public async Task <PageDataContainer <UserDto> > GetUsers(PageArguments pageArguments, string query)
        {
            PageDataContainer <UserDto> pagedUsers = await _userRepository.GetPagedUsers(query, pageArguments);

            if (pagedUsers.PageData.Count > 0)
            {
                return(pagedUsers);
            }

            return(null);
        }
Ejemplo n.º 2
0
        public async Task <PageDataContainer <TownDto> > GetPagedTowns(string filter, PageArguments pageArguments)
        {
            filter = filter?.ToLower() ?? string.Empty;
            PageDataContainer <TownDto> pagedTowns = await _townRepository.GetPagedTows(filter, pageArguments);

            if (pagedTowns.PageData.Count == 0)
            {
                return(null);
            }

            return(pagedTowns);
        }
        public async Task <IActionResult> GetUsers([FromQuery] PageArguments pageArguments, [FromQuery] string filter)
        {
            PageDataContainer <UserDto> pagedUserDtos = await _userService.GetUsers(pageArguments, filter);

            if (pagedUserDtos == null)
            {
                return(NoContent());
            }
            PageDataContainer <UserAuditWebModel> pagedUserAuditModels = _mapper.Map <PageDataContainer <UserAuditWebModel> >(pagedUserDtos);

            return(Ok(pagedUserAuditModels));
        }
Ejemplo n.º 4
0
        public async Task <PageDataContainer <BrandDto> > GetAllBrands(BrandFilterArguments filterArguments,
                                                                       PageArguments pageArguments, SortingArguments sortingArguments)
        {
            PageDataContainer <BrandDto> pagedBrands = await _brandRepo.GetPagedBrands(filterArguments, sortingArguments, pageArguments);

            if (pagedBrands.PageData.Count > 0)
            {
                return(pagedBrands);
            }

            return(null);
        }
Ejemplo n.º 5
0
        public async Task <PageDataContainer <AnnoucementDto> > GetAnnoucements(AnnoucementFilterArguments filterOptions,
                                                                                PageArguments paginateParams, SortingArguments orderParams)
        {
            PageDataContainer <AnnoucementDto> pagedAnnoucements = await _annoucementRepo.GetPagedAnnoucements(filterOptions, paginateParams, orderParams);

            if (pagedAnnoucements.PageData.Count == 0)
            {
                return(null);
            }

            return(pagedAnnoucements);
        }
Ejemplo n.º 6
0
        public async Task <IActionResult> GetAll([FromQuery] AnnoucementFilterArguments filterArgs,
                                                 [FromQuery] PageArguments pageArgs, [FromQuery] SortingArguments sortingArgs)
        {
            PageDataContainer <AnnoucementDto> pagedAnnoucementDtos = await _annoucementService.GetAnnoucements(filterArgs, pageArgs, sortingArgs);

            if (pagedAnnoucementDtos == null)
            {
                return(NoContent());
            }
            PageDataContainer <AnnoucementWebModel> pagedWebAnnoucements = _mapper.Map <PageDataContainer <AnnoucementWebModel> >(pagedAnnoucementDtos);

            return(Ok(pagedWebAnnoucements));
        }
        public async Task <IActionResult> Get([FromQuery] BrandFilterArguments filterArgs,
                                              [FromQuery] PageArguments pageArgs, [FromQuery] SortingArguments sortingArgs)
        {
            PageDataContainer <BrandDto> pagedBrandDtos = await _brandService.GetAllBrands(filterArgs, pageArgs, sortingArgs);

            if (pagedBrandDtos == null)
            {
                return(NoContent());
            }

            PageDataContainer <BrandWebModel> pagedBrandModels = _mapper.Map <PageDataContainer <BrandWebModel> >(pagedBrandDtos);

            return(Ok(pagedBrandModels));
        }
Ejemplo n.º 8
0
        public async Task <PageDataContainer <TownDto> > GetPagedTows(string filter, PageArguments pageArguments)
        {
            var references = new string[0];

            var filters = new List <Expression <Func <Town, bool> > >()
            {
                town => town.Title == filter
            };

            var orderParams = new List <OrderParams <Town> >
            {
                new OrderParams <Town> {
                    OrderBy = (town) => town.Title, Descending = false
                }
            };

            PageDataContainer <Town> pagedTowns = await GetPagedData(references, filters, orderParams, pageArguments);

            return(_mapper.Map <PageDataContainer <TownDto> >(pagedTowns));
        }
        public async Task <PageDataContainer <BrandDto> > GetPagedBrands(BrandFilterArguments filterOptions, SortingArguments sortingArguments, PageArguments pageArguments)
        {
            var filters = new List <Expression <Func <Brand, bool> > >()
            {
                brand => brand.Title.Contains(filterOptions.Title ?? ""),
            };

            var includes = new string[] { "BrandCategories.Category" };

            var orderParameters = new List <OrderParams <Brand> >()
            {
                new OrderParams <Brand> {
                    OrderBy    = (x) => x.Title,
                    Descending = (sortingArguments.Direction == "desc")
                }
            };

            IOrderedQueryable <Brand> query       = GetAllForPaging(includes, filters, orderParameters);
            PageDataContainer <Brand> pagedBrands = await query.GetPageAsync(pageArguments);

            return(_mapper.Map <PageDataContainer <BrandDto> >(pagedBrands));
        }