コード例 #1
0
        public async Task FindBanknotes_ReturnsAllBanknotes()
        {
            //Act
            var result = await _banknoteService.FindBanknotes(resourceParameters);

            //Assert
            Assert.NotNull(result);
            Assert.Equal(6, result.Count());
        }
        public BanknoteManipulationDtoValidator(IBanknoteService service, IEqualityComparer <Currency> comparer, IMapper mapper)
        {
            _service  = service;
            _comparer = comparer;
            _mapper   = mapper;

            var banknotes = _service.FindBanknotes(new CurrenciesResourceParameters()).Result;

            RuleFor(b => b)
            .IsDuplicate(banknotes, _comparer, _mapper, "Banknote must be unique");

            RuleFor(b => b.FaceValue)
            .NotEmpty().WithMessage("Face value is a required field");

            RuleFor(b => b.Type)
            .NotEmpty().WithMessage("Type is a required field")
            .MaximumLength(100).WithMessage("Type shouldn't contain more than 100 characters");

            RuleFor(b => b.ReleaseDate)
            .NotEmpty().WithMessage("ReleaseDate is a required field")
            .MaximumLength(100).WithMessage("ReleaseDate shouldn't contain more than 100 characters");

            RuleFor(b => b.CountryId)
            .NotEmpty().WithMessage("CountryId is a required field");

            RuleFor(b => b.Color)
            .MaximumLength(250).WithMessage("Color shouldn't contain more than 250 characters");

            RuleFor(b => b.Watermark)
            .MaximumLength(100).WithMessage("Watermark shouldn't contain more than 100 characters");

            RuleFor(b => b.Signature)
            .MaximumLength(250).WithMessage("Signature shouldn't contain more than 250 characters");

            RuleFor(b => b.ObverseDescription)
            .MaximumLength(250).WithMessage("ObverseDescription shouldn't contain more than 250 characters");

            RuleFor(b => b.ReverseDescription)
            .MaximumLength(250).WithMessage("ReverseDescription shouldn't contain more than 250 characters");

            RuleFor(b => b.Designer)
            .MaximumLength(250).WithMessage("Designer shouldn't contain more than 250 characters");

            RuleFor(b => b.HeadOfState)
            .MaximumLength(250).WithMessage("HeadOfState shouldn't contain more than 250 characters");

            RuleFor(b => b.FrontImagePath)
            .MaximumLength(250).WithMessage("FrontImagePath shouldn't contain more than 250 characters");

            RuleFor(b => b.BackImagePath)
            .MaximumLength(250).WithMessage("BackImagePath shouldn't contain more than 250 characters");
        }
コード例 #3
0
        public async Task <IActionResult> GetBanknotes(CurrenciesResourceParameters resourceParameters,
                                                       [FromHeader(Name = "Accept")] string mediaType)
        {
            if (!PropertyMappingService.ValidMappingExistsFor <Banknote>(resourceParameters.OrderBy))
            {
                return(BadRequest());
            }

            if (!TypeHelper.TypeHasProperties <BanknoteDto>(resourceParameters.Fields))
            {
                return(BadRequest());
            }

            var retrievedBanknotes = await _banknoteService.FindBanknotes(resourceParameters);

            var banknotes       = _mapper.Map <IEnumerable <BanknoteDto> >(retrievedBanknotes);
            var shapedBanknotes = banknotes.ShapeData(resourceParameters.Fields);

            if (mediaType == "application/json+hateoas")
            {
                if (!string.IsNullOrEmpty(resourceParameters.Fields) &&
                    !resourceParameters.Fields.ToLowerInvariant().Contains("id"))
                {
                    return(BadRequest("Field parameter 'id' is required"));
                }

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

                Response.Headers.Add("X-Pagination",
                                     JsonConvert.SerializeObject(paginationMetadata));

                var links = CreateBanknotesLinks(resourceParameters,
                                                 retrievedBanknotes.HasNext, retrievedBanknotes.HasPrevious);

                var linkedBanknotes = shapedBanknotes.Select(banknote =>
                {
                    var banknoteAsDictionary = banknote as IDictionary <string, object>;
                    var banknoteLinks        = CreateBanknoteLinks((Guid)banknoteAsDictionary["Id"],
                                                                   resourceParameters.Fields);

                    banknoteAsDictionary.Add("links", banknoteLinks);

                    return(banknoteAsDictionary);
                });

                var linkedCollectionResource = new LinkedCollectionResource
                {
                    Value = linkedBanknotes,
                    Links = links
                };

                return(Ok(linkedCollectionResource));
            }
            else
            {
                var previousPageLink = retrievedBanknotes.HasPrevious ?
                                       CreateBanknotesResourceUri(resourceParameters,
                                                                  ResourceUriType.PreviousPage) : null;

                var nextPageLink = retrievedBanknotes.HasNext ?
                                   CreateBanknotesResourceUri(resourceParameters,
                                                              ResourceUriType.NextPage) : null;

                var paginationMetadata = new
                {
                    totalCount  = retrievedBanknotes.TotalCount,
                    pageSize    = retrievedBanknotes.PageSize,
                    currentPage = retrievedBanknotes.CurrentPage,
                    totalPages  = retrievedBanknotes.TotalPages,
                    previousPageLink,
                    nextPageLink,
                };

                Response.Headers.Add("X-Pagination",
                                     JsonConvert.SerializeObject(paginationMetadata));

                return(Ok(shapedBanknotes));
            }
        }