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 PrintingEditionsInfoModel GetInfo(PrintingEditionFilterModel printingEditionFilter = null, int pageSize = Constants.PRINTINGEDITIONPAGESIZE)
{
int dbPrintingEditionsCount = _printingEditionRepository.GetCount(printingEditionFilter);
int pageCount = (int)Math.Ceiling(dbPrintingEditionsCount / (double)pageSize);
var filter = new PrintingEditionFilterModel
{
Title = printingEditionFilter.Title,
Type = printingEditionFilter.Type
};
var dbPrintingEditions = _printingEditionRepository.GetAll(filter).ToList();
decimal min = default;
decimal max = default;
if (dbPrintingEditions.Any())
{
min = dbPrintingEditions.Aggregate((currentMin, x) => (currentMin == null || x.Price < currentMin.Price ? x : currentMin)).Price;
max = dbPrintingEditions.Aggregate((currentMax, x) => (currentMax == null || x.Price > currentMax.Price ? x : currentMax)).Price;
}
return(new PrintingEditionsInfoModel
{
MaxPrice = max,
MinPrice = min,
PageCount = pageCount
});
}
public async Task <DataModel <PrintingEdition> > GetAllPrintingEditions(PrintingEditionFilterModel filterModel)
{
var list = new DataModel <PrintingEdition>();
list.Items = GetAll(filterModel, out int counter);
list.Counter = counter;
return(list);
}
public PrintingEditionModel GetPrintingEditionByTitle(string title)
{
var editionFilter = new PrintingEditionFilterModel {
Title = title
};
var edition = _printingEditionRepository.GetOne(editionFilter);
var result = _mapper.Map <PrintingEditionModel>(edition);
return(result);
}
public int GetPageCount(bool isBook = true, bool isNewspaper = true, bool isJournal = true)
{
var filter = new PrintingEditionFilterModel
{
IsBook = isBook,
IsJournal = isJournal,
IsNewspaper = isNewspaper
};
int dbPrintingEditionsCount = _printingEditionRepository.GetCount(filter);
int pageCount = (int)Math.Ceiling(dbPrintingEditionsCount / (double)Constants.ADMINPRINTINGEDITIONPAGESIZE);
return(pageCount);
}
public int GetCount(PrintingEditionFilterModel printingEditionFilter = null, bool getRemoved = false)
{
Expression <Func <PrintingEditionEntity, bool> > filter = null;
if (printingEditionFilter is not null)
{
filter = edition => ((printingEditionFilter.IsBook && edition.Type == Enums.PrintingEditionType.Book) ||
(printingEditionFilter.IsNewspaper && edition.Type == Enums.PrintingEditionType.Newspaper) ||
(printingEditionFilter.IsJournal && edition.Type == Enums.PrintingEditionType.Journal)) &&
(string.IsNullOrWhiteSpace(printingEditionFilter.Title) || edition.Title.Contains(printingEditionFilter.Title)) &&
(printingEditionFilter.LowPrice != null || edition.Price >= printingEditionFilter.LowPrice) &&
(printingEditionFilter.HighPrice != null || edition.Price <= printingEditionFilter.HighPrice) &&
(!printingEditionFilter.Type.Any() || printingEditionFilter.Type.Contains(edition.Type)) &&
(!printingEditionFilter.EditionIds.Any() || printingEditionFilter.EditionIds.Contains(edition.Id));
}
return(base.Get(filter, getRemoved: getRemoved).Count());
}
public List <PrintingEditionModel> GetPrintingEditionsAdmin(bool isBook = true, bool isNewspaper = true, bool isJournal = true, string field = Constants.DEFAULTEDITIONSORT, string orderAsc = Constants.DEFAULTSORTORDER, int page = Constants.DEFAULTPAGE, bool getRemoved = false)
{
var filter = new PrintingEditionFilterModel
{
IsBook = isBook,
IsJournal = isJournal,
IsNewspaper = isNewspaper
};
var dbPrintingEditions = _printingEditionRepository.Get(filter, field, orderAsc == Constants.DEFAULTSORTORDER, getRemoved, page, Constants.ADMINPRINTINGEDITIONPAGESIZE).ToList();
var printingEditions = new List <PrintingEditionModel>();
foreach (var printingEdition in dbPrintingEditions)
{
var mappedEdition = _mapper.Map <PrintingEditionModel>(printingEdition);
mappedEdition.Authors = printingEdition.Authors.Select(author => author.Name).ToList();
printingEditions.Add(mappedEdition);
}
return(printingEditions);
}
public PrintingEditionResponseModel GetPrintingEditionsFiltered(PrintingEditionFilterModel printingEditionFilter = null, string field = Constants.DEFAULTEDITIONSORT, bool orderAsc = false, int page = Constants.DEFAULTPAGE, bool getRemoved = false, int pageSize = Constants.PRINTINGEDITIONPAGESIZE)
{
var dbPrintingEditions = _printingEditionRepository.Get(printingEditionFilter, field, orderAsc, getRemoved, page, pageSize).ToList();
var printingEditions = new List <PrintingEditionModel>();
foreach (var printingEdition in dbPrintingEditions)
{
var mappedEdition = _mapper.Map <PrintingEditionModel>(printingEdition);
mappedEdition.Authors = printingEdition.Authors.Select(author => author.Name).ToList();
printingEditions.Add(mappedEdition);
}
var info = GetInfo(printingEditionFilter);
return(new PrintingEditionResponseModel
{
Books = printingEditions,
Info = info
});
}
public List <PrintingEditionEntity> Get(PrintingEditionFilterModel printingEditionFilter = null, string field = null, bool ascending = true, bool getRemoved = false, int page = Constants.DEFAULTPAGE, int pageSize = Constants.PRINTINGEDITIONPAGESIZE)
{
page = page < Constants.DEFAULTPAGE ? Constants.DEFAULTPAGE : page;
Expression <Func <PrintingEditionEntity, bool> > filter = null;
if (printingEditionFilter is not null)
{
filter = edition => ((printingEditionFilter.IsBook && edition.Type == Enums.PrintingEditionType.Book) ||
(printingEditionFilter.IsNewspaper && edition.Type == Enums.PrintingEditionType.Newspaper) ||
(printingEditionFilter.IsJournal && edition.Type == Enums.PrintingEditionType.Journal)) &&
(string.IsNullOrWhiteSpace(printingEditionFilter.Title) || edition.Title.Contains(printingEditionFilter.Title)) &&
(printingEditionFilter.LowPrice != null || edition.Price >= printingEditionFilter.LowPrice) &&
(printingEditionFilter.HighPrice != null || edition.Price <= printingEditionFilter.HighPrice) &&
(!printingEditionFilter.Type.Any() || printingEditionFilter.Type.Contains(edition.Type)) &&
(!printingEditionFilter.EditionIds.Any() || printingEditionFilter.EditionIds.Contains(edition.Id));
}
return(base.Get(filter, field, ascending, getRemoved)
.Skip((page - Constants.DEFAULTPREVIOUSPAGEOFFSET) * pageSize)
.Take(pageSize).ToList());
}
public async Task <DataModel <PrintingEdition> > GetAllPrintingEditions(PrintingEditionFilterModel filterModel)
{
var sql = new StringBuilder($@" SELECT *
FROM (SELECT *
FROM PrintingEditions
WHERE (Price BETWEEN @MinPrice AND @MaxPrice) AND
(IsRemoved = @IsRemoved) AND
(Type IN @Types) AND
(Title LIKE CONCAT('%',@SearchQuery,'%') OR
Id IN (SELECT PrintingEditionId
FROM AuthorInPrintingEdition
WHERE AuthorId IN (SELECT Id
FROM Authors
WHERE Name LIKE CONCAT('%',@SearchQuery,'%'))))
ORDER BY {filterModel.SortProperty.ToString()} { (filterModel.IsAscending ? "ASC" : "DESC") }
OFFSET @Offset ROWS" );
if (filterModel.Quantity > 0)
{
sql.Append(new StringBuilder($@" FETCH NEXT @Quantity ROWS ONLY"));
}
sql.Append(new StringBuilder($@") AS pe
LEFT JOIN AuthorInPrintingEdition AS aipe ON pe.Id = aipe.PrintingEditionId
LEFT JOIN Authors AS a ON aipe.AuthorId = a.Id;"));
var sqlCounter = new StringBuilder($@"SELECT COUNT(*)
FROM (SELECT *
FROM PrintingEditions
WHERE (Price BETWEEN @MinPrice AND @MaxPrice) AND
(IsRemoved = @IsRemoved) AND
(Type IN @Types) AND
(Title LIKE CONCAT('%',@SearchQuery,'%') OR
Id IN (SELECT PrintingEditionId
FROM AuthorInPrintingEdition
WHERE AuthorId IN (SELECT Id
FROM Authors
WHERE Name LIKE CONCAT('%',@SearchQuery,'%'))))) AS pe;" );
sql.Append(sqlCounter);
using (var databaseConnection = new SqlConnection(_connectionString))
{
var parameters = new
{
MinPrice = filterModel.MinPrice,
MaxPrice = filterModel.MaxPrice,
IsRemoved = 0,
Types = filterModel.Types.ToArray(),
SearchQuery = filterModel.SearchQuery,
Offset = filterModel.StartIndex,
Quantity = filterModel.Quantity
};
var queryResult = await databaseConnection.QueryMultipleAsync(sql.ToString(), parameters);
var dataModel = new DataModel <PrintingEdition>();
var printingEditions = queryResult.Read <PrintingEdition, AuthorInPrintingEdition, Author, PrintingEdition>(
(printingEdition, authorInPrintingEdition, author) =>
{
printingEdition.AuthorInPrintingEditions = new List <AuthorInPrintingEdition>();
if (authorInPrintingEdition == null)
{
return(printingEdition);
}
authorInPrintingEdition.Author = author;
authorInPrintingEdition.AuthorId = author.Id;
printingEdition.AuthorInPrintingEditions.Add(authorInPrintingEdition);
return(printingEdition);
},
splitOn: "AuthorId, Id"
);
dataModel.Items = printingEditions.GroupBy(printingEdition =>
new
{
printingEdition.Id,
printingEdition.Title,
printingEdition.Image,
printingEdition.Price,
printingEdition.Type,
printingEdition.Description,
printingEdition.Currency,
printingEdition.Date
}
)
.Select(group => new PrintingEdition
{
Id = group.Key.Id,
Date = group.Key.Date,
Type = group.Key.Type,
Image = group.Key.Image,
Title = group.Key.Title,
Price = group.Key.Price,
Currency = group.Key.Currency,
Description = group.Key.Description,
AuthorInPrintingEditions = group.Select(printingEdition => printingEdition.AuthorInPrintingEditions.FirstOrDefault()).ToList()
});
dataModel.Counter = await queryResult.ReadFirstAsync <int>();
return(dataModel);
}
}
public async Task <PagedResponse <PrintingEditionModel> > GetFilteredPrintingEditionsAsync(PrintingEditionFilterModel model, PaginationFilterModel pagination)
{
if (string.IsNullOrWhiteSpace(model.SortBy) && string.IsNullOrWhiteSpace(model.TypeSort))
{
model.SortBy = Constants.Sort.DefaultSortById;
model.TypeSort = Constants.Sort.DefaultSortByAsc;
}
(IEnumerable <PrintingEdition> printingEditions, int count)printingEditions = await _printingEditionRepository.GetFilteredPrintingEditionsAsync(model, pagination);
var printingEditionModel = _autoMapper.Map <IEnumerable <PrintingEditionModel> >(printingEditions.printingEditions);
if (model.Currency is not null)
{
printingEditionModel.ToList().ForEach(item =>
{
item.Price = _convertCurrency.Convert(item.Price.Value, item.Currency.Value, model.Currency);
item.Currency = (CurrencyType)model.Currency;
});
}
var pagedResponse = new PagedResponse <PrintingEditionModel>
{
Data = printingEditionModel,
PageNumber = pagination.PageNumber,
PageSize = pagination.PageSize,
TotalItems = printingEditions.count
};
return(pagedResponse);
}
public async Task <(IEnumerable <PrintingEdition>, int)> GetFilteredPrintingEditionsAsync(PrintingEditionFilterModel model, PaginationFilterModel pagination)
{
using (var connection = CreateConnection())
{
var categories = new StringBuilder();
if (model.Category is not null)
{
foreach (var item in model.Category)
{
categories.Append($"'{(int)item}'");
categories.Append(",");
}
categories.Remove(categories.Length - Constants.Numbers.COUNT_ELEMENT_DELETE, Constants.Numbers.COUNT_ELEMENT_DELETE);
}
if (model.Category is null)
{
categories.Append("''");
}
var sql = new StringBuilder();
sql.Append("SELECT pe.*, author.*");
sql.Append($" FROM PrintingEditions as pe");
sql.Append($" INNER JOIN AuthorInPrintingEditions as auInpe on pe.Id = auInpe.PrintingEditionId");
sql.Append($" INNER JOIN Authors as author on author.Id = auInpe.AuthorId");
sql.Append($" WHERE (('{model.Category}' = '' OR '{model.Category}' = null) OR pe.Type IN ({categories}))");
sql.Append($" AND ((@PrintingEditionName = '' OR @PrintingEditionName = null) OR pe.Title LIKE @PrintingEditionName) ");
sql.Append($" AND ((@MinPrice IS NULL OR @MaxPrice IS NULL ) ");
sql.Append($" OR ((pe.Price >= @MinPrice) AND (pe.Price <= @MaxPrice)) ) ");
sql.Append($" AND ( (@AuthorName = '' OR @AuthorName = null) OR author.Name LIKE @AuthorName )");
var printingEditions = await connection.QueryAsync <PrintingEdition, Author, PrintingEdition>(sql.ToString(),
(printingEdition, author) =>
{
printingEdition.AuthorInPrintingEdition.Add(new AuthorInPrintingEdition {
Author = author
});
return(printingEdition);
},
new
{
PrintingEditionName = $"%{model.PrintingEditionName}%",
MinPrice = model.MinPrice,
MaxPrice = model.MaxPrice,
AuthorName = $"%{model.AuthorName}%"
},
splitOn : "Id");
var groupedAuthors = printingEditions.GroupBy(printingEdition => printingEdition.Id).Select(groupPrintingEdition =>
{
var groupedAuthor = groupPrintingEdition.First();
groupedAuthor.AuthorInPrintingEdition = groupPrintingEdition.Select(printingEdition => printingEdition.AuthorInPrintingEdition.FirstOrDefault()).ToList();
return(groupedAuthor);
});
int countElement = printingEditions.Count();
groupedAuthors = groupedAuthors.Skip((pagination.PageNumber - Constants.Page.PAGE_NUMBER) * pagination.PageSize).Take(pagination.PageSize).ToList();
(IEnumerable <PrintingEdition>, int)tupleResult = (groupedAuthors, countElement);
return(tupleResult);
}
}
public SessionModel CreateCheckoutSession(OrderModel order)
{
_validator.ValidateOrder(order);
bool isExisting = order.Id is not null;
PaymentEntity payment = isExisting ? new PaymentEntity {
Id = order.PaymentId
} : null;
if (!isExisting)
{
order.Status = Enums.OrderStatusType.Unpaid;
order.Date = DateTime.UtcNow;
payment = new PaymentEntity
{
TransactionId = string.Empty
};
_paymentRepository.Insert(payment);
}
var dbOrder = _mapper.Map <OrderEntity>(order);
if (!isExisting)
{
dbOrder.PaymentId = payment.Id;
dbOrder.Total = order.CurrentItems.Sum(item => item.Price);
_orderRepository.Insert(dbOrder);
}
var items = new List <SessionLineItemOptions>();
var editionIds = order.CurrentItems.Select(item => item.PrintingEditionId).ToList();
var editionFilter = new PrintingEditionFilterModel {
EditionIds = editionIds
};
var printingEditions = _printingEditionService.GetPrintingEditionsRange(editionFilter);
var dbItems = _mapper.Map <List <OrderItemEntity> >(order.CurrentItems);
dbItems.ForEach(item => item.OrderId = dbOrder.Id);
foreach (var item in dbItems)
{
var printingEdition = printingEditions.Where(edition => edition.Id == item.PrintingEditionId).FirstOrDefault();
var lineItem = new SessionLineItemOptions
{
PriceData = new SessionLineItemPriceDataOptions
{
UnitAmountDecimal = printingEdition.Price * Constants.CENTMULTIPLIER,
Currency = item.Currency.ToString(),
ProductData = new SessionLineItemPriceDataProductDataOptions
{
Name = printingEdition.Title,
Description = printingEdition.Description
}
},
Quantity = item.Amount
};
items.Add(lineItem);
}
if (!isExisting)
{
_itemRepository.InsertRange(dbItems);
}
string successUrl = new UriBuilder
{
Scheme = _urlConfig.Scheme,
Port = _urlConfig.Port,
Host = _urlConfig.Host,
Path = Constants.STRIPESUCCESSPATH
}.ToString();
string cancelUrl = new UriBuilder
{
Scheme = _urlConfig.Scheme,
Port = _urlConfig.Port,
Host = _urlConfig.Host,
Path = Constants.STRIPECANCELPATH
}.ToString();
var options = new SessionCreateOptions
{
PaymentMethodTypes = new List <string>
{
Constants.DEFAULTPAYMENTMETHOD
},
LineItems = items,
Mode = Constants.DEFAULTPAYMENTMODE,
SuccessUrl = successUrl,
CancelUrl = cancelUrl
};
var service = new SessionService();
Session session = service.Create(options);
payment.TransactionId = session.PaymentIntentId;
_paymentRepository.Update(payment);
return(new SessionModel
{
Id = session.Id,
PaymentIntentId = session.PaymentIntentId
});
}
public async Task <IActionResult> GetAll([FromBody] PrintingEditionFilterModel printingEditionFilter)
{
var printingEditionModel = await _printingEditionService.GetAllAsync(printingEditionFilter);
return(Ok(printingEditionModel));
}
public async Task <(IEnumerable <PrintingEdition>, int)> GetFilteredPrintingEditionsAsync(PrintingEditionFilterModel model, PaginationFilterModel pagination)
{
var result = await _dbSet
.Include(authorInPe => authorInPe.AuthorInPrintingEdition)
.ThenInclude(author => author.Author)
.Where(printingEdition => model.Category == null || model.Category.Contains(printingEdition.Type))
.Where(printingEdition => model.PrintingEditionName == null || EF.Functions.Like(printingEdition.Title, $"%{model.PrintingEditionName}%"))
.Where(printingEdition => (model.MinPrice == null || model.MaxPrice == null) || (printingEdition.Price >= model.MinPrice && printingEdition.Price <= model.MaxPrice))
.Where(printingEdition => model.AuthorName == null || printingEdition.AuthorInPrintingEdition
.Any(author => EF.Functions.Like(author.Author.Name, $"%{model.AuthorName}%")))
.OrderBy($"{model.SortBy} {model.TypeSort}")
.ToListAsync();
int countElement = result.Count();
result = result.Skip((pagination.PageNumber - Constants.Page.PAGE_NUMBER) * pagination.PageSize).Take(pagination.PageSize).ToList();
(IEnumerable <PrintingEdition>, int)tupleResult = (result, countElement);
return(tupleResult);
}
public List <PrintingEditionEntity> GetPrintingEditionsRange(PrintingEditionFilterModel printingEditionFilter = null, bool getRemoved = false)
{
var dbPrintingEditions = _printingEditionRepository.GetAll(printingEditionFilter, getRemoved);
return(dbPrintingEditions.ToList());
}
