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 = "";
}
