/// <summary>
/// Ordnet dem Namen einer Eigenschaft den zugehörigen Namen der Tabellenspalte in der Datenbanktabelle zu
/// </summary>
/// <param name="propName"></param>
/// <returns></returns>
public static string mapPropertyToColName(Type boRecordType, string propName)
{
if (typeof(TEntity) == typeof(TEntityView))
{
return(propName);
}
System.Reflection.PropertyInfo pinfo = boRecordType.GetProperty(propName);
#if (DEBUG)
if (pinfo == null)
{
// Liste aller Eigenschaften
Debug.WriteLine(boRecordType.Name + "-Eigenschaften:");
foreach (System.Reflection.PropertyInfo pi in boRecordType.GetProperties())
{
Debug.WriteLine(" + hat Eigenschaft " + pi.Name);
}
}
#endif
Debug.Assert(pinfo != null, "Die Eigenschaft " + propName + " existiert nicht im Business- Objekt " + boRecordType.Name);
// Falls ein MapPropertytoColName- Attribut existiert, wird der Spaltenname aus diesem gelesen und
// zurückgegeben, sonst der Name der Eigenschaft
if (pinfo.GetCustomAttributes(typeof(mkoIt.Db.MapPropertyToColNameAttribute), false).Count() > 0)
{
mkoIt.Db.MapPropertyToColNameAttribute att = pinfo.GetCustomAttributes(typeof(mkoIt.Db.MapPropertyToColNameAttribute), false)[0] as mkoIt.Db.MapPropertyToColNameAttribute;
return(att == null ? propName : att.ColName);
}
else
{
return(propName);
}
}
//ALTER TABLE tool ADD ID INT UNSIGNED
/// <summary>
/// If mysqltable attribute is used and the columnname is defined, then this columnname will be returned. if not defined the name of the property will be returned.
/// If neither of the properties use the mysqltable attribute, the name of the property will be returned, else exception will be thrown
/// </summary>
public static string GetPropertyDatabaseColumnName(System.Reflection.PropertyInfo property, System.Reflection.PropertyInfo[] properties)
{
if (GetUsesProperties(properties))
{
if (GetHasProperty(property))
{
if (string.IsNullOrEmpty(((MySqlColumnAttribute)property.GetCustomAttributes(false).First(n => n.GetType() == typeof(MySqlColumnAttribute))).DatabaseColumnName))
{
return(property.Name);
}
else
{
return(((MySqlColumnAttribute)property.GetCustomAttributes(false).First(n => n.GetType() == typeof(MySqlColumnAttribute))).DatabaseColumnName);
}
}
else
{
throw new Exception("This object uses property attributes but not this property");
}
}
else
{
return(property.Name);
}
}
private static ModelMapping CreateModelMappingFrom(System.Reflection.PropertyInfo propertyInfo)
{
var displayAttribute = propertyInfo.GetCustomAttributes(typeof(DisplayAttribute), true).FirstOrDefault() as DisplayAttribute;
return(new ModelMapping()
{
IsRequired = propertyInfo.GetCustomAttributes(typeof(RequiredAttribute), true).Any(),
PropertyInfo = propertyInfo,
ModelPropertyName = propertyInfo.Name,
SourceKeyName = displayAttribute?.Name ?? propertyInfo.Name,
});
}
private DictionaryItem getAttributes(System.Reflection.PropertyInfo info)
{
object[] attributes = info.GetCustomAttributes(true);
DictionaryItem DI = new DictionaryItem(info.Name);
DI.sortable = false;
DI.displayOrder = 0;
DI.displayName = DI.variableName;
foreach (Object att in attributes)
{
if (att is DisplayNameAttribute)
{
DI.displayName = ((DisplayNameAttribute)att).DisplayName;
}
if (att is SortableAttribute)
{
DI.sortable = ((SortableAttribute)att).value;
}
if (att is DisplayOrderAttribute)
{
DI.displayOrder = ((DisplayOrderAttribute)att).value;
}
}
return(DI);
}
private ColumnDescriptor getAttributes(System.Reflection.PropertyInfo info)
{
object[] attributes = info.GetCustomAttributes(true);
ColumnDescriptor DI = new ColumnDescriptor(info.Name);
DI.sortable = false;
DI.displayOrder = 0;
DI.displayName = null;
foreach (Object att in attributes)
{
if (att is DisplayNameAttribute)
{
DI.displayName = ((DisplayNameAttribute)att).DisplayName;
}
if (att is SortableAttribute)
{
DI.sortable = ((SortableAttribute)att).value;
}
if (att is DisplayOrderAttribute)
{
DI.displayOrder = ((DisplayOrderAttribute)att).value;
}
}
if (DI.displayName == null)
{
throw new InvalidOperationException("Column does not have display parameters");
}
return(DI);
}
public static string PropertyAbbreviation(this object obj, string propName)
{
if (obj == null)
{
Compute.RecordError("Cannot query the property abbreviation of a null object.");
return("");
}
if (propName == null)
{
Compute.RecordError("Cannot query the property abbreviation where the property name is null.");
return("");
}
System.Reflection.PropertyInfo prop = obj.GetType().GetProperty(propName);
if (prop != null)
{
object[] attributes = prop.GetCustomAttributes(typeof(AbbreviationAttribute), false);
if (attributes.Length == 1)
{
AbbreviationAttribute attribute = (AbbreviationAttribute)attributes[0];
if (attribute != null)
{
return(attribute.Name);
}
}
}
return("");
}
public IModelBinder GetBinder(ModelBinderProviderContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (context.Metadata.IsComplexType)
{
string propName = context.Metadata.PropertyName;
System.Reflection.PropertyInfo propInfo = context.Metadata.ContainerType?.GetProperty(propName);
if (propName == null || propInfo == null)
{
return(null);
}
// Look for FromJson attributes
object attribute = propInfo.GetCustomAttributes(typeof(FromJsonAttribute), false).FirstOrDefault();
if (attribute != null)
{
return(new JsonModelBinder(context.Metadata.ModelType, attribute as IJsonAttribute));
}
}
return(null);
}
static string GetPersitentName(System.Reflection.PropertyInfo propertyInfo)
{
var a = propertyInfo.GetCustomAttributes(typeof(PersistedNameAttribute), false)
.Cast <PersistedNameAttribute>().FirstOrDefault();
return(a != null ? a.Name : propertyInfo.Name);
}
private KeyTypeAttributeState GetKeyTypeAttributeState(System.Reflection.PropertyInfo pi)
{
KeyTypeAttributeState state = new KeyTypeAttributeState();
CustomAttributeField[] arr = (CustomAttributeField[])pi.GetCustomAttributes(typeof(CustomAttributeField), false);
for (int i = 0; i < arr.Length; i++)
{
if (arr[i].KeyType == KeyTypeAttribute.PrimaryKey)
{
state.IsPrimaryKey = true;
}
else if (arr[i].KeyType == KeyTypeAttribute.ForeignKey)
{
state.IsForeignKey = true;
}
else if (arr[i].KeyType == KeyTypeAttribute.QueryField)
{
state.IsQueryField = true;
}
else if (arr[i].KeyType == KeyTypeAttribute.OmitIfIsNull)
{
state.IsOmitIfIsNull = true;
}
}
return(state);
}
private DataTable _CreateDT(Stack <ParentKeysInfo> parentKeys, System.Reflection.PropertyInfo pro, string tbName, Type subType, string parentName)
{
DataTable subTb;
subTb = new DataTable(tbName);
mDataset.Tables.Add(subTb);
mTableNameToOwnerTabel[tbName] = parentName;
if (pro.GetCustomAttributes(typeof(System.ComponentModel.DisplayNameAttribute), true).Length > 0)
{
mTableNameToDescrip[tbName] = (pro.GetCustomAttributes(typeof(System.ComponentModel.DisplayNameAttribute), true)[0] as System.ComponentModel.DisplayNameAttribute).DisplayName;
}
else
{
mTableNameToDescrip[tbName] = "";
}
mTableNameToTypeName[tbName] = subType.ToString();
DataColumn column;
var ar = parentKeys.ToArray();
for (int i = parentKeys.Count - 1; i >= 0; i--)
{
var pkey = ar[i];
column = new DataColumn();
column.DataType = pkey.value.GetType();
column.ColumnName = pkey.KeyName;
column.Caption = pkey.Descrip;
column.ReadOnly = false;
column.Unique = false;
subTb.Columns.Add(column);
}
column = new DataColumn();
column.DataType = typeof(Int32);
column.ColumnName = "@index";
column.Caption = "序号";
column.ReadOnly = false;
column.Unique = false;
subTb.Columns.Add(column);
_InitColumn(subType, subTb, null);
return(subTb);
}
public bool MapPropertyToColumn(System.Reflection.PropertyInfo pi, ref string columnName, ref bool resultColumn)
{
if (pi.GetCustomAttributes(typeof(PetaPoco.ColumnAttribute), true).Length == 0)
{
columnName = ToDBName(columnName);
return(true);
}
return(false);
}
public static T GetCustomAttribute <T>(this System.Reflection.PropertyInfo propery, bool inherit) where T : Attribute
{
object[] objs = propery.GetCustomAttributes(typeof(T), inherit);
if (objs == null || objs.Length == 0)
{
return(null);
}
return(objs[0] as T);
}
public static JsonFieldTypes GetFieldFlag(System.Reflection.PropertyInfo pro)
{
object[] atts = pro.GetCustomAttributes(typeof(JsonFieldAttribute), false);
if (atts.Length > 0)
{
JsonFieldAttribute attr = atts[0] as JsonFieldAttribute;
return(attr.FieldTypeName);
}
return(JsonFieldTypes.Null);
}
public static T GetCustomAttribute <T>(this System.Reflection.PropertyInfo property)
{
var attrs = property.GetCustomAttributes(typeof(T), true);
if (attrs?.Length != 1)
{
return(default(T));
}
return((T)attrs.FirstOrDefault());
}
public static string GetFieldFlag(System.Reflection.PropertyInfo pro)
{
object[] atts = pro.GetCustomAttributes(typeof(ConfigAttribute), false);
if (atts.Length > 0)
{
ConfigAttribute attr = atts[0] as ConfigAttribute;
return(attr._fieldFlag);
}
return(null);
}
private static string GetAttributeDisplayName(System.Reflection.PropertyInfo property)
{
var atts = property.GetCustomAttributes(typeof(DisplayAttribute), true);
if (atts is null || atts.Length == 0)
{
return(property.Name);
}
return((atts[0] as DisplayAttribute).GetName());
}
private static string GetDisplayName(System.Reflection.PropertyInfo property)
{
string result = null;
BaseAttribute baseAttribute = property.GetCustomAttributes(typeof(BaseAttribute), true).FirstOrDefault <object>() as BaseAttribute;
if (baseAttribute != null)
{
result = baseAttribute.DisplayName;
}
return(result);
}
// Helper method to return the Category string from a
// CategoryAttribute assigned to a property exposed by
//the specified object
private static string GetCategory(object source, string propertyName)
{
System.Reflection.PropertyInfo property = source.GetType().GetProperty(propertyName);
CategoryAttribute attribute = (CategoryAttribute)property.GetCustomAttributes(typeof(CategoryAttribute), false)[0];
if (attribute == null)
{
return(null);
}
return(attribute.Category);
}
/// <summary>
/// return Business Type Metadata
/// </summary>
/// <param name="p"></param>
/// <returns></returns>
public string GetClassType(System.Reflection.PropertyInfo p)
{
var attr = p.GetCustomAttributes(typeof(BusinessTypeAttribute), false).FirstOrDefault();
if (attr == null || !(attr is BusinessTypeAttribute))
{
return("");
}
return((attr as BusinessTypeAttribute).ClassType);
}
private string GetDisplayName(System.Reflection.PropertyInfo propertyInfo)
{
if (propertyInfo != null)
{
var propertyCustomDisplayNameAttribute = propertyInfo.GetCustomAttributes(typeof(Ifc4.Attributes.CustomDisplayNameAttribute), false).SingleOrDefault() as Ifc4.Attributes.CustomDisplayNameAttribute;
if (propertyCustomDisplayNameAttribute != null)
{
return(propertyCustomDisplayNameAttribute.DisplayName);
}
}
return(null);
}
/// <summary>
/// Return the TGIBlockListContentField value for a Content Field.
/// </summary>
/// <param name="t">Type on which Content Field exists.</param>
/// <param name="index">Content Field name.</param>
/// <returns>The value of the TGIBlockListContentFieldAttribute TGIBlockListContentField field, if found;
/// otherwise <c>null</c>.</returns>
public static string GetTGIBlockListContentField(Type t, string index)
{
System.Reflection.PropertyInfo pi = t.GetProperty(index);
if (pi != null)
{
foreach (Attribute attr in pi.GetCustomAttributes(typeof(TGIBlockListContentFieldAttribute), true))
{
return((attr as TGIBlockListContentFieldAttribute).TGIBlockListContentField);
}
}
return(null);
}
public Column(System.Reflection.PropertyInfo propertyInfo)
{
bool isPrimaryKey = propertyInfo.Name.ToLower() == "id";
bool isRequired = isPrimaryKey ||
propertyInfo.IsDefined(typeof(RobotBlocks.Annotations.Constraint.Field.Required), false) ||
!Column.CanBeNull(propertyInfo.PropertyType);
int?maximumLength = null;
object[] lengthAttributes = propertyInfo.GetCustomAttributes(typeof(RobotBlocks.Annotations.Constraint.Field.Length), false);
foreach (RobotBlocks.Annotations.Constraint.Field.Length lengthConstraint in lengthAttributes)
{
if (lengthConstraint != null)
{
maximumLength = lengthConstraint.Maximum;
break;
}
}
bool isUnique = propertyInfo.IsDefined(typeof(RobotBlocks.Annotations.Constraint.Field.Unique), false);
string defaultValue = null;
object[] defaultAttributes = propertyInfo.GetCustomAttributes(typeof(RobotBlocks.Annotations.Constraint.Field.Default), false);
foreach (RobotBlocks.Annotations.Constraint.Field.Default defaultConstraint in defaultAttributes)
{
if (defaultConstraint != null)
{
defaultValue = defaultConstraint.Value;
break;
}
}
Name = propertyInfo.Name;
UnderlyingSystemType = propertyInfo.PropertyType.UnderlyingSystemType;
Length = maximumLength;
IsRequired = isRequired;
IsPrimaryKey = isPrimaryKey;
IsUnique = isUnique;
DefaultValue = defaultValue;
}
public static Schema GetAttributeDetails(Schema schema, System.Reflection.PropertyInfo propInfo)
{
if (schema == null || propInfo == null)
{
return(schema);
}
foreach (var attribute in propInfo.GetCustomAttributes(false))
{
SetSchemaDetails(schema, attribute);
}
return(schema);
}
/// <summary>
/// Gets the first Attribute of given type in the given property
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="propertyInfo"></param>
/// <returns></returns>
public static ParametersDefinition GetProperty <ParametersDefinition>(this System.Reflection.PropertyInfo propertyInfo)
where ParametersDefinition : Attribute
{
try
{
var def = (ParametersDefinition)propertyInfo.GetCustomAttributes(typeof(ParametersDefinition), false)[0];
return(def);
}
catch (IndexOutOfRangeException)
{
throw new IndexOutOfRangeException($"Attribute {nameof(ParametersDefinition)} not found on property {propertyInfo.Name} on object {propertyInfo.DeclaringType.Name}");
}
}
object GetArgumentValue(object value, System.Reflection.PropertyInfo protype)
{
if (protype.GetCustomAttributes(typeof(JSONAttribute), true).Length > 0
||
protype.PropertyType.GetCustomAttributes(typeof(JSONAttribute), true).Length > 0)
{
return(JSON.Serialize(value, true));
}
else
{
return(value);
}
}
private static bool IsWriteable(System.Reflection.PropertyInfo pi)
{
var attributes = pi.GetCustomAttributes(typeof(WriteAttribute), false).AsList();
if (attributes.Count != 1)
{
return(true);
}
var writeAttribute = (WriteAttribute)attributes[0];
return(writeAttribute.Write);
}
private static System.Reflection.PropertyInfo FindProperty(System.Reflection.PropertyInfo targetField, ref object localSource)
{
System.Reflection.PropertyInfo sourceProperty = null;
foreach (var Attribute in targetField.GetCustomAttributes(true).OfType <CopyFromAttribute>())
{
sourceProperty = FindProperty(sourceProperty, Attribute.getPath().Split('.'), ref localSource);
if (sourceProperty != null)
{
break;
}
}
return(sourceProperty);
}
public Task BindModelAsync(ModelBindingContext bindingContext)
{
var valueProviderResult =
bindingContext.ValueProvider.GetValue(bindingContext.ModelName);
if (valueProviderResult == ValueProviderResult.None)
{
return(Task.CompletedTask);
}
bindingContext.ModelState.SetModelValue(bindingContext.ModelName, valueProviderResult);
System.Reflection.PropertyInfo propInfo = bindingContext.ModelMetadata.ContainerType.GetProperty(bindingContext.ModelMetadata.PropertyName);
if (propInfo == null)
{
return(Task.CompletedTask);
}
var attribute = propInfo.GetCustomAttributes(typeof(OnlyEnumAttribute), false).FirstOrDefault() as OnlyEnumAttribute;
if (attribute == null)
{
return(Task.CompletedTask);
}
if (!EnumValidator.Validate(attribute.EnumType, valueProviderResult.ToString(), out object parsedEnum))
{
bindingContext.ModelState.TryAddModelError(bindingContext.ModelName, string.Format("Object \"{0}\" of type {1} is not a {2} type", valueProviderResult.ToString(), "String", attribute.EnumType.Name));
}
else
{
if (propInfo.PropertyType == typeof(string))
{
bindingContext.Result = ModelBindingResult.Success(parsedEnum.ToString());
}
else if (propInfo.PropertyType == typeof(int) || Nullable.GetUnderlyingType(propInfo.PropertyType) == typeof(int))
{
bindingContext.Result = ModelBindingResult.Success((int)parsedEnum);
}
else if (propInfo.PropertyType == attribute.EnumType || Nullable.GetUnderlyingType(propInfo.PropertyType) == attribute.EnumType)
{
bindingContext.Result = ModelBindingResult.Success(parsedEnum);
}
else
{
bindingContext.ModelState.TryAddModelError(bindingContext.ModelName, string.Format("Parameter of type {0} must be declared as an Integer, String or {1} type.", propInfo.PropertyType.Name, attribute.EnumType.Name));
}
}
return(Task.CompletedTask);
}
/// <summary>
/// Return the ElementPriority value for a Content Field.
/// </summary>
/// <param name="t">Type on which Content Field exists.</param>
/// <param name="index">Content Field name.</param>
/// <returns>The value of the ElementPriorityAttribute Priority field, if found;
/// otherwise Int32.MaxValue.</returns>
public static Int32 GetPriority(Type t, string index)
{
System.Reflection.PropertyInfo pi = t.GetProperty(index);
if (pi != null)
{
foreach (var attr in pi.GetCustomAttributes(typeof(ElementPriorityAttribute), true))
{
return((attr as ElementPriorityAttribute).Priority);
}
}
return(Int32.MaxValue);
}
/// <summary>
/// Return the DataGridExpandable value for a Content Field.
/// </summary>
/// <param name="t">Type on which Content Field exists.</param>
/// <param name="index">Content Field name.</param>
/// <returns>The value of the DataGridExpandableAttribute DataGridExpandable field, if found;
/// otherwise <c>false</c>.</returns>
public static bool GetDataGridExpandable(Type t, string index)
{
System.Reflection.PropertyInfo pi = t.GetProperty(index);
if (pi != null)
{
foreach (var attr in pi.GetCustomAttributes(typeof(DataGridExpandableAttribute), true))
{
return((attr as DataGridExpandableAttribute).DataGridExpandable);
}
}
return(false);
}