public void DisplayAttribute_Resourced_Properties() {
DisplayAttribute attr = new DisplayAttribute();
attr.ResourceType = typeof(DisplayAttribute_Resources);
Assert.IsNull(attr.GetShortName());
Assert.IsNull(attr.GetName());
Assert.IsNull(attr.GetPrompt());
Assert.IsNull(attr.GetDescription());
Assert.IsNull(attr.GetGroupName());
attr.ShortName = "Resource1";
attr.Name = "Resource2";
attr.Prompt = "Resource3";
attr.Description = "Resource4";
attr.GroupName = "Resource5";
Assert.AreEqual("string1", attr.GetShortName());
Assert.AreEqual("string2", attr.GetName());
Assert.AreEqual("string3", attr.GetPrompt());
Assert.AreEqual("string4", attr.GetDescription());
Assert.AreEqual("string5", attr.GetGroupName());
Assert.AreEqual("Resource1", attr.ShortName);
Assert.AreEqual("Resource2", attr.Name);
Assert.AreEqual("Resource3", attr.Prompt);
Assert.AreEqual("Resource4", attr.Description);
Assert.AreEqual("Resource5", attr.GroupName);
}
public void Name_Get_Set(string value)
{
DisplayAttribute attribute = new DisplayAttribute();
attribute.Name = value;
Assert.Equal(value, attribute.Name);
Assert.Equal(value == null, attribute.GetName() == null);
// Set again, to cover the setter avoiding operations if the value is the same
attribute.Name = value;
Assert.Equal(value, attribute.Name);
}
public void Ctor()
{
DisplayAttribute attribute = new DisplayAttribute();
Assert.Null(attribute.ShortName);
Assert.Null(attribute.GetShortName());
Assert.Null(attribute.Name);
Assert.Null(attribute.GetName());
Assert.Null(attribute.Description);
Assert.Null(attribute.GetDescription());
Assert.Null(attribute.Prompt);
Assert.Null(attribute.GetPrompt());
Assert.Null(attribute.GroupName);
Assert.Null(attribute.GetGroupName());
Assert.Null(attribute.ResourceType);
}
public void DisplayAttribute_Literal_Properties() {
DisplayAttribute attr = new DisplayAttribute();
Assert.IsNull(attr.ResourceType);
Assert.IsNull(attr.ShortName);
Assert.IsNull(attr.Name);
Assert.IsNull(attr.Prompt);
Assert.IsNull(attr.Description);
Assert.IsNull(attr.GroupName);
Assert.IsNull(attr.GetShortName());
Assert.IsNull(attr.GetName());
Assert.IsNull(attr.GetPrompt());
Assert.IsNull(attr.GetDescription());
Assert.IsNull(attr.GetGroupName());
attr.ShortName = "theShortName";
attr.Name = "theName";
attr.Prompt = "thePrompt";
attr.Description = "theDescription";
attr.GroupName = "theGroupName";
Assert.AreEqual("theShortName", attr.GetShortName());
Assert.AreEqual("theName", attr.GetName());
Assert.AreEqual("thePrompt", attr.GetPrompt());
Assert.AreEqual("theDescription", attr.GetDescription());
Assert.AreEqual("theGroupName", attr.GetGroupName());
attr.ShortName = String.Empty;
attr.Name = String.Empty;
attr.Prompt = String.Empty;
attr.Description = String.Empty;
attr.GroupName = String.Empty;
Assert.AreEqual(String.Empty, attr.GetShortName());
Assert.AreEqual(String.Empty, attr.GetName());
Assert.AreEqual(String.Empty, attr.GetPrompt());
Assert.AreEqual(String.Empty, attr.GetDescription());
Assert.AreEqual(String.Empty, attr.GetGroupName());
}
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_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");
}
internal static bool ValidateMethodCall(string methodName,
ValidationContext validationContext, object[] parameters,
List <ValidationResult> validationResults, bool performTypeValidation)
{
if (string.IsNullOrEmpty(methodName))
{
throw new ArgumentNullException("methodName");
}
if (validationContext == null)
{
throw new ArgumentNullException("validationContext");
}
if (validationContext.ObjectInstance == null)
{
throw new ArgumentException(DataResource.ValidationUtilities_ContextInstance_CannotBeNull, "validationContext");
}
MethodInfo method = GetMethod(validationContext.ObjectInstance, methodName, parameters);
ValidationContext methodContext = CreateValidationContext(validationContext.ObjectInstance, validationContext);
methodContext.MemberName = method.Name;
DisplayAttribute display = GetDisplayAttribute(method);
if (display != null)
{
methodContext.DisplayName = display.GetName();
}
string memberPath = string.Empty;
if (performTypeValidation)
{
memberPath = method.Name + ".";
}
IEnumerable <ValidationAttribute> validationAttributes = method.GetCustomAttributes(typeof(ValidationAttribute), true).Cast <ValidationAttribute>();
bool success = ValidationUtilities.ValidateValue(validationContext.ObjectInstance, methodContext, validationResults, validationAttributes, string.Empty);
ParameterInfo[] parameterInfos = method.GetParameters();
for (int paramIndex = 0; paramIndex < parameterInfos.Length; paramIndex++)
{
ParameterInfo methodParameter = parameterInfos[paramIndex];
object value = (parameters.Length > paramIndex ? parameters[paramIndex] : null);
ValidationContext parameterContext = ValidationUtilities.CreateValidationContext(validationContext.ObjectInstance, validationContext);
parameterContext.MemberName = methodParameter.Name;
string paramName = methodParameter.Name;
display = GetDisplayAttribute(methodParameter);
if (display != null)
{
paramName = display.GetName();
}
parameterContext.DisplayName = paramName;
string parameterPath = memberPath;
if (performTypeValidation)
{
parameterPath += methodParameter.Name;
}
IEnumerable <ValidationAttribute> parameterAttributes = methodParameter.GetCustomAttributes(typeof(ValidationAttribute), false).Cast <ValidationAttribute>();
bool parameterSuccess = ValidationUtilities.ValidateValue(value, parameterContext, validationResults,
parameterAttributes, ValidationUtilities.NormalizeMemberPath(parameterPath, methodParameter.ParameterType));
if (parameterSuccess && performTypeValidation && value != null)
{
Type parameterType = methodParameter.ParameterType;
// If the user expects an exception we perform shallow validation only.
if (validationResults == null)
{
if (TypeUtility.IsComplexType(parameterType))
{
ValidationContext context = ValidationUtilities.CreateValidationContext(value, parameterContext);
context.DisplayName = paramName;
Validator.ValidateObject(value, context, /*validateAllProperties*/ true);
}
}
// Else we are able to report fully recursive validation errors to the user, perform deep validation.
else
{
if (TypeUtility.IsComplexType(parameterType))
{
parameterSuccess = ValidationUtilities.ValidateObjectRecursive(value, parameterPath, validationContext, validationResults);
}
else if (TypeUtility.IsComplexTypeCollection(parameterType))
{
parameterSuccess = ValidationUtilities.ValidateComplexCollection(value as IEnumerable, parameterPath, validationContext, validationResults);
}
}
}
success &= parameterSuccess;
}
return(success);
}
private void DiscoverObject()
{
this.displays.Clear();
this.properties.Clear();
this.bindables.Clear();
this.bindings.Clear();
#if !SILVERLIGHT
this.rules.Clear();
#endif
this.controls.Clear();
this.validations.Clear();
if (this.CurrentItem == null)
{
return;
}
Type dataType = this.CurrentItem.GetType();
PropertyInfo[] properties;
//Code for dynamic Types....
/*var meta = this.CurrentItem as IDynamicMetaObjectProvider;
* if (meta != null)
* {
* List<PropertyInfo> tmpLst = new List<PropertyInfo>();
* var metaObject = meta.GetMetaObject(System.Linq.Expressions.Expression.Constant(this.CurrentItem));
* var membernames = metaObject.GetDynamicMemberNames();
* foreach (var membername in membernames)
* {
* var binder = Microsoft.CSharp.RuntimeBinder.Binder.GetMember(CSharpBinderFlags.None, membername, dataType, new[] { CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null) });
* var callsite = CallSite<Func<CallSite, object, object>>.Create(binder);
* var item = callsite.Target(callsite, this.CurrentItem);
* }
* }
* else*/
{
properties = GetPropertyInfos(dataType);
}
BindableAttribute bindable = ((BindableAttribute[])dataType.GetCustomAttributes(typeof(System.ComponentModel.BindableAttribute), true)).FirstOrDefault();
foreach (PropertyInfo property in properties)
{
BindableAttribute propBindable = ((BindableAttribute[])property.GetCustomAttributes(typeof(System.ComponentModel.BindableAttribute), true)).FirstOrDefault();
// Check if Readable
if (!property.CanRead)
{
continue;
}
// Check if Bindable
if ((bindable != null && !bindable.Bindable && propBindable == null) || (bindable != null && !bindable.Bindable && propBindable != null && !propBindable.Bindable) || (propBindable != null && !propBindable.Bindable))
{
continue;
}
DisplayAttribute propDisplay = ((DisplayAttribute[])Attribute.GetCustomAttributes(property, typeof(DisplayAttribute), true)).FirstOrDefault();
EditableAttribute propEditable = ((EditableAttribute[])Attribute.GetCustomAttributes(property, typeof(EditableAttribute), true)).FirstOrDefault();
List <ValidationAttribute> validations = new List <ValidationAttribute>((ValidationAttribute[])Attribute.GetCustomAttributes(property, typeof(ValidationAttribute), true));
if (propDisplay == null)
{
propDisplay = new DisplayAttribute()
{
AutoGenerateField = true, Name = property.Name, ShortName = property.Name, Order = 10000, Prompt = null, GroupName = null, Description = null
}
}
;
if (propEditable == null)
{
propEditable = new EditableAttribute(!this.DefaultReadOnly)
{
AllowInitialValue = true
}
}
;
bool setPrivate = true;
if (property.GetSetMethod(true) != null)
{
setPrivate = !property.GetSetMethod(true).IsPublic;
}
if (propDisplay.GetAutoGenerateField().HasValue&& !propDisplay.AutoGenerateField)
{
continue;
}
if (PropertyDisplayInformations != null)
{
var prpDisplay = PropertyDisplayInformations.FirstOrDefault(x => x.Name == property.Name);
if (prpDisplay == null || !prpDisplay.Visible)
{
continue;
}
propDisplay.Order = prpDisplay.Order;
}
if (bindable != null && propBindable == null)
{
if ((!property.CanWrite || !propEditable.AllowEdit || setPrivate) && bindable.Direction == BindingDirection.TwoWay)
{
this.bindables.Add(property.Name, new BindableAttribute(true, BindingDirection.OneWay));
}
else
{
this.bindables.Add(property.Name, new BindableAttribute(true, bindable.Direction));
}
}
else if (propBindable != null)
{
if ((!property.CanWrite || !propEditable.AllowEdit || setPrivate) && propBindable.Direction == BindingDirection.TwoWay)
{
this.bindables.Add(property.Name, new BindableAttribute(true, BindingDirection.OneWay));
}
else
{
this.bindables.Add(property.Name, new BindableAttribute(true, propBindable.Direction));
}
}
else
{
if (!this.bindables.ContainsKey(property.Name))
{
if (!property.CanWrite || !propEditable.AllowEdit || setPrivate)
{
this.bindables.Add(property.Name, new BindableAttribute(true, BindingDirection.OneWay));
}
else
{
this.bindables.Add(property.Name, new BindableAttribute(true, BindingDirection.TwoWay));
}
}
}
if (!this.validations.ContainsKey(property.Name))
{
this.validations.Add(property.Name, validations);
this.displays.Add(property.Name, propDisplay);
this.properties.Add(property.Name, property);
}
}
}
public void DisplayAttribute_Resourced_Properties_Wrong_Keys() {
DisplayAttribute attr = new DisplayAttribute();
attr.ResourceType = typeof(DisplayAttribute_Resources);
attr.ShortName = "notAKey1";
attr.Name = "notAKey2";
attr.Prompt = "notAKey3";
attr.Description = "notAKey4";
attr.GroupName = "notAKey5";
Assert.AreEqual("notAKey1", attr.ShortName);
Assert.AreEqual("notAKey2", attr.Name);
Assert.AreEqual("notAKey3", attr.Prompt);
Assert.AreEqual("notAKey4", attr.Description);
Assert.AreEqual("notAKey5", attr.GroupName);
string shortNameError = String.Format(CultureInfo.CurrentCulture, Resources.DataAnnotationsResources.LocalizableString_LocalizationFailed, "ShortName", attr.ResourceType.FullName, attr.ShortName);
string nameError = String.Format(CultureInfo.CurrentCulture, Resources.DataAnnotationsResources.LocalizableString_LocalizationFailed, "Name", attr.ResourceType.FullName, attr.Name);
string promptError = String.Format(CultureInfo.CurrentCulture, Resources.DataAnnotationsResources.LocalizableString_LocalizationFailed, "Prompt", attr.ResourceType.FullName, attr.Prompt);
string descriptionError = String.Format(CultureInfo.CurrentCulture, Resources.DataAnnotationsResources.LocalizableString_LocalizationFailed, "Description", attr.ResourceType.FullName, attr.Description);
string groupNameError = String.Format(CultureInfo.CurrentCulture, Resources.DataAnnotationsResources.LocalizableString_LocalizationFailed, "GroupName", attr.ResourceType.FullName, attr.GroupName);
ExceptionHelper.ExpectException<InvalidOperationException>(() => { string s = attr.GetShortName(); }, shortNameError);
ExceptionHelper.ExpectException<InvalidOperationException>(() => { string s = attr.GetName(); }, nameError);
ExceptionHelper.ExpectException<InvalidOperationException>(() => { string s = attr.GetPrompt(); }, promptError);
ExceptionHelper.ExpectException<InvalidOperationException>(() => { string s = attr.GetDescription(); }, descriptionError);
ExceptionHelper.ExpectException<InvalidOperationException>(() => { string s = attr.GetGroupName(); }, groupNameError);
}
public static string GetDisplayName(this System.Type type, string fieldName)
{
DisplayAttribute displayAttribute = type.GetField(fieldName).GetCustomAttributes(typeof(DisplayAttribute), false).FirstOrDefault <object>() as DisplayAttribute;
return((displayAttribute != null) ? displayAttribute.Name : fieldName);
}
/// <summary>
/// Configures the localizable strings to the <see cref="PageInfo"/> in the tree path
/// created from the current request. Uses <see cref="DisplayAttribute"/> and/or the
/// <see cref="PageMetadataAttribute"/>.
/// </summary>
/// <param name="currentPageTree">Current page tree to apply</param>
private void ApplyAttributes(PageTree currentPageTree)
{
PageInfo currentPage = currentPageTree.Page;
MethodInfo pageAction = currentPage.Action;
//detect and apply the display attribute
DisplayAttribute displayAttribute = pageAction.GetCustomAttribute <DisplayAttribute>();
if (displayAttribute != null)
{
if (displayAttribute.ResourceType != null)
{
var rs = new ResourceManager(displayAttribute.ResourceType);
currentPage.Caption = rs.GetString(displayAttribute.Name);
}
else
{
currentPage.Caption = displayAttribute.Name;
}
}
//detect and apply the page metadata attribute
PageMetadataAttribute pageMetadataAttribute = pageAction.GetCustomAttribute <PageMetadataAttribute>();
if (pageMetadataAttribute != null)
{
if (pageMetadataAttribute.ResourceType != null)
{
var rs = new ResourceManager(pageMetadataAttribute.ResourceType);
if (!String.IsNullOrEmpty(pageMetadataAttribute.Caption))
{
currentPage.Caption = rs.GetString(pageMetadataAttribute.Caption);
}
if (!String.IsNullOrEmpty(pageMetadataAttribute.Header))
{
currentPage.Header = rs.GetString(pageMetadataAttribute.Header);
}
}
else
{
currentPage.Caption = pageMetadataAttribute.Caption;
currentPage.Header = pageMetadataAttribute.Header;
}
currentPage.RenderHeader = pageMetadataAttribute.RenderHeader;
currentPage.RenderCaption = pageMetadataAttribute.RenderCaption;
}
//translate template variables from route data
if (!String.IsNullOrEmpty(currentPage.Caption))
{
currentPage.Caption = TranslateParameters(currentPage.Caption);
}
if (!String.IsNullOrEmpty(currentPage.Header))
{
currentPage.Header = TranslateParameters(currentPage.Header);
}
var urlHelper = new UrlHelper(actionContextAccessor.ActionContext);
//build url for the items in the page tree using the existing route values
var routeValues = new Dictionary <string, object>();
foreach (KeyValuePair <string, object> routeValue in actionContextAccessor.ActionContext.RouteData.Values)
{
//detecting a variable template with "{" should be enough
if (currentPage.UrlTemplate.Contains("{" + routeValue.Key))
{
routeValues.Add(routeValue.Key, routeValue.Value);
}
}
currentPage.CurrentUrl = urlHelper.Action(new UrlActionContext()
{
Action = currentPage.Action.Name,
Controller = currentPage.Action.DeclaringType.Name.Replace("controller", "", StringComparison.InvariantCultureIgnoreCase),
Values = routeValues
});
}
public static string GetDescription(this AbilityId prop)
{
DisplayAttribute description = prop.GetAttributeOfType <DisplayAttribute>();
return(description?.Description ?? prop.ToString());
}
/*
* ViewBag.FleetTypeList = new List<SelectListItem>{
* new SelectListItem { Text="17 Truck", Value="1"},
* new SelectListItem { Text="20 Truck", Value="2"},
* new SelectListItem { Text="Something else", Value="0"}
* };
* and in the view
*
* @Html.DropDownListFor(m => m.FleetType, ViewBag.FleetTypeList as List<SelectListItem>
* , new { @class = "btn btn-primary btn-lg dropdown-toggle" })
*/
public static MvcHtmlString DropDownListModel <TModel>(this HtmlHelper <IEnumerable <TModel> > helper, SelectList ListaValores = null, object htmlAttributes = null)
{
//a ideia aqui é dado um selectList / list montar a lista e retornar; caso contrário, procurar os atributos customizados
//if (ListaValores != null)
//{
//}
PropertyInfo[] Props = typeof(TModel).GetProperties(BindingFlags.Public | BindingFlags.Instance);
//Get column headers
bool isDisplayGridHeader = false;
bool isDisplayAttributeDefined = false;
List <string> nomesPropriedades = new List <string>();
StringBuilder tags = new StringBuilder();
TagBuilder tagBuilder = new TagBuilder("select");
tagBuilder.Attributes.Add("name", "pesquisaDropList");
tagBuilder.Attributes.Add("id", "pesquisaDropListId");
StringBuilder options = new StringBuilder();
options.AppendLine("<option value='-1'> Selecione uma opção </option>");
foreach (PropertyInfo prop in Props)
{
nomesPropriedades.Add(prop.Name);
var displayName = "";
isDisplayAttributeDefined = Attribute.IsDefined(prop, typeof(DisplayAttribute));
if (isDisplayAttributeDefined)
{
DisplayAttribute dna = (DisplayAttribute)Attribute.GetCustomAttribute(prop, typeof(DisplayAttribute));
if (dna != null)
{
displayName = dna.Description;
}
}
else
{
displayName = prop.Name;
}
isDisplayGridHeader = Attribute.IsDefined(prop, typeof(DisplayGridHeader));
if (isDisplayGridHeader)
{
DisplayGridHeader dgh = (DisplayGridHeader)Attribute.GetCustomAttribute(prop, typeof(DisplayGridHeader));
if (dgh != null)
{
if (!string.IsNullOrEmpty(dgh.Descricao))
{
displayName = dgh.Descricao;
}
if (dgh.FiltroPesquisa)
{
string dynamicTypeJSfilter = "text";
if (prop.PropertyType == typeof(int))
{
dynamicTypeJSfilter = "number";
}
else if (prop.PropertyType == typeof(DateTime) || prop.PropertyType == typeof(DateTime?))
{
dynamicTypeJSfilter = "date";
}
string singleOption = "<option value = '" + dynamicTypeJSfilter + '|' + prop.Name + "'>" + displayName + "</option>";
options.AppendLine(singleOption);
}
}
}
}
tagBuilder.InnerHtml = options.ToString();
foreach (PropertyDescriptor prop in TypeDescriptor.GetProperties(htmlAttributes))
{
tagBuilder.MergeAttribute(prop.Name.Replace('_', '-'), prop.GetValue(htmlAttributes).ToString(), true);
}
return(MvcHtmlString.Create(tagBuilder.ToString()));
}
/// <summary>
/// Display components that are tagged with the <see cref="DisplayAttribute"/>.
/// </summary>
/// <param name="context">Context of the view model.</param>
/// <param name="viewModel">The current view model</param>
/// <param name="component">The entity component to display</param>
private void AutoDisplayComponent(ViewModelContext context, IViewModelNode viewModel, EntityComponent component)
{
var displayComp = DisplayAttribute.GetDisplay(component.GetType());
if (displayComp == null)
{
return;
}
var componentViewModel = viewModel.GetChildrenByName("Component");
if (componentViewModel == null)
{
return;
}
// Change the name of the component being displayed
if (!string.IsNullOrEmpty(displayComp.Name))
{
var componentName = viewModel.GetChildrenByName("PropertyKeyName");
if (componentName != null)
{
componentName.Value = displayComp.Name;
}
}
var propertyToDisplay = new List <Tuple <DisplayAttribute, ViewModelNode> >();
var memberInfos = new List <MemberInfo>();
memberInfos.AddRange(component.GetType().GetProperties());
memberInfos.AddRange(component.GetType().GetFields());
// Process fields and properties
foreach (var property in memberInfos)
{
var display = DisplayAttribute.GetDisplay(property);
if (display == null)
{
continue;
}
IViewModelContent modelContent = null;
object modelValue = null;
var propertyInfo = property as PropertyInfo;
if (propertyInfo != null)
{
if (typeof(ParameterCollection).IsAssignableFrom(propertyInfo.PropertyType))
{
modelValue = propertyInfo.GetValue(component, null);
}
else
{
modelContent = new PropertyInfoViewModelContent(new ParentNodeValueViewModelContent(), propertyInfo);
}
}
var fieldInfo = property as FieldInfo;
if (fieldInfo != null)
{
if (typeof(ParameterCollection).IsAssignableFrom(fieldInfo.FieldType))
{
modelValue = fieldInfo.GetValue(component);
}
else
{
modelContent = new FieldInfoViewModelContent(new ParentNodeValueViewModelContent(), fieldInfo);
}
}
var propertyViewModel = modelValue != null ? new ViewModelNode(display.Name ?? property.Name, modelValue) : new ViewModelNode(display.Name ?? property.Name, modelContent);
propertyViewModel.GenerateChildren(context);
propertyToDisplay.Add(new Tuple <DisplayAttribute, ViewModelNode>(display, propertyViewModel));
}
foreach (var item in propertyToDisplay.OrderBy((left) => left.Item1.Order))
{
componentViewModel.Children.Add(item.Item2);
}
}
public static MvcHtmlString DisplayGridModel <TModel, TValue>(this HtmlHelper <IPagedList <TModel> > helper, TValue valores, string classTable = "", string classTr = "", string classTh = "", string classTd = "")
{
var url = new UrlHelper(helper.ViewContext.RequestContext);
var controller = helper.ViewContext.RouteData.Values["controller"].ToString();
var listaOrder = (List <string>)helper.ViewBag.Orders;
//System.Reflection.MemberInfo info = typeof(TModel);
//Get properties
PropertyInfo[] Props = typeof(TModel).GetProperties(BindingFlags.Public | BindingFlags.Instance);
//Get column headers
bool isDisplayGridHeader = false;
bool isDisplayAttributeDefined = false;
List <string> nomesPropriedades = new List <string>();
StringBuilder tags = new StringBuilder();
tags.Append("<table").Append(classTable.Length > 0 ? string.Format(" {0}\"{1}\"", "class=", classTable) : "").Append(">");
tags.Append("<tr").Append(classTr.Length > 0 ? string.Format(" {0}\"{1}\"", "class=", classTr) : "").Append(">");
foreach (PropertyInfo prop in Props)
{
var displayName = "";
isDisplayAttributeDefined = Attribute.IsDefined(prop, typeof(DisplayAttribute));
if (isDisplayAttributeDefined)
{
DisplayAttribute dna = (DisplayAttribute)Attribute.GetCustomAttribute(prop, typeof(DisplayAttribute));
if (dna != null)
{
displayName = dna.Description;
}
}
else
{
displayName = prop.Name;
}
isDisplayGridHeader = Attribute.IsDefined(prop, typeof(DisplayGridHeader));
if (isDisplayGridHeader)
{
DisplayGridHeader dgh = (DisplayGridHeader)Attribute.GetCustomAttribute(prop, typeof(DisplayGridHeader));
if (dgh != null)
{
if (dgh.VisivelGrid)
{
if (!string.IsNullOrEmpty(dgh.Descricao))
{
displayName = dgh.Descricao;
}
if (!dgh.OrdenaColuna)
{
tags.Append("<th").Append(classTh.Length > 0 ? string.Format(" {0}\"{1}\"", "class=", classTh) : "").Append(">").Append(displayName).Append("</th>");
}
else
{
var ordemColumn = "";
for (int i = 0; i < listaOrder.Count; i++)
{
if (listaOrder[i].StartsWith(prop.Name))
{
ordemColumn = listaOrder[i];
break;
}
}
if (!string.IsNullOrEmpty(ordemColumn))
{
var anchorBuilderEdit = new TagBuilder("a");
//Importante toda lista deve ter um id!!!!
anchorBuilderEdit.MergeAttribute("href", url.Action("Lista", controller, new { sortOrder = ordemColumn }));
anchorBuilderEdit.SetInnerText(displayName);
var linkOrder = anchorBuilderEdit.ToString(TagRenderMode.Normal);
tags.Append("<th").Append(classTh.Length > 0 ? string.Format(" {0}\"{1}\"", "class=", classTh) : "").Append(">").Append(linkOrder).Append("</th>");
}
else
{
tags.Append("<th").Append(classTh.Length > 0 ? string.Format(" {0}\"{1}\"", "class=", classTh) : "").Append(">").Append(displayName).Append("</th>");
}
}
nomesPropriedades.Add(prop.Name);
}
}
}
}
tags.Append("<th></th>");
//Montagem da grid
dynamic lista = valores;
foreach (var item in lista)
{
tags.Append("<tr").Append(classTr.Length > 0 ? string.Format(" {0}\"{1}\"", "class=", classTr) : "").Append(">");
foreach (var column in nomesPropriedades)
{
dynamic conteudo = item.GetType().GetProperty(column).GetValue(item, null);
if (conteudo != null)
{
tags.Append("<td").Append(classTd.Length > 0 ? string.Format(" {0}\"{1}\"", "class=", classTd) : "").Append(">").Append(conteudo).Append("</td>");
}
else
{
tags.Append("<td").Append(classTd.Length > 0 ? string.Format(" {0}\"{1}\"", "class=", classTd) : "").Append(">").Append("</td>");
}
}
var anchorBuilderEdit = new TagBuilder("a");
//Importante toda lista deve ter um id!!!!
anchorBuilderEdit.MergeAttribute("href", url.Action("UpInsert", controller, new { modeid = "UPD|" + item.id }));
anchorBuilderEdit.SetInnerText("Editar");
var linkEdit = anchorBuilderEdit.ToString(TagRenderMode.Normal);
tags.Append("<td").Append(classTd.Length > 0 ? string.Format(" {0}\"{1}\"", "class=", classTd) : "").Append(">").Append(linkEdit).Append("</td>");
var anchorBuilderDel = new TagBuilder("a");
//Importante toda lista deve ter um id!!!!
anchorBuilderDel.MergeAttribute("href", url.Action("UpInsert", controller, new { modeid = "DEL|" + item.id }));
anchorBuilderDel.SetInnerText("Remover");
var linkRemover = anchorBuilderDel.ToString(TagRenderMode.Normal);
tags.Append("<td").Append(classTd.Length > 0 ? string.Format(" {0}\"{1}\"", "class=", classTd) : "").Append(">").Append(linkRemover).Append("</td>");
tags.Append("</tr>");
}
tags.Append("</tr>");
tags.Append("</table>");
return(MvcHtmlString.Create(tags.ToString()));
}
private static string GetDisplayAttributeName(Type containerType, string propertyName, DisplayAttribute displayAttribute)
{
if (containerType != null)
{
if (String.IsNullOrEmpty(displayAttribute.Name))
{
// check to see that resource key exists.
string resourceKey = GetResourceKey(containerType, propertyName);
if (displayAttribute.ResourceType.PropertyExists(resourceKey))
{
return(resourceKey);
}
else
{
return(propertyName);
}
}
}
return(null);
}
protected override void OnInitialized()
{
base.OnInitialized();
Display = typeof(TModel).GetType().GetCustomAttribute <DisplayAttribute>();
}
public void DisplayAttribute_GetShortName_Falls_Back_Onto_NonLocalized_Name() {
DisplayAttribute attr = new DisplayAttribute { Name = "Name" };
Assert.AreEqual("Name", attr.GetShortName(), "GetShortName should return the Name when ShortName is null");
}
public static string GetName(this WealthRating?prop)
{
DisplayAttribute description = prop.GetAttributeOfType <DisplayAttribute>();
return(description?.Name ?? prop?.ToString() ?? "");
}
public void DisplayAttribute_GetGroupName_Does_Not_Fall_Back() {
DisplayAttribute attr = new DisplayAttribute { ShortName = "ShortName", Name = "Name", Description = "Description", Prompt = "Prompt" };
Assert.IsNull(attr.GetGroupName(), "GetGroupName should NOT fall back onto any other values");
}
public static bool CanSupplyDisplayName(this DisplayAttribute attribute)
{
return(attribute != null &&
attribute.ResourceType != null &&
!string.IsNullOrEmpty(attribute.Name));
}
private void SetMetaFromDisplayAttribute(DisplayAttribute displayAttribute)
{
PropertyDisplayName = displayAttribute.Name;
PropertyDescription = displayAttribute.Description;
}
public Boolean HasAttribute(DisplayAttribute attr)
{
return((attr & attributes) == attr);
}
internal static bool TryValidateMethodCall(DomainOperationEntry operationEntry, ValidationContext validationContext, object[] parameters, List <ValidationResult> validationResults)
{
bool breakOnFirstError = validationResults == null;
ValidationContext methodContext = CreateValidationContext(validationContext.ObjectInstance, validationContext);
methodContext.MemberName = operationEntry.Name;
DisplayAttribute display = (DisplayAttribute)operationEntry.Attributes[typeof(DisplayAttribute)];
if (display != null)
{
methodContext.DisplayName = display.GetName();
}
string methodPath = string.Empty;
if (operationEntry.Operation == DomainOperation.Custom)
{
methodPath = operationEntry.Name + ".";
}
IEnumerable <ValidationAttribute> validationAttributes = operationEntry.Attributes.OfType <ValidationAttribute>();
bool success = Validator.TryValidateValue(validationContext.ObjectInstance, methodContext, validationResults, validationAttributes);
if (!breakOnFirstError || success)
{
for (int paramIndex = 0; paramIndex < operationEntry.Parameters.Count; paramIndex++)
{
DomainOperationParameter methodParameter = operationEntry.Parameters[paramIndex];
object value = (parameters.Length > paramIndex ? parameters[paramIndex] : null);
ValidationContext parameterContext = ValidationUtilities.CreateValidationContext(validationContext.ObjectInstance, validationContext);
parameterContext.MemberName = methodParameter.Name;
string paramName = methodParameter.Name;
AttributeCollection parameterAttributes = methodParameter.Attributes;
display = (DisplayAttribute)parameterAttributes[typeof(DisplayAttribute)];
if (display != null)
{
paramName = display.GetName();
}
parameterContext.DisplayName = paramName;
string parameterPath = string.Empty;
if (!string.IsNullOrEmpty(methodPath) && paramIndex > 0)
{
parameterPath = methodPath + methodParameter.Name;
}
IEnumerable <ValidationAttribute> parameterValidationAttributes = parameterAttributes.OfType <ValidationAttribute>();
bool parameterSuccess = ValidationUtilities.ValidateValue(value, parameterContext, validationResults, parameterValidationAttributes,
ValidationUtilities.NormalizeMemberPath(parameterPath, methodParameter.ParameterType));
// Custom methods run deep validation as well as parameter validation.
// If parameter validation has already failed, stop further validation.
if (parameterSuccess && operationEntry.Operation == DomainOperation.Custom && value != null)
{
Type parameterType = methodParameter.ParameterType;
if (TypeUtility.IsComplexType(parameterType))
{
parameterSuccess = ValidationUtilities.ValidateObjectRecursive(value, parameterPath, parameterContext, validationResults);
}
else if (TypeUtility.IsComplexTypeCollection(parameterType))
{
parameterSuccess = ValidationUtilities.ValidateComplexCollection(value as IEnumerable, parameterPath, parameterContext, validationResults);
}
}
success &= parameterSuccess;
if (breakOnFirstError && !success)
{
break;
}
}
}
return(success);
}
private static string GetSharedRendererDisplayName(ISharedRenderer sharedRenderer) => $"Shared: {DisplayAttribute.GetDisplayName(sharedRenderer.GetType())}";
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;
}
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;
}
}
DataTypeAttribute dataTypeAttribute = attributeList.OfType <DataTypeAttribute>().FirstOrDefault();
DisplayFormatAttribute displayFormatAttribute = attributeList.OfType <DisplayFormatAttribute>().FirstOrDefault();
SetFromDataTypeAndDisplayAttributes(result, dataTypeAttribute, displayFormatAttribute);
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);
}
/// <summary>
/// 返回属性的数据规则和约束条件
/// </summary>
/// <param name="prop"></param>
/// <returns></returns>
CatalogExtAttribute GetAdvDataRule(PropertyInfo prop)
{
var attrs = prop.GetCustomAttributes(true);
CatalogExtAttribute extAttr = attrs.FirstOrDefault(attr => attr is CatalogExtAttribute) as CatalogExtAttribute;
if (extAttr == null)
{
extAttr = new CatalogExtAttribute();
if (prop.Name == "Id")
{
extAttr.Editable = false;
extAttr.DataType = ExtDataType.SingleLineText;
}
if (prop.PropertyType.IsValueType && !prop.PropertyType.IsNullableType())
{
extAttr.AllowNull = false;
}
}
if (extAttr.Name.IsEmpty())
{
extAttr.Name = prop.Name;
}
RequiredAttribute required = attrs.FirstOrDefault(attr => attr is RequiredAttribute) as RequiredAttribute;
if (required != null)
{
extAttr.AllowNull = false;
}
StringLengthAttribute stringLen = attrs.FirstOrDefault(attr => attr is StringLengthAttribute) as StringLengthAttribute;
if (stringLen != null)
{
extAttr.MaxLength = stringLen.MaximumLength;
extAttr.MinLength = stringLen.MinimumLength;
}
DisplayColumnAttribute displayProp = attrs.FirstOrDefault(attr => attr is DisplayColumnAttribute) as DisplayColumnAttribute;
if (displayProp != null)
{
extAttr.DisplayProperty = displayProp.DisplayColumn;
}
DisplayFormatAttribute displayFmt = attrs.FirstOrDefault(attr => attr is DisplayFormatAttribute) as DisplayFormatAttribute;
if (displayFmt != null)
{
extAttr.DisplayFormat = displayFmt.DataFormatString;
}
RegularExpressionAttribute reg = attrs.FirstOrDefault(attr => attr is RegularExpressionAttribute) as RegularExpressionAttribute;
if (reg != null)
{
extAttr.RegExpr = reg.Pattern;
}
RangeAttribute rng = attrs.FirstOrDefault(attr => attr is RangeAttribute) as RangeAttribute;
if (rng != null)
{
extAttr.MinValue = rng.Minimum;
extAttr.MaxValue = rng.Maximum;
}
DisplayAttribute dsp = attrs.FirstOrDefault(attr => attr is DisplayAttribute) as DisplayAttribute;
if (dsp != null)
{
extAttr.Name = dsp.Name;
}
BrowsableAttribute brw = attrs.FirstOrDefault(attr => attr is BrowsableAttribute) as BrowsableAttribute;
if (brw != null)
{
extAttr.Browsable = brw.Browsable;
}
if (extAttr.DataType == ExtDataType.Auto)
{
Type type = prop.PropertyType;
if (type.IsNullableType())
{
type = type.GetGenericArguments()[0];
}
if (type.IsEnum)
{
}
else if (type == typeof(DateTime))
{
extAttr.DataType = ExtDataType.Date;
}
else if (type == typeof(bool))
{
extAttr.DataType = ExtDataType.Bool;
}
else if (type == typeof(decimal))
{
extAttr.DataType = ExtDataType.Currency;
}
else if (type == typeof(float) || type == typeof(double))
{
extAttr.DataType = ExtDataType.FloatNumber;
}
else if (type.IsValueType)
{
extAttr.DataType = ExtDataType.SingleNumber;
}
}
if (!extAttr.LinkedProperty.IsEmpty() && extAttr.DisplayProperty.IsEmpty())
{
extAttr.DisplayProperty = extAttr.Name;
}
if (extAttr.DisplayFormat == null)
{
switch (extAttr.DataType)
{
case ExtDataType.Date:
extAttr.DisplayFormat = "yyyy-MM-dd";
break;
case ExtDataType.DateAndTime:
extAttr.DisplayFormat = "yyyy-MM-dd HH:mm:ss";
break;
case ExtDataType.FloatNumber:
extAttr.DisplayFormat = "#0.00";
//extAttr.MaxValue = int.MaxValue;
break;
case ExtDataType.SingleNumber:
extAttr.DisplayFormat = "#0";
//extAttr.MaxValue = int.MaxValue;
break;
case ExtDataType.Currency:
char currChar = 100.ToString("C")[0];
extAttr.DisplayFormat = currChar + "#0.00";
//extAttr.MaxValue = int.MaxValue;
break;
case ExtDataType.Percent:
extAttr.DisplayFormat = "p2";
//extAttr.MaxValue = 1;
break;
case ExtDataType.Time:
extAttr.DisplayFormat = "H:mm";
break;
}
}
if (extAttr.InputFormat == null)
{
extAttr.InputFormat = extAttr.DisplayFormat;
}
switch (extAttr.DataType)
{
case ExtDataType.FloatNumber:
case ExtDataType.SingleNumber:
case ExtDataType.Currency:
case ExtDataType.Percent:
if (extAttr.MaxValue == null && extAttr.MinValue == null)
{
extAttr.MinValue = 0;
extAttr.MaxValue = int.MaxValue;
}
break;
}
extAttr.Property = prop;
return(extAttr);
}
private void DiscoverRecordFields(Type recordType, string declaringMember, bool optIn = false)
{
if (!recordType.IsDynamicType())
{
Type pt = null;
int startIndex = 0;
int size = 0;
if (optIn) //ChoTypeDescriptor.GetProperties(recordType).Where(pd => pd.Attributes.OfType<ChoFixedLengthRecordFieldAttribute>().Any()).Any())
{
foreach (PropertyDescriptor pd in ChoTypeDescriptor.GetProperties(recordType))
{
pt = pd.PropertyType.GetUnderlyingType();
if (!pt.IsSimple() && !typeof(IEnumerable).IsAssignableFrom(pt))
{
DiscoverRecordFields(pt, declaringMember == null ? pd.Name : "{0}.{1}".FormatString(declaringMember, pd.Name), optIn);
}
else if (pd.Attributes.OfType <ChoFixedLengthRecordFieldAttribute>().Any())
{
var obj = new ChoFixedLengthRecordFieldConfiguration(pd.Name, pd.Attributes.OfType <ChoFixedLengthRecordFieldAttribute>().First(), pd.Attributes.OfType <Attribute>().ToArray());
obj.FieldType = pt;
obj.PropertyDescriptor = pd;
obj.DeclaringMember = declaringMember == null ? null : "{0}.{1}".FormatString(declaringMember, pd.Name);
if (!FixedLengthRecordFieldConfigurations.Any(c => c.Name == pd.Name))
{
FixedLengthRecordFieldConfigurations.Add(obj);
}
}
}
}
else
{
foreach (PropertyDescriptor pd in ChoTypeDescriptor.GetProperties(recordType))
{
pt = pd.PropertyType.GetUnderlyingType();
if (pt != typeof(object) && !pt.IsSimple() && !typeof(IEnumerable).IsAssignableFrom(pt))
{
DiscoverRecordFields(pt, declaringMember == null ? pd.Name : "{0}.{1}".FormatString(declaringMember, pd.Name), optIn);
}
else
{
if (FixedLengthFieldDefaultSizeConfiguation == null)
{
size = ChoFixedLengthFieldDefaultSizeConfiguation.Instance.GetSize(pd.PropertyType);
}
else
{
size = FixedLengthFieldDefaultSizeConfiguation.GetSize(pd.PropertyType);
}
var obj = new ChoFixedLengthRecordFieldConfiguration(pd.Name, startIndex, size);
obj.FieldType = pt;
obj.PropertyDescriptor = pd;
obj.DeclaringMember = declaringMember == null ? null : "{0}.{1}".FormatString(declaringMember, pd.Name);
StringLengthAttribute slAttr = pd.Attributes.OfType <StringLengthAttribute>().FirstOrDefault();
if (slAttr != null && slAttr.MaximumLength > 0)
{
obj.Size = slAttr.MaximumLength;
}
DisplayAttribute dpAttr = pd.Attributes.OfType <DisplayAttribute>().FirstOrDefault();
if (dpAttr != null)
{
if (!dpAttr.ShortName.IsNullOrWhiteSpace())
{
obj.FieldName = dpAttr.ShortName;
}
else if (!dpAttr.Name.IsNullOrWhiteSpace())
{
obj.FieldName = dpAttr.Name;
}
}
DisplayFormatAttribute dfAttr = pd.Attributes.OfType <DisplayFormatAttribute>().FirstOrDefault();
if (dfAttr != null && !dfAttr.DataFormatString.IsNullOrWhiteSpace())
{
obj.FormatText = dfAttr.DataFormatString;
}
if (dfAttr != null && !dfAttr.NullDisplayText.IsNullOrWhiteSpace())
{
obj.NullValue = dfAttr.NullDisplayText;
}
if (!FixedLengthRecordFieldConfigurations.Any(c => c.Name == pd.Name))
{
FixedLengthRecordFieldConfigurations.Add(obj);
}
startIndex += size;
}
}
}
}
}
private void DiscoverRecordFields(Type recordType, string declaringMember, bool optIn = false)
{
if (!recordType.IsDynamicType())
{
Type pt = null;
if (ChoTypeDescriptor.GetProperties(recordType).Where(pd => pd.Attributes.OfType <ChoJSONRecordFieldAttribute>().Any()).Any())
{
foreach (PropertyDescriptor pd in ChoTypeDescriptor.GetProperties(recordType))
{
pt = pd.PropertyType.GetUnderlyingType();
bool optIn1 = ChoTypeDescriptor.GetProperties(pt).Where(pd1 => pd1.Attributes.OfType <ChoJSONRecordFieldAttribute>().Any()).Any();
if (optIn1 && !pt.IsSimple() && !typeof(IEnumerable).IsAssignableFrom(pt) && FlatToNestedObjectSupport)
{
DiscoverRecordFields(pt, declaringMember == null ? pd.Name : "{0}.{1}".FormatString(declaringMember, pd.Name), optIn1);
}
else if (pd.Attributes.OfType <ChoJSONRecordFieldAttribute>().Any())
{
var obj = new ChoJSONRecordFieldConfiguration(pd.Name, pd.Attributes.OfType <ChoJSONRecordFieldAttribute>().First(), pd.Attributes.OfType <Attribute>().ToArray());
obj.FieldType = pt;
obj.PropertyDescriptor = pd;
obj.DeclaringMember = declaringMember == null ? null : "{0}.{1}".FormatString(declaringMember, pd.Name);
if (!JSONRecordFieldConfigurations.Any(c => c.Name == pd.Name))
{
JSONRecordFieldConfigurations.Add(obj);
}
}
}
}
else
{
foreach (PropertyDescriptor pd in ChoTypeDescriptor.GetProperties(recordType))
{
pt = pd.PropertyType.GetUnderlyingType();
if (pt != typeof(object) && !pt.IsSimple() && !typeof(IEnumerable).IsAssignableFrom(pt) && FlatToNestedObjectSupport)
{
DiscoverRecordFields(pt, declaringMember == null ? pd.Name : "{0}.{1}".FormatString(declaringMember, pd.Name), optIn);
}
else
{
var obj = new ChoJSONRecordFieldConfiguration(pd.Name, (string)null);
obj.FieldType = pt;
obj.PropertyDescriptor = pd;
obj.DeclaringMember = declaringMember == null ? null : "{0}.{1}".FormatString(declaringMember, pd.Name);
StringLengthAttribute slAttr = pd.Attributes.OfType <StringLengthAttribute>().FirstOrDefault();
if (slAttr != null && slAttr.MaximumLength > 0)
{
obj.Size = slAttr.MaximumLength;
}
ChoUseJSONSerializationAttribute sAttr = pd.Attributes.OfType <ChoUseJSONSerializationAttribute>().FirstOrDefault();
if (sAttr != null)
{
obj.UseJSONSerialization = true;
}
DisplayAttribute dpAttr = pd.Attributes.OfType <DisplayAttribute>().FirstOrDefault();
if (dpAttr != null)
{
if (!dpAttr.ShortName.IsNullOrWhiteSpace())
{
obj.FieldName = dpAttr.ShortName;
}
else if (!dpAttr.Name.IsNullOrWhiteSpace())
{
obj.FieldName = dpAttr.Name;
}
}
DisplayFormatAttribute dfAttr = pd.Attributes.OfType <DisplayFormatAttribute>().FirstOrDefault();
if (dfAttr != null && !dfAttr.DataFormatString.IsNullOrWhiteSpace())
{
obj.FormatText = dfAttr.DataFormatString;
}
if (dfAttr != null && !dfAttr.NullDisplayText.IsNullOrWhiteSpace())
{
obj.NullValue = dfAttr.NullDisplayText;
}
if (!JSONRecordFieldConfigurations.Any(c => c.Name == pd.Name))
{
JSONRecordFieldConfigurations.Add(obj);
}
}
}
}
}
}
public void DisplayAttribute_Fail_No_Getter_Resource() {
DisplayAttribute attr = new DisplayAttribute();
attr.ResourceType = typeof(DisplayAttribute_Resources);
attr.ShortName = "NoGetter";
attr.Name = "NoGetter";
attr.Prompt = "NoGetter";
attr.Description = "NoGetter";
attr.GroupName = "NoGetter";
string shortNameError = String.Format(CultureInfo.CurrentCulture, Resources.DataAnnotationsResources.LocalizableString_LocalizationFailed, "ShortName", attr.ResourceType.FullName, attr.ShortName);
string nameError = String.Format(CultureInfo.CurrentCulture, Resources.DataAnnotationsResources.LocalizableString_LocalizationFailed, "Name", attr.ResourceType.FullName, attr.Name);
string promptError = String.Format(CultureInfo.CurrentCulture, Resources.DataAnnotationsResources.LocalizableString_LocalizationFailed, "Prompt", attr.ResourceType.FullName, attr.Prompt);
string descriptionError = String.Format(CultureInfo.CurrentCulture, Resources.DataAnnotationsResources.LocalizableString_LocalizationFailed, "Description", attr.ResourceType.FullName, attr.Description);
string groupNameError = String.Format(CultureInfo.CurrentCulture, Resources.DataAnnotationsResources.LocalizableString_LocalizationFailed, "GroupName", attr.ResourceType.FullName, attr.GroupName);
ExceptionHelper.ExpectException<InvalidOperationException>(() => { string s = attr.GetShortName(); }, shortNameError);
ExceptionHelper.ExpectException<InvalidOperationException>(() => { string s = attr.GetName(); }, nameError);
ExceptionHelper.ExpectException<InvalidOperationException>(() => { string s = attr.GetPrompt(); }, promptError);
ExceptionHelper.ExpectException<InvalidOperationException>(() => { string s = attr.GetDescription(); }, descriptionError);
ExceptionHelper.ExpectException<InvalidOperationException>(() => { string s = attr.GetGroupName(); }, groupNameError);
}
private Type DiscoverRecordFields(Type recordType, string declaringMember, bool optIn = false,
List <ChoYamlRecordFieldConfiguration> recordFieldConfigurations = null, bool isTop = false)
{
if (recordType == null)
{
return(recordType);
}
if (!recordType.IsDynamicType())
{
Type pt = null;
if (ChoTypeDescriptor.GetProperties(recordType).Where(pd => pd.Attributes.OfType <ChoYamlRecordFieldAttribute>().Any()).Any())
{
foreach (PropertyDescriptor pd in ChoTypeDescriptor.GetProperties(recordType))
{
pt = pd.PropertyType.GetUnderlyingType();
bool optIn1 = ChoTypeDescriptor.GetProperties(pt).Where(pd1 => pd1.Attributes.OfType <ChoYamlRecordFieldAttribute>().Any()).Any();
if (optIn1 && !pt.IsSimple() && !typeof(IEnumerable).IsAssignableFrom(pt) && FlatToNestedObjectSupport)
{
DiscoverRecordFields(pt, declaringMember == null ? pd.Name : "{0}.{1}".FormatString(declaringMember, pd.Name), optIn1, recordFieldConfigurations, false);
}
else if (pd.Attributes.OfType <ChoYamlRecordFieldAttribute>().Any())
{
var obj = new ChoYamlRecordFieldConfiguration(pd.Name, pd.Attributes.OfType <ChoYamlRecordFieldAttribute>().First(), pd.Attributes.OfType <Attribute>().ToArray());
obj.FieldType = pt;
obj.PropertyDescriptor = pd;
obj.DeclaringMember = declaringMember == null ? pd.Name : "{0}.{1}".FormatString(declaringMember, pd.Name);
if (recordFieldConfigurations != null)
{
if (!recordFieldConfigurations.Any(c => c.Name == pd.Name))
{
recordFieldConfigurations.Add(obj);
}
}
}
}
}
else
{
if (isTop)
{
if (typeof(IList).IsAssignableFrom(recordType))
{
throw new ChoParserException("Record type not supported.");
}
else if (typeof(IDictionary <string, object>).IsAssignableFrom(recordType))
{
recordType = typeof(ExpandoObject);
return(recordType);
}
else if (typeof(IDictionary).IsAssignableFrom(recordType))
{
recordType = typeof(ExpandoObject);
return(recordType);
}
}
if (recordType.IsSimple())
{
var obj = new ChoYamlRecordFieldConfiguration("Value", "$.Value");
obj.FieldType = recordType;
recordFieldConfigurations.Add(obj);
return(recordType);
}
foreach (PropertyDescriptor pd in ChoTypeDescriptor.GetProperties(recordType))
{
ChoYamlIgnoreAttribute jiAttr = pd.Attributes.OfType <ChoYamlIgnoreAttribute>().FirstOrDefault();
if (jiAttr != null)
{
continue;
}
pt = pd.PropertyType.GetUnderlyingType();
if (pt != typeof(object) && !pt.IsSimple() && !typeof(IEnumerable).IsAssignableFrom(pt) && FlatToNestedObjectSupport)
{
DiscoverRecordFields(pt, declaringMember == null ? pd.Name : "{0}.{1}".FormatString(declaringMember, pd.Name), optIn, recordFieldConfigurations, false);
}
else
{
var obj = new ChoYamlRecordFieldConfiguration(pd.Name, (string)null);
obj.FieldType = pt;
obj.PropertyDescriptor = pd;
obj.DeclaringMember = declaringMember == null ? pd.Name : "{0}.{1}".FormatString(declaringMember, pd.Name);
StringLengthAttribute slAttr = pd.Attributes.OfType <StringLengthAttribute>().FirstOrDefault();
if (slAttr != null && slAttr.MaximumLength > 0)
{
obj.Size = slAttr.MaximumLength;
}
//ChoUseYamlSerializationAttribute sAttr = pd.Attributes.OfType<ChoUseYamlSerializationAttribute>().FirstOrDefault();
//if (sAttr != null)
// obj.UseYamlSerialization = sAttr.Flag;
ChoYamlPathAttribute jpAttr = pd.Attributes.OfType <ChoYamlPathAttribute>().FirstOrDefault();
if (jpAttr != null)
{
obj.YamlPath = jpAttr.YamlPath;
}
ChoYamPropertyAttribute jAttr = pd.Attributes.OfType <ChoYamPropertyAttribute>().FirstOrDefault();
if (jAttr != null && !jAttr.PropertyName.IsNullOrWhiteSpace())
{
obj.FieldName = jAttr.PropertyName;
}
else
{
DisplayNameAttribute dnAttr = pd.Attributes.OfType <DisplayNameAttribute>().FirstOrDefault();
if (dnAttr != null && !dnAttr.DisplayName.IsNullOrWhiteSpace())
{
obj.FieldName = dnAttr.DisplayName.Trim();
}
else
{
DisplayAttribute dpAttr = pd.Attributes.OfType <DisplayAttribute>().FirstOrDefault();
if (dpAttr != null)
{
if (!dpAttr.ShortName.IsNullOrWhiteSpace())
{
obj.FieldName = dpAttr.ShortName;
}
else if (!dpAttr.Name.IsNullOrWhiteSpace())
{
obj.FieldName = dpAttr.Name;
}
obj.Order = dpAttr.Order;
}
else
{
ColumnAttribute clAttr = pd.Attributes.OfType <ColumnAttribute>().FirstOrDefault();
if (clAttr != null)
{
obj.Order = clAttr.Order;
if (!clAttr.Name.IsNullOrWhiteSpace())
{
obj.FieldName = clAttr.Name;
}
}
}
}
}
DisplayFormatAttribute dfAttr = pd.Attributes.OfType <DisplayFormatAttribute>().FirstOrDefault();
if (dfAttr != null && !dfAttr.DataFormatString.IsNullOrWhiteSpace())
{
obj.FormatText = dfAttr.DataFormatString;
}
if (dfAttr != null && !dfAttr.NullDisplayText.IsNullOrWhiteSpace())
{
obj.NullValue = dfAttr.NullDisplayText;
}
if (recordFieldConfigurations != null)
{
if (!recordFieldConfigurations.Any(c => c.Name == pd.Name))
{
recordFieldConfigurations.Add(obj);
}
}
}
}
}
}
return(recordType);
}
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 static List <Property> GetProperties(Type type)
{
List <Property> properties = new List <Property>();
List <PropertyInfo> _properties = type.GetProperties().ToList();
for (var i = 0; i < _properties.Count(); i++)
{
DisplayAttribute _display = (DisplayAttribute)_properties.ElementAt(i).GetCustomAttributes(typeof(DisplayAttribute), true).FirstOrDefault();
if (_display != null)
{
Property property = new Property()
{
Description = _display.Description,
Name = _display.Name,
AutoGenerateField = _display.AutoGenerateField,
Order = _display.Order,
Minimum = 0,
Maximum = Int64.MaxValue,
Required = false,
Type_Description = "",
AutoGenerateFilter = _display.AutoGenerateFilter
};
property.Name = property.Name[0].ToString().ToLower() + property.Name.Substring(1);
RequiredAttribute required = (RequiredAttribute)_properties.ElementAt(i).GetCustomAttributes(typeof(RequiredAttribute), true).FirstOrDefault();
if (required != null)
{
property.Required = true;
}
else
{
property.Required = false;
}
StringLengthAttribute stringLength = (StringLengthAttribute)_properties.ElementAt(i).GetCustomAttributes(typeof(StringLengthAttribute), true).FirstOrDefault();
if (stringLength != null)
{
property.Minimum = stringLength.MinimumLength;
property.Maximum = stringLength.MaximumLength;
}
switch (Type.GetTypeCode(_properties.ElementAt(i).PropertyType))
{
case TypeCode.String:
property.Type_Description = "string";
break;
case TypeCode.Int16:
case TypeCode.Int32:
case TypeCode.Int64:
case TypeCode.UInt16:
case TypeCode.UInt32:
case TypeCode.UInt64:
property.Type_Description = "int";
break;
case TypeCode.Boolean:
property.Type_Description = "boolean";
break;
case TypeCode.Char:
property.Type_Description = "char";
break;
case TypeCode.DateTime:
property.Type_Description = "datetime";
break;
case TypeCode.Decimal:
case TypeCode.Double:
case TypeCode.Single:
property.Type_Description = "decimal";
break;
case TypeCode.Object:
List <Type> int_types = new List <Type>();
int_types.Add(typeof(Nullable <Int16>));
int_types.Add(typeof(Nullable <Int32>));
int_types.Add(typeof(Nullable <Int64>));
int_types.Add(typeof(Nullable <UInt16>));
int_types.Add(typeof(Nullable <UInt32>));
int_types.Add(typeof(Nullable <UInt64>));
List <Type> decimal_types = new List <Type>();
decimal_types.Add(typeof(Nullable <Decimal>));
decimal_types.Add(typeof(Nullable <Double>));
decimal_types.Add(typeof(Nullable <Single>));
if (int_types.Contains(_properties.ElementAt(i).PropertyType))
{
property.Type_Description = "int";
}
if (decimal_types.Contains(_properties.ElementAt(i).PropertyType))
{
property.Type_Description = "decimal";
}
if (_properties.ElementAt(i).PropertyType == typeof(Nullable <DateTime>))
{
property.Type_Description = "datetime";
}
if (property.Type_Description.Length == 0)
{
property.Type_Description = _properties.ElementAt(i).PropertyType.ToString();
}
break;
}
ReadOnlyAttribute isreadonly = (ReadOnlyAttribute)_properties.ElementAt(i).GetCustomAttributes(typeof(ReadOnlyAttribute), true).FirstOrDefault();
if (isreadonly != null)
{
property.ReadOnly = isreadonly.IsReadOnly;
}
else
{
property.ReadOnly = false;
}
properties.Add(property);
}
}
return(properties.OrderBy(e => e.Order).ToList());
}
public void DisplayAttribute_AutoGenerateFilter_Can_Be_Set_And_Retrieved() {
DisplayAttribute attr = new DisplayAttribute { AutoGenerateFilter = true };
Assert.IsTrue(attr.AutoGenerateFilter, "AutoGenerateFilter should be true after setting it to true");
Assert.IsTrue(attr.GetAutoGenerateFilter().Value, "GetAutoGenerateFilter should be true after setting it to true");
attr = new DisplayAttribute { AutoGenerateFilter = false };
Assert.IsFalse(attr.AutoGenerateFilter, "AutoGenerateFilter should be false after setting it to false");
Assert.IsFalse(attr.GetAutoGenerateFilter().Value, "GetAutoGenerateFilter should be false after setting it to false");
}
public void ResourceType_Get_Set(Type value)
{
DisplayAttribute attribute = new DisplayAttribute();
attribute.ResourceType = value;
Assert.Equal(value, attribute.ResourceType);
// Set again, to cover the setter avoiding operations if the value is the same
attribute.ResourceType = value;
Assert.Equal(value, attribute.ResourceType);
}
public void DisplayAttribute_GetShortName_Falls_Back_Onto_Localized_Name() {
DisplayAttribute attr = new DisplayAttribute { ResourceType = typeof(DisplayAttribute_Resources), Name = "Resource1" };
Assert.AreEqual(DisplayAttribute_Resources.Resource1, attr.GetShortName(), "GetShortName should return the localized Name when ShortName is null");
}
public void Order_Get_Set(int value)
{
DisplayAttribute attribute = new DisplayAttribute();
attribute.Order = value;
Assert.Equal(value, attribute.Order);
Assert.Equal(value, attribute.GetOrder());
}
SortableColumn CreateColumnHeader(System.Reflection.PropertyInfo propertyInfo, DisplayAttribute attr)
{
return(CreateColumnHeader(propertyInfo.Name, attr.Name, 0.15, true, new ColumnCellText(null, true)));
}
public void Order_Get_NotSet_ThrowsInvalidOperationException()
{
DisplayAttribute attribute = new DisplayAttribute();
Assert.Throws<InvalidOperationException>(() => attribute.Order);
Assert.Null(attribute.GetOrder());
}
protected override void OnInitialized()
{
display = Prop.GetCustomAttribute <DisplayAttribute>();
}
public List <DataAnnotationsDetails> GetDataAnnotationsDetailsList(string className)
{
object currentClassInstance = CreateClassByName(className);
PropertyDescriptorCollection properties = TypeDescriptor.GetProperties(currentClassInstance, true);
List <DataAnnotationsDetails> listFieldDetails = new List <DataAnnotationsDetails>();
foreach (PropertyDescriptor property in properties)
{
AttributeCollection attributes = property.Attributes;
RequiredAttribute requiredAttribute = (RequiredAttribute)attributes[typeof(RequiredAttribute)];
DisplayAttribute displayAttribute = (DisplayAttribute)attributes[typeof(DisplayAttribute)];
DisplayFormatAttribute displayFormatAttribute = (DisplayFormatAttribute)attributes[typeof(DisplayFormatAttribute)];
string displayName = "", shortName = "", prompt = "", description = "", groupName = "", dataFormatString = "", nullDisplayText = "", attributeList = "";
displayName = property.DisplayName;
if (displayAttribute != null)
{
// DisplayName and Description both have single purpose attributes
displayName = displayAttribute.Name ?? displayName;
description = displayAttribute.Description ?? description;
shortName = displayAttribute.ShortName ?? "";
prompt = displayAttribute.Prompt ?? "";
groupName = displayAttribute.GroupName ?? "";
}
if (displayFormatAttribute != null)
{
dataFormatString = displayFormatAttribute.DataFormatString ?? "";
nullDisplayText = displayFormatAttribute.NullDisplayText ?? "";
}
foreach (Attribute attr in property.Attributes)
{
attributeList += attr.GetType().Name + ",";
}
DataAnnotationsDetails dad = new DataAnnotationsDetails
{
Name = property.Name,
DisplayName = displayName,
ShortName = shortName,
Prompt = prompt,
GroupName = groupName,
Description = description,
Category = property.Category,
DataFormatString = dataFormatString,
NullDisplayText = nullDisplayText,
Required = (requiredAttribute != null),
Attributes = attributeList.TrimEnd(','),
Browsable = property.IsBrowsable,
PropertyType = property.PropertyType.Name,
SerializationVisibility = property.SerializationVisibility.ToString()
};
if (requiredAttribute != null)
{
dad.ErrorMessage = requiredAttribute.ErrorMessage;
}
listFieldDetails.Add(dad);
}
return(listFieldDetails);
}
public void AutoGenerateFilter_Get_Set(bool value)
{
DisplayAttribute attribute = new DisplayAttribute();
attribute.AutoGenerateFilter = value;
Assert.Equal(value, attribute.AutoGenerateFilter);
Assert.Equal(value, attribute.GetAutoGenerateFilter());
}
public void TestGetAttribute()
{
DisplayAttribute attribute = Lambda.GetAttribute <Sample, string, DisplayAttribute>(t => t.StringValue);
Assert.Equal("字符串值", attribute.Name);
}
public void AutoGenerateField_Get_NotSet_ThrowsInvalidOperationException()
{
DisplayAttribute attribute = new DisplayAttribute();
Assert.Throws<InvalidOperationException>(() => attribute.AutoGenerateField);
Assert.Null(attribute.GetAutoGenerateField());
}
internal ChoJSONRecordFieldConfiguration(string name, ChoJSONRecordFieldAttribute attr = null, Attribute[] otherAttrs = null) : base(name, attr, otherAttrs)
{
//IsArray = false;
FieldName = name;
if (attr != null)
{
Order = attr.Order;
JSONPath = attr.JSONPath;
UseJSONSerialization = attr.UseJSONSerializationInternal;
FieldName = attr.FieldName.IsNullOrWhiteSpace() ? Name.NTrim() : attr.FieldName.NTrim();
}
if (otherAttrs != null)
{
var sa = otherAttrs.OfType <ChoSourceTypeAttribute>().FirstOrDefault();
if (sa != null)
{
SourceType = sa.Type;
}
StringLengthAttribute slAttr = otherAttrs.OfType <StringLengthAttribute>().FirstOrDefault();
if (slAttr != null && slAttr.MaximumLength > 0)
{
Size = slAttr.MaximumLength;
}
ChoUseJSONSerializationAttribute sAttr = otherAttrs.OfType <ChoUseJSONSerializationAttribute>().FirstOrDefault();
if (sAttr != null)
{
UseJSONSerialization = sAttr.Flag;
}
ChoJSONPathAttribute jpAttr = otherAttrs.OfType <ChoJSONPathAttribute>().FirstOrDefault();
if (jpAttr != null)
{
JSONPath = jpAttr.JSONPath;
}
JsonPropertyAttribute jAttr = otherAttrs.OfType <JsonPropertyAttribute>().FirstOrDefault();
if (jAttr != null && !jAttr.PropertyName.IsNullOrWhiteSpace())
{
FieldName = jAttr.PropertyName;
JSONPath = jAttr.PropertyName;
Order = jAttr.Order;
}
else
{
DisplayNameAttribute dnAttr = otherAttrs.OfType <DisplayNameAttribute>().FirstOrDefault();
if (dnAttr != null && !dnAttr.DisplayName.IsNullOrWhiteSpace())
{
FieldName = dnAttr.DisplayName.Trim();
}
else
{
DisplayAttribute dpAttr = otherAttrs.OfType <DisplayAttribute>().FirstOrDefault();
if (dpAttr != null)
{
if (!dpAttr.ShortName.IsNullOrWhiteSpace())
{
FieldName = dpAttr.ShortName;
}
else if (!dpAttr.Name.IsNullOrWhiteSpace())
{
FieldName = dpAttr.Name;
}
Order = dpAttr.Order;
}
else
{
ColumnAttribute clAttr = otherAttrs.OfType <ColumnAttribute>().FirstOrDefault();
if (clAttr != null)
{
Order = clAttr.Order;
if (!clAttr.Name.IsNullOrWhiteSpace())
{
FieldName = clAttr.Name;
}
}
}
}
}
DisplayFormatAttribute dfAttr = otherAttrs.OfType <DisplayFormatAttribute>().FirstOrDefault();
if (dfAttr != null && !dfAttr.DataFormatString.IsNullOrWhiteSpace())
{
FormatText = dfAttr.DataFormatString;
}
if (dfAttr != null && !dfAttr.NullDisplayText.IsNullOrWhiteSpace())
{
NullValue = dfAttr.NullDisplayText;
}
}
}
/// <summary>
/// 根据枚举变量获取对应枚举类型的所有值的 Description 、 DisplayName 或 Display(Name= 特性值
/// </summary>
/// <param name="obj"></param>
/// <param name="spliter"></param>
/// <returns></returns>
public static string GetMutiEnumDescription(this object obj, string spliter = ",")
{
if (obj == null)
{
return(string.Empty);
}
try
{
Type type = obj.GetType();
if (type.IsEnum)
{
var flagValues = Enum.GetValues(type);
Dictionary <object, string> vd = new Dictionary <object, string>();
//DescriptionAttribute da = null;
//FieldInfo fi = type.GetField(Enum.GetName(type, obj));
// da = (DescriptionAttribute)Attribute.GetCustomAttribute(fi, typeof(DescriptionAttribute));
foreach (var v in flagValues)
{
FieldInfo fi = type.GetField(Enum.GetName(type, obj));
var attrs = fi.GetCustomAttributes(false);
if (attrs.Any(i => i.GetType() == typeof(DescriptionAttribute)))
{
DescriptionAttribute desc = (DescriptionAttribute)attrs.Where(i => i.GetType() == typeof(DescriptionAttribute)).FirstOrDefault();
vd.Add(v, desc.Description);
}
else if (attrs.Any(i => i.GetType() == typeof(DisplayNameAttribute)))
{
DisplayNameAttribute desc = (DisplayNameAttribute)attrs.Where(i => i.GetType() == typeof(DisplayNameAttribute)).FirstOrDefault();
vd.Add(v, desc.DisplayName);
}
else if (attrs.Any(i => i.GetType() == typeof(DisplayAttribute)))
{
DisplayAttribute desc = (DisplayAttribute)attrs.Where(i => i.GetType() == typeof(DisplayAttribute)).FirstOrDefault();
vd.Add(v, desc.Name);
}
}
List <string> descs = new List <string>();
int realValue = (int)obj;
foreach (var x in flagValues)
{
var temp = (int)x;
if ((realValue & temp) == temp)
{
if (vd.ContainsKey(x))
{
descs.Add(vd[x]);
}
else
{
descs.Add(x.ToString());
}
}
}
return(descs.Aggregate((s, r) => { return string.Format("{0}{1}{2}", s, spliter, r); }));
}
}
catch
{
}
return(string.Empty);
}
public static string GetDescription(this TreasureClass?prop)
{
DisplayAttribute description = prop.GetAttributeOfType <DisplayAttribute>();
return(description?.Description ?? prop?.ToString() ?? "");
}
