public async Task CheckRemovingProductToProcedureAsync()
{
ApplicationDbContext db = GetDb();
var repository = new EfDeletableEntityRepository <Procedure>(db);
var procedureProductsRepository = new EfRepository <ProcedureProduct>(db);
var service = new ProceduresService(
repository,
this.procedureReviewsRepository.Object,
procedureProductsRepository,
this.procedureStylistsRepository.Object,
this.skinProblemProceduresRepository.Object,
this.appointmentsRepository.Object,
this.categoriesService.Object);
var procedure = new Procedure()
{
Id = "1",
};
var product = new Product()
{
Id = "1"
};
await service.AddProductToProcedureAsync(procedure.Id, product.Id);
await service.RemoveProductAsync(product.Id, procedure.Id);
Assert.Empty(procedureProductsRepository.All());
}
public async Task CheckGettingProcedureIdByProcedureNameAsync()
{
ApplicationDbContext db = GetDb();
var repository = new EfDeletableEntityRepository <Procedure>(db);
var service = new ProceduresService(
repository,
this.procedureReviewsRepository.Object,
this.procedureProductsRepository.Object,
this.procedureStylistsRepository.Object,
this.skinProblemProceduresRepository.Object,
this.appointmentsRepository.Object,
this.categoriesService.Object);
var procedure = new Procedure()
{
Id = "1",
Name = "first procedure",
};
await db.Procedures.AddAsync(procedure);
await db.SaveChangesAsync();
var procedureId = await service.GetProcedureIdByNameAsync(procedure.Name);
Assert.Equal(procedure.Id, procedureId);
}
public async Task CheckGettingProcedureDetailsAsync()
{
ApplicationDbContext db = GetDb();
var repository = new EfDeletableEntityRepository <Procedure>(db);
var service = new ProceduresService(
repository,
this.procedureReviewsRepository.Object,
this.procedureProductsRepository.Object,
this.procedureStylistsRepository.Object,
this.skinProblemProceduresRepository.Object,
this.appointmentsRepository.Object,
this.categoriesService.Object);
var firstProcedure = new Procedure()
{
Id = "1"
};
var secondProcedure = new Procedure()
{
Id = "2"
};
await db.Procedures.AddAsync(firstProcedure);
await db.Procedures.AddAsync(secondProcedure);
await db.SaveChangesAsync();
var procedure = await service.GetProcedureDetailsAsync <TestProcedureModel>(firstProcedure.Id);
Assert.Equal(firstProcedure.Id, procedure.Id);
}
public async Task CheckAddingProductToProcedureAsync()
{
ApplicationDbContext db = GetDb();
var repository = new EfDeletableEntityRepository <Procedure>(db);
var procedureProductsRepository = new EfRepository <ProcedureProduct>(db);
var service = new ProceduresService(
repository,
this.procedureReviewsRepository.Object,
procedureProductsRepository,
this.procedureStylistsRepository.Object,
this.skinProblemProceduresRepository.Object,
this.appointmentsRepository.Object,
this.categoriesService.Object);
var procedure = new Procedure()
{
Id = "1",
};
var product = new Product()
{
Id = "1"
};
var isAddedTrueCase = await service.AddProductToProcedureAsync(procedure.Id, product.Id);
var isAddedFalseCase = await service.AddProductToProcedureAsync(procedure.Id, product.Id);
Assert.True(isAddedTrueCase);
Assert.True(!isAddedFalseCase);
}
public async Task CheckGettingAppointmentsHistoryUserAsync()
{
ApplicationDbContext db = GetDb();
var repository = new EfDeletableEntityRepository <Appointment>(db);
var usersService = new Mock <IUsersService>();
var cardsService = new Mock <ICardsService>();
var categoriesRepository = new EfDeletableEntityRepository <Category>(db);
var categoryService = new CategoriesService(categoriesRepository);
var proceduresRepository = new EfDeletableEntityRepository <Procedure>(db);
var procedureReviewsRepository = new EfDeletableEntityRepository <Review>(db);
var procedureProductsRepository = new EfRepository <ProcedureProduct>(db);
var procedureStylistsRepository = new EfRepository <ProcedureStylist>(db);
var skinProblemProcedureRepository = new EfRepository <SkinProblemProcedure>(db);
var proceduresService = new ProceduresService(
proceduresRepository,
procedureReviewsRepository,
procedureProductsRepository,
procedureStylistsRepository,
skinProblemProcedureRepository,
repository,
categoryService);
var service = new AppointmentsService(
repository,
usersService.Object,
cardsService.Object,
proceduresService,
categoryService);
await db.Procedures.AddAsync(this.procedure);
await db.Categories.AddAsync(this.category);
await db.SaveChangesAsync();
string appId = await this.GetAppointmentIdAsync(service);
await service.DoneAsync(appId);
var firstApp = await GetAppointmentAsync(repository, appId);
firstApp.IsReview = true;
repository.Update(firstApp);
await repository.SaveChangesAsync();
var resultAppointments = await
service.GetHistoryUserAsync <TestAppointmentModel>(this.client.Id);
Assert.Single(resultAppointments);
}
public async Task CheckProductUseProceduresAsync()
{
ApplicationDbContext db = GetDb();
var repository = new EfDeletableEntityRepository <Procedure>(db);
var procedureProductsRepository = new EfRepository <ProcedureProduct>(db);
var service = new ProceduresService(
repository,
this.procedureReviewsRepository.Object,
procedureProductsRepository,
this.procedureStylistsRepository.Object,
this.skinProblemProceduresRepository.Object,
this.appointmentsRepository.Object,
this.categoriesService.Object);
var firstProcedure = new Procedure()
{
Id = "1",
};
var secondProcedure = new Procedure()
{
Id = "2",
};
var thirdProcedure = new Procedure()
{
Id = "3",
};
var product = new Product()
{
Id = "1",
};
await db.Procedures.AddAsync(firstProcedure);
await db.Procedures.AddAsync(secondProcedure);
await db.Procedures.AddAsync(thirdProcedure);
await db.Products.AddAsync(product);
await db.SaveChangesAsync();
await service.AddProductToProcedureAsync(firstProcedure.Id, product.Id);
await service.AddProductToProcedureAsync(secondProcedure.Id, product.Id);
var procedures = await service.GetProceduresUseProductAsync <TestProcedureModel>(product.Id);
Assert.Equal(2, procedures.Count());
}
private static AppointmentsService PreperaAppointmentServiceWithAllDependencies(ApplicationDbContext db)
{
var repository = new EfDeletableEntityRepository <Appointment>(db);
var usersRepository = new EfDeletableEntityRepository <ApplicationUser>(db);
var skinProblemsRepository = new EfDeletableEntityRepository <SkinProblem>(db);
var clientSkinProblemRepository = new EfRepository <ClientSkinProblem>(db);
var cardsRepository = new EfDeletableEntityRepository <Card>(db);
var cloudinaryService = new Mock <ICloudinaryService>();
var usersService = new UsersService(
usersRepository,
skinProblemsRepository,
clientSkinProblemRepository,
cardsRepository,
cloudinaryService.Object);
var cardTypesRepository = new EfDeletableEntityRepository <TypeCard>(db);
var cardsService = new CardsService(
cardTypesRepository,
cardsRepository);
var categoriesRepository = new EfDeletableEntityRepository <Category>(db);
var categoryService = new CategoriesService(categoriesRepository);
var proceduresRepository = new EfDeletableEntityRepository <Procedure>(db);
var procedureReviewsRepository = new EfDeletableEntityRepository <Review>(db);
var procedureProductsRepository = new EfRepository <ProcedureProduct>(db);
var procedureStylistsRepository = new EfRepository <ProcedureStylist>(db);
var skinProblemProcedureRepository = new EfRepository <SkinProblemProcedure>(db);
var proceduresService = new ProceduresService(
proceduresRepository,
procedureReviewsRepository,
procedureProductsRepository,
procedureStylistsRepository,
skinProblemProcedureRepository,
repository,
categoryService);
var service = new AppointmentsService(
repository,
usersService,
cardsService,
proceduresService,
categoryService);
return(service);
}
public async Task CheckUpdatingProcedureAsync()
{
ApplicationDbContext db = GetDb();
var repository = new EfDeletableEntityRepository <Procedure>(db);
var service = new ProceduresService(
repository,
this.procedureReviewsRepository.Object,
this.procedureProductsRepository.Object,
this.procedureStylistsRepository.Object,
this.skinProblemProceduresRepository.Object,
this.appointmentsRepository.Object,
this.categoriesService.Object);
var procedure = new Procedure()
{
Id = "1",
Name = "procedureName",
Description = "procedureDEscription",
Price = 12,
CategoryId = "1",
SkinTypeId = "1",
IsSensitive = true,
};
await db.Procedures.AddAsync(procedure);
await db.SaveChangesAsync();
await service.UpdateAsync(procedure.Id, "newName", procedure.Description, 13, "2", "2", "No");
var procedureId = await service.GetIdByNameAsync(procedure.Name);
Assert.Equal(procedure.Id, procedureId);
Assert.Equal("newName", procedure.Name);
Assert.Equal("procedureDEscription", procedure.Description);
Assert.Equal(13, procedure.Price);
Assert.Equal("2", procedure.SkinTypeId);
Assert.Equal("2", procedure.CategoryId);
Assert.True(!procedure.IsSensitive);
}
public async Task CheckCreatingProcedureAsync()
{
ApplicationDbContext db = GetDb();
var repository = new EfDeletableEntityRepository <Procedure>(db);
var skinProblemProceduresRepository = new EfRepository <SkinProblemProcedure>(db);
var service = new ProceduresService(
repository,
this.procedureReviewsRepository.Object,
this.procedureProductsRepository.Object,
this.procedureStylistsRepository.Object,
skinProblemProceduresRepository,
this.appointmentsRepository.Object,
this.categoriesService.Object);
var procedure = await PrepareProcedureAsync(db, service);
Assert.NotNull(procedure);
Assert.True(procedure.IsSensitive);
Assert.Equal(3, procedure.SkinProblemProcedures.Count());
}
private static async Task <Procedure> PrepareProcedureAsync(ApplicationDbContext db, ProceduresService service)
{
var firstSkinProblem = new SkinProblem()
{
Id = "1",
Name = "firstSkinProblemName",
};
var secondSkinProblem = new SkinProblem()
{
Id = "2",
Name = "secondSkinProblemName",
};
var thirdSkinProblem = new SkinProblem()
{
Id = "3",
Name = "thirdSkinProblemName",
};
SkinProblem[] skinProblems = new SkinProblem[]
{
firstSkinProblem,
secondSkinProblem,
thirdSkinProblem,
};
await db.SkinProblems.AddRangeAsync(skinProblems);
await db.SaveChangesAsync();
var skinProblemsAsSelectListItemt = skinProblems
.Select(sp => new SelectListItem()
{
Value = sp.Id,
Text = sp.Name,
Selected = true,
})
.ToList();
var procedureId = await service.CreateAsync("procedureName", "procedureDEscription", 12, "1", "1", "Yes", skinProblemsAsSelectListItemt);
var procedure = await service.GetByIdAsync(procedureId);
return(procedure);
}
public async Task CheckProcedureSearchByAsync()
{
ApplicationDbContext db = GetDb();
var repository = new EfDeletableEntityRepository <Procedure>(db);
var categoriesRepository = new EfDeletableEntityRepository <Category>(db);
var categoriesService = new Mock <CategoriesService>(categoriesRepository);
var service = new ProceduresService(
repository,
this.procedureReviewsRepository.Object,
this.procedureProductsRepository.Object,
this.procedureStylistsRepository.Object,
this.skinProblemProceduresRepository.Object,
this.appointmentsRepository.Object,
categoriesService.Object);
var skinCareCategory = new Category()
{
Id = "1",
Name = GlobalConstants.CategorySkinName,
};
var firstSkinType = new SkinType()
{
Id = "1",
};
var secondSkinType = new SkinType()
{
Id = "2",
};
var firstProcedure = new Procedure()
{
Id = "1",
CategoryId = skinCareCategory.Id,
SkinTypeId = firstSkinType.Id,
Price = 1,
AverageRating = 1,
};
var secondProcedure = new Procedure()
{
Id = "2",
CategoryId = skinCareCategory.Id,
SkinTypeId = secondSkinType.Id,
Price = 2,
AverageRating = 2,
};
var thirdProcedure = new Procedure()
{
Id = "3",
CategoryId = "2",
Price = 3,
AverageRating = 4,
};
var fourthProcedure = new Procedure()
{
Id = "4",
CategoryId = skinCareCategory.Id,
SkinTypeId = firstSkinType.Id,
Price = 4,
AverageRating = 4,
};
await categoriesRepository.AddAsync(skinCareCategory);
await db.Procedures.AddAsync(firstProcedure);
await db.Procedures.AddAsync(secondProcedure);
await db.Procedures.AddAsync(thirdProcedure);
await db.Procedures.AddAsync(fourthProcedure);
await db.SkinTypes.AddAsync(firstSkinType);
await db.SkinTypes.AddAsync(secondSkinType);
await db.SaveChangesAsync();
var proceduresSearchWithoutCriteria = await service.SearchByAsync <TestProcedureModel>(firstSkinType.Id, string.Empty);
var proceduresOrderByPriceWithoutSkinType = await service.SearchByAsync <TestProcedureModel>(string.Empty, "price");
var proceduresOrderByRatingWithoutSkinType = await service.SearchByAsync <TestProcedureModel>(string.Empty, "rating");
var proceduresOrderByPriceWithSkinType = await service.SearchByAsync <TestProcedureModel>(firstSkinType.Id, "price");
var proceduresOrderByRatingWithSkinType = await service.SearchByAsync <TestProcedureModel>(firstSkinType.Id, "rating");
var proceduresOrderByPriceWithoutSkinTypeExpected = await repository
.All()
.Where(p => p.CategoryId == skinCareCategory.Id)
.OrderBy(p => p.Price)
.To <TestProcedureModel>()
.ToListAsync();
var proceduresOrderByRatingWithoutSkinTypeExpected = await repository
.All()
.Where(p => p.CategoryId == skinCareCategory.Id)
.OrderByDescending(p => p.AverageRating)
.To <TestProcedureModel>()
.ToListAsync();
var proceduresOrderByPriceWithSkinTypeExpected = await repository
.All()
.Where(p => p.CategoryId == skinCareCategory.Id && p.SkinTypeId == firstSkinType.Id)
.OrderBy(p => p.Price)
.To <TestProcedureModel>()
.ToListAsync();
var proceduresOrderByRatingWithSkinTypeExpected = await repository
.All()
.Where(p => p.CategoryId == skinCareCategory.Id && p.SkinTypeId == firstSkinType.Id)
.OrderByDescending(p => p.AverageRating)
.To <TestProcedureModel>()
.ToListAsync();
Assert.Equal(2, proceduresSearchWithoutCriteria.Count());
proceduresOrderByPriceWithoutSkinType.SequenceEqual(proceduresOrderByPriceWithoutSkinTypeExpected);
proceduresOrderByRatingWithoutSkinType.SequenceEqual(proceduresOrderByRatingWithoutSkinTypeExpected);
proceduresOrderByPriceWithSkinType.SequenceEqual(proceduresOrderByPriceWithSkinTypeExpected);
proceduresOrderByRatingWithSkinType.SequenceEqual(proceduresOrderByRatingWithSkinTypeExpected);
}
public async Task CheckGettingAllAndGettingAllByCategoryProceduresAsync()
{
ApplicationDbContext db = GetDb();
var repository = new EfDeletableEntityRepository <Procedure>(db);
var service = new ProceduresService(
repository,
this.procedureReviewsRepository.Object,
this.procedureProductsRepository.Object,
this.procedureStylistsRepository.Object,
this.skinProblemProceduresRepository.Object,
this.appointmentsRepository.Object,
this.categoriesService.Object);
var firstCategory = new Category()
{
Id = "1", Name = "firstCategoryName",
};
var secondCategory = new Category()
{
Id = "2", Name = "secondCategoryName",
};
var skinType = new SkinType()
{
Id = "1", Name = "skinTypeName",
};
var firstProcedure = new Procedure()
{
Id = "1", CategoryId = firstCategory.Id, SkinTypeId = skinType.Id
};
var secondProcedure = new Procedure()
{
Id = "2", CategoryId = firstCategory.Id, SkinTypeId = skinType.Id
};
var thirdProcedure = new Procedure()
{
Id = "3", CategoryId = secondCategory.Id, SkinTypeId = skinType.Id
};
await db.Procedures.AddAsync(firstProcedure);
await db.Procedures.AddAsync(secondProcedure);
await db.Procedures.AddAsync(thirdProcedure);
await db.Categories.AddAsync(firstCategory);
await db.Categories.AddAsync(secondCategory);
await db.SkinTypes.AddAsync(skinType);
await db.SaveChangesAsync();
var procedures = await service.GetAllAdministrationAsync <TestProcedureModel>();
var proceduresCurrentCategory = await service.GetAllByCategoryAsync <TestProcedureModel>(firstCategory.Id, 5, 0);
var proceduresByCurrentCategoryCount = await service.GetTotalCountProceduresByCategoryAsync(firstCategory.Id);
Assert.Equal(3, procedures.Count());
Assert.Equal(2, proceduresCurrentCategory.Count());
Assert.Equal(2, proceduresByCurrentCategoryCount);
}
public async Task CheckDeletingProcedureAsync()
{
ApplicationDbContext db = GetDb();
var repository = new EfDeletableEntityRepository <Procedure>(db);
var skinProblemProceduresRepository = new EfRepository <SkinProblemProcedure>(db);
var procedureStylistsRepository = new EfRepository <ProcedureStylist>(db);
var procedureProductsRepository = new EfRepository <ProcedureProduct>(db);
var service = new ProceduresService(
repository,
this.procedureReviewsRepository.Object,
procedureProductsRepository,
procedureStylistsRepository,
skinProblemProceduresRepository,
this.appointmentsRepository.Object,
this.categoriesService.Object);
var procedure = await PrepareProcedureAsync(db, service);
var firstStylist = new ApplicationUser()
{
Id = "1"
};
var secondStylist = new ApplicationUser()
{
Id = "2"
};
var firstStylistProcedure = new ProcedureStylist()
{
ProcedureId = procedure.Id,
StylistId = firstStylist.Id,
};
var secondStylistProcedure = new ProcedureStylist()
{
ProcedureId = procedure.Id,
StylistId = secondStylist.Id,
};
var product = new Product()
{
Id = "1"
};
var procedureProduct = new ProcedureProduct()
{
ProcedureId = procedure.Id,
ProductId = product.Id,
};
await db.Users.AddAsync(firstStylist);
await db.Users.AddAsync(secondStylist);
await db.ProcedureStylists.AddAsync(firstStylistProcedure);
await db.ProcedureStylists.AddAsync(secondStylistProcedure);
await db.Products.AddAsync(product);
await db.ProcedureProducts.AddAsync(procedureProduct);
await db.SaveChangesAsync();
await service.DeleteAsync(procedure.Id);
Assert.True(procedure.IsDeleted);
Assert.Empty(procedureProductsRepository.All());
Assert.Empty(procedureStylistsRepository.All());
Assert.Empty(procedureProductsRepository.All());
}
public async Task CheckSmartSearchPerfectProceduresAsync()
{
ApplicationDbContext db = GetDb();
var repository = new EfDeletableEntityRepository <Procedure>(db);
var procedureStylistsRepository = new EfRepository <ProcedureStylist>(db);
var service = new ProceduresService(
repository,
this.procedureReviewsRepository.Object,
this.procedureProductsRepository.Object,
procedureStylistsRepository,
this.skinProblemProceduresRepository.Object,
this.appointmentsRepository.Object,
this.categoriesService.Object);
var skinType = new SkinType()
{
Id = "1",
};
var firstProcedure = new Procedure()
{
Id = "1",
IsSensitive = true,
SkinTypeId = skinType.Id,
};
var secondProcedure = new Procedure()
{
Id = "2",
IsSensitive = true,
SkinTypeId = skinType.Id,
};
var thirdProcedure = new Procedure()
{
Id = "3",
IsSensitive = false,
SkinTypeId = skinType.Id,
};
var fourthProcedure = new Procedure()
{
Id = "4",
IsSensitive = true,
SkinTypeId = "2",
};
var stylist = new ApplicationUser()
{
Id = "1"
};
var firstStylistProcedure = new ProcedureStylist()
{
ProcedureId = firstProcedure.Id,
StylistId = stylist.Id,
};
var secondStylistProcedure = new ProcedureStylist()
{
ProcedureId = secondProcedure.Id,
StylistId = stylist.Id,
};
var thirdStylistProcedure = new ProcedureStylist()
{
ProcedureId = thirdProcedure.Id,
StylistId = stylist.Id,
};
var fourthStylistProcedure = new ProcedureStylist()
{
ProcedureId = fourthProcedure.Id,
StylistId = stylist.Id,
};
await db.Procedures.AddAsync(firstProcedure);
await db.Procedures.AddAsync(secondProcedure);
await db.Procedures.AddAsync(thirdProcedure);
await db.Procedures.AddAsync(fourthProcedure);
await db.Users.AddAsync(stylist);
await db.SkinTypes.AddAsync(skinType);
await db.ProcedureStylists.AddAsync(firstStylistProcedure);
await db.ProcedureStylists.AddAsync(secondStylistProcedure);
await db.ProcedureStylists.AddAsync(thirdStylistProcedure);
await db.ProcedureStylists.AddAsync(fourthStylistProcedure);
await db.SaveChangesAsync();
var proceduresSmartSearch = await service.GetSmartSearchProceduresAsync <TestProcedureStylistModel>(skinType.Id, "yes", stylist.Id);
var perfectProcedures = await service.GetPerfectProceduresForSkinTypeAsync <TestProcedureModel>(true, skinType.Id);
Assert.Equal(2, proceduresSmartSearch.Count());
Assert.Equal(2, perfectProcedures.Count());
}
public async Task CheckGettingProcedureStylistsAsync()
{
ApplicationDbContext db = GetDb();
var repository = new EfDeletableEntityRepository <Procedure>(db);
var procedureStylistsRepository = new EfRepository <ProcedureStylist>(db);
var service = new ProceduresService(
repository,
this.procedureReviewsRepository.Object,
this.procedureProductsRepository.Object,
procedureStylistsRepository,
this.skinProblemProceduresRepository.Object,
this.appointmentsRepository.Object,
this.categoriesService.Object);
var procedure = new Procedure()
{
Id = "1"
};
var firstStylist = new ApplicationUser()
{
Id = "1"
};
var secondStylist = new ApplicationUser()
{
Id = "2"
};
var thirdStylist = new ApplicationUser()
{
Id = "3"
};
var firstStylistProcedure = new ProcedureStylist()
{
ProcedureId = procedure.Id,
StylistId = firstStylist.Id,
};
var secondStylistProcedure = new ProcedureStylist()
{
ProcedureId = procedure.Id,
StylistId = secondStylist.Id,
};
await db.Procedures.AddAsync(procedure);
await db.Users.AddAsync(firstStylist);
await db.Users.AddAsync(secondStylist);
await db.Users.AddAsync(thirdStylist);
await db.ProcedureStylists.AddAsync(firstStylistProcedure);
await db.ProcedureStylists.AddAsync(secondStylistProcedure);
await db.SaveChangesAsync();
var procedures = await service.GetProceduresByStylistAsync <TestProcedureStylistModel>(firstStylist.Id);
Assert.Single(procedures);
}
private async Task <AppointmentsService> PrepareAppointmentReviewAsync()
{
ApplicationDbContext db = GetDb();
var repository = new EfDeletableEntityRepository <Appointment>(db);
var usersService = new Mock <IUsersService>();
var cardsService = new Mock <ICardsService>();
var categoriesRepository = new EfDeletableEntityRepository <Category>(db);
var categoryService = new CategoriesService(categoriesRepository);
var proceduresRepository = new EfDeletableEntityRepository <Procedure>(db);
var procedureReviewsRepository = new EfDeletableEntityRepository <Review>(db);
var procedureProductsRepository = new EfRepository <ProcedureProduct>(db);
var procedureStylistsRepository = new EfRepository <ProcedureStylist>(db);
var skinProblemProcedureRepository = new EfRepository <SkinProblemProcedure>(db);
var proceduresService = new ProceduresService(
proceduresRepository,
procedureReviewsRepository,
procedureProductsRepository,
procedureStylistsRepository,
skinProblemProcedureRepository,
repository,
categoryService);
var service = new AppointmentsService(
repository,
usersService.Object,
cardsService.Object,
proceduresService,
categoryService);
await db.Procedures.AddAsync(this.procedure);
await db.Categories.AddAsync(this.category);
await db.SaveChangesAsync();
var pastDate = DateTime.ParseExact("12/10/2020", "dd/MM/yyyy", CultureInfo.InvariantCulture);
string firstAppId = await service.CreateAsync(this.client.Id, this.stylist.Id, this.procedure.Id, pastDate, "11:00", "test comment");
string secondAppId = await service.CreateAsync(this.client.Id, this.stylist.Id, this.procedure.Id, pastDate, "12:00", "test comment");
string thirdAppId = await service.CreateAsync(this.client.Id, this.stylist.Id, this.procedure.Id, DateTime.UtcNow, "13:00", "test comment");
await service.DoneAsync(firstAppId);
await service.DoneAsync(secondAppId);
await service.DoneAsync(thirdAppId);
var firstApp = await GetAppointmentAsync(repository, firstAppId);
firstApp.IsReview = true;
repository.Update(firstApp);
await repository.SaveChangesAsync();
return(service);
}
public List <ValoresRelatorioRentabilidadeDto> ObterInformacoesPorDiretoria(FiltroRelatorioRentabilidadeDiretoriaDto filtro)
{
var idCelulaSelecionada = filtro.IdsCelula.LastOrDefault();
var proceduresService = new ProceduresService(_connectionStrings.Value.EacessoConnection);
var celulaValidadas = proceduresService.ObterHierarquiaCelulas(filtro.IdsCelula.LastOrDefault());
var idsCelulaValidadas = celulaValidadas.Select(x => x.IdCelula).Concat(celulaValidadas.Select(x => x.IdCelulaSup)).Distinct().ToList();
filtro.IdsCelula = idsCelulaValidadas;
#region variaveis
var servicos = new List <ServicoContratadoRelatorioRentabilidadeModel>();
var repassesPagos = new List <RepasseRelatorioRentabilidadeModel>();
var repassesRecebidos = new List <RepasseRelatorioRentabilidadeModel>();
List <ValoresRelatorioRentabilidadeDto> valoresRelatorio = new List <ValoresRelatorioRentabilidadeDto>();
List <ValoresRelatorioRentabilidadeDto> valoresRelatorioCliente = new List <ValoresRelatorioRentabilidadeDto>();
List <ValoresRelatorioRentabilidadeDto> valoresRelatorioCelula = new List <ValoresRelatorioRentabilidadeDto>();
var itensLancamentosServico = new List <ItemLancamentoFinanceiro>();
var itensLancamentosRepassesPagos = new List <ItemLancamentoFinanceiro>();
var itensLancamentosRepassesRecebidos = new List <ItemLancamentoFinanceiro>();
var celulas = new List <CelulaEacesso>();
var celulasService = new CelulaEacessoService(_connectionStrings.Value.EacessoConnection);
celulas = celulasService.ObterCelulasPorIds(filtro.IdsCelula);
#endregion
itensLancamentosServico = ObterItensLancamentoPorServico(filtro, out servicos);
itensLancamentosRepassesPagos = ObterItensLancamentoRepassesPagos(filtro, out repassesPagos);
itensLancamentosRepassesRecebidos = ObterItensLancamentoRepassesRecebidos(filtro, out repassesRecebidos);
var itensAgrupados = itensLancamentosServico.GroupBy(x => x.IdServicoContratado);
var itensAgrupadosRepassesPagos = itensLancamentosRepassesPagos.GroupBy(x => x.IdRepasse);
var itensAgrupadosRepassesRecebidos = itensLancamentosRepassesRecebidos.GroupBy(x => x.IdRepasse);
var repassesPagosAgrupados = repassesPagos.GroupBy(x => x.IdServicoContratado);
var repassesRecebidosAgrupados = repassesRecebidos.GroupBy(x => x.IdServicoContratado);
var idsServicos = itensAgrupados.Select(x => new ManipularValoresRelatorio {
Id = x.Key.Value, Tipo = "S"
}).Distinct().ToList();
var idsRepassesPagos = itensAgrupadosRepassesPagos.Select(x => new ManipularValoresRelatorio {
Id = x.Key.Value, Tipo = "R"
}).Distinct();
var idsRepassesRecebidos = itensAgrupadosRepassesRecebidos.Select(x => new ManipularValoresRelatorio {
Id = x.Key.Value, Tipo = "R"
}).Distinct();
foreach (var item in repassesPagosAgrupados)
{
if (!idsServicos.Any(x => x.Id == item.Key))
{
idsServicos.Add(new ManipularValoresRelatorio {
Id = item.Key, Tipo = "S"
});
}
}
foreach (var item in repassesRecebidosAgrupados)
{
if (!idsServicos.Any(x => x.Id == item.Key))
{
idsServicos.Add(new ManipularValoresRelatorio {
Id = item.Key, Tipo = "S"
});
}
}
foreach (var idItem in idsServicos)
{
var servicoAtual = new ServicoContratadoRelatorioRentabilidadeModel();
if (idItem.Tipo == "S")
{
servicoAtual = servicos.FirstOrDefault(x => x.Id == idItem.Id);
}
else
{
var idServico = repassesPagosAgrupados.FirstOrDefault(x => x.Any(y => y.Id == idItem.Id));
if (idServico != null)
{
servicoAtual = servicos.FirstOrDefault(x => x.Id == idServico.Key);
}
else
{
idServico = repassesRecebidosAgrupados.FirstOrDefault(x => x.Any(y => y.Id == idItem.Id));
if (idServico != null)
{
servicoAtual = servicos.FirstOrDefault(x => x.Id == idServico.Key);
}
}
}
IGrouping <int?, ItemLancamentoFinanceiro> itemServico = null;
itemServico = itensAgrupados.FirstOrDefault(x => x.Key == servicoAtual.Id);
if (itemServico == null)
{
var idsPagos = repassesPagos.Where(x => x.IdServicoContratado == servicoAtual.Id).Select(x => x.Id).ToList();
var itens = itensLancamentosRepassesPagos.Where(x => idsPagos.Contains(x.IdRepasse.Value));
foreach (var item in itens)
{
item.IdServicoContratado = repassesPagos.FirstOrDefault(x => x.Id == item.IdRepasse).IdServicoContratado;
}
itemServico = itensLancamentosRepassesPagos.Where(x => idsPagos.Contains(x.IdRepasse.Value)).GroupBy(x => x.IdServicoContratado).FirstOrDefault();
}
if (itemServico == null)
{
var idsPagos = repassesRecebidos.Where(x => x.IdServicoContratado == servicoAtual.Id).Select(x => x.Id).ToList();
var itens = itensLancamentosRepassesRecebidos.Where(x => idsPagos.Contains(x.IdRepasse.Value));
foreach (var item in itens)
{
item.IdServicoContratado = repassesRecebidos.FirstOrDefault(x => x.Id == item.IdRepasse).IdServicoContratado;
}
itemServico = itensLancamentosRepassesRecebidos.Where(x => idsPagos.Contains(x.IdRepasse.Value)).GroupBy(x => x.IdServicoContratado).FirstOrDefault();
}
if (itemServico == null)
{
continue;
}
var valorRelatorio = new ValoresRelatorioRentabilidadeDto();
valorRelatorio.Descricao = "SERVIÇO:" + servicos.FirstOrDefault(x => x.Id == servicoAtual.Id).DescEscopo;
valorRelatorio.Tipo = "";
valorRelatorio.Nivel = 4;
valorRelatorio.IdServico = servicoAtual.Id;
valorRelatorio.IdCelula = servicoAtual.IdCelula;
valorRelatorio.IdCliente = servicos.FirstOrDefault(x => x.Id == servicoAtual.Id).IdCliente;
CalcularValorFaturamentoServico(valorRelatorio, itemServico, celulas);
CalcularValorAjusteFaturamento(valorRelatorio, itemServico, servicos.FirstOrDefault(x => x.Id == servicoAtual.Id), itensLancamentosRepassesPagos.ToList(), repassesPagos, celulas);
CalcularValorFaturamentoAjusteServico(valorRelatorio, celulas);
CalcularValorMarkup(valorRelatorio, itemServico, servicos.FirstOrDefault(x => x.Id == servicoAtual.Id), itensLancamentosRepassesPagos.ToList(), repassesPagos, celulas);
CalcularValorDespesasGerais(valorRelatorio, itemServico, servicos.FirstOrDefault(x => x.Id == servicoAtual.Id), itensLancamentosRepassesPagos.ToList(), repassesPagos, celulas);
CalcularValorDespesasSalario(valorRelatorio, itemServico, servicos.FirstOrDefault(x => x.Id == servicoAtual.Id), itensLancamentosRepassesPagos.ToList(), repassesPagos, celulas);
CalcularValorDespesasCelula(valorRelatorio, itemServico, servicos.FirstOrDefault(x => x.Id == servicoAtual.Id), itensLancamentosRepassesPagos.ToList(), repassesPagos, celulas);
CalcularValorTotalDespesa(valorRelatorio, itemServico);
CalcularValorImpostoRepasse(valorRelatorio, itensLancamentosRepassesPagos.ToList(), repassesPagos, servicoAtual, celulas);
CalcularValorRepassePago(valorRelatorio, itensLancamentosRepassesPagos.ToList(), repassesPagos, servicoAtual, celulas);
CalcularValorRepasseRecebido(valorRelatorio, itensLancamentosRepassesRecebidos.ToList(), repassesRecebidos, servicoAtual, celulas);
CalcularValorLucroServico(valorRelatorio);
CalcularValorPorcentagemLucroServico(valorRelatorio);
valoresRelatorio.Add(valorRelatorio);
}
return(FiltrarTipoRelatorio(filtro, idCelulaSelecionada, celulaValidadas, valoresRelatorio));
}
public async Task CheckAddingReviewToProcedureAsync()
{
ApplicationDbContext db = GetDb();
var repository = new EfDeletableEntityRepository <Procedure>(db);
var appointmentsRepository = new EfRepository <Appointment>(db);
var procedureReviewsRepository = new EfRepository <Review>(db);
var service = new ProceduresService(
repository,
procedureReviewsRepository,
this.procedureProductsRepository.Object,
this.procedureStylistsRepository.Object,
this.skinProblemProceduresRepository.Object,
appointmentsRepository,
this.categoriesService.Object);
var procedure = new Procedure()
{
Id = "1",
};
var firstAppointment = new Appointment()
{
Id = "1",
ProcedureId = procedure.Id,
};
var secondAppointment = new Appointment()
{
Id = "2",
ProcedureId = procedure.Id,
};
var thirdAppointment = new Appointment()
{
Id = "3",
ProcedureId = procedure.Id,
};
await db.Appointments.AddAsync(firstAppointment);
await db.Appointments.AddAsync(secondAppointment);
await db.Appointments.AddAsync(thirdAppointment);
await db.Procedures.AddAsync(procedure);
await db.SaveChangesAsync();
var firstRaiting = procedure.AverageRating;
var firstReviewsCount = procedure.Reviews.Count();
await service.AddProcedureReviewsAsync(secondAppointment.Id, "second test content", 3);
await service.AddProcedureReviewsAsync(thirdAppointment.Id, "second test content", 1);
Assert.Equal(0, firstRaiting);
Assert.Equal(0, firstReviewsCount);
Assert.Equal(2, procedure.AverageRating);
Assert.Equal(2, procedure.Reviews.Count());
}
