public List <Offer> GetOffersByMatching(OfferParams offerParams)
{
var query = offerParams.QueryFilter.Trim().RemoveDiacritics().ToLower();
if (!string.IsNullOrEmpty(query))
{
HashSet <Offer> conj = new HashSet <Offer>();
// Utils.TreatValues(offerParams);
var offers = _context.Offers.Include(off => off.Photos).AsQueryable();
conj = conj.Union(offers.Where(off => off.Advertiser.RemoveDiacritics().Trim().ToLower().Contains(query))).ToHashSet();
conj = conj.Union(offers.Where(off => off.Category.Trim().RemoveDiacritics().ToLower().Contains(query))).ToHashSet();
conj = conj.Union(offers.Where(off => off.Description.Trim().RemoveDiacritics().ToLower().Contains(query))).ToHashSet();
conj = conj.Union(offers.Where(off => off.Title.Trim().RemoveDiacritics().ToLower().Contains(query))).ToHashSet();
conj = conj.Union(offers.Where(off => off.ComoUsar.Trim().RemoveDiacritics().ToLower().Contains(query))).ToHashSet();
conj = conj.Union(offers.Where(off => off.OndeFica.Trim().RemoveDiacritics().ToLower().Contains(query))).ToHashSet();
return(conj.ToList());
}
return(new List <Offer> {
});
}
public IActionResult GetOffersByMatching([FromQuery] OfferParams offerParams)
{
List <Offer> offers = _repo.GetOffersByMatching(offerParams);
List <OfferForReturnDto> offersForReturnDto = _mapper.Map <List <OfferForReturnDto> >(offers);
return(Ok(offersForReturnDto));
}
public async Task <IActionResult> GetFilteredOffers([FromQuery] OfferParams offerParams)
{
List <Offer> offers = await _repo.GetOffersByFiltering(offerParams);
var offersToReturn = _mapper.Map <List <OfferForReturnDto> >(offers);
return(Ok(offersToReturn));
}
public async Task <ActionResult <IEnumerable <Offer> > > OffersFromCategory(OfferCategory offerCategory,
[FromQuery] OfferParams offerParams)
{
var offers = await _unitOfWork.OfferRepository.GetOffersFromCategoryAsync(offerCategory, offerParams);
Response.AddPaginationHeader(offers.CurrentPage, offers.PageSize,
offers.TotalCount, offers.TotalPages);
return(Ok(offers));
}
public async Task <List <Offer> > GetOffersByFiltering(OfferParams offerParams)
{
var offers = _context.Offers.Include(off => off.Photos).AsQueryable();
if (offerParams.OfferId > 0)
{
offers = offers.Where(off => off.Id == offerParams.OfferId);
}
if (!string.IsNullOrEmpty(offerParams.Advertiser))
{
offers = offers.Where(off => off.Advertiser == offerParams.Advertiser);
}
if (!string.IsNullOrEmpty(offerParams.Category))
{
offers = offers.Where(off => off.Category == offerParams.Category);
}
if (!string.IsNullOrEmpty(offerParams.Description))
{
offers = offers.Where(off => off.Description == offerParams.Description);
}
if (!string.IsNullOrEmpty(offerParams.Title))
{
offers = offers.Where(off => off.Title == offerParams.Title);
}
if (!string.IsNullOrEmpty(offerParams.ComoUsar))
{
offers = offers.Where(off => off.ComoUsar == offerParams.ComoUsar);
}
if (!string.IsNullOrEmpty(offerParams.OndeFica))
{
offers = offers.Where(off => off.OndeFica == offerParams.OndeFica);
}
if (offerParams.IsHanked)
{
offers = offers.Where(off => off.IsHanked);
}
return(await offers.ToListAsync());
}
public async Task <PagedList <Offer> > GetOffersFromCategoryAsync(OfferCategory offerCategory,
OfferParams offerParams)
{
var query = _context.Offers
.Where(x => x.OfferCategoryName == offerCategory)
.Include(p => p.Photos)
.AsQueryable();
var order = offerParams.OrderBy;
query = query.Where(x => x.Price >= offerParams.MinPrice && x.Price <= offerParams.MaxPrice);
query = offerParams.OrderBy switch
{
"PriceDesc" => query.OrderByDescending(x => x.Price),
"Price" => query.OrderBy(x => x.Price),
_ => query.OrderBy(x => x.Id)
};
return(await PagedList <Offer> .CreateAsync(query.AsNoTracking(), offerParams.PageNumber, offerParams.PageSize));
}
public async Task <IActionResult> GetAllOffers([FromQuery] OfferParams param)
{
IQueryable <Offer> queryable = _repoWrapper.Offer.Queryable();
if (param.Role == UserParams.ROLE_EMPLOYEE)
{
queryable = queryable.Where(u => u.Publication.UserId.Equals(param.Id) && u.Enabled == true);
}
else if (param.Role == UserParams.ROLE_DISTRIBUTOR)
{
queryable = queryable.Where(d => (d.UserId.Equals(param.Id) && d.Enabled == true));
}
var offers = await PagedList <Offer> .CreateAsync(queryable.OrderByDescending(
c => c.Id), param.PageNumber, param.PageSize);
Response.AddPagination(offers.CurrentPage, offers.PageSize,
offers.TotalCount, offers.TotalPages);
return(Ok(offers.ToList()));
}
public async Task <IActionResult> GetFilteredOffersForUser(int userId,
[FromQuery] OfferParams offerParams)
{
if (userId != int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value))
{
return(Unauthorized());
}
List <Offer> offers = await _repo.GetOffersByFiltering(offerParams);
List <Offer> offersCart = await _repo.GetOffersCart(userId);
foreach (var offer in offersCart)
{
offers.RemoveAll(off => off.Id == offer.Id);
}
var offersToReturn = _mapper.Map <List <OfferForReturnDto> >(offers);
return(Ok(offersToReturn));
}
