private IEnumerable <Link> CreateLinksForFilteredTransactions(
            LinkedPaginatedResult <LinkedTransactionDto> paginatedResult,
            TransactionFilterDto filterModel)
        {
            var links = new List <Link>
            {
                new Link
                {
                    Href = CreateFilteredTransactionsResourceUrl(
                        ResourceUriType.CurrentPage,
                        filterModel),
                    Rel    = "self",
                    Method = HttpMethod.Get.ToString()
                }
            };

            if (paginatedResult.HasPrevious)
            {
                links.Add(
                    new Link
                {
                    Href = CreateFilteredTransactionsResourceUrl(
                        ResourceUriType.CurrentPage,
                        filterModel),
                    Rel    = "previousPage",
                    Method = HttpMethod.Get.ToString()
                });
            }

            if (paginatedResult.HasNext)
            {
                links.Add(
                    new Link
                {
                    Href = CreateFilteredTransactionsResourceUrl(
                        ResourceUriType.CurrentPage,
                        filterModel),
                    Rel    = "nextPage",
                    Method = HttpMethod.Get.ToString()
                });
            }

            return(links);
        }
        public async Task <IActionResult> GetFilteredAsync([FromQuery] TransactionFilterDto filterModel)
        {
            _logger.LogInformation($"{nameof(TransactionsController)}: {nameof(GetFilteredAsync)} was called with filter model: {JsonSerializer.Serialize(filterModel)}.");

            var filterDomainModel = _mapper.Map <TransactionFilterDomainModel>(filterModel);

            var modelState = _transactionsService.ValidateTransactionFilterModel(filterDomainModel);

            if (!modelState.IsValid)
            {
                return(UnprocessableEntity(modelState));
            }

            var pagedTransactionsDomainModel = await _transactionsService
                                               .GetFilteredTransactions(
                filterDomainModel,
                _currentUserService.AccessKey);

            var pagedTransactionsDto = _mapper.Map <PaginatedResult <TransactionDto> >(pagedTransactionsDomainModel);

            SetPaginationHeaders(pagedTransactionsDomainModel.Metadata);

            if (_mediaTypeService.IsLinkedRepresentation(_mediaType))
            {
                var linkedTransactionsDto = pagedTransactionsDto.Results
                                            .Select(transaction => new LinkedTransactionDto
                {
                    Transaction = transaction,
                    Links       = CreateLinksForTransaction(transaction.TransactionId)
                });

                var linkedPagedTransactionsDto = new LinkedPaginatedResult <LinkedTransactionDto>(linkedTransactionsDto, pagedTransactionsDto.Metadata);

                linkedPagedTransactionsDto.Links =
                    CreateLinksForFilteredTransactions(linkedPagedTransactionsDto, filterModel);

                return(Ok(linkedPagedTransactionsDto));
            }
            else
            {
                return(Ok(pagedTransactionsDto));
            }
        }