示例#1
0
        public PagedList <WaterProfile> GetWaterProfiles(WaterProfileResourceParameters waterProfileResourceParameters)
        {
            if (waterProfileResourceParameters == null)
            {
                throw new ArgumentNullException(nameof(waterProfileResourceParameters));
            }

            var collection = _context.WaterProfiles as IQueryable <WaterProfile>;

            collection = collection.Include(wp => wp.Additions);

            if (!string.IsNullOrWhiteSpace(waterProfileResourceParameters.SearchQuery))
            {
                var searchQuery = waterProfileResourceParameters.SearchQuery.Trim();

                collection = collection.Where(r => r.Name.Contains(searchQuery) ||
                                              r.Description.Contains(searchQuery));
            }

            if (!string.IsNullOrWhiteSpace(waterProfileResourceParameters.OrderBy))
            {
                var waterProfilePropertyMappingDictionary =
                    _propertyMappingService.GetPropertyMapping <Models.WaterProfileDto, WaterProfile>();

                collection = collection.ApplySort(waterProfileResourceParameters.OrderBy,
                                                  waterProfilePropertyMappingDictionary);
            }

            return(PagedList <WaterProfile> .Create(collection,
                                                    waterProfileResourceParameters.PageNumber,
                                                    waterProfileResourceParameters.PageSize));
        }
        private string CreateWaterProfilesResourceUri(
            WaterProfileResourceParameters waterProfileResourceParameters,
            ETypeOfResourceUri type)
        {
            switch (type)
            {
            case ETypeOfResourceUri.PreviousPage:
                return(Url.Link("GetWaterProfiles", new
                {
                    orderBy = waterProfileResourceParameters.OrderBy,
                    pageNumber = waterProfileResourceParameters.PageNumber - 1,
                    pageSize = waterProfileResourceParameters.PageSize,
                    searchQuery = waterProfileResourceParameters.SearchQuery
                }));

            case ETypeOfResourceUri.NextPage:
                return(Url.Link("GetWaterProfiles", new
                {
                    orderBy = waterProfileResourceParameters.OrderBy,
                    pageNumber = waterProfileResourceParameters.PageNumber + 1,
                    pageSize = waterProfileResourceParameters.PageSize,
                    searchQuery = waterProfileResourceParameters.SearchQuery
                }));

            case ETypeOfResourceUri.Current:
            default:
                return(Url.Link("GetWaterProfiles", new
                {
                    orderBy = waterProfileResourceParameters.OrderBy,
                    pageNumber = waterProfileResourceParameters.PageNumber,
                    pageSize = waterProfileResourceParameters.PageSize,
                    searchQuery = waterProfileResourceParameters.SearchQuery
                }));
            }
        }
        private IEnumerable <LinkDto> CreateLinksForWaterProfiles(
            WaterProfileResourceParameters waterProfileResourceParameters,
            bool hasNext,
            bool hasPrevious)
        {
            var links = new List <LinkDto>();

            links.Add(
                new LinkDto(CreateWaterProfilesResourceUri(
                                waterProfileResourceParameters, ETypeOfResourceUri.Current),
                            this.SELF,
                            this.GET));

            if (hasNext)
            {
                links.Add(
                    new LinkDto(CreateWaterProfilesResourceUri(
                                    waterProfileResourceParameters, ETypeOfResourceUri.NextPage),
                                this.NEXT_PAGE,
                                this.GET));
            }

            if (hasPrevious)
            {
                links.Add(
                    new LinkDto(CreateWaterProfilesResourceUri(
                                    waterProfileResourceParameters, ETypeOfResourceUri.PreviousPage),
                                this.PREVIOUS_PAGE,
                                this.GET));
            }

            return(links);
        }
        public ActionResult <IEnumerable <WaterProfileDto> > GetWaterProfiles(
            [FromQuery] WaterProfileResourceParameters waterProfileResourceParameters,
            [FromHeader(Name = ExtendedControllerBase.ACCEPT)] string mediaTypes)
        {
            if (!_propertyMappingService.ValidMappingExistsFor <WaterProfileDto, Entities.WaterProfile>
                    (waterProfileResourceParameters.OrderBy))
            {
                return(BadRequest());
            }

            var splitMediaTypes = mediaTypes.Split(',');

            if (!MediaTypeHeaderValue.TryParseList(splitMediaTypes,
                                                   out IList <MediaTypeHeaderValue> parsedMediaTypes))
            {
                return(BadRequest());
            }

            var waterProfiles = _homeBrewRepository.GetWaterProfiles(waterProfileResourceParameters);

            var paginationMetaData = new
            {
                totalCount  = waterProfiles.TotalCount,
                pageSize    = waterProfiles.PageSize,
                currentPage = waterProfiles.CurrentPage,
                totalPages  = waterProfiles.TotalPages
            };

            Response.Headers.Add(this.PAGINATION_HEADER,
                                 JsonSerializer.Serialize(paginationMetaData));

            var shapedWaterProfiles = _mapper.Map <IEnumerable <WaterProfileDto> >(waterProfiles).
                                      ShapeData(null);

            if (parsedMediaTypes.Any(pmt => pmt.SubTypeWithoutSuffix.EndsWith(this.HATEOAS, StringComparison.InvariantCultureIgnoreCase)))
            {
                var links = CreateLinksForWaterProfiles(waterProfileResourceParameters,
                                                        waterProfiles.HasNext,
                                                        waterProfiles.HasPrevious);

                var shapedWaterProfilesWithLinks = shapedWaterProfiles.Select(waterProfile =>
                {
                    var waterProfileAsDictionary = waterProfile as IDictionary <string, object>;
                    var waterProfileLinks        = CreateLinksForWaterProfile((int)waterProfileAsDictionary["Id"], false);
                    waterProfileAsDictionary.Add(this.LINKS, links);
                    return(waterProfileAsDictionary);
                });

                var linkedCollectionResource = new
                {
                    value = shapedWaterProfilesWithLinks,
                    links
                };

                return(Ok(linkedCollectionResource));
            }

            return(Ok(shapedWaterProfiles));
        }