コード例 #1
0
        private IEnumerable <LinkDto> CreateLinksForTastingNotes(
            TastingNotesResourceParameters tastingNotesResourceParameters,
            bool hasNext,
            bool hasPrevious)
        {
            var links = new List <LinkDto>();

            links.Add(
                new LinkDto(CreateTastingNotesResourceUri(
                                tastingNotesResourceParameters, ETypeOfResourceUri.Current),
                            this.SELF,
                            this.GET));

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

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

            return(links);
        }
コード例 #2
0
        private string CreateTastingNotesResourceUri(
            TastingNotesResourceParameters tastingNotesResourceParameters,
            ETypeOfResourceUri type)
        {
            var linkProps = new ExpandoObject() as IDictionary <string, Object>;

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

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

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

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

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

                return(Url.Link("GetTastingNotes", linkProps));
            }
        }
コード例 #3
0
        public PagedList <TastingNote> GetTastingNotes(TastingNotesResourceParameters tastingNotesResourceParameters)
        {
            if (tastingNotesResourceParameters == null)
            {
                throw new ArgumentNullException(nameof(tastingNotesResourceParameters));
            }

            var collection = _context.TastingNotes as IQueryable <TastingNote>;

            if (tastingNotesResourceParameters.BrewId != TastingNotesResourceParameters.INVALID_BREW_ID)
            {
                collection = collection.Where(tn => tn.BrewID == tastingNotesResourceParameters.BrewId);
            }

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

                collection = collection.Where(b => b.Note.Contains(searchQuery));
            }

            if (!string.IsNullOrWhiteSpace(tastingNotesResourceParameters.OrderBy))
            {
                var tastingNotePropertyMappingDictionary =
                    _propertyMappingService.GetPropertyMapping <Models.TastingNoteDto, TastingNote>();

                collection = collection.ApplySort(tastingNotesResourceParameters.OrderBy,
                                                  tastingNotePropertyMappingDictionary);
            }

            return(PagedList <TastingNote> .Create(collection,
                                                   tastingNotesResourceParameters.PageNumber,
                                                   tastingNotesResourceParameters.PageSize));
        }
コード例 #4
0
        public ActionResult <IEnumerable <TastingNoteDto> > GetTastingNotes(
            int brewId,
            [FromQuery] TastingNotesResourceParameters tastingNotesResourceParameters,
            [FromHeader(Name = ExtendedControllerBase.ACCEPT)] string mediaTypes)
        {
            if (!_propertyMappingService.ValidMappingExistsFor <TastingNoteDto, Entities.TastingNote>
                    (tastingNotesResourceParameters.OrderBy))
            {
                return(BadRequest());
            }

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

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

            tastingNotesResourceParameters.BrewId = brewId;
            var tastingNotes = _homebrewRepository.GetTastingNotes(tastingNotesResourceParameters);

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

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

            var shapedTastingNotes = _mapper.Map <IEnumerable <TastingNoteDto> >(tastingNotes)
                                     .ShapeData(null);

            if (parsedMediaTypes.Any(pmt => pmt.SubTypeWithoutSuffix.EndsWith(this.HATEOAS, StringComparison.InvariantCultureIgnoreCase)))
            {
                var links = CreateLinksForTastingNotes(tastingNotesResourceParameters,
                                                       tastingNotes.HasNext,
                                                       tastingNotes.HasPrevious);

                var shapedTastingNotesWithLinks = shapedTastingNotes.Select(tastingNote =>
                {
                    var tastingNoteAsDictionary = tastingNote as IDictionary <string, object>;
                    var tastingNoteLinks        = CreateLinksForTastingNote(brewId, (int)tastingNoteAsDictionary["Id"]);
                    tastingNoteAsDictionary.Add(this.LINKS, tastingNoteLinks);
                    return(tastingNoteAsDictionary);
                });

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

                return(Ok(linkedCollectionResource));
            }

            return(Ok(shapedTastingNotes));
        }