private static IEdmModel getEdmModel()
{
ODataConventionModelBuilder modelBuilder = new ODataConventionModelBuilder();
EntitySetConfiguration <Person> peopleEntitySet = modelBuilder.EntitySet <Person>("People");
EntityTypeConfiguration <Person> personType = peopleEntitySet.EntityType;
personType.Ignore(p => p.CreatedTime);
personType.Ignore(p => p.LastModifiedTime);
EntitySetConfiguration <Account> accountEntitySet = modelBuilder.EntitySet <Account>("Accounts");
EntityTypeConfiguration <Account> accountType = accountEntitySet.EntityType;
accountType.Ignore(a => a.LastModifyTime);
accountType.Ignore(a => a.CreateTime);
FunctionConfiguration getPersonAndDescendants = modelBuilder.Function("GetPersonAndDescendants");
getPersonAndDescendants.ReturnsFromEntitySet <Person>("People");
getPersonAndDescendants.Parameter <long>("Id"); // The id of the root person.
getPersonAndDescendants.Parameter <long>("TotalLevels"); // How many levels will be loaded and the root person is included.
getPersonAndDescendants.IsComposable = true;
FunctionConfiguration getPersonAndAncestors = modelBuilder.Function("GetPersonAndAncestors");
getPersonAndAncestors.ReturnsCollectionFromEntitySet <Person>("People");
getPersonAndAncestors.Parameter <long>("Id"); // The id of the root person.
getPersonAndAncestors.Parameter <long>("TotalLevels"); // How many levels will be loaded and the root person is included.
getPersonAndAncestors.IsComposable = true;
modelBuilder.Namespace = typeof(Person).Namespace;
return(modelBuilder.GetEdmModel());
}
void ConfigureCatalogItem(EntityTypeConfiguration <CatalogItem> builder)
{
builder.ToTable("Catalog");
builder.HasKey(ci => ci.Id);
builder.Property(ci => ci.Id)
.HasDatabaseGeneratedOption(DatabaseGeneratedOption.None)
.IsRequired();
builder.Property(ci => ci.Name)
.IsRequired()
.HasMaxLength(50);
builder.Property(ci => ci.Price)
.IsRequired();
builder.Property(ci => ci.PictureFileName);
builder.Ignore(ci => ci.PictureUri);
builder.Ignore(ci => ci.TempImageName);
builder.HasRequired <CatalogBrand>(ci => ci.CatalogBrand)
.WithMany()
.HasForeignKey(ci => ci.CatalogBrandId);
builder.HasRequired <CatalogType>(ci => ci.CatalogType)
.WithMany()
.HasForeignKey(ci => ci.CatalogTypeId);
}
/// <summary>
/// Configure the mapping of database tables to entities
/// </summary>
/// <param name="modelBuilder"><see cref="System.Data.Entity.DbModelBuilder"/></param>
protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
//base.OnModelCreating(modelBuilder);
modelBuilder.Conventions.Remove <PluralizingTableNameConvention>();
// Author mapping
EntityTypeConfiguration <Author> author = modelBuilder.Entity <Author>();
author.ToTable("authors");
author.Property(a => a.AuthorID).HasColumnName("au_id");
author.Property(a => a.FirstName).HasColumnName("au_fname");
author.Property(a => a.LastName).HasColumnName("au_lname");
author.Ignore(a => a.Name);
author.Property(a => a.PhoneNumber).HasColumnName("phone");
author.Property(a => a.Address).HasColumnName("address");
author.Property(a => a.City).HasColumnName("city");
author.Property(a => a.State).HasColumnName("state");
author.Property(a => a.PostalCode).HasColumnName("zip");
author.Property(a => a.HasContract).HasColumnName("contract");
author.Ignore(a => a.YearToDateSales);
author.HasKey(a => a.AuthorID);
// Publisher mapping
EntityTypeConfiguration <Publisher> publisher = modelBuilder.Entity <Publisher>();
publisher.ToTable("publishers");
publisher.Property(p => p.PublisherID).HasColumnName("pub_id");
publisher.Property(p => p.Name).HasColumnName("pub_name");
publisher.Property(p => p.City).HasColumnName("city");
publisher.Property(p => p.State).HasColumnName("state");
publisher.Property(p => p.Country).HasColumnName("country");
publisher.Ignore(p => p.YearToDateSales);
publisher.HasKey(p => p.PublisherID);
// Title mapping
EntityTypeConfiguration <Title> title = modelBuilder.Entity <Title>();
title.ToTable("titles");
title.Property(t => t.TitleID).HasColumnName("title_id");
title.Property(t => t.BookTitle).HasColumnName("title");
title.Property(t => t.Type).HasColumnName("type");
title.Property(t => t.Price).HasColumnName("price");
title.Property(t => t.Advance).HasColumnName("advance");
title.Property(t => t.Royalty).HasColumnName("royalty");
title.Property(t => t.YearToDateSales).HasColumnName("ytd_sales");
title.Property(t => t.Notes).HasColumnName("notes");
title.Property(t => t.PublishDate).HasColumnName("pubdate");
title.HasRequired(t => t.Publisher).WithMany(p => p.Titles).Map(pt => pt.MapKey("pub_id"));
title.HasMany(t => t.Authors).WithMany(a => a.Titles).Map(at => { at.ToTable("titleauthor"); at.MapLeftKey("title_id"); at.MapRightKey("au_id"); });
title.HasKey(t => t.TitleID);
}
protected OrderDbObjectMap(DbModelBuilder builder)
{
Map = builder.Entity <TObject>();
Map.ToTable(typeof(TObject).Name);
Map.HasKey(o => o.Id);
Map.Ignore(o => o.IsNew);
}
public LeadBuilder(EntityTypeConfiguration <Lead> builder)
{
builder.Property(b => b.Owner).HasMaxLength(100);
builder.Ignore(b => b.FullName);
builder.Property(b => b.FirstName).HasMaxLength(50).IsRequired();
builder.Property(b => b.LastName).HasMaxLength(50);
builder.Property(b => b.Company).HasMaxLength(100);
builder.Property(b => b.Title).HasMaxLength(100);
builder.Property(b => b.Telephone).HasMaxLength(20);
builder.Property(b => b.MobilePhone).HasMaxLength(20);
builder.Property(b => b.Email).HasMaxLength(100);
builder.Property(b => b.Fax).HasMaxLength(20);
builder.Property(b => b.Website).HasMaxLength(100);
builder.Property(b => b.SkypeId).HasMaxLength(100);
builder.Property(b => b.Twitter).HasMaxLength(100);
builder.Property(b => b.SecondaryEmail).HasMaxLength(100);
builder.Property(b => b.Photo).HasMaxLength(200);
builder.Property(b => b.Address).HasMaxLength(500);
builder.Property(b => b.PostalCode).HasMaxLength(10);
builder.Property(b => b.Description).HasMaxLength(4000);
builder.Property(b => b.Company).HasMaxLength(100).IsRequired();
builder.HasOptional(p => p.LeadSource).WithMany(w => w.Leads).HasForeignKey(p => p.LeadSourceId);
builder.HasOptional(p => p.Sector).WithMany(w => w.Leads).HasForeignKey(p => p.SectorId);
builder.HasOptional(p => p.LeadStatus).WithMany(w => w.Leads).HasForeignKey(p => p.LeadStatusId);
builder.HasOptional(p => p.Country).WithMany(w => w.Leads).HasForeignKey(p => p.CountryId);
builder.HasOptional(p => p.City).WithMany(w => w.Leads).HasForeignKey(p => p.CityId);
builder.HasOptional(p => p.Region).WithMany(w => w.Leads).HasForeignKey(p => p.RegionId);
}
/// <summary>
/// Ignores the catel properties for database mappings.
/// </summary>
/// <typeparam name="TEntity">The type of the t entity.</typeparam>
/// <param name="configuration">The configuration.</param>
/// <returns>EntityTypeConfiguration<TEntity>.</returns>
public static EntityTypeConfiguration <TEntity> IgnoreCatelProperties <TEntity>(this EntityTypeConfiguration <TEntity> configuration)
where TEntity : ModelBase
{
//configuration.Ignore(x => x.BusinessRuleErrorCount);
//configuration.Ignore(x => x.BusinessRuleWarningCount);
//configuration.Ignore(x => x.FieldErrorCount);
//configuration.Ignore(x => x.FieldWarningCount);
//configuration.Ignore(x => x.HasErrors);
//configuration.Ignore(x => x.HasWarnings);
configuration.Ignore(x => x.IsDirty);
//configuration.Ignore(x => x.IsInEditSession);
configuration.Ignore(x => x.IsReadOnly);
//configuration.Ignore(x => x.Mode);
//configuration.Ignore(x => x.ValidationContext);
//configuration.Ignore(x => x.Validator);
return(configuration);
}
public void Cloning_an_entity_configuration_clones_its_ignored_properties()
{
var configuration = new EntityTypeConfiguration(typeof(object));
var mockProperty1 = new MockPropertyInfo(typeof(int), "P1");
configuration.Ignore(mockProperty1);
var clone = configuration.Clone();
Assert.True(clone.IgnoredProperties.Contains(mockProperty1));
var mockProperty2 = new MockPropertyInfo(typeof(int), "P2");
configuration.Ignore(mockProperty2);
Assert.False(clone.IgnoredProperties.Contains(mockProperty2));
}
public AuditTrailChangeLogBuilder(EntityTypeConfiguration <AuditTrailChangeLogEntity> modelBuilder)
{
modelBuilder.ToTable(TableName);
modelBuilder.HasKey(b => b.Id);
modelBuilder.Property(b => b.ColumnName);
modelBuilder.Property(b => b.ValueBefore);
modelBuilder.Property(b => b.ValueAfter);
modelBuilder.Ignore(b => b.Changed);
}
public static void Map(DbModelBuilder modelBuilder)
{
EntityTypeConfiguration <User> userConfig = modelBuilder.Entity <User>();
userConfig.HasKey(u => u.Id);
userConfig.Property(u => u.FirstName).IsRequired().HasMaxLength(50);
userConfig.Property(u => u.LastName).IsRequired().HasMaxLength(50);
userConfig.Ignore(u => u.FullName);
userConfig.Property(u => u.Username).IsRequired().HasMaxLength(50);
userConfig.Property(u => u.Password).IsRequired().HasMaxLength(50);
}
private static void SuppressTrinityRdf <T>(EntityTypeConfiguration <T> entity) where T : ODataResource
{
entity.Ignore(v => v.IsDisposed);
entity.Ignore(v => v.IsNew);
entity.Ignore(v => v.IsBlank);
entity.Ignore(v => v.IsSynchronized);
entity.Ignore(v => v.Language);
entity.Ignore(v => v.Model);
entity.Ignore(v => v.Uri);
}
/// <summary>
/// Takes care of setting up type configuration specific to the IBase model
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="entity"></param>
/// <param name="entityName">Name of the entity. used for automated index naming</param>
/// <returns></returns>
public static EntityTypeConfiguration <T> ApplyIBaseConfiguration <T>(this EntityTypeConfiguration <T> entity, string entityName) where T : class, IBase
{
entity.HasKey(t => t.Uuid);
entity.Property(en => en.Uuid).HasColumnName("uuid");
entity.Property(en => en.CreatedBy).HasColumnName("created_by");
entity.Property(en => en.LastModifiedBy).HasColumnName("last_modified_by");
entity.Property(en => en.CreateDateUtc).HasColumnName("create_date_utc");
entity.Property(en => en.ModifyDateUtc).HasColumnName("modify_date_utc");
entity.Property(en => en.EndDateUtc).HasColumnName("end_date_utc");
entity.Ignore(p => p.TypeUuid);
entity.Ignore(p => p.Links);
entity.Ignore(p => p.LinkData);
entity.Property(en => en.CreateDateUtc)
.HasColumnAnnotation(
"Index",
new IndexAnnotation(new IndexAttribute($"idx_create_date_{entityName.ToLower()}")));
return(entity);
}
/// <summary>
/// 映射属性
/// </summary>
/// <param name="builder"></param>
protected override void MapProperties(EntityTypeConfiguration <Login> builder)
{
base.MapProperties(builder);
builder.Property(t => t.Id).HasColumnName("LoginID");
builder.Property(t => t.CreatorId).HasColumnName("Creater");
builder.Property(t => t.CreationTime).HasColumnName("CreateTime");
builder.Property(t => t.LastModifierId).HasColumnName("Editor");
builder.Property(t => t.LastModificationTime).HasColumnName("EditTime");
builder.Ignore(t => t.Version);
}
public override void Build(EntityTypeConfiguration <User> configuration)
{
configuration.HasKey(x => x.ID);
configuration.Property(x => x.ID).HasColumnName("UserID");
configuration.Property(x => x.Name).HasColumnName("UserName");
configuration.Property(x => x.Salt).HasColumnName("PasswordSalt");
configuration.Property(x => x.SecretQuestion).HasColumnName("SecretQuestion");
configuration.Property(x => x.SecretAnswer).HasColumnName("SecretAnswer");
configuration.HasRequired(x => x.Consumer).WithMany(x => x.Users).Map(m => m.MapKey("ConsumerID"));
configuration.Ignore(x => x.IsAuthenticated);
configuration.Ignore(x => x.Permissions);
configuration.HasMany(x => x.Roles)
.WithMany(x => x.Users)
.Map(map =>
{
map.ToTable("UsersInRoles");
map.MapLeftKey("UserID");
map.MapRightKey("RoleID");
});
configuration.HasMany(x => x.Groups)
.WithMany(x => x.Users)
.Map(map =>
{
map.ToTable("UsersInGroups");
map.MapLeftKey("UserID");
map.MapRightKey("GroupID");
});
configuration.HasMany(x => x.Applications)
.WithMany(x => x.Users)
.Map(map =>
{
map.ToTable("UsersInApplications");
map.MapLeftKey("UserID");
map.MapRightKey("ApplicationID");
});
}
public CustomerBuilder(EntityTypeConfiguration <Customer> builder)
{
builder.Property(b => b.FirstName).HasMaxLength(50).IsRequired();
builder.Property(b => b.LastName).HasMaxLength(50).IsRequired();
builder.Ignore(b => b.FullName);
builder.Property(b => b.MobilePhone).HasMaxLength(20).IsRequired();
builder.Property(b => b.Email).HasMaxLength(100);
builder.Property(b => b.Company).HasMaxLength(100).IsRequired();
builder.Property(b => b.Address).HasMaxLength(4000);
builder.HasOptional(p => p.Country).WithMany(w => w.Customers).HasForeignKey(p => p.CountryId);
builder.HasOptional(p => p.City).WithMany(w => w.Customers).HasForeignKey(p => p.CityId);
builder.Property(b => b.Photo).HasMaxLength(200);
}
public static ManyNavigationPropertyConfiguration <T, TTarget> HasManyPrivate <T, TTarget>(
this EntityTypeConfiguration <T> mapper,
Expression <Func <T, ICollection <TTarget> > > exp,
NamingConventions?convention = null)
where T : class
where TTarget : class
{
mapper.Ignore(exp);
dynamic expression = exp;
string columnName;
ExpressionModifier.ToPrivate(ref expression, convention, out columnName);
return(mapper.HasMany(expression));
}
public static DateTimePropertyConfiguration PrivateProperty <T>(
this EntityTypeConfiguration <T> mapper,
Expression <Func <T, DateTimeOffset?> > exp,
NamingConventions?convention = null) where T : class
{
mapper.Ignore(exp);
dynamic expression = exp;
string defaultColumnName;
ExpressionModifier.ToPrivate(ref expression, convention, out defaultColumnName);
DateTimePropertyConfiguration configuration = mapper.Property(expression);
configuration.HasColumnName(defaultColumnName);
return(configuration);
}
/// <summary>
/// Gets the model.
/// </summary>
/// <returns></returns>
/// <seealso cref="http://stackoverflow.com/questions/24829422/handling-dates-with-odata-v4-ef6-and-web-api-v2-2"/>
public static IEdmModel GetModel()
{
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
EntityTypeConfiguration <Address> titleType = builder.EntityType <Address>();
//http://stackoverflow.com/questions/24829422/handling-dates-with-odata-v4-ef6-and-web-api-v2-2
titleType.Ignore(t => t.ModifiedDate);
//titleType.Property(t => t.EdmModifiedDate).Name = "ModifiedDate";
builder.EntitySet <Address>("Addresses");
builder.Namespace = typeof(Address).Namespace;
return(builder.GetEdmModel());
}
public static void IgnoreAllBut <TEntityType>(
this EntityTypeConfiguration <TEntityType> entityTypeConfiguration, params string[] names)
where TEntityType : class
{
var properties = typeof(TEntityType).GetProperties(BindingFlags.Instance | BindingFlags.Public);
foreach (var property in properties.Where(p => !names.Contains(p.Name)))
{
var parameter = Expression.Parameter(typeof(TEntityType), "e");
dynamic expression
= Expression.Lambda(
Expression.Property(parameter, property),
parameter);
entityTypeConfiguration.Ignore(expression);
}
}
private void MapCustomer(EntityTypeConfiguration <Customer> entity)
{
entity.Property(k => k.CustomerTypeId).HasColumnName("CustomerTypeID");
entity.Property(k => k.InitialDate).HasColumnType("DATETIME").HasColumnName("InitialDate").IsOptional();
entity.Property(k => k.PrimaryDestinationId).HasColumnName("PrimaryDesintation");
entity.Property(k => k.SecondaryDestinationId).HasColumnName("SecondaryDestination");
entity.Property(k => k.PrimaryActivityId).HasColumnName("PrimaryActivity");
entity.Property(k => k.SecondaryActivityId).HasColumnName("SecondaryActivity");
entity.Property(k => k.Notes);
entity.Property(k => k.CustomerRowVersion).HasColumnName("RowVersion").IsRowVersion().IsConcurrencyToken(false);
entity.HasOptional(k => k.PrimaryActivity).WithMany().HasForeignKey(k => k.PrimaryActivityId);
entity.HasOptional(k => k.SecondaryActivity).WithMany().HasForeignKey(k => k.SecondaryActivityId);
entity.HasOptional(k => k.PrimaryDestination).WithMany().HasForeignKey(k => k.PrimaryDestinationId);
entity.HasOptional(k => k.SecondaryDestination).WithMany().HasForeignKey(k => k.SecondaryDestinationId);
entity.Property(k => k.BirthDate).HasColumnType("DATETIME").IsOptional();
entity.Property(k => k.HeightInches).IsOptional();
entity.Property(k => k.WeightPounds).IsOptional();
entity.Property(k => k.DietaryRestrictions).IsOptional();
entity.HasMany(k => k.Reservations).WithRequired().HasForeignKey(k => k.CustomerId);
entity.Ignore(k => k.CustomerType);
entity.Map(m =>
{
m.Properties(c => new { c.BirthDate, c.HeightInches, c.WeightPounds, c.DietaryRestrictions });
m.ToTable("ContactPersonalInfo");
});
}
public EmployeeBuilder(EntityTypeConfiguration <Employee> builder)
{
builder.Property(b => b.FirstName).HasMaxLength(100).IsRequired();
builder.Property(b => b.LastName).HasMaxLength(100).IsRequired();
builder.Ignore(b => b.FullName);
builder.Property(b => b.Photo).HasMaxLength(200);
builder.Property(b => b.IdentityNumber).HasMaxLength(11);
builder.Property(b => b.Mobile).HasMaxLength(20).IsRequired();
builder.Property(b => b.Nationality).HasMaxLength(100).IsRequired();
builder.Property(b => b.Address).HasMaxLength(100).IsRequired();
builder.HasOptional(a => a.Department).WithMany(b => b.Employees).HasForeignKey(a => a.DepartmentId);
builder.HasOptional(a => a.Position).WithMany(b => b.Employees).HasForeignKey(a => a.PositionId);
builder.Property(b => b.Title).HasMaxLength(4000).IsRequired();
builder.HasOptional(a => a.Certificate).WithMany(b => b.Employees).HasForeignKey(a => a.CertificateId);
builder.HasOptional(a => a.Country).WithMany(b => b.Employees).HasForeignKey(a => a.CountryId);
builder.HasOptional(a => a.City).WithMany(b => b.Employees).HasForeignKey(a => a.CityId);
builder.HasOptional(a => a.Region).WithMany(b => b.Employees).HasForeignKey(a => a.RegionId);
}
private void MapUsuarios(DbModelBuilder modelBuilder)
{
EntityTypeConfiguration <Usuario> tabla = modelBuilder.Entity <Usuario>();
tabla
.ToTable("Usuarios")
.HasKey(c => c.UsuarioID);
tabla
.Property(c => c.UsuarioID)
.HasDatabaseGeneratedOption(DatabaseGeneratedOption.Identity);
tabla
.Property(c => c.Nombre)
.HasMaxLength(50);
tabla
.Property(c => c.Apellidos)
.HasMaxLength(150);
tabla
.Property(c => c.Email)
.HasMaxLength(250);
tabla
.Ignore(e => e.Id)
.Ignore(e => e.UserName)
.Ignore(e => e.ApellidosNombre);
tabla
.HasMany(e => e.Aplicaciones)
.WithMany(c => c.Usuarios)
.Map(c =>
{
c.ToTable("AplicacionesUsuarios");
c.MapLeftKey("UsuarioID");
c.MapRightKey("AplicacionID");
});
tabla.HasRequired(c => c.Rol)
.WithMany()
.HasForeignKey(u => u.RolID);
}
protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
base.OnModelCreating(modelBuilder);
modelBuilder.HasDefaultSchema("word");
EntityTypeConfiguration <Question> cardboxConfiguration = modelBuilder.Entity <Question>();
cardboxConfiguration.HasKey(x => x.Id);
cardboxConfiguration.HasRequired(x => x.Cardbox);
cardboxConfiguration.Property(x => x.Text).IsRequired().HasColumnType("nvarchar").HasMaxLength(15);
cardboxConfiguration.Property(x => x.QuestionType).IsRequired();
cardboxConfiguration.Property(x => x.DateAddedValue).IsRequired().HasColumnType("date");
cardboxConfiguration.Ignore(x => x.DateAdded);
EntityTypeConfiguration <Cardbox> cardboxDefinitionConfiguration = modelBuilder.Entity <Cardbox>();
cardboxDefinitionConfiguration.HasKey(x => x.Id);
cardboxDefinitionConfiguration.Property(x => x.Duration).IsRequired();
cardboxDefinitionConfiguration.Property(x => x.Number).IsRequired();
}
protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
modelBuilder.Types().Configure(c => c.Ignore("IsDirty"));
modelBuilder.Properties <Guid>().Where(p => p.Name == "Key").Configure(c => c.IsKey());
var temp = new EntityTypeConfiguration <Person>();
temp.Ignore(p => p.Customer);
modelBuilder.Configurations.Add(temp);
var cus = new CustomerConfigurations();
modelBuilder.Configurations.Add(cus);
modelBuilder.Conventions.Add(new TableSchemaAttributeConvention());
modelBuilder.HasDefaultSchema("AnythingsBut_dbo");
base.OnModelCreating(modelBuilder);
}
private void MapContact(EntityTypeConfiguration <Contact> entity)
{
entity.HasKey(k => k.Id).ToTable("Contact");
entity.Property(k => k.Id).HasColumnName("ContactID");
entity.Property(k => k.FirstName).HasColumnName("FirstName");
entity.Property(k => k.LastName).HasColumnName("LastName");
entity.Property(k => k.Title).HasColumnName("Title");
entity.Property(k => k.AddDate).HasColumnName("AddDate").HasColumnType("DATETIME");
entity.Property(k => k.ModifiedDate).HasColumnName("ModifiedDate").HasColumnType("DATETIME");
entity.Property(k => k.RowVersion).IsRowVersion();
entity.Map <Customer>(m =>
{
m.Properties(c => new
{
c.CustomerType,
c.InitialDate,
c.PrimaryActivityId,
c.PrimaryDestinationId,
c.SecondaryActivityId,
c.SecondaryDestinationId,
c.Notes,
c.CustomerRowVersion
});
m.ToTable("Customers");
});
entity.HasMany(k => k.Addresses).WithRequired(k => k.Contact).HasForeignKey(k => k.ContactId).WillCascadeOnDelete(true);
entity.Ignore(k => k.FullName);
}
public override void Build(EntityTypeConfiguration <Group> configuration)
{
configuration.HasKey(x => x.ID);
configuration.Property(x => x.ID).HasColumnName("GroupID");
configuration.HasRequired(x => x.Consumer).WithMany(x => x.Groups).Map(m => m.MapKey("ConsumerID"));
configuration.Ignore(x => x.Permissions);
configuration.HasMany(x => x.Roles)
.WithMany(x => x.Groups)
.Map(map =>
{
map.ToTable("RolesInGroups");
map.MapLeftKey("GroupID");
map.MapRightKey("RoleID");
});
configuration.HasMany(x => x.Users)
.WithMany(x => x.Groups)
.Map(map =>
{
map.ToTable("UsersInGroups");
map.MapLeftKey("GroupID");
map.MapRightKey("UserID");
});
}
public ContactBuilder(EntityTypeConfiguration <Contact> builder)
{
builder.Ignore(b => b.FullName);
builder.Property(b => b.FirstName).HasMaxLength(50).IsRequired();
builder.Property(b => b.LastName).HasMaxLength(50);
builder.HasOptional(a => a.Company).WithMany(b => b.Contacts).HasForeignKey(a => a.CompanyId);
builder.HasOptional(a => a.LeadSource).WithMany(b => b.Contacts).HasForeignKey(a => a.LeadSourceId);
builder.HasOptional(a => a.ReportsToContact).WithMany(b => b.ChildContacts).HasForeignKey(a => a.ReportsToContactId);
builder.HasOptional(a => a.Country).WithMany(b => b.PostalContacts).HasForeignKey(a => a.CountryId);
builder.HasOptional(a => a.City).WithMany(b => b.PostalContacts).HasForeignKey(a => a.CityId);
builder.HasOptional(a => a.Region).WithMany(b => b.PostalContacts).HasForeignKey(a => a.RegionId);
builder.HasOptional(a => a.OtherCountry).WithMany(b => b.OtherContacts).HasForeignKey(a => a.OtherCountryId);
builder.HasOptional(a => a.OtherCity).WithMany(b => b.OtherContacts).HasForeignKey(a => a.OtherCityId);
builder.HasOptional(a => a.OtherRegion).WithMany(b => b.OtherContacts).HasForeignKey(a => a.OtherRegionId);
builder.Property(b => b.Owner).HasMaxLength(100);
builder.Property(b => b.Email).HasMaxLength(100);
builder.Property(b => b.Telephone).HasMaxLength(20);
builder.Property(b => b.OtherPhone).HasMaxLength(20);
builder.Property(b => b.HomePhone).HasMaxLength(20);
builder.Property(b => b.MobilePhone).HasMaxLength(20);
builder.Property(b => b.AssistantName).HasMaxLength(100);
builder.Property(b => b.AssistantPhone).HasMaxLength(20);
builder.Property(b => b.Title).HasMaxLength(100);
builder.Property(b => b.Department).HasMaxLength(100);
builder.Property(b => b.Fax).HasMaxLength(20);
builder.Property(b => b.SkypeId).HasMaxLength(100);
builder.Property(b => b.Twitter).HasMaxLength(100);
builder.Property(b => b.SecondaryEmail).HasMaxLength(100);
builder.Property(b => b.Photo).HasMaxLength(200);
builder.Property(b => b.Address).HasMaxLength(500);
builder.Property(b => b.PostalCode).HasMaxLength(10);
builder.Property(b => b.OtherAddress).HasMaxLength(500);
builder.Property(b => b.OtherPostalCode).HasMaxLength(10);
builder.Property(b => b.Description).HasMaxLength(4000);
}
public static void IgnorePhone(this EntityTypeConfiguration <AppUser> source)
{
source
.Ignore(m => m.PhoneNumber)
.Ignore(m => m.PhoneNumberConfirmed);
}
public override void Configure <TEntity>(EntityTypeConfiguration <TEntity> config)
{
config.HasKey(t => t.Id);
config.Property(t => t.Id).HasDatabaseGeneratedOption(DatabaseGeneratedOption.None);
config.Ignore(t => t.IsActive);
}
private void ConfigurePerson(EntityTypeConfiguration<Person> person) {
person.Ignore(p => p.PersonType);
person.Property(p => p.CreatedBy).IsRequired();
person.Property(p => p.CreatedOn).IsRequired();
}
Alias <
TEntity,
T,
TPropertyConfiguration>(
EntityTypeConfiguration <TEntity> entityConfig,
Expression <Func <TEntity, T> > realExpression,
string aliasName,
Func <Expression <Func <TEntity, T> >, TPropertyConfiguration>
propertyConfigFunc,
out PropertyInfo realInfo,
out TPropertyConfiguration aliasConfig)
where TEntity
: class
where TPropertyConfiguration
: PrimitivePropertyConfiguration
{
Check.Required(entityConfig, "entityConfig");
Check.Required(realExpression, "realExpression");
Check.Required(aliasName, "aliasName");
Check.Required(propertyConfigFunc, "propertyConfigFunc");
//
// First, tell EF not to map the real property. This has the side-effect
// of getting it to sanity-check the real property lambda for us.
//
entityConfig.Ignore(realExpression);
//
// Dig PropertyInfo and (possibly) conversion operator out of the real
// property lambda
//
MethodInfo realConversion;
EFUtilities.GetPropertyInfoAndConversionFromPropertyLambda(
realExpression,
out realInfo,
out realConversion);
string realName = realInfo.Name;
Type realType = realInfo.PropertyType;
//
// Get the alias PropertyInfo
//
var aliasInfo = EFUtilities.GetMappablePropertyInfo(
typeof(TEntity),
realType,
aliasName);
//
// Build a lambda to the alias property, going through the same conversion
// operator as the real one (if present)
//
var aliasExpression = EFUtilities.MakeLambdaToProperty <TEntity, T>(
aliasInfo,
realConversion);
//
// Tell EF to map the alias property to the real property's DB column
//
aliasConfig = propertyConfigFunc(aliasExpression);
aliasConfig.HasColumnName(realName);
//
// Apply alias column settings from attributes on the real property
//
if (realInfo.GetCustomAttributes <RequiredAttribute>().Any())
{
aliasConfig.IsRequired();
}
//
// Remember the property mapping so we can duplicate it when querying
//
lock (realToAlias)
realToAlias[realInfo] = aliasInfo;
}
private void ConfigureMovie(EntityTypeConfiguration<Movie> movie) {
movie.Property(p => p.CreatedBy).IsRequired();
movie.Property(p => p.CreatedOn).IsRequired();
movie.Ignore(m => m.Actors);
movie.Ignore(m => m.Directors);
}
