public async Task <List <PrintingEditionModel> > GetAllAsync()
{
List <PrintingEdition> printingEditions = _printingEditionsRepository.GetAll();
List <PrintingEditionModel> printingEditionModels = new List <PrintingEditionModel>();
foreach (var printingEdition in printingEditions)
{
PrintingEditionModel printingEditionModel = new PrintingEditionModel();
printingEditionModel.Id = printingEdition.Id;
printingEditionModel.Name = printingEdition.Name;
printingEditionModel.Price = printingEdition.Price;
printingEditionModel.Description = printingEdition.Description;
printingEditionModel.Currency = printingEdition.Currency;
printingEditionModel.Status = printingEdition.Status;
printingEditionModel.Type = printingEdition.Type;
printingEditionModel.AuthorId = printingEdition.AuthorInPrintingEditions.Select(s => s.AuthorId).ToList();
printingEditionModel.AuthorName = new List <string>();
foreach (var authorId in printingEditionModel.AuthorId)
{
Author author = await _authorRepository.GetByIdAsync(authorId);
string s = author.Name;
printingEditionModel.AuthorName.Add(s);
}
printingEditionModels.Add(printingEditionModel);
}
return(printingEditionModels);
}
public async Task <PrintingEditionModel> GetAllAsync(PrintingEditionFilterModel printingEditionFilterModel)
{
var printingEditionModel = new PrintingEditionModel();
var filterModel = printingEditionFilterModel.MapToEFFilterModel();
var listOfPrintingEditions = await _printingEditionRepository.GetAllPrintingEditions(filterModel);
if (listOfPrintingEditions.Items == null)
{
printingEditionModel.Errors.Add(Constants.Errors.NotFoundPrintingEditionsError);
return(printingEditionModel);
}
printingEditionModel.Counter = listOfPrintingEditions.Counter;
foreach (var printingEdition in listOfPrintingEditions.Items)
{
var item = printingEdition.MapToModel();
item.Price = item.Price.ConvertFromUSD(printingEditionFilterModel.Currency);
item.Currency = printingEditionFilterModel.Currency;
printingEditionModel.Items.Add(item);
}
return(printingEditionModel);
}
private BaseResponseModel ValidationPrintingEdition(PrintingEditionModel printingEdition)
{
BaseResponseModel report = new BaseResponseModel();
if (printingEdition == null)
{
report.Message.Add(_sendNullMsg);
}
if (string.IsNullOrEmpty(printingEdition.Name) || string.IsNullOrWhiteSpace(printingEdition.Name))
{
report.Message.Add(_titleOfPublicationMsg);
}
if (printingEdition.Price < 0)
{
report.Message.Add(_negativePriceMsg);
}
if (!Enum.IsDefined(typeof(Status), printingEdition.Status))
{
report.Message.Add(_StatusMsg);
}
if (!Enum.IsDefined(typeof(Currency), printingEdition.Currency))
{
report.Message.Add(_currencyMsg);
}
if (!Enum.IsDefined(typeof(Types), printingEdition.Type))
{
report.Message.Add(_typeMsg);
}
return(report);
}
public async Task <PrintingEditionModel> DeletePrintingEditionAsync(long printingEditionId)
{
var responseModel = new PrintingEditionModel();
var printingEdition = await _printingEditionRepository.GetByIdAsync(printingEditionId);
if (printingEdition == null)
{
responseModel.Errors.Add(Constants.Errors.InvalidData);
return(responseModel);
}
var deleteResult = await _printingEditionRepository.DeleteAsync(printingEdition);
if (deleteResult.Equals(0))
{
responseModel.Errors.Add(Constants.Errors.FailedDelete);
}
var deleteAuthorsInPrintingEdition = await _authorInPrintingEditionRepository.DeletePrintingEditionsById(printingEditionId);
if (deleteAuthorsInPrintingEdition.Equals(0))
{
responseModel.Errors.Add(Constants.Errors.FailedDelete);
}
return(responseModel);
}
public async Task <PrintingEditionModel> UpdatePrintingEditionAsync(PrintingEditionModel model)
{
var printingEdition = await GetPrintingEditionByIdAsync(model.Id);
if (printingEdition is null)
{
throw new ServerException(Constants.Errors.PRINTING_EDITION_NOT_FOUND);
}
if (model.AuthorsId.Any())
{
printingEdition.AuthorInPrintingEdition.Clear();
model.AuthorsId.ForEach(authorId => printingEdition.AuthorInPrintingEdition.Add(new AuthorInPrintingEdition
{
AuthorId = authorId,
PrintingEditionId = model.Id
}));
}
printingEdition.Title = model.Title;
printingEdition.Description = model.Description;
printingEdition.Price = model.Price.Value;
printingEdition.Currency = model.Currency.Value;
printingEdition.Type = model.Type.Value;
await _printingEditionRepository.UpdateAsync(printingEdition);
var printingEditionModel = _autoMapper.Map <PrintingEditionModel>(printingEdition);
return(printingEditionModel);
}
public async Task CreateAsync(PrintingEditionModel model)
{
var editions = await _printingEditionRepository.GetAsync(edition => edition.Description == model.Description);
if (editions.Any())
{
throw new CustomExeption(Constants.Error.EDITION_EXISTS_DB,
StatusCodes.Status400BadRequest);
}
if (!model.AuthorModels.Any())
{
throw new CustomExeption(Constants.Error.EDITION_MUST_HAVE_AUTHOR,
StatusCodes.Status400BadRequest);
}
var allAuthors = await _authorRepository.GetAllAsync();
var autors = allAuthors.Where(a => model.AuthorModels.Exists(p => p.Id == a.Id)).ToList();
if (model.AuthorModels.Count != autors.Count)
{
throw new CustomExeption(Constants.Error.NO_AUTHOR_ID_IN_DB_ADD_AUTHOR_FIRST,
StatusCodes.Status400BadRequest);
}
var printingEdition = _mapper.Map <PrintingEdition>(model);
await _printingEditionRepository.CreateAsync(printingEdition);
}
public void DeletePrintingEdition(PrintingEditionModel printingEdition)
{
var dbPrintingEdition = _printingEditionRepository.GetById(printingEdition.Id);
if (dbPrintingEdition is null)
{
throw new CustomApiException(HttpStatusCode.BadRequest, Constants.PRINTINGEDITIONNOTFOUNDERROR);
}
_printingEditionRepository.Delete(dbPrintingEdition);
}
public PrintingEditionModel ConvertCurrencyToUSD(PrintingEditionModel model)
{
if (model.Currency != CurrencyType.USD)
{
model.Price = _converter.Convert(model.Price, model.Currency, CurrencyType.USD);
model.Currency = CurrencyType.USD;
}
return(model);
}
public async Task RemoveAsync(PrintingEditionModel model)
{
var edition = await _printingEditionRepository.GetAsync(edition => edition.Description == model.Description);
if (!edition.Any())
{
throw new CustomExeption(Constants.Error.EDITION_BY_ID_NOT_FOUND,
StatusCodes.Status400BadRequest);
}
await _printingEditionRepository.RemoveAsync(edition.First());
}
public async Task <PrintingEditionModel> GetPrintingEditionsAsync(PrintingEditionsFilterModel printingEditionsFilterModels)
{
var printingEditions = await _printingEditionRepository.GetPrintingEditionsAsync(printingEditionsFilterModels);
var resultModel = new PrintingEditionModel();
foreach (var printingEdition in printingEditions)
{
resultModel.Items.Add(printingEdition.Mapping());
}
return(resultModel);
}
private PrintingEditionModel ValidateData(PrintingEditionModelItem printingEditionsModelItem)
{
var responseModel = new PrintingEditionModel();
if (string.IsNullOrWhiteSpace(printingEditionsModelItem.Title) || string.IsNullOrWhiteSpace(printingEditionsModelItem.Description) ||
!printingEditionsModelItem.Authors.Any() || printingEditionsModelItem.Price == 0)
{
responseModel.Errors.Add(Constants.Errors.InvalidData);
}
return(responseModel);
}
public async Task AddAsync(PrintingEditionModel model)
{
if (string.IsNullOrEmpty(model.Title))
{
model.Errors.Add(ExceptionsInfo.InvalidTitle);
}
if (string.IsNullOrEmpty(model.Description))
{
model.Errors.Add(ExceptionsInfo.InvalidDescription);
}
if (model.Type == PrintingEditionType.None)
{
model.Errors.Add(ExceptionsInfo.InvalidPrintingEditionType);
}
if (model.Currency == CurrencyType.None)
{
model.Errors.Add(ExceptionsInfo.InvalidCurrencyType);
}
if (model.Price == default)
{
model.Errors.Add(ExceptionsInfo.InvalidPrice);
}
if (model.Authors is null)
{
model.Errors.Add(ExceptionsInfo.InvalidAuthor);
}
if (model.Errors.Any())
{
throw new UserException(HttpStatusCode.BadRequest, model.Errors);
}
model.Price = _exchangeRateProvider.ExchangeToUSD(model.Price, model.Currency);
model.Currency = CurrencyType.USD;
List <Author> authors = await _authorRepository.GetByNamesAsync(model.Authors);
var printingEdition = _printingEditionMapper.Map(model);
await _printingEditionRepository.AddAsync(printingEdition);
var authorInPrintingEditions = authors.Select(item => new AuthorInPrintingEdition
{
AuthorId = item.Id,
PrintingEditionId = printingEdition.Id
}).ToList();
await _authorInPrintingEditionRepository.AddRangeAsync(authorInPrintingEditions);
}
public async Task <PrintingEditionModel> GetByDescriptionAsync(PrintingEditionModel model)
{
var editions = await _printingEditionRepository.GetAsync(pe => pe.Description == model.Description);
if (!editions.Any())
{
throw new CustomExeption(Constants.Error.NO_ANY_EDITIONS_IN_DB_WITH_THIS_CONDITIONS,
StatusCodes.Status400BadRequest);
}
var editionModel = _mapper.Map <PrintingEditionModel>(editions.First());
return(editionModel);
}
public async Task <PrintingEditionModel> CreateAsync(PrintingEditionModel printingEditionModel)
{
var printingEdition = _printingEditionMapper.Map(printingEditionModel);
printingEdition = await _printingEditionRepository.CreateAsync(printingEdition);
if (printingEditionModel.Authors.Any())
{
await AddToAuthorsAsync(printingEdition.Id, printingEditionModel.Authors);
}
printingEditionModel = _printingEditionModelMapper.Map(printingEdition);
return(printingEditionModel);
}
public async Task <PrintingEditionModel> GetPrintingEditionDetailsAsync(long printingEditionId, Enums.Currency currency)
{
var responseModel = new PrintingEditionModel();
var printingEditionData = await _printingEditionRepository.GetPrintingEditionDetailsAsync(printingEditionId);
var printingEdition = printingEditionData.MapToModel(currency);
printingEdition.Price = _currencyConverterHelper.Convert(Enums.Currency.USD, currency, printingEdition.Price);
responseModel.Items.Add(printingEdition);
return(responseModel);
}
public async Task UpdateAsync(PrintingEditionModel model)
{
var edition = await _printingEditionRepository.GetByIdAsync(edition => edition.Id == model.Id);
if (edition is null)
{
throw new CustomExeption(Constants.Error.NO_EDITION_ID_IN_DB,
StatusCodes.Status400BadRequest);
}
edition = _mapper.Map <PrintingEdition>(model);
await _printingEditionRepository.UpdateAsync(edition);
}
public void AddPrintingEdition(PrintingEditionModel printingEdition)
{
_validator.ValidatePrintingEdition(printingEdition);
var dbPrintingEdition = _mapper.Map <PrintingEditionEntity>(printingEdition);
dbPrintingEdition.Status = Enums.PrintingEditionStatusType.InStock;
var authorFilter = new AuthorFilterModel {
EditionAuthors = printingEdition.Authors
};
var authors = _authorRepository.GetAll(authorFilter);
dbPrintingEdition.Authors = new List <AuthorEntity>(authors);
_printingEditionRepository.Insert(dbPrintingEdition);
}
public async Task <PrintingEditionModel> EditAsync(PrintingEditionModel printingEditionModel)
{
var printingEdition = _printingEditionMapper.Map(printingEditionModel);
var result = await _printingEditionRepository.UpdateAsync(printingEdition);
if (result is null)
{
return(null);
}
if (printingEditionModel.Authors != null)
{
await AddToAuthorsAsync(printingEdition.Id, printingEditionModel.Authors);
}
return(printingEditionModel);
}
public async Task <PrintingEditionModel> CreatePrintingEditionAsync(PrintingEditionModel model)
{
var existsPrintingEdition = await _printingEditionRepository.GetPrintingEditionByTitleAsync(model.Title);
if (existsPrintingEdition is not null)
{
throw new ServerException(Constants.Errors.ALREADY_EXISTS);
}
var printingEdition = _autoMapper.Map <PrintingEdition>(model);
await _printingEditionRepository.CreateAsync(printingEdition);
await _authorInPrinting.AddAuthorToPEAsync(model.AuthorsId, printingEdition.Id);
var printingEditionModel = _autoMapper.Map <PrintingEditionModel>(printingEdition);
return(printingEditionModel);
}
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 PrintingEditionModel ResponseModelToModelItem(List<GetAllItemsEditionItemResponseModel> responseModels)
{
var modelItem = new PrintingEditionModel();
/* foreach (GetAllItemsEditionItemResponseModel responseModel in responseModels)
{
)
var modelItem = new PrintingEditionModelItem();
modelItem.Title = responseModel.Title;
modelItem.Description = responseModel.Description;
modelItem.Price = responseModel.Price;
modelItem.Currency = (Currency)responseModel.Currency;
modelItem.Type = (PrintingEditionType)responseModel.Type;
}
return modelItem;
}
*/
return modelItem;
}
public async Task AddPrintingEdition(PrintingEditionModel printingEditionModel)
{
var printingEditionEntity = printingEditionModel.PrintingEditionMapToEntity();
await _printingEditionRepository.Create(printingEditionEntity);
var authors = printingEditionModel.Authors;
foreach (AuthorModel author in authors)
{
Author _author = await _authorRepository.FindByName(author.Name);
if (_author == null)
{
_author = new Author {
Name = author.Name
};
}
await _authorInBookRepository.Create(new AuthorInBook { PrintingEdition = printingEditionEntity, Author = _author });
}
}
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 UpdatePrintingEdition(PrintingEditionModel printingEdition)
{
_validator.ValidatePrintingEdition(printingEdition);
var dbPrintingEdition = _printingEditionRepository.GetById(printingEdition.Id);
if (dbPrintingEdition is null)
{
throw new CustomApiException(HttpStatusCode.BadRequest, Constants.PRINTINGEDITIONNOTFOUNDERROR);
}
_mapper.Map(printingEdition, dbPrintingEdition);
var authorFilter = new AuthorFilterModel {
EditionAuthors = printingEdition.Authors
};
var authors = _authorRepository.GetAll(authorFilter);
dbPrintingEdition.Authors.Clear();
var dbAuthors = dbPrintingEdition.Authors.ToList();
dbAuthors.AddRange(authors);
dbPrintingEdition.Authors = dbAuthors;
_printingEditionRepository.Update(dbPrintingEdition);
}
public void ValidatePrintingEdition(PrintingEditionModel printingEdition)
{
if (string.IsNullOrWhiteSpace(printingEdition.Title))
{
printingEdition.Errors.Add(Constants.INVALIDEMPTYINPUT);
}
if (printingEdition.Price == default)
{
printingEdition.Errors.Add(Constants.INVALIDEMPTYINPUT);
}
if (printingEdition.Currency == default)
{
printingEdition.Errors.Add(Constants.INVALIDEMPTYINPUT);
}
if (printingEdition.Type == default)
{
printingEdition.Errors.Add(Constants.INVALIDEMPTYINPUT);
}
if (printingEdition.Errors.Any())
{
throw new CustomApiException(HttpStatusCode.UnprocessableEntity, Constants.INCORRECTINPUTERROR);
}
}
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 <PrintingEditionModel> GetPrintingEditionsAsync(FilterPrintingEditionModel filter, bool isAdmin)
{
var responseModel = new PrintingEditionModel();
var repositoryFilter = _mapperHelper.Map <FilterPrintingEditionModel, DataFilter.FilterPrintingEditionModel>(filter);
if (repositoryFilter == null)
{
responseModel.Errors.Add(Constants.Errors.OccuredProcessing);
return(responseModel);
}
if (!isAdmin)
{
repositoryFilter.PriceMinValue = _currencyConverterHelper.Convert(repositoryFilter.Currency, Enums.Currency.USD, repositoryFilter.PriceMinValue);
repositoryFilter.PriceMaxValue = _currencyConverterHelper.Convert(repositoryFilter.Currency, Enums.Currency.USD, repositoryFilter.PriceMaxValue);
}
var printingEditionsModel = await _printingEditionRepository.GetPrintingEditionFilteredDataAsync(repositoryFilter, isAdmin);
foreach (var printingEdition in printingEditionsModel.Collection)
{
var modelItem = printingEdition.MapToModel(filter.Currency);
if (!isAdmin)
{
modelItem.Price = _currencyConverterHelper.Convert(Enums.Currency.USD, filter.Currency, modelItem.Price);
}
responseModel.Items.Add(modelItem);
}
responseModel.ItemsCount = printingEditionsModel.CollectionCount;
return(responseModel);
}
public async Task <BaseResponseModel> DeleteAsync([FromBody] PrintingEditionModel printingEdition)
{
BaseResponseModel report = await _service.DeleteAsync(printingEdition.Id);
return(report);
}
public async Task <PrintingEditionModel> GetAsync(Guid Id)
{
PrintingEditionModel printingEdition = await _service.GetByIdAsync(Id);
return(printingEdition);
}
public async Task <BaseResponseModel> UpdateAsync([FromBody] PrintingEditionModel newPrintingEdition)
{
BaseResponseModel report = await _service.UpdateAsync(newPrintingEdition);
return(report);
}
