protected override void Seed(AppContext context)
{
// UserSeed.VandGrow(context);
EstateStatusSeed.VandGrow(context);
CourseHoldingTypeSeed.VandGrow(context);
BankSeed.VandGrow(context);
MaritalStatusSeed.VandGrow(context);
ReligionSeed.VandGrow(context);
EducationDegreeSeed.VandGrow(context);
MilitaryStatusSeed.VandGrow(context);
ShiftSeed.VandGrow(context);
RoleSeed.VandGrow(context);
MenuSeed.VandGrow(context);
SexSeed.VandGrow(context);
//ProvinceSeed.VandGrow(context);
CategorySeed.VandGrow(context);
SiteSeed.VandGrow(context);
TeacherSeed.VandGrow(context);
EducationalCenterUserSeed.VandGrow(context);
StudentSeed.VandGrow(context);
MenuSeed.VandGrow(context);
RecruitmentTypeSeed.VandGrow(context);
//OrganizationSeed.VandGrow(context);
//DepartmentTypeSeed.VandGrow(context);
//SiteSeed.VandGrow(context);
//LanguageCenterUserRoleSeed.VandGrow(context);
ClassroomTypeSeed.VandGrow(context);
//MinistryOfEducationUserSeed.VandGrow(context);
base.Seed(context);
}
public async Task GetAllCategoriesAsync_Should_Return_All_Categories()
{
//Arrange
//Act
List <Category> categories = await categoryRepositoryMock.Object.GetAllCategoriesAsync();
//Assert
Assert.NotNull(categories);
Assert.NotEmpty(categories);
Assert.Equal(CategorySeed.Seed().Count, categories.Count);
}
public DataSeedService(
ILogger logger,
AppSettings appSettings,
CategorySeed categorySeed,
DemoUserSeed demoUserSeed,
ImportBankSeed importBankSeed)
{
_logger = logger;
_appSettings = appSettings;
_categorySeed = categorySeed;
_demoUserSeed = demoUserSeed;
_importBankSeed = importBankSeed;
}
public DataSeedService(
ILogger logger,
Func <IUnitOfWork> unitOfWork,
AppSettings appSettings,
CategorySeed categorySeed,
DemoUserSeed demoUserSeed)
{
_logger = logger;
_unitOfWork = unitOfWork;
_appSettings = appSettings;
_categorySeed = categorySeed;
_demoUserSeed = demoUserSeed;
}
public static void Initialize(RentingContext context)
{
context.Database.EnsureCreated();
if (context.Users.Any())
{
return; // DB has been seeded
}
CategorySeed.Seed(context).GetAwaiter().GetResult();
UserSeed.Seed(context).GetAwaiter().GetResult();
ItemsSeed.Seed(context).GetAwaiter().GetResult();
RentsSeed.Seed(context).GetAwaiter().GetResult();
RentedItemsSeed.Seed(context).GetAwaiter().GetResult();
}
public BaseUnitTest()
{
roosterPlannerContextMock = CreateContextMock();
roosterPlannerContextMock.Object.Projects.AddRange(ProjectSeed.Seed());
roosterPlannerContextMock.Object.Persons.AddRange(PersonSeed.Seed());
roosterPlannerContextMock.Object.Managers.AddRange(ManagerSeed.Seed());
roosterPlannerContextMock.Object.Requirements.AddRange(RequirementSeed.Seed());
roosterPlannerContextMock.Object.CertificateTypes.AddRange(CertificateTypeSeed.Seed());
roosterPlannerContextMock.Object.Documents.AddRange(DocumentSeed.Seed());
roosterPlannerContextMock.Object.Participations.AddRange(ParticipationSeed.Seed());
roosterPlannerContextMock.Object.Tasks.AddRange(TaskSeed.Seed());
roosterPlannerContextMock.Object.Categories.AddRange(CategorySeed.Seed());
roosterPlannerContextMock.Object.SaveChanges();
}
public static async Task Main(string[] args)
{
var host = CreateHostBuilder(args).Build();
var scope = host.Services.CreateScope();
using (scope)
{
var services = scope.ServiceProvider;
var loggerFactory = services.GetRequiredService <ILoggerFactory>();
try
{
var context = services.GetRequiredService <StoreContext>();
var userManager = services.GetRequiredService <UserManager <User> >();
await context.Database.MigrateAsync();
await UserSeed.SeedUserAsync(userManager, context);
await CategorySeed.SeedCategoryAsync(context);
await SubCategorySeed.SeedSubCategory(context);
await ProductSeed.SeedProductAsync(context, userManager);
await ProductImagesSeed.SeedProductImages(context);
await ProductLinkSubCategory.SeedProductLinkSubCategoriesAsync(context);
await VIPAdsSeed.SeedVIPAds(context);
}
catch (Exception e)
{
var logger = loggerFactory.CreateLogger <Program>();
logger.LogError(e, "error happen in migration");
}
}
host.Run();
}
public static bool Seed(FittifyContext fittifyContext)
{
if (!CategorySeed.Seed(fittifyContext))
{
return(false);
}
if (!WorkoutSeed.Seed(fittifyContext))
{
return(false);
}
if (!WorkoutHistorySeed.Seed(fittifyContext))
{
return(false);
}
if (!ExerciseSeed.Seed(fittifyContext))
{
return(false);
}
if (!ExerciseHistorySeed.Seed(fittifyContext))
{
return(false);
}
if (!WeightLiftingSetSeed.Seed(fittifyContext))
{
return(false);
}
if (!CardioSetSeed.Seed(fittifyContext))
{
return(false);
}
if (!MapExerciseWorkoutSeeder.Seed(fittifyContext))
{
return(false);
}
return(true);
}
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
//Call base method first.
base.OnModelCreating(modelBuilder);
modelBuilder.Entity <ProjectTask>(p =>
{
p.HasOne(pt => pt.Project)
.WithMany(pt => pt.ProjectTasks)
.HasForeignKey(pt => pt.ProjectId);
p.HasOne(pt => pt.Task)
.WithMany(t => t.ProjectTasks)
.HasForeignKey(pt => pt.TaskId)
.OnDelete(DeleteBehavior.Cascade);
});
modelBuilder.Entity <Project>(pro =>
{
pro.HasMany(pt => pt.ProjectTasks)
.WithOne(p => p.Project);
pro.HasMany(p => p.Participations)
.WithOne(x => x.Project);
});
modelBuilder.Entity <Task>(tsk =>
{
tsk
.HasMany(t => t.ProjectTasks)
.WithOne(t => t.Task);
tsk.HasMany(s => s.Shifts)
.WithOne(t => t.Task)
.OnDelete(DeleteBehavior.SetNull);
tsk
.HasMany(t => t.Requirements)
.WithOne(t => t.Task);
});
modelBuilder.Entity <Document>(doc =>
{
doc.HasMany(d => d.Instructions)
.WithOne(i => i.Instruction)
.OnDelete(DeleteBehavior.SetNull);
doc.HasMany(d => d.ProfilePictures)
.WithOne(i => i.ProfilePicture)
.OnDelete(DeleteBehavior.SetNull);
});
modelBuilder.Entity <Category>(cat =>
{
cat.HasMany(c => c.Tasks)
.WithOne(t => t.Category)
.OnDelete(DeleteBehavior.SetNull);
});
modelBuilder.Entity <Person>(p =>
{
p.HasIndex(per => per.Oid)
.IsUnique();
p.HasMany(cer => cer.Certificates)
.WithOne(x => x.Person);
p.HasMany(par => par.Participations)
.WithOne(x => x.Person);
});
modelBuilder.Entity <Availability>(ava =>
{
ava.HasOne(p => p.Participation)
.WithMany(a => a.Availabilities)
.HasForeignKey(a => a.ParticipationId)
.OnDelete(DeleteBehavior.Restrict);
ava.HasOne(s => s.Shift)
.WithMany(a => a.Availabilities)
.HasForeignKey(a => a.ShiftId)
.OnDelete(DeleteBehavior.Cascade);
});
modelBuilder.Entity <Participation>(par =>
{
par.HasMany(m => m.Availabilities)
.WithOne(p => p.Participation);
par.HasOne(p => p.Person)
.WithMany(ppar => ppar.Participations)
.HasForeignKey(ppar => ppar.PersonId);
par.HasOne(p => p.Project)
.WithMany(ppar => ppar.Participations)
.HasForeignKey(ppar => ppar.ProjectId);
});
modelBuilder.Entity <Shift>(shf =>
{
shf.HasMany(m => m.Availabilities)
.WithOne(t => t.Shift);
});
modelBuilder.Entity <Certificate>(cer =>
{
cer.HasOne(p => p.Person)
.WithMany(c => c.Certificates)
.HasForeignKey(c => c.PersonId);
cer.HasOne(ct => ct.CertificateType)
.WithMany(c => c.Certificates)
.HasForeignKey(c => c.CertificateTypeId)
.OnDelete(DeleteBehavior.SetNull);
});
modelBuilder.Entity <CertificateType>(ct =>
{
ct.HasMany(c => c.Certificates)
.WithOne(x => x.CertificateType);
ct.HasMany(c => c.Requirements)
.WithOne(req => req.CertificateType);
});
modelBuilder.Entity <Requirement>(req =>
{
req.HasOne(t => t.Task)
.WithMany(reqt => reqt.Requirements)
.HasForeignKey(reqt => reqt.TaskId)
.OnDelete(DeleteBehavior.Cascade);
req.HasOne(cer => cer.CertificateType)
.WithMany(reqt => reqt.Requirements)
.HasForeignKey(reqt => reqt.CertificateTypeId)
.OnDelete(DeleteBehavior.Cascade);
});
var categorySeed = new CategorySeed(modelBuilder);
categorySeed.Seed();
var personSeed = new PersonSeed(modelBuilder);
personSeed.Seed();
var projectseed = new ProjectSeed(modelBuilder);
projectseed.Seed();
var participationSeed = new ParticipationSeed(modelBuilder);
participationSeed.Seed();
var taskseed = new TaskSeed(modelBuilder);
taskseed.Seed();
var documentSeed = new DocumentSeed(modelBuilder);
documentSeed.Seed();
var certificateTypeSeed = new CertificateTypeSeed(modelBuilder);
certificateTypeSeed.Seed();
}
protected override void OnModelCreating(ModelBuilder builder)
{
base.OnModelCreating(builder);
builder.Entity <PokemonType>(x =>
{
x.HasKey(y => y.Id);
x.Property(y => y.Id).ValueGeneratedOnAdd();
});
builder.Entity <PokemonMatchup>(x =>
{
x.HasOne(y => y.AttackingType)
.WithMany(y => y.Attacking)
.HasForeignKey(y => y.AttackingTypeId)
.OnDelete(DeleteBehavior.Restrict)
.HasConstraintName("FK_PokemonType_PokemonMatchup_Attacking");
x.HasOne(y => y.DefendingType)
.WithMany(y => y.Defending)
.HasForeignKey(y => y.DefendingTypeId)
.OnDelete(DeleteBehavior.Restrict)
.HasConstraintName("FK_PokemonType_PokemonMatchup_Defending");
x.HasKey(y => y.Id);
x.Property(y => y.Id).ValueGeneratedOnAdd();
});
builder.Entity <PokemonMoveType>(x =>
{
x.HasKey(y => y.Id);
x.Property(y => y.Id).ValueGeneratedOnAdd();
});
builder.Entity <PokemonAbility>(x =>
{
x.HasKey(y => y.Id);
x.Property(y => y.Id).ValueGeneratedOnAdd();
});
builder.Entity <PokemonItem>(x =>
{
x.HasKey(y => y.Id);
x.Property(y => y.Id).ValueGeneratedOnAdd();
});
builder.Entity <PokemonNature>(x =>
{
x.HasKey(y => y.Id);
x.Property(y => y.Id).ValueGeneratedOnAdd();
});
builder.Entity <PokemonStat>(x =>
{
x.HasKey(y => y.Id);
x.Property(y => y.Id).ValueGeneratedOnAdd();
});
builder.Entity <Pokemon>(x =>
{
x.HasKey(y => y.Id);
x.Property(y => y.Id).ValueGeneratedOnAdd();
x.HasOne(y => y.Type1)
.WithMany(y => y.PokemonType1)
.HasForeignKey(y => y.Type1Id)
.OnDelete(DeleteBehavior.Restrict)
.HasConstraintName("FK_Type1_Pokemon");
x.HasOne(y => y.Type2)
.WithMany(y => y.PokemonType2)
.HasForeignKey(y => y.Type2Id)
.OnDelete(DeleteBehavior.Restrict)
.HasConstraintName("FK_Type2_Pokemon");
});
builder.Entity <PokemonMoveset>(x =>
{
x.HasKey(y => y.Id);
x.Property(y => y.Id).ValueGeneratedOnAdd();
x.HasOne(y => y.Move)
.WithMany(y => y.Moveset)
.HasForeignKey(y => y.MoveId)
.OnDelete(DeleteBehavior.Restrict)
.HasConstraintName("FK_Move_Moveset");
x.HasOne(y => y.MoveType)
.WithMany(y => y.Moveset)
.HasForeignKey(y => y.MoveTypeId)
.OnDelete(DeleteBehavior.Restrict)
.HasConstraintName("FK_MoveType_Moveset");
x.HasOne(y => y.Pokemon)
.WithMany(y => y.Moveset)
.HasForeignKey(y => y.PokemonId)
.OnDelete(DeleteBehavior.Restrict)
.HasConstraintName("FK_Pokemon_Moveset");
});
builder.Entity <PokemonAbilityset>(x =>
{
x.HasKey(y => y.Id);
x.Property(y => y.Id).ValueGeneratedOnAdd();
x.HasOne(y => y.Ability)
.WithMany(y => y.Abilityset)
.HasForeignKey(y => y.AbilityId)
.OnDelete(DeleteBehavior.Restrict)
.HasConstraintName("FK_Ability_Abilityset");
x.HasOne(y => y.Pokemon)
.WithMany(y => y.Abilities)
.HasForeignKey(y => y.PokemonId)
.OnDelete(DeleteBehavior.Restrict)
.HasConstraintName("FK_Pokemon_Abilityset");
});
builder.Entity <TeamMember>(x =>
{
x.HasKey(y => y.Id);
x.Property(y => y.Id).ValueGeneratedOnAdd();
x.HasOne(y => y.Pokemon)
.WithMany(y => y.TeamMembers)
.HasForeignKey(y => y.PokemonId)
.OnDelete(DeleteBehavior.Restrict)
.HasConstraintName("FK_TeamMember_Pokemon");
x.HasOne(y => y.Ability)
.WithMany(y => y.TeamMembers)
.HasForeignKey(y => y.AbilityId)
.OnDelete(DeleteBehavior.Restrict)
.HasConstraintName("FK_TeamMember_PokemonAbility");
x.HasOne(y => y.Nature)
.WithMany(y => y.TeamMembers)
.HasForeignKey(y => y.NatureId)
.OnDelete(DeleteBehavior.Restrict)
.HasConstraintName("FK_TeamMember_Nature");
x.HasOne(y => y.Item)
.WithMany(y => y.TeamMembers)
.HasForeignKey(y => y.ItemId)
.OnDelete(DeleteBehavior.Restrict)
.HasConstraintName("FK_TeamMember_Item");
x.HasOne(y => y.Move1)
.WithMany(y => y.TeamMembers1)
.HasForeignKey(y => y.Move1Id)
.OnDelete(DeleteBehavior.Restrict)
.HasConstraintName("FK_TeamMember_Move1");
x.HasOne(y => y.Move2)
.WithMany(y => y.TeamMembers2)
.HasForeignKey(y => y.Move2Id)
.OnDelete(DeleteBehavior.Restrict)
.HasConstraintName("FK_TeamMember_Move2");
x.HasOne(y => y.Move3)
.WithMany(y => y.TeamMembers3)
.HasForeignKey(y => y.Move3Id)
.OnDelete(DeleteBehavior.Restrict)
.HasConstraintName("FK_TeamMember_Move3");
x.HasOne(y => y.Move4)
.WithMany(y => y.TeamMembers4)
.HasForeignKey(y => y.Move4Id)
.OnDelete(DeleteBehavior.Restrict)
.HasConstraintName("FK_TeamMember_Move4");
x.HasOne(y => y.User)
.WithMany(y => y.TeamMembers)
.HasForeignKey(y => y.UserId)
.OnDelete(DeleteBehavior.Restrict)
.HasConstraintName("FK_TeamMember_User");
});
builder.Entity <Team>(x =>
{
x.HasKey(a => a.Id);
x.Property(a => a.Id).ValueGeneratedOnAdd();
x.HasOne(y => y.User)
.WithMany(y => y.Teams)
.HasForeignKey(y => y.UserId)
.OnDelete(DeleteBehavior.Restrict)
.HasConstraintName("FK_Team_User");
});
builder.Entity <TeamLike>(x =>
{
x.HasKey(a => a.Id);
x.Property(a => a.Id).ValueGeneratedOnAdd();
x.HasOne(a => a.Team)
.WithMany(a => a.Likes)
.HasForeignKey(a => a.TeamId)
.OnDelete(DeleteBehavior.Restrict)
.HasConstraintName("FK_TeamLikes_Team");
x.HasOne(a => a.User)
.WithMany(a => a.TeamLikes)
.HasForeignKey(a => a.UserId)
.OnDelete(DeleteBehavior.Restrict)
.HasConstraintName("FK_User_TeamMember");
});
builder.Entity <TeamMembers>(x =>
{
x.HasKey(a => a.Id);
x.Property(a => a.Id).ValueGeneratedOnAdd();
x.HasOne(a => a.Team)
.WithMany(a => a.Members)
.HasForeignKey(a => a.TeamId)
.OnDelete(DeleteBehavior.Restrict)
.HasConstraintName("FK_TeamMembers_Team");
x.HasOne(a => a.TeamMember)
.WithMany(a => a.Members)
.HasForeignKey(a => a.TeamMemberId)
.OnDelete(DeleteBehavior.Restrict)
.HasConstraintName("FK_TeamMembers_TeamMember");
});
builder.Entity <NewsItem>(x =>
{
x.HasKey(a => a.Id);
x.Property(a => a.Id).ValueGeneratedOnAdd();
});
var categories = CategorySeed.Seed(builder);
var types = TypeSeed.Seed(builder);
var moveTypes = MoveTypeSeed.Seed(builder);
MatchupSeed.Seed(builder, types);
var abilities = AbilitySeed.Seed(builder);
ItemSeed.Seed(builder);
NatureSeed.Seed(builder);
StatSeed.Seed(builder);
var moves = MoveSeed.Seed(builder, types, categories);
PokemonSeed.Seed(builder, types, moveTypes, moves, abilities);
}
