private static void ApplyMetadataAwareAttributes(IEnumerable<Attribute> attributes, ModelMetadata result) { foreach (IMetadataAware awareAttribute in attributes.OfType<IMetadataAware>()) { awareAttribute.OnMetadataCreated(result); } }
/// <summary> /// Provides metadata to the model metadata creation process. /// </summary> /// <param name="metadata">The model metadata.</param> public void OnMetadataCreated(ModelMetadata metadata) { LabelOptions.CssStyles = CssStyles; LabelOptions.HtmlAttributes = HtmlAttributes; metadata.SetColumnLabelOptions(LabelOptions); }
private static string GetResourceCommon(ControllerContext controllerContext, ModelMetadata modelMetadata, object incomingValue, Func<ControllerContext, string> resourceAccessor) { string displayName = modelMetadata.GetDisplayName(); string errorMessageTemplate = resourceAccessor(controllerContext); string errorMessage = String.Format(CultureInfo.CurrentCulture, errorMessageTemplate, incomingValue, displayName); return errorMessage; }
public IEnumerable<ModelClientValidationRule> GetClientValidationRules(ModelMetadata metadata, ControllerContext context) { var name = metadata.GetDisplayName(); var message = FormatErrorMessage(name); yield return new TodayOrLaterClientValidationRule(message); }
/// <summary> /// When implemented in a class, returns client validation rules for that class. /// </summary> /// <param name="metadata">The model metadata.</param> /// <param name="context">The controller context.</param> /// <returns> /// The client validation rules for this validator. /// </returns> public IEnumerable<ModelClientValidationRule> GetClientValidationRules(ModelMetadata metadata, ControllerContext context) { var rule = new ModelClientValidationRule { ErrorMessage = ErrorMessageString ?? "Field invalid. Field can only contain alphanumeric characters: 'a-z', 'A-Z', '0-9'.", ValidationType = clientValidationRule }; rule.ValidationParameters.Add("pattern", RootModuleConstants.AlphanumericExpression); yield return rule; }
public void OnMetadataCreated(ModelMetadata metadata) { if (!string.IsNullOrEmpty(Name)) { metadata.DisplayName = GetFormatedName(); } }
public void DefaultValues() { // Arrange Mock<ModelMetadataProvider> provider = new Mock<ModelMetadataProvider>(); // Act ModelMetadata metadata = new ModelMetadata(provider.Object, typeof(Exception), () => "model", typeof(string), "propertyName"); // Assert Assert.Equal(typeof(Exception), metadata.ContainerType); Assert.True(metadata.ConvertEmptyStringToNull); Assert.Null(metadata.DataTypeName); Assert.Null(metadata.Description); Assert.Null(metadata.DisplayFormatString); Assert.Null(metadata.DisplayName); Assert.Null(metadata.EditFormatString); Assert.False(metadata.HideSurroundingHtml); Assert.Equal("model", metadata.Model); Assert.Equal(typeof(string), metadata.ModelType); Assert.Null(metadata.NullDisplayText); Assert.Equal(10000, metadata.Order); Assert.Equal("propertyName", metadata.PropertyName); Assert.False(metadata.IsReadOnly); Assert.True(metadata.RequestValidationEnabled); Assert.Null(metadata.ShortDisplayName); Assert.True(metadata.ShowForDisplay); Assert.True(metadata.ShowForEdit); Assert.Null(metadata.TemplateHint); Assert.Null(metadata.Watermark); }
protected override IEnumerable<ModelValidator> GetValidators(ModelMetadata metadata, ControllerContext context, IEnumerable<Attribute> attributes) { _adaptersLock.EnterReadLock(); try { List<ModelValidator> results = new List<ModelValidator>(); if (AddImplicitRequiredAttributeForValueTypes && metadata.IsRequired && !attributes.Any(a => a is RequiredAttribute)) { attributes = attributes.Concat(new[] { new RequiredAttribute() }); } foreach (ValidationAttribute attribute in attributes.OfType<ValidationAttribute>()) { DataAnnotationsModelValidationFactory factory; if (!AttributeFactories.TryGetValue(attribute.GetType(), out factory)) { factory = DefaultAttributeFactory; } results.Add(factory(metadata, context, attribute)); } return results; } finally { _adaptersLock.ExitReadLock(); } }
public virtual void OnMetadataCreated(ModelMetadata metadata) { string smallKey = Name.ToLowerInvariant(); string key = string.Format(CultureInfo.InvariantCulture, Prefix, smallKey); metadata.AdditionalValues[key] = Value; }
public void OnMetadataCreated(ModelMetadata metadata) { metadata.AdditionalValues[UxAttributeKeys.Boolean.TrueText] = TrueText; metadata.AdditionalValues[UxAttributeKeys.Boolean.FalseText] = FalseText; metadata.AdditionalValues[UxAttributeKeys.Boolean.NullText] = NullText; metadata.AdditionalValues[UxAttributeKeys.Boolean.Type] = Type; }
protected override void OnMetadataProcess(ModelMetadata meta, string name, ViewDataDictionary viewData, ControllerContext context) { base.OnMetadataProcess(meta, name, viewData, context); if (name.IsEmpty()) { throw new Exception("Name from ControlFor is empty"); } this.Name = name; if (meta.IsReadOnly) { this.ReadOnly = true; } if (this.FieldLabel.IsEmpty()) { this.FieldLabel = meta.GetDisplayName(); } if (this.Note.IsEmpty() && meta.Description.IsNotEmpty()) { this.Note = meta.Description; } ModelState modelState; if (viewData.ModelState.TryGetValue(name, out modelState)) { if (modelState.Errors.Count > 0) { this.CustomConfig.Add(new ConfigItem("activeError", JSON.Serialize(modelState.Errors.Select(e => e.ErrorMessage)), ParameterMode.Raw)); } } }
public void OnMetadataCreated(ModelMetadata metadata) { metadata.AdditionalValues.Add("dropdownlistenerwithspecificvalue", true); metadata.AdditionalValues.Add("dropdownlistenerwithspecificvalue-match", _matchingValue); metadata.AdditionalValues.Add("dropdownlistenerwithspecificvalue-callback", _clientCallback); metadata.AdditionalValues.Add("dropdownlistenerwithspecificvalue-parent", _parent); }
public ListBox(HtmlHelper html, string htmlFieldName, IEnumerable<SelectListItem> selectList, ModelMetadata metadata) { this.html = html; this._model.htmlFieldName = htmlFieldName; this._model.selectList = selectList; this._model.metadata = metadata; }
public IEnumerable<ModelClientValidationRule> GetClientValidationRules(ModelMetadata metadata, ControllerContext context) { var rule = new ModelClientValidationRule(); rule.ErrorMessage = "true"; rule.ValidationType = "dbisunique"; yield return rule; }
public IEnumerable<ModelClientValidationRule> GetClientValidationRules(ModelMetadata metadata, ControllerContext context) { var rule = new ModelClientValidationRule(); rule.ErrorMessage = FormatErrorMessage(metadata.GetDisplayName()); rule.ValidationType = "dbisbool"; yield return rule; }
public void Number_Of_Properties_And_Navigations_Is_Correct() { //Arrange var productEntity = TestModel.CategoryProductModel.FindEntityType(typeof(Product)); var productMetadata = new ModelMetadata(productEntity, typeof(TestDbContext)); //Act && Assert Assert.Equal(8, productMetadata.Properties.Length); Assert.Equal(1, productMetadata.Navigations.Length); //Arrange var categoryEntity = TestModel.CategoryProductModel.FindEntityType(typeof(Category)); var categoryMetadata = new ModelMetadata(categoryEntity, typeof(TestDbContext)); //Act && Assert Assert.Equal(2, categoryMetadata.Properties.Length); Assert.Equal(0, categoryMetadata.Navigations.Length); //Arrange var customerEntity = TestModel.CustomerOrderModel.FindEntityType(typeof(Customer)); var customerMetadata = new ModelMetadata(customerEntity, typeof(TestDbContext)); //Act && Assert Assert.Equal(2, customerMetadata.Properties.Length); Assert.Equal(0, customerMetadata.Navigations.Length); //Arrange var orderEntity = TestModel.CustomerOrderModel.FindEntityType(typeof(Order)); var orderMetadata = new ModelMetadata(orderEntity, typeof(TestDbContext)); //Act && Assert Assert.Equal(3, orderMetadata.Properties.Length); Assert.Equal(1, orderMetadata.Navigations.Length); }
public BootstrapRadioButton(HtmlHelper html, string htmlFieldName, object value, ModelMetadata metadata) { this.html = html; this._model.htmlFieldName = htmlFieldName; this._model.value = value; this._model.metadata = metadata; }
public static IDictionary<string, object> GetValidationAttributes( Property property, ControllerContext context) { // create own metadata based on Property object var metadata = new ModelMetadata( ModelMetadataProviders.Current, property.Entity.Type, null, property.TypeInfo.Type, property.Name); metadata.DisplayName = property.Display; var clientRules = ModelValidatorProviders.Providers .GetValidators(metadata, context) .SelectMany(v => v.GetClientValidationRules()); var provider = new PropertyModelValidatorProvider(); var modelValidators = provider .GetValidatorsForAttributes(metadata, context, property.Validators); clientRules = clientRules .Union(modelValidators.SelectMany(x => x.GetClientValidationRules())) .DistinctBy(x => x.ValidationType); var validationAttributes = new Dictionary<string, object>(); UnobtrusiveValidationAttributesGenerator .GetValidationAttributes(clientRules, validationAttributes); return validationAttributes; }
/// <summary> /// Returns the validators for the given class metadata. This gets called for each property. /// </summary> /// <returns>Yield returns client validator instances with a list of rules for the current property</returns> protected override IEnumerable<ModelValidator> GetValidators(ModelMetadata metadata, ControllerContext context, IEnumerable<Attribute> attributes) { if (metadata.ContainerType == null) yield break; //Break if there is no metadata container var engine = ValidatorEngineFactory.ValidatorEngine; var validator = engine.GetClassValidator(metadata.ContainerType); var constraints = validator.GetMemberConstraints(metadata.PropertyName).OfType<IRuleArgs>(); var rules = new List<ModelClientValidationRule>(); foreach (var constraint in constraints) //for each constraint, emit the rules for that constraint { foreach (var validationRule in _ruleEmitters.EmitRules(constraint)) { validationRule.ErrorMessage = constraint.Message; //Temporarily give validation rule the error message provided by the validator validationRule.ErrorMessage = MessageOrDefault(validationRule, metadata.PropertyName); //Get a true error message if not provided rules.Add(validationRule); } } yield return new NHibernateValidatorClientValidator(metadata, context, rules); }
public override IEnumerable<ModelValidator> GetValidators(ModelMetadata metadata, ControllerContext context) { if (IsValidatingProperty(metadata)) { return GetValidatorsForProperty(metadata, context, ValidatorFactory.GetValidator(metadata.ContainerType)); } return GetValidatorsForModel(metadata, context, ValidatorFactory.GetValidator(metadata.ModelType)); }
IEnumerable<ModelValidator> GetValidatorsForProperty(ModelMetadata metadata, ControllerContext context, IValidator validator) { var modelValidators = new List<ModelValidator>(); if (validator != null) { var descriptor = validator.CreateDescriptor(); var validatorsWithRules = from rule in descriptor.GetRulesForMember(metadata.PropertyName) let propertyRule = (PropertyRule)rule let validators = rule.Validators where validators.Any() from propertyValidator in validators let modelValidatorForProperty = GetModelValidator(metadata, context, propertyRule, propertyValidator) where modelValidatorForProperty != null select modelValidatorForProperty; modelValidators.AddRange(validatorsWithRules); } if(validator != null && metadata.IsRequired && AddImplicitRequiredValidator) { bool hasRequiredValidators = modelValidators.Any(x => x.IsRequired); //If the model is 'Required' then we assume it must have a NotNullValidator. //This is consistent with the behaviour of the DataAnnotationsModelValidatorProvider //which silently adds a RequiredAttribute if(! hasRequiredValidators) { modelValidators.Add(CreateNotNullValidatorForProperty(metadata, context)); } } return modelValidators; }
public IEnumerable<ModelClientValidationRule> GetClientValidationRules(ModelMetadata metadata, ControllerContext context) { if (!Required) yield break; yield return new ReferenceRequiredValidationRule(ErrorMessage, Required); }
//private class LocalizableAttributeCacheKey //{ // public LocalizableAttributeCacheKey(Attribute attribute) // { // string cacheFormat = "Attribute HashCode:{0}; CultureName LCID:{1}"; // this.CacheKey = string.Format(cacheFormat, attribute.GetHashCode(), System.Threading.Thread.CurrentThread.CurrentCulture.LCID); // } // public string CacheKey { get; private set; } // public override int GetHashCode() // { // return CacheKey.GetHashCode(); // } // public override bool Equals(object obj) // { // return this.GetHashCode() == ((LocalizableAttributeCacheKey)obj).GetHashCode(); // } //} //private static readonly List<LocalizableAttributeCacheKey> localized = new List<LocalizableAttributeCacheKey>(); //protected override IEnumerable<ModelValidator> GetValidators(ModelMetadata metadata, ControllerContext context, IEnumerable<Attribute> attributes) //{ // foreach (ValidationAttribute attribute in attributes.OfType<ValidationAttribute>()) // { // var cacheKey = new LocalizableAttributeCacheKey(attribute); // if (!localized.Contains(cacheKey)) // { // lock (localized) // { // if (!localized.Contains(cacheKey)) // { // if (!string.IsNullOrWhiteSpace(attribute.ErrorMessage)) // { // attribute.ErrorMessage = attribute.ErrorMessage.Localize(); // } // else // { // if (attribute is RequiredAttribute) // { // attribute.ErrorMessage = "Required".Localize(); // } // } // localized.Add(cacheKey); // } // } // } // } // var validators = base.GetValidators(metadata, context, attributes); // return validators; //} protected override IEnumerable<ModelValidator> GetValidators(ModelMetadata metadata, ControllerContext context, IEnumerable<Attribute> attributes) { foreach (var validator in base.GetValidators(metadata, context, attributes)) { yield return new ModelValidatorWrapper(validator, metadata, context); } }
/// <summary> /// Gets the client validation rules. /// </summary> /// <param name="metadata">The metadata.</param> /// <param name="context">The context.</param> /// <returns>The client validation rules</returns> public IEnumerable<ModelClientValidationRule> GetClientValidationRules(ModelMetadata metadata, ControllerContext context) { return new[] { new ModelClientValidationStringLengthRule(this.FormatErrorMessage(metadata.GetDisplayName()), this.minimumCharacterCount, int.MaxValue) }; }
/// <summary> /// When implemented in a class, provides metadata to the model metadata creation process. /// </summary> /// <param name="metadata">The model metadata.</param> public void OnMetadataCreated(ModelMetadata metadata) { metadata.AdditionalValues.Add("LookupMethodName", this.LookupMethodName); metadata.AdditionalValues.Add("AddLookupData", this.AddLookupData); metadata.AdditionalValues.Add("LookupType",this.LookupType); metadata.TemplateHint = "DropDownList"; }
public MyValidator(ValidationAttribute attribute, string errorMsg, ModelMetadata metadata, ControllerContext controllerContext, IEnumerable<ModelClientValidationRule> create) : base(metadata, controllerContext) { _attribute = attribute; _errorMsg = errorMsg; _create = create; }
public override IEnumerable<ModelValidator> GetValidators(ModelMetadata metadata, ControllerContext context) { var validators = new List<ModelValidator>(); if (metadata is FluentModelMetadata) { var isPropertyMetadata = !string.IsNullOrEmpty(metadata.PropertyName); var rules = (metadata as FluentModelMetadata).Metadata.Rules; if (isPropertyMetadata) { validators.AddRange( rules .Select(rule => new RuleModelValidator(rule, metadata, context)) .Cast<ModelValidator>()); //TODO unnecessary for .NET 4 } else { validators.AddRange( rules .Select(rule => new ClassRuleModelValidator(rule as IClassRule, metadata, context)) .Cast<ModelValidator>()); //TODO unnecessary for .NET 4 } } return validators; }
public void MultipleAttributesCanSetValuesOnMetadata() { // Arrange string name1 = "name1"; string name2 = "name2"; object value1 = new object(); object value2 = new object(); object value3 = new object(); ModelMetadata modelMetadata = new ModelMetadata(new Mock<ModelMetadataProvider>().Object, null, null, typeof(object), null); AdditionalMetadataAttribute attr1 = new AdditionalMetadataAttribute(name1, value1); AdditionalMetadataAttribute attr2 = new AdditionalMetadataAttribute(name2, value2); AdditionalMetadataAttribute attr3 = new AdditionalMetadataAttribute(name1, value3); // Act attr1.OnMetadataCreated(modelMetadata); attr2.OnMetadataCreated(modelMetadata); attr3.OnMetadataCreated(modelMetadata); // Assert Assert.Equal(2, modelMetadata.AdditionalValues.Count); Assert.Equal(modelMetadata.AdditionalValues[name1], value3); Assert.Equal(modelMetadata.AdditionalValues[name2], value2); Assert.NotEqual(attr1.TypeId, attr2.TypeId); Assert.NotEqual(attr2.TypeId, attr3.TypeId); Assert.NotEqual(attr3.TypeId, attr1.TypeId); }
public void TransformMetadata(ModelMetadata metadata, IEnumerable<Attribute> attributes) { if (!string.IsNullOrEmpty(metadata.PropertyName) && !attributes.OfType<DisplayNameAttribute>().Any()) { metadata.DisplayName = metadata.PropertyName.ToProperCaseWords(); } }
public IEnumerable<ModelClientValidationRule> GetClientValidationRules(ModelMetadata metadata, ControllerContext context) { yield return new ModelClientValidationRule { ErrorMessage = this.ErrorMessage, ValidationType = "mustbetrue" }; }
public IEnumerable <ModelClientValidationRule> GetClientValidationRules(ModelMetadata metadata, ControllerContext context) { return(new[] { new ModelClientValidationStringLengthRule(FormatErrorMessage(metadata.GetDisplayName()), _minCharacters, int.MaxValue) }); }
// Generates the editable form controls in a tr element private static string EditRowControlCells(HtmlHelper helper, ModelMetadata fileMetatdata, string prefix, IEnumerable <string> extraColumns, Dictionary <string, object> optionLists) { StringBuilder html = new StringBuilder(); foreach (string column in extraColumns) { // TODO: Add data list ModelMetadata metaData = fileMetatdata.Properties.FirstOrDefault(x => x.PropertyName == column); string name = String.Format("{0}.{1}", prefix, column); Type type = metaData.ModelType; if (Nullable.GetUnderlyingType(type) != null) { type = Nullable.GetUnderlyingType(type); } if (metaData.DataTypeName == "MultilineText") { string textAreaCell = TextAreaCell(helper, name, metaData); html.Append(textAreaCell); } else if (metaData.ModelType == typeof(bool)) { string checkBoxCell = CheckboxCell(helper, name, metaData); html.Append(checkBoxCell); } else if (metaData.ModelType == typeof(bool?)) { bool?defaultValue = (bool?)metaData.Model; List <SelectListItem> selectList = new List <SelectListItem>() { new SelectListItem() { Value = "", Text = "", Selected = !defaultValue.HasValue }, // TODO: Text from Resource File new SelectListItem() { Value = "true", Text = "Yes", Selected = defaultValue.HasValue && defaultValue.Value }, new SelectListItem() { Value = "false", Text = "No", Selected = defaultValue.HasValue && !defaultValue.Value } }; string selectCell = SelectCell(helper, name, metaData, selectList); html.Append(selectCell); } else if (type.IsEnum) { string defaultValue = Convert.ToString(metaData.Model); List <SelectListItem> selectList = new List <SelectListItem>(); var nullText = metaData.NullDisplayText; selectList.Add(new SelectListItem() { Value = "", Text = nullText }); foreach (var item in Enum.GetNames(type)) { selectList.Add(new SelectListItem() { Value = item, Text = item, Selected = (item == defaultValue) }); } string selectCell = SelectCell(helper, name, metaData, selectList); html.Append(selectCell); } else if (metaData.AdditionalValues.ContainsKey(_SelectListKey)) { IEnumerable <SelectListItem> options = optionLists[column] as IEnumerable <SelectListItem>; List <SelectListItem> selectList = new List <SelectListItem>(); string defaultValue = Convert.ToString(metaData.Model); foreach (SelectListItem item in options) { item.Selected = (item.Value != null) ? item.Value == defaultValue : item.Text == defaultValue; selectList.Add(item); } string selectCell = SelectCell(helper, name, metaData, selectList); html.Append(selectCell); } else if (metaData.AdditionalValues.ContainsKey(_DataListKey)) { IEnumerable <string> options = optionLists[column] as IEnumerable <string>; string dataListCell = DataListCell(helper, name, metaData, options); html.Append(dataListCell); } else { string textBoxCell = TextBoxCell(helper, name, metaData); html.Append(textBoxCell); } } return(html.ToString()); }
// Gets the data used to generate datalists and selectlists private static Dictionary <string, object> GetOptionLists(ModelMetadata itemMetadata, object parentModel) { // Get datalists var dataLists = itemMetadata.Properties.Where(x => x.AdditionalValues.ContainsKey(_DataListKey)).Select(x => new { propertyName = x.PropertyName, optionsPropertyName = x.AdditionalValues[_DataListKey] }); // Get selectlists var selectLists = itemMetadata.Properties.Where(x => x.AdditionalValues.ContainsKey(_SelectListKey)).Select(x => new { propertyName = x.PropertyName, optionsPropertyName = x.AdditionalValues[_SelectListKey], optionLabel = x.AdditionalValues[_OptionLabelKey] }); if (selectLists.Any() || dataLists.Any()) { Dictionary <string, object> optionsLists = new Dictionary <string, object>(); Type parentType = parentModel.GetType(); var parentMetadata = ModelMetadataProviders.Current.GetMetadataForType(() => parentModel, parentType); foreach (var item in dataLists) { var optionsMetadata = parentMetadata.Properties.FirstOrDefault(x => x.PropertyName == (string)item.optionsPropertyName); if (optionsMetadata == null) { string message = String.Format(_InvalidDataListPropertyName, item.optionsPropertyName); throw new MissingFieldException(message); // TODO: What is the correct exception } if (optionsMetadata.Model == null) { string message = String.Format(_NullDataList, item.optionsPropertyName); throw new NullReferenceException(message); } IEnumerable <string> options = optionsMetadata.Model as IEnumerable <string>; if (options == null) { string message = String.Format(_InvalidDataListType, item.optionsPropertyName); throw new InvalidCastException(message); // TODO: What is the correct exception } optionsLists.Add(item.propertyName, options); } foreach (var item in selectLists) { var optionsMetadata = parentMetadata.Properties.FirstOrDefault(x => x.PropertyName == (string)item.optionsPropertyName); if (optionsMetadata == null) { string message = String.Format(_InvalidSelectListPropertyName, item.optionsPropertyName); throw new MissingFieldException(message); // TODO: What is the correct exception } if (optionsMetadata.Model == null) { string message = String.Format(_NullSelectList, item.optionsPropertyName); throw new NullReferenceException(message); } IEnumerable <SelectListItem> options = optionsMetadata.Model as IEnumerable <SelectListItem>; if (options == null) { string message = String.Format(_InvalidSelectListType, item.optionsPropertyName); throw new InvalidCastException(message); // TODO: What is the correct exception } // Build new option list List <SelectListItem> selectList = new List <SelectListItem>(); if (item.optionLabel != null) { selectList.Add(new SelectListItem() { Value = "", Text = (string)item.optionLabel }); } foreach (var option in options) { selectList.Add(new SelectListItem() { Value = option.Value, Text = option.Text }); } optionsLists.Add(item.propertyName, selectList); } return(optionsLists); } return(new Dictionary <string, object>()); }
/// <summary> /// Returns the html for an editable control to add and delete files. /// </summary> /// <param name="helper"> /// The HtmlHelper instance that this method extends. /// </param> /// <param name="expression"> /// An expression that identifies the property to render. /// </param> public static MvcHtmlString FileAttachmentEditorFor <TModel>(this HtmlHelper <TModel> helper, Expression <Func <TModel, IEnumerable <IFileAttachment> > > expression) { // Get the model metadata ModelMetadata metaData = ModelMetadata.FromLambdaExpression(expression, helper.ViewData); // Get the attachments IEnumerable <IFileAttachment> attachments = metaData.Model as IEnumerable <IFileAttachment>; // Get the fully qualified name of the property string propertyName = ExpressionHelper.GetExpressionText(expression); // Get the type metadata Type modelType = metaData.ModelType.GetGenericArguments()[0]; // Get the metadata for new instance object instance = Activator.CreateInstance(modelType); ModelMetadata itemMetadata = ModelMetadataProviders.Current.GetMetadataForType(() => instance, modelType); // Get any selectlists or datalists Dictionary <string, object> optionLists = GetOptionLists(itemMetadata, helper.ViewData.Model); // Get properties included in the model but not the IFileAttachment IEnumerable <ModelMetadata> extraProperties = GetExtraProperties(modelType); // Build html StringBuilder html = new StringBuilder(); IEnumerable <string> extraColumns = extraProperties.Select(x => x.GetDisplayName()); string header = EditHeader(extraColumns); html.Append(header); extraColumns = extraProperties.Select(x => x.PropertyName); if (attachments == null) { TagBuilder tbody = new TagBuilder("tbody"); html.Append(tbody.ToString()); } else { string body = EditBody(helper, modelType, attachments, propertyName, extraColumns, optionLists); html.Append(body); } string hiddenBody = HiddenBody(helper, itemMetadata, propertyName, extraColumns, optionLists); html.Append(hiddenBody); string footer = EditFooter(propertyName, extraProperties.Count()); html.Append(footer); TagBuilder table = new TagBuilder("table"); table.AddCssClass("edit-table"); table.AddCssClass("file-attachments"); table.MergeAttribute("id", HtmlHelper.GenerateIdFromName(propertyName)); table.InnerHtml = html.ToString(); // Add any datalists var datalists = optionLists.Where(x => x.Value is IEnumerable <string>); if (datalists.Any()) { html = new StringBuilder(); html.Append(table.ToString()); foreach (var item in datalists) { string id = String.Format("{0}-datalist", item.Key).ToLower(); string datalist = DataList(id, item.Value as IEnumerable <string>); html.Append(datalist); } return(MvcHtmlString.Create(html.ToString())); } return(MvcHtmlString.Create(table.ToString())); }
public PropertyKey(ModelMetadata metadata, BindingSource source) { ContainerType = metadata.ContainerType; PropertyName = metadata.PropertyName; Source = source; }
public static ModelField CreateModelFieldFromMeta(ModelMetadata propertyMetadata, Ext.Net.Model storeModel = null, ModelFieldAttribute modelAttr = null, ControllerContext controllerContext = null) { var modelField = new ModelField(); if (modelAttr == null) { modelAttr = propertyMetadata.AdditionalValues.ContainsKey(ModelFieldAttribute.KEY) ? (ModelFieldAttribute)propertyMetadata.AdditionalValues[ModelFieldAttribute.KEY] : null; } modelField.Name = propertyMetadata.PropertyName; if (Store.IsDate(propertyMetadata.ModelType)) { modelField.Type = ModelFieldType.Date; } else if (Store.IsInteger(propertyMetadata.ModelType)) { modelField.Type = ModelFieldType.Int; } else if (Store.IsFloat(propertyMetadata.ModelType)) { modelField.Type = ModelFieldType.Float; } else if (Store.IsBoolean(propertyMetadata.ModelType)) { modelField.Type = ModelFieldType.Boolean; } else if (propertyMetadata.ModelType == typeof(string)) { modelField.Type = ModelFieldType.String; } if (propertyMetadata.IsComplexType && modelAttr != null) { modelField.IsComplex = true; } if (modelAttr != null && storeModel != null) { modelAttr.CopyTo(modelField, storeModel); } if (storeModel != null) { storeModel.Fields.Add(modelField); } ValidationCollection validations = new ValidationCollection(); if (propertyMetadata.AdditionalValues.ContainsKey(AbstractValidationAttribute.KEY)) { validations = (ValidationCollection)propertyMetadata.AdditionalValues[AbstractValidationAttribute.KEY]; } foreach (ModelValidator v in propertyMetadata.GetValidators(controllerContext)) { var rule = v.GetClientValidationRules().FirstOrDefault(); if (rule != null) { switch (rule.ValidationType) { case "required": validations.Add(new PresenceValidation { Message = rule.ErrorMessage }); break; case "regex": if (rule.ValidationParameters.ContainsKey("pattern")) { validations.Add(new FormatValidation { Matcher = rule.ValidationParameters["pattern"].ToString(), Message = rule.ErrorMessage }); } break; case "length": int num; LengthValidation length = new LengthValidation(); length.Message = rule.ErrorMessage; if (rule.ValidationParameters.ContainsKey("max")) { if (int.TryParse(rule.ValidationParameters["max"].ToString(), out num)) { length.Max = num; } else { continue; } } if (rule.ValidationParameters.ContainsKey("min")) { if (int.TryParse(rule.ValidationParameters["min"].ToString(), out num)) { length.Min = num; } else { continue; } } validations.Add(length); break; } } } if (controllerContext != null) { foreach (ModelValidator v in propertyMetadata.GetValidators(controllerContext)) { var rule = v.GetClientValidationRules().FirstOrDefault(); if (rule != null) { switch (rule.ValidationType) { case "required": validations.Add(new PresenceValidation { Field = modelField.Name, Message = rule.ErrorMessage }); break; case "regex": if (rule.ValidationParameters.ContainsKey("pattern")) { validations.Add(new FormatValidation { Field = modelField.Name, Matcher = rule.ValidationParameters["pattern"].ToString(), Message = rule.ErrorMessage }); } break; case "length": var lengthVal = new LengthValidation(); if (rule.ValidationParameters.ContainsKey("max")) { lengthVal.Max = (int)Convert.ChangeType(rule.ValidationParameters["max"], typeof(int)); } if (rule.ValidationParameters.ContainsKey("min")) { lengthVal.Min = (int)Convert.ChangeType(rule.ValidationParameters["min"], typeof(int)); } lengthVal.Message = rule.ErrorMessage; validations.Add(lengthVal); break; } } } } if (validations.Count > 0) { if (storeModel != null) { storeModel.Validations.AddRange(validations); } else { modelField.Validations = validations; } } return(modelField); }
public virtual void InitByType(Type type, bool extractGeneric = true) { if (extractGeneric) { type = Store.GetEnumerableGenericType(type); } ModelMetadata metadata = ModelMetadataProviders.Current.GetMetadataForType(null, type); if (metadata != null) { var storeModel = this.Model.Primary; if (storeModel == null) { storeModel = new Model(); this.Model.Add(storeModel); } ModelAttribute storeModelAttr = metadata.AdditionalValues.ContainsKey(ModelAttribute.KEY) ? (ModelAttribute)metadata.AdditionalValues[ModelAttribute.KEY] : null; if (storeModelAttr != null) { storeModelAttr.CopyTo(storeModel); } if (metadata.AdditionalValues.ContainsKey(AbstractValidationAttribute.KEY)) { storeModel.Validations.AddRange((ValidationCollection)metadata.AdditionalValues[AbstractValidationAttribute.KEY]); } if (metadata.AdditionalValues.ContainsKey(AbstractAssociationAttribute.KEY)) { storeModel.Associations.AddRange((AssociationCollection)metadata.AdditionalValues[AbstractAssociationAttribute.KEY]); } if (metadata.AdditionalValues.ContainsKey(ProxyAttribute.KEY)) { this.Proxy.Add((AbstractProxy)metadata.AdditionalValues[ProxyAttribute.KEY]); } if (metadata.AdditionalValues.ContainsKey(AbstractReaderAttribute.KEY)) { if (this.Proxy.Primary != null && this.Proxy.Primary is ServerProxy) { ((ServerProxy)this.Proxy.Primary).Reader.Add((AbstractReader)metadata.AdditionalValues[AbstractReaderAttribute.KEY]); } else { this.Reader.Add((AbstractReader)metadata.AdditionalValues[AbstractReaderAttribute.KEY]); } } if (metadata.AdditionalValues.ContainsKey(AbstractWriterAttribute.KEY)) { if (this.Proxy.Primary != null && this.Proxy.Primary is ServerProxy) { ((ServerProxy)this.Proxy.Primary).Writer.Add((AbstractWriter)metadata.AdditionalValues[AbstractWriterAttribute.KEY]); } else { this.Writer.Add((AbstractWriter)metadata.AdditionalValues[AbstractWriterAttribute.KEY]); } } var virtualFieldsAttr = metadata.AdditionalValues.ContainsKey(ModelFieldAttribute.KEY) ? (List <VirtualModelField>)metadata.AdditionalValues[ModelFieldAttribute.KEY] : null; if (virtualFieldsAttr != null) { foreach (VirtualModelField attr in virtualFieldsAttr) { var modelField = new ModelField(); if (storeModel != null) { attr.CopyTo(modelField, storeModel); storeModel.Fields.Add(modelField); } } } var registrator = metadata.AdditionalValues.ContainsKey(ClientResourceAttribute.KEY) ? (ResourcesRegistrator)metadata.AdditionalValues[ClientResourceAttribute.KEY] : null; if (registrator != null) { this.Controls.Add(registrator); } foreach (ModelMetadata propertyMetadata in metadata.Properties) { var modelAttr = propertyMetadata.AdditionalValues.ContainsKey(ModelFieldAttribute.KEY) ? (ModelFieldAttribute)propertyMetadata.AdditionalValues[ModelFieldAttribute.KEY] : null; if (modelAttr == null && this.InitForModelOnly) { continue; } if (modelAttr != null && modelAttr.Ignore) { continue; } Store.CreateModelFieldFromMeta(propertyMetadata, storeModel, modelAttr, this.ControllerContext); } } }
public RequiredAdapter(ModelMetadata metadata, ControllerContext context, RequiredAttribute attribute) : base(metadata, context, attribute) { Attribute.ErrorMessage = Validations.FieldIsRequired; }
public SubstitutedModelMetadata(ModelMetadata inner, Type substitutedModelType) : base(ModelMetadataIdentity.ForType(substitutedModelType)) => this.inner = inner;
public static MvcHtmlString ControlGroupFor <TModel, TValue>( this HtmlHelper <TModel> html, Expression <Func <TModel, TValue> > expression, InputEditorType editorType = InputEditorType.TextBox, bool required = false, string helpHint = null, string breakpoint = "md", string additionalCtrlClasses = "") { if (editorType == InputEditorType.Hidden) { return(html.HiddenFor(expression)); } string inputHtml = ""; var htmlAttributes = new RouteValueDictionary(); var metadata = ModelMetadata.FromLambdaExpression(expression, html.ViewData); var dataTypeName = metadata.DataTypeName.EmptyNull(); var groupClass = "form-group row"; var labelClass = "col-{0}-3 col-form-label".FormatInvariant(breakpoint.NullEmpty() ?? "md"); var controlsClass = "col-{0}-9".FormatInvariant(breakpoint.NullEmpty() ?? "md"); var sb = new StringBuilder("<div class='{0}'>".FormatWith(groupClass)); if (editorType != InputEditorType.Checkbox) { var className = labelClass + (required ? " required" : ""); var fieldId = html.IdFor(expression).ToString(); sb.AppendLine(html.LabelFor(expression, new { @class = className, @for = fieldId }).ToString()); } sb.AppendLine("<div class='{0}'>".FormatWith(controlsClass)); if (!required && (editorType == InputEditorType.TextBox || editorType == InputEditorType.Password)) { htmlAttributes.Add("placeholder", EngineContext.Current.Resolve <ILocalizationService>().GetResource("Common.Optional")); } switch (dataTypeName) { case "EmailAddress": htmlAttributes.Add("type", "email"); break; case "PhoneNumber": htmlAttributes.Add("type", "tel"); break; } htmlAttributes.Add("class", "form-control" + (additionalCtrlClasses.HasValue() ? " " + additionalCtrlClasses : "")); switch (editorType) { case InputEditorType.Checkbox: CommonHelper.TryConvert <bool>(metadata.Model, out var isChecked); inputHtml = string.Format("<div class='form-check'>{0}<label class='form-check-label' for='{1}'>{2}</label></div>", html.CheckBox(ExpressionHelper.GetExpressionText(expression), isChecked, new { @class = "form-check-input" }).ToString(), html.IdFor(expression), metadata.DisplayName); break; case InputEditorType.Password: inputHtml = html.PasswordFor(expression, htmlAttributes).ToString(); break; default: inputHtml = html.TextBoxFor(expression, htmlAttributes).ToString(); break; } sb.AppendLine(inputHtml); sb.AppendLine(html.ValidationMessageFor(expression).ToString()); if (helpHint.HasValue()) { sb.AppendLine(string.Format("<div class='form-text text-muted'>{0}</div>", helpHint)); } sb.AppendLine("</div>"); // div.controls sb.AppendLine("</div>"); // div.control-group return(MvcHtmlString.Create(sb.ToString())); }
public BootstrapControlGroupDisplayText(HtmlHelper html, string htmlFieldName, ModelMetadata metadata) { this.html = html; this._model.htmlFieldName = htmlFieldName; this._model.metadata = metadata; }
public override IEnumerable <ModelValidationResult> Validate(ModelMetadata metadata, object container) { return(new ModelValidationResult[0]); }
public static void ValidateFor <TModel, TProperty>(this HtmlHelper <TModel> htmlHelper, Expression <Func <TModel, TProperty> > expression) { ValidateHelper(htmlHelper, ModelMetadata.FromLambdaExpression(expression, htmlHelper.ViewData), ExpressionHelper.GetExpressionText(expression)); }
// Support binding only to simple types or collection of simple types. private bool IsSimpleType(ModelMetadata modelMetadata) { var metadata = modelMetadata.ElementMetadata ?? modelMetadata; return(!metadata.IsComplexType); }
private static FieldValidationMetadata ApplyFieldValidationMetadata(HtmlHelper htmlHelper, ModelMetadata modelMetadata, string modelName) { FormContext formContext = htmlHelper.ViewContext.FormContext; FieldValidationMetadata fieldMetadata = formContext.GetValidationMetadataForField(modelName, true /* createIfNotFound */); // write rules to context object IEnumerable <ModelValidator> validators = ModelValidatorProviders.Providers.GetValidators(modelMetadata, htmlHelper.ViewContext); foreach (ModelClientValidationRule rule in validators.SelectMany(v => v.GetClientValidationRules())) { fieldMetadata.ValidationRules.Add(rule); } return(fieldMetadata); }
internal static bool CalculateHasValidators(HashSet <DefaultModelMetadata> visited, ModelMetadata metadata) { RuntimeHelpers.EnsureSufficientExecutionStack(); if (metadata?.GetType() != typeof(DefaultModelMetadata)) { // The calculation is valid only for DefaultModelMetadata instances. Null, other ModelMetadata instances // or subtypes of DefaultModelMetadata will be treated as always requiring validation. return(true); } var defaultModelMetadata = (DefaultModelMetadata)metadata; if (defaultModelMetadata._hasValidators.HasValue) { // Return a previously calculated value if available. return(defaultModelMetadata._hasValidators.Value); } if (defaultModelMetadata.ValidationMetadata.HasValidators != false) { // Either the ModelMetadata instance has some validators (HasValidators = true) or it is non-deterministic (HasValidators = null). // In either case, assume it has validators. return(true); } // Before inspecting properties or elements of a collection, ensure we do not have a cycle. // Consider a model like so // // Employee { BusinessDivision Division; int Id; string Name; } // BusinessDivision { int Id; List<Employee> Employees } // // If we get to the Employee element from Employee.Division.Employees, we can return false for that instance // and allow other properties of BusinessDivision and Employee to determine if it has validators. if (!visited.Add(defaultModelMetadata)) { return(false); } // We have inspected the current element. Inspect properties or elements that may contribute to this value. if (defaultModelMetadata.IsEnumerableType) { if (CalculateHasValidators(visited, defaultModelMetadata.ElementMetadata !)) { return(true); } } else if (defaultModelMetadata.IsComplexType) { var parameters = defaultModelMetadata.BoundConstructor?.BoundConstructorParameters ?? Array.Empty <ModelMetadata>(); foreach (var parameter in parameters) { if (CalculateHasValidators(visited, parameter)) { return(true); } } foreach (var property in defaultModelMetadata.BoundProperties) { if (CalculateHasValidators(visited, property)) { return(true); } } } // We've come this far. The ModelMetadata does not have any validation return(false); }
protected override void SetProperty(ControllerContext controllerContext, ExtensibleModelBindingContext bindingContext, ModelMetadata propertyMetadata, ComplexModelDtoResult dtoResult) { SetPropertyPublic(controllerContext, bindingContext, propertyMetadata, dtoResult); }
private static MvcHtmlString ValidationMessageHelper(this HtmlHelper htmlHelper, ModelMetadata modelMetadata, string expression, string validationMessage, IDictionary <string, object> htmlAttributes, string tag) { string modelName = htmlHelper.ViewContext.ViewData.TemplateInfo.GetFullHtmlFieldName(expression); FormContext formContext = htmlHelper.ViewContext.GetFormContextForClientValidation(); if (!htmlHelper.ViewData.ModelState.ContainsKey(modelName) && formContext == null) { return(null); } ModelState modelState = htmlHelper.ViewData.ModelState[modelName]; ModelErrorCollection modelErrors = (modelState == null) ? null : modelState.Errors; ModelError modelError = (((modelErrors == null) || (modelErrors.Count == 0)) ? null : modelErrors.FirstOrDefault(m => !String.IsNullOrEmpty(m.ErrorMessage)) ?? modelErrors[0]); if (modelError == null && formContext == null) { return(null); } if (String.IsNullOrEmpty(tag)) { tag = htmlHelper.ViewContext.ValidationMessageElement; } TagBuilder builder = new TagBuilder(tag); builder.MergeAttributes(htmlAttributes); builder.AddCssClass((modelError != null) ? HtmlHelper.ValidationMessageCssClassName : HtmlHelper.ValidationMessageValidCssClassName); if (!String.IsNullOrEmpty(validationMessage)) { builder.SetInnerText(validationMessage); } else if (modelError != null) { builder.SetInnerText(GetUserErrorMessageOrDefault(htmlHelper.ViewContext.HttpContext, modelError, modelState)); } if (formContext != null) { bool replaceValidationMessageContents = String.IsNullOrEmpty(validationMessage); if (htmlHelper.ViewContext.UnobtrusiveJavaScriptEnabled) { builder.MergeAttribute("data-valmsg-for", modelName); builder.MergeAttribute("data-valmsg-replace", replaceValidationMessageContents.ToString().ToLowerInvariant()); } else { FieldValidationMetadata fieldMetadata = ApplyFieldValidationMetadata(htmlHelper, modelMetadata, modelName); // rules will already have been written to the metadata object fieldMetadata.ReplaceValidationMessageContents = replaceValidationMessageContents; // only replace contents if no explicit message was specified // client validation always requires an ID builder.GenerateId(modelName + "_validationMessage"); fieldMetadata.ValidationMessageId = builder.Attributes["id"]; } } return(builder.ToMvcHtmlString(TagRenderMode.Normal)); }
protected override bool CanUpdateProperty(ModelMetadata propertyMetadata) { return(CanUpdatePropertyPublic(propertyMetadata)); }
public static IEnumerable <string> GetTypeNames(ModelMetadata modelMetadata, Type fieldType) { // Not returning type name here for IEnumerable<IFormFile> since we will be returning // a more specific name, IEnumerableOfIFormFileName. if (typeof(IEnumerable <IFormFile>) != fieldType) { yield return(fieldType.Name); } if (fieldType == typeof(string)) { // Nothing more to provide yield break; } else if (!modelMetadata.IsComplexType) { // IsEnum is false for the Enum class itself if (fieldType.IsEnum) { // Same as fieldType.BaseType.Name in this case yield return("Enum"); } else if (fieldType == typeof(DateTimeOffset)) { yield return("DateTime"); } yield return("String"); yield break; } else if (!fieldType.IsInterface) { var type = fieldType; while (true) { type = type.BaseType; if (type == null || type == typeof(object)) { break; } yield return(type.Name); } } if (typeof(IEnumerable).IsAssignableFrom(fieldType)) { if (typeof(IEnumerable <IFormFile>).IsAssignableFrom(fieldType)) { yield return(IEnumerableOfIFormFileName); // Specific name has already been returned, now return the generic name. if (typeof(IEnumerable <IFormFile>) == fieldType) { yield return(fieldType.Name); } } yield return("Collection"); } else if (typeof(IFormFile) != fieldType && typeof(IFormFile).IsAssignableFrom(fieldType)) { yield return(nameof(IFormFile)); } yield return("Object"); }
public MinLengthAdapter(ModelMetadata metadata, ControllerContext context, MinLengthAttribute attribute) : base(metadata, context, attribute) { Attribute.ErrorMessage = Validations.FieldMustBeWithMinLengthOf; }
public virtual void SetPropertyPublic(ControllerContext controllerContext, ExtensibleModelBindingContext bindingContext, ModelMetadata propertyMetadata, ComplexModelDtoResult dtoResult) { base.SetProperty(controllerContext, bindingContext, propertyMetadata, dtoResult); }
public static MvcHtmlString NLabelFor <TModel, TValue>(this HtmlHelper <TModel> htmlHelper, Expression <Func <TModel, TValue> > expression, object htmlattr, int col = 2, string helptext = null, string inputicon = null) { var name = ExpressionHelper.GetExpressionText(expression); var metadata = ModelMetadata.FromLambdaExpression(expression, htmlHelper.ViewData); string resolvedLabelText = metadata.DisplayName ?? metadata.PropertyName; var required = metadata.IsRequired; string coltab = (12 / col).ToString(); var borderClass = htmlHelper.NAddClassIfPropertyInError(expression, "border-danger"); TagBuilder outerdiv = new TagBuilder("div"); outerdiv.AddCssClass(string.Format("col-lg-{0}", coltab)); TagBuilder middlediv = new TagBuilder("div"); middlediv.AddCssClass("form-group"); middlediv.AddCssClass(name + "divClass"); TagBuilder labletag = new TagBuilder("label"); labletag.Attributes["style"] = "font-weight: bold; font-size: 120%;"; string labeltext = resolvedLabelText + (required == true ? " <span class='text-danger'>*</span>" : "") + (string.IsNullOrEmpty(helptext) == true ? "" : " <small><i>" + helptext + "</small></i>"); labletag.InnerHtml = labeltext; labletag.AddCssClass(borderClass.Replace("border", "text")); TagBuilder inputBoxdiv = new TagBuilder("div"); inputBoxdiv.AddCssClass("input-group"); TagBuilder validationBoxdiv = new TagBuilder("form-control-feedback"); validationBoxdiv.AddCssClass("form-text text-danger"); middlediv.InnerHtml = labletag.ToString(); if (!string.IsNullOrEmpty(inputicon)) { TagBuilder icondiv1 = new TagBuilder("div"); icondiv1.AddCssClass("input-group-prepend"); TagBuilder icondiv2 = new TagBuilder("div"); icondiv2.AddCssClass("input-group-text"); TagBuilder icondiv3 = new TagBuilder("i"); icondiv3.AddCssClass(inputicon); icondiv2.InnerHtml = icondiv3.ToString(); icondiv1.InnerHtml = icondiv2.ToString(); inputBoxdiv.InnerHtml = icondiv1.ToString(); } var routeValueDictionary = new System.Web.Routing.RouteValueDictionary(htmlattr); if (routeValueDictionary.Keys.Where(x => x.ToLower() == "class") != null && routeValueDictionary.Keys.Where(x => x.ToLower() == "class").Count() > 0) { var @class = routeValueDictionary.Keys.Where(x => x.ToLower() == "class").FirstOrDefault(); if (!string.IsNullOrEmpty(borderClass)) { routeValueDictionary[@class] = routeValueDictionary[@class].ToString().Replace(" " + borderClass, ""); routeValueDictionary[@class] += " " + borderClass; } } else { routeValueDictionary.Add("class", " " + borderClass); } inputBoxdiv.InnerHtml += htmlHelper.DisplayFor(expression, routeValueDictionary).ToString(); validationBoxdiv.InnerHtml = htmlHelper.ValidationMessageFor(expression, null, new { @class = "form-text text-danger" }).ToString(); middlediv.InnerHtml += inputBoxdiv.ToString(); middlediv.InnerHtml += validationBoxdiv.ToString(); outerdiv.InnerHtml = middlediv.ToString(); return(new MvcHtmlString(outerdiv.ToString())); }
public virtual bool CanUpdatePropertyPublic(ModelMetadata propertyMetadata) { return(base.CanUpdateProperty(propertyMetadata)); }
private string DummyErrorSelector(HttpActionContext actionContext, ModelMetadata modelMetadata, object incomingValue) { throw new NotImplementedException(); }
// Returns the generic type arguments for the model type if updatable, else null. // supportedInterfaceType: open type (like IList<>) of supported interface, must implement ICollection<> // newInstanceType: open type (like List<>) of object that will be created, must implement supportedInterfaceType public static Type[] GetTypeArgumentsForUpdatableGenericCollection( Type supportedInterfaceType, Type newInstanceType, ModelMetadata modelMetadata ) { /* * Check that we can extract proper type arguments from the model. */ if ( !modelMetadata.ModelType.IsGenericType || modelMetadata.ModelType.IsGenericTypeDefinition ) { // not a closed generic type return(null); } Type[] modelTypeArguments = modelMetadata.ModelType.GetGenericArguments(); if (modelTypeArguments.Length != supportedInterfaceType.GetGenericArguments().Length) { // wrong number of generic type arguments return(null); } /* * Is it possible just to change the reference rather than update the collection in-place? */ if (!modelMetadata.IsReadOnly) { Type closedNewInstanceType = newInstanceType.MakeGenericType(modelTypeArguments); if (modelMetadata.ModelType.IsAssignableFrom(closedNewInstanceType)) { return(modelTypeArguments); } } /* * At this point, we know we can't change the reference, so we need to verify that * the model instance can be updated in-place. */ Type closedSupportedInterfaceType = supportedInterfaceType.MakeGenericType( modelTypeArguments ); if (!closedSupportedInterfaceType.IsInstanceOfType(modelMetadata.Model)) { return(null); // not instance of correct interface } Type closedCollectionType = TypeHelpers.ExtractGenericInterface( closedSupportedInterfaceType, typeof(ICollection <>) ); bool collectionInstanceIsReadOnly = (bool)closedCollectionType .GetProperty("IsReadOnly") .GetValue(modelMetadata.Model, null); if (collectionInstanceIsReadOnly) { return(null); } else { return(modelTypeArguments); } }
private IReadOnlyList <IClientModelValidator> GetValidatorsFromEntry(CacheEntry entry, ModelMetadata metadata, IClientModelValidatorProvider validationProvider) { if (entry.Validators != null) { return(entry.Validators); } Debug.Assert(entry.Items != null); var items = new List <ClientValidatorItem>(entry.Items.Count); for (var i = 0; i < entry.Items.Count; i++) { var item = entry.Items[i]; if (item.IsReusable) { items.Add(item); } else { items.Add(new ClientValidatorItem(item.ValidatorMetadata)); } } ExecuteProvider(validationProvider, metadata, items); return(ExtractValidators(items)); }
/// <summary> /// Initializes a new instance of the <see cref="LocalizedDataTypeAttributeAdapter"/> class. /// </summary> /// <param name="metadata">The model metadata.</param> /// <param name="context">The controller context.</param> /// <param name="attribute">The <see cref="DataTypeAttribute"/> attribute.</param> /// <param name="ruleName">The name of the client validation rule.</param> public LocalizedDataTypeAttributeAdapter(ModelMetadata metadata, ControllerContext context, DataTypeAttribute attribute, string ruleName) : base(metadata, context, attribute) { mRuleName = ruleName; }
private void ExecuteProvider(IClientModelValidatorProvider validatorProvider, ModelMetadata metadata, List <ClientValidatorItem> items) { var context = new ClientValidatorProviderContext(metadata, items); validatorProvider.CreateValidators(context); }
protected override void OnMetadataProcess(ModelMetadata meta, string name, ViewDataDictionary viewData, ControllerContext context) { base.OnMetadataProcess(meta, name, viewData, context); this.FieldLabel = ""; }