public static async Task Run(IServiceProvider serviceProvider)
{
using (var serviceScope = serviceProvider.GetService <IServiceScopeFactory>().CreateScope())
{
serviceScope.ServiceProvider.GetRequiredService <PersistedGrantDbContext>().Database.Migrate();
serviceScope.ServiceProvider.GetRequiredService <ConfigurationDbContext>().Database.Migrate();
var context = serviceScope.ServiceProvider.GetRequiredService <ConfigurationDbContext>();
foreach (var resource in IdentityServerSeeder.GetIdentityResources())
{
await context.IdentityResources.AddAsync(resource.ToEntity());
}
foreach (var resource in IdentityServerSeeder.GetApiResources())
{
await context.ApiResources.AddAsync(resource.ToEntity());
}
foreach (var client in IdentityServerSeeder.GetClients())
{
await context.Clients.AddAsync(client.ToEntity());
}
await context.SaveChangesAsync();
// migrate the data for our identity server
var identityServerContext = serviceScope.ServiceProvider.GetRequiredService <IdentityServerDbContext>();
identityServerContext.Database.Migrate();
await UserSeeder.Seed(identityServerContext);
}
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IHostingEnvironment env,
UserManager <AppUser> userManager, RoleManager <IdentityRole> roleManager,
HotelsDbContext context)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
app.UseDatabaseErrorPage();
}
else
{
app.UseExceptionHandler("/Home/Error");
// The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
app.UseHsts();
}
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseCookiePolicy();
app.UseAuthentication();
UserSeeder.Seed(userManager, roleManager).Wait();
DataSeeder.Seed(context, userManager).Wait();
app.UseMvc(routes =>
{
routes.MapRoute(
name: "default",
template: "{controller=Home}/{action=Index}/{id?}");
});
}
public CreatePmCommandTestFixture()
{
MaterialCategorySeeder.Seed(Context);
Materials = MaterialSeeder.Seed(Context);
UserSeeder.Seed(Context);
SeedMaterials();
}
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
base.OnModelCreating(modelBuilder);
modelBuilder.Entity <UserTask>()
.ToTable("UserTasks")
.HasOne(ut => ut.User)
.WithMany(u => u.UserTasks)
.HasForeignKey(ut => ut.UserId);
modelBuilder.Entity <UserTask>()
.HasOne(ut => ut.Task)
.WithMany(t => t.TaskUsers)
.HasForeignKey(ut => ut.TaskId);
modelBuilder.Entity <Message>()
.ToTable("Messages")
.HasKey(m => m.Id);
modelBuilder.Entity <Message>()
.HasOne(m => m.Sender)
.WithMany(u => u.SendMessages)
.OnDelete(DeleteBehavior.NoAction)
.HasForeignKey(m => m.SenderId);
modelBuilder.Entity <Message>()
.HasOne(m => m.Receiver)
.WithMany(u => u.ReceivedMessages)
.OnDelete(DeleteBehavior.NoAction)
.HasForeignKey(m => m.ReceiverId);
modelBuilder.Entity <Message>()
.HasOne(m => m.Task)
.WithMany(t => t.Messages)
.HasForeignKey(m => m.TaskId);
modelBuilder.Entity <Picture>()
.ToTable("Pictures")
.Ignore(p => p.Image);
modelBuilder.Entity <Picture>()
.HasOne(p => p.Task)
.WithMany(t => t.Pictures)
.HasForeignKey(p => p.TaskId);
modelBuilder.Entity <AppTask>()
.ToTable("Tasks")
.HasOne(t => t.Project)
.WithMany(p => p.Tasks)
.HasForeignKey(t => t.ProjectId);
UserSeeder.Seed(modelBuilder);
IdentityRoleSeeder.Seed(modelBuilder);
IdentityUserRoleSeeder.Seed(modelBuilder);
ProjectSeeder.Seed(modelBuilder);
TaskSeeder.Seed(modelBuilder);
UserTaskSeeder.Seed(modelBuilder);
MessageSeeder.Seed(modelBuilder);
PictureSeeder.Seed(modelBuilder);
}
private static async Task InitializeIdentityDb()
{
using (var serviceScope = _serviceProvider.GetService <IServiceScopeFactory>().CreateScope())
{
var context = serviceScope.ServiceProvider.GetRequiredService <IdentityServerDbContext>();
context.Database.Migrate();
await UserSeeder.Seed(context);
}
}
public static void SeedDatabase(this IServiceProvider serviceProvider, string password = "******", string emailDomain = "ssrd.io",
string adminUserName = "******", string adminPassword = "******")
{
SystemEntitySeeder systemEntitySeeder = serviceProvider.GetRequiredService <SystemEntitySeeder>();
AdminSeeder adminSeeder = serviceProvider.GetRequiredService <AdminSeeder>();
UserSeeder userSeeder = serviceProvider.GetRequiredService <UserSeeder>();
Task.WaitAll(systemEntitySeeder.SeedIdentityUI());
Task.WaitAll(adminSeeder.SeedIdentityAdmin(adminUserName, adminPassword));
Task.WaitAll(userSeeder.Seed(emailDomain, password));
}
public static void Initialize(LectureContext context)
{
context.Database.EnsureCreated();
UserSeeder.Seed(context);
UniSeeder.Seed(context);
LectureSeeder.Seed(context);
LectureCommentSeeder.Seed(context);
context.SaveChanges();
}
public void Run()
{
dependencies.logger.LogDebug("Seeding data to database...");
clientSeeder.Seed().Wait();
userSeeder.Seed().Wait();
workflowStepItemSeeder.Seed().Wait();
// workflowStepSeeder.Seed().Wait();
// workflowSeeder.Seed().Wait();
projectSeeder.Seed().Wait();
dependencies.logger.LogDebug("Seeding complete");
}
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
//Seeders
UserSeeder.Seed(modelBuilder);
PaymentSeeder.Seed(modelBuilder);
OrderStatusSeeder.Seed(modelBuilder);
//Configurations
DecimalConfiguration.Configure(modelBuilder);
UserRoleConfiguration.Configure(modelBuilder);
ProductIngredientConfiguration.Configure(modelBuilder);
base.OnModelCreating(modelBuilder);
}
/**
* Seed tables with data and give relationships
*/
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
base.OnModelCreating(modelBuilder);
ChecklistSeeder cs = new ChecklistSeeder();
CheckSeeder qs = new CheckSeeder();
UserSeeder us = new UserSeeder();
Check.InitRelationships(modelBuilder);
User.InitRelationships(modelBuilder);
Checklist.InitRelationships(modelBuilder);
cs.Seed(modelBuilder);
qs.Seed(modelBuilder);
us.Seed(modelBuilder);
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory, UserSeeder seeder)
{
loggerFactory.AddConsole();
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
Mapper.Initialize(cfg =>
{
cfg.CreateMap <Customer, CustomerDto>();
cfg.CreateMap <Order, OrderDto>();
cfg.CreateMap <OrderItem, OrderItemDto>();
cfg.CreateMap <Product, ProductDto>();
cfg.CreateMap <OrderItemPostDto, OrderItem>();
});
app.UseIdentity();
app.UseJwtBearerAuthentication(new JwtBearerOptions()
{
AutomaticAuthenticate = true,
AutomaticChallenge = true,
TokenValidationParameters = new TokenValidationParameters()
{
ValidIssuer = _config["Tokens:Issuer"],
ValidAudience = _config["Tokens:Audience"],
ValidateIssuerSigningKey = true,
IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_config["Tokens:Key"])),
ValidateLifetime = true
}
});
app.UseMvc();
seeder.Seed().Wait();
}
protected override void Seed(ApplicationDbContext context)
{
ParameterSeeder.Seed(context);
RoleSeeder.Seed(context);
UserSeeder.Seed(context);
}
public PmQueryTestFixture()
{
UserSeeder.Seed(Context);
SeedUser();
SeedPms();
}
protected override void OnModelCreating(ModelBuilder builder)
{
base.OnModelCreating(builder);
#region ApplicationUser
builder.Entity <ApplicationUser>(b => {
b.HasMany(x => x.UserRoles).WithOne().HasForeignKey(ur => ur.UserId).IsRequired();
b.HasMany(t => t.TreatmentHistories).WithOne(th => th.User).HasForeignKey(th => th.UserId).IsRequired();
b.HasMany(t => t.Schedule).WithOne(s => s.User).HasForeignKey(s => s.UserId).IsRequired();
b.HasMany(t => t.Comments).WithOne(c => c.User).HasForeignKey(th => th.UserId);
});
builder.Entity <ApplicationRole>(b =>
{
b.HasMany(ur => ur.UserRoles).WithOne().HasForeignKey(ur => ur.RoleId).IsRequired();
});
builder.Entity <ApplicationUserRole>(b =>
{
b.HasOne(ur => ur.Role).WithMany(r => r.UserRoles).HasForeignKey(ur => ur.RoleId);
b.HasOne(ur => ur.User).WithMany(r => r.UserRoles).HasForeignKey(ur => ur.UserId);
});
#endregion
#region Affiliate
builder.Entity <Affiliate>(b => {
b.HasMany(u => u.Users).WithOne(a => a.Affiliate);
b.HasOne(a => a.Address).WithOne(a => a.Affiliate).HasForeignKey <Address>(a => a.AffiliateId);
b.HasMany(t => t.TreatmentHistories).WithOne(a => a.Affiliate);
});
#endregion
#region Patient
builder.Entity <Patient>(b =>
{
b.HasOne(p => p.MedicalChart).WithOne(mc => mc.Patient).HasForeignKey <MedicalChart>(mc => mc.PatientId);
b.HasMany(p => p.Schedule).WithOne(c => c.Patient).HasForeignKey(th => th.PatientId);
});
#endregion
#region MedicalChart
builder.Entity <MedicalChart>(b =>
{
b.HasMany(t => t.Teeth).WithOne(mc => mc.MedicalChart);
b.HasMany(t => t.Allergies).WithOne(mc => mc.MedicalChart);
b.HasMany(t => t.Files).WithOne(mc => mc.MedicalChart);
b.HasMany(t => t.TreatmentHistories).WithOne(mc => mc.MedicalChart);
});
#endregion
#region ToothDisease
builder.Entity <ToothDisease>().HasKey(td => new { td.DiseaseId, td.ToothId });
builder.Entity <ToothDisease>().HasOne(td => td.Disease).WithMany(d => d.ToothDiseases).HasForeignKey(td => td.DiseaseId);
builder.Entity <ToothDisease>().HasOne(td => td.Tooth).WithMany(d => d.ToothDiseases).HasForeignKey(td => td.ToothId);
#endregion
#region Treatment
builder.Entity <Treatment>(b => {
b.HasMany(t => t.TreatmentHistories).WithOne(th => th.Treatment);
});
#endregion
#region Tooth
builder.Entity <Tooth>(b => {
b.HasMany(t => t.Comments).WithOne(c => c.Tooth);
b.HasMany(t => t.TreatmentHistories).WithOne(c => c.Tooth);
});
#endregion
#region Seeds
RoleSeeder.Seed(builder);
AffiliateSeeder.Seed(builder);
UserSeeder.Seed(builder);
UserRoleSeed.Seed(builder);
#endregion
}
public static void Initialize(AppDbContext context, IServiceProvider services)
{
context.Database.EnsureCreated();
var userSeeder = new UserSeeder(context);
userSeeder.Seed();
// usuarios
//if (!context.Usuarios.Any())
//{
//context.Usuarios.Add(new UserEntity()
//{
// NIF = "11223344A",
// Nombre = "Josep",
// Apellidos = "Temprà Cor",
// Direccion = "Carrer Trobadiners, 40",
// Movil = "615051815",
// Email = "*****@*****.**",
// PathFoto = "c:\\fotos\\jt.jpg",
// Rol = TipoUsuario.Administrador,
// UserName = "******",
// Password = "******",
// Lecturas = new List<LecturaEntity>(),
// Incidencias = new List<IncidenciaEntity>(),
// OrdenesTrabajoCreadas = new List<OTEntity>(),
// OrdenesTrabajoGestionadas = new List<OTEntity>()
//});
//context.Usuarios.Add(new UserEntity()
//{
// NIF = "55667788B",
// Nombre = "Ahmed",
// Apellidos = "Al Azred",
// Direccion = "Carrer Allah, 3-2-1",
// Movil = "600112233",
// Email = "*****@*****.**",
// PathFoto = "c:\\fotos\\aaa.jpg",
// Rol = TipoUsuario.Lector,
// UserName = "******",
// Password = "******",
// Lecturas = new List<LecturaEntity>(),
// Incidencias = new List<IncidenciaEntity>(),
// OrdenesTrabajoCreadas = new List<OTEntity>(),
// OrdenesTrabajoGestionadas = new List<OTEntity>()
//});
//context.Usuarios.Add(new UserEntity()
//{
// NIF = "99009900X",
// Nombre = "Joan",
// Apellidos = "Manges",
// Direccion = "Carrer de la frontera, 124",
// Movil = "600234532",
// Email = "*****@*****.**",
// PathFoto = "c:\\fotos\\jm.jpg",
// Rol = TipoUsuario.Operario,
// UserName = "******",
// Password = "******",
// Lecturas = new List<LecturaEntity>(),
// Incidencias = new List<IncidenciaEntity>(),
// OrdenesTrabajoCreadas = new List<OTEntity>(),
// OrdenesTrabajoGestionadas = new List<OTEntity>()
//});
//}
//context.SaveChanges();
}
public async Task <IActionResult> GenerateUsersForGraph()
{
await userSeeder.Seed(new DateTime(2020, 5, 1), new DateTime(2020, 5, 2));
return(Ok());
}
public CreateMaterialCommandTestFixture() : base()
{
MaterialCategorySeeder.Seed(Context);
UserSeeder.Seed(Context);
}
