public async Task <OperationResult> GetAdvetisements(AdQueryOptions queryOptions)
        {
            var ads = await repository.GetQueriedAds(queryOptions);

            var result = mapper.Map <IEnumerable <Advertisement>, IEnumerable <AdvertisementWithoutItemDto> >(ads);

            return(new OperationResult()
            {
                IsSuccessful = true,
                Payload = result
            });
        }
        public async Task <IActionResult> Get([FromQuery] string search, [FromQuery] string sort, [FromQuery] int?page, [FromQuery] int?size, [FromQuery] bool?desc,
                                              [FromQuery] string type, [FromQuery(Name = "genres")] int[] genres, [FromQuery] int?state, [FromQuery] int?region, [FromQuery(Name = "systems")] int[] systems)
        {
            var query = new AdQueryOptions
            {
                Desc     = desc,
                Genres   = genres,
                Page     = page.GetValueOrDefault() > 0 ? page.GetValueOrDefault() - 1 : 0,
                PageSize = size,
                Systems  = systems,
                Region   = region,
                Search   = search,
                Sort     = sort,
                State    = state,
                Type     = type
            };
            var result = await _advertisementService.GetAdvetisements(query);

            return(Ok(result.Payload));
        }
示例#3
0
        public async Task <IEnumerable <Advertisement> > GetQueriedAds(AdQueryOptions options)
        {
            var query = Context.Advertisements.AsQueryable();

            query = query.Where(a => a.IsActive);
            if (options.Systems.Any())
            {
                query = query.Where(a => options.Systems.Contains(a.Item.SystemId));
            }

            if (options.State.HasValue)
            {
                query = query.Where(a => a.Item.StateId == options.State.Value);
            }

            //default sorting
            if (string.IsNullOrEmpty(options.Sort))
            {
                if (options.Desc.HasValue && options.Desc.Value)
                {
                    query = query.OrderByDescending(a => a.DateCreated);
                }
                else
                {
                    query = query.OrderBy(a => a.DateCreated);
                }
            }
            else
            {
                query = query.OrderByPropertyName(options.Sort, !(options.Desc.HasValue && options.Desc.Value));
            }

            if (!string.IsNullOrEmpty(options.Search))
            {
                query = query.Where(a => EF.Functions.ILike(a.Title, "%" + options.Search + "%"));
            }


            if (!string.IsNullOrEmpty(options.Type))
            {
                options.Type = char.ToUpper(options.Type[0]) + options.Type.Substring(1);
                switch (options.Type)
                {
                case nameof(Game):
                {
                    query = query.Where(a => a.Item is Game);
                    if (options.Genres.Any())
                    {
                        query = query.Where(a => options.Genres.Contains(((Game)a.Item).GenreId));
                    }

                    if (options.Region.HasValue)
                    {
                        query = query.Where(a => ((Game)a.Item).GameRegionId == options.Region.Value);
                    }
                    break;
                }

                case nameof(Accessory):
                {
                    query = query.Where(a => a.Item is Accessory);
                    break;
                }

                case nameof(Console):
                {
                    query = query.Where(a => a.Item is Console);
                    if (options.Region.HasValue)
                    {
                        query = query.Where(a => ((Console)a.Item).ConsoleRegionId == options.Region.Value);
                    }
                    break;
                }

                default:
                {
                    throw new ArgumentException("No such category!");
                }
                }
            }

            if (options.Page.HasValue && options.PageSize.HasValue)
            {
                var skip = options.Page.Value * options.PageSize.Value;
                return(await query.Skip(skip).Take(options.PageSize.Value).ToListAsync());
            }

            var result = await query.Include(a => a.Photos).ToListAsync();

            return(result);
        }