Textbox rejecting ##,00 format - html

Question

I have a MVC project where I am displaying currency amounts in different formats based on the currency of the object.
My project handles the ##.00 format just find, but I have some objects that are using Euros for example that need to be in the ##,00 format instead of ##.00.
Then the page loads in read only mode both formats display correctly, but then the form is edited, it initially shows the currencies correctly, but if I click out of a Euro formatted amount, it drops the "," out of the amount (for example 1000,00 changes to 100000).
In the model, the fields are of DataType = Currency and are decimals. Also, if 1000,00 is tried to save, it is returned as invalid.
How to I get the textbox to handle the both currency formats?
This is my code
#model Projections.Web.ViewModels.Projections.ProjectionFormView
#Html.HiddenFor(model => model.Number)
#Html.HiddenFor(model => model.Department)
#* -- Quarters -- *#
<div class="edit-fields">
<div class="control-group">
#Html.LabelFor(model => model.Q12017, new {#class = "control-label"})
<div class="controls">
#Html.EditorFor(model => model.Q12017)
</div>
</div>
<div class="control-group">
#Html.LabelFor(model => model.Q22017, new {#class = "control-label"})
<div class="controls">
#Html.EditorFor(model => model.Q22017)
</div>
</div>
<div class="control-group">
#Html.LabelFor(model => model.Q32017, new {#class = "control-label"})
<div class="controls">
#Html.EditorFor(model => model.Q32017)
</div>
</div>
<div class="control-group">
#Html.LabelFor(model => model.Q42017, new { #class = "control-label" })
<div class="controls">
#Html.EditorFor(model => model.Q42017)
</div>
</div>
<div class="control-group">
#Html.LabelFor(model => model.Q12018, new { #class = "control-label" })
<div class="controls">
#Html.EditorFor(model => model.Q12018)
</div>
</div>
</div>
Controller:
public ActionResult Edit(string number, string department)
{
// Get the project we're trying to edit a projection for.
var projects = _db.Projects.FindBy(
x => x.Number == number &&
x.PMUsername == SessionWrapper.CurrentManager,
null,
"Projection").ToList();
if (!projects.Any())
{
return Error(
Notices.ProjectNotFoundTitle,
string.Format(Notices.ProjectNotFound, number)
);
}
var project = projects.SingleOrDefault(x => x.Department == department);
var baseProject = projects.SingleOrDefault(x => x.Department == string.Empty);
// Project doesn't exist, error time!
if (project == null || baseProject == null)
{
return Error(
Notices.DepartmentNotFoundTitle,
string.Format(Notices.DepartmentNotFound, department, number)
);
}
project.Projection = project.Projection ?? new Projection { Number = number, Department = department, Project = project };
SetProjectCulture(project.ProjectCurrencyCode);
var projection = Mapper.Map<ProjectionFormView>(project.Projection);
projection.BaseProjectName = baseProject.Name;
return View(projection);
}
private void SetProjectCulture(string currencyCode)
{
var uiHelper = DependencyResolver.Current.GetService<IThreadUIHelper>();
if (!uiHelper.SetUICulture(currencyCode)) return;
var notice = new Notification(string.Format(Notices.ProjectCurrencyNotice, currencyCode));
NotificationHandler.AddNotification(notice);
}
Model
using System;
using System.ComponentModel;
using System.ComponentModel.DataAnnotations;
using System.Linq;
namespace Projections.Web.ViewModels.Projections
{
public class Forecast : INotifyPropertyChanged
{
private decimal _q12017;
private decimal _q22017;
private decimal _q32017;
private decimal _q42017;
private decimal _q12018;
[DataType(DataType.Currency)]
public decimal Q12017
{
get { return _q12017; }
set { _q12017 = value; ForecastChanged("Q12017"); }
}
[DataType(DataType.Currency)]
public decimal Q22017
{
get { return _q22017; }
set { _q22017 = value; ForecastChanged("Q22017"); }
}
[DataType(DataType.Currency)]
public decimal Q32017
{
get { return _q32017; }
set { _q32017 = value; ForecastChanged("Q32017"); }
}
[DataType(DataType.Currency)]
public decimal Q42017
{
get { return _q42017; }
set { _q42017 = value; ForecastChanged("Q42017"); }
}
[DataType(DataType.Currency)]
public decimal Q12018
{
get { return _q12018; }
set { _q12018 = value; ForecastChanged("Q12018"); }
}
public decimal Total
{
get
{
var quarters = GetType().GetProperties().Where(x => x.Name.StartsWith("Q")).ToList();
return quarters.Sum(q => (decimal?)q.GetValue(this, null) ?? default(decimal));
}
}
public DateTime? Modified { get; set; }
public event PropertyChangedEventHandler PropertyChanged;
protected virtual void ForecastChanged(string name)
{
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(name));
}
public decimal? this[string name]
{
get
{
var property = GetType().GetProperty(name);
if (property == null) throw new InvalidOperationException("Invalid property specified.");
if (property.PropertyType == typeof(decimal))
{
return property.GetValue(this, null) as decimal?;
}
throw new InvalidOperationException("Invalid property specified.");
}
}
}
}

Answer 1

The default model binder will only handle decimals with a U.S.-style decimal point (.). If you need to accept a comma, you need a custom model binder. I use the following, which I found original here.
public class DecimalModelBinder : IModelBinder {
public object BindModel(ControllerContext controllerContext,
ModelBindingContext bindingContext) {
ValueProviderResult valueResult = bindingContext.ValueProvider
.GetValue(bindingContext.ModelName);
ModelState modelState = new ModelState { Value = valueResult };
object actualValue = null;
try {
actualValue = Convert.ToDecimal(valueResult.AttemptedValue,
CultureInfo.CurrentCulture);
}
catch (FormatException e) {
modelState.Errors.Add(e);
}
bindingContext.ModelState.Add(bindingContext.ModelName, modelState);
return actualValue;
}
}
Then, register it in Application_Start in Global.asax:
ModelBinders.Binders.Add(typeof(decimal), new DecimalModelBinder());
You may need to alter the model binder to your specific usage scenario. This version simply converts based on the current culture, but you may need to do some different type of processing here if you're going to be handling both periods and commas as "decimal points".