protected override void OnModelCreating(ModelBuilder modelBuilder)
{
// Timestamp/row version
modelBuilder.Entity <Blog>()
.Property(p => p.Timestamp)
.IsRowVersion();
modelBuilder.Entity <Blog>()
.HasIndex(d => d.Url)
.IsUnique();
var convert = new EnumToStringConverter <PostType>();
modelBuilder.Entity <Post>()
.Property(d => d.PostType)
.HasConversion(convert);
base.OnModelCreating(modelBuilder);
}
/// <summary>
/// Override this method to further configure the model that was discovered by convention from the entity types
/// exposed in dbset properties on your derived context. The resulting model may be cached
/// and re-used for subsequent instances of your derived context.
/// </summary>
/// <param name="builder">The builder being used to construct the model for this context. Databases (and other extensions) typically
/// define extension methods on this object that allow you to configure aspects of the model that are specific
/// to a given database.</param>
/// <exception cref="ArgumentNullException">modelBuilder.</exception>
/// <remarks>
/// If a model is explicitly set on the options for this context" />)
/// then this method will not be run.
/// </remarks>
protected override void OnModelCreating(ModelBuilder builder)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
base.OnModelCreating(builder);
EnumToStringConverter <DayOfWeek> converterDayOfWeek = new EnumToStringConverter <DayOfWeek>();
EnumToStringConverter <ETimePeriod> converterTimePeriod = new EnumToStringConverter <ETimePeriod>();
CompetitionDto.OnModelBuilding(
builder,
converterDayOfWeek,
converterTimePeriod);
DisableCascadeDeletes(builder);
}
public void Configure(EntityTypeBuilder <PaymentMethod> builder)
{
builder.HasOne(pm => pm.User)
.WithMany(u => u.PaymentMethods)
.HasForeignKey(pm => pm.UserId);
builder.HasOne(pm => pm.CreditCard)
.WithOne(cc => cc.PaymentMethod)
.HasForeignKey <PaymentMethod>(pm => pm.CreditCardId);
builder.HasOne(pm => pm.BankAccount)
.WithOne(ba => ba.PaymentMethod)
.HasForeignKey <PaymentMethod>(pm => pm.BankAccountId);
var converter = new EnumToStringConverter <PaymentType>();
builder.Property(pm => pm.Type)
.HasConversion(converter);
}
public void EnumToStringConverterTest()
{
var conv = new EnumToStringConverter();
var a = MockEnum.Simple;
var b = MockEnum.MultipleWordsInTheName;
var aForward = conv.Convert(a, typeof(MockEnum), null, _cult) as string;
var bForward = conv.Convert(b, typeof(MockEnum), null, _cult) as string;
Assert.AreEqual("Simple", aForward);
Assert.AreEqual("Multiple Words In The Name", bForward);
var aBack = conv.ConvertBack(aForward, typeof(MockEnum), null, _cult);
var bBack = conv.ConvertBack(bForward, typeof(MockEnum), null, _cult);
Assert.AreEqual(a, aBack);
Assert.AreEqual(b, bBack);
}
public void Configure(EntityTypeBuilder <PaymentHistory> builder)
{
var descriptionConverter = new EnumToStringConverter <PaymentDescription>();
builder.ToTable("PaymentHistory");
builder.HasKey(x => x.Id);
builder.Property(x => x.Id).ValueGeneratedOnAdd();
builder.Property(x => x.Date).HasDefaultValueSql("GETDATE()");
builder.Property(x => x.Description)
.IsRequired()
.HasConversion(descriptionConverter)
.HasMaxLength(32);
builder.Property(x => x.Saldo).IsRequired().HasColumnType("decimal(18, 2)");
builder.Property(x => x.CurrentBalance).HasColumnType("decimal(18, 2)");
builder.HasOne(x => x.Payer).WithMany().HasForeignKey(x => x.UserId);
}
public void Configure(EntityTypeBuilder <Activity> builder)
{
var activitySeverityConverter = new EnumToStringConverter <ActivitySeverityEnum>();
builder
.Property(a => a.Severity)
.HasConversion(activitySeverityConverter);
var activityObjectConverter = new EnumToStringConverter <ActivityObjectEnum>();
builder
.Property(a => a.ObjectName)
.HasConversion(activityObjectConverter);
builder
.HasOne(a => a.CreatedBy)
.WithMany(u => u.Activities)
.HasForeignKey(a => a.CreatedById);
}
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
var converter = new BoolToStringConverter("F", "T");
var myBoolConverter = new ValueConverter <bool, string>(
v => v ? "T" : "F",
v => v == "T"
);
var enumConverter = new EnumToStringConverter <BoolEnum>();
var myEnumConverter = new ValueConverter <BooleanEnum, string>(
v => v == BooleanEnum.TrueValue ? "T" : "F",
v => v == "T" ? BooleanEnum.TrueValue : BooleanEnum.FalseValue
);
modelBuilder.Entity <Zbozi>(ent =>
{
ent.ToTable("ZBOZI");
ent.HasKey(k => k.C_ZBO);
ent.Property(p => p.NAZEV).IsRequired();
// field ZRUSENO is Oracle: CHAR(1) NULL
ent.Property(p => p.ZRUSENO).HasConversion(converter);
// field ZOBR_INTERNET is Oracle: CHAR(1) NULL
ent.Property(p => p.ZOBR_INTERNET).HasConversion(myBoolConverter);
// field SESTAVA is Oracle: CHAR(1) NULL
ent.Property(p => p.SESTAVA).HasConversion(enumConverter);
// field SALOBAL is Oracle: CHAR(1) NULL
ent.Property(p => p.SALOBAL).HasConversion(myEnumConverter);
});
modelBuilder.Entity <Rkdav>(ent =>
{
ent.HasKey(k => k.RKDAV);
ent.Property(p => p.RKDAV).HasMaxLength(5);
});
modelBuilder.Entity <Entity>(ent =>
{
ent.HasKey(k => k.ENTITA);
});
}
public async Task <string[]> CancelAllOrders(string symbol = null, TradeType?tradeType = null)
{
// /api/v1/orders
var dict = new Dictionary <string, object>();
if (symbol != null)
{
dict.Add("symbol", symbol);
}
if (tradeType != null)
{
dict.Add("tradeType", EnumToStringConverter <TradeType> .GetEnumName((TradeType)tradeType));
}
var jobj = await MakeRequest(HttpMethod.Delete, "/api/v1/orders", reqParams : dict);
return(jobj["cancelledOrderIds"].ToObject <string[]>());
}
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
// TODO create migarion, update db, update remote db
var productPaymentInfoTypeEnumConverter = new EnumToStringConverter <ProductPaymentInfoType>();
var fieldTypeEnumConverter = new EnumToStringConverter <FieldType>();
var fieldInerfaceTypeEnumConverter = new EnumToStringConverter <FieldInerfaceType>();
modelBuilder.Entity <ProviderField>().Property(x => x.Type).HasConversion(fieldTypeEnumConverter);
modelBuilder.Entity <ProviderField>().Property(x => x.InterfaceType).HasConversion(fieldInerfaceTypeEnumConverter);
modelBuilder.Entity <ProductPaymentInfo>().Property(x => x.ProductType).HasConversion(productPaymentInfoTypeEnumConverter);
//modelBuilder.ApplyConfiguration(new PaymentCategoryConfigurator());
//modelBuilder.ApplyConfiguration(new PaymentCommissionConfigurator());
modelBuilder.ApplyConfiguration(new PaymentInfoConfigurator());
modelBuilder.ApplyConfiguration(new PaymentProviderConfigurator());
modelBuilder.ApplyConfiguration(new PaymentProviderFieldConfigurator());
modelBuilder.ApplyConfiguration(new PaymentProviderRegionConfigurator());
modelBuilder.ApplyConfiguration(new ProductPaymentInfoConfigurator());
//modelBuilder.ApplyConfiguration(new ProviderMaskListItemConfigurator());
}
public void Configure(EntityTypeBuilder <Optionmeta> builder)
{
var keyConverter = new EnumToStringConverter <KeyEnum>();
builder
.Property(om => om.Key)
.HasConversion(keyConverter);
var valueConverter = new EnumToStringConverter <ValueEnum>();
builder
.Property(om => om.Value)
.HasConversion(valueConverter);
var defaultValueConverter = new EnumToStringConverter <ValueEnum>();
builder
.Property(om => om.DefaultValue)
.HasConversion(defaultValueConverter);
}
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
var converterParamType = new EnumToStringConverter <ParamType>();
modelBuilder
.Entity <Param>()
.Property(e => e.Type)
.HasConversion(converterParamType);
//var converterUnitType = new EnumToStringConverter<UnitType>();
//modelBuilder
// .Entity<ParamValue>()
// .Property(e => e.Unit)
// .HasConversion(converterUnitType);
var converterQuestionType = new EnumToStringConverter <QuestionType>();
modelBuilder
.Entity <Question>()
.Property(e => e.Type)
.HasConversion(converterQuestionType);
var converterQuestionScenarioType = new EnumToStringConverter <QuestionScenarioType>();
modelBuilder
.Entity <Question>()
.Property(e => e.ScenarioType)
.HasConversion(converterQuestionScenarioType);
var converterScenarioType = new EnumToStringConverter <ScenarioType>();
modelBuilder
.Entity <Scenario>()
.Property(e => e.Type)
.HasConversion(converterScenarioType);
}
protected override void OnModelCreating(ModelBuilder builder)
{
var cascadeFKs = builder.Model.GetEntityTypes()
.SelectMany(t => t.GetForeignKeys())
.Where(fk => !fk.IsOwnership && fk.DeleteBehavior == DeleteBehavior.Cascade);
foreach (var fk in cascadeFKs)
{
fk.DeleteBehavior = DeleteBehavior.Cascade;
}
var providerConverter = new EnumToStringConverter <Provider>();
builder
.Entity <CloudProvider>()
.Property(e => e.Provider)
.HasConversion(providerConverter);
builder.Entity <MddComponent>().Ignore(p => p.MddComponents);
base.OnModelCreating(builder);
}
public void Configure(EntityTypeBuilder <Post> builder)
{
var statusConverter = new EnumToStringConverter <PostStatusEnum>();
builder
.Property(p => p.PostStatus)
.HasConversion(statusConverter);
var typeConverter = new EnumToStringConverter <PostTypeEnum>();
builder
.Property(p => p.Type)
.HasConversion(typeConverter);
var visibilityConverter = new EnumToStringConverter <PostVisibility>();
builder
.Property(p => p.Visibility)
.HasConversion(visibilityConverter);
builder
.HasIndex(p => p.Title)
.IsUnique();
builder
.HasIndex(p => p.Slug)
.IsUnique();
builder
.HasOne(p => p.CreatedBy)
.WithMany(u => u.CreatedPosts)
.HasForeignKey(p => p.CreatedById);
builder
.HasOne(p => p.ModifiedBy)
.WithMany(u => u.ModifiedPosts)
.HasForeignKey(p => p.ModifiedById);
}
public void Configure(EntityTypeBuilder <Package> builder)
{
var deliveryStatusConverter = new EnumToStringConverter <DeliveryStatus>();
builder.ToTable("Packages");
builder.HasKey(p => p.PackageId);
builder.Property(p => p.PackageId).HasColumnName("package_id");
builder.Property(p => p.InvoiceNo).HasColumnName("invoice_no");
builder.Property(p => p.Description).HasColumnName("description").IsRequired();
builder.Property(p => p.Price).HasColumnName("price").IsRequired();
builder.Property(p => p.DeliveryPrice).HasColumnName("delivery_price").IsRequired();
builder.Property(p => p.Status).HasColumnName("status").IsRequired().HasConversion(deliveryStatusConverter);
builder.OwnsOne(p => p.PhysicalParameters,
parameters =>
{
parameters.Property(p => p.Height).HasColumnName("height").IsRequired();
parameters.Property(p => p.Length).HasColumnName("length").IsRequired();
parameters.Property(p => p.Weight).HasColumnName("weight").IsRequired();
parameters.Property(p => p.Width).HasColumnName("width").IsRequired();
});
builder.OwnsOne(p => p.DeliveryDetails,
parameters =>
{
parameters.Property(p => p.FromCity).HasColumnName("from_city").IsRequired();
parameters.Property(p => p.ToCity).HasColumnName("to_city").IsRequired();
parameters.Property(p => p.Sender).HasColumnName("sender").IsRequired();
parameters.Property(p => p.Receiver).HasColumnName("receiver").IsRequired();
});
builder.Property(p => p.Created).HasColumnName("created");
builder.Property(p => p.CreatedBy).HasColumnName("created_by");
builder.Property(p => p.LastModified).HasColumnName("last_modified");
builder.Property(p => p.LastModifiedBy).HasColumnName("last_modified_by");
builder.HasOne(p => p.Shipment)
.WithMany(p => p.Packages);
}
// public override void Dispose()
// {
// base.Dispose();
// _writer.Dispose();
// }
#endregion
#region Filtro Global
// protected override void OnModelCreating(ModelBuilder modelBuilder)
// {
// //Filtro Global
// //modelBuilder.Entity<Departamento>().HasQueryFilter(p => !p.Excluido);
// }
#endregion
#region Collate e Sequence
// protected override void OnModelCreating(ModelBuilder modelBuilder)
// {
// modelBuilder.UseCollation("SQL_Latin1_General_CP1_CI_AI");
// //CI = Não Use Case Sensitive => Icaro == icaro
// //AI = Não use Sensitive de Acentuação => Ícaro == Icaro
// modelBuilder.Entity<Departamento>().Property(p => p.Descricao).UseCollation("SQL_Latin1_General_CP1_CS_AS");
// //CS = Use Case Sensitive => Icaro != icaro
// //AS = Use Sensitive de Acentuação => Ícaro != Icaro
// modelBuilder.HasSequence<int>("MinhaSequencia", "sequencias") //Tipos aceitos => int, byte e long (padrão)
// .StartsAt(1) //Inicia em
// .IncrementsBy(2) //Incrementa de 2 em 2
// .HasMin(1) // Minimo
// .HasMax(10) //Maximo (chegouno maximo da exception ou vai pro cyclic)
// .IsCyclic(); // Reseta a contagem
// modelBuilder.Entity<Departamento>().Property(p => p.Id).HasDefaultValueSql("NEXT VALUE FOR sequencias.MinhaSequencia");
// }
#endregion
#region Indices
// protected override void OnModelCreating(ModelBuilder modelBuilder)
// {
// modelBuilder.Entity<Departamento>()
// //.HasIndex(p => p.Descricao);
// .HasIndex(p => new { p.Descricao, p.Ativo })
// .HasDatabaseName("idx_meu_indice_composto")
// .HasFilter("Descricao IS NOT NULL")
// .HasFillFactor(80) //20% para uso de preenchimento de dados pelo SQL Server
// .IsUnique();
// }
#endregion
#region Propagação de Dados
// protected override void OnModelCreating(ModelBuilder modelBuilder)
// {
// modelBuilder.Entity<Estado>().HasData(new[]
// {
// new Estado {Id = 1, Nome = "São Paulo" },
// new Estado {Id = 2, Nome = "Minas Gerais" }
// });
// }
#endregion
#region Esquemas e Conversores
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
// modelBuilder.HasDefaultSchema("cadastros");
// modelBuilder.Entity<Estado>().ToTable("Estados", "SegundoEsquema");
var conversao = new ValueConverter <Versao, string>(
p => p.ToString(), p => (Versao)Enum.Parse(typeof(Versao), p)
);
var conversao1 = new EnumToStringConverter <Versao>();
modelBuilder.Entity <Conversor>()
.Property(p => p.Versao)
.HasConversion(conversao1);
//.HasConversion(conversao);
//.HasConversion(p => p.ToString(), p => (Versao)Enum.Parse(typeof(Versao), p));
//.HasConversion<string>();
modelBuilder.Entity <Conversor>()
.Property(p => p.Status)
.HasConversion(new Curso.Conversores.ConversorCustomizado());
}
public static EnumToStringConverter <Values> FluentInitAndSeed(ModelBuilder modelBuilder)
{
var converter = new EnumToStringConverter <Values>();
modelBuilder.Entity <TransactionStatus>(entity => {
entity.HasKey(e => e.V);
entity.Property(e => e.V).HasConversion(converter);
});
var values = Enum.GetValues(typeof(Values)).Cast <Values>();
foreach (var v in values)
{
modelBuilder.Entity <TransactionStatus>(entity =>
{
entity.HasData(new TransactionStatus()
{
V = v
});
});
}
return(converter);
}
public void Configure(EntityTypeBuilder <Taxonomy> builder)
{
var converter = new EnumToStringConverter <TaxonomyTypeEnum>();
builder
.Property(tt => tt.Type)
.HasConversion(converter);
builder
.HasOne(tt => tt.CreatedBy)
.WithMany(u => u.CreatedTaxonomies)
.HasForeignKey(tt => tt.CreatedById);
builder
.HasOne(tt => tt.ModifiedBy)
.WithMany(u => u.ModifiedTaxonomies)
.HasForeignKey(tt => tt.ModifiedById);
builder
.HasMany(tt => tt.ChildTaxonomies)
.WithOne(tt => tt.Parent)
.HasForeignKey(tt => tt.ParentId);
}
public void Configure(EntityTypeBuilder <Document> builder)
{
var converter = new EnumToStringConverter <DocumentType>();
builder.Property(p => p.DocumentType).HasConversion(converter);
builder.Property(p => p.CreatedOn)
.HasDefaultValueSql("CONVERT(date, GETDATE())");
builder.Property(p => p.CreatedOn)
.ValueGeneratedOnAdd();
// [DatabaseGenerator(DatabasseGenerationOptions.Identity)]
builder.Property(p => p.UpdatedOn)
.ValueGeneratedOnUpdate();
// [DatabaseGenerator(DatabasseGenerationOptions.Computed)]
DocumentFaker documentFaker = new DocumentFaker();
var documents = documentFaker.Generate(20);
builder.HasData(documents);
}
public void Configure(EntityTypeBuilder <Attachment> builder)
{
var attachmentTypeConverter = new EnumToStringConverter <AttachmentTypeEnum>();
builder
.Property(a => a.Type)
.HasConversion(attachmentTypeConverter);
var UploadLocationConverter = new EnumToStringConverter <UploadLocationEnum>();
builder
.Property(a => a.UploadLocation)
.HasConversion(UploadLocationConverter);
builder
.HasOne(a => a.CreatedBy)
.WithMany(u => u.CreatedAttachments)
.HasForeignKey(a => a.CreatedById);
builder
.HasOne(a => a.ModifiedBy)
.WithMany(u => u.ModifiedAttachments)
.HasForeignKey(a => a.ModifiedById);
}
protected override void OnModelCreating(ModelBuilder builder)
{
base.OnModelCreating(builder);
#region 验证模型
builder.Entity <TodoItem>(entity =>
{
entity.ToTable("TodoItme_StartOne");
entity.HasKey(e => e.Id);
entity.Property(e => e.Id).ValueGeneratedOnAdd();
entity.Property(e => e.IsComplete).HasColumnType("bit").HasDefaultValue(1);//默认值
#region 枚举类型装换
////方法一
//entity.Property(e => e.state).HasConversion(v => v.ToString(), v => (StateCode)Enum.Parse(typeof(StateCode), v));//枚举类型装换
////方法二
//var converter = new ValueConverter<StateCode, string>(v => v.ToString(), v => (StateCode)Enum.Parse(typeof(StateCode), v));
//entity.Property(e => e.state).HasConversion(converter);
//方法三
var converter1 = new EnumToStringConverter <StateCode>();
entity.Property(e => e.state).HasConversion(converter1);
#endregion
});
#endregion
}
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);
var converter = new EnumToStringConverter <Level>();
builder
.Entity <Work>()
.Property(work => work.Difficulty)
.HasConversion(converter);
builder
.Entity <Work>()
.Property(work => work.Duration)
.HasConversion(converter);
builder
.Entity <Work>()
.Property(work => work.Priority)
.HasConversion(converter);
}
public DebugOutputFilterStrategy()
{
if (Application.Current != null)
{
_timeSpanToStringConverter = Application.Current.Resources["TimeSpanToStringConverter"] as TimeSpanToStringConverter;
_dateTimeToStringConverter = Application.Current.Resources["DateTimeToStringConverter"] as DateTimeToStringConverter;
_enumToStringConverter = Application.Current.Resources["EnumToStringConverter"] as EnumToStringConverter;
}
if (_timeSpanToStringConverter == null)
{
_timeSpanToStringConverter = new TimeSpanToStringConverter();
}
if (_dateTimeToStringConverter == null)
{
_dateTimeToStringConverter = new DateTimeToStringConverter();
}
if (_enumToStringConverter == null)
{
_enumToStringConverter = new EnumToStringConverter();
}
}
public void Configure(EntityTypeBuilder <PlexLibrary> builder)
{
builder
.HasMany(x => x.Movies)
.WithOne(x => x.PlexLibrary)
.HasForeignKey(x => x.PlexLibraryId)
.OnDelete(DeleteBehavior.Cascade);
builder
.HasMany(x => x.TvShows)
.WithOne(x => x.PlexLibrary)
.HasForeignKey(x => x.PlexLibraryId)
.OnDelete(DeleteBehavior.Cascade);
var converter = new EnumToStringConverter <PlexMediaType>();
builder
.Property(e => e.Type)
.HasConversion(converter);
builder
.Property(x => x.MetaData)
.HasJsonValueConversion();
}
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
var ETSConverter = new EnumToStringConverter <Enums.StatusState>();
modelBuilder.Entity <Status>().Property(s => s.State).HasConversion(ETSConverter);
}
public void Configure(EntityTypeBuilder <Operation> builder)
{
builder.ToTable("Operations", "dbo");
builder.HasKey(p => p.Id);
builder.Property(p => p.Id).UseSqlServerIdentityColumn();
builder.Property(p => p.Name).HasColumnType("nvarchar(50)").IsRequired();
var converter = new EnumToStringConverter <OperationGroups>();
builder.Property(p => p.Group).HasConversion(converter).HasColumnType("varchar(16)").IsRequired();
builder.Property(p => p.Complexity).HasColumnType("real");
builder.HasData(new Operation[] {
new Operation {
Id = 1, Name = "Сканирование товара", Group = OperationGroups.Reception, Complexity = (float)1.0
},
new Operation {
Id = 2, Name = "Сканирование транзитов", Group = OperationGroups.Reception, Complexity = (float)1.0
},
new Operation {
Id = 3, Name = "Размещение товара", Group = OperationGroups.Placing, Complexity = (float)1.0
},
new Operation {
Id = 4, Name = "Перемещение товара", Group = OperationGroups.Placing, Complexity = (float)1.0
},
new Operation {
Id = 5, Name = "Подтоварка", Group = OperationGroups.Defragmentation, Complexity = (float)1.0
},
new Operation {
Id = 6, Name = "Верт. дефрагментация", Group = OperationGroups.Defragmentation, Complexity = (float)1.0
},
new Operation {
Id = 7, Name = "Гор. дефрагментация", Group = OperationGroups.Defragmentation, Complexity = (float)1.0
},
new Operation {
Id = 8, Name = "Подбор товара", Group = OperationGroups.Gathering, Complexity = (float)1.0
},
new Operation {
Id = 9, Name = "Подбор клиентского товара", Group = OperationGroups.Gathering, Complexity = (float)1.0
},
new Operation {
Id = 11, Name = "Предварительный подбор товара", Group = OperationGroups.Gathering, Complexity = (float)1.0
},
new Operation {
Id = 10, Name = "Подбор товаров покупателей", Group = OperationGroups.BuyerGathering, Complexity = (float)1.0
},
new Operation {
Id = 12, Name = "Упаковка товара в места", Group = OperationGroups.Placing, Complexity = (float)1.0
},
new Operation {
Id = 13, Name = "Инвентаризация", Group = OperationGroups.Inventory, Complexity = (float?)1.0
},
new Operation {
Id = 14, Name = "Выгрузка машины", Group = OperationGroups.Shipment, Complexity = (float)1.0
},
new Operation {
Id = 15, Name = "Погрузка машины", Group = OperationGroups.Shipment, Complexity = (float)1.0
},
new Operation {
Id = 16, Name = "Прочие операции", Group = OperationGroups.Other, Complexity = (float)1.0
},
});
}
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
base.OnModelCreating(modelBuilder);
const string AdministratorRoleName = "Administrator";
modelBuilder.Entity <IdentityRole <Guid> >().HasData(new IdentityRole <Guid>
{
Id = Guid.NewGuid(),
Name = AdministratorRoleName,
NormalizedName = AdministratorRoleName.ToUpper()
});
const string UserRoleName = "User";
modelBuilder.Entity <IdentityRole <Guid> >().HasData(new IdentityRole <Guid>
{
Id = Guid.NewGuid(),
Name = UserRoleName,
NormalizedName = UserRoleName.ToUpper()
});
var languageCodes = Enum.GetValues(typeof(LanguageCode)).Cast <LanguageCode>();
foreach (var languageCode in languageCodes)
{
modelBuilder.Entity <Language>().HasData(new Language
{
Id = Guid.NewGuid(),
LanguageCode = languageCode
});
}
modelBuilder.Entity <Language>()
.HasMany(l => l.DictionaryLanguages)
.WithOne(dl => dl.Language)
.OnDelete(DeleteBehavior.Restrict);
modelBuilder.Entity <Entities.Attribute>()
.HasMany(a => a.AttributeValues)
.WithOne(av => av.Attribute)
.OnDelete(DeleteBehavior.Cascade);
var userTypeConverter = new EnumToStringConverter <UserType>();
modelBuilder.Entity <UserDictionary>()
.Property(ud => ud.Type)
.HasConversion(userTypeConverter);
var attributeTypeConverter = new EnumToStringConverter <AttributeType>();
modelBuilder.Entity <Entities.Attribute>()
.Property(a => a.Type)
.HasConversion(attributeTypeConverter);
var languageTypeConverter = new EnumToStringConverter <LanguageType>();
modelBuilder.Entity <DictionaryLanguage>()
.Property(dl => dl.Type)
.HasConversion(languageTypeConverter);
var languageCodeConverter = new EnumToStringConverter <LanguageCode>();
modelBuilder.Entity <Language>()
.Property(l => l.LanguageCode)
.HasConversion(languageCodeConverter);
}
public void ConfigureAddressNotes(EntityTypeBuilder <AddressNote> builder)
{
builder.HasKey(ci => ci.NoteDbId);
builder.Property(ci => ci.NoteDbId)
.IsConcurrencyToken(true)
.IsRowVersion()
.ValueGeneratedOnAdd()
.UseSqlServerIdentityColumn();
builder
.HasOne(n => n.address)
.WithMany(a => a.Notes);
//.HasForeignKey(c => c.RouteDestinationId);
//builder
// .HasOne(n => n.route)
// .WithMany(r => r.Notes);
//builder.Property(n => n.RouteId)
// .HasMaxLength(32)
// .IsUnicode(false);
builder.Property(n => n.UploadId)
.HasMaxLength(32)
.IsUnicode(false);
var statusUpdateTypeConverter = new EnumToStringConverter <Enum.StatusUpdateType>();
builder.Property(n => n.StatusUpdateType)
.HasConversion(statusUpdateTypeConverter)
.HasMaxLength(32)
.IsUnicode(false);
var uploadTypeConverter = new EnumToStringConverter <Enum.UploadType>();
builder.Property(n => n.UploadType)
.HasConversion(uploadTypeConverter)
.HasMaxLength(32)
.IsUnicode(false);
builder.Property(n => n.UploadUrl)
.HasMaxLength(250)
.IsUnicode(false);
builder.Property(n => n.UploadExtension)
.HasMaxLength(16)
.IsUnicode(false);
var deviceTypeConverter = new EnumToStringConverter <Enum.DeviceType>();
builder.Property(n => n.DeviceType)
.HasConversion(deviceTypeConverter)
.HasMaxLength(32)
.IsUnicode(false);
//builder.HasData(
// new AddressNote()
// {
// NoteDbId = -1,
// Contents = "Note example",
// DeviceType = Enum.DeviceType.Web,
// UploadType = Enum.UploadType.AnyFile,
// StatusUpdateType = Enum.StatusUpdateType.DropOff,
// IsInactive = true,
// Latitude = 95.85441,
// Longitude = -250.65418,
// UploadExtension = "jpg",
// NoteId = 111111,
// RouteDestinationId = 363044949
// //RouteId = "76DF97A0AB51EAC8B90D75700A3BBFBF"
// }
// );
}
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
modelBuilder.HasAnnotation("ProductVersion", "2.2.6-servicing-10079");
#region enum converters
/*
* Converters do not nicely handle null values, outputting 'NULL' string into the database.
* This isn't a major issue though, as the mapping in application is accurate.
*/
var statusEnumConverter = new EnumToStringConverter <Status>();
var dotStatusEnumConverter = new EnumToStringConverter <DotStatus>();
var healthcareSettingEnumConverter = new EnumToStringConverter <HealthcareSetting>();
var hivStatusEnumConverter = new EnumToStringConverter <HIVTestStatus>();
var riskFactorEnumConverter = new EnumToStringConverter <RiskFactorType>();
var notificationStatusEnumConverter = new EnumToStringConverter <NotificationStatus>();
var denotificationReasonEnumConverter = new EnumToStringConverter <DenotificationReason>();
var testResultEnumConverter = new EnumToStringConverter <Result>();
var alertStatusEnumConverter = new EnumToStringConverter <AlertStatus>();
var alertTypeEnumConverter = new EnumToStringConverter <AlertType>();
var frequencyEnumConverter = new EnumToStringConverter <Frequency>();
var treatmentEventTypeEnumConverter = new EnumToStringConverter <TreatmentEventType>();
var treatmentOutcomeTypeEnumConverter = new EnumToStringConverter <TreatmentOutcomeType>();
var treatmentOutcomeSubTypeEnumConverter = new EnumToStringConverter <TreatmentOutcomeSubType>();
var transferReasonEnumConverter = new EnumToStringConverter <TransferReason>();
var exposureSettingEnumConverter = new EnumToStringConverter <ExposureSetting>();
var milkProductEnumConverter = new EnumToStringConverter <MilkProductType>();
var consumptionFrequencyEnumConverter = new EnumToStringConverter <ConsumptionFrequency>();
var occupationSettingEnumConverter = new EnumToStringConverter <OccupationSetting>();
var animalTypeEnumConverter = new EnumToStringConverter <AnimalType>();
var animalTbStatusEnumConverter = new EnumToStringConverter <AnimalTbStatus>();
var treatmentRegimentEnumConverter = new EnumToStringConverter <TreatmentRegimen>();
var logMessageLevelEnumConverter = new EnumToStringConverter <LogMessageLevel>();
#endregion
modelBuilder.Entity <ReleaseVersion>(entity =>
entity.HasKey(rv => rv.Version)
);
modelBuilder.Entity <Country>(entity =>
{
entity.Property(e => e.Name).HasMaxLength(200);
entity.HasIndex(e => new { e.IsLegacy, e.Name });
entity.ToTable(nameof(Country), ReferenceDataSchemaName);
entity.HasData(Models.SeedData.Countries.GetCountriesArray());
});
modelBuilder.Entity <Continent>(entity =>
{
entity.ToTable(nameof(Continent), ReferenceDataSchemaName);
entity.HasData(Models.SeedData.Continents.GetContinents());
});
modelBuilder.Entity <Ethnicity>(entity =>
{
entity.Property(e => e.Code).HasMaxLength(50);
entity.Property(e => e.Label).HasMaxLength(200);
entity.ToTable(nameof(Ethnicity), ReferenceDataSchemaName);
entity.HasData(
new Ethnicity {
EthnicityId = 1, Code = "WW", Label = "White", Order = 1
},
new Ethnicity {
EthnicityId = 8, Code = "H", Label = "Indian", Order = 2
},
new Ethnicity {
EthnicityId = 9, Code = "J", Label = "Pakistani", Order = 3
},
new Ethnicity {
EthnicityId = 10, Code = "K", Label = "Bangladeshi", Order = 4
},
new Ethnicity {
EthnicityId = 11, Code = "L", Label = "Any other Asian background", Order = 5
},
new Ethnicity {
EthnicityId = 13, Code = "N", Label = "Black African", Order = 6
},
new Ethnicity {
EthnicityId = 12, Code = "M", Label = "Black Caribbean", Order = 7
},
new Ethnicity {
EthnicityId = 14, Code = "P", Label = "Any other Black Background", Order = 8
},
new Ethnicity {
EthnicityId = 16, Code = "R", Label = "Chinese", Order = 9
},
new Ethnicity {
EthnicityId = 6, Code = "F", Label = "Mixed - White and Asian", Order = 10
},
new Ethnicity {
EthnicityId = 5, Code = "E", Label = "Mixed - White and Black African", Order = 11
},
new Ethnicity
{
EthnicityId = 4,
Code = "D",
Label = "Mixed - White and Black Caribbean",
Order = 12
},
new Ethnicity {
EthnicityId = 7, Code = "G", Label = "Any other mixed background", Order = 13
},
new Ethnicity {
EthnicityId = 15, Code = "S", Label = "Any other ethnic group", Order = 14
},
new Ethnicity {
EthnicityId = Ethnicities.NotStatedId, Code = "Z", Label = "Not stated", Order = 15
}
);
});
modelBuilder.Entity <TBService>(entity =>
{
entity.Property(e => e.Code).HasMaxLength(16).ValueGeneratedOnAdd();
entity.HasKey(e => e.Code);
entity.Property(e => e.Name).HasMaxLength(200);
/*
* TB services have TB service AD group associated with them in a 1-1
* mapping. PHEC AD groups are defined on the PHEC model itself, which has a many-to-one mapping to TB Service through TBServiceToPHEC.
* AD groups have a length limit if 64 characters, see
* https://docs.microsoft.com/en-us/previous-versions/windows/it-pro/windows-server-2003/cc756101(v=ws.10)?redirectedfrom=MSDN#fqdn-length-limitations
*/
entity.Property(e => e.ServiceAdGroup).HasMaxLength(64);
entity.HasIndex(e => e.ServiceAdGroup).IsUnique();
entity.HasIndex(e => e.Name);
entity.HasIndex(e => new { e.IsLegacy, e.Name });
entity.HasOne(e => e.PHEC)
.WithMany()
.HasForeignKey(tb => tb.PHECCode);
entity.ToTable(nameof(TbService), ReferenceDataSchemaName);
});
modelBuilder.Entity <Hospital>(entity =>
{
entity.ToTable(nameof(Hospital), ReferenceDataSchemaName);
});
modelBuilder.Entity <PHEC>(entity =>
{
entity.HasKey(e => e.Code);
entity.Property(e => e.Code).ValueGeneratedOnAdd();
entity.ToTable(nameof(PHEC), ReferenceDataSchemaName);
});
modelBuilder.Entity <LocalAuthority>(entity =>
{
entity.HasKey(e => e.Code);
entity.Property(e => e.Code).ValueGeneratedOnAdd();
entity.ToTable(nameof(LocalAuthority), ReferenceDataSchemaName);
});
modelBuilder.Entity <LocalAuthorityToPHEC>(entity =>
{
entity.HasKey(e => new { e.PHECCode, e.LocalAuthorityCode });
entity.HasOne(e => e.LocalAuthority)
.WithOne(x => x.LocalAuthorityToPHEC)
.HasForeignKey <LocalAuthorityToPHEC>(la => la.LocalAuthorityCode)
.OnDelete(DeleteBehavior.Cascade)
.IsRequired(false);
entity.HasOne(e => e.PHEC)
.WithMany()
.HasForeignKey(la => la.PHECCode)
.OnDelete(DeleteBehavior.Cascade)
.IsRequired(false);
entity.ToTable(nameof(LocalAuthorityToPHEC), ReferenceDataSchemaName);
});
modelBuilder.Entity <PostcodeLookup>(entity =>
{
entity.HasKey(e => e.Postcode);
entity.Property(e => e.Postcode).ValueGeneratedOnAdd();
entity.HasOne(e => e.LocalAuthority)
.WithMany(c => c.PostcodeLookups)
.HasForeignKey(ns => ns.LocalAuthorityCode);
entity.ToTable(nameof(PostcodeLookup), ReferenceDataSchemaName);
// We don't use HasData to populate postcode lookup due to the size of this dataset -
// it would completely clog up any EF actions. We've used manually created migrations instead.
});
modelBuilder.Entity <PatientDetails>(entity =>
{
entity.HasKey(pd => pd.NotificationId);
entity.HasOne(pd => pd.PostcodeLookup)
.WithMany()
.HasForeignKey(ns => ns.PostcodeToLookup);
entity.ToTable("Patients");
});
modelBuilder.Entity <HospitalDetails>(entity =>
{
entity.HasKey(pd => pd.NotificationId);
entity.HasOne(hd => hd.CaseManager).WithMany();
entity.ToTable("HospitalDetails");
});
modelBuilder.Entity <Notification>(entity =>
{
entity.HasOne(n => n.Group)
.WithMany(g => g.Notifications)
.HasForeignKey(e => e.GroupId);
entity.HasOne(n => n.PatientDetails)
.WithOne()
.OnDelete(DeleteBehavior.Cascade);
entity.HasOne(n => n.HospitalDetails)
.WithOne()
.OnDelete(DeleteBehavior.Cascade);
entity.OwnsOne(e => e.ClinicalDetails,
e =>
{
e.Property(cd => cd.BCGVaccinationState)
.HasConversion(statusEnumConverter)
.HasMaxLength(EnumMaxLength);
e.Property(c => c.DotStatus)
.HasConversion(dotStatusEnumConverter)
.HasMaxLength(EnumMaxLength);
e.Property(c => c.HomeVisitCarriedOut)
.HasConversion(statusEnumConverter)
.HasMaxLength(EnumMaxLength);
e.Property(c => c.HealthcareSetting)
.HasConversion(healthcareSettingEnumConverter)
.HasMaxLength(EnumMaxLength);
e.Property(c => c.EnhancedCaseManagementStatus)
.HasConversion(statusEnumConverter)
.HasMaxLength(EnumMaxLength);
e.Property(c => c.HIVTestState)
.HasConversion(hivStatusEnumConverter)
.HasMaxLength(EnumMaxLength);
e.Property(c => c.IsDotOffered)
.HasConversion(statusEnumConverter)
.HasMaxLength(EnumMaxLength);
e.Property(c => c.Notes)
.HasMaxLength(1000);
e.Property(c => c.TreatmentRegimen)
.HasConversion(treatmentRegimentEnumConverter)
.HasMaxLength(EnumMaxLength);
e.Property(c => c.TreatmentRegimenOtherDescription)
.HasMaxLength(100);
e.Property(c => c.EnhancedCaseManagementLevel)
.HasDefaultValue(0);
e.ToTable("ClinicalDetails");
});
entity.OwnsOne(e => e.PreviousTbHistory,
e =>
{
e.Property(ph => ph.PreviouslyTreated)
.HasConversion(statusEnumConverter)
.HasMaxLength(EnumMaxLength);
e.Property(ph => ph.PreviouslyHadTb)
.HasConversion(statusEnumConverter)
.HasMaxLength(EnumMaxLength);
e.ToTable("PreviousTbHistory");
});
entity.OwnsOne(e => e.ContactTracing).ToTable("ContactTracing");
entity.OwnsOne(e => e.SocialRiskFactors,
x =>
{
x.OwnsOne(c => c.RiskFactorDrugs,
rf =>
{
rf.Property(e => e.Status)
.HasConversion(statusEnumConverter)
.HasMaxLength(EnumMaxLength);
rf.Property(e => e.Type)
.HasConversion(riskFactorEnumConverter)
.HasMaxLength(EnumMaxLength)
.HasDefaultValue(RiskFactorType.Drugs);
rf.ToTable("RiskFactorDrugs");
});
x.OwnsOne(c => c.RiskFactorHomelessness,
rh =>
{
rh.Property(e => e.Status)
.HasConversion(statusEnumConverter)
.HasMaxLength(EnumMaxLength);
rh.Property(e => e.Type)
.HasConversion(riskFactorEnumConverter)
.HasMaxLength(EnumMaxLength)
.HasDefaultValue(RiskFactorType.Homelessness);
rh.ToTable("RiskFactorHomelessness");
});
x.OwnsOne(c => c.RiskFactorImprisonment,
rh =>
{
rh.Property(e => e.Status)
.HasConversion(statusEnumConverter)
.HasMaxLength(EnumMaxLength);
rh.Property(e => e.Type)
.HasConversion(riskFactorEnumConverter)
.HasMaxLength(EnumMaxLength)
.HasDefaultValue(RiskFactorType.Imprisonment);
rh.ToTable("RiskFactorImprisonment");
});
x.OwnsOne(c => c.RiskFactorSmoking,
rf =>
{
rf.Property(e => e.Status)
.HasConversion(statusEnumConverter)
.HasMaxLength(EnumMaxLength);
rf.Property(e => e.Type)
.HasConversion(riskFactorEnumConverter)
.HasMaxLength(EnumMaxLength)
.HasDefaultValue(RiskFactorType.Smoking);
rf.ToTable("RiskFactorSmoking");
});
x.Property(e => e.AlcoholMisuseStatus)
.HasConversion(statusEnumConverter)
.HasMaxLength(EnumMaxLength);
x.Property(e => e.MentalHealthStatus)
.HasConversion(statusEnumConverter)
.HasMaxLength(EnumMaxLength);
x.Property(e => e.AsylumSeekerStatus)
.HasConversion(statusEnumConverter)
.HasMaxLength(EnumMaxLength);
x.Property(e => e.ImmigrationDetaineeStatus)
.HasConversion(statusEnumConverter)
.HasMaxLength(EnumMaxLength);
x.ToTable("SocialRiskFactors");
});
entity.Property(e => e.NotificationStatus)
.HasConversion(notificationStatusEnumConverter)
.HasMaxLength(EnumMaxLength);
entity.OwnsOne(e => e.ImmunosuppressionDetails,
i =>
{
i.Property(e => e.Status)
.HasConversion(statusEnumConverter)
.HasMaxLength(EnumMaxLength);
i.ToTable("ImmunosuppressionDetails");
});
entity.OwnsOne(e => e.TravelDetails,
x =>
{
x.Property(td => td.HasTravel)
.HasConversion(statusEnumConverter)
.HasMaxLength(EnumMaxLength);
x.ToTable("TravelDetails");
});
entity.OwnsOne(e => e.VisitorDetails,
x =>
{
x.Property(vd => vd.HasVisitor)
.HasConversion(statusEnumConverter)
.HasMaxLength(EnumMaxLength);
x.ToTable("VisitorDetails");
});
entity.OwnsOne(e => e.ComorbidityDetails,
cd =>
{
cd.Property(e => e.DiabetesStatus)
.HasConversion(statusEnumConverter)
.HasMaxLength(EnumMaxLength);
cd.Property(e => e.HepatitisBStatus)
.HasConversion(statusEnumConverter)
.HasMaxLength(EnumMaxLength);
cd.Property(e => e.HepatitisCStatus)
.HasConversion(statusEnumConverter)
.HasMaxLength(EnumMaxLength);
cd.Property(e => e.LiverDiseaseStatus)
.HasConversion(statusEnumConverter)
.HasMaxLength(EnumMaxLength);
cd.Property(e => e.RenalDiseaseStatus)
.HasConversion(statusEnumConverter)
.HasMaxLength(EnumMaxLength);
cd.ToTable("ComorbidityDetails");
});
entity.OwnsOne(e => e.DenotificationDetails,
i =>
{
i.Property(e => e.Reason)
.HasConversion(denotificationReasonEnumConverter)
.HasMaxLength(EnumMaxLength);
i.ToTable("DenotificationDetails");
});
entity.OwnsOne(e => e.MDRDetails,
i =>
{
i.Property(e => e.ExposureToKnownCaseStatus)
.HasConversion(statusEnumConverter)
.HasMaxLength(EnumMaxLength);
i.Property(e => e.NotifiedToPheStatus)
.HasConversion(statusEnumConverter)
.HasMaxLength(EnumMaxLength);
i.ToTable("MDRDetails");
});
entity.OwnsMany(e => e.PreviousTbServices)
.ToTable("PreviousTbService")
.HasKey(e => e.PreviousTbServiceId);
entity.HasIndex(e => e.NotificationStatus);
entity.HasIndex(e => new { e.NotificationStatus, e.SubmissionDate });
entity.HasIndex(e => e.LTBRID).IsUnique();
entity.HasIndex(e => e.ETSID).IsUnique();
entity.HasIndex(e => e.LTBRPatientId);
entity.HasIndex(e => e.ClusterId);
entity.ToTable("Notification");
});
modelBuilder.Entity <Sex>(entity =>
{
entity.Property(e => e.Label).HasMaxLength(200);
entity.ToTable(nameof(Sex), ReferenceDataSchemaName);
entity.HasData(
new Sex {
SexId = 1, Label = "Male"
},
new Sex {
SexId = 2, Label = "Female"
},
new Sex {
SexId = Sexes.UnknownId, Label = Sexes.UnknownLabel
}
);
});
modelBuilder.Entity <NotificationSite>(entity =>
{
entity.HasKey(e => new { e.NotificationId, e.SiteId });
entity.HasOne(e => e.Site)
.WithMany(s => s.NotificationSites)
.HasForeignKey(ns => ns.SiteId);
});
modelBuilder.Entity <Site>(entity =>
{
entity.ToTable(nameof(Site), ReferenceDataSchemaName);
entity.HasData(
new Site {
SiteId = (int)SiteId.PULMONARY, Description = "Pulmonary", OrderIndex = 1
},
new Site {
SiteId = (int)SiteId.BONE_SPINE, Description = "Spine", OrderIndex = 4
},
new Site {
SiteId = (int)SiteId.BONE_OTHER, Description = "Bone/joint: Other", OrderIndex = 5
},
new Site {
SiteId = (int)SiteId.CNS_MENINGITIS, Description = "Meningitis", OrderIndex = 6
},
new Site {
SiteId = (int)SiteId.CNS_OTHER, Description = "CNS: Other", OrderIndex = 7
},
new Site {
SiteId = (int)SiteId.OCULAR, Description = "Ocular", OrderIndex = 13
},
new Site {
SiteId = (int)SiteId.CRYPTIC, Description = "Cryptic disseminated", OrderIndex = 10
},
new Site {
SiteId = (int)SiteId.GASTROINTESTINAL, Description = "Gastrointestinal/peritoneal", OrderIndex = 11
},
new Site {
SiteId = (int)SiteId.GENITOURINARY, Description = "Genitourinary", OrderIndex = 12
},
new Site {
SiteId = (int)SiteId.LYMPH_INTRA, Description = "Lymph nodes: Intra-thoracic", OrderIndex = 8
},
new Site {
SiteId = (int)SiteId.LYMPH_EXTRA, Description = "Lymph nodes: Extra-thoracic", OrderIndex = 9
},
new Site {
SiteId = (int)SiteId.LARYNGEAL, Description = "Laryngeal", OrderIndex = 2
},
new Site {
SiteId = (int)SiteId.MILIARY, Description = "Miliary", OrderIndex = 3
},
new Site {
SiteId = (int)SiteId.PLEURAL, Description = "Pleural", OrderIndex = 14
},
new Site {
SiteId = (int)SiteId.PERICARDIAL, Description = "Pericardial", OrderIndex = 15
},
new Site {
SiteId = (int)SiteId.SKIN, Description = "Soft tissue/Skin", OrderIndex = 16
},
new Site {
SiteId = (int)SiteId.OTHER, Description = "Other extra-pulmonary", OrderIndex = 17
}
);
});
modelBuilder.Entity <Occupation>(entity =>
{
entity.Property(e => e.Role).HasMaxLength(40);
entity.Property(e => e.Sector).HasMaxLength(40);
entity.ToTable(nameof(Occupation), ReferenceDataSchemaName);
entity.HasData(Models.SeedData.Occupations.GetOccupations());
});
modelBuilder.Entity <User>(entity =>
{
entity.Property(e => e.Id).ValueGeneratedOnAdd();
entity.Property(e => e.Username).HasMaxLength(64);
entity.Property(e => e.FamilyName).HasMaxLength(64);
entity.Property(e => e.GivenName).HasMaxLength(64);
entity.Property(e => e.DisplayName).HasMaxLength(256);
entity.Property(e => e.JobTitle).HasMaxLength(100);
entity.Property(e => e.PhoneNumberPrimary).HasMaxLength(100);
entity.Property(e => e.PhoneNumberSecondary).HasMaxLength(100);
entity.Property(e => e.EmailPrimary).HasMaxLength(100);
entity.Property(e => e.EmailSecondary).HasMaxLength(100);
entity.Property(e => e.Notes).HasMaxLength(500);
entity.HasIndex(e => e.Username).IsUnique();
entity.HasKey(e => e.Id);
});
modelBuilder.Entity <CaseManagerTbService>(entity =>
{
entity.Property(e => e.TbServiceCode).HasMaxLength(16);
entity.HasKey(e => new { e.CaseManagerId, e.TbServiceCode });
entity.HasOne(e => e.CaseManager)
.WithMany(caseManager => caseManager.CaseManagerTbServices)
.HasForeignKey(e => e.CaseManagerId)
.OnDelete(DeleteBehavior.Cascade)
.IsRequired(false);
entity.HasOne(e => e.TbService)
.WithMany(tbService => tbService.CaseManagerTbServices)
.HasForeignKey(e => e.TbServiceCode)
.OnDelete(DeleteBehavior.Cascade)
.IsRequired(false);
});
modelBuilder.Entity <ManualTestType>(entity =>
{
entity.Property(e => e.Description).HasMaxLength(40);
entity.ToTable(nameof(ManualTestType), ReferenceDataSchemaName);
entity.HasData(Models.SeedData.ManualTestTypes.GetManualTestTypes());
});
modelBuilder.Entity <SampleType>(entity =>
{
entity.Property(e => e.Description).HasMaxLength(40);
entity.Property(e => e.Category).HasMaxLength(40);
entity.ToTable(nameof(SampleType), ReferenceDataSchemaName);
entity.HasData(Models.SeedData.SampleTypes.GetSampleTypes());
});
modelBuilder.Entity <ManualTestTypeSampleType>(entity =>
{
entity.HasKey(e => new { e.ManualTestTypeId, e.SampleTypeId });
entity.HasOne(e => e.ManualTestType)
.WithMany(manualTestType => manualTestType.ManualTestTypeSampleTypes)
.HasForeignKey(e => e.ManualTestTypeId)
.OnDelete(DeleteBehavior.Cascade)
.IsRequired(false);
entity.HasOne(e => e.SampleType)
.WithMany(sampleType => sampleType.ManualTestTypeSampleTypes)
.HasForeignKey(e => e.SampleTypeId)
.OnDelete(DeleteBehavior.Cascade)
.IsRequired(false);
entity.ToTable(nameof(ManualTestTypeSampleType), ReferenceDataSchemaName);
entity.HasData(Models.SeedData.ManualTestTypeSampleTypes.GetJoinDataManualTestTypeToSampleType());
});
modelBuilder.Entity <TestData>(entity =>
{
entity.HasKey(e => e.NotificationId);
entity.HasMany(e => e.ManualTestResults);
});
modelBuilder.Entity <ManualTestResult>(entity =>
{
entity.Property(e => e.Result)
.HasConversion(testResultEnumConverter)
.HasMaxLength(EnumMaxLength);
entity.HasOne(e => e.ManualTestType)
.WithMany()
.HasForeignKey(e => e.ManualTestTypeId)
.OnDelete(DeleteBehavior.Cascade)
.IsRequired(false);
entity.HasOne(e => e.SampleType)
.WithMany()
.HasForeignKey(e => e.SampleTypeId);
entity.HasOne <TestData>()
.WithMany(e => e.ManualTestResults)
.HasForeignKey(e => e.NotificationId)
.OnDelete(DeleteBehavior.Cascade)
.IsRequired(false);
});
modelBuilder.Entity <DrugResistanceProfile>(entity =>
{
entity.Property(e => e.Species)
.IsRequired()
.HasMaxLength(30)
.HasDefaultValue("No result");
entity.Property(e => e.DrugResistanceProfileString)
.IsRequired()
.HasMaxLength(30)
.HasDefaultValue("No result");
entity.ToTable("DrugResistanceProfile").HasKey(e => e.NotificationId);
});
modelBuilder.Entity <MBovisDetails>(entity =>
{
entity.Property(e => e.ExposureToKnownCasesStatus)
.HasConversion(statusEnumConverter)
.HasMaxLength(EnumMaxLength);
entity.Property(e => e.UnpasteurisedMilkConsumptionStatus)
.HasConversion(statusEnumConverter)
.HasMaxLength(EnumMaxLength);
entity.Property(e => e.OccupationExposureStatus)
.HasConversion(statusEnumConverter)
.HasMaxLength(EnumMaxLength);
entity.Property(e => e.AnimalExposureStatus)
.HasConversion(statusEnumConverter)
.HasMaxLength(EnumMaxLength);
entity.ToTable("MBovisDetails").HasKey(e => e.NotificationId);
});
modelBuilder.Entity <MBovisExposureToKnownCase>(entity =>
{
entity.Property(e => e.ExposureSetting)
.HasConversion(exposureSettingEnumConverter)
.HasMaxLength(EnumMaxLength);
entity.Property(e => e.NotifiedToPheStatus)
.HasConversion(statusEnumConverter)
.HasMaxLength(EnumMaxLength);
entity.ToTable("MBovisExposureToKnownCase");
entity.HasOne <MBovisDetails>()
.WithMany(e => e.MBovisExposureToKnownCases)
.HasForeignKey(e => e.NotificationId)
.OnDelete(DeleteBehavior.Cascade)
.IsRequired(false);
});
modelBuilder.Entity <MBovisUnpasteurisedMilkConsumption>(entity =>
{
entity.Property(e => e.ConsumptionFrequency)
.HasConversion(consumptionFrequencyEnumConverter)
.HasMaxLength(EnumMaxLength);
entity.Property(e => e.MilkProductType)
.HasConversion(milkProductEnumConverter)
.HasMaxLength(EnumMaxLength);
entity.ToTable("MBovisUnpasteurisedMilkConsumption");
entity.HasOne <MBovisDetails>()
.WithMany(e => e.MBovisUnpasteurisedMilkConsumptions)
.HasForeignKey(e => e.NotificationId)
.OnDelete(DeleteBehavior.Cascade)
.IsRequired(false);
});
modelBuilder.Entity <MBovisOccupationExposure>(entity =>
{
entity.Property(e => e.OccupationSetting)
.HasConversion(occupationSettingEnumConverter)
.HasMaxLength(EnumMaxLength);
entity.ToTable("MBovisOccupationExposures");
entity.HasOne <MBovisDetails>()
.WithMany(e => e.MBovisOccupationExposures)
.HasForeignKey(e => e.NotificationId)
.OnDelete(DeleteBehavior.Cascade)
.IsRequired(false);
});
modelBuilder.Entity <MBovisAnimalExposure>(entity =>
{
entity.Property(e => e.AnimalType)
.HasConversion(animalTypeEnumConverter)
.HasMaxLength(EnumMaxLength);
entity.Property(e => e.AnimalTbStatus)
.HasConversion(animalTbStatusEnumConverter)
.HasMaxLength(EnumMaxLength);
entity.ToTable("MBovisAnimalExposure");
entity.HasOne <MBovisDetails>()
.WithMany(e => e.MBovisAnimalExposures)
.HasForeignKey(e => e.NotificationId)
.OnDelete(DeleteBehavior.Cascade)
.IsRequired(false);
});
modelBuilder.Entity <Alert>(entity =>
{
entity.Property(e => e.AlertStatus)
.HasConversion(alertStatusEnumConverter)
.HasMaxLength(EnumMaxLength);
entity.Property(e => e.ClosingUserId).HasMaxLength(64);
entity.HasIndex(p => new { p.NotificationId, p.AlertType });
entity.Property(e => e.AlertType)
.HasConversion(alertTypeEnumConverter);
entity.HasDiscriminator <AlertType>("AlertType")
.HasValue <TestAlert>(AlertType.Test)
.HasValue <MdrAlert>(AlertType.EnhancedSurveillanceMDR)
.HasValue <MBovisAlert>(AlertType.EnhancedSurveillanceMBovis)
.HasValue <TransferAlert>(AlertType.TransferRequest)
.HasValue <TransferRejectedAlert>(AlertType.TransferRejected)
.HasValue <UnmatchedLabResultAlert>(AlertType.UnmatchedLabResult)
.HasValue <DataQualityDraftAlert>(AlertType.DataQualityDraft)
.HasValue <DataQualityBirthCountryAlert>(AlertType.DataQualityBirthCountry)
.HasValue <DataQualityClinicalDatesAlert>(AlertType.DataQualityClinicalDates)
.HasValue <DataQualityClusterAlert>(AlertType.DataQualityCluster)
.HasValue <DataQualityTreatmentOutcome12>(AlertType.DataQualityTreatmentOutcome12)
.HasValue <DataQualityTreatmentOutcome24>(AlertType.DataQualityTreatmentOutcome24)
.HasValue <DataQualityTreatmentOutcome36>(AlertType.DataQualityTreatmentOutcome36)
.HasValue <DataQualityDotVotAlert>(AlertType.DataQualityDotVotAlert)
.HasValue <DataQualityChildECMLevel>(AlertType.DataQualityChildECMLevel)
.HasValue <DataQualityPotentialDuplicateAlert>(AlertType.DataQualityPotientialDuplicate);
entity.HasIndex(e => new { e.AlertStatus, e.AlertType });
});
modelBuilder.Entity <TestAlert>().HasBaseType <Alert>();
modelBuilder.Entity <TransferAlert>(entity =>
{
entity.Property(e => e.TransferReason)
.HasConversion(transferReasonEnumConverter)
.HasMaxLength(EnumMaxLength);
entity.Property(e => e.TbServiceCode).HasColumnName("TbServiceCode").HasMaxLength(16);
entity.HasOne(e => e.CaseManager)
.WithMany()
.HasForeignKey(e => e.CaseManagerId);
});
modelBuilder.Entity <UnmatchedLabResultAlert>(entity =>
{
entity.Property(e => e.SpecimenId).HasMaxLength(50);
});
modelBuilder.Entity <VenueType>(entity =>
{
entity.ToTable(nameof(VenueType), ReferenceDataSchemaName);
entity.HasData(Models.SeedData.Venues.GetTypes());
});
modelBuilder.Entity <SocialContextVenue>(entity =>
{
entity.Property(e => e.Frequency)
.HasConversion(frequencyEnumConverter)
.HasMaxLength(EnumMaxLength);
});
modelBuilder.Entity <TreatmentEvent>(entity =>
{
entity.Property(e => e.TreatmentEventType)
.HasConversion(treatmentEventTypeEnumConverter)
.HasMaxLength(EnumMaxLength);
entity.Property(e => e.Note)
.HasMaxLength(1000);
entity.HasOne(e => e.CaseManager)
.WithMany()
.HasForeignKey(e => e.CaseManagerId)
.IsRequired(false);
entity.HasOne(e => e.TbService)
.WithMany()
.HasForeignKey(e => e.TbServiceCode);
});
modelBuilder.Entity <TreatmentOutcome>(entity =>
{
entity.Property(e => e.TreatmentOutcomeType)
.HasConversion(treatmentOutcomeTypeEnumConverter)
.HasMaxLength(EnumMaxLength);
entity.Property(e => e.TreatmentOutcomeSubType)
.HasConversion(treatmentOutcomeSubTypeEnumConverter)
.HasMaxLength(EnumMaxLength);
entity.ToTable(nameof(TreatmentOutcome), ReferenceDataSchemaName);
entity.HasData(Models.SeedData.TreatmentOutcomes.GetTreatmentOutcomes());
});
modelBuilder.Entity <UserLoginEvent>(entity =>
{
entity.Property(e => e.Username)
.IsRequired()
.HasMaxLength(64);
entity.Property(e => e.LoginDate)
.IsRequired();
entity.Property(e => e.SystemName)
.IsRequired()
.HasMaxLength(64);
});
modelBuilder.Entity <LegacyImportNotificationOutcome>(entity =>
{
entity.Property(e => e.OldNotificationId)
.HasMaxLength(50)
.IsRequired();
entity.HasOne <LegacyImportMigrationRun>()
.WithMany(e => e.LegacyImportNotificationOutcomes)
.HasForeignKey(e => e.LegacyImportMigrationRunId)
.OnDelete(DeleteBehavior.Cascade)
.IsRequired();
entity.HasIndex(e => e.LegacyImportMigrationRunId);
});
modelBuilder.Entity <LegacyImportNotificationLogMessage>(entity =>
{
entity.Property(e => e.OldNotificationId)
.HasMaxLength(50)
.IsRequired();
entity.Property(e => e.LogMessageLevel)
.HasConversion(logMessageLevelEnumConverter)
.HasMaxLength(EnumMaxLength);
entity.HasOne <LegacyImportMigrationRun>()
.WithMany(e => e.LegacyImportNotificationLogMessages)
.HasForeignKey(e => e.LegacyImportMigrationRunId)
.OnDelete(DeleteBehavior.Cascade)
.IsRequired();
entity.HasIndex(e => e.LegacyImportMigrationRunId);
});
}
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
var godId = Guid.Parse("67af6f37-55b6-4a84-a87e-d059416e0af6");
var godRoles = new[]
{
new Role {
Id = RoleNameExtension.ConsumerRoleId, Name = RoleName.Consumer
},
new Role {
Id = RoleNameExtension.LocksmithRoleId, Name = RoleName.Locksmith
},
new Role {
Id = RoleNameExtension.AdminRoleId, Name = RoleName.Admin
}
};
var roleNameConverter = new EnumToStringConverter <RoleName>();
var userStatusConverter = new EnumToStringConverter <UserStatus>();
var messageTypeConverter = new EnumToStringConverter <MessageType>();
var territoryTypeConverter = new EnumToStringConverter <TerritoryType>();
var gasEquipmentTypeConverter = new EnumToStringConverter <GasEquipmentType>();
#region Control
modelBuilder.Entity <Control>()
.HasMany(control => control.Users)
.WithOne(user => user.Control)
.HasForeignKey(user => user.ControlId);
modelBuilder.Entity <Control>()
.HasData(new Control
{
Id = godId,
Number = 1
});
#endregion
#region User
modelBuilder.Entity <User>()
.HasOne(profile => profile.Profile)
.WithOne()
.HasForeignKey <User>(user => user.Id)
.OnDelete(DeleteBehavior.Restrict);
modelBuilder.Entity <User>()
.HasMany(user => user.MaintenanceCards)
.WithOne(maintenanceCard => maintenanceCard.User)
.HasForeignKey(maintenanceCard => maintenanceCard.UserId);
modelBuilder.Entity <User>()
.Property(user => user.Status)
.HasConversion(userStatusConverter);
modelBuilder.Entity <User>()
.HasData(new User
{
Id = godId,
ControlId = godId,
ProfileId = godId,
Email = "*****@*****.**",
Password = "******",
Status = UserStatus.Confirmed
});
#endregion
#region Role
modelBuilder.Entity <Role>()
.Property(role => role.Name)
.HasConversion(roleNameConverter);
modelBuilder.Entity <Role>().HasData(godRoles);
#endregion
#region UserRole
modelBuilder.Entity <UserRole>()
.HasKey(userRole => new { userRole.UserId, userRole.RoleId });
modelBuilder.Entity <UserRole>()
.HasOne(userRole => userRole.User)
.WithMany(user => user.Roles)
.HasForeignKey(userRole => userRole.UserId);
modelBuilder.Entity <UserRole>()
.HasOne(userRole => userRole.Role)
.WithMany(role => role.Users)
.HasForeignKey(userRole => userRole.RoleId);
modelBuilder.Entity <UserRole>()
.HasData(godRoles.Select(role => new UserRole {
UserId = godId, RoleId = role.Id
}).ToArray());
#endregion
#region EmailMessage
modelBuilder.Entity <EmailMessage>()
.Property(emailMessage => emailMessage.Type)
.HasConversion(messageTypeConverter);
#endregion
#region Consumer
modelBuilder.Entity <Consumer>()
.HasOne(profile => profile.Profile)
.WithOne()
.HasForeignKey <Consumer>(consumer => consumer.Id)
.OnDelete(DeleteBehavior.Restrict);
modelBuilder.Entity <Consumer>()
.HasOne(consumer => consumer.Address)
.WithMany(profile => profile.Consumers);
modelBuilder.Entity <Consumer>()
.HasMany(consumer => consumer.MaintenanceCards)
.WithOne(maintenanceCard => maintenanceCard.Consumer)
.HasForeignKey(maintenanceCard => maintenanceCard.ConsumerId);
#endregion
#region Profile
modelBuilder.Entity <Profile>()
.HasData(new Profile
{
Id = godId,
FirstName = "Саня",
LastName = "Желонкин",
Patronymic = "Викторович",
PhoneNumber = "+7 927 298 32 49"
});
#endregion
#region Address
modelBuilder.Entity <Address>()
.HasOne(address => address.Structure)
.WithMany(structure => structure.Addresses);
#endregion
#region Structure
modelBuilder.Entity <Structure>()
.HasOne(structure => structure.Street)
.WithMany(structure => structure.Structures);
#endregion
#region Street
modelBuilder.Entity <Street>()
.HasOne(street => street.Locality)
.WithMany(structure => structure.Streets);
#endregion
#region Locality
modelBuilder.Entity <Locality>()
.HasOne(locality => locality.Territory)
.WithMany(structure => structure.Localities);
#endregion
#region Territory
modelBuilder.Entity <Territory>()
.HasOne(territory => territory.Parent)
.WithMany(territory => territory.Children)
.HasForeignKey(territory => territory.ParentId);
modelBuilder.Entity <Territory>()
.Property(territory => territory.Type)
.HasConversion(territoryTypeConverter);
#endregion
#region GasEquipment
modelBuilder.Entity <GasEquipment>()
.HasOne(gasEquipment => gasEquipment.Manufacturer)
.WithMany(manufacturer => manufacturer.GasEquipments)
.HasForeignKey(gasEquipment => gasEquipment.ManufacturerId);
modelBuilder.Entity <GasEquipment>()
.Property(gasEquipment => gasEquipment.Type)
.HasConversion(gasEquipmentTypeConverter);
#endregion
#region ConsumerGasEquipment
modelBuilder.Entity <ConsumerGasEquipment>()
.HasKey(consumerGasEquipment => new { consumerGasEquipment.ConsumerId, consumerGasEquipment.GasEquipmentId });
modelBuilder.Entity <ConsumerGasEquipment>()
.HasOne(consumerGasEquipment => consumerGasEquipment.Consumer)
.WithMany(consumer => consumer.GasEquipments)
.HasForeignKey(consumerGasEquipment => consumerGasEquipment.ConsumerId);
modelBuilder.Entity <ConsumerGasEquipment>()
.HasOne(consumerGasEquipment => consumerGasEquipment.GasEquipment)
.WithMany()
.HasForeignKey(consumerGasEquipment => consumerGasEquipment.GasEquipmentId);
#endregion
#region MaintenanceCard
modelBuilder.Entity <MaintenanceCard>()
.HasMany(maintenanceCard => maintenanceCard.Maintenances)
.WithOne(maintenance => maintenance.MaintenanceCard)
.HasForeignKey(maintenance => maintenance.MaintenanceCardId);
#endregion
base.OnModelCreating(modelBuilder);
}
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
base.OnModelCreating(modelBuilder);
modelBuilder.Entity <Person>()
.Property(p => p.Name)
.IsRequired();
modelBuilder.Entity <Meeting>()
.Property(m => m.Date)
.IsRequired();
modelBuilder.Entity <Note>()
.Property(n => n.Notes)
.IsRequired();
modelBuilder.Entity <Note>()
.Property(n => n.Time)
.HasDefaultValue(DateTime.Now);
modelBuilder.Entity <Person>()
.Property(p => p.RowVersion)
.ValueGeneratedOnAddOrUpdate()
.IsConcurrencyToken();
#region Seeding
modelBuilder.Entity <Person>().HasData(
new Person
{
ID = 1, Name = "Bálint", MartialState = MartialState.Single, SiblingState = SiblingState.Middle
},
new Person
{
ID = 2, Name = "Zsófia", MartialState = MartialState.Single, SiblingState = SiblingState.Eldest
}
);
modelBuilder.Entity <Meeting>().HasData(
new Meeting
{
ID = 1, Date = new DateTime(2019, 5, 10), Notes = "Zenekar"
},
new Meeting
{
ID = 2, Date = new DateTime(2019, 5, 9), Notes = "Házi átvétel", Place = "BME L épület"
}
);
modelBuilder.Entity <Note>().HasData(
new Note {
ID = 1, PersonID = 1, Notes = "barbarbarbar"
}
);
modelBuilder.Entity <PersonMeeting>().HasData(
new PersonMeeting {
ID = 1, PersonID = 1, MeetingID = 1
},
new PersonMeeting {
ID = 2, PersonID = 2, MeetingID = 1
}
);
#endregion
var martialConverter = new EnumToStringConverter <MartialState>();
modelBuilder
.Entity <Person>()
.Property(e => e.MartialState)
.HasConversion(martialConverter);
var siblingConverter = new EnumToStringConverter <SiblingState>();
modelBuilder
.Entity <Person>()
.Property(e => e.SiblingState)
.HasConversion(siblingConverter);
}
