/// <summary>
/// Realiza a vinculação dos dados com o modelo.
/// </summary>
/// <param name="controllerContext"></param>
/// <param name="bindingContext"></param>
/// <returns></returns>
public override object BindModel(System.Web.Mvc.ControllerContext controllerContext, System.Web.Mvc.ModelBindingContext bindingContext)
{
System.Runtime.CompilerServices.RuntimeHelpers.EnsureSufficientExecutionStack();
if (bindingContext == null)
{
throw new ArgumentNullException("bindingContext");
}
if (!string.IsNullOrEmpty(bindingContext.ModelName) && !bindingContext.ValueProvider.ContainsPrefix(bindingContext.ModelName))
{
if (!bindingContext.FallbackToEmptyPrefix)
{
return(null);
}
var context = new System.Web.Mvc.ModelBindingContext {
ModelMetadata = bindingContext.ModelMetadata,
ModelState = bindingContext.ModelState,
PropertyFilter = bindingContext.PropertyFilter,
ValueProvider = bindingContext.ValueProvider
};
if (bindingContext.ModelMetadata.AdditionalValues.ContainsKey(EntityModelMetadataProvider.ClearPropertyNamesKey))
{
context.ModelMetadata.AdditionalValues.Add(EntityModelMetadataProvider.ClearPropertyNamesKey, bindingContext.ModelMetadata.AdditionalValues[EntityModelMetadataProvider.ClearPropertyNamesKey]);
}
bindingContext = context;
}
if (!bindingContext.ModelMetadata.IsComplexType)
{
return(null);
}
return(this.BindComplexModel(controllerContext, bindingContext));
}
/// <summary>
/// Main process of model binding
/// </summary>
/// <param name="controllerContext"></param>
/// <param name="bindingContext"></param>
/// <returns></returns>
public object BindModel(System.Web.Mvc.ControllerContext controllerContext, System.Web.Mvc.ModelBindingContext bindingContext)
{
var model = new DataTablesParam();
if (bindingContext.ModelType == typeof(DataTablesParam))
{
var provider = bindingContext.ValueProvider;
//var controller = controllerContext.HttpContext;
if (provider.GetValue("iDisplayStart") != null)
{
model.iDisplayStart = provider.GetValue("iDisplayStart").AttemptedValue.To <int>();
}
if (provider.GetValue("iDisplayLength") != null)
{
model.iDisplayLength = provider.GetValue("iDisplayLength").AttemptedValue.To <int>();
}
if (provider.GetValue("sSearch") != null)
{
model.sSearch = provider.GetValue("sSearch").AttemptedValue.To <string>();
}
if (provider.GetValue("iColumns") != null)
{
model.iColumns = provider.GetValue("iColumns").AttemptedValue.To <int>();
}
string index = "";
if (provider.GetValue("iSortingCols") != null)
{
model.iSortingCols = provider.GetValue("iSortingCols").AttemptedValue.To <int>();
model.iSortCols = model.iSortCols ?? new Dictionary <int, SortOrder>();
for (int i = 0; i < model.iSortingCols; i++)
{
index = i.ToString();
if (provider.GetValue("bSortable_" + index) != null &&
provider.GetValue("bSortable_" + index).AttemptedValue.To <bool>() &&
provider.GetValue("iSortCol_" + index) != null &&
provider.GetValue("iSortDir_" + index) != null)
{
int key = provider.GetValue("iSortCol_" + index).AttemptedValue.To <int>();
SortOrder sortOrder = provider.GetValue("iSortDir_" + index).AttemptedValue.To <string>().Trim().ToLower() == "desc" ? SortOrder.Desc : SortOrder.Asc;
model.iSortCols[key] = sortOrder;
}
}
}
model.sSearchs = model.sSearchs ?? new Dictionary <int, string>();
for (int i = 0; i < model.iColumns; i++)
{
index = i.ToString();
if (provider.GetValue("bSearchable_" + index) != null &&
provider.GetValue("bSearchable_" + index).AttemptedValue.To <bool>() &&
provider.GetValue("sSearch_" + index) != null)
{
model.sSearchs[i] = provider.GetValue("sSearch_" + index).AttemptedValue.To <string>();
}
}
}
return(model);
}
public object BindModel(ControllerContext controllerContext, System.Web.Mvc.ModelBindingContext bindingContext)
{
// use Json.NET to deserialize the incoming Position
controllerContext.HttpContext.Request.InputStream.Position = 0; // see: https://stackoverflow.com/a/3468653/331281
Stream stream = controllerContext.RequestContext.HttpContext.Request.InputStream;
var readStream = new StreamReader(stream, Encoding.UTF8);
string json = readStream.ReadToEnd();
return(JsonConvert.DeserializeObject <Site>(json, new JsonBuildBlockConverter()));
}
/// <summary>
/// MVC version
/// </summary>
/// <param name="controllerContext"></param>
/// <param name="bindingContext"></param>
/// <returns></returns>
public object BindModel(System.Web.Mvc.ControllerContext controllerContext,
System.Web.Mvc.ModelBindingContext bindingContext)
{
var info = new Models.EnvironmentInfo();
info.RequestedUrl = controllerContext.RequestContext.HttpContext.Request.Url.ToString();
info.UserId = GetLoggedUser();
// you also can get form/request properties
return(info);
}
public object BindModel(ControllerContext controllerContext, System.Web.Mvc.ModelBindingContext bindingContext)
{
HttpRequestBase request = controllerContext.HttpContext.Request;
var retVal = new SortDirection();
foreach (var prop in currType.GetProperties())
{
string dir = request.Form.Get(string.Format("sort[{0}]", prop.Name));
if (!string.IsNullOrEmpty(dir))
{
retVal.prop = prop.Name;
retVal.direction = dir;
}
}
return(retVal);
}
/// <summary>
/// Recupera os indices
/// </summary>
/// <param name="bindingContext"></param>
/// <param name="stopOnIndexNotFound"></param>
/// <param name="indexes"></param>
private static void GetIndexes(System.Web.Mvc.ModelBindingContext bindingContext, out bool stopOnIndexNotFound, out IEnumerable <string> indexes)
{
string key = CreateSubPropertyName(bindingContext.ModelName, "index");
var result = bindingContext.ValueProvider.GetValue(key);
if (result != null)
{
string[] strArray = result.ConvertTo(typeof(string[])) as string[];
if (strArray != null)
{
stopOnIndexNotFound = false;
indexes = strArray;
return;
}
}
stopOnIndexNotFound = true;
indexes = GetZeroBasedIndexes();
}
public object BindModel(System.Web.Mvc.ControllerContext controllerContext, System.Web.Mvc.ModelBindingContext bindingContext)
{
string key = bindingContext.ModelName;
ValueProviderResult val = bindingContext.ValueProvider.GetValue(key);
if (val != null)
{
var s = val.AttemptedValue as string;
if (s != null && (s.IsEmpty() || s.Trim().IsEmpty()))
{
return(null);
}
return(val.AttemptedValue);
}
return(null);
}
public object BindModel(System.Web.Mvc.ControllerContext controllerContext,
System.Web.Mvc.ModelBindingContext bindingContext)
{
var valueProvider = bindingContext.ValueProvider;
Message mes = new Message();
mes.Text = (string)valueProvider.GetValue("Text").ConvertTo(typeof(string));
try
{
mes.TimesToShow = (int)valueProvider.GetValue("TimesToShow").ConvertTo(typeof(int));
}
catch
{
mes.TimesToShow = null;
}
mes.Minutes = (int)valueProvider.GetValue("Minutes").ConvertTo(typeof(int));
return(mes);
}
public override object BindModel(System.Web.Mvc.ControllerContext controllerContext, System.Web.Mvc.ModelBindingContext bindingContext)
{
var bindModel = base.BindModel(controllerContext, bindingContext);
var commentingSettings = bindModel as CommentingSettings;
if (commentingSettings == null)
{
return(bindModel);
}
var types = new List <Type>();
foreach (var source in controllerContext.HttpContext.Request.Params.AllKeys.Where(s => s.StartsWith(PageType)))
{
var value = controllerContext.HttpContext.Request[source];
if (value.Contains("true"))
{
types.Add(TypeHelper.GetTypeByName(source.Replace(PageType, string.Empty)));
}
}
commentingSettings.SetAllowedPageTypes(types.ToArray());
return(commentingSettings);
}
protected override object CreateModel(System.Web.Mvc.ControllerContext controllerContext, System.Web.Mvc.ModelBindingContext bindingContext, Type modelType)
{
return(Kernel.Get <CommentingSettings>());
}
public override object BindModel(System.Web.Mvc.ControllerContext controllerContext, System.Web.Mvc.ModelBindingContext bindingContext)
{
var valueProviderResult = bindingContext.ValueProvider.GetValue(bindingContext.ModelName);
if (!string.IsNullOrEmpty(valueProviderResult.AttemptedValue))
{
var items = valueProviderResult.AttemptedValue.Split(',');
var result = new int[items.Length];
for (var counter = 0; counter < items.Length; counter++)
{
var intVal = int.Parse(items[counter]);
}
return(result);
}
return(base.BindModel(controllerContext, bindingContext));
}
public override object BindModel(System.Web.Mvc.ControllerContext controllerContext, System.Web.Mvc.ModelBindingContext bindingContext)
{
return(base.Bind(controllerContext, bindingContext, typeof(SearchDataTablesRequest)));
}
/// <summary>
/// Cria um contexto de vinculação para um elemento complexo do model.
/// </summary>
/// <param name="controllerContext"></param>
/// <param name="bindingContext"></param>
/// <param name="model"></param>
/// <returns></returns>
private System.Web.Mvc.ModelBindingContext CreateComplexElementalModelBindingContext(System.Web.Mvc.ControllerContext controllerContext, System.Web.Mvc.ModelBindingContext bindingContext, object model)
{
var bindAttr = (System.Web.Mvc.BindAttribute) this.GetTypeDescriptor(controllerContext, bindingContext).GetAttributes()[typeof(System.Web.Mvc.BindAttribute)];
Predicate <string> predicate = (bindAttr != null) ? propertyName => (bindAttr.IsPropertyAllowed(propertyName) && bindingContext.PropertyFilter(propertyName)) : bindingContext.PropertyFilter;
return(new System.Web.Mvc.ModelBindingContext {
ModelMetadata = System.Web.Mvc.ModelMetadataProviders.Current.GetMetadataForType(() => model, bindingContext.ModelType),
ModelName = bindingContext.ModelName,
ModelState = bindingContext.ModelState,
PropertyFilter = predicate,
ValueProvider = bindingContext.ValueProvider
});
}
public object BindModel(System.Web.Mvc.ControllerContext controllerContext, System.Web.Mvc.ModelBindingContext bindingContext)
{
this.bindingContext = bindingContext;
return(this.Bind());
}
/// <summary>
/// Verifica se pode realizar a validação na requisição.
/// </summary>
/// <param name="controllerContext"></param>
/// <param name="bindingContext"></param>
/// <returns></returns>
private static bool ShouldPerformRequestValidation(System.Web.Mvc.ControllerContext controllerContext, System.Web.Mvc.ModelBindingContext bindingContext)
{
return((((controllerContext == null) || (controllerContext.Controller == null)) || ((bindingContext == null) || (bindingContext.ModelMetadata == null))) || (controllerContext.Controller.ValidateRequest && bindingContext.ModelMetadata.RequestValidationEnabled));
}
public override object BindModel(System.Web.Mvc.ControllerContext controllerContext, System.Web.Mvc.ModelBindingContext bindingContext)
{
System.Collections.Specialized.NameValueCollection nameValueCollection = controllerContext.HttpContext.Request.Form;
System.Collections.Generic.IEnumerable <string> keys = nameValueCollection.AllKeys.Where(s => s.StartsWith("acl-"));
return(keys.Select(s =>
{
string[] substring = s.Substring(4).Split('-');
return new ACLUpdateRecord
{
Role = substring[0],
Key = substring[1],
Allowed = nameValueCollection[s].Contains("true")
};
}).ToList());
}
public override object BindModel(System.Web.Mvc.ControllerContext controllerContext, System.Web.Mvc.ModelBindingContext bindingContext)
{
ProductReviewOperation currentOperation;
if (controllerContext.HttpContext.Request.Form["Approve"] != null)
{
currentOperation = ProductReviewOperation.Approve;
}
else if (controllerContext.HttpContext.Request.Form["Reject"] != null)
{
currentOperation = ProductReviewOperation.Reject;
}
else if (controllerContext.HttpContext.Request.Form["Delete"] != null)
{
currentOperation = ProductReviewOperation.Delete;
}
else
{
return(new ReviewUpdateModel());
}
var nameValueCollection = controllerContext.HttpContext.Request.Form;
var keys = nameValueCollection.AllKeys.Where(s => s.StartsWith("review-"));
var reviewUpdateModel = new ReviewUpdateModel
{
CurrentOperation = currentOperation,
Reviews = new List <ProductReview>()
};
foreach (var key in keys)
{
var substring = key.Substring(7);
int id;
if (Int32.TryParse(substring, out id) && nameValueCollection[key].Contains("true"))
{
var review = Session.Get <ProductReview>(id);
if (review != null)
{
reviewUpdateModel.Reviews.Add(review);
}
}
}
return(reviewUpdateModel);
}
public override bool BindProperty(System.Web.Mvc.ControllerContext controllerContext, System.Web.Mvc.ModelBindingContext bindingContext, System.ComponentModel.PropertyDescriptor propertyDescriptor)
{
return(false);
}
/// <summary>
/// Cria a model que será usada na vinculação.
/// </summary>
/// <param name="controllerContext"></param>
/// <param name="bindingContext"></param>
/// <param name="modelType"></param>
/// <returns></returns>
protected override object CreateModel(System.Web.Mvc.ControllerContext controllerContext, System.Web.Mvc.ModelBindingContext bindingContext, Type modelType)
{
var getMethodName = _getMethodName ?? string.Format("Get{0}", modelType.Name);
var methods = _flowType.GetMethods(System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Static);
var getMethods = methods.Where(f => f.Name == getMethodName).ToArray();
var loader = EntityTypeManager.GetLoader(modelType);
System.Reflection.MethodInfo getMethod = null;
if (getMethods.Length == 1)
{
getMethod = getMethods[0];
}
else if (loader.HasUid)
{
foreach (var method in getMethods)
{
var methodParameters = method.GetParameters();
if (methodParameters.Length == 1 && methodParameters[0].ParameterType == typeof(int))
{
getMethod = method;
break;
}
}
}
if (getMethod == null)
{
throw new InvalidOperationException(ResourceMessageFormatter.Create(() => Properties.Resources.EntityBinder_GetMethodNotFound, getMethodName, _flowType.FullName).Format());
}
var descriptor = GetTypeDescriptor(controllerContext, bindingContext);
var record = GetRecordOfKey(controllerContext, bindingContext, modelType);
var flow = GetFlowInstance();
if (loader.HasUid && record.GetInt32(loader.UidPropertyName) <= 0)
{
return(CreateEntity(flow, modelType));
}
object[] parameters = null;
if (record.Descriptor.Count == 1)
{
parameters = new object[] {
record.GetInt32(0)
}
}
;
else
{
var methodParameters = getMethod.GetParameters();
parameters = new object[methodParameters.Length];
for (var i = 0; i < parameters.Length; i++)
{
var key = record.Descriptor.FirstOrDefault(f => StringComparer.InvariantCultureIgnoreCase.Equals(f.Name, methodParameters[i].Name));
if (key == null && methodParameters[i].Name == "id" && loader.HasUid)
{
key = record.Descriptor.FirstOrDefault(f => StringComparer.InvariantCultureIgnoreCase.Equals(f.Name, loader.UidPropertyName));
}
if (key != null)
{
parameters[i] = Colosoft.Reflection.TypeConverter.Get(methodParameters[i].ParameterType, record.GetValue(key.Name));
}
;
}
}
Business.IEntity entity = null;
try
{
entity = (Business.IEntity)getMethod.Invoke(flow, parameters);
}
catch (System.Reflection.TargetInvocationException ex)
{
throw ex.InnerException;
}
if (entity == null)
{
entity = CreateEntity(flow, modelType);
}
if (entity.Uid == 0)
{
entity.Uid = entity.TypeManager.GenerateInstanceUid(modelType);
}
return(entity);
}
/// <summary>
/// Vincula as propriedades.
/// </summary>
/// <param name="controllerContext"></param>
/// <param name="bindingContext"></param>
private void BindProperties(System.Web.Mvc.ControllerContext controllerContext, System.Web.Mvc.ModelBindingContext bindingContext)
{
var modelProperties = this.GetModelProperties(controllerContext, bindingContext);
Predicate <string> propertyFilter = bindingContext.PropertyFilter;
for (int i = 0; i < modelProperties.Count; i++)
{
var property = modelProperties[i];
if (ShouldUpdateProperty(property, propertyFilter))
{
this.BindProperty(controllerContext, bindingContext, property);
}
}
}
/// <summary>
/// Vincula um elemento complexo para a model.
/// </summary>
/// <param name="controllerContext"></param>
/// <param name="bindingContext"></param>
/// <param name="model"></param>
private void BindComplexElementalModel(System.Web.Mvc.ControllerContext controllerContext, System.Web.Mvc.ModelBindingContext bindingContext, object model)
{
var context = this.CreateComplexElementalModelBindingContext(controllerContext, bindingContext, model);
if (this.OnModelUpdating(controllerContext, context))
{
this.BindProperties(controllerContext, context);
this.OnModelUpdated(controllerContext, context);
}
}
/// <summary>
/// Cria uma instancia da modelo para realizar a vinculação dos dados.
/// </summary>
/// <param name="controllerContext"></param>
/// <param name="bindingContext"></param>
/// <param name="modelType"></param>
/// <returns></returns>
protected override object CreateModel(System.Web.Mvc.ControllerContext controllerContext, System.Web.Mvc.ModelBindingContext bindingContext, Type modelType)
{
var entity = CreateEntity(modelType);
if (entity.Uid == 0)
{
entity.Uid = entity.TypeManager.GenerateInstanceUid(modelType);
}
return(entity);
}
/// <summary>
/// Realiza a vinculação dos dados.
/// </summary>
/// <param name="controllerContext"></param>
/// <param name="bindingContext"></param>
/// <returns></returns>
public override object BindModel(System.Web.Mvc.ControllerContext controllerContext, System.Web.Mvc.ModelBindingContext bindingContext)
{
var properties = controllerContext.Controller.ViewData.ContainsKey(EntityModelMetadataProvider.ClearPropertyNamesKey) ? controllerContext.Controller.ViewData[EntityModelMetadataProvider.ClearPropertyNamesKey] as IEnumerable <string> : null;
if (properties == null)
{
controllerContext.Controller.ViewData.Add(EntityModelMetadataProvider.ClearPropertyNamesKey, _clearPropertyNames);
}
else
{
controllerContext.Controller.ViewData[EntityModelMetadataProvider.ClearPropertyNamesKey] = properties.Concat(_clearPropertyNames);
}
var entity = (Colosoft.Business.IEntity)base.BindModel(controllerContext, bindingContext);
if (entity != null && entity.Uid == 0)
{
entity.Uid = entity.TypeManager.GenerateInstanceUid(entity.GetType());
}
return(entity);
}
public override string[] BindModel(System.Web.Mvc.ControllerContext controllerContext, System.Web.Mvc.ModelBindingContext bindingContext)
{
return(bindingContext.ValueProvider.GetValue(bindingContext.ModelName).AttemptedValue.Split(
new[] { ',' },
StringSplitOptions.RemoveEmptyEntries));
}
// Override the default BindModel called by ASP.NET and make it call Bind passing the type of your
// implementation of IDataTablesRequest:
public override object BindModel(System.Web.Mvc.ControllerContext controllerContext, System.Web.Mvc.ModelBindingContext bindingContext)
{
return(Bind(controllerContext, bindingContext, typeof(TransactionSearchRequest)));
}
/// <summary>
/// Realiza a vinculação com a model complexa
/// </summary>
/// <param name="controllerContext"></param>
/// <param name="bindingContext"></param>
/// <returns></returns>
private object BindComplexModel(System.Web.Mvc.ControllerContext controllerContext, System.Web.Mvc.ModelBindingContext bindingContext)
{
Func <object> func2 = null;
object model = bindingContext.ModelMetadata.Model;
Type modelType = bindingContext.ModelType;
if ((model == null) && modelType.IsArray)
{
var elementType = modelType.GetElementType();
var type3 = typeof(List <>).MakeGenericType(new Type[] {
elementType
});
object collection = this.CreateModel(controllerContext, bindingContext, type3);
var context = new System.Web.Mvc.ModelBindingContext {
ModelMetadata = System.Web.Mvc.ModelMetadataProviders.Current.GetMetadataForType(() => collection, type3),
ModelName = bindingContext.ModelName,
ModelState = bindingContext.ModelState,
PropertyFilter = bindingContext.PropertyFilter,
ValueProvider = bindingContext.ValueProvider
};
if (bindingContext.ModelMetadata.AdditionalValues.ContainsKey(EntityModelMetadataProvider.ClearPropertyNamesKey))
{
context.ModelMetadata.AdditionalValues.Add(EntityModelMetadataProvider.ClearPropertyNamesKey, bindingContext.ModelMetadata.AdditionalValues[EntityModelMetadataProvider.ClearPropertyNamesKey]);
}
var list = (System.Collections.IList) this.UpdateCollection(controllerContext, context, elementType);
if (list == null)
{
return(null);
}
var array = Array.CreateInstance(elementType, list.Count);
list.CopyTo(array, 0);
return(array);
}
if (model == null)
{
model = this.CreateModel(controllerContext, bindingContext, modelType);
}
var type7 = TypeHelpers.ExtractGenericInterface(modelType, typeof(IEnumerable <>));
if (type7 != null)
{
Type type8 = type7.GetGenericArguments()[0];
if (typeof(ICollection <>).MakeGenericType(new Type[] {
type8
}).IsInstanceOfType(model))
{
var context6 = new System.Web.Mvc.ModelBindingContext();
if (func2 == null)
{
func2 = () => model;
}
context6.ModelMetadata = System.Web.Mvc.ModelMetadataProviders.Current.GetMetadataForType(func2, modelType);
context6.ModelName = bindingContext.ModelName;
context6.ModelState = bindingContext.ModelState;
context6.PropertyFilter = bindingContext.PropertyFilter;
context6.ValueProvider = bindingContext.ValueProvider;
if (bindingContext.ModelMetadata.AdditionalValues.ContainsKey(EntityModelMetadataProvider.ClearPropertyNamesKey))
{
context6.ModelMetadata.AdditionalValues.Add(EntityModelMetadataProvider.ClearPropertyNamesKey, bindingContext.ModelMetadata.AdditionalValues[EntityModelMetadataProvider.ClearPropertyNamesKey]);
}
var context5 = context6;
return(this.UpdateCollection(controllerContext, context5, type8));
}
}
this.BindComplexElementalModel(controllerContext, bindingContext, model);
return(model);
}
protected override object CreateModel(System.Web.Mvc.ControllerContext controllerContext, System.Web.Mvc.ModelBindingContext bindingContext, Type modelType)
{
return(base.CreateModel(controllerContext, bindingContext, modelType));
}
/// <summary>
/// Atualiza a coleção.
/// </summary>
/// <param name="controllerContext"></param>
/// <param name="bindingContext"></param>
/// <param name="elementType">Tipo do elemento da coleção.</param>
/// <returns></returns>
public object UpdateCollection(System.Web.Mvc.ControllerContext controllerContext, System.Web.Mvc.ModelBindingContext bindingContext, Type elementType)
{
bool flag;
IEnumerable <string> enumerable;
GetIndexes(bindingContext, out flag, out enumerable);
var binder = this.Binders.GetBinder(elementType);
var newContents = new List <Colosoft.Business.IEntity>();
var entityList = (System.Collections.IList)bindingContext.Model;
foreach (string str in enumerable)
{
string prefix = CreateSubIndexName(bindingContext.ModelName, str);
if (!bindingContext.ValueProvider.ContainsPrefix(prefix))
{
if (!flag)
{
continue;
}
break;
}
var context = new System.Web.Mvc.ModelBindingContext {
ModelMetadata = System.Web.Mvc.ModelMetadataProviders.Current.GetMetadataForType(null, elementType),
ModelName = prefix,
ModelState = bindingContext.ModelState,
PropertyFilter = bindingContext.PropertyFilter,
ValueProvider = bindingContext.ValueProvider
};
if (bindingContext.ModelMetadata.AdditionalValues.ContainsKey(EntityModelMetadataProvider.ClearPropertyNamesKey))
{
context.ModelMetadata.AdditionalValues.Add(EntityModelMetadataProvider.ClearPropertyNamesKey, bindingContext.ModelMetadata.AdditionalValues[EntityModelMetadataProvider.ClearPropertyNamesKey]);
}
var entityFound = false;
if (binder is EntityModelBinderBase)
{
var entityBinder = (EntityModelBinderBase)binder;
var recordKey = entityBinder.GetRecordKey(controllerContext, context, elementType);
foreach (Colosoft.Business.IEntity i in entityList)
{
if (i.Equals(recordKey, Query.RecordKeyComparisonType.Key))
{
entityFound = true;
context.ModelMetadata.Model = i;
break;
}
}
}
var entity = (Colosoft.Business.IEntity)binder.BindModel(controllerContext, context);
AddValueRequiredMessageToModelState(controllerContext, bindingContext.ModelState, prefix, elementType, entity);
if (!entityFound)
{
entityList.Add(entity);
}
newContents.Add(entity);
}
for (var i = 0; i < entityList.Count; i++)
{
if (!newContents.Contains(entityList[i]))
{
var count = entityList.Count;
entityList.RemoveAt(i);
if (entityList.Count < count)
{
i--;
}
}
}
return(entityList);
}
public override object BindModel(System.Web.Mvc.ControllerContext controllerContext, System.Web.Mvc.ModelBindingContext bindingContext)
{
var model = base.BindModel(controllerContext, bindingContext);
var f = (QtrReportinServiceTypePctFilter)model;
var From = ParseQtr(bindingContext.ValueProvider.GetValue("QtrReportingServiceTypePctFilter.From").AttemptedValue);
if (From != null)
{
f.FromQuarter = From.Item1;
f.FromYear = From.Item2;
}
var To = ParseQtr(bindingContext.ValueProvider.GetValue("QtrReportingServiceTypePctFilter.To").AttemptedValue);
if (To != null)
{
f.ToQuarter = To.Item1;
f.ToYear = To.Item2;
}
return(model);
}