private async Task UpdateItemsTypeAsync(EntityProperty dbp, PropertyMetadataDto cp)
{
var shouldHaveItemsType = dbp.DataType == DataTypes.Array && cp.ItemsType != null;
if (!shouldHaveItemsType)
{
// delete item type if exists
if (dbp.ItemsType != null)
{
await _entityPropertyRepository.DeleteAsync(dbp.ItemsType);
dbp.ItemsType = null;
await _entityPropertyRepository.UpdateAsync(dbp);
}
}
else
{
if (dbp.ItemsType == null)
{
dbp.ItemsType = new EntityProperty();
}
dbp.ItemsType.EntityConfig = dbp.EntityConfig;
MapProperty(cp.ItemsType, dbp.ItemsType);
dbp.ItemsType.Source = Domain.Enums.MetadataSourceType.ApplicationCode;
dbp.ItemsType.SortOrder = 0;
await _entityPropertyRepository.UpdateAsync(dbp);
}
}
internal IEnumerable <PropertyMetadataDto> EmitProperties(IEnumerable <PropertyInfo> props, AssemblyMetadataStorage metaStore)
{
List <PropertyMetadataDto> properties = new List <PropertyMetadataDto>();
foreach (PropertyInfo property in props)
{
if (property.GetGetMethod().IsVisible() || property.GetSetMethod().IsVisible())
{
string id = $"{property.DeclaringType.FullName}.{property.Name}";
if (metaStore.PropertiesDictionary.ContainsKey(id))
{
_logger.Trace("Using property already added to dictionary: Id =" + id);
properties.Add(metaStore.PropertiesDictionary[id]);
}
else
{
PropertyMetadataDto newProperty = new PropertyMetadataDto()
{
Id = id,
Name = property.Name
};
_logger.Trace("Adding new property to dictionary: " + newProperty.Id + " ;Name = " + newProperty.Name);
metaStore.PropertiesDictionary.Add(newProperty.Id, newProperty);
properties.Add(newProperty);
newProperty.TypeMetadata = LoadTypeMetadataDto(property.PropertyType, metaStore);
}
}
}
return(properties);
}
private void MapProperty(PropertyMetadataDto src, EntityProperty dst, bool skipConfigurable = true)
{
dst.Name = src.Path;
dst.DataType = src.DataType;
dst.DataFormat = src.DataFormat;
dst.EntityType = src.EntityTypeShortAlias;
dst.ReferenceListName = src.ReferenceListName;
dst.ReferenceListNamespace = src.ReferenceListNamespace;
dst.IsFrameworkRelated = src.IsFrameworkRelated;
if (!skipConfigurable)
{
dst.Label = src.Label;
dst.Description = src.Description;
}
}
public IEnumerable <PropertyMetadataDto> GetMetadataFilteringFields()
{
try {
var filtering = new List <PropertyMetadataDto>();
foreach (var p in OrderItemMvoMetadata.Instance.Properties)
{
if (p.IsFilteringProperty)
{
var pdto = new PropertyMetadataDto(p.Name, p.TypeName, p.IsFilteringProperty,
!String.IsNullOrWhiteSpace(p.SourceChainingName) ? p.SourceChainingName :
(!String.IsNullOrWhiteSpace(p.DerivedFrom) ? p.DerivedFrom : p.Name));
filtering.Add(pdto);
}
}
return(filtering);
} catch (Exception ex) { var response = OrderItemMvosControllerUtils.GetErrorHttpResponseMessage(ex); throw new HttpResponseException(response); }
}
protected void With_PropertyMetadata()
{
TypeMetadataDto typeMetadata = _storage.TypesDictionary[_typeName];
typeMetadata.TypeKind = TypeKind.ClassType;
TypeMetadataDto propertyTypeMetadata = CreateSimpleTypeMetadata(_secondTypeName);
PropertyMetadataDto propertyMetadata = new PropertyMetadataDto()
{
Id = _propertyName,
Name = _propertyName,
TypeMetadata = propertyTypeMetadata
};
(typeMetadata.Properties as List <PropertyMetadataDto>).Add(propertyMetadata);
_storage.PropertiesDictionary.Add(propertyMetadata.Id, propertyMetadata);
_storage.TypesDictionary.Add(propertyTypeMetadata.Id, propertyTypeMetadata);
}
/// inheritedDoc
public PropertyMetadataDto GetPropertyMetadata(PropertyInfo property)
{
var path = property.Name;
var entityConfig = property.DeclaringType != null && property.DeclaringType.IsEntityType()
? _entityConfigurationStore.Get(property.DeclaringType)
: null;
var epc = entityConfig?[property.Name];
var dataType = GetDataType(property);
var result = new PropertyMetadataDto
{
Path = path,
Label = ReflectionHelper.GetDisplayName(property),
Description = ReflectionHelper.GetDescription(property),
IsVisible = property.GetAttribute <BrowsableAttribute>()?.Browsable ?? true,
Required = property.HasAttribute <RequiredAttribute>(),
Readonly = !property.CanWrite || (property.GetAttribute <ReadOnlyAttribute>()?.IsReadOnly ?? false),
DataType = dataType.DataType,
DataFormat = dataType.DataFormat,
EntityTypeShortAlias = property.PropertyType.IsEntityType()
? _entityConfigurationStore.Get(property.PropertyType)?.SafeTypeShortAlias
: null,
ReferenceListName = epc?.ReferenceListName,
ReferenceListNamespace = epc?.ReferenceListNamespace,
EnumType = epc?.EnumType,
OrderIndex = property.GetAttribute <DisplayAttribute>()?.GetOrder() ?? -1,
IsFrameworkRelated = IsFrameworkRelatedProperty(property),
//ConfigurableByUser = property.GetAttribute<BindableAttribute>()?.Bindable ?? true,
//GroupName = ReflectionHelper.get(declaredProperty ?? property),
};
if (dataType.DataType == DataTypes.Array)
{
result.ItemsType = GetItemsType(property);
}
return(result);
}
private Relation GetRelation(PropertyMetadataDto value)
{
return(new Relation(value.Id, value.TypeMetadata.Id));
}
private MetadataItem MapItem(PropertyMetadataDto value)
{
return(new MetadataItem($"Property: {value.Name}", true));
}