/// <summary> /// Throws an <see cref="RequiredDependencyConstaintViolationException"/> if the <paramref name="dependencies"/> /// collection contains one or more entities with a <see cref="EntityDependencySummary.CanDelete"/> /// property value of <see langword="false"/>. /// </summary> /// <param name="definitionOfEntityBeingDeleted"> /// The <see cref="IEntityDefinition.EntityDefinitionCode"/> of the entity attempting to be deleted. /// </param> /// <param name="dependencies">Collection of dependencies to check.</param> public static void ThrowIfCannotDelete(IEntityDefinition definitionOfEntityBeingDeleted, ICollection <EntityDependencySummary> dependencies) { if (definitionOfEntityBeingDeleted == null) { throw new ArgumentNullException(nameof(definitionOfEntityBeingDeleted)); } var invalidDependencies = EnumerableHelper .Enumerate(dependencies) .Where(d => !d.CanDelete); var numInvalidDependencies = invalidDependencies.Count(); if (numInvalidDependencies > 0) { var requiredDependency = invalidDependencies.First(); string message; if (numInvalidDependencies == 1) { message = string.Format(MESSAGE_TEMPLATE, definitionOfEntityBeingDeleted.Name.ToLower(), requiredDependency.Entity.EntityDefinitionName.ToLower(), requiredDependency.Entity.RootEntityTitle); } else { var numberOfOtherInvalidEntityies = numInvalidDependencies - 1; var numberText = numberOfOtherInvalidEntityies == 2 ? "one other" : numberOfOtherInvalidEntityies + " other entities"; message = string.Format(MESSAGE_TEMPLATE_WITH_COUNT, definitionOfEntityBeingDeleted.Name.ToLower(), requiredDependency.Entity.EntityDefinitionName.ToLower(), requiredDependency.Entity.RootEntityTitle, numberText); } throw new RequiredDependencyConstaintViolationException(message); } }
public void ApplyMapping(IEntityDefinition definition, BsonClassMap classMap) { //Remove invalid maps for the class foreach (var map in classMap.DeclaredMemberMaps.ToArray()) { if (map.MemberInfo is PropertyInfo propertyInfo) { var getPropertyBaseDefinition = propertyInfo.GetMethod.GetBaseDefinition(); if (getPropertyBaseDefinition.DeclaringType != definition.EntityType) { //Remove any member map that just overrides another member classMap.UnmapMember(map.MemberInfo); continue; } } else { //Removes any member map that isn't for a property classMap.UnmapMember(map.MemberInfo); } } definition.Properties = classMap.DeclaredMemberMaps .Select(m => new EntityProperty { EntityType = definition.EntityType, IsKey = m == classMap.IdMemberMap, ElementName = m.ElementName, FullPath = m.ElementName, PropertyType = (m.MemberInfo as PropertyInfo).PropertyType, PropertyInfo = (m.MemberInfo as PropertyInfo) }); }
public void ApplyMapping(IEntityDefinition definition, BsonClassMap classMap) { definition.Relationships = GetEntityRelationships(definition).ToArray(); var removeProperties = new HashSet <string>(); foreach (var relationship in definition.Relationships) { if (relationship.IsCollection) { var memberMap = classMap.MapMember(relationship.NavigationProperty.PropertyInfo); var serializerType = typeof(EntityNavigationCollectionSerializer <>).MakeGenericType(relationship.EntityType); var collectionSerializer = Activator.CreateInstance(serializerType, relationship.IdProperty) as IBsonSerializer; memberMap.SetSerializer(collectionSerializer); } else { removeProperties.Add(relationship.NavigationProperty.FullPath); classMap.UnmapMember(relationship.NavigationProperty.PropertyInfo); } } //Remove navigation properties definition.Properties = definition.Properties.Where(p => !removeProperties.Contains(p.FullPath)).ToArray(); }
public static IEnumerable <IEntityProperty> GetAllProperties(this IEntityDefinition definition) { var localProperties = definition.Properties; var inheritedProperties = definition.GetInheritedProperties(); return(localProperties.Concat(inheritedProperties)); }
public static IEntity Create(this IEntityFactory entityFactory, IEntityDefinition definition) { entityFactory.NotNull(nameof(entityFactory)); definition.NotNull(nameof(definition)); return(entityFactory.Create(definition, CancellationToken.None).GetAwaiter().GetResult()); }
public Task <bool> Delete(IEntityDefinition entityDefinition, object id, CancellationToken ct) { entityDefinition.NotNull(nameof(entityDefinition)); id.NotNull(nameof(id)); return(entityDefinition.DeleteHandler.Execute(new DeleteExecution(entityDefinition, id), ct)); }
public IQuery CreateQuery(IEntityDefinition entityDefinition) { entityDefinition.NotNull(nameof(entityDefinition)); //TODO: Might allow security/audit interception capability later... return(_entityRepository.CreateQuery(entityDefinition)); }
public static IEntity Hydrate(this IEntityFactory entityFactory, IEntityDefinition definition, PropertyBag values) { entityFactory.NotNull(nameof(entityFactory)); definition.NotNull(nameof(definition)); return(entityFactory.Hydrate(definition, values, CancellationToken.None).GetAwaiter().GetResult()); }
public void ApplyMapping(IEntityDefinition definition, BsonClassMap classMap) { var entityType = definition.EntityType; var collectionName = entityType.Name; var tableAttribute = entityType.GetCustomAttribute <TableAttribute>(); if (tableAttribute == null && entityType.IsGenericType && entityType.GetGenericTypeDefinition() == typeof(EntityBucket <,>)) { var groupType = entityType.GetGenericArguments()[0]; tableAttribute = groupType.GetCustomAttribute <TableAttribute>(); if (tableAttribute == null) { collectionName = groupType.Name; } } if (tableAttribute != null) { if (string.IsNullOrEmpty(tableAttribute.Schema)) { collectionName = tableAttribute.Name; } else { collectionName = tableAttribute.Schema + "." + tableAttribute.Name; } } definition.CollectionName = collectionName; }
public void ApplyMapping(IEntityDefinition definition, BsonClassMap classMap) { var entityType = definition.EntityType; //Find the first property with the "Key" attribute to use as the Id var properties = entityType.GetProperties(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly); var idProperty = properties.Where(p => p.GetCustomAttribute <KeyAttribute>() != null).FirstOrDefault(); if (idProperty != null) { classMap.MapIdMember(idProperty); } //If there is no Id generator, set a default based on the member type if (classMap.IdMemberMap != null && classMap.IdMemberMap.IdGenerator == null) { var idMemberMap = classMap.IdMemberMap; var memberType = BsonClassMap.GetMemberInfoType(idMemberMap.MemberInfo); if (memberType == typeof(string)) { idMemberMap.SetIdGenerator(StringObjectIdGenerator.Instance); } else if (memberType == typeof(Guid)) { idMemberMap.SetIdGenerator(CombGuidGenerator.Instance); } else if (memberType == typeof(ObjectId)) { idMemberMap.SetIdGenerator(ObjectIdGenerator.Instance); } } }
public void CreateDiagram() { Table t = new Table(); t.Name = manager.GetName(); IEntityDefinition definition = SystemDefinitionsManager.DefinitionsManager.GetValidationDefinition(EntityTypesDefinition.Table); if (!(definition is TableDefinition)) { return; } TableDefinition tabledefinition = definition as TableDefinition; List <EntityElement> e = manager.GetEntityElements(tabledefinition.TablePropertyTag); t.Properties = new System.Collections.ObjectModel.ObservableCollection <Properties>(); foreach (EntityElement ee in e) { var type = ee.attributes.Where(x => x.Key == tabledefinition.TablePropertyType).First(); var name = ee.attributes.Where(x => x.Key == tabledefinition.TablePropertyName).First(); var isprimary = ee.attributes.Where(x => x.Key == tabledefinition.TablePropertyPrimary); bool iskey = (isprimary.Count() > 0 && isprimary.First().Value.ToUpper() == "TRUE"); if (string.IsNullOrEmpty(name.Value) || string.IsNullOrEmpty(type.Value)) { continue; } t.Properties.Add(new Properties() { Name = name.Value, Type = type.Value, IsPrimaryKey = iskey }); } var m = Structure.Struct.model; m.tables.Add(t); }
private static void ValidateDefinitionExists(IEntityDefinition definition, string identifier) { if (definition == null) { throw new EntityNotFoundException <IEntityDefinition>($"IEntityDefinition '{identifier}' is not registered, but has been requested.", identifier); } }
private bool CheckValidCriterion(IEntityDefinition entityDefinition, string propertyName) { string remaining = null; var leading = propertyName.SplitFirst('.', out remaining); var propertyDefinition = entityDefinition.Properties.SafeGet(leading); if ((propertyDefinition == null) || ((propertyDefinition.PropertyType.DataTypeType == DataTypeType.Relation) && !remaining.SafeOrdinalEquals(MetaConstants.IdProperty))) { return(false); } if (remaining == null) { return(true); } var targetDataType = propertyDefinition.PropertyType; var indirectTargetEntityDefinition = targetDataType.GetTargetValueType(propertyDefinition); IEntityDefinition targetEntityDefinition; if (indirectTargetEntityDefinition != null) { targetEntityDefinition = indirectTargetEntityDefinition as IEntityDefinition; } else { targetEntityDefinition = targetDataType as IEntityDefinition; } return(targetEntityDefinition != null && CheckValidCriterion(targetEntityDefinition, remaining)); }
public void ApplyMapping(IEntityDefinition definition, BsonClassMap classMap) { var entityType = definition.EntityType; var collectionName = entityType.Name; var tableAttribute = entityType.GetCustomAttribute <TableAttribute>(); if (tableAttribute == null && entityType.IsGenericType && entityType.GetGenericTypeDefinition() == typeof(EntityBucket <,>)) { var groupProperty = entityType.GetProperty("Group", BindingFlags.Public | BindingFlags.Instance); tableAttribute = groupProperty.GetCustomAttribute <TableAttribute>(); if (tableAttribute == null) { collectionName = groupProperty.PropertyType.Name; } } if (tableAttribute != null) { if (string.IsNullOrEmpty(tableAttribute.Schema)) { collectionName = tableAttribute.Name; } else { collectionName = tableAttribute.Schema + "." + tableAttribute.Name; } } definition.CollectionName = collectionName; }
public void ApplyMapping(IEntityDefinition definition, BsonClassMap classMap) { var entityType = definition.EntityType; //Ignore extra elements when the "IgnoreExtraElementsAttribute" is on the Entity var ignoreExtraElements = entityType.GetCustomAttribute <IgnoreExtraElementsAttribute>(); if (ignoreExtraElements != null) { classMap.SetIgnoreExtraElements(true); classMap.SetIgnoreExtraElementsIsInherited(ignoreExtraElements.IgnoreInherited); } else { //If any of the Entity's properties have the "ExtraElementsAttribute", assign that against the BsonClassMap var extraElementsProperty = entityType.GetProperties(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly) .Select(p => new { PropertyInfo = p, ExtraElementsAttribute = p.GetCustomAttribute <ExtraElementsAttribute>() }).Where(p => p.ExtraElementsAttribute != null).FirstOrDefault(); if (extraElementsProperty != null && typeof(IDictionary <string, object>).IsAssignableFrom(extraElementsProperty.PropertyInfo.PropertyType)) { var memberMap = classMap.DeclaredMemberMaps .Where(m => m.MemberInfo == extraElementsProperty.PropertyInfo) .FirstOrDefault(); classMap.SetExtraElementsMember(memberMap); } } }
public static IEntityDefinition SetEntityDefinition(IEntityDefinition definition) { return(EntityDefinitions.AddOrUpdate(definition.EntityType, definition, (entityType, existingValue) => { return definition; })); }
public static IPropertyDefinition Create( IEntityDefinition entityDefinition, IDataType dataType = null, PropertyBag propertyBag = null) { entityDefinition.NotNull(nameof(entityDefinition)); var result = new PropertyDefinition { EntityDefinition = entityDefinition, PropertyType = dataType, PropertyBag = propertyBag, Name = propertyBag?["name"] as string, Description = propertyBag?["description"] as string, DefaultValue = propertyBag?["default"] }; var validatorsData = propertyBag?["validators"] as PropertyBag[]; if (validatorsData != null) { result.ValidatorDefinitions = CreateValidatorDefinitions(result, validatorsData); } return(result); }
public void ApplyMapping(IEntityDefinition definition, BsonClassMap classMap) { var entityType = definition.EntityType; //Ignore extra elements when the "IgnoreExtraElementsAttribute" is on the Entity var ignoreExtraElements = entityType.GetCustomAttribute <IgnoreExtraElementsAttribute>(); if (ignoreExtraElements != null) { classMap.SetIgnoreExtraElements(true); classMap.SetIgnoreExtraElementsIsInherited(ignoreExtraElements.IgnoreInherited); } else { classMap.SetIgnoreExtraElements(false); //If any of the Entity's properties have the "ExtraElementsAttribute", assign that against the BsonClassMap foreach (var property in definition.Properties) { var extraElementsAttribute = property.PropertyInfo.GetCustomAttribute <ExtraElementsAttribute>(); if (extraElementsAttribute != null && typeof(IDictionary <string, object>).IsAssignableFrom(property.PropertyType)) { foreach (var memberMap in classMap.DeclaredMemberMaps) { if (memberMap.ElementName == property.ElementName) { classMap.SetExtraElementsMember(memberMap); return; } } } } } }
/// <summary> /// Root constructor /// </summary> /// <param name="definition">Entity definition that determines identity parameters</param> /// <param name="rootItem">Item contained by root</param> /// <param name="checkOptions">Options governing how uniqueness is enforced</param> protected MutableEntityTreeNode(IEntityDefinition <TId, TName, TItem> definition, TItem rootItem, ErrorCheckOptions checkOptions = ErrorCheckOptions.Default) : base(definition, rootItem, checkOptions) { _getName = definition.GetName; }
public void ApplyMapping(IEntityDefinition definition, BsonClassMap classMap) { var entityType = definition.EntityType; var properties = entityType.GetProperties(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly); foreach (var property in properties) { var propertyType = property.PropertyType; //Maps the property type for handling property nesting if (propertyType.IsClass && propertyType != entityType) { if (!EntityMapping.IsRegistered(propertyType)) { EntityMapping.RegisterType(propertyType); } } else if ( propertyType.IsGenericType && propertyType.GetGenericArguments().Count() == 1 && ( propertyType.GetGenericTypeDefinition() == typeof(IEnumerable <>) || propertyType.GetInterfaces().Where(i => i.IsGenericType).Any(i => i.GetGenericTypeDefinition() == typeof(IEnumerable <>)) ) ) { var genericType = propertyType.GetGenericArguments()[0]; if (!EntityMapping.IsRegistered(genericType)) { EntityMapping.RegisterType(genericType); } } } }
public void ApplyMapping(IEntityDefinition definition, BsonClassMap classMap) { var entityType = definition.EntityType; var properties = entityType.GetProperties(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly); foreach (var property in properties) { //Unmap fields with the "NotMappedAttribute" var notMappedAttribute = property.GetCustomAttribute <NotMappedAttribute>(); if (notMappedAttribute != null) { classMap.UnmapProperty(property.Name); continue; } //Remap fields with the "ColumnAttribute" var columnAttribute = property.GetCustomAttribute <ColumnAttribute>(); if (columnAttribute != null) { var mappedName = columnAttribute.Name; var memberMap = classMap.GetMemberMap(property.Name); memberMap?.SetElementName(mappedName); } } }
protected Query(IEntityDefinition entityDefinition) { EntityDefinition = entityDefinition.NotNull(nameof(entityDefinition)); Criterions = new List <ICriterion>(); Orders = new List <Order>(); SubQueries = new Dictionary <string, IQuery>(StringComparer.OrdinalIgnoreCase); Includes = new HashSet <IPropertyDefinition>(); }
public void ApplyMapping(IEntityDefinition definition, BsonClassMap classMap) { if (!ProviderAdded) { ProviderAdded = true; BsonSerializer.RegisterSerializationProvider(TypeDiscoverySerializationProvider.Instance); } }
public static Task <IEntity> GetById(this IEntityService entityService, IEntityDefinition entityDefinition, object id, CancellationToken ct) { entityService.NotNull(nameof(entityService)); entityDefinition.NotNull(nameof(entityDefinition)); id.NotNull(nameof(id)); return(entityService.CreateQuery(entityDefinition).Add(Criterion.IdEq(id)).UniqueResult <IEntity>(ct)); }
/// <summary> /// Root constructor /// </summary> /// <param name="definition">Entity definition that determines identity parameters</param> /// <param name="rootItem">Item contained by root</param> /// <param name="checkOptions">Options governing how uniqueness is enforced</param> protected ReadOnlyEntityTreeNode(IEntityDefinition <TId, TItem> definition, TItem rootItem, ErrorCheckOptions checkOptions = ErrorCheckOptions.Default) : base(definition, checkOptions, rootItem) { }
/// <summary> /// Root constructor /// </summary> /// <param name="definition">Entity definition that determines identity parameters</param> /// <param name="setItemName">Function specifying how entity name is set</param> /// <param name="rootItem">Item contained by root</param> /// <param name="checkOptions">Options governing how uniqueness is enforced</param> public NamedMutableEntityTreeNode(IEntityDefinition <TId, string, TItem> definition, Action <TItem, string> setItemName, TItem rootItem, ErrorCheckOptions checkOptions = ErrorCheckOptions.Default) : base(definition, rootItem, checkOptions) { _setItemName = setItemName; }
public IPermission GetByEntityAndPermissionType(IEntityDefinition entityDefinition, PermissionType permissionType) { if (entityDefinition == null || permissionType == null) { return(null); } return(GetByEntityAndPermissionType(entityDefinition.EntityDefinitionCode, permissionType.Code)); }
protected override IEnumerable <IFieldDefinition> EvaluateFields(IEntityDefinition entityDefinition) { return(_fields.Join(entityDefinition.FieldDefinitions, field => field, definition => definition.Name, (s, definition) => definition, StringComparer.CurrentCultureIgnoreCase)); }
public DefaultIdPropertyDefinition(IEntityDefinition entityDefinition, IDataType guidDataType) { Name = MetaConstants.IdProperty; EntityDefinition = entityDefinition; PropertyType = guidDataType; DefaultValue = GuidValueType.NewGuidDefaultValue; Description = $"Id for {entityDefinition}"; }
public void ApplyMapping(IEntityDefinition definition, BsonClassMap classMap) { var entityType = definition.EntityType; var properties = entityType.GetProperties(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly); var definitionProperties = new List <IEntityProperty>(); foreach (var property in properties) { if (!property.CanRead || !property.CanWrite) { continue; } //Skip overridden properties var getMethod = property.GetMethod; if (property.GetMethod.IsVirtual && getMethod.GetBaseDefinition().DeclaringType != entityType) { continue; } //Skip indexer properties (eg. "this[int index]") if (property.GetIndexParameters().Length > 0) { continue; } //Skip properties with the "NotMappedAttribute" var notMappedAttribute = property.GetCustomAttribute <NotMappedAttribute>(); if (notMappedAttribute != null) { continue; } //Do the mapping var memberMap = classMap.MapMember(property); //Set custom element name with the "ColumnAttribute" var columnAttribute = property.GetCustomAttribute <ColumnAttribute>(); if (columnAttribute != null) { var mappedName = columnAttribute.Name; memberMap.SetElementName(mappedName); } definitionProperties.Add(new EntityProperty { EntityType = definition.EntityType, ElementName = memberMap.ElementName, FullPath = memberMap.ElementName, PropertyType = property.PropertyType, PropertyInfo = property }); } definition.Properties = definitionProperties; }