private static int GetColumnOrder(MetaColumn column)
{
DisplayAttribute displayAttribute = column.Metadata.DisplayAttribute;
if ((displayAttribute != null) && displayAttribute.GetOrder().HasValue)
{
return(displayAttribute.GetOrder().Value);
}
return(0x2710);
}
public void Order_Get_NotSet_ThrowsInvalidOperationException()
{
DisplayAttribute attribute = new DisplayAttribute();
Assert.Throws <InvalidOperationException>(() => attribute.Order);
Assert.Null(attribute.GetOrder());
}
public VxSelectItem(DisplayAttribute displayAttribute, Enum value)
{
this.Order = displayAttribute.GetOrder() ?? 0;
this.Label = displayAttribute.GetName();
this.Key = value.ToString();
this.Description = displayAttribute.GetDescription();
}
public static List <EnumEntry <TEnum, TRaw> > ConvertEnumToEntryList <TEnum, TRaw>(IEnumerable <TEnum> excludes = null, Func <TRaw, string, string> func = null)
{
var enumType = typeof(TEnum);
var list = new List <EnumEntry <TEnum, TRaw> >();
if (enumType.IsEnum == false)
{
return(list);
}
//
TEnum[] aryEnum = Enum.GetValues(enumType) as TEnum[];
if (aryEnum == null)
{
return(list);
}
var lstEnums = aryEnum;
if (excludes != null)
{
lstEnums = aryEnum.Except(excludes).ToArray();
}
//
foreach (var item in lstEnums)
{
string strEnum = item.ToString();
TRaw rawVal = (TRaw)Convert.ChangeType(item, typeof(TRaw));
Enum objEnum = Enum.Parse(enumType, strEnum) as Enum;
var entry = new EnumEntry <TEnum, TRaw>(item, rawVal, strEnum)
{
Description = GetEnumDescription(objEnum)
};
//entry.DisplayName = GetEnumDisplay(objEnum);
//entry.DisplayDesc = GetEnumDisplay(objEnum, 1);
var disObj = GetEnumDisplayAttributs(objEnum);
DisplayAttribute displayAttr = null;
if (disObj != null)
{
displayAttr = disObj.FirstOrDefault();
}
if (displayAttr != null)
{
entry.DisplayName = displayAttr.GetName();
entry.DisplayShortName = displayAttr.GetShortName();
entry.DisplayDesc = displayAttr.GetDescription();
entry.DisplayOrder = displayAttr.GetOrder() ?? 0;
}
if (func != null)
{
entry.CustomName = func(rawVal, "");
}
list.Add(entry);
}
list = list.OrderBy(l => l.RawValue).ToList();
return(list);
}
public void Order_Get_Set(int value)
{
DisplayAttribute attribute = new DisplayAttribute();
attribute.Order = value;
Assert.Equal(value, attribute.Order);
Assert.Equal(value, attribute.GetOrder());
}
public static int GetOrder <T>(this T source) where T : struct, IComparable, IConvertible, IFormattable
{
DisplayAttribute attribute = GetDisplayAttribute(source);
int?order = attribute?.GetOrder();
return(order != null && order >= 0
? (int)order
: int.MaxValue);
}
public void DisplayAttribute_Order_Can_Be_Set_And_Retrieved()
{
DisplayAttribute attr = new DisplayAttribute {
Order = 1
};
Assert.AreEqual(1, attr.Order, "The Order getter should return what was set");
Assert.AreEqual(1, attr.GetOrder().Value, "The GetOrder method should return what was set for the Order property");
}
public void DisplayAttribute_AutoGenerateFilter_Is_Optional()
{
DisplayAttribute attr = new DisplayAttribute();
ExceptionHelper.ExpectException <InvalidOperationException>(delegate() {
attr.AutoGenerateFilter.ToString();
}, String.Format(CultureInfo.CurrentCulture, Resources.DataAnnotationsResources.DisplayAttribute_PropertyNotSet, "AutoGenerateFilter", "GetAutoGenerateFilter"));
Assert.IsNull(attr.GetOrder(), "GetAutoGenerateFilter should be null by default");
}
public void DisplayAttribute_Order_Accepts_Negative_Values()
{
DisplayAttribute attr = new DisplayAttribute();
attr.Order = Int32.MinValue;
Assert.AreEqual(Int32.MinValue, attr.GetOrder());
attr.Order = -1;
Assert.AreEqual(-1, attr.GetOrder());
attr.Order = 0;
Assert.AreEqual(0, attr.GetOrder());
attr.Order = 1;
Assert.AreEqual(1, attr.GetOrder());
attr.Order = Int32.MaxValue;
Assert.AreEqual(Int32.MaxValue, attr.GetOrder());
}
/// <summary>
/// Localizes the display attribute metadata.
/// </summary>
/// <param name="display">The display attribute.</param>
public virtual void LocalizeDisplayAttribute(DisplayAttribute display, ModelMetadata metadata)
{
if (display == null)
{
return;
}
metadata.DisplayName = GetTranslation(display.Name);
metadata.Description = GetTranslation(display.Description);
metadata.ShortDisplayName = GetTranslation(display.ShortName);
metadata.Watermark = GetTranslation(display.Prompt);
metadata.Order = display.GetOrder() ?? ModelMetadata.DefaultOrder;
}
private static IEnumerable <PropertyInfo> SortAndFilterProperties(Type type, bool isList)
{
if (type.Module.ScopeName == "CommonLanguageRuntimeLibrary")
{
return(null);
}
SortedDictionary <int, PropertyInfo> orderedProperties = new SortedDictionary <int, PropertyInfo>();
List <PropertyInfo> unorderedProperties = new List <PropertyInfo>();
foreach (PropertyInfo property in type.GetProperties())
{
DisplayAttribute displayAttribute = property.GetCustomAttribute <DisplayAttribute>();
if (displayAttribute != null)
{
if (isList)
{
if (displayAttribute.GetListOrder().HasValue&& !displayAttribute.ListOmit)
{
orderedProperties.Add(displayAttribute.ListOrder, property);
}
else if (!displayAttribute.ListOmit)
{
unorderedProperties.Add(property);
}
}
else
{
if (displayAttribute.GetOrder().HasValue&& !displayAttribute.Omit)
{
orderedProperties.Add(displayAttribute.Order, property);
}
else if (!displayAttribute.Omit)
{
unorderedProperties.Add(property);
}
}
continue;
}
unorderedProperties.Add(property);
}
return(orderedProperties.Select(c => c.Value).Concat(unorderedProperties));
}
/// <summary>
/// Set the metadata of display.
/// </summary>
/// <param name="display">Display attribute.</param>
protected virtual void SetDisplay(DisplayAttribute display)
{
if (display == null)
{
throw new ArgumentNullException("display");
}
if (display.Name == null)
{
Name = ClrName;
}
else
{
Name = display.Name;
}
ShortName = display.ShortName == null ? Name : display.ShortName;
Description = display.Description;
Order = display.GetOrder().HasValue ? display.Order : 0;
}
internal static IEnumerable <Tuple <PropertyInfo, object> > GetDisplayAttributePropertyValuePairs(Attribute attributeBase)
{
DisplayAttribute attribute = (DisplayAttribute)attributeBase;
List <Tuple <PropertyInfo, object> > result = new List <Tuple <PropertyInfo, object> >();
if (attribute.GetOrder() != null)
{
result.Add(GetPropertyValuePair(attribute, x => x.Order));
}
if (attribute.GetAutoGenerateField() != null)
{
result.Add(GetPropertyValuePair(attribute, x => x.AutoGenerateField));
}
result.Add(GetPropertyValuePair(attribute, x => x.Name));
result.Add(GetPropertyValuePair(attribute, x => x.ShortName));
result.Add(GetPropertyValuePair(attribute, x => x.Description));
return(result);
}
public void OrderAndAutoGenerateProperties_Success()
{
var display = new DisplayAttribute()
{
Order = 1,
AutoGenerateField = true,
AutoGenerateFilter = false
};
Assert.AreEqual(1, display.Order);
Assert.AreEqual(1, display.GetOrder());
Assert.AreEqual(true, display.AutoGenerateField);
Assert.AreEqual(true, display.GetAutoGenerateField());
Assert.AreEqual(false, display.AutoGenerateFilter);
Assert.AreEqual(false, display.GetAutoGenerateFilter());
}
/// <summary>
/// 创建实体属性元数据。
/// </summary>
/// <param name="property"></param>
/// <param name="attributes"></param>
/// <returns></returns>
protected virtual IEntityPropertyMetadata CreateEntityPropertyMetadata(PropertyInfo property,
IEnumerable <Attribute> attributes)
{
var result = new EntityPropertyMetadata(property)
{
IsSearcher = attributes.Any(x => x is SearcherAttribute),
IsRequired = attributes.Any(x => x is RequiredAttribute),
IsKey = attributes.Any(x => x is KeyAttribute),
DataType = EntityExtensions.GetDataType(property)
};
DisplayAttribute display = attributes.OfType <DisplayAttribute>().FirstOrDefault();
string name = null;
if (display != null)
{
result.Description = display.GetDescription();
result.Order = display.GetOrder() ?? ModelMetadata.DefaultOrder;
result.GroupName = display.GetGroupName();
name = display.GetName();
}
if (name != null)
{
result.Name = name;
}
else
{
DisplayNameAttribute displayNameAttribute = attributes.OfType <DisplayNameAttribute>().FirstOrDefault();
if (displayNameAttribute != null)
{
result.Name = displayNameAttribute.DisplayName;
}
}
if (string.IsNullOrEmpty(result.Name))
{
result.Name = property.Name;
}
return(result);
}
public static DisplayAttribute Copy(this DisplayAttribute srcAttribute)
{
if (srcAttribute == null)
{
return(null);
}
var copy = new DisplayAttribute
{
Name = srcAttribute.Name,
GroupName = srcAttribute.GroupName,
Description = srcAttribute.Description,
ResourceType = srcAttribute.ResourceType,
ShortName = srcAttribute.ShortName,
Prompt = srcAttribute.Prompt
};
var order = srcAttribute.GetOrder();
if (order != null)
{
copy.Order = order.Value;
}
var autoGenerateField = srcAttribute.GetAutoGenerateField();
if (autoGenerateField != null)
{
copy.AutoGenerateField = autoGenerateField.Value;
}
var autoGenerateFilter = srcAttribute.GetAutoGenerateFilter();
if (autoGenerateFilter != null)
{
copy.AutoGenerateFilter = autoGenerateFilter.Value;
}
return(copy);
}
public static DisplayAttribute Copy(this DisplayAttribute attribute)
{
if (attribute == null)
{
return(null);
}
// DisplayAttribute is sealed, so it's safe to copy.
var copy = new DisplayAttribute
{
Name = attribute.Name,
GroupName = attribute.GroupName,
Description = attribute.Description,
ResourceType = attribute.ResourceType,
ShortName = attribute.ShortName,
Prompt = attribute.Prompt,
Order = attribute.GetOrder() ?? 10000,
AutoGenerateField = attribute.GetAutoGenerateField() ?? true,
AutoGenerateFilter = attribute.GetAutoGenerateFilter() ?? true
};
return(copy);
}
public int?GetOrder()
{
return(_displayAttribute.GetOrder());
}
//public override IEnumerable<ModelMetadata> GetMetadataForProperties(object container, Type containerType)
//{
// return base.GetMetadataForProperties(container, containerType);
//}
//public override ModelMetadata GetMetadataForType(Func<object> modelAccessor, Type modelType)
//{
// return base.GetMetadataForType(modelAccessor, modelType);
//}
//public override ModelMetadata GetMetadataForProperty(Func<object> modelAccessor, Type containerType, string propertyName)
//{
// return base.GetMetadataForProperty(modelAccessor, containerType, propertyName);
//}
//protected override ModelMetadata GetMetadataForProperty(Func<object> modelAccessor, Type containerType, System.ComponentModel.PropertyDescriptor propertyDescriptor)
//{
// return base.GetMetadataForProperty(modelAccessor, containerType, propertyDescriptor);
//}
protected override ModelMetadata CreateMetadata(IEnumerable <Attribute> attributes, Type containerType, Func <object> modelAccessor, Type modelType, string propertyName)
{
//Reflected from base class
List <Attribute> list = new List <Attribute>(attributes);
DisplayColumnAttribute displayColumnAttribute = Enumerable.FirstOrDefault <DisplayColumnAttribute>(Enumerable.OfType <DisplayColumnAttribute>((IEnumerable)list));
DataAnnotationsModelMetadata annotationsModelMetadata = null;
//brl additions
//if this is a BOV backed object
if (containerType != null && Attribute.IsDefined(containerType, typeof(DryLogicObjectAttribute)) && propertyName != "OI")
{
Object container = null;
ObjectInstance oi = null;
//By having this code here instead of in GetMetadataForProperty, some of the normal features like ui hint will work
if (modelAccessor != null)
{
var rootModelType = modelAccessor.Target.GetType();
var field = rootModelType.GetField("container");
if (field != null)
{
container = field.GetValue(modelAccessor.Target);
//if we don't have a reference to the container yet...
if (container.GetType() != containerType)
{
//...then try to break down the expression to get it
//get the expression as text, ie "model.EmployeeViewModel.MyEmployee" and split it
var expressionParts = ((LambdaExpression)rootModelType.GetField("expression").GetValue(modelAccessor.Target)).Body.ToString().Split('.');
//var expressionParts = new string[] { };
//loop thru the parts in the middle
for (int i = 1; i < expressionParts.Length - 1; i++)
{
container = container.GetType().GetProperty(expressionParts[i]).GetValue(container);
}
}
//could use an attribute instead to identify the object instance
oi = ObjectInstance.GetObjectInstance(container);
if (oi != null)//not really sure how this woudl fail at this point
{
annotationsModelMetadata = new PropertyValueMetadata(this, containerType, modelAccessor, modelType, propertyName, displayColumnAttribute);
annotationsModelMetadata.Container = container;
//internally, setting model wipes out modelAccessor (caching of sorts)
annotationsModelMetadata.Model = oi.PropertyValues[propertyName];
annotationsModelMetadata.TemplateHint = "PropertyValue";
}
}
}
}
if (annotationsModelMetadata == null)
{
annotationsModelMetadata = new DataAnnotationsModelMetadata(this, containerType, modelAccessor, modelType, propertyName, displayColumnAttribute);
}
HiddenInputAttribute hiddenInputAttribute = Enumerable.FirstOrDefault <HiddenInputAttribute>(Enumerable.OfType <HiddenInputAttribute>((IEnumerable)list));
if (hiddenInputAttribute != null)
{
annotationsModelMetadata.TemplateHint = "HiddenInput";
annotationsModelMetadata.HideSurroundingHtml = !hiddenInputAttribute.DisplayValue;
}
IEnumerable <UIHintAttribute> source = Enumerable.OfType <UIHintAttribute>((IEnumerable)list);
UIHintAttribute uiHintAttribute = Enumerable.FirstOrDefault <UIHintAttribute>(source, (Func <UIHintAttribute, bool>)(a => string.Equals(a.PresentationLayer, "MVC", StringComparison.OrdinalIgnoreCase))) ?? Enumerable.FirstOrDefault <UIHintAttribute>(source, (Func <UIHintAttribute, bool>)(a => string.IsNullOrEmpty(a.PresentationLayer)));
if (uiHintAttribute != null)
{
annotationsModelMetadata.TemplateHint = uiHintAttribute.UIHint;
}
DataTypeAttribute attribute = Enumerable.FirstOrDefault <DataTypeAttribute>(Enumerable.OfType <DataTypeAttribute>((IEnumerable)list));
if (attribute != null)
{
annotationsModelMetadata.DataTypeName = DataTypeUtil.ToDataTypeName(attribute, (Func <DataTypeAttribute, bool>)null);
}
EditableAttribute editableAttribute = Enumerable.FirstOrDefault <EditableAttribute>(Enumerable.OfType <EditableAttribute>((IEnumerable)attributes));
if (editableAttribute != null)
{
annotationsModelMetadata.IsReadOnly = !editableAttribute.AllowEdit;
}
else
{
ReadOnlyAttribute readOnlyAttribute = Enumerable.FirstOrDefault <ReadOnlyAttribute>(Enumerable.OfType <ReadOnlyAttribute>((IEnumerable)list));
if (readOnlyAttribute != null)
{
annotationsModelMetadata.IsReadOnly = readOnlyAttribute.IsReadOnly;
}
}
DisplayFormatAttribute displayFormatAttribute = Enumerable.FirstOrDefault <DisplayFormatAttribute>(Enumerable.OfType <DisplayFormatAttribute>((IEnumerable)list));
if (displayFormatAttribute == null && attribute != null)
{
displayFormatAttribute = attribute.DisplayFormat;
}
if (displayFormatAttribute != null)
{
annotationsModelMetadata.NullDisplayText = displayFormatAttribute.NullDisplayText;
annotationsModelMetadata.DisplayFormatString = displayFormatAttribute.DataFormatString;
annotationsModelMetadata.ConvertEmptyStringToNull = displayFormatAttribute.ConvertEmptyStringToNull;
if (displayFormatAttribute.ApplyFormatInEditMode)
{
annotationsModelMetadata.EditFormatString = displayFormatAttribute.DataFormatString;
}
if (!displayFormatAttribute.HtmlEncode && string.IsNullOrWhiteSpace(annotationsModelMetadata.DataTypeName))
{
annotationsModelMetadata.DataTypeName = DataTypeUtil.HtmlTypeName;
}
}
ScaffoldColumnAttribute scaffoldColumnAttribute = Enumerable.FirstOrDefault <ScaffoldColumnAttribute>(Enumerable.OfType <ScaffoldColumnAttribute>((IEnumerable)list));
if (scaffoldColumnAttribute != null)
{
annotationsModelMetadata.ShowForDisplay = annotationsModelMetadata.ShowForEdit = scaffoldColumnAttribute.Scaffold;
}
DisplayAttribute displayAttribute = Enumerable.FirstOrDefault <DisplayAttribute>(Enumerable.OfType <DisplayAttribute>((IEnumerable)attributes));
string str = (string)null;
if (displayAttribute != null)
{
annotationsModelMetadata.Description = displayAttribute.GetDescription();
annotationsModelMetadata.ShortDisplayName = displayAttribute.GetShortName();
annotationsModelMetadata.Watermark = displayAttribute.GetPrompt();
annotationsModelMetadata.Order = displayAttribute.GetOrder() ?? 10000;
str = displayAttribute.GetName();
}
if (str != null)
{
annotationsModelMetadata.DisplayName = str;
}
else
{
DisplayNameAttribute displayNameAttribute = Enumerable.FirstOrDefault <DisplayNameAttribute>(Enumerable.OfType <DisplayNameAttribute>((IEnumerable)list));
if (displayNameAttribute != null)
{
annotationsModelMetadata.DisplayName = displayNameAttribute.DisplayName;
}
}
if (Enumerable.FirstOrDefault <RequiredAttribute>(Enumerable.OfType <RequiredAttribute>((IEnumerable)list)) != null)
{
annotationsModelMetadata.IsRequired = true;
}
return((ModelMetadata)annotationsModelMetadata);
}
internal static IEnumerable <SilverlightColumnInfo> GetColumnGenerationInfo(object dataSource)
{
List <SilverlightColumnInfo> columnGenerationInfos = new List <SilverlightColumnInfo>();
PropertyInfo[] dataProperties = GetItemsSourceProperties(dataSource);
if (dataProperties != null && dataProperties.Length > 0)
{
List <KeyValuePair <int, SilverlightColumnInfo> > columnOrderPairs = new List <KeyValuePair <int, SilverlightColumnInfo> >();
// Generate the columns
foreach (PropertyInfo propertyInfo in dataProperties)
{
string columnHeader = null;
int columnOrder = DefaultColumnDisplayOrder;
// If Browsable exists in SL, consider filtering out the BrowsableAttribute.No properties here
// Check if DisplayAttribute is defined on the property
object[] attributes = propertyInfo.GetCustomAttributes(typeof(DisplayAttribute), true);
if (attributes != null && attributes.Length > 0)
{
DisplayAttribute displayAttribute = attributes[0] as DisplayAttribute;
Debug.Assert(displayAttribute != null);
// We want to return all properties even if they are marked AutoGenerateField == false
// because in the Designer, we're not generating the columns. We're allowing the user
// to choose columns based on properties
string header = displayAttribute.GetShortName();
if (header != null)
{
columnHeader = header;
}
int?order = displayAttribute.GetOrder();
if (order.HasValue)
{
columnOrder = order.Value;
}
}
// Generate a single column and determine its relative order
int insertIndex = 0;
if (columnOrder == int.MaxValue)
{
insertIndex = columnOrderPairs.Count;
}
else
{
foreach (KeyValuePair <int, SilverlightColumnInfo> columnOrderPair in columnOrderPairs)
{
if (columnOrderPair.Key > columnOrder)
{
break;
}
insertIndex++;
}
}
SilverlightColumnInfo columnGenerationInfo = new SilverlightColumnInfo(columnHeader, propertyInfo);
columnOrderPairs.Insert(insertIndex, new KeyValuePair <int, SilverlightColumnInfo>(columnOrder, columnGenerationInfo));
}
// Add the ColumnGenerationInfo's in the correct order and set IsReadOnly
foreach (KeyValuePair <int, SilverlightColumnInfo> columnOrderPair in columnOrderPairs)
{
columnGenerationInfos.Add(columnOrderPair.Value);
}
}
return(columnGenerationInfos);
}
public static Metadata Create(MemberInfo memberInfo)
{
if (memberInfo == null)
{
throw new ArgumentNullException("memberInfo");
}
Metadata metadata = new Metadata();
// Name
metadata.Name = memberInfo.Name;
// DisplayAttribute
DisplayAttribute displayAttribute = memberInfo.GetCustomAttribute <DisplayAttribute>();
if (displayAttribute != null)
{
metadata.DisplayName = displayAttribute.GetName();
metadata.ShortName = displayAttribute.GetShortName();
metadata.GroupName = displayAttribute.GetGroupName();
metadata.Description = displayAttribute.GetDescription();
int?order = displayAttribute.GetOrder();
if (order != null)
{
metadata.Order = order.Value;
}
}
if (metadata.DisplayName == null)
{
metadata.DisplayName = ConvertUtilities.Decamelize(metadata.Name);
}
// DataType
DataTypeAttribute dataTypeAttribute = memberInfo.GetCustomAttribute <DataTypeAttribute>();
if (dataTypeAttribute != null)
{
metadata.DataType = dataTypeAttribute.GetDataTypeName();
Fill(metadata, dataTypeAttribute.DisplayFormat);
}
if (metadata.DataType == null)
{
PropertyInfo pi = memberInfo as PropertyInfo;
if (pi != null)
{
metadata.DataType = pi.PropertyType.AssemblyQualifiedName;
}
else
{
FieldInfo fi = memberInfo as FieldInfo;
if (fi != null)
{
metadata.DataType = fi.FieldType.AssemblyQualifiedName;
}
}
}
// DisplayFormat
DisplayFormatAttribute displayFormatAttribute = memberInfo.GetCustomAttribute <DisplayFormatAttribute>();
if (displayFormatAttribute != null)
{
Fill(metadata, displayFormatAttribute);
}
// ScaffoldColumnAttribute
ScaffoldColumnAttribute scaffoldColumnAttribute = memberInfo.GetCustomAttribute <ScaffoldColumnAttribute>();
if (scaffoldColumnAttribute != null)
{
metadata.Hidden = scaffoldColumnAttribute.Scaffold;
}
return(metadata);
}
public int?GetOrder()
{
return(_innerAttribute.GetOrder());
}
public void DisplayAttribute_Order_Can_Be_Set_And_Retrieved() {
DisplayAttribute attr = new DisplayAttribute { Order = 1 };
Assert.AreEqual(1, attr.Order, "The Order getter should return what was set");
Assert.AreEqual(1, attr.GetOrder().Value, "The GetOrder method should return what was set for the Order property");
}
protected override ModelMetadata CreateMetadata(IEnumerable <Attribute> attributes, Type containerType, Func <object> modelAccessor, Type modelType, string propertyName)
{
List <Attribute> attributeList = new List <Attribute>(attributes);
DisplayColumnAttribute displayColumnAttribute = attributeList.OfType <DisplayColumnAttribute>().FirstOrDefault();
DataAnnotationsModelMetadata result = new DataAnnotationsModelMetadata(this, containerType, modelAccessor, modelType, propertyName, displayColumnAttribute);
// Do [HiddenInput] before [UIHint], so you can override the template hint
HiddenInputAttribute hiddenInputAttribute = attributeList.OfType <HiddenInputAttribute>().FirstOrDefault();
if (hiddenInputAttribute != null)
{
result.TemplateHint = "HiddenInput";
result.HideSurroundingHtml = !hiddenInputAttribute.DisplayValue;
}
// We prefer [UIHint("...", PresentationLayer = "MVC")] but will fall back to [UIHint("...")]
IEnumerable <UIHintAttribute> uiHintAttributes = attributeList.OfType <UIHintAttribute>();
UIHintAttribute uiHintAttribute = uiHintAttributes.FirstOrDefault(a => String.Equals(a.PresentationLayer, "MVC", StringComparison.OrdinalIgnoreCase))
?? uiHintAttributes.FirstOrDefault(a => String.IsNullOrEmpty(a.PresentationLayer));
if (uiHintAttribute != null)
{
result.TemplateHint = uiHintAttribute.UIHint;
}
DataTypeAttribute dataTypeAttribute = attributeList.OfType <DataTypeAttribute>().FirstOrDefault();
if (dataTypeAttribute != null)
{
result.DataTypeName = dataTypeAttribute.ToDataTypeName();
}
EditableAttribute editable = attributes.OfType <EditableAttribute>().FirstOrDefault();
if (editable != null)
{
result.IsReadOnly = !editable.AllowEdit;
}
else
{
ReadOnlyAttribute readOnlyAttribute = attributeList.OfType <ReadOnlyAttribute>().FirstOrDefault();
if (readOnlyAttribute != null)
{
result.IsReadOnly = readOnlyAttribute.IsReadOnly;
}
}
DisplayFormatAttribute displayFormatAttribute = attributeList.OfType <DisplayFormatAttribute>().FirstOrDefault();
if (displayFormatAttribute == null && dataTypeAttribute != null)
{
displayFormatAttribute = dataTypeAttribute.DisplayFormat;
}
if (displayFormatAttribute != null)
{
result.NullDisplayText = displayFormatAttribute.NullDisplayText;
result.DisplayFormatString = displayFormatAttribute.DataFormatString;
result.ConvertEmptyStringToNull = displayFormatAttribute.ConvertEmptyStringToNull;
if (displayFormatAttribute.ApplyFormatInEditMode)
{
result.EditFormatString = displayFormatAttribute.DataFormatString;
}
if (!displayFormatAttribute.HtmlEncode && String.IsNullOrWhiteSpace(result.DataTypeName))
{
result.DataTypeName = DataTypeUtil.HtmlTypeName;
}
}
ScaffoldColumnAttribute scaffoldColumnAttribute = attributeList.OfType <ScaffoldColumnAttribute>().FirstOrDefault();
if (scaffoldColumnAttribute != null)
{
result.ShowForDisplay = result.ShowForEdit = scaffoldColumnAttribute.Scaffold;
}
DisplayAttribute display = attributes.OfType <DisplayAttribute>().FirstOrDefault();
string name = null;
if (display != null)
{
result.Description = display.GetDescription();
result.ShortDisplayName = display.GetShortName();
result.Watermark = display.GetPrompt();
result.Order = display.GetOrder() ?? ModelMetadata.DefaultOrder;
name = display.GetName();
}
if (name != null)
{
result.DisplayName = name;
}
else
{
DisplayNameAttribute displayNameAttribute = attributeList.OfType <DisplayNameAttribute>().FirstOrDefault();
if (displayNameAttribute != null)
{
result.DisplayName = displayNameAttribute.DisplayName;
}
}
RequiredAttribute requiredAttribute = attributeList.OfType <RequiredAttribute>().FirstOrDefault();
if (requiredAttribute != null)
{
result.IsRequired = true;
}
return(result);
}
public override AttributeDeclaration GetAttributeDeclaration(Attribute attribute)
{
DisplayAttribute displayAttribute = (DisplayAttribute)attribute;
AttributeDeclaration attributeDeclaration = new AttributeDeclaration(typeof(DisplayAttribute));
// By convention, the attribute parameters are not validated until an attempt is made to
// access the resources. We do the following probe merely to trigger this validation process.
// An InvalidOperationException will be thrown if the attribute is ill-formed.
Type attributeType = attribute.GetType();
try
{
displayAttribute.GetName();
}
catch (InvalidOperationException ex)
{
throw new AttributeBuilderException(ex, attributeType, "Name");
}
try
{
displayAttribute.GetShortName();
}
catch (InvalidOperationException ex)
{
throw new AttributeBuilderException(ex, attributeType, "ShortName");
}
try
{
displayAttribute.GetDescription();
}
catch (InvalidOperationException ex)
{
throw new AttributeBuilderException(ex, attributeType, "Description");
}
try
{
displayAttribute.GetPrompt();
}
catch (InvalidOperationException ex)
{
throw new AttributeBuilderException(ex, attributeType, "Prompt");
}
// Add AutoGenerateField
if (displayAttribute.GetAutoGenerateField().HasValue)
{
attributeDeclaration.NamedParameters.Add("AutoGenerateField", displayAttribute.AutoGenerateField);
}
// Add AutoGenerateFilter
if (displayAttribute.GetAutoGenerateFilter().HasValue)
{
attributeDeclaration.NamedParameters.Add("AutoGenerateFilter", displayAttribute.AutoGenerateFilter);
}
// Add Description
if (!string.IsNullOrEmpty(displayAttribute.Description))
{
attributeDeclaration.NamedParameters.Add("Description", displayAttribute.Description);
}
// Add GroupName
if (!string.IsNullOrEmpty(displayAttribute.GroupName))
{
attributeDeclaration.NamedParameters.Add("GroupName", displayAttribute.GroupName);
}
// Add Name
if (!string.IsNullOrEmpty(displayAttribute.Name))
{
attributeDeclaration.NamedParameters.Add("Name", displayAttribute.Name);
}
// Add Order
if (displayAttribute.GetOrder().HasValue)
{
attributeDeclaration.NamedParameters.Add("Order", displayAttribute.Order);
}
// Add Prompt
if (!string.IsNullOrEmpty(displayAttribute.Prompt))
{
attributeDeclaration.NamedParameters.Add("Prompt", displayAttribute.Prompt);
}
// Add ResourceType
if (displayAttribute.ResourceType != null)
{
attributeDeclaration.NamedParameters.Add("ResourceType", displayAttribute.ResourceType);
}
// Add ShortName
if (!string.IsNullOrEmpty(displayAttribute.ShortName))
{
attributeDeclaration.NamedParameters.Add("ShortName", displayAttribute.ShortName);
}
return(attributeDeclaration);
}
/// <summary>
/// Initialize property metadata.
/// </summary>
/// <param name="propertyInfo">Property info.</param>
public PropertyMetadata(PropertyInfo propertyInfo)
{
Property = propertyInfo;
DisplayAttribute display = propertyInfo.GetCustomAttribute <DisplayAttribute>();
if (display != null)
{
Name = display.Name == null ? propertyInfo.Name : display.Name;
if (display.Description != null)
{
Description = display.Description;
}
Order = display.GetOrder().HasValue ? display.Order : 0;
ShortName = display.ShortName == null ? Name : display.ShortName;
}
else
{
Name = propertyInfo.Name;
}
RequiredAttribute required = propertyInfo.GetCustomAttribute <RequiredAttribute>();
IsRequired = required != null;
HideAttribute hide = propertyInfo.GetCustomAttribute <HideAttribute>();
if (hide != null)
{
IsHiddenOnEdit = hide.IsHiddenOnEdit;
IsHiddenOnView = hide.IsHiddenOnView;
IsHiddenOnDetail = hide.IsHiddenOnDetail;
}
else
{
if (propertyInfo.PropertyType.IsGenericType)
{
IsHiddenOnView = true;
}
}
var customDataType = propertyInfo.GetCustomAttribute <CustomDataTypeAttribute>();
if (customDataType != null)
{
Type = customDataType.Type;
CustomType = customDataType.Custom;
}
else
{
Type type = propertyInfo.PropertyType;
if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable <>))
{
type = type.GetGenericArguments()[0];
}
if (type == typeof(DateTime))
{
Type = CustomDataType.Date;
}
if (type == typeof(TimeSpan))
{
Type = CustomDataType.Time;
}
else if (type == typeof(bool))
{
Type = CustomDataType.Boolean;
}
else if (type == typeof(short) || type == typeof(int) || type == typeof(long))
{
Type = CustomDataType.Integer;
}
else if (type == typeof(float) || type == typeof(double))
{
Type = CustomDataType.Number;
}
else if (type == typeof(decimal))
{
Type = CustomDataType.Currency;
}
else if (type == typeof(byte[]))
{
Type = CustomDataType.File;
}
else if (type.IsEnum)
{
Type = CustomDataType.Other;
CustomType = "Enum";
}
else if (type.IsGenericType)
{
Type = CustomDataType.Other;
CustomType = "Collection";
}
else if (typeof(IEntity).IsAssignableFrom(type))
{
Type = CustomDataType.Other;
CustomType = "Entity";
}
}
if (Type != CustomDataType.Image && Type != CustomDataType.Password && Type != CustomDataType.Time)
{
if (CustomType == null || CustomType == "Entity" || CustomType == "Enum")
{
SearchableAttribute searchable = propertyInfo.GetCustomAttribute <SearchableAttribute>();
Searchable = searchable != null;
}
}
IsDistinct = propertyInfo.GetCustomAttribute <DistinctAttribute>() != null;
}
public void DisplayAttribute_Order_Accepts_Negative_Values() {
DisplayAttribute attr = new DisplayAttribute();
attr.Order = Int32.MinValue;
Assert.AreEqual(Int32.MinValue, attr.GetOrder());
attr.Order = -1;
Assert.AreEqual(-1, attr.GetOrder());
attr.Order = 0;
Assert.AreEqual(0, attr.GetOrder());
attr.Order = 1;
Assert.AreEqual(1, attr.GetOrder());
attr.Order = Int32.MaxValue;
Assert.AreEqual(Int32.MaxValue, attr.GetOrder());
}
public void Order_Get_NotSet_ThrowsInvalidOperationException()
{
DisplayAttribute attribute = new DisplayAttribute();
Assert.Throws<InvalidOperationException>(() => attribute.Order);
Assert.Null(attribute.GetOrder());
}
public void Order_Get_Set(int value)
{
DisplayAttribute attribute = new DisplayAttribute();
attribute.Order = value;
Assert.Equal(value, attribute.Order);
Assert.Equal(value, attribute.GetOrder());
}
public void DisplayAttribute_AutoGenerateFilter_Is_Optional() {
DisplayAttribute attr = new DisplayAttribute();
ExceptionHelper.ExpectException<InvalidOperationException>(delegate() {
attr.AutoGenerateFilter.ToString();
}, String.Format(CultureInfo.CurrentCulture, Resources.DataAnnotationsResources.DisplayAttribute_PropertyNotSet, "AutoGenerateFilter", "GetAutoGenerateFilter"));
Assert.IsNull(attr.GetOrder(), "GetAutoGenerateFilter should be null by default");
}
