public static void InitializeDBAuthorAndPrintingEdition(this ModelBuilder builder)
{
var author = new Author
{
Id = 1,
Name = "Pushkin"
};
var printingEdition = new PrintingEdition
{
Id = 1,
Title = "Captain's daughter",
Description = "Roman is very interesting",
Price = 110,
Currency = Enums.CurrencyType.USD,
Type = Enums.PrintingType.Book,
Subtitle = "Printing edition"
};
var authorInPrintingEdition = new AuthorInPrintingEdition
{
AuthorId = author.Id,
PrintingEditionId = printingEdition.Id
};
builder.Entity <Author>().HasData(author);
builder.Entity <PrintingEdition>().HasData(printingEdition);
builder.Entity <AuthorInPrintingEdition>().HasData(authorInPrintingEdition);
}
public async Task AddOrder(OrderModel orderModel)
{
Order order = orderModel.OrderMapToEntity();
order.UserId = orderModel.UserId;
var orderId = await _orderRespository.GetIdAfterCreate(order);
foreach (OrderItemsModel orderItem in orderModel.OrderItemsModel)
{
PrintingEdition printingEdition = await _printingEditionRepository.Read(orderItem.PrintingEditionId);
await _orderItemsRepository.Create(new OrderItems
{
Amount = orderItem.Amount,
Count = orderItem.Count,
Currency = orderItem.Currency,
OrderId = orderId,
PrintingEditionId = orderItem.PrintingEditionId
});
}
Payment payment = new Payment();
payment.TransactionId = orderModel.StripeToken;
payment.OrderId = orderId;
await _paymentRepository.GetIdAfterCreate(payment);
}
public async Task <PrintingEdition> UpdateAsync(PrintingEdition item)
{
_context.PrintingEditions.Update(item);
await _context.SaveChangesAsync();
return(item);
}
private void InitializePrintingEdition()
{
var printingEdition = new PrintingEdition()
{
CreationDate = DateTime.Now,
Title = BaseInitConstants.PrintingEditionTitle,
Type = ProductType.Book,
Price = BaseInitConstants.PrintingEditionPrice,
Currency = Currency.USD,
Status = StatusType.Unpaid
};
var author = new Author()
{
Name = BaseInitConstants.AuthorName,
CreationDate = DateTime.Now
};
var printingEditionResult = _dbContext.PrintingEditions
.Where(x => x.Title == BaseInitConstants.PrintingEditionTitle).FirstOrDefault();
if (printingEditionResult == null)
{
_dbContext.PrintingEditions.Add(printingEdition);
}
var authorResult = _dbContext.Authors
.Where(x => x.Name == BaseInitConstants.AuthorName).FirstOrDefault();
if (authorResult == null)
{
_dbContext.Authors.Add(author);
}
_dbContext.SaveChanges();
}
public async Task <PrintingEdition> CreateAsync(PrintingEdition item)
{
await _context.PrintingEditions.AddAsync(item);
await _context.SaveChangesAsync();
return(item);
}
public async Task <PrintingEditionViewModel> GetPrintingEditionById(int id)
{
PrintingEdition printingEdition = await _printEditRepository.Get(id);
PrintingEditionViewModel printingEditionModel = _mapper.Map <PrintingEditionViewModel>(printingEdition);
return(printingEditionModel);
}
public static PrintingEdition UpdateEntityWithModel(PrintingEdition edition, PrintingEditionsModelItem model)
{
edition.Type = (DataEnums.ProductType)model.ProductType;
edition.Title = model.Title;
edition.Status = (DataEnums.StatusType)model.Status;
edition.Price = model.Price;
edition.Description = model.Description;
edition.Currency = (DataEnums.Currency)model.Currency;
return(edition);
}
public static AuthorInPrintingEdition MapToAuthorInProduct(PrintingEdition product, long authorId)
{
var authorInProduct = new AuthorInPrintingEdition()
{
PrintingEditionId = product.Id,
CreationDate = DateTime.Now,
AuthorId = authorId
};
return(authorInProduct);
}
public PrintingEdition NewProductModelToEntity(NewProductModel modelItem)
{
var printingEdition = new PrintingEdition();
printingEdition.Title = modelItem.Title;
printingEdition.Description = modelItem.Description;
printingEdition.Price = modelItem.Price;
printingEdition.Currency = (Currency)modelItem.Currency;
printingEdition.Type = (PrintingEditionType)modelItem.Type;
return(printingEdition);
}
public async Task <string> DeleteAsync(PrintingEdition item)
{
string result;
_context.PrintingEditions.Update(item);
await _context.SaveChangesAsync();
result = $"You delete {item.Name}";
return(result);
}
private long CreationPrintingEdition()
{
var printingEdition = new PrintingEdition();
printingEdition.Title = NameTitle;
printingEdition.Description = NameDescription;
printingEdition.Price = Price;
printingEdition.Currency = Currency.USD;
printingEdition.Type = PrintingEditionType.Book;
_context.PrintingEditions.Add(printingEdition);
return(printingEdition.Id);
}
public void Initialize()
{
if (_bookStoreContext.Users.Any() && _bookStoreContext.Roles.Any())
{
var adminRole = new StoreRole("Admin");
var userRole = new StoreRole("User");
_roleManager.CreateAsync(adminRole);
_roleManager.CreateAsync(userRole);
var admin = new StoreUser("Main admin");
var adminPassword = "******";
_userManager.AddToRoleAsync(admin, adminRole.Name);
_userManager.CreateAsync(admin, adminPassword);
}
if (_bookStoreContext.Authors.Any() && !_bookStoreContext.PrintingEditions.Any())
{
var dostoevskyiBook1 = new PrintingEdition()
{
CreationData = DateTime.Parse("24 05 1933"),
Currency = Entities.Enums.Currency.USD,
Description = "Most boring book ever",
Name = "Crime and punishment",
Price = 7,
IsRemoved = false,
Type = Entities.Enums.EditionType.Book
};
var dostoevskiyBook2 = new PrintingEdition()
{
CreationData = DateTime.Parse("24 05 1678"),
Currency = Entities.Enums.Currency.USD,
Description = "Better then LSD",
Name = "Karamazow brothers",
Price = 44,
IsRemoved = false,
Type = Entities.Enums.EditionType.Book
};
var dostoevskyiBooks = new List <PrintingEdition>();
dostoevskyiBooks.Add(dostoevskyiBook1);
dostoevskyiBooks.Add(dostoevskiyBook2);
_bookStoreContext.PrintingEditions.Add(dostoevskyiBook1);
_bookStoreContext.PrintingEditions.Add(dostoevskiyBook2);
var dostoevskyy = new Author()
{
Name = "Dostoevskyi", IsRemoved = false, PrintingEditions = dostoevskyiBooks
};
_bookStoreContext.Authors.Add(dostoevskyy);
}
_bookStoreContext.SaveChanges();
}
public async Task <IEnumerable <PrintingEditionViewModel> > GetAllPrintingEditions()
{
IEnumerable <AuthorInPrintingEditions> authorsInPriningEditions = _authorInPrintingEditionRepository.GetWithInclude();
var modelsList = new List <PrintingEditionViewModel>();
foreach (AuthorInPrintingEditions authInPrintingEdition in authorsInPriningEditions)
{
PrintingEdition printingEdition = await _printingEditionRepository.Get(authInPrintingEdition.PrintingEditionId);
modelsList.Add(_mapper.Map <PrintingEditionViewModel>(printingEdition));
}
return(modelsList);
}
public static PrintingEditionsModelItem MapEntityToModel(PrintingEdition edition)
{
var result = new PrintingEditionsModelItem()
{
Currency = (BusinessEnums.Currency)edition.Currency,
Description = edition.Description,
Id = edition.Id,
Price = edition.Price,
Status = (BusinessEnums.StatusType)edition.Status,
Title = edition.Title,
ProductType = (BusinessEnums.ProductType)edition.Type
};
return(result);
}
public async Task <IEnumerable <PrintingEditionViewModel> > GetAuthorPrintingEditions(int authorId, string currentCurrencyName)
{
IEnumerable <AuthorInPrintingEditions> authorsInPriningEditions = _authorInPrintingEditionRepository.FindByAuthor(authorId);
var modelsList = new List <PrintingEditionViewModel>();
foreach (AuthorInPrintingEditions authInPrintingEdition in authorsInPriningEditions)
{
PrintingEdition printingEdition = await _printingEditionRepository.Get(authInPrintingEdition.PrintingEditionId);
modelsList.Add(_mapper.Map <PrintingEditionViewModel>(printingEdition));
}
;
return(modelsList);
}
internal PrintingEditionModel(PrintingEdition printingEdition)
{
Name = printingEdition.Name;
Type = printingEdition.Type;
Price = printingEdition.Price;
Currency = printingEdition.Currency;
Status = printingEdition.Status;
Description = printingEdition.Description;
Id = printingEdition.Id;
}
public async Task <IEnumerable <AuthorViewModel> > GetPritningEditionAuthors(int id)
{
PrintingEdition printingEdition = await _printEditRepository.Get(id);
IEnumerable <AuthorInPrintingEditions> authors = _authorInPrintingEditionRepository.FindByPrintingEditionID(printingEdition.Id);
var modelsList = new List <AuthorViewModel>();
foreach (AuthorInPrintingEditions author in authors)
{
AuthorViewModel model = _mapper.Map <AuthorViewModel>(author);
modelsList.Add(model);
}
;
return(modelsList);
}
public static PrintingEdition MapModelToEntity(PrintingEditionsModelItem model, decimal changedPrice)
{
var result = new PrintingEdition()
{
CreationDate = DateTime.Now,
Currency = DataEnums.Currency.USD,
Description = model.Description,
Id = model.Id,
Price = changedPrice,
Status = (DataEnums.StatusType)model.Status,
Title = model.Title,
Type = (DataEnums.ProductType)model.ProductType
};
return(result);
}
public async Task <BaseResponseModel> DeleteAsync(Guid id)
{
BaseResponseModel report = new BaseResponseModel();
IPrintingEditionsRepository printingEditionsRepository = new PrintingEditionsRepository(_context);
PrintingEdition printingEdition = await _context.PrintingEditions.FindAsync(id);
if (printingEdition == null)
{
report.Message.Add(_publicationNotFoundMsg);
return(report);
}
printingEdition.IsRemoved = true;
report.Message.Add(await printingEditionsRepository.DeleteAsync(printingEdition));
return(report);
}
private async Task <BaseModel> CreateAuthorInProductAsync(PrintingEdition product, ICollection <AuthorsModelItem> authors)
{
var response = new BaseModel();
var authorsInProduct = new List <AuthorInPrintingEdition>();
foreach (var item in authors)
{
var authorInProduct = AuthorInProductMapper.MapToAuthorInProduct(product, item.Id);
authorsInProduct.Add(authorInProduct);
}
var result = await _authorInPrintingEditionsRepository.CreateRangeAsync(authorsInProduct);
if (!result)
{
response.Errors.Add(ErrorConstants.ImpossibleToAddAuthorToProduct);
}
return(response);
}
private async Task <BaseModel> DeleteAuthorInProductAsync(PrintingEdition product)
{
var response = new BaseModel();
var authorInProduct = await _authorInPrintingEditionsRepository.GetAsyncByProductId(product.Id);
if (authorInProduct == null)
{
response.Errors.Add(ErrorConstants.ImpossibleToFindProduct);
return(response);
}
var result = await _authorInPrintingEditionsRepository.DeleteRangeAsync(authorInProduct);
if (!result)
{
response.Errors.Add(ErrorConstants.ImpossibleToAddAuthorToProduct);
}
return(response);
}
private async Task <BaseModel> UpdateAuthorInProductAsync(PrintingEdition product, ICollection <AuthorsModelItem> authors)
{
var response = new BaseModel();
var result = await DeleteAuthorInProductAsync(product);
if (result.Errors.Any())
{
response.Errors.Add(ErrorConstants.ImpossibleToUpdateProduct);
return(response);
}
result = await CreateAuthorInProductAsync(product, authors);
if (result.Errors.Any())
{
response.Errors.Add(ErrorConstants.ImpossibleToUpdateProduct);
}
return(response);
}
public async Task <BaseResponseModel> UpdateAsync(PrintingEditionModel UpdatePrintingEdition)
{
BaseResponseModel report = ValidationPrintingEdition(UpdatePrintingEdition);
IPrintingEditionsRepository printingEditionsRepository = new PrintingEditionsRepository(_context);
PrintingEdition printingEdition = await printingEditionsRepository.GetByIdAsync(UpdatePrintingEdition.Id);
printingEdition.AuthorInPrintingEditions = _authorInPrintingEditionsRepository.GetById(UpdatePrintingEdition.Id);
printingEdition.Cover = _coverRepository.GetById(UpdatePrintingEdition.Id);
if (!report.IsValid)
{
return(report);
}
printingEdition.Id = UpdatePrintingEdition.Id;
printingEdition.Name = UpdatePrintingEdition.Name;
printingEdition.Description = UpdatePrintingEdition.Description;
printingEdition.Price = UpdatePrintingEdition.Price;
printingEdition.Status = UpdatePrintingEdition.Status;
printingEdition.Currency = UpdatePrintingEdition.Currency;
printingEdition.Type = UpdatePrintingEdition.Type;
printingEdition.Cover.Base64Image = UpdatePrintingEdition.Image;
printingEdition.Cover.PrintingEditionId = UpdatePrintingEdition.Id;
printingEdition.Cover.PrintingEdition = printingEdition;
List <AuthorInPrintingEdition> authorInPrintingEditions = new List <AuthorInPrintingEdition>();
foreach (Guid authorId in UpdatePrintingEdition.AuthorId)
{
AuthorInPrintingEdition authorInPrintingEdition = new AuthorInPrintingEdition();
authorInPrintingEdition.Author = await _authorRepository.GetByIdAsync(authorId);
authorInPrintingEditions.Add(authorInPrintingEdition);
}
printingEdition.AuthorInPrintingEditions = authorInPrintingEditions;
await printingEditionsRepository.UpdateAsync(printingEdition);
return(report);
}
public PrintingEdition PrintingEditionMapToEntity()
{
PrintingEdition printingEdition = new PrintingEdition();
printingEdition.Name = this.Name;
printingEdition.Type = this.Type;
printingEdition.Price = this.Price;
printingEdition.Status = this.Status;
printingEdition.Currency = this.Currency;
printingEdition.Description = this.Description;
return(printingEdition);
}
public async Task <BaseResponseModel> CreateAsync(PrintingEditionModel newPrintingEdition)
{
BaseResponseModel report = ValidationPrintingEdition(newPrintingEdition);
PrintingEdition printingEdition = new PrintingEdition();
Cover cover = new Cover();
if (!report.IsValid)
{
return(report);
}
printingEdition.Name = newPrintingEdition.Name;
printingEdition.Description = newPrintingEdition.Description;
printingEdition.Price = newPrintingEdition.Price;
printingEdition.Status = newPrintingEdition.Status;
printingEdition.Type = newPrintingEdition.Type;
printingEdition.Currency = newPrintingEdition.Currency;
printingEdition.IsRemoved = false;
printingEdition.CreationDate = DateTime.Now;
cover.CreationDate = DateTime.Now;
cover.Base64Image = newPrintingEdition.Image;
cover.PrintingEdition = printingEdition;
printingEdition.Cover = cover;
var authorInPrintingEditions = new List <AuthorInPrintingEdition>();
foreach (Guid authorId in newPrintingEdition.AuthorId)
{
var authorInPrintingEdition = new AuthorInPrintingEdition();
authorInPrintingEdition.AuthorId = authorId;
authorInPrintingEditions.Add(authorInPrintingEdition);
}
printingEdition.AuthorInPrintingEditions = authorInPrintingEditions;
await _printingEditionsRepository.CreateAsync(printingEdition);
report.Message.Add(_publicationAddedMsg);
return(report);
}
public void InitializationPrintingEdition()
{
long amountPrintingEdition = _applicationContext.PrintingEditions.Count();
if (amountPrintingEdition > 0)
{
return;
}
PrintingEdition printingEdition = new PrintingEdition
{
Title = "Title5",
Description = "Description",
Price = 40,
Status = "Status",
Currency = "Currency",
Type = "Type"
};
_applicationContext.PrintingEditions.Add(printingEdition);
_applicationContext.SaveChanges();
}
public async Task CreatePrintingEdition(AuthorsInPrintingEditionsViewModel model)
{
PrintingEdition printingEdition = _mapper.Map <PrintingEdition>(model);
var authors = new List <Author>();
var authorsInPrintEdit = new List <AuthorInPrintingEditions>();
await _printEditRepository.Create(printingEdition);
foreach (AuthorViewModel authorId in model.AuthorsList)
{
authors.Add(await _authorRepository.Get(authorId.Id));
}
foreach (Author author in authors)
{
authorsInPrintEdit.Add(new AuthorInPrintingEditions {
AuthorId = author.Id, PrintingEditionId = printingEdition.Id
});
}
_authorInPrintingEditionRepository.AddAuthorInPe(authorsInPrintEdit);
}
private void InitPrintingEditions()
{
if (_dbContext.PrintingEditions.Any())
{
return;
}
var book = new PrintingEdition
{
Currency = CurrencyType.USD,
IsRemoved = false,
Title = "Book Title",
Description = "Book Description",
Price = 20,
Type = PrintingEditionType.Book
};
var magazine = new PrintingEdition
{
Currency = CurrencyType.USD,
IsRemoved = false,
Title = "Magazine Title",
Description = "Magazine Description",
Price = 20,
Type = PrintingEditionType.Magazine
};
var newspaper = new PrintingEdition
{
Currency = CurrencyType.USD,
IsRemoved = false,
Title = "Newspaper Title",
Description = "Newspaper Description",
Price = 20,
Type = PrintingEditionType.Newspaper
};
_dbContext.Add(book);
_dbContext.Add(magazine);
_dbContext.Add(newspaper);
_dbContext.SaveChanges();
}
public async Task <PrintingEditionModel> GetByIdAsync(Guid id)
{
IPrintingEditionsRepository printingEditionsRepository = new PrintingEditionsRepository(_context);
PrintingEdition printingEdition = await printingEditionsRepository.GetByIdAsync(id);
Cover cover = _coverRepository.GetById(printingEdition.Id);
PrintingEditionModel printingEditionModel = new PrintingEditionModel();
printingEditionModel.Id = printingEdition.Id;
printingEditionModel.Name = printingEdition.Name;
printingEditionModel.Description = printingEdition.Description;
printingEditionModel.Type = printingEdition.Type;
printingEditionModel.Currency = printingEdition.Currency;
printingEditionModel.Price = printingEdition.Price;
printingEditionModel.Status = printingEdition.Status;
printingEditionModel.AuthorId = _authorInPrintingEditionsRepository.GetAuthors(printingEdition.Id);
printingEditionModel.Image = cover.Base64Image;
printingEditionModel.AuthorName = _authorInPrintingEditionsRepository.GetAuthorsName(printingEditionModel.AuthorId);
return(printingEditionModel);
}
public async Task <BaseModel> CreateAsync(PrintingEditionModelItem printingEditionModel)
{
var printingEdition = new PrintingEdition();
printingEdition = printingEditionModel.MapToEntity(printingEdition);
var printingEditionId = await _printingEditionRepository.CreateAsync(printingEdition);
if (printingEditionId == 0)
{
printingEditionModel.Errors.Add(Constants.Errors.CreatePrintingEditionError);
return(printingEditionModel);
}
var authorInPrintingEditions = printingEditionModel.Authors.MapToAuthorInPrintingEditionList(printingEditionId).ToList();
var result = await _authorInPrintingEditionRepository.CreateListAsync(authorInPrintingEditions);
if (!result && authorInPrintingEditions.Count > 0)
{
printingEditionModel.Errors.Add(Constants.Errors.CreatePrintingEditionError);
}
return(printingEditionModel);
}
