예제 #1
0
        private IEnumerable <LinkDto> CreateLinksForBrews(
            BrewsResourceParameters brewsResourceParameters,
            bool hasNext,
            bool hasPrevious)
        {
            var links = new List <LinkDto>();

            links.Add(
                new LinkDto(CreateBrewResourceUri(
                                brewsResourceParameters, ETypeOfResourceUri.Current),
                            this.SELF,
                            this.GET));

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

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

            return(links);
        }
예제 #2
0
        public ActionResult <IEnumerable <BrewWithoutAdditionalInfoDto> > GetBrews(
            [FromQuery] BrewsResourceParameters brewsResourceParameters,
            [FromHeader(Name = ExtendedControllerBase.ACCEPT)] string mediaTypes)
        {
            if (!_propertyMappingService.ValidMappingExistsFor <BrewDto, Entities.Brew>
                    (brewsResourceParameters.OrderBy))
            {
                return(BadRequest());
            }

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

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

            var brews = _homebrewRepository.GetBrews(brewsResourceParameters);

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

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

            var shapedBrews = brewsResourceParameters.IncludeAdditionalInfo ?
                              _mapper.Map <IEnumerable <BrewDto> >(brews).ShapeData(null) :
                              _mapper.Map <IEnumerable <BrewWithoutAdditionalInfoDto> >(brews).ShapeData(null);

            if (parsedMediaTypes.Any(pmt => pmt.SubTypeWithoutSuffix.EndsWith(this.HATEOAS, StringComparison.InvariantCultureIgnoreCase)))
            {
                var links = CreateLinksForBrews(brewsResourceParameters,
                                                brews.HasNext,
                                                brews.HasPrevious);

                var shapedBrewsWithLinks = shapedBrews.Select(brew =>
                {
                    var brewAsDictionary = brew as IDictionary <string, object>;
                    var brewLinks        = CreateLinksForBrew((int)brewAsDictionary["Id"], false);
                    brewAsDictionary.Add(this.LINKS, brewLinks);
                    return(brewAsDictionary);
                });

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

                return(Ok(linkedCollectionResource));
            }

            return(Ok(shapedBrews));
        }
예제 #3
0
        public PagedList <Brew> GetBrews(BrewsResourceParameters brewsResourceParameters)
        {
            if (brewsResourceParameters == null)
            {
                throw new ArgumentNullException(nameof(brewsResourceParameters));
            }

            var collection = _context.Brews as IQueryable <Brew>;

            if (brewsResourceParameters.MinRating > 0)
            {
                collection = collection.Where(b => b.Rating >= brewsResourceParameters.MinRating);
            }

            if (brewsResourceParameters.IncludeAdditionalInfo)
            {
                collection = collection.Include(b => b.TastingNotes)
                             .Include(b => b.Recipe.Steps).ThenInclude(s => s.Ingredients)
                             .Include(b => b.Recipe.Steps).ThenInclude(s => s.Timer)
                             .Include(b => b.Recipe.WaterProfile).ThenInclude(wp => wp.Additions);
            }

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

                collection = collection.Where(b => b.Name.Contains(searchQuery) ||
                                              b.BrewingNotes.Contains(searchQuery) ||
                                              b.TastingNotes.Where(tn => tn.Note.Contains(searchQuery)).Any());
            }

            if (!string.IsNullOrWhiteSpace(brewsResourceParameters.OrderBy))
            {
                var brewPropertyMappingDictionary =
                    _propertyMappingService.GetPropertyMapping <Models.BrewDto, Brew>();

                collection = collection.ApplySort(brewsResourceParameters.OrderBy,
                                                  brewPropertyMappingDictionary);
            }

            return(PagedList <Brew> .Create(collection,
                                            brewsResourceParameters.PageNumber,
                                            brewsResourceParameters.PageSize));
        }
예제 #4
0
        private string CreateBrewResourceUri(
            BrewsResourceParameters brewsResourceParameters,
            ETypeOfResourceUri type)
        {
            var linkProps = new ExpandoObject() as IDictionary <string, Object>;

            if (brewsResourceParameters.MinRating > 0)
            {
                linkProps.Add("minRating", brewsResourceParameters.MinRating);
            }

            switch (type)
            {
            case ETypeOfResourceUri.PreviousPage:
                linkProps.Add("orderBy", brewsResourceParameters.OrderBy);
                linkProps.Add("pageNumber", brewsResourceParameters.PageNumber - 1);
                linkProps.Add("pageSize", brewsResourceParameters.PageSize);
                linkProps.Add("searchQuery", brewsResourceParameters.SearchQuery);

                return(Url.Link("GetBrews", linkProps));

            case ETypeOfResourceUri.NextPage:
                linkProps.Add("orderBy", brewsResourceParameters.OrderBy);
                linkProps.Add("pageNumber", brewsResourceParameters.PageNumber + 1);
                linkProps.Add("pageSize", brewsResourceParameters.PageSize);
                linkProps.Add("searchQuery", brewsResourceParameters.SearchQuery);

                return(Url.Link("GetBrews", linkProps));

            case ETypeOfResourceUri.Current:
            default:
                linkProps.Add("orderBy", brewsResourceParameters.OrderBy);
                linkProps.Add("pageNumber", brewsResourceParameters.PageNumber);
                linkProps.Add("pageSize", brewsResourceParameters.PageSize);
                linkProps.Add("searchQuery", brewsResourceParameters.SearchQuery);

                return(Url.Link("GetBrews", linkProps));
            }
        }