public static void RefTextNamingConvention(IModelInspector modelInspector, PropertyPath member, IPropertyMapper map) { var property = member.LocalMember as PropertyInfo; if (property.Name == "RefText") { var props = member.GetContainerEntity(modelInspector).GetProperties(); var refTextProp = props.Where(p => Attribute.IsDefined(p, typeof(RefTextAttribute), true)); if (refTextProp.Count() == 1) { map.Formula(refTextProp.First().Name); } else { string s = ""; var signatures = props.Where( p => Attribute.IsDefined(p, typeof(DomainSignatureAttribute), true) && p.PropertyType == typeof(String)); foreach (var prop in signatures) { s += prop.Name + "+'-'+"; } //if (s == "") throw new NetArchException("Must define RefText, or DomainSignature on string props for a DomainObject class:" + member.GetContainerEntity(modelInspector).Name); if (s == "") { map.Formula("'not defined'"); } else { map.Formula(s.Remove(s.Length - 5)); } } } }
public static void ManyToManyConvention(IModelInspector modelInspector, PropertyPath member, IManyToManyMapper map) { map.ForeignKey( string.Format("fk_{0}_{1}", member.LocalMember.Name, member.GetContainerEntity(modelInspector).Name)); }
public static void WithConventions(this ConventionModelMapper mapper, Configuration configuraiton) { Type baseEntityType = typeof(Entity); mapper.IsEntity((type, declared) => IsEntity(type)); mapper.IsRootEntity((type, declared) => baseEntityType.Equals(type.BaseType)); mapper.BeforeMapClass += (modelInspector, type, classCustomizer) => { classCustomizer.Id(c => c.Column("Id")); classCustomizer.Id(c => c.Generator(Generators.Identity)); //classCustomizer.Table(Inflector.Net.Inflector.Singularize(type.Name.ToString())); }; mapper.BeforeMapManyToOne += (modelInspector, propertyPath, map) => { map.Column(propertyPath.LocalMember.GetPropertyOrFieldType().Name + "Id"); map.Cascade(Cascade.Persist); }; mapper.BeforeMapBag += (modelInspector, PropertyPath, map) => { map.Key(keyMapper => keyMapper.Column(PropertyPath.GetContainerEntity(modelInspector).Name + "Id")); map.Cascade(Cascade.All); }; AddConventionOverrides(mapper); HbmMapping mapping = mapper.CompileMappingFor(typeof(Stack).Assembly.GetExportedTypes().Where(t => IsEntity(t))); configuraiton.AddDeserializedMapping(mapping, "DevelopmentStackMappings"); }
/// <summary> /// Maps a many to one relationship /// </summary> /// <param name="modelInspector">The model inspector</param> /// <param name="property">The property to map</param> /// <param name="mapper">The property mapper</param> private void MapManyToOne(IModelInspector modelInspector, PropertyPath property, IManyToOneMapper mapper) { Type targetEntityType = property.LocalMember.GetPropertyOrFieldType(); Type sourceEntityType = property.GetContainerEntity(modelInspector); MemberInfo member = property.PreviousPath != null ? property.PreviousPath.LocalMember : property.LocalMember; var targetEntityIDProperty = modelInspector.GetIdentifierMember(targetEntityType); var foreignKeyProperty = property.LocalMember; string columnName = null; string foreignKeyName = null; var one = modelInspector.IsOneToOne(property.LocalMember); if (MatchOneToOneComponent(property, modelInspector)) { columnName = namingEngine.ToComponentForeignKeyColumnName(foreignKeyProperty, member, targetEntityIDProperty); foreignKeyName = namingEngine.ToForeignKeyName(sourceEntityType, targetEntityType, member, targetEntityIDProperty); } else { columnName = namingEngine.ToForeignKeyColumnName(property.LocalMember, targetEntityIDProperty); foreignKeyName = namingEngine.ToForeignKeyName(sourceEntityType, targetEntityType, foreignKeyProperty, targetEntityIDProperty); } mapper.Column(columnName); mapper.ForeignKey(foreignKeyName); }
private static void BeforeBag(IModelInspector modelinspector, PropertyPath member, IBagPropertiesMapper propertycustomizer) { propertycustomizer.Key(x => x.Column(member.GetContainerEntity(modelinspector).Name + "Id")); propertycustomizer.Cascade(Cascade.All); propertycustomizer.Inverse(false); propertycustomizer.Lazy(CollectionLazy.NoLazy); }
public static void ReferenceConvention(IModelInspector modelInspector, PropertyPath member, IManyToOneMapper map) { map.Column(k => k.Name(member.LocalMember.GetPropertyOrFieldType().Name + "Id")); map.ForeignKey( string.Format("fk_{0}_{1}", member.LocalMember.Name, member.GetContainerEntity(modelInspector).Name)); map.Cascade(Cascade.All | Cascade.DeleteOrphans); }
/// <summary> /// Maps a collection of components or entities /// </summary> /// <param name="modelInspector">The model inspector</param> /// <param name="property">The property to map</param> /// <param name="mapper">The collections mapper</param> private void MapCollection(IModelInspector modelInspector, PropertyPath property, ICollectionPropertiesMapper mapper) { Type sourceType = property.GetContainerEntity(modelInspector); Type targetType = property.LocalMember.GetPropertyOrFieldType().DetermineCollectionElementType(); var primaryKeyProperty = modelInspector.GetIdentifierMember(sourceType); var foreignKeyProperty = property.LocalMember; string foreignKeyColumnName = null; string foreignKeyName = null; string tableName = null; string schemaName = null; if (modelInspector.IsEntity(targetType)) { // Entity Relationship Mapping if (modelInspector.IsManyToManyItem(property.LocalMember)) { // Many to many foreignKeyColumnName = namingEngine.ToManyToManyForeignKeyColumnName(sourceType, primaryKeyProperty); foreignKeyName = namingEngine.ToManyToManyForeignKeyName(sourceType, targetType, sourceType, primaryKeyProperty); tableName = namingEngine.ToManyToManyTableName(sourceType, targetType); schemaName = namingEngine.ToSchemaName(sourceType, targetType); } else { // One to Many foreignKeyColumnName = namingEngine.ToForeignKeyColumnName(sourceType, primaryKeyProperty); foreignKeyName = namingEngine.ToForeignKeyName(targetType, sourceType, sourceType, primaryKeyProperty); } } else if (IsElement(targetType)) { // Element mapping foreignKeyColumnName = namingEngine.ToForeignKeyColumnName(sourceType, primaryKeyProperty); foreignKeyName = namingEngine.ToComponentForeignKeyName(targetType, sourceType, foreignKeyProperty, primaryKeyProperty); tableName = namingEngine.ToElementTableName(sourceType, targetType, property.LocalMember); schemaName = namingEngine.ToSchemaName(sourceType, targetType); } else { // Component Relationship Mapping foreignKeyColumnName = namingEngine.ToForeignKeyColumnName(sourceType, primaryKeyProperty); foreignKeyName = namingEngine.ToComponentForeignKeyName(targetType, sourceType, foreignKeyProperty, primaryKeyProperty); tableName = namingEngine.ToComponentTableName(sourceType, targetType, property.LocalMember); schemaName = namingEngine.ToSchemaName(sourceType, targetType); } // Mapping mapper.Schema(schemaName); mapper.Table(tableName); mapper.Key(k => { k.Column(foreignKeyColumnName); k.ForeignKey(foreignKeyName); }); }
private void ManyToManyConvention(IModelInspector modelInspector, PropertyPath member, IManyToManyMapper map) { if (FkConstraintNaming != null) { map.ForeignKey( FkConstraintNaming( member.LocalMember, member.GetContainerEntity(modelInspector))); } }
private static void OnBeforeMapCollection(IModelInspector inspector, PropertyPath member, ICollectionPropertiesMapper customizer) { customizer.Key(mapper => { mapper.Column(columnMapper => columnMapper.Name(member.GetContainerEntity(inspector).Name + "Id")); if (inspector.IsManyToManyItem(member.LocalMember)) { mapper.ForeignKey( $"FK_{member.GetContainerEntity(inspector).Name.ToUpper()}_{member.LocalMember.Name.ToUpper()}_{member.GetContainerEntity(inspector).Name + "Id"}"); } else { var a = member.LocalMember.GetPropertyOrFieldType(); if (a.IsEnumerable(out var elementType)) { mapper.ForeignKey( $"FK_{elementType.Name.ToUpper()}_{member.GetContainerEntity(inspector).Name.ToUpper()}"); } } }); if (inspector.IsManyToManyItem(member.LocalMember)) { customizer.Table(member.LocalMember.DeclaringType.Name + "_" + member.LocalMember.Name); } else { if (member.LocalMember.GetPropertyOrFieldType().IsEnumerable(out var elementType) && typeof(Entity).IsAssignableFrom(elementType)) { var parentRef = elementType .GetProperties() .Single(p => p.PropertyType == member.GetContainerEntity(inspector)); customizer.Key(o => o.Column($"{parentRef.Name}Id")); customizer.Inverse(true); } customizer.Cascade(Cascade.All | Cascade.DeleteOrphans); } }
public static void OneToManyConvention(IModelInspector modelInspector, PropertyPath member, IBagPropertiesMapper map) { var inv = member.LocalMember.GetInverseProperty(); if (inv == null) { map.Key(x => x.Column(member.GetContainerEntity(modelInspector).Name + "Id")); map.Cascade(Cascade.All | Cascade.DeleteOrphans); map.BatchSize(20); map.Inverse(true); } }
public void GetContainerEntityWhenPropertyIsInComponentThenReturnEntity() { var orm = new Mock <IDomainInspector>(); orm.Setup(x => x.IsEntity(typeof(MainEntity))).Returns(true); orm.Setup(x => x.IsRootEntity(typeof(MainEntity))).Returns(true); orm.Setup(x => x.IsEntity(typeof(InheritedEntity))).Returns(true); var level0 = new PropertyPath(null, ForClass <InheritedEntity> .Property(p => p.Component)); var path = new PropertyPath(level0, ForClass <MyComponent> .Property(p => p.Something)); path.GetContainerEntity(orm.Object).Should().Be(typeof(InheritedEntity)); }
private void OneToManyConvention(IModelInspector modelInspector, PropertyPath member, ICollectionPropertiesMapper map) { var inv = GetInverseProperty(member.LocalMember); if (inv == null && InverseFkColumnNaming != null) { var containerEntity = member.GetContainerEntity(modelInspector); foreach (var idProperty in containerEntity.GetProperties().Where(modelInspector.IsPersistentId)) { map.Key(x => x.Column(InverseFkColumnNaming(member.LocalMember, containerEntity, idProperty))); } } }
/// <summary> /// Sets the mapper to use: /// 1) a properties StringLength attribute if it has one for the databases field size. /// 2) non-nullable types to be not nullable in the database. /// 3) creates indexes based on the index attributes of properties. /// </summary> private void OnMapperOnBeforeMapProperty( IModelInspector inspector, PropertyPath member, IPropertyMapper customizer) { // Get all the custom attributes. var customAttributes = member.LocalMember.GetCustomAttributes(false); // For all types check for index attributes and add indexes if required. var indexAttributes = customAttributes.OfType <IndexAttribute>(); foreach (var indexAttribute in indexAttributes) { string indexPrefix = member.GetContainerEntity(inspector).Name; if (indexAttribute.Unique) { string indexName = $"UI_{indexPrefix}_{indexAttribute.Name}"; customizer.UniqueKey(indexName); } else { string indexName = $"IX_{indexPrefix}_{indexAttribute.Name}"; customizer.Index(indexName); } } // For string types check for string length attribute and set field length if required Type memberType = member.LocalMember.GetPropertyOrFieldType(); if (memberType == typeof(string)) { StringLengthAttribute stringlengthAttribute = (StringLengthAttribute) customAttributes.FirstOrDefault(x => x.GetType() == typeof(StringLengthAttribute)); int length = this.DefaltStringLength; if (stringlengthAttribute != null && stringlengthAttribute.MaximumLength > 0) { length = stringlengthAttribute.MaximumLength; } customizer.Length(length); } // For all types if the type is not nullable then set not nullable to true. if (!IsNullable(memberType)) { customizer.NotNullable(true); } }
private static void OneToManyConvention(IModelInspector modelInspector, PropertyPath propertyPath, ISetPropertiesMapper setPropertiesMapper) { var propertyInfo = propertyPath.LocalMember.GetInverseProperty(); if (propertyInfo == null) { setPropertiesMapper.Key(km => km.Column(string.Concat(propertyPath.GetContainerEntity(modelInspector). Name, ConventionNames.PrimaryKeyPostfix))); setPropertiesMapper.Cascade(Cascade.All | Cascade.DeleteOrphans); setPropertiesMapper.BatchSize(20); setPropertiesMapper.Inverse(true); } }
public static void MapBag(IModelInspector modelInspector, PropertyPath member, IBagPropertiesMapper map) { var inv = member.LocalMember.GetInverseProperty(); if (inv == null) { map.Key(x => x.Column(member.GetContainerEntity(modelInspector).Name + "Id")); //map.Cascade(Cascade.All | Cascade.DeleteOrphans); map.BatchSize(20); map.Inverse(true); var elementType = member.LocalMember.GetPropertyOrFieldType().DetermineCollectionElementType(); var genericCollectionType = typeof(DomainListType <>); var collectionType = genericCollectionType.MakeGenericType(new[] { elementType }); map.Type(collectionType); } }
private void ReferenceConvention(IModelInspector modelInspector, PropertyPath member, IManyToOneMapper map) { if (FkColumnNaming != null) { foreach (var idProperty in member.LocalMember.GetPropertyOrFieldType().GetProperties().Where(modelInspector.IsPersistentId)) { map.Column(k => k.Name(FkColumnNaming(member.LocalMember, idProperty))); } } if (FkConstraintNaming != null) { map.ForeignKey( FkConstraintNaming( member.LocalMember, member.GetContainerEntity(modelInspector))); } }