public override void Configure(EntityTypeBuilder <FilterList> builder)
{
// TODO: register and resolve INameRewriter
var nr = new SnakeCaseNameRewriter(CultureInfo.InvariantCulture);
builder.HasIndex(f => f.Name)
.IsUnique();
builder.Property(f => f.LicenseId)
.HasDefaultValue(5);
builder.HasOne(f => f.License)
.WithMany(l => l.FilterLists)
.OnDelete(DeleteBehavior.Restrict);
builder.OwnsMany(
f => f.ViewUrls,
b =>
{
b.ToTable($"{nr.RewriteName(nameof(FilterListViewUrl))}s");
b.Property(u => u.Id)
.UseHiLo($"EntityFrameworkHiLoSequence-{nameof(FilterListViewUrl)}");
b.Property(u => u.SegmentNumber)
.HasDefaultValue(1);
b.Property(u => u.Primariness)
.HasDefaultValue(1);
b.HasIndex(u => new { u.FilterListId, u.SegmentNumber, u.Primariness })
.IsUnique();
b.HasDataJsonFile <FilterListViewUrl>();
});
builder.HasDataJsonFileEntityRequiringApproval <FilterList>();
base.Configure(builder);
}
public virtual void Configure(EntityTypeBuilder <Change> builder)
{
// TODO: register and resolve INameRewriter
var nr = new SnakeCaseNameRewriter(CultureInfo.InvariantCulture);
builder.ToTable($"{nr.RewriteName(nameof(Change))}s");
builder.HasDiscriminator <AggregateType>(nr.RewriteName(nameof(Queries.Entities.Change.AggregateType)))
.HasValue <FilterListChange>(AggregateType.FilterList);
}
public virtual void Configure(EntityTypeBuilder <FilterListSyntax> builder)
{
// TODO: register and resolve INameRewriter
var nr = new SnakeCaseNameRewriter(CultureInfo.InvariantCulture);
builder.ToTable($"{nr.RewriteName(nameof(FilterListSyntax))}es");
builder.HasKey(fls => new { fls.FilterListId, fls.SyntaxId });
builder.HasQueryFilter(fls => fls.FilterList.IsApproved && fls.Syntax.IsApproved);
builder.HasDataJsonFile <FilterListSyntax>();
}
public virtual void Configure(EntityTypeBuilder <SoftwareSyntax> builder)
{
// TODO: register and resolve INameRewriter
var nr = new SnakeCaseNameRewriter(CultureInfo.InvariantCulture);
builder.ToTable($"{nr.RewriteName(nameof(SoftwareSyntax))}es");
builder.HasKey(ss => new { ss.SoftwareId, ss.SyntaxId });
builder.HasQueryFilter(ss => ss.Software.IsApproved && ss.Syntax.IsApproved);
builder.HasDataJsonFile <SoftwareSyntax>();
}
public virtual void Configure(EntityTypeBuilder <Merge> builder)
{
// TODO: register and resolve INameRewriter
var nr = new SnakeCaseNameRewriter(CultureInfo.InvariantCulture);
builder.ToTable($"{nr.RewriteName(nameof(Merge))}s");
builder.HasKey(m => new { m.IncludedInFilterListId, m.IncludesFilterListId });
builder.HasOne(m => m.IncludedInFilterList)
.WithMany(fl => fl.IncludesFilterLists)
.HasForeignKey(m => m.IncludedInFilterListId)
.HasConstraintName("fk_merges_filter_lists_included_in_filter_list_id");
builder.HasOne(m => m.IncludesFilterList)
.WithMany(fl => fl.IncludedInFilterLists)
.HasForeignKey(m => m.IncludesFilterListId)
.HasConstraintName("fk_merges_filter_lists_includes_filter_list_id");
builder.HasQueryFilter(m => m.IncludedInFilterList.IsApproved && m.IncludesFilterList.IsApproved);
builder.HasDataJsonFile <Merge>();
}
public virtual void Configure(EntityTypeBuilder <Dependent> builder)
{
// TODO: register and resolve INameRewriter
var nr = new SnakeCaseNameRewriter(CultureInfo.InvariantCulture);
builder.ToTable($"{nr.RewriteName(nameof(Dependent))}s");
builder.HasKey(d => new { d.DependencyFilterListId, d.DependentFilterListId });
builder.HasOne(d => d.DependencyFilterList)
.WithMany(fl => fl.DependentFilterLists)
.HasForeignKey(d => d.DependencyFilterListId)
.HasConstraintName("fk_dependents_filter_lists_dependency_filter_list_id");
builder.HasOne(d => d.DependentFilterList)
.WithMany(fl => fl.DependencyFilterLists)
.HasForeignKey(d => d.DependentFilterListId)
.HasConstraintName("fk_dependents_filter_lists_dependent_filter_list_id");
builder.HasQueryFilter(d => d.DependencyFilterList.IsApproved && d.DependentFilterList.IsApproved);
builder.HasDataJsonFile <Dependent>();
}
public virtual void Configure(EntityTypeBuilder <Fork> builder)
{
// TODO: register and resolve INameRewriter
var nr = new SnakeCaseNameRewriter(CultureInfo.InvariantCulture);
builder.ToTable($"{nr.RewriteName(nameof(Fork))}s");
builder.HasKey(f => new { f.UpstreamFilterListId, f.ForkFilterListId });
builder.HasOne(f => f.UpstreamFilterList)
.WithMany(fl => fl.ForkFilterLists)
.HasForeignKey(f => f.UpstreamFilterListId)
.HasConstraintName("fk_forks_filter_lists_upstream_filter_list_id");
builder.HasOne(f => f.ForkFilterList)
.WithMany(fl => fl.UpstreamFilterLists)
.HasForeignKey(f => f.ForkFilterListId)
.HasConstraintName("fk_forks_filter_lists_fork_filter_list_id");
builder.HasQueryFilter(f => f.UpstreamFilterList.IsApproved && f.ForkFilterList.IsApproved);
builder.HasDataJsonFile <Fork>();
}
public static void NamingConventionsRewriteName(this ModelBuilder modelBuilder,
DbNamingConvention namingConvention = DbNamingConvention.Default,
CultureInfo culture = null)
{
if (namingConvention == DbNamingConvention.Default)
{
return;
}
INameRewriter nameRewriter = null;
culture ??= CultureInfo.InvariantCulture;
switch (namingConvention)
{
case DbNamingConvention.Default:
break;
case DbNamingConvention.SnakeCase:
nameRewriter = new SnakeCaseNameRewriter(culture);
break;
case DbNamingConvention.LowerCase:
nameRewriter = new LowerCaseNameRewriter(culture);
break;
case DbNamingConvention.UpperCase:
nameRewriter = new UpperCaseNameRewriter(culture);
break;
case DbNamingConvention.UpperSnakeCase:
nameRewriter = new UpperSnakeCaseNameRewriter(culture);
break;
case DbNamingConvention.CamelCase:
nameRewriter = new CamelCaseNameRewriter(culture);
break;
default:
break;
}
foreach (var entity in modelBuilder.Model.GetEntityTypes())
{
entity.SetTableName(nameRewriter.RewriteName(entity.GetTableName()));
foreach (var property in entity.GetProperties())
{
// property.SetColumnName(nameRewriter.RewriteName(property.GetColumnName()));
var columnName = property.GetColumnName(StoreObjectIdentifier.Table(entity.GetTableName(), null));
property.SetColumnName(nameRewriter.RewriteName(columnName));
}
foreach (var key in entity.GetKeys())
{
key.SetName(nameRewriter.RewriteName(key.GetName()));
}
foreach (var key in entity.GetForeignKeys())
{
key.SetConstraintName(nameRewriter.RewriteName(key.GetConstraintName()));
}
foreach (var index in entity.GetIndexes())
{
// index.SetName(nameRewriter.RewriteName(index.GetName());
index.SetDatabaseName(nameRewriter.RewriteName(index.GetDatabaseName()));
}
}
}
public virtual void Configure(EntityTypeBuilder <FilterList> builder)
{
// TODO: register and resolve INameRewriter
var nr = new SnakeCaseNameRewriter(CultureInfo.InvariantCulture);
builder.HasMany(f => f.Syntaxes)
.WithMany(s => s.FilterLists)
.UsingEntity(
nameof(FilterListSyntax),
e =>
{
e.ToTable($"{nr.RewriteName(nameof(FilterListSyntax))}es");
e.Property <long>(nameof(FilterListSyntax.FilterListId));
e.Property <long>(nameof(FilterListSyntax.SyntaxId));
e.HasKey(nameof(FilterListSyntax.FilterListId), nameof(FilterListSyntax.SyntaxId));
});
builder.HasMany(f => f.Languages)
.WithMany(l => l.FilterLists)
.UsingEntity(
nameof(FilterListLanguage),
e =>
{
e.ToTable($"{nr.RewriteName(nameof(FilterListLanguage))}s");
e.Property <long>(nameof(FilterListLanguage.FilterListId));
e.Property <long>(nameof(FilterListLanguage.LanguageId));
e.HasKey(nameof(FilterListLanguage.FilterListId), nameof(FilterListLanguage.LanguageId));
});
builder.HasMany(f => f.Tags)
.WithMany(t => t.FilterLists)
.UsingEntity(
nameof(FilterListTag),
e =>
{
e.ToTable($"{nr.RewriteName(nameof(FilterListTag))}s");
e.Property <long>(nameof(FilterListTag.FilterListId));
e.Property <long>(nameof(FilterListTag.TagId));
e.HasKey(nameof(FilterListTag.FilterListId), nameof(FilterListTag.TagId));
});
builder.OwnsMany(
f => f.ViewUrls,
b =>
{
b.ToTable($"{nr.RewriteName(nameof(FilterListViewUrl))}s");
b.Property(u => u.Id)
.UseHiLo($"EntityFrameworkHiLoSequence-{nameof(FilterListViewUrl)}");
b.Property(u => u.SegmentNumber)
.HasDefaultValue(1);
b.Property(u => u.Primariness)
.HasDefaultValue(1);
b.HasIndex(
nameof(FilterListViewUrl.FilterListId),
nameof(FilterListViewUrl.SegmentNumber),
nameof(FilterListViewUrl.Primariness))
.IsUnique();
});
builder.Navigation(f => f.ViewUrls)
.AutoInclude();
builder.HasMany(f => f.Maintainers)
.WithMany(m => m.FilterLists)
.UsingEntity(
nameof(FilterListMaintainer),
e =>
{
e.ToTable($"{nr.RewriteName(nameof(FilterListMaintainer))}s");
e.Property <long>(nameof(FilterListMaintainer.FilterListId));
e.Property <long>(nameof(FilterListMaintainer.MaintainerId));
e.HasKey(nameof(FilterListMaintainer.FilterListId), nameof(FilterListMaintainer.MaintainerId));
});
builder.HasMany(f => f.UpstreamFilterLists)
.WithMany(f => f.ForkFilterLists)
.UsingEntity <Dictionary <string, object> >(
nameof(Fork),
rj => rj
.HasOne <FilterList>()
.WithMany()
.HasForeignKey(nameof(Fork.UpstreamFilterListId)),
lj => lj
.HasOne <FilterList>()
.WithMany()
.HasForeignKey(nameof(Fork.ForkFilterListId)),
e => e.ToTable($"{nr.RewriteName(nameof(Fork))}s"));
builder.HasMany(f => f.IncludedInFilterLists)
.WithMany(f => f.IncludesFilterLists)
.UsingEntity <Dictionary <string, object> >(
nameof(Merge),
rj => rj
.HasOne <FilterList>()
.WithMany()
.HasForeignKey(nameof(Merge.IncludedInFilterListId)),
lj => lj
.HasOne <FilterList>()
.WithMany()
.HasForeignKey(nameof(Merge.IncludesFilterListId)),
e => e.ToTable($"{nr.RewriteName(nameof(Merge))}s"));
builder.HasMany(f => f.DependencyFilterLists)
.WithMany(f => f.DependentFilterLists)
.UsingEntity <Dictionary <string, object> >(
nameof(Dependent),
rj => rj
.HasOne <FilterList>()
.WithMany()
.HasForeignKey(nameof(Dependent.DependencyFilterListId)),
lj => lj
.HasOne <FilterList>()
.WithMany()
.HasForeignKey(nameof(Dependent.DependentFilterListId)),
e => e.ToTable($"{nr.RewriteName(nameof(Dependent))}s"));
builder.HasMany(f => f.Changes)
.WithOne()
.HasForeignKey(nameof(Change.FilterListId));
builder.Navigation(f => f.Changes)
.AutoInclude();
}
