290 lines
13 KiB
C#
290 lines
13 KiB
C#
using Microsoft.EntityFrameworkCore;
|
|
using Microsoft.SelfService.Portal.Core.API.Extensions.Dataannotations;
|
|
using Microsoft.SelfService.Portal.Core.API.Models;
|
|
using System.Reflection;
|
|
|
|
namespace Microsoft.SelfService.Portal.Core.API.Context
|
|
{
|
|
public class DataContext : DbContext
|
|
{
|
|
public DataContext(DbContextOptions<DataContext> options) : base(options)
|
|
{
|
|
}
|
|
|
|
public DbSet<EnvironmentModel> Environments { get; set; }
|
|
public DbSet<EnvironmentDomainsModel> EnvironmentDomains { get; set; }
|
|
public DbSet<DomainModel> Domains { get; set; }
|
|
public DbSet<TargetModel> Targets { get; set; }
|
|
public DbSet<DeploymentModel> Deployments { get; set; }
|
|
public DbSet<DeploymentGroupModel> DeploymentGroups { get; set; }
|
|
public DbSet<TemplateModel> Templates { get; set; }
|
|
public DbSet<TemplateVersionModel> TemplateVersions { get; set; }
|
|
public DbSet<DeploymentRuleModel> DeploymentRules { get; set; }
|
|
public DbSet<DeploymentRuleStepModel> DeploymentRuleSteps { get; set; }
|
|
public DbSet<DeploymentTemplateSelectionModel> DeploymentTemplateSelections { get; set; }
|
|
public DbSet<DeploymentParameterValueModel> DeploymentParameterValues { get; set; }
|
|
public DbSet<DeploymentTargetAssignmentModel> DeploymentTargetAssignments { get; set; }
|
|
public DbSet<TemplateCategoryModel> TemplateCategories { get; set; }
|
|
public DbSet<ServiceModel> Services { get; set; }
|
|
public DbSet<ServiceRoleDefinitionModel> ServiceRoleDefinitions { get; set; }
|
|
public DbSet<TemplateOptionModel> TemplateOptions { get; set; }
|
|
public DbSet<OptionModel> Options { get; set; }
|
|
public DbSet<OptionCategoryModel> OptionCategories { get; set; }
|
|
public DbSet<QueueJobModel> QueueJobs { get; set; }
|
|
public DbSet<QueueJobTargetModel> QueueJobTargets { get; set; }
|
|
public DbSet<QueueJobStepModel> QueueJobSteps { get; set; }
|
|
|
|
protected override void OnModelCreating(ModelBuilder modelBuilder)
|
|
{
|
|
base.OnModelCreating(modelBuilder);
|
|
|
|
modelBuilder.Entity<EnvironmentDomainsModel>()
|
|
.HasKey(ed => new { ed.EnvironmentId, ed.DomainId });
|
|
|
|
modelBuilder.Entity<EnvironmentDomainsModel>()
|
|
.HasOne(ed => ed.Environment)
|
|
.WithMany(e => e.EnvironmentDomains)
|
|
.HasForeignKey(ed => ed.EnvironmentId);
|
|
|
|
modelBuilder.Entity<EnvironmentDomainsModel>()
|
|
.HasOne(ed => ed.Domain)
|
|
.WithMany(d => d.EnvironmentDomains)
|
|
.HasForeignKey(ed => ed.DomainId);
|
|
|
|
modelBuilder.Entity<TemplateOptionModel>()
|
|
.HasKey(to => new { to.OptionId, to.TemplateId });
|
|
|
|
modelBuilder.Entity<TemplateOptionModel>()
|
|
.HasOne(to => to.Option)
|
|
.WithMany(o => o.TemplateOptions)
|
|
.HasForeignKey(to => to.OptionId);
|
|
|
|
modelBuilder.Entity<TemplateOptionModel>()
|
|
.HasOne(to => to.Template)
|
|
.WithMany(t => t.TemplateOptions)
|
|
.HasForeignKey(to => to.TemplateId);
|
|
|
|
modelBuilder.Entity<TemplateCategoryModel>()
|
|
.HasOne(tc => tc.Service)
|
|
.WithMany(s => s.TemplateCategories)
|
|
.HasForeignKey(tc => tc.ServiceId);
|
|
|
|
modelBuilder.Entity<ServiceRoleDefinitionModel>()
|
|
.HasOne(role => role.Service)
|
|
.WithMany(service => service.RoleDefinitions)
|
|
.HasForeignKey(role => role.ServiceId);
|
|
|
|
modelBuilder.Entity<DeploymentGroupModel>()
|
|
.ToTable("DeploymentBatches");
|
|
|
|
modelBuilder.Entity<TargetModel>()
|
|
.Property(target => target.TargetType)
|
|
.HasMaxLength(64);
|
|
|
|
modelBuilder.Entity<TargetModel>()
|
|
.Property(target => target.ProviderType)
|
|
.HasMaxLength(64);
|
|
|
|
modelBuilder.Entity<DeploymentModel>()
|
|
.ToTable("DeploymentExecutions");
|
|
modelBuilder.Entity<DeploymentModel>()
|
|
.Property(deployment => deployment.DeploymentGroupId)
|
|
.HasColumnName("DeploymentBatchId");
|
|
|
|
modelBuilder.Entity<QueueJobModel>()
|
|
.ToTable("DeploymentJobs");
|
|
|
|
modelBuilder.Entity<QueueJobTargetModel>()
|
|
.ToTable("DeploymentJobTargets");
|
|
modelBuilder.Entity<QueueJobTargetModel>()
|
|
.Property(target => target.QueueJobId)
|
|
.HasColumnName("DeploymentJobId");
|
|
modelBuilder.Entity<QueueJobTargetModel>()
|
|
.Property(target => target.DeploymentGroupId)
|
|
.HasColumnName("DeploymentBatchId");
|
|
|
|
modelBuilder.Entity<QueueJobStepModel>()
|
|
.ToTable("DeploymentJobSteps");
|
|
modelBuilder.Entity<QueueJobStepModel>()
|
|
.Property(step => step.QueueJobId)
|
|
.HasColumnName("DeploymentJobId");
|
|
modelBuilder.Entity<QueueJobStepModel>()
|
|
.Property(step => step.DependsOnQueueJobStepId)
|
|
.HasColumnName("DependsOnDeploymentJobStepId");
|
|
|
|
modelBuilder.Entity<DeploymentModel>()
|
|
.HasKey(d => new { d.TargetId, d.DeploymentGroupId });
|
|
|
|
modelBuilder.Entity<DeploymentModel>()
|
|
.HasOne(d => d.Target)
|
|
.WithMany(vm => vm.Deployments)
|
|
.HasForeignKey(d => d.TargetId);
|
|
|
|
modelBuilder.Entity<DeploymentModel>()
|
|
.HasOne(d => d.DeploymentGroup)
|
|
.WithMany(dg => dg.Deployments)
|
|
.HasForeignKey(d => d.DeploymentGroupId);
|
|
|
|
modelBuilder.Entity<DeploymentGroupModel>()
|
|
.HasOne(dg => dg.Template)
|
|
.WithMany(t => t.DeploymentGroups)
|
|
.HasForeignKey(dg => dg.TemplateId);
|
|
|
|
modelBuilder.Entity<DeploymentGroupModel>()
|
|
.HasOne(dg => dg.DeploymentRule)
|
|
.WithMany()
|
|
.HasForeignKey(dg => dg.DeploymentRuleId)
|
|
.OnDelete(DeleteBehavior.SetNull);
|
|
|
|
modelBuilder.Entity<DeploymentTemplateSelectionModel>()
|
|
.HasOne(selection => selection.DeploymentGroup)
|
|
.WithMany(batch => batch.TemplateSelections)
|
|
.HasForeignKey(selection => selection.DeploymentGroupId);
|
|
|
|
modelBuilder.Entity<DeploymentTemplateSelectionModel>()
|
|
.HasOne(selection => selection.TemplateVersion)
|
|
.WithMany()
|
|
.HasForeignKey(selection => selection.TemplateVersionId)
|
|
.OnDelete(DeleteBehavior.Restrict);
|
|
|
|
modelBuilder.Entity<DeploymentTemplateSelectionModel>()
|
|
.HasIndex(selection => new { selection.DeploymentGroupId, selection.SortOrder })
|
|
.IsUnique();
|
|
|
|
modelBuilder.Entity<DeploymentParameterValueModel>()
|
|
.HasOne(parameterValue => parameterValue.DeploymentGroup)
|
|
.WithMany(batch => batch.ParameterValues)
|
|
.HasForeignKey(parameterValue => parameterValue.DeploymentGroupId);
|
|
|
|
modelBuilder.Entity<DeploymentParameterValueModel>()
|
|
.HasOne(parameterValue => parameterValue.DeploymentTemplateSelection)
|
|
.WithMany()
|
|
.HasForeignKey(parameterValue => parameterValue.DeploymentTemplateSelectionId)
|
|
.OnDelete(DeleteBehavior.NoAction);
|
|
|
|
modelBuilder.Entity<DeploymentParameterValueModel>()
|
|
.HasIndex(parameterValue => new { parameterValue.DeploymentGroupId, parameterValue.DeploymentTemplateSelectionId, parameterValue.Name })
|
|
.IsUnique()
|
|
.HasFilter("[DeploymentTemplateSelectionId] IS NOT NULL");
|
|
|
|
modelBuilder.Entity<DeploymentParameterValueModel>()
|
|
.HasIndex(parameterValue => new { parameterValue.DeploymentGroupId, parameterValue.Name })
|
|
.IsUnique()
|
|
.HasFilter("[DeploymentTemplateSelectionId] IS NULL");
|
|
|
|
modelBuilder.Entity<DeploymentParameterValueModel>()
|
|
.ToTable(table => table.HasCheckConstraint("CK_DeploymentParameterValues_ValueJson_IsJson", "ISJSON([ValueJson]) = 1"));
|
|
|
|
modelBuilder.Entity<DeploymentTargetAssignmentModel>()
|
|
.HasOne(target => target.DeploymentGroup)
|
|
.WithMany(batch => batch.TargetAssignments)
|
|
.HasForeignKey(target => target.DeploymentGroupId);
|
|
|
|
modelBuilder.Entity<DeploymentTargetAssignmentModel>()
|
|
.HasOne(target => target.Target)
|
|
.WithMany()
|
|
.HasForeignKey(target => target.TargetId)
|
|
.OnDelete(DeleteBehavior.Restrict);
|
|
|
|
modelBuilder.Entity<DeploymentTargetAssignmentModel>()
|
|
.HasIndex(target => new { target.DeploymentGroupId, target.TargetId, target.RoleKey })
|
|
.IsUnique();
|
|
|
|
modelBuilder.Entity<DeploymentTargetAssignmentModel>()
|
|
.ToTable(table => table.HasCheckConstraint("CK_DeploymentTargetAssignments_NodeDataJson_IsJson", "ISJSON([NodeDataJson]) = 1"));
|
|
|
|
modelBuilder.Entity<TemplateModel>()
|
|
.HasOne(template => template.DeploymentRule)
|
|
.WithMany()
|
|
.HasForeignKey(template => template.DeploymentRuleId);
|
|
|
|
modelBuilder.Entity<TemplateVersionModel>()
|
|
.HasOne(version => version.Template)
|
|
.WithMany(template => template.TemplateVersions)
|
|
.HasForeignKey(version => version.TemplateId);
|
|
|
|
modelBuilder.Entity<TemplateVersionModel>()
|
|
.HasIndex(version => new { version.TemplateId, version.Version })
|
|
.IsUnique();
|
|
|
|
modelBuilder.Entity<TemplateVersionModel>()
|
|
.HasIndex(version => version.TemplateId)
|
|
.IsUnique()
|
|
.HasFilter("[IsPublished] = 1");
|
|
|
|
modelBuilder.Entity<TemplateVersionModel>()
|
|
.Property(version => version.Version)
|
|
.HasMaxLength(64);
|
|
|
|
modelBuilder.Entity<TemplateVersionModel>()
|
|
.Property(version => version.JsonHash)
|
|
.HasMaxLength(64);
|
|
|
|
modelBuilder.Entity<TemplateVersionModel>()
|
|
.Property(version => version.SchemaVersion)
|
|
.HasMaxLength(32);
|
|
|
|
modelBuilder.Entity<TemplateVersionModel>()
|
|
.ToTable(table => table.HasCheckConstraint("CK_TemplateVersions_JsonData_IsJson", "ISJSON([JsonData]) = 1"));
|
|
|
|
modelBuilder.Entity<DeploymentRuleStepModel>()
|
|
.HasOne(step => step.DeploymentRule)
|
|
.WithMany(rule => rule.Steps)
|
|
.HasForeignKey(step => step.DeploymentRuleId);
|
|
|
|
modelBuilder.Entity<QueueJobTargetModel>()
|
|
.HasOne(target => target.QueueJob)
|
|
.WithMany(job => job.Targets)
|
|
.HasForeignKey(target => target.QueueJobId);
|
|
|
|
modelBuilder.Entity<QueueJobStepModel>()
|
|
.HasOne(step => step.QueueJob)
|
|
.WithMany(job => job.Steps)
|
|
.HasForeignKey(step => step.QueueJobId);
|
|
|
|
modelBuilder.Entity<QueueJobStepModel>()
|
|
.HasOne(step => step.DependsOnQueueJobStep)
|
|
.WithMany()
|
|
.HasForeignKey(step => step.DependsOnQueueJobStepId)
|
|
.OnDelete(DeleteBehavior.Restrict);
|
|
|
|
OnModelCreatingAddDefaultSqlValues(modelBuilder);
|
|
DemoData.Seed(modelBuilder);
|
|
}
|
|
|
|
private void OnModelCreatingAddDefaultSqlValues(ModelBuilder modelBuilder)
|
|
{
|
|
var assemblyName = "Microsoft.SelfService.Portal.Core.API";
|
|
var nameSpace = "Microsoft.SelfService.Portal.Core.API.Models";
|
|
|
|
var asm = Assembly.Load(assemblyName);
|
|
|
|
List<Type> types = asm.GetTypes().Where(p => p.Namespace == nameSpace).ToList();
|
|
var dbSets = typeof(DataContext).GetProperties().Where(p => p.PropertyType.Name.ToLower().Contains("dbset")).ToList();
|
|
List<Type> dbSetTypes = new List<Type>();
|
|
|
|
foreach (PropertyInfo pi in dbSets)
|
|
{
|
|
dbSetTypes.Add(pi.PropertyType.GetGenericArguments()[0]);
|
|
}
|
|
|
|
foreach (Type t in types)
|
|
{
|
|
if (typeof(BaseModel).IsAssignableFrom(t) && t.Name != nameof(BaseModel) && dbSetTypes.Contains(t))
|
|
{
|
|
var properties = t.GetProperties().ToList();
|
|
foreach (var p in properties)
|
|
{
|
|
var att = p.GetCustomAttribute<DefaultValueSqlAttribute>();
|
|
if (att != null)
|
|
{
|
|
modelBuilder.Entity(t).Property(p.Name).HasDefaultValueSql(att.DefaultValueSql);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|