public async Task SeedAsync(SteuDbContext dbContext, IServiceProvider serviceProvider)
{
if (dbContext == null)
{
throw new ArgumentNullException(nameof(dbContext));
}
if (serviceProvider == null)
{
throw new ArgumentNullException(nameof(serviceProvider));
}
var logger = serviceProvider.GetService <ILoggerFactory>().CreateLogger(typeof(ApplicationDbContextSeeder));
var seeders = new List <ISeeder>
{
new RolesSeeder(),
new SettingsSeeder(),
new CountrySeed(),
new TruckTypeSeeder(),
new PrioritySeeder(),
};
foreach (var seeder in seeders)
{
await seeder.SeedAsync(dbContext, serviceProvider);
await dbContext.SaveChangesAsync();
logger.LogInformation($"Seeder {seeder.GetType().Name} done.");
}
}
private NewsService IntializeNewsService(SteuDbContext context)
{
var repository = new EfDeletableEntityRepository <News>(context);
MapperInitializer.InitializeMapper();
var cloudinaryService = new Mock <ICloudinaryService>();
cloudinaryService
.Setup(x => x.UploadPictureAsync(It.IsAny <IFormFile>(), "fileName"))
.Returns(Task.FromResult("url"));
var mapper = new Mock <IMapper>();
mapper.Setup(
x => x.Map <NewsDetailsViewModel>(It.IsAny <News>()))
.Returns(new NewsDetailsViewModel()
{
Content = "content"
});
mapper.Setup(
x => x.Map <IndexViewModel>(It.IsAny <News>()))
.Returns(new IndexViewModel()
{
Content = "content2"
});
var service = new NewsService(repository, cloudinaryService.Object, mapper.Object);
return(service);
}
private TruckTypesService IntializeTruckTypesService(SteuDbContext context)
{
var repository = new EfRepository <TruckType>(context);
MapperInitializer.InitializeMapper();
var service = new TruckTypesService(repository);
return(service);
}
private ReplayService IntializeReplayService(SteuDbContext context)
{
var repository = new EfDeletableEntityRepository <Replay>(context);
MapperInitializer.InitializeMapper();
var service = new ReplayService(repository);
return(service);
}
public async Task SeedAsync(SteuDbContext dbContext, IServiceProvider serviceProvider)
{
if (dbContext.Settings.Any())
{
return;
}
await dbContext.Settings.AddAsync(new Setting { Name = "Setting1", Value = "value1" });
}
public async Task SeedAsync(SteuDbContext dbContext, IServiceProvider serviceProvider)
{
var roleManager = serviceProvider.GetRequiredService <RoleManager <SteuRole> >();
await SeedRoleAsync(roleManager, GlobalConstants.AdministratorRoleName);
await SeedRoleAsync(roleManager, GlobalConstants.ModeratorRoleName);
await SeedRoleAsync(roleManager, GlobalConstants.OwnerRoleName);
await SeedRoleAsync(roleManager, GlobalConstants.UserRoleName);
}
private DeleteMessagesService IntializeDeleteMessagesService(SteuDbContext context)
{
var repository = new EfDeletableEntityRepository <Message>(context);
MapperInitializer.InitializeMapper();
var replayService = new Mock <IReplaysService>();
var service = new DeleteMessagesService(repository, replayService.Object);
return(service);
}
private static LoadsService IntializeLoadService(SteuDbContext context)
{
MapperInitializer.InitializeMapper();
var repository = new EfDeletableEntityRepository <Order>(context);
var userService = new Mock <IUsersService>();
userService.Setup(x => x.GetUserByIdAsync("asdasd"))
.ReturnsAsync(new SteuUser()
{
UserName = "******",
FirstName = "Pesho",
Id = "asdasd",
Company = new Company()
{
Id = "companyId",
},
});
var countriesService = new Mock <ICountriesService>();
var townService = new Mock <ITownsService>();
var truckTypesService = new Mock <ITruckTypesService>();
truckTypesService.Setup(x => x.GetTruckTypeByNameAsync("Normal"))
.Returns(Task.FromResult(new TruckType()
{
Name = "Normal"
}));
var priorityTypesService = new Mock <IPriorityTypesService>();
priorityTypesService.Setup(x => x.GetPriorityTypeByNameAsync("Normal"))
.Returns(Task.FromResult(new PriorityType()
{
Name = "Normal"
}));
var mapper = new Mock <IMapper>();
mapper.Setup(
x => x.Map <DetailsLoadViewModel>(It.IsAny <Order>()))
.Returns(new DetailsLoadViewModel()
{
SteuUserFirstName = "Pesho"
});
var addressesService = new Mock <IAddressesService>();
var service = new LoadsService(
repository,
addressesService.Object,
mapper.Object,
priorityTypesService.Object,
truckTypesService.Object,
userService.Object);
return(service);
}
public async Task SeedAsync(SteuDbContext dbContext, IServiceProvider serviceProvider)
{
if (await dbContext.PriorityTypes.AnyAsync())
{
return;
}
await dbContext.PriorityTypes.AddAsync(new PriorityType { Name = "Normal" });
await dbContext.PriorityTypes.AddAsync(new PriorityType {
Name = "High",
IconUrl = "https://res.cloudinary.com/steu/image/upload/v1564000497/Icons/Priority/high_qorivg.gif"
});
}
public async Task GetCountShouldReturnCorrectNumberUsingDbContext()
{
var options = new DbContextOptionsBuilder <SteuDbContext>()
.UseInMemoryDatabase(databaseName: "Find_User_Database") // Give a Unique name to the DB
.Options;
var dbContext = new SteuDbContext(options);
dbContext.Settings.Add(new Setting());
dbContext.Settings.Add(new Setting());
dbContext.Settings.Add(new Setting());
await dbContext.SaveChangesAsync();
var repository = new EfDeletableEntityRepository <Setting>(dbContext);
var service = new SettingsService(repository);
var count = service.GetCount();
Assert.Equal(3, count);
}
private OrdersService IntializeOrdersService(SteuDbContext context)
{
var repository = new EfDeletableEntityRepository <Order>(context);
MapperInitializer.InitializeMapper();
var companyServiceMock = new Mock <ICompaniesService>();
companyServiceMock.Setup(x => x.GetCompanyManagerByCompanyIdAsync("companyId"))
.Returns(Task.FromResult("menagerId"));
var mapperOrder = new Mock <IMapper>();
mapperOrder.Setup(x => x.Map <SendMessageInputModel>(It.IsAny <Order>()))
.Returns(new SendMessageInputModel()
{
CountryFrom = "Bulgaria"
});
var service = new OrdersService(repository, companyServiceMock.Object, mapperOrder.Object);
return(service);
}
private UsersService IntializeUsersService(SteuDbContext context)
{
MapperInitializer.InitializeMapper();
var repository = new EfDeletableEntityRepository <SteuUser>(context);
var orderServiceUsers = new Mock <IOrdersService>();
var companiesServicesUsers = new Mock <ICompaniesService>();
var newsServiceUsers = new Mock <INewsService>();
var userRolesServiceUsers = new Mock <IUserRolesService>();
var deleteMessageServiceUsers = new Mock <IDeleteMessagesService>();
var userManagerUsers = this.GetMockUserManager();
var service = new UsersService(
repository,
orderServiceUsers.Object,
companiesServicesUsers.Object,
newsServiceUsers.Object,
userRolesServiceUsers.Object,
deleteMessageServiceUsers.Object,
userManagerUsers.Object);
return(service);
}
private MessagesService IntializeMessagesService(SteuDbContext context)
{
var repository = new EfDeletableEntityRepository <Message>(context);
var mapper = new Mock <IMapper>();
var ordersService = new Mock <IOrdersService>();
ordersService.Setup(x => x.GetOrderByIdAsync <SendMessageInputModel>("orderId"))
.Returns(Task.FromResult(new SendMessageInputModel()
{
CountryFrom = "Bulgaria"
}));
var replaysService = new Mock <IReplaysService>();
MapperInitializer.InitializeMapper();
var service = new MessagesService(
repository,
mapper.Object,
ordersService.Object,
replaysService.Object);
return(service);
}
public async Task SeedAsync(SteuDbContext dbContext, IServiceProvider serviceProvider)
{
if (await dbContext.TruckTypes.AnyAsync())
{
return;
}
await dbContext.TruckTypes.AddAsync(new TruckType
{
Name = "Normal",
IconUrl = "https://res.cloudinary.com/steu/image/upload/v1564000522/Icons/TruckType/kompl_bfwm5l.gif"
});
await dbContext.TruckTypes.AddAsync(new TruckType {
Name = "Refrigerated",
IconUrl = "https://res.cloudinary.com/steu/image/upload/v1564000522/Icons/TruckType/hkompl_fgbpat.gif"
});
await dbContext.TruckTypes.AddAsync(new TruckType {
Name = "ADR",
IconUrl = "https://res.cloudinary.com/steu/image/upload/v1564000522/Icons/TruckType/adr_g3x0ew.gif"
});
}
public async Task SeedAsync(SteuDbContext dbContext, IServiceProvider serviceProvider)
{
if (await dbContext.Countries.AnyAsync())
{
return;
}
await dbContext.Countries.AddAsync(new Country { Name = "Albania" });
await dbContext.Countries.AddAsync(new Country { Name = "Armenia" });
await dbContext.Countries.AddAsync(new Country { Name = "Austria" });
await dbContext.Countries.AddAsync(new Country { Name = "Azerbaijan" });
await dbContext.Countries.AddAsync(new Country { Name = "Belarus" });
await dbContext.Countries.AddAsync(new Country { Name = "Belgium" });
await dbContext.Countries.AddAsync(new Country { Name = "Bulgaria" });
await dbContext.Countries.AddAsync(new Country { Name = "Bosnia and Herzegovina" });
await dbContext.Countries.AddAsync(new Country { Name = "Switzerland" });
await dbContext.Countries.AddAsync(new Country { Name = "Cyprus" });
await dbContext.Countries.AddAsync(new Country { Name = "Czech Republic" });
await dbContext.Countries.AddAsync(new Country { Name = "Germany" });
await dbContext.Countries.AddAsync(new Country { Name = "Denmark" });
await dbContext.Countries.AddAsync(new Country { Name = "Estonia" });
await dbContext.Countries.AddAsync(new Country { Name = "Spain" });
await dbContext.Countries.AddAsync(new Country { Name = "Finland" });
await dbContext.Countries.AddAsync(new Country { Name = "France" });
await dbContext.Countries.AddAsync(new Country { Name = "United Kingdom" });
await dbContext.Countries.AddAsync(new Country { Name = "Georgia" });
await dbContext.Countries.AddAsync(new Country { Name = "Greece" });
await dbContext.Countries.AddAsync(new Country { Name = "Croatia" });
await dbContext.Countries.AddAsync(new Country { Name = "Hungary" });
await dbContext.Countries.AddAsync(new Country { Name = "Ireland" });
await dbContext.Countries.AddAsync(new Country { Name = "Iraq" });
await dbContext.Countries.AddAsync(new Country { Name = "Iran" });
await dbContext.Countries.AddAsync(new Country { Name = "Iceland" });
await dbContext.Countries.AddAsync(new Country { Name = "Italy" });
await dbContext.Countries.AddAsync(new Country { Name = "Jordan" });
await dbContext.Countries.AddAsync(new Country { Name = "Kyrgyzstan" });
await dbContext.Countries.AddAsync(new Country { Name = "Kazakhstan" });
await dbContext.Countries.AddAsync(new Country { Name = "Liechtenstein" });
await dbContext.Countries.AddAsync(new Country { Name = "Lithuania" });
await dbContext.Countries.AddAsync(new Country { Name = "Luxembourg" });
await dbContext.Countries.AddAsync(new Country { Name = "Latvia" });
await dbContext.Countries.AddAsync(new Country { Name = "Moldova" });
await dbContext.Countries.AddAsync(new Country { Name = "North Macedonia" });
await dbContext.Countries.AddAsync(new Country { Name = "Montenegro" });
await dbContext.Countries.AddAsync(new Country { Name = "Malta" });
await dbContext.Countries.AddAsync(new Country { Name = "Netherlands" });
await dbContext.Countries.AddAsync(new Country { Name = "Norway" });
await dbContext.Countries.AddAsync(new Country { Name = "Poland" });
await dbContext.Countries.AddAsync(new Country { Name = "Portugal" });
await dbContext.Countries.AddAsync(new Country { Name = "Kosovo" });
await dbContext.Countries.AddAsync(new Country { Name = "Romania" });
await dbContext.Countries.AddAsync(new Country { Name = "Russia" });
await dbContext.Countries.AddAsync(new Country { Name = "Sweden" });
await dbContext.Countries.AddAsync(new Country { Name = "Slovenia" });
await dbContext.Countries.AddAsync(new Country { Name = "Slovakia" });
await dbContext.Countries.AddAsync(new Country { Name = "Serbia" });
await dbContext.Countries.AddAsync(new Country { Name = "Syria" });
await dbContext.Countries.AddAsync(new Country { Name = "Turkmenistan" });
await dbContext.Countries.AddAsync(new Country { Name = "Turkey" });
await dbContext.Countries.AddAsync(new Country { Name = "Ukraine" });
await dbContext.Countries.AddAsync(new Country { Name = "Uzbekistan" });
}
public EfRepository(SteuDbContext context)
{
this.Context = context ?? throw new ArgumentNullException(nameof(context));
this.DbSet = this.Context.Set <TEntity>();
}
private async Task SeedData(SteuDbContext context)
{
context.AddRange(this.GetDummyData());
await context.SaveChangesAsync();
}
public EfDeletableEntityRepository(SteuDbContext context)
: base(context)
{
}
