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