private void UpdatePlaceholder(DisplayMetadataProviderContext context)
{
// Special cases
if (context.Attributes.OfType <DisplayAttribute>().Any(x => !string.IsNullOrWhiteSpace(x.Prompt)))
{
return;
}
// Try get resource key name
var keyName = this.resourceManager.GetResourceKeyName(context.Key, "Placeholder");
if (keyName != null)
{
context.DisplayMetadata.Placeholder = () => this.resourceManager.GetString(keyName);
}
}
public void GetDisplayMetadata(DisplayMetadataProviderContext context)
{
if (context.Key.ModelType == typeof(LargeModelWithValidation))
{
context.DisplayMetadata.AdditionalValues.Add("key1", _guid);
context.DisplayMetadata.AdditionalValues.Add("key2", "value2");
}
var displayAttribute = context.Attributes.OfType <DisplayAttribute>().FirstOrDefault();
var groupName = displayAttribute?.GroupName;
if (!string.IsNullOrEmpty(groupName))
{
context.DisplayMetadata.AdditionalValues[GroupNameKey] = groupName;
}
}
/// <summary>
/// Sets the values for properties of isplay metadata
/// </summary>
/// <param name="context">Display metadata provider context</param>
public void CreateDisplayMetadata(DisplayMetadataProviderContext context)
{
//get all custom attributes
var additionalValues = context.Attributes.OfType <IModelAttribute>().ToList();
//and try add them as additional values of metadata
foreach (var additionalValue in additionalValues)
{
if (context.DisplayMetadata.AdditionalValues.ContainsKey(additionalValue.Name))
{
throw new SmiException("There is already an attribute with the name '{0}' on this model", additionalValue.Name);
}
context.DisplayMetadata.AdditionalValues.Add(additionalValue.Name, additionalValue);
}
}
public void TransformMetadata(DisplayMetadataProviderContext context)
{
if (!_displayConventionsDisableSettings.HtmlByName)
{
var propertyAttributes = context.Attributes;
var modelMetadata = context.DisplayMetadata;
var propertyName = context.Key.Name;
if (!string.IsNullOrEmpty(propertyName) &&
string.IsNullOrEmpty(modelMetadata.DataTypeName) &&
TextAreaFieldNames.Any(propertyName.ToLower().Contains))
{
modelMetadata.DataTypeName = "Html";
}
}
}
public void CreateDisplayMetadata(DisplayMetadataProviderContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
var viewConfig = ViewConfigureAttribute.GetAttribute(context.Key.ContainerType);
var displayMetadata = context.DisplayMetadata;
if (viewConfig != null && context.Key.Name.IsNotNullAndWhiteSpace())
{
var descriptor = viewConfig.GetViewPortDescriptor(context.Key.Name);
if (descriptor != null)
{
displayMetadata.AdditionalValues.Add("ViewPortDescriptor", descriptor);
if (displayMetadata.DisplayName == null)
{
displayMetadata.DisplayName = () =>
{
var attr = ViewConfigureAttribute.GetAttribute(context.Key.ContainerType);
attr.InitDisplayName();
var descriptop = attr.GetViewPortDescriptor(context.Key.Name);
return(descriptop.DisplayName);
};
}
displayMetadata.Order = descriptor.OrderIndex;
displayMetadata.TemplateHint = descriptor.TemplateName;
displayMetadata.ShowForDisplay = descriptor.IsShowForDisplay;
displayMetadata.ShowForEdit = descriptor.IsShowForEdit;
if (descriptor.IsHidden)
{
displayMetadata.TemplateHint = "HiddenInput";
displayMetadata.ShowForDisplay = false;
displayMetadata.ShowForEdit = false;
}
if (descriptor.IsIgnore)
{
displayMetadata.ShowForDisplay = false;
displayMetadata.ShowForEdit = false;
displayMetadata.TemplateHint = "Ignore";
}
}
}
}
public void CreateDisplayMetadata(DisplayMetadataProviderContext context)
{
if (context.PropertyAttributes != null)
{
foreach (object propAttr in context.PropertyAttributes)
{
UIHintAttribute uiHintAttribute = propAttr as UIHintAttribute;
if (uiHintAttribute != null && uiHintAttribute.ControlParameters != null)
{
foreach (var item in uiHintAttribute.ControlParameters)
{
context.DisplayMetadata.AdditionalValues.Add(item.Key, item.Value);
}
}
}
}
}
public void CreateDisplayMetadata(DisplayMetadataProviderContext context)
{
if (context.Key.Name == nameof(NonHumanizedViewModel.FieldWithSimpleDisplayPropertyFromAnotherMetadataProvider))
{
context.DisplayMetadata.SimpleDisplayProperty = DisplayName;
}
if (context.Key.Name == nameof(NonHumanizedViewModel.FieldWithDisplayNameFromAnotherMetadataProvider))
{
context.DisplayMetadata.DisplayName = () => DisplayName;
}
if (context.Key.Name == nameof(NonHumanizedViewModel.FieldWithNullDisplayNameFromAnotherMetadataProvider))
{
context.DisplayMetadata.DisplayName = () => null;
}
}
public void CreateDisplayMetadata(DisplayMetadataProviderContext context)
{
var modelMetadata = context.DisplayMetadata;
var propertyName = context.Key.Name;
if (!string.IsNullOrWhiteSpace(propertyName))
{
var localizedPropertyName = ModelsResource.ResourceManager.GetString(propertyName);
if (string.IsNullOrWhiteSpace(localizedPropertyName))
{
Trace.WriteLine("Property name" + propertyName + " not found in localized resource file.");
localizedPropertyName = propertyName;
}
modelMetadata.DisplayName = () => localizedPropertyName;
}
}
/// <inheritdoc />
public void CreateDisplayMetadata([NotNull] DisplayMetadataProviderContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (IsController(context.Key.ContainerType) || !context.Attributes.OfType <FromQueryAttribute>().Any())
{
return;
}
if (context.DisplayMetadata.DisplayName == null)
{
context.DisplayMetadata.DisplayName = () => context.Key.Name?.ConvertToKebabCase();
}
}
public void CreateDisplayMetadata(DisplayMetadataProviderContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (context.Key.ContainerType != null && !context.Key.ContainerType.IsValueType)
{
var viewConfig = ServiceLocator.GetViewConfigure(context.Key.ContainerType);
var displayMetadata = context.DisplayMetadata;
if (viewConfig != null && context.Key.Name.IsNotNullAndWhiteSpace())
{
var descriptor = viewConfig.GetViewPortDescriptor(context.Key.Name);
if (descriptor != null)
{
displayMetadata.AdditionalValues.Add("ViewPortDescriptor", descriptor);
if (displayMetadata.DisplayName == null)
{
displayMetadata.DisplayName = () => descriptor.DisplayName;
}
displayMetadata.Order = descriptor.OrderIndex;
displayMetadata.TemplateHint = descriptor.TemplateName;
displayMetadata.ShowForDisplay = descriptor.IsShowForDisplay;
displayMetadata.ShowForEdit = descriptor.IsShowForEdit;
if (descriptor.IsHidden)
{
displayMetadata.TemplateHint = "HiddenInput";
displayMetadata.ShowForDisplay = false;
displayMetadata.ShowForEdit = false;
}
if (descriptor.IsIgnore)
{
displayMetadata.ShowForDisplay = false;
displayMetadata.ShowForEdit = false;
displayMetadata.TemplateHint = "Ignore";
}
if (descriptor.IsHideSurroundingHtml)
{
displayMetadata.HideSurroundingHtml = true;
}
}
}
}
}
public void CreateDisplayMetadata(DisplayMetadataProviderContext context)
{
var propertyAttributes = context.Attributes;
var displayMetadata = context.DisplayMetadata;
var propertyName = context.Key.Name;
if (IsTransformRequired(propertyName, displayMetadata, propertyAttributes))
{
displayMetadata.DisplayName = () => Transform(propertyName);
}
var attributes = propertyAttributes.OfType <IDisplayMetadataProviderAttribute>();
foreach (var attribute in attributes)
{
attribute.SetDisplayMetadata(context.DisplayMetadata);
}
}
public void Decorate(object attribute, DisplayMetadataProviderContext context)
{
if (attribute == null)
{
throw new ArgumentNullException(nameof(attribute));
}
if (!(attribute is MaxLengthAttribute))
{
throw new ArgumentException("Attribute type is not MaxLengthAttribute", nameof(attribute));
}
var maxLengthttribtue = (MaxLengthAttribute)attribute;
var modelMetaData = context.DisplayMetadata;
modelMetaData.AddAdditionalValueWithValidationMessage("Maxlength", maxLengthttribtue.Length, maxLengthttribtue);
}
private string GetNestedModelTypeName(DisplayMetadataProviderContext context)
{
var singularType = TypeHelper.GetCollectionTypeOrNull(context.Key.ModelType);
if (singularType == null)
{
throw GetIncorrectTypeException(context);
}
if (!typeof(INestedDataModel).IsAssignableFrom(singularType))
{
throw GetIncorrectTypeException(context);
}
var nestedModelName = StringHelper.RemoveSuffix(singularType.Name, "DataModel", StringComparison.OrdinalIgnoreCase);
return(nestedModelName);
}
public void Process(DisplayMetadataProviderContext context)
{
MetaDataAttributePlacementValidator.ValidatePropertyType(this, context, typeof(int), typeof(int?));
var modelMetaData = context.DisplayMetadata;
modelMetaData
.AddAdditionalValueIfNotEmpty("Tags", Tags)
.AddAdditionalValueIfNotEmpty("Width", Width)
.AddAdditionalValueIfNotEmpty("Height", Height)
.AddAdditionalValueIfNotEmpty("MinWidth", MinWidth)
.AddAdditionalValueIfNotEmpty("MinHeight", MinHeight)
.AddAdditionalValueIfNotEmpty("PreviewWidth", PreviewWidth)
.AddAdditionalValueIfNotEmpty("PreviewHeight", PreviewHeight)
;
modelMetaData.TemplateHint = "ImageAsset";
}
public void TransformMetadata(DisplayMetadataProviderContext context)
{
if (!_displayConventionsDisableSettings.TextAreaByName)
{
var propertyAttributes = context.Attributes;
var modelMetadata = context.DisplayMetadata;
var propertyName = context.Key.Name;
if (!string.IsNullOrEmpty(propertyName) &&
string.IsNullOrEmpty(modelMetadata.DataTypeName) &&
TextAreaFieldNames.Any(propertyName.ToLower().Contains))
{
modelMetadata.DataTypeName = "MultilineText";
modelMetadata.AdditionalValues["MultilineTextRows"] = 7;
modelMetadata.AdditionalValues["MultilineTextHTML"] = false;
}
}
}
public void CreateDisplayMetadata_EnumNamesAndValues_ReflectsModelType(
Type type,
IReadOnlyDictionary <string, string> expectedDictionary)
{
// Arrange
var provider = new DataAnnotationsMetadataProvider();
var key = ModelMetadataIdentity.ForType(type);
var attributes = new object[0];
var context = new DisplayMetadataProviderContext(key, new ModelAttributes(attributes));
// Act
provider.CreateDisplayMetadata(context);
// Assert
// This assertion does *not* require entry orders to match.
Assert.Equal(expectedDictionary, context.DisplayMetadata.EnumNamesAndValues);
}
public void CreateDisplayMetadata_FindsDisplayFormat_FromDataType()
{
// Arrange
var provider = new DataAnnotationsMetadataProvider();
var dataType = new DataTypeAttribute(DataType.Currency);
var displayFormat = dataType.DisplayFormat; // Non-null for DataType.Currency.
var attributes = new[] { dataType, };
var key = ModelMetadataIdentity.ForType(typeof(string));
var context = new DisplayMetadataProviderContext(key, new ModelAttributes(attributes));
// Act
provider.CreateDisplayMetadata(context);
// Assert
Assert.Same(displayFormat.DataFormatString, context.DisplayMetadata.DisplayFormatString);
}
public void CreateDisplayMetadata(DisplayMetadataProviderContext context)
{
var displayMetadata = context.DisplayMetadata;
if (displayMetadata.DisplayName != null)
{
var displayName = displayMetadata.DisplayName();
return;
}
var attributes = context.Attributes;
if (attributes.OfType <DisplayAttribute>().Any() ||
attributes.OfType <DisplayNameAttribute>().Any())
{
return;
}
if (context.Key.Name.IsNullOrWhiteSpace())
{
return;
}
if (_localizationOptions.Value.Value.DataAnnotationLocalizerProvider == null)
{
return;
}
var containerType = context.Key.ContainerType ?? context.Key.ModelType;
var localizer = _localizationOptions.Value.Value.DataAnnotationLocalizerProvider(containerType, _stringLocalizerFactory.Value);
displayMetadata.DisplayName = () =>
{
var localizedString = localizer[PropertyLocalizationKeyPrefix + context.Key.Name];
if (localizedString.ResourceNotFound)
{
localizedString = localizer[context.Key.Name];
}
return(localizedString);
};
}
public void CreateDisplayMetadata_SimpleAttributes(
object attribute,
Func <DisplayMetadata, object> accessor,
object expected)
{
// Arrange
var provider = new DataAnnotationsMetadataProvider();
var key = ModelMetadataIdentity.ForType(typeof(string));
var context = new DisplayMetadataProviderContext(key, new ModelAttributes(new object[] { attribute }));
// Act
provider.CreateDisplayMetadata(context);
// Assert
var value = accessor(context.DisplayMetadata);
Assert.Equal(expected, value);
}
public void TransformMetadata(DisplayMetadataProviderContext context)
{
var propertyAttributes = context.Attributes;
var modelMetadata = context.DisplayMetadata;
var propertyName = context.Key.Name;
modelMetadata.AdditionalValues["ShowForGrid"] = ShowForGrid;
modelMetadata.AdditionalValues["LinkToCollectionInGrid"] = LinkToCollectionInGrid;
modelMetadata.AdditionalValues["AllowSortForGrid"] = AllowSortForGrid;
modelMetadata.ShowForEdit = ShowForEdit;
if (!_showForCreateSet)
{
_showForCreate = ShowForEdit;
}
modelMetadata.AdditionalValues["ShowForCreate"] = _showForCreate;
modelMetadata.ShowForDisplay = ShowForDisplay;
}
public void Decorate(object attribute, DisplayMetadataProviderContext context)
{
if (attribute == null)
{
throw new ArgumentNullException(nameof(attribute));
}
if (!(attribute is RangeAttribute))
{
throw new ArgumentException("Attribute type is not RangeAttribute", nameof(attribute));
}
var rangeLengthttribtue = (RangeAttribute)attribute;
string minAttribute = null;
string maxAttribute = null;
if (rangeLengthttribtue.OperandType == typeof(string))
{
minAttribute = "Minlength";
maxAttribute = "Maxlength";
}
else
{
minAttribute = "Min";
maxAttribute = "Max";
}
if (minAttribute != null)
{
var modelMetaData = context.DisplayMetadata;
if (rangeLengthttribtue.Minimum != null)
{
modelMetaData.AddAdditionalValueWithValidationMessage(minAttribute, rangeLengthttribtue.Minimum, rangeLengthttribtue);
}
if (rangeLengthttribtue.Maximum != null)
{
modelMetaData.AddAdditionalValueWithValidationMessage(maxAttribute, rangeLengthttribtue.Maximum, rangeLengthttribtue);
}
}
}
private string GetNestedModelTypeName(DisplayMetadataProviderContext context)
{
var propertyModelType = context.Key.ModelType;
if (!propertyModelType.IsGenericType)
{
throw new Exception(GetBadTypeExceptionMessage());
}
var genericParameters = propertyModelType.GetGenericArguments();
if (genericParameters?.Length != 1 || !typeof(INestedDataModel).IsAssignableFrom(genericParameters.Single()))
{
throw new Exception(GetBadTypeExceptionMessage());
}
var nestedModelName = StringHelper.RemoveSuffix(genericParameters.Single().Name, "DataModel", StringComparison.OrdinalIgnoreCase);
return(nestedModelName);
}
public void CreateDisplayMetadata(DisplayMetadataProviderContext context)
{
switch (context.Key.MetadataKind)
{
case ModelMetadataKind.Property:
if (context.DisplayMetadata.DisplayName == null)
{
ResourceKey displayKey = _resourceMapper.GetKey(context.Key.ContainerType.Namespace, context.Key.ContainerType.Name, context.Key.Name, "DisplayName");
if (displayKey != null)
{
IStringLocalizer localizer = _stringLocalizerFactory.Create(displayKey.ResourceName, displayKey.ResourceLocation);
context.DisplayMetadata.DisplayName = () => localizer.GetString(displayKey.KeyName);
}
}
break;
case ModelMetadataKind.Type:
break;
}
}
private string GetNestedModelTypeName(DisplayMetadataProviderContext context)
{
var propertyModelType = context.Key.ModelType;
if (!typeof(IEnumerable).IsAssignableFrom(propertyModelType))
{
throw GetIncorrectTypeException(context);
}
Type singularType = null;
if (propertyModelType.IsGenericType)
{
var genericParameters = propertyModelType.GetGenericArguments();
if (genericParameters?.Length != 1)
{
throw GetIncorrectTypeException(context);
}
singularType = genericParameters.Single();
}
else if (propertyModelType.IsArray)
{
singularType = propertyModelType.GetElementType();
}
if (singularType == null)
{
throw GetIncorrectTypeException(context);
}
if (!typeof(INestedDataModel).IsAssignableFrom(singularType))
{
throw GetIncorrectTypeException(context);
}
var nestedModelName = StringHelper.RemoveSuffix(singularType.Name, "DataModel", StringComparison.OrdinalIgnoreCase);
return(nestedModelName);
}
public void CreateDisplayMetadata(DisplayMetadataProviderContext context)
{
if (context.Attributes.Any(a => a.GetType() == typeof(HideForEditAttribute)))
{
context.DisplayMetadata.ShowForEdit = false;
}
if (context.Attributes.Any(a => a.GetType() == typeof(HideForDisplayAttribute)))
{
context.DisplayMetadata.ShowForDisplay = false;
}
if (context.Attributes.Any(a => a.GetType() == typeof(LayoutAttribute)))
{
var attr = context.Attributes.FirstOrDefault(a => a.GetType() == typeof(LayoutAttribute)) as LayoutAttribute;
if (attr != null)
{
context.DisplayMetadata.DataTypeName = "Layout";
context.DisplayMetadata.AdditionalValues.Add("layoutName", attr.name);
}
}
}
public void CreateDisplayMetadata(DisplayMetadataProviderContext context)
{
var mt = context.Key.ModelType;
if (mt.IsArray && mt.GetArrayRank() == 2)
{
context.DisplayMetadata.TemplateHint = "Matrix";
}
else if (mt.GetInterfaces().Any(t => t.IsGenericType && t.GetGenericTypeDefinition() == typeof(ICollection <>)))
{
var itemType = mt.IsArray ? mt.GetElementType() : (mt.IsGenericType ? mt.GetGenericArguments()[0] : null);
context.DisplayMetadata.TemplateHint =
itemType != null && itemType.GetInterfaces().Any(t => t.IsGenericType && t.GetGenericTypeDefinition() == typeof(ICollection <>)) ? "NestedCollection" : "Collection";
}
else if (typeof(ICollection).IsAssignableFrom(mt))
{
context.DisplayMetadata.TemplateHint = "Collection";
}
}
public void Decorate(object attribute, DisplayMetadataProviderContext context)
{
if (attribute == null)
{
throw new ArgumentNullException(nameof(attribute));
}
if (!(attribute is CompareAttribute))
{
throw new ArgumentException("Attribute type is not CompareAttribute", nameof(attribute));
}
var compareAttribtue = (CompareAttribute)attribute;
var otherProperty = compareAttribtue.OtherProperty;
var valAttribute = compareAttribtue;
var modelMetaData = context.DisplayMetadata;
modelMetaData.AddAdditionalValueWithValidationMessage("Match", otherProperty, valAttribute);
}
public void CreateDisplayMetadata(DisplayMetadataProviderContext context)
{
var propertyAttributes = context.Attributes;
var modelMetadata = context.DisplayMetadata;
var propertyName = context.Key.Name;
if (IsTransformRequired(propertyName, modelMetadata, propertyAttributes))
{
modelMetadata.DisplayName = () =>
{
switch (propertyName)
{
case "ActiveYn":
return("Is Active");
default:
return(propertyName.Humanize().Transform(To.TitleCase));
}
};
}
}
public void CreateDisplayMetadata_FindsDisplayFormat_OverridingDataType()
{
// Arrange
var provider = new DataAnnotationsMetadataProvider();
var dataType = new DataTypeAttribute(DataType.Time); // Has a non-null DisplayFormat.
var displayFormat = new DisplayFormatAttribute() // But these values override the values from DataType
{
DataFormatString = "Cool {0}",
};
var attributes = new Attribute[] { dataType, displayFormat, };
var key = ModelMetadataIdentity.ForType(typeof(string));
var context = new DisplayMetadataProviderContext(key, new ModelAttributes(attributes));
// Act
provider.CreateDisplayMetadata(context);
// Assert
Assert.Same(displayFormat.DataFormatString, context.DisplayMetadata.DisplayFormatString);
}
public void TransformMetadata(DisplayMetadataProviderContext context)
{
var propertyAttributes = context.Attributes;
var modelMetadata = context.DisplayMetadata;
var propertyName = context.Key.Name;
RouteValueDictionary routeValueDictionary = null;
if (modelMetadata.AdditionalValues.ContainsKey("RouteValueDictionary"))
{
routeValueDictionary = (RouteValueDictionary)modelMetadata.AdditionalValues["RouteValueDictionary"];
}
if (routeValueDictionary == null)
{
routeValueDictionary = new RouteValueDictionary();
}
routeValueDictionary.Add(Key, Value);
modelMetadata.AdditionalValues["RouteValueDictionary"] = routeValueDictionary;
}
