public static Microsoft.EntityFrameworkCore.ModelBuilder AddWaifuRelations(
this Microsoft.EntityFrameworkCore.ModelBuilder mb)
{
mb.Entity <UserWaifu>()
.HasKey(k => new { k.UserId, k.WaifuId });
mb.Entity <UserWaifu>()
.HasOne(u => u.Owner)
.WithMany(w => w.UserWaifus)
.HasForeignKey(k => k.UserId)
.OnDelete(DeleteBehavior.Cascade);
mb.Entity <UserWaifu>()
.HasOne(w => w.Waifu)
.WithMany(m => m.UserWaifus)
.HasForeignKey(k => k.WaifuId)
.OnDelete(DeleteBehavior.Cascade);
mb.Entity <User>()
.HasOne(u => u.FavoriteWaifu)
.WithMany(w => w.UsersFavorite)
.HasForeignKey(k => k.FavoriteWaifuId)
.IsRequired(false)
.OnDelete(DeleteBehavior.SetNull);
return(mb);
}
protected override void OnModelCreating(Microsoft.EntityFrameworkCore.ModelBuilder modelBuilder)
{
modelBuilder.Entity <TimelinePost>()
.HasOne(e => e.PostFriend)
.WithMany()
.HasForeignKey(e => e.PostFriendId);
}
protected override void OnModelCreating(Microsoft.EntityFrameworkCore.ModelBuilder builder)
{
builder.Entity <IdentityRole>(r => r.HasData(
new IdentityRole
{
Id = "1",
Name = "Admin",
NormalizedName = "Admin"
},
new IdentityRole
{
Id = "2",
Name = "Mentor",
NormalizedName = "Mentor"
},
new IdentityRole
{
Id = "3",
Name = "Student",
NormalizedName = "Student"
}
));
base.OnModelCreating(builder);
}
private EntityType CreateEntityType(Microsoft.EntityFrameworkCore.ModelBuilder modelBuilder, String tableName)
{
if (!_entityTypes.TryGetValue(tableName, out EntityType entityType))
{
var dynamicTypeDefinition = TypeDefinitionManager.GetDynamicTypeDefinition(tableName);
EntityTypeBuilder entityTypeBuilder = modelBuilder.Entity(dynamicTypeDefinition.DynamicTypeType).ToTable(tableName);
entityType = (EntityType)entityTypeBuilder.Metadata;
foreach (DynamicPropertyInfo property in MetadataProvider.GetStructuralProperties(tableName))
{
String fieldName = dynamicTypeDefinition.AddShadowPropertyFieldInfo(property.Name, property.Type).Name;
PropertyBuilder propertyBuilder = entityTypeBuilder.Property(property.Type, property.Name).HasField(fieldName);
if (property.DatabaseGeneratedOption == DatabaseGeneratedOption.Identity)
{
propertyBuilder.ValueGeneratedOnAdd();
}
else if (property.DatabaseGeneratedOption == DatabaseGeneratedOption.Computed)
{
propertyBuilder.ValueGeneratedOnAddOrUpdate();
}
else
{
propertyBuilder.ValueGeneratedNever();
}
}
entityTypeBuilder.HasKey(MetadataProvider.GetPrimaryKey(tableName).ToArray());
_entityTypes.Add(tableName, entityType);
}
return(entityType);
}
private static void Champion(Microsoft.EntityFrameworkCore.ModelBuilder modelBuilder)
{
//modelBuilder.Entity<Champion>()
// .HasOne(bc => bc.NoticeBoard)
// .WithMany(b => b.Champions)
// .HasForeignKey(bc => bc.NoticeBoardId);
}
public static Microsoft.EntityFrameworkCore.ModelBuilder AddWaifuRequestRelations(
this Microsoft.EntityFrameworkCore.ModelBuilder mb)
{
mb.Entity <WaifuRequest>()
.HasOne(k => k.User)
.WithMany(u => u.WaifuRequests)
.HasForeignKey(k => k.UserId)
.OnDelete(DeleteBehavior.Cascade);
mb.Entity <WaifuRequest>()
.Property(p => p.ProcessedTime)
.IsRequired(false)
.HasDefaultValue(null);
mb.Entity <WaifuRequest>()
.Property(p => p.RejectReason)
.IsRequired(false)
.HasDefaultValue(null);
mb.Entity <WaifuRequest>()
.Property(p => p.RequestState)
.HasDefaultValue(RequestState.Pending);
return(mb);
}
public void Customize(Microsoft.EntityFrameworkCore.ModelBuilder modelBuilder, DbContext context)
{
_modelCustomizer.Customize(modelBuilder, context);
foreach (IMutableEntityType entityType in modelBuilder.Model.GetEntityTypes())
{
entityType.SetQueryFilter(GetFilter(entityType.ClrType));
if (entityType.GetSchema() != null)
{
entityType.SetSchema(entityType.GetSchema().ToLowerInvariant());
}
entityType.SetTableName(entityType.GetTableName().ToLowerInvariant());
foreach (IMutableProperty property in entityType.GetProperties())
{
property.SetColumnName(property.GetColumnName().ToLowerInvariant());
}
}
Expression <Func <Parameter, bool> > parameterFilter = t => t.SpecificSchema != "pg_catalog" && t.SpecificSchema != "information_schema";
modelBuilder.Model.FindEntityType(typeof(Parameter)).SetQueryFilter(parameterFilter);
Expression <Func <Routine, bool> > routineFilter = t => t.SpecificSchema != "pg_catalog" && t.SpecificSchema != "information_schema" && t.DataType != "internal";
modelBuilder.Model.FindEntityType(typeof(Routine)).SetQueryFilter(routineFilter);
}
public static Microsoft.EntityFrameworkCore.ModelBuilder AddStarboardRelations(
this Microsoft.EntityFrameworkCore.ModelBuilder mb)
{
mb.Entity <Starboard>()
.Property(p => p.StarboardThreshold)
.HasDefaultValue(1);
mb.Entity <Starboard>()
.HasOne(s => s.Guild)
.WithOne(g => g.Starboard)
.HasForeignKey <Starboard>(k => k.GuildId)
.IsRequired(true)
.OnDelete(DeleteBehavior.Cascade);
mb.Entity <Starboard>()
.HasKey(k => k.GuildId);
mb.Entity <StarboardMessage>()
.HasOne(m => m.Guild)
.WithMany(g => g.StarboardMessages)
.HasForeignKey(k => k.GuildId)
.OnDelete(DeleteBehavior.Cascade);
return(mb);
}
public static void Grades(this Microsoft.EntityFrameworkCore.ModelBuilder modelBuilder)
{
modelBuilder.Entity <Grade>().HasData(new Grade {
Id = 1, ExamTime = "01:30H", Evaluation = 5, CourseId = 1, StudentId = 1
});
modelBuilder.Entity <Grade>().HasData(new Grade {
Id = 2, ExamTime = "01:15H", Evaluation = 4, CourseId = 2, StudentId = 2
});
modelBuilder.Entity <Grade>().HasData(new Grade {
Id = 3, ExamTime = "01:30H", Evaluation = 4, CourseId = 3, StudentId = 3
});
modelBuilder.Entity <Grade>().HasData(new Grade {
Id = 4, ExamTime = "01:00H", Evaluation = 3, CourseId = 4, StudentId = 4
});
modelBuilder.Entity <Grade>().HasData(new Grade {
Id = 5, ExamTime = "01:45H", Evaluation = 2, CourseId = 3, StudentId = 2
});
modelBuilder.Entity <Grade>().HasData(new Grade {
Id = 6, ExamTime = "01:30H", Evaluation = 4, CourseId = 2, StudentId = 3
});
modelBuilder.Entity <Grade>().HasData(new Grade {
Id = 7, ExamTime = "01:15H", Evaluation = 5, CourseId = 1, StudentId = 1
});
modelBuilder.Entity <Grade>().HasData(new Grade {
Id = 8, ExamTime = "01:30H", Evaluation = 3, CourseId = 4, StudentId = 4
});
modelBuilder.Entity <Grade>().HasData(new Grade {
Id = 9, ExamTime = "01:00H", Evaluation = 5, CourseId = 3, StudentId = 1
});
modelBuilder.Entity <Grade>().HasData(new Grade {
Id = 10, ExamTime = "01:45H", Evaluation = 5, CourseId = 1, StudentId = 5
});
}
public void Customize(Microsoft.EntityFrameworkCore.ModelBuilder modelBuilder, DbContext context)
{
_modelCustomizer.Customize(modelBuilder, context);
foreach (IMutableEntityType entityType in modelBuilder.Model.GetEntityTypes())
{
entityType.QueryFilter = GetFilter(entityType.ClrType);
RelationalEntityTypeAnnotations relational = entityType.Relational();
if (relational.Schema != null)
{
relational.Schema = relational.Schema.ToLowerInvariant();
}
relational.TableName = entityType.Relational().TableName.ToLowerInvariant();
foreach (IMutableProperty property in entityType.GetProperties())
{
property.Relational().ColumnName = property.Relational().ColumnName.ToLowerInvariant();
}
}
Expression <Func <Parameter, bool> > parameterFilter = t => t.SpecificSchema != "pg_catalog" && t.SpecificSchema != "information_schema" && t.DataType != "ARRAY";
modelBuilder.Model.FindEntityType(typeof(Parameter)).QueryFilter = parameterFilter;
Expression <Func <Routine, bool> > routineFilter = t => t.SpecificSchema != "pg_catalog" && t.SpecificSchema != "information_schema";
modelBuilder.Model.FindEntityType(typeof(Routine)).QueryFilter = routineFilter;
}
protected override void OnModelCreating(Microsoft.EntityFrameworkCore.ModelBuilder modelBuilder)
{
base.OnModelCreating(modelBuilder);
modelBuilder.Entity <Dept>().HasAlternateKey(d => d.Ref);
modelBuilder.Entity <Acct>().HasOne(a => a.DeptRefNavigation).WithMany(d => d.AcctRefs).HasForeignKey(a => a.DeptRef).HasPrincipalKey(d => d.Ref);
}
protected override void OnModelCreating(ef.ModelBuilder modelBuilder)
{
modelBuilder.Entity <User>();
modelBuilder.Entity <Appointment>();
base.OnModelCreating(modelBuilder);
}
protected override void OnModelCreating(Microsoft.EntityFrameworkCore.ModelBuilder modelBuilder)
{
base.OnModelCreating(modelBuilder);
modelBuilder.Entity <Article>().ToTable("Article");
modelBuilder.Entity <Log>().ToTable("Log");
modelBuilder.Entity <Comment>().ToTable("Comment");
}
protected override void OnModelCreating(Microsoft.EntityFrameworkCore.ModelBuilder modelBuilder)
{
modelBuilder.Entity <Customer>().HasKey(c => new { c.Country, c.Id });
modelBuilder.Entity <ShippingAddress>().HasKey(s => new { s.OrderId, s.Id });
modelBuilder.Entity <CustomerShippingAddress>().HasKey(t => new { t.CustomerCountry, t.CustomerId, t.ShippingAddressOrderId, t.ShippingAddressId });
base.OnModelCreating(modelBuilder);
}
public static void Seed(this Microsoft.EntityFrameworkCore.ModelBuilder modelBuilder)
{
Cities(modelBuilder);
NoticeBoard(modelBuilder);
Countries(modelBuilder);
QuizTheme(modelBuilder);
}
public static void QuizTheme(this Microsoft.EntityFrameworkCore.ModelBuilder modelBuilder)
{
modelBuilder.Entity <QuizTheme>().HasData(new QuizTheme {
Id = 1, Name = "Science fiction",
});
modelBuilder.Entity <QuizTheme>().HasData(new QuizTheme {
Id = 2, Name = "Books",
});
modelBuilder.Entity <QuizTheme>().HasData(new QuizTheme {
Id = 3, Name = "TV shows",
});
modelBuilder.Entity <QuizTheme>().HasData(new QuizTheme {
Id = 4, Name = "Movies",
});
modelBuilder.Entity <QuizTheme>().HasData(new QuizTheme {
Id = 5, Name = "Techonolgy",
});
modelBuilder.Entity <QuizTheme>().HasData(new QuizTheme {
Id = 6, Name = "Programming",
});
modelBuilder.Entity <QuizTheme>().HasData(new QuizTheme {
Id = 7, Name = "Geography",
});
modelBuilder.Entity <QuizTheme>().HasData(new QuizTheme {
Id = 8, Name = "History",
});
modelBuilder.Entity <QuizTheme>().HasData(new QuizTheme {
Id = 9, Name = "Games",
});
}
public static Microsoft.EntityFrameworkCore.ModelBuilder ApplyConventions(this Microsoft.EntityFrameworkCore.ModelBuilder modelBuilder)
{
var entities = modelBuilder.Model.GetEntityTypes();
foreach (var entity in entities)
{
var properties = entity.GetProperties();
foreach (var prop in properties)
{
if (prop.ClrType != typeof(string))
{
continue;
}
prop.SetIsUnicode(false);
if (prop.GetMaxLength() == null)
{
prop.SetMaxLength(Constants.Database.DefaultVarcharMaxLength);
}
}
var cascadeForeignKeys = entity.GetForeignKeys()
.Where(c => !c.IsOwnership && c.DeleteBehavior == DeleteBehavior.Cascade);
foreach (var fk in cascadeForeignKeys)
{
fk.DeleteBehavior = DeleteBehavior.Restrict;
}
}
return(modelBuilder);
}
protected override void OnModelCreating(Microsoft.EntityFrameworkCore.ModelBuilder modelBuilder)
{
modelBuilder.Entity <Customer>().HasKey(c => new { c.Country, c.Id });
modelBuilder.Entity <ShippingAddress>().HasKey(s => new { s.OrderId, s.Id });
modelBuilder.Entity <CustomerShippingAddress>().HasKey(t => new { t.CustomerCountry, t.CustomerId, t.ShippingAddressOrderId, t.ShippingAddressId });
modelBuilder.Query <CustomerOrdersCount>();
modelBuilder.Entity <Order>().HasData(
new Order()
{
Id = 1, Name = "Order from Order2 context", CustomerCountry = "AL", CustomerId = 42, Status = OrderStatus.Cancelled
}
);
modelBuilder.Entity <ManyColumns2>().HasData(
new ManyColumns2()
{
Column01 = 123456
}
);
modelBuilder.Entity <Customer>().HasData(
new Customer()
{
Id = 42, Country = "AL", Name = "Dua Lipa"
}
);
}
protected override void OnModelCreating(Microsoft.EntityFrameworkCore.ModelBuilder modelBuilder)
{
modelBuilder.Entity <Employee>()
.HasDiscriminator <string>("Type")
.HasValue <Worker>(EmployeeType.Worker.Title)
.HasValue <Manager>(EmployeeType.Manager.Title)
.HasValue <Sales>(EmployeeType.Sales.Title);
}
public void Customize(Microsoft.EntityFrameworkCore.ModelBuilder modelBuilder, DbContext context)
{
_modelCustomizer.Customize(modelBuilder, context);
Expression <Func <Parameter, bool> > parameterFilter = t => t.DataType != "table type";
modelBuilder.Model.FindEntityType(typeof(Parameter)).SetQueryFilter(parameterFilter);
}
protected override void OnModelCreating(Microsoft.EntityFrameworkCore.ModelBuilder modelBuilder)
{
modelBuilder.ApplyConfiguration(new UserModelBuilder());
modelBuilder.ApplyConfiguration(new ErrorModelBuilder());
modelBuilder.ApplyConfiguration(new ErrorFileModelBuilder());
base.OnModelCreating(modelBuilder);
}
public void Build(Microsoft.EntityFrameworkCore.ModelBuilder modelBuilder)
{
foreach (String tableName in MetadataProvider.GetTableNames())
{
CreateEntityType(modelBuilder, tableName);
CreateNavigationProperties(modelBuilder, tableName);
}
}
protected override void OnModelCreating(Microsoft.EntityFrameworkCore.ModelBuilder modelBuilder)
{
base.OnModelCreating(modelBuilder);
modelBuilder.ApplyConfiguration(new EmployeeConfiguration());
modelBuilder.ApplyConfiguration(new AddressConfiguration());
modelBuilder.ApplyConfiguration(new ProjectConfiguration());
modelBuilder.ApplyConfiguration(new ProjectEngagementConfiguration());
}
internal static void SetEntityQueryFilter <TEntityInterface>(
this Microsoft.EntityFrameworkCore.ModelBuilder builder,
Type entityType,
Expression <Func <TEntityInterface, bool> > filterExpression)
{
SetQueryFilterMethod
.MakeGenericMethod(entityType, typeof(TEntityInterface))
.Invoke(null, new object[] { builder, filterExpression });
}
protected override void OnModelCreating(Microsoft.EntityFrameworkCore.ModelBuilder modelBuilder)
{
//modelBuilder.Entity<Usuario>()
// .HasData(new List<Usuario>(){
// new Usuario(1, "*****@*****.**", "123", "primeiro nm", "nm completo", "end", "compl", 1, "cidade nv", "rj", "12345", "M")
//});
//modelBuilder.Conventions.Remove<PluralizingTableNameConvention>();
}
public static Microsoft.EntityFrameworkCore.ModelBuilder AddClanRelations(this Microsoft.EntityFrameworkCore.ModelBuilder mb)
{
mb.Entity <Clan>()
.Property(p => p.Description)
.IsRequired(false);
mb.Entity <Clan>()
.Property(p => p.AvatarUrl)
.IsRequired(false);
mb.Entity <Clan>()
.Property(p => p.Level)
.IsRequired(true)
.HasDefaultValue(0);
// Make name unique
// mb.Entity<Clan>()
// .HasAlternateKey(k => k.Name);
mb.Entity <Clan>()
.HasOne(u => u.Owner)
.WithOne(a => a.ClanOwner)
.HasForeignKey <Clan>(k => k.OwnerId)
.OnDelete(DeleteBehavior.Cascade);
mb.Entity <ClanMember>()
.HasKey(k => k.UserId);
mb.Entity <ClanMember>()
.HasOne(u => u.Clan)
.WithMany(m => m.Members)
.HasForeignKey(k => k.ClanId)
.OnDelete(DeleteBehavior.Cascade);
mb.Entity <ClanMember>()
.HasOne(u => u.User)
.WithOne(c => c.ClanMember)
.HasForeignKey <ClanMember>(k => k.UserId)
.OnDelete(DeleteBehavior.Cascade);
mb.Entity <ClanInvite>()
.HasKey(k => new { k.ClanId, k.UserId });
mb.Entity <ClanInvite>()
.HasOne(u => u.Clan)
.WithMany(m => m.Invites)
.HasForeignKey(k => k.ClanId)
.OnDelete(DeleteBehavior.Cascade);
mb.Entity <ClanInvite>()
.HasOne(u => u.User)
.WithMany(c => c.ClanInvites)
.HasForeignKey(k => k.UserId)
.OnDelete(DeleteBehavior.Cascade);
return(mb);
}
public static void Executors(this Microsoft.EntityFrameworkCore.ModelBuilder modelBuilder)
{
modelBuilder.Entity <Executor>().HasData(new Executor {
Id = 1, Description = "Learning syntax", CourseId = 1, TeacherId = 1
});
modelBuilder.Entity <Executor>().HasData(new Executor {
Id = 2, Description = "Introductory lecture", CourseId = 2, TeacherId = 2
});
}
protected override void OnModelCreating(ModelBuilder builder)
{
base.OnModelCreating(builder);
// Customize the ASP.NET Identity model and override the defaults if needed.
// For example, you can rename the ASP.NET Identity table names and more.
// Add your customizations after calling base.OnModelCreating(builder);
builder.HasPostgresExtension("uuid-ossp");
//builder.Entity<User>().HasMany(u => u.Preferences).WithOne(p => p.User);//.OnDelete(DeleteBehavior.SetNull);
}
public static void Divisions(this Microsoft.EntityFrameworkCore.ModelBuilder modelBuilder)
{
modelBuilder.Entity <Division>().HasData(new Division {
Id = 1, Name = "Computer System Maintenance", CollegeId = 1
});
modelBuilder.Entity <Division>().HasData(new Division {
Id = 2, Name = "Computer Science", CollegeId = 2
});
}
//protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
//{
// optionsBuilder.UseSqlServer(
// @"Server=(localdb)\mssqllocaldb;Database=ODataServiceAspNetCore;Integrated Security=True");
//}
protected override void OnModelCreating(Microsoft.EntityFrameworkCore.ModelBuilder modelBuilder)
{
modelBuilder.Entity <Product>().Property(p => p.Id).ValueGeneratedOnAdd();
modelBuilder.Entity <ProductFamily>().Property(p => p.Id).ValueGeneratedNever();
modelBuilder.Entity <Supplier>().Property(p => p.Id).ValueGeneratedNever();
modelBuilder.Entity <Supplier>().OwnsOne(p => p.Address);
base.OnModelCreating(modelBuilder);
}
