public void Validate(ModelBindingExecutionContext modelBindingExecutionContext, ModelValidationNode parentNode) { if (modelBindingExecutionContext == null) { throw new ArgumentNullException("modelBindingExecutionContext"); } if (SuppressValidation) { // no-op return; } // pre-validation steps ModelValidatingEventArgs eValidating = new ModelValidatingEventArgs(modelBindingExecutionContext, parentNode); OnValidating(eValidating); if (eValidating.Cancel) { return; } ValidateChildren(modelBindingExecutionContext); ValidateThis(modelBindingExecutionContext, parentNode); // post-validation steps ModelValidatedEventArgs eValidated = new ModelValidatedEventArgs(modelBindingExecutionContext, parentNode); OnValidated(eValidated); }
public override IModelBinder GetBinder(ModelBindingExecutionContext modelBindingExecutionContext, ModelBindingContext bindingContext) { return((from provider in _providers let binder = provider.GetBinder(modelBindingExecutionContext, bindingContext) where binder != null select binder).FirstOrDefault()); }
public override IValueProvider GetValueProvider(ModelBindingExecutionContext modelBindingExecutionContext) { if (modelBindingExecutionContext == null) { throw new ArgumentNullException("modelBindingExecutionContext"); } HttpSessionStateBase session = modelBindingExecutionContext.HttpContext.Session; if (session == null) { // session is disabled return(null); } Dictionary <string, object> backingStore = new Dictionary <string, object>(StringComparer.OrdinalIgnoreCase); foreach (string key in session) { if (key != null) { backingStore[key] = session[key]; // copy to backing store } } // use the invariant culture since Session contains serialized objects return(new DictionaryValueProvider <object>(backingStore, CultureInfo.InvariantCulture)); }
public bool BindModel(ModelBindingExecutionContext modelBindingExecutionContext, ModelBindingContext bindingContext) { ModelBinderUtil.ValidateBindingContext(bindingContext); ValueProviderResult vpResult = bindingContext.UnvalidatedValueProvider.GetValue(bindingContext.ModelName); // case 1: there was no <input ... /> element containing this data if (vpResult == null) { return(false); } string base64string = (string)vpResult.ConvertTo(typeof(string)); // case 2: there was an <input ... /> element but it was left blank if (String.IsNullOrEmpty(base64string)) { return(false); } // Future proofing. If the byte array is actually an instance of System.Data.Linq.Binary // then we need to remove these quotes put in place by the ToString() method. string realValue = base64string.Replace("\"", String.Empty); try { bindingContext.Model = ConvertByteArray(Convert.FromBase64String(realValue)); return(true); } catch { // corrupt data - just ignore return(false); } }
protected virtual void EnsureModel(ModelBindingExecutionContext modelBindingExecutionContext, ModelBindingContext bindingContext) { if (bindingContext.Model == null) { bindingContext.ModelMetadata.Model = CreateModel(modelBindingExecutionContext, bindingContext); } }
private void ValidateProperties(ModelBindingExecutionContext modelBindingExecutionContext) { // Based off CompositeModelValidator. ModelStateDictionary modelState = modelBindingExecutionContext.ModelState; // DevDiv Bugs #227802 - Caching problem in ModelMetadata requires us to manually regenerate // the ModelMetadata. object model = ModelMetadata.Model; ModelMetadata updatedMetadata = ModelMetadataProviders.Current.GetMetadataForType(() => model, ModelMetadata.ModelType); foreach (ModelMetadata propertyMetadata in updatedMetadata.Properties) { // Only want to add errors to ModelState if something doesn't already exist for the property node, // else we could end up with duplicate or irrelevant error messages. string propertyKeyRoot = ModelBinderUtil.CreatePropertyModelName(ModelStateKey, propertyMetadata.PropertyName); if (modelState.IsValidField(propertyKeyRoot)) { foreach (ModelValidator propertyValidator in propertyMetadata.GetValidators(modelBindingExecutionContext)) { foreach (ModelValidationResult propertyResult in propertyValidator.Validate(model)) { string thisErrorKey = ModelBinderUtil.CreatePropertyModelName(propertyKeyRoot, propertyResult.MemberName); modelState.AddModelError(thisErrorKey, propertyResult.Message); } } } } }
public override IModelBinder GetBinder(ModelBindingExecutionContext modelBindingExecutionContext, ModelBindingContext bindingContext) { ModelBinderUtil.ValidateBindingContext(bindingContext); Type[] typeArguments = null; if (ModelType.IsInterface) { Type matchingClosedInterface = TypeHelpers.ExtractGenericInterface(bindingContext.ModelType, ModelType); if (matchingClosedInterface != null) { typeArguments = matchingClosedInterface.GetGenericArguments(); } } else { typeArguments = TypeHelpers.GetTypeArgumentsIfMatch(bindingContext.ModelType, ModelType); } if (typeArguments != null) { if (SuppressPrefixCheck || bindingContext.UnvalidatedValueProvider.ContainsPrefix(bindingContext.ModelName)) { return(_modelBinderFactory(typeArguments)); } } return(null); }
public bool BindModel(ModelBindingExecutionContext modelBindingExecutionContext, ModelBindingContext bindingContext) { ModelBindingContext newBindingContext = bindingContext; IModelBinder binder = Providers.GetBinder(modelBindingExecutionContext, bindingContext); if (binder == null && !String.IsNullOrEmpty(bindingContext.ModelName) && bindingContext.ModelMetadata.IsComplexType) { // fallback to empty prefix? newBindingContext = new ModelBindingContext(bindingContext) { ModelName = String.Empty, ModelMetadata = bindingContext.ModelMetadata }; binder = Providers.GetBinder(modelBindingExecutionContext, newBindingContext); } if (binder != null) { bool boundSuccessfully = binder.BindModel(modelBindingExecutionContext, newBindingContext); if (boundSuccessfully) { // run validation newBindingContext.ValidationNode.Validate(modelBindingExecutionContext, parentNode: null); return(true); } } return(false); // something went wrong }
private static string GetUserResourceString(ModelBindingExecutionContext modelBindingExecutionContext, string resourceName) { #if UNDEF return(GetUserResourceString(modelBindingExecutionContext, resourceName, DefaultModelBinder.ResourceClassKey)); #endif return(GetUserResourceString(modelBindingExecutionContext, resourceName, String.Empty)); }
internal void ProcessComplexModel(ModelBindingExecutionContext modelBindingExecutionContext, ModelBindingContext bindingContext, ComplexModel complexModel) { HashSet <string> requiredProperties; HashSet <string> skipProperties; GetRequiredPropertiesCollection(bindingContext.ModelType, out requiredProperties, out skipProperties); // Are all of the required fields accounted for? HashSet <string> missingRequiredProperties = new HashSet <string>(requiredProperties); missingRequiredProperties.ExceptWith(complexModel.Results.Select(r => r.Key.PropertyName)); string missingPropertyName = missingRequiredProperties.FirstOrDefault(); if (missingPropertyName != null) { string fullPropertyKey = ModelBinderUtil.CreatePropertyModelName(bindingContext.ModelName, missingPropertyName); throw Error.BindingBehavior_ValueNotFound(fullPropertyKey); } // for each property that was bound, call the setter, recording exceptions as necessary foreach (var entry in complexModel.Results) { ModelMetadata propertyMetadata = entry.Key; ComplexModelResult complexModelResult = entry.Value; if (complexModelResult != null) { SetProperty(modelBindingExecutionContext, bindingContext, propertyMetadata, complexModelResult); bindingContext.ValidationNode.ChildNodes.Add(complexModelResult.ValidationNode); } } }
// Used when the ValueProvider contains the collection to be bound as multiple elements, e.g. foo[0], foo[1]. private static List <TElement> BindComplexCollection(ModelBindingExecutionContext modelBindingExecutionContext, ModelBindingContext bindingContext) { string indexPropertyName = ModelBinderUtil.CreatePropertyModelName(bindingContext.ModelName, "index"); ValueProviderResult vpResultIndex = bindingContext.UnvalidatedValueProvider.GetValue(indexPropertyName); IEnumerable <string> indexNames = CollectionModelBinderUtil.GetIndexNamesFromValueProviderResult(vpResultIndex); return(BindComplexCollectionFromIndexes(modelBindingExecutionContext, bindingContext, indexNames)); }
private static string GetResourceCommon(ModelBindingExecutionContext modelBindingExecutionContext, ModelMetadata modelMetadata, object incomingValue, Func <ModelBindingExecutionContext, string> resourceAccessor) { string displayName = modelMetadata.GetDisplayName(); string errorMessageTemplate = resourceAccessor(modelBindingExecutionContext); string errorMessage = String.Format(CultureInfo.CurrentCulture, errorMessageTemplate, incomingValue, displayName); return(errorMessage); }
public IValueProvider GetValueProvider(ModelBindingExecutionContext modelBindingExecutionContext) { if (modelBindingExecutionContext == null) { throw new ArgumentNullException("modelBindingExecutionContext"); } return(new UserProfileValueProvider(modelBindingExecutionContext)); }
public override IValueProvider GetValueProvider(ModelBindingExecutionContext modelBindingExecutionContext) { if (modelBindingExecutionContext == null) { throw new ArgumentNullException("modelBindingExecutionContext"); } return(new FormValueProvider(modelBindingExecutionContext)); }
protected virtual void SetProperty(ModelBindingExecutionContext modelBindingExecutionContext, ModelBindingContext bindingContext, ModelMetadata propertyMetadata, ComplexModelResult complexModelResult) { PropertyDescriptor propertyDescriptor = TypeDescriptorHelper.Get(bindingContext.ModelType).GetProperties().Find(propertyMetadata.PropertyName, true /* ignoreCase */); if (propertyDescriptor == null || propertyDescriptor.IsReadOnly) { return; // nothing to do } object value = complexModelResult.Model ?? GetPropertyDefaultValue(propertyDescriptor); propertyMetadata.Model = value; // 'Required' validators need to run first so that we can provide useful error messages if // the property setters throw, e.g. if we're setting entity keys to null. See comments in // DefaultModelBinder.SetProperty() for more information. if (value == null) { string modelStateKey = complexModelResult.ValidationNode.ModelStateKey; if (bindingContext.ModelState.IsValidField(modelStateKey)) { ModelValidator requiredValidator = ModelValidatorProviders.Providers.GetValidators(propertyMetadata, modelBindingExecutionContext).Where(v => v.IsRequired).FirstOrDefault(); if (requiredValidator != null) { foreach (ModelValidationResult validationResult in requiredValidator.Validate(bindingContext.Model)) { bindingContext.ModelState.AddModelError(modelStateKey, validationResult.Message); } } } } if (value != null || TypeHelpers.TypeAllowsNullValue(propertyDescriptor.PropertyType)) { try { propertyDescriptor.SetValue(bindingContext.Model, value); } catch (Exception ex) { // don't display a duplicate error message if a binding error has already occurred for this field string modelStateKey = complexModelResult.ValidationNode.ModelStateKey; if (bindingContext.ModelState.IsValidField(modelStateKey)) { bindingContext.ModelState.AddModelError(modelStateKey, ex); } } } else { // trying to set a non-nullable value type to null, need to make sure there's a message string modelStateKey = complexModelResult.ValidationNode.ModelStateKey; if (bindingContext.ModelState.IsValidField(modelStateKey)) { complexModelResult.ValidationNode.Validated += CreateNullCheckFailedHandler(modelBindingExecutionContext, propertyMetadata, value); } } }
protected override object FetchValue(string key) { StateBag pageViewState = ModelBindingExecutionContext.GetService <StateBag>(); if (pageViewState != null) { return(pageViewState[key]); } return(null); }
internal IModelBinder GetRequiredBinder(ModelBindingExecutionContext modelBindingExecutionContext, ModelBindingContext bindingContext) { IModelBinder binder = GetBinder(modelBindingExecutionContext, bindingContext); if (binder == null) { throw Error.ModelBinderProviderCollection_BinderForTypeNotFound(bindingContext.ModelType); } return(binder); }
public DataAnnotationsModelValidator(ModelMetadata metadata, ModelBindingExecutionContext context, ValidationAttribute attribute) : base(metadata, context) { if (attribute == null) { throw new ArgumentNullException("attribute"); } Attribute = attribute; }
public ModelValidatedEventArgs(ModelBindingExecutionContext modelBindingExecutionContext, ModelValidationNode parentNode) { if (modelBindingExecutionContext == null) { throw new ArgumentNullException("modelBindingExecutionContext"); } ModelBindingExecutionContext = modelBindingExecutionContext; ParentNode = parentNode; }
private static RouteValueDictionary GetRouteValues(ModelBindingExecutionContext modelBindingExecutionContext) { RouteData routeData = modelBindingExecutionContext.GetService <RouteData>(); if (routeData != null) { return(routeData.Values); } return(new RouteValueDictionary()); }
private void ValidateChildren(ModelBindingExecutionContext modelBindingExecutionContext) { foreach (ModelValidationNode child in ChildNodes) { child.Validate(modelBindingExecutionContext, this); } if (ValidateAllProperties) { ValidateProperties(modelBindingExecutionContext); } }
public override IModelBinder GetBinder(ModelBindingExecutionContext modelBindingExecutionContext, ModelBindingContext bindingContext) { ModelBinderUtil.ValidateBindingContext(bindingContext); if (!bindingContext.ModelMetadata.IsReadOnly && bindingContext.ModelType.IsArray && bindingContext.UnvalidatedValueProvider.ContainsPrefix(bindingContext.ModelName)) { Type elementType = bindingContext.ModelType.GetElementType(); return((IModelBinder)Activator.CreateInstance(typeof(ArrayModelBinder <>).MakeGenericType(elementType))); } return(null); }
public virtual bool BindModel(ModelBindingExecutionContext modelBindingExecutionContext, ModelBindingContext bindingContext) { ModelBinderUtil.ValidateBindingContext(bindingContext); ValueProviderResult vpResult = bindingContext.UnvalidatedValueProvider.GetValue(bindingContext.ModelName, skipValidation: !bindingContext.ValidateRequest); List <TElement> boundCollection = (vpResult != null) ? BindSimpleCollection(modelBindingExecutionContext, bindingContext, vpResult.RawValue, vpResult.Culture) : BindComplexCollection(modelBindingExecutionContext, bindingContext); bool retVal = CreateOrReplaceCollection(modelBindingExecutionContext, bindingContext, boundCollection); return(retVal); }
public override IModelBinder GetBinder(ModelBindingExecutionContext modelBindingExecutionContext, ModelBindingContext bindingContext) { ModelBinderUtil.ValidateBindingContext(bindingContext); if (bindingContext.UnvalidatedValueProvider.ContainsPrefix(bindingContext.ModelName)) { return(CollectionModelBinderUtil.GetGenericBinder(typeof(IDictionary <,>), typeof(Dictionary <,>), typeof(DictionaryModelBinder <,>), bindingContext.ModelMetadata)); } else { return(null); } }
internal static List <TElement> BindComplexCollectionFromIndexes(ModelBindingExecutionContext modelBindingExecutionContext, ModelBindingContext bindingContext, IEnumerable <string> indexNames) { bool indexNamesIsFinite; if (indexNames != null) { indexNamesIsFinite = true; } else { indexNamesIsFinite = false; indexNames = CollectionModelBinderUtil.GetZeroBasedIndexes(); } List <TElement> boundCollection = new List <TElement>(); foreach (string indexName in indexNames) { string fullChildName = ModelBinderUtil.CreateIndexModelName(bindingContext.ModelName, indexName); ModelBindingContext childBindingContext = new ModelBindingContext(bindingContext) { ModelMetadata = ModelMetadataProviders.Current.GetMetadataForType(null, typeof(TElement)), ModelName = fullChildName }; object boundValue = null; IModelBinder childBinder = bindingContext.ModelBinderProviders.GetBinder(modelBindingExecutionContext, childBindingContext); if (childBinder != null) { if (childBinder.BindModel(modelBindingExecutionContext, childBindingContext)) { boundValue = childBindingContext.Model; // merge validation up bindingContext.ValidationNode.ChildNodes.Add(childBindingContext.ValidationNode); } } else { // should we even bother continuing? if (!indexNamesIsFinite) { break; } } boundCollection.Add(ModelBinderUtil.CastOrDefault <TElement>(boundValue)); } return(boundCollection); }
public override IModelBinder GetBinder(ModelBindingExecutionContext modelBindingExecutionContext, ModelBindingContext bindingContext) { ModelBinderUtil.ValidateBindingContext(bindingContext); if (bindingContext.ModelType == ModelType) { if (SuppressPrefixCheck || bindingContext.UnvalidatedValueProvider.ContainsPrefix(bindingContext.ModelName)) { return(_modelBinderFactory()); } } return(null); }
protected virtual IEnumerable <ModelMetadata> GetMetadataForProperties(ModelBindingExecutionContext modelBindingExecutionContext, ModelBindingContext bindingContext) { // keep a set of the required properties so that we can cross-reference bound properties later HashSet <string> requiredProperties; HashSet <string> skipProperties; GetRequiredPropertiesCollection(bindingContext.ModelType, out requiredProperties, out skipProperties); return(from propertyMetadata in bindingContext.ModelMetadata.Properties let propertyName = propertyMetadata.PropertyName let shouldUpdateProperty = requiredProperties.Contains(propertyName) || !skipProperties.Contains(propertyName) where shouldUpdateProperty && CanUpdateProperty(propertyMetadata) select propertyMetadata); }
protected ModelValidator(ModelMetadata metadata, ModelBindingExecutionContext modelBindingExecutionContext) { if (metadata == null) { throw new ArgumentNullException("metadata"); } if (modelBindingExecutionContext == null) { throw new ArgumentNullException("modelBindingExecutionContext"); } Metadata = metadata; ModelBindingExecutionContext = modelBindingExecutionContext; }
private ComplexModel CreateAndPopulateComplexModel(ModelBindingExecutionContext modelBindingExecutionContext, ModelBindingContext bindingContext, IEnumerable <ModelMetadata> propertyMetadatas) { // create a Complex Model and call into the Complex Model binder ComplexModel originalComplexModel = new ComplexModel(bindingContext.ModelMetadata, propertyMetadatas); ModelBindingContext complexModelBindingContext = new ModelBindingContext(bindingContext) { ModelMetadata = MetadataProvider.GetMetadataForType(() => originalComplexModel, typeof(ComplexModel)), ModelName = bindingContext.ModelName }; IModelBinder complexModelBinder = bindingContext.ModelBinderProviders.GetRequiredBinder(modelBindingExecutionContext, complexModelBindingContext); complexModelBinder.BindModel(modelBindingExecutionContext, complexModelBindingContext); return((ComplexModel)complexModelBindingContext.Model); }
public bool BindModel(ModelBindingExecutionContext modelBindingExecutionContext, ModelBindingContext bindingContext) { ModelBinderUtil.ValidateBindingContext(bindingContext, typeof(KeyValuePair <TKey, TValue>), true /* allowNullModel */); TKey key; bool keyBindingSucceeded = KeyValuePairModelBinderUtil.TryBindStrongModel <TKey>(modelBindingExecutionContext, bindingContext, "key", MetadataProvider, out key); TValue value; bool valueBindingSucceeded = KeyValuePairModelBinderUtil.TryBindStrongModel <TValue>(modelBindingExecutionContext, bindingContext, "value", MetadataProvider, out value); if (keyBindingSucceeded && valueBindingSucceeded) { bindingContext.Model = new KeyValuePair <TKey, TValue>(key, value); } return(keyBindingSucceeded || valueBindingSucceeded); }