public void OnActionExecuted(ActionExecutedContext context)
{
if (context.Result is OkObjectResult okResult && okResult.Value is PagedList <Path> pagedList)
{
var helper = context.HttpContext.RequestServices.GetService <PagedListHeadersHelper>();
var nextPageLink = pagedList.HasNext ?
helper.CreatePathResourceUri(pagedList.CurrentPage, pagedList.PageSize, _requestParams, ResourceUriType.NextPage)
: null;
var prevPageLink = pagedList.HasPrevious ?
helper.CreatePathResourceUri(pagedList.CurrentPage, pagedList.PageSize, _requestParams, ResourceUriType.PreviousPage)
: null;
var paginationMetadata = new PaginationMetadata
{
TotalCount = pagedList.TotalCount,
PageSize = pagedList.PageSize,
CurrentPage = pagedList.CurrentPage,
TotalPages = pagedList.TotalPages,
PrevPageLink = prevPageLink,
NextPageLink = nextPageLink
};
var options = new JsonSerializerOptions {
PropertyNamingPolicy = JsonNamingPolicy.CamelCase
};
context.HttpContext.Response.Headers.Add("X-Pagination", JsonSerializer.Serialize(paginationMetadata, options));
}
}
public async Task <IActionResult> GetUncorrelatedEvents([FromQuery] PaginationMetadata pagination,
[FromQuery] EventFilters filter)
{
var result = await _mediator.Send(new GetUncorrelatedEventsRequest(pagination, filter, _authContext));
return(Ok(result));
}
public async Task OnResultExecutionAsync(ResultExecutingContext context, ResultExecutionDelegate next)
{
var result = context.Result as ObjectResult;
if (FiltersHelper.IsResponseSuccesful(result))
{
PaginationModel <TEntity> paginationModel =
await FiltersHelper.GetParameterFromActionAsync <PaginationModel <TEntity> >(context);
IQueryable <TDto> list = result.Value as IQueryable <TDto>;
var dtoPagedList = await list.ToPagedListAsync(paginationModel.PageSize, paginationModel.PageNumber);
/// Doesn't support many pagination methods for a single controller
var paginationMethodInfo = filterConfiguration.ControllerInfoDictionary[context.Controller.GetType()].ControllerActions.Where(t => t.ResourceType == Attributes.ResourceType.Collection).FirstOrDefault();
string mediaType = FiltersHelper.GetValueFromHeader(context, "Accept");
PaginationMetadata paginationMetadata = paginationHelperService.GeneratePaginationMetaData(dtoPagedList, paginationModel, context.Controller.GetType().Name, paginationMethodInfo.ActionName);
if (filterConfiguration.SupportsCustomDataType && mediaType.Equals(filterConfiguration.CustomDataType, StringComparison.CurrentCultureIgnoreCase))
{
var controllerType = context.Controller.GetType();
var dtoPagedListWithExternalLinks = HateoasHelper.CreateLinksForCollectionResource(dtoPagedList, filterConfiguration, paginationMetadata, context.Controller.GetType());
var shapedDtoPagedListWithLinks = new EnvelopCollection <EnvelopDto <TDto> > {
Values = dtoPagedListWithExternalLinks.Values.Select(dto => {
return(HateoasHelper
.CreateLinksForSingleResource(dto, filterConfiguration, linkGenerator, controllerType));
}), Links = dtoPagedListWithExternalLinks.Links
};
result.Value = shapedDtoPagedListWithLinks;
}
else
{
result.Value = dtoPagedList;
}
await next();
}
}
private async Task GetDogs(bool searching = false)
{
StateHasChanged();
if (searching)
{
DogsList = null;
IsLoading = true;
}
Filters.ForcePageNumber =
Pagination == null || searching
? 1
: Filters.PageNumber;
var filters = $"?Name={Filters.Name}&SizeId={Filters.SizeId}&RaceId={Filters.RaceId}&PageNumber={Filters.PageNumber}";
var apiResponse =
await httpClient.GetAsync($"api/Dog{filters}");
var response = await ApiResponse <List <DogDto> > .Create(apiResponse);
DogsList = response.Data;
Pagination = response.PaginationMetadata;
TotalDogs = response.PaginationMetadata.TotalCount;
IsLoading = false;
}
public async Task <TodoPreviewListDto> Handle(GetTodosQuery request, CancellationToken cancellationToken)
{
var todos = todoRepository.GetQueryable();
if (request.Status == TodoStatus.Done)
{
todos = todos.Where(x => x.Status == TodoStatus.Done);
}
if (request.Status == TodoStatus.Todo)
{
todos = todos.Where(x => x.Status == TodoStatus.Todo);
}
if (!string.IsNullOrWhiteSpace(request.Search))
{
todos = todos.Where(x => x.Title.Contains(request.Search) || x.Description.Contains(request.Search));
}
todos = todos.OrderByDescending(x => x.Priority);
var totalCount = await todos.CountAsync();
todos = todos.ApplyPagination(request.PageNumber, request.PageSize);
var todoList = mapper.Map <List <Todo>, List <TodoPreviewDto> >(await todos.ToListAsync());
var paginationMetadata = new PaginationMetadata(request.PageNumber, request.PageSize, totalCount);
return(new TodoPreviewListDto()
{
TodoPreviewDtos = todoList,
PaginationMetadata = paginationMetadata
});
}
public IActionResult GetHateoasUserList(ResourceParameter resourceParameter)
{
var skip = (resourceParameter.PageNumber > 0) ? resourceParameter.PageNumber - 1 : 0;
var userList = Mapper.Map <IEnumerable <UserDto> >(this.usersServices.GetUsersList(skip, resourceParameter.PageSize));
var pagedList = PagedList <UserDto> .Create(
userList,
resourceParameter.PageNumber,
resourceParameter.PageSize);
var previousPageLink = pagedList.HasPrevious
? this.CreateUserResourceUri(resourceParameter, ResourceUriType.PreviousPage)
: null;
var nextPageLink = pagedList.HasNext
? this.CreateUserResourceUri(resourceParameter, ResourceUriType.NextPage)
: null;
var paginationMetadata = new PaginationMetadata(
pagedList.TotalCount,
pagedList.PageSize,
pagedList.CurrentPage,
pagedList.TotalPages,
previousPageLink,
nextPageLink);
// add links on each retrieved user
userList = userList.Select(user => this.CreateLinksForUser(user));
var wrapper = new LinkedCollectionResourceWrapperDto <UserDto>(userList);
return(this.Ok(this.CreateLinksForUser(wrapper)));
}
public void ReturnTwoRowsStartingAtSpecifiedFirstRecordInPageWhenFirstRecordMoreThanTwo()
{
var tableData = new List <List <string> >
{
new List <string> {
"kiwi", "cat", "green"
},
new List <string> {
"grape", "cat", "pink"
},
new List <string> {
"apple", "dog", "blue"
},
new List <string> {
"banana", "dog", "blue"
},
new List <string> {
"cherry", "rat", "yellow"
},
new List <string> {
"tomato", "dog", "blue"
},
new List <string> {
"passion fruit", "dog", "blue"
},
new List <string> {
"plum", "dog", "brown"
},
};
var paginationMetadata = new PaginationMetadata(4, 2);
Paginate.PaginateData(tableData, paginationMetadata).Count().ShouldBe(2);
Paginate.PaginateData(tableData, paginationMetadata).First()[0].ShouldBe("cherry");
}
public IActionResult GetUserList(ResourceParameter resourceParameter)
{
var userList = Mapper.Map <IEnumerable <UserDto> >(this.usersServices.GetUsersList(resourceParameter.PageNumber, resourceParameter.PageSize));
var pagedList = PagedList <UserDto> .Create(
userList,
resourceParameter.PageNumber,
resourceParameter.PageSize);
var previousPageLink = pagedList.HasPrevious
? this.CreateUserResourceUri(resourceParameter, ResourceUriType.PreviousPage)
: null;
var nextPageLink = pagedList.HasNext
? this.CreateUserResourceUri(resourceParameter, ResourceUriType.NextPage)
: null;
var paginationMetadata = new PaginationMetadata(
pagedList.TotalCount,
pagedList.PageSize,
pagedList.CurrentPage,
pagedList.TotalPages,
previousPageLink,
nextPageLink);
this.Response.Headers.Add("X-Pagination", Newtonsoft.Json.JsonConvert.SerializeObject(paginationMetadata));
return(this.Ok(pagedList));
}
public ApiResponse(bool isDone, string message, T data, PaginationMetadata paginationMetadata)
{
IsDone = isDone;
Message = message;
Data = data;
PaginationMetadata = paginationMetadata;
}
public void GetHeaderValuesAssignsMetadataAndPaginationAsNull_WhenNoMetaDataPassedIn()
{
//Arrange
methods.Clear();
ids.Clear();
var pagination = new PaginationMetadata()
{
PageNumber = 2,
PageSize = 2,
TotalRecords = 10
};
var linksHeaderWithoutMetadata = new LinksHeader(null, null, urlHelperMock.Object, "EventsController", null,
null);
var linksHeaderWithMetadata = new LinksHeader(null, pagination, urlHelperMock.Object, "EventsController", null,
null);
//Act
var linksWithoutMetadata = linksHeaderWithoutMetadata.GetHeaderValues();
var linksWithMetadata = linksHeaderWithMetadata.GetHeaderValues();
//Assert
Assert.IsNull(linksWithoutMetadata.Metadata);
Assert.IsNull(linksWithoutMetadata.Links.Pagination);
Assert.IsNotNull(linksWithMetadata.Metadata);
Assert.IsNotNull(linksWithMetadata.Links.Pagination);
urlHelperMock.Verify(foo => foo.Link("EventsController", It.IsAny <object>()), Times.Exactly(2));
Assert.AreEqual(GetProperty(ids[0], "id"), "");
Assert.AreEqual(GetProperty(ids[1], "id"), "");
}
public IActionResult GetAuthors([FromQuery] AuthorsResourceParameters authorsResourceParameters)
{
if (!_propertyMappingService.ValidMappingExistFor <AuthorDto, Author>(authorsResourceParameters.OrderBy) ||
!_propertyCheckerService.TypeHasProperty <AuthorDto>(authorsResourceParameters.Fields))
{
return(BadRequest());
}
var authors = _courseLibraryRepository.GetAuthors(authorsResourceParameters);
var metadata = PaginationMetadata.Create(authors);
Response.Headers.Add("X-Pagination", JsonSerializer.Serialize(metadata));
var links = GetLinksForAuthors(authorsResourceParameters, authors.HasNext, authors.HasPrevious);
var shapedAuthors = _mapper.Map <IEnumerable <AuthorDto> >(authors)
.ShapeData(authorsResourceParameters.Fields);
var shapedAuthorsWithLinks = shapedAuthors.Select(sa =>
{
var shapedAuthor = sa as IDictionary <string, object>;
var authorLinks = GetLinksForAuthor((Guid)shapedAuthor["Id"]);
shapedAuthor.Add("links", authorLinks);
return(shapedAuthor);
});
return(Ok(new { value = shapedAuthorsWithLinks, links }));
}
public void FilterSortPaginateFilters()
{
List <String> headers = SampleHorseData.GetSampleHeaders();
List <List <string> > tableData = SampleHorseData.GetSampleTableData();
List <FilterMetadata> filters = new List <FilterMetadata>
{
new FilterMetadata("Colour", "Bay")
};
SortMetadata sortMetadata = null;
PaginationMetadata paginationMetadata = null;
var expectedTableData = new List <List <string> >
{
new List <string> {
"Thoroughbred", "Bay", "1.66", "3", "true"
},
new List <string> {
"Arabian horse", "Bay", "1.51", "5", "true"
}
};
PaginatedTable table =
Horse.FilterSortPaginateTable(headers, tableData, filters, sortMetadata, paginationMetadata);
table.Headers.ShouldBe(headers);
table.TotalRows.ShouldBe(2);
table.TableData.ShouldBe(expectedTableData);
}
private void SetPaginationHeaders(PaginationMetadata metadata)
{
Response.Headers.Add("X-Paging-PageNumber", metadata.Page.ToString());
Response.Headers.Add("X-Paging-PageSize", metadata.PageSize.ToString());
Response.Headers.Add("X-Paging-PageCount", metadata.TotalPages.ToString());
Response.Headers.Add("X-Paging-TotalRecordCount", metadata.TotalRecordCount.ToString());
}
public LinksHeader CreateLinks(string id, PaginationMetadata pagination, string routeName)
{
var _operationLinks = new OperationLinks()
{
Single = new SingleOperationLinks()
{
Get = _urlHelper.Link(GetSingleRouteName, new { id }),
Post = _urlHelper.Link(PostSingleRouteName, new { })
},
Multiple = new MultipleOperationLinks()
{
Get = _urlHelper.Link(GetMultipleRouteName, new { })
}
};
RelationLinks _relationLinks = null;
if (id != null)
{
_relationLinks = new RelationLinks()
{
Children = new RelatedChildLinks()
{
Events = _urlHelper.Link(EventsController.GetMultipleRouteName, new { incidentId = id })
}
};
}
return(new LinksHeader(null, pagination, _urlHelper, routeName, _operationLinks, _relationLinks));
}
public async Task OnResultExecutionAsync(ResultExecutingContext context, ResultExecutionDelegate next)
{
PaginatedResult result = context.Result as PaginatedResult;
if (FiltersHelper.IsResponseSuccesful(result))
{
PaginationModel paginationModel = await FiltersHelper.GetParameterKnowingBaseTypeFromActionAsync <PaginationModel>(context);
var paginationMethodInfo = filterConfiguration.ControllerInfoDictionary[context.Controller.GetType()].ControllerActions.
Where(t => t.ResourceType == Attributes.ResourceType.Collection).FirstOrDefault();
PaginationMetadata paginationMetadata = paginationHelperService.GeneratePaginationMetaData(
result.PaginationInfo, paginationModel, FiltersHelper.GetControllerName(context), paginationMethodInfo.ActionName);
string mediaType = FiltersHelper.GetValueFromHeader(context, "Accept");
IEnumerable <TDto> pagedList = (IEnumerable <TDto>)result.Value;
if (filterConfiguration.HateoasConfiguration.SupportsCustomDataType && mediaType.Equals(filterConfiguration.HateoasConfiguration.CustomDataType, StringComparison.CurrentCultureIgnoreCase))
{
EnvelopCollection <EnvelopDto <TDto> > pagedListWithLinks = AddInternalAndExternalLinks(context, paginationMetadata, pagedList);
result.Value = pagedListWithLinks;
}
else
{
result.Value = pagedList;
}
await next();
}
}
public static PaginationMetadataValues ToSerializableValues(this PaginationMetadata pagination)
=> new PaginationMetadataValues()
{
PageNumber = pagination.PageNumber.ToPathTokenString(),
PageSize = pagination.PageSize.ToPathTokenString(),
TotalRecords = pagination.TotalRecords.ToPathTokenString(),
TotalPages = pagination.TotalPages.ToPathTokenString()
};
public IActionResult GetPeople([FromQuery] PeopleParameters peopleParameters)
{
IPaginationMetadata metadata = new PaginationMetadata(peopleParameters.MaxPageSize, peopleParameters.PageNumber, peopleParameters.PageSize);
Response.Headers.Add("X-Pagination", JsonConvert.SerializeObject(metadata));
return(Ok(_peopleDataAccess.GetByPaginationParameters(peopleParameters.PageNumber, peopleParameters.PageSize)));
}
public GetUncorrelatedEventsRequest(PaginationMetadata pagination,
EventFilters filter,
AuthenticatedUserContext userContext)
: base(userContext)
{
Pagination = pagination;
Filter = filter;
}
/// <summary>
/// GET request to the API
/// </summary>
/// <typeparam name="T">Type of return data</typeparam>
/// <param name="resourceParameters">Resource parameters that will be sent as query string params</param>
/// <param name="pathToAppend">Additional path to append on base url (e.g. "lock" custom operation as "/users/1/lock")</param>
/// <returns></returns>
public async Task <APIServiceResult <List <T> > > Get <T>(object resourceParameters = null, string pathToAppend = "")
{
try
{
if (!string.IsNullOrWhiteSpace(pathToAppend))
{
request.Url.AppendPathSegment(pathToAppend);
}
var response = await request.SetQueryParams(resourceParameters).GetAsync();
RevertToBaseRequest(resourceParameters);
if (response.StatusCode != HttpStatusCode.OK)
{
if (response.StatusCode == HttpStatusCode.Forbidden)
{
}
if (response.StatusCode == HttpStatusCode.BadRequest)
{
if (response.Content != null)
{
var errorMessage = await response.Content.ReadAsStringAsync();
return(APIServiceResult <List <T> > .BadRequest(errorMessage));
}
}
return(APIServiceResult <List <T> > .WithStatusCode(response.StatusCode));
}
var headers = response.Headers;
var result = await response.Content.ReadAsAsync <List <T> >();
if (response.StatusCode == HttpStatusCode.OK && result == null)
{
return(APIServiceResult <List <T> > .OK());
}
var xpaginationHeader = headers.FirstOrDefault(x => x.Key == "X-Pagination").Value?.FirstOrDefault();
PaginationMetadata paginationMetadata = null;
if (!string.IsNullOrWhiteSpace(xpaginationHeader))
{
paginationMetadata = JsonConvert.DeserializeObject <PaginationMetadata>(xpaginationHeader);
}
return(APIServiceResult <List <T> > .OK(result, paginationMetadata));
}
catch (Exception ex)
{
return(APIServiceResult <List <T> > .Exception());
}
}
public async Task <IActionResult> GetAllShowtimesAsync([FromRoute] Guid movieId, [FromQuery] RequestParameters requestParameters, [FromHeader(Name = "Accept")] string mediaType)
{
if (!await _showtimeRepository.MovieExists(movieId))
{
return(NotFound());
}
if (string.IsNullOrWhiteSpace(requestParameters.OrderBy))
{
// TODO: change to order by when playing
requestParameters.OrderBy = "Id";
}
if (!_propertyMappingService.ValidMappingExistsFor <ShowtimeDto, Showtime>(requestParameters.Fields))
{
return(BadRequest());
}
if (!_typeHelperService.TypeHasProperties <ShowtimeDto>(requestParameters.Fields))
{
return(BadRequest());
}
var showtimesPagedList = await _showtimeRepository.GetAllShowtimesAsync(movieId, requestParameters.OrderBy, requestParameters.PageNumber, requestParameters.PageSize);
var showtimes = Mapper.Map <IEnumerable <ShowtimeDto> >(showtimesPagedList);
if (mediaType == "application/vnd.biob.json+hateoas")
{
return(Ok(CreateHateoasResponse(showtimesPagedList, requestParameters)));
}
else
{
var previousPageLink = showtimesPagedList.HasPrevious ? CreateUrlForResource(requestParameters, PageType.PreviousPage) : null;
var nextPageLink = showtimesPagedList.HasNext ? CreateUrlForResource(requestParameters, PageType.NextPage) : null;
var paginationMetadata = new PaginationMetadata()
{
TotalCount = showtimesPagedList.TotalCount,
PageSize = showtimesPagedList.PageSize,
CurrentPage = showtimesPagedList.CurrentPage,
TotalPages = showtimesPagedList.TotalPages,
PreviousPageLink = previousPageLink,
NextPageLink = nextPageLink
};
Response.Headers.Add("X-Pagination", Newtonsoft.Json.JsonConvert.SerializeObject(paginationMetadata));
if (requestParameters.IncludeMetadata)
{
var showtimesWithMetadata = new EntityWithPaginationMetadataDto <ShowtimeDto>(paginationMetadata, showtimes);
return(Ok(showtimesWithMetadata));
}
return(Ok(showtimes));
}
}
public GetEventsRequest(long incidentId,
PaginationMetadata pagination,
EventFilters filter,
AuthenticatedUserContext userContext)
: base(userContext)
{
IncidentId = incidentId;
Pagination = pagination;
Filter = filter;
}
public async Task <IActionResult> Get([FromQuery] PaginationMetadata pagination)
{
var result = await _mediator
.Send(new GetIncidentsRequest(pagination, AuthContext))
.ConfigureAwait(continueOnCapturedContext: false);
var links = Links.CreatePaginatedLinks(IncidentRoutes.GetSingle, pagination);
return(OkIfFound(result, links));
}
public async Task <IActionResult> GetEvents([FromRoute] long incidentId,
[FromQuery] PaginationMetadata pagination,
[FromQuery] EventFilters filter)
{
var result = await _mediator.Send(new GetEventsRequest(incidentId, pagination, filter, _authContext));
Response.Headers.AddLinksHeader(CreateLinks(null, incidentId.ToString(), filter, pagination, GetMultipleRouteName));
return(Ok(result));
}
public async Task <IActionResult> GetAllMoviesAsync(
[FromQuery] RequestParameters requestParameters,
[FromHeader(Name = "Accept")] string mediaType)
{
if (string.IsNullOrWhiteSpace(requestParameters.OrderBy))
{
requestParameters.OrderBy = "Title";
}
if (!_propertyMappingService.ValidMappingExistsFor <MovieDto, Movie>(requestParameters.Fields))
{
return(BadRequest());
}
if (!_typeHelperService.TypeHasProperties <MovieDto>(requestParameters.Fields))
{
return(BadRequest());
}
var moviesPagedList = await _movieRepository.GetAllMoviesAsync(requestParameters.OrderBy,
requestParameters.SearchQuery,
requestParameters.PageNumber, requestParameters.PageSize);
var movies = Mapper.Map <IEnumerable <MovieDto> >(moviesPagedList);
if (mediaType == "application/vnd.biob.json+hateoas")
{
return(Ok(CreateHateoasResponse(moviesPagedList, requestParameters)));
}
else
{
var previousPageLink = moviesPagedList.HasPrevious ? CreateUrlForResource(requestParameters, PageType.PreviousPage) : null;
var nextPageLink = moviesPagedList.HasNext ? CreateUrlForResource(requestParameters, PageType.NextPage) : null;
var paginationMetadata = new PaginationMetadata()
{
TotalCount = moviesPagedList.TotalCount,
PageSize = moviesPagedList.PageSize,
CurrentPage = moviesPagedList.CurrentPage,
TotalPages = moviesPagedList.TotalPages,
PreviousPageLink = previousPageLink,
NextPageLink = nextPageLink
};
Response.Headers.Add("X-Pagination", Newtonsoft.Json.JsonConvert.SerializeObject(paginationMetadata));
if (requestParameters.IncludeMetadata)
{
var shapedMovies = movies.ShapeData(requestParameters.Fields);
var moviesWithMetadata = new EntityWithPaginationMetadataDto <ExpandoObject>(paginationMetadata, shapedMovies);
return(Ok(moviesWithMetadata));
}
return(Ok(movies.ShapeData(requestParameters.Fields)));
}
}
public ILinksHeader CreatePaginatedLinks(string routeName, PaginationMetadata pagination)
{
ThrowIf.NullOrWhiteSpace(routeName, nameof(routeName));
var routeValues = new { };
var route = UrlHelper.Link(routeName, routeValues);
var operationLinks = GetOperationLinks(routeValues);
RelationLinks relationLinks = null;
return(new PaginatedLinksHeader(route, operationLinks, relationLinks, pagination));
}
public async Task <IActionResult> Get([FromQuery] PaginationMetadata pagination)
{
var result = await _mediator.Send(new GetIncidentsRequest(pagination, _authContext));
if (result == null)
{
return(NotFound($"{nameof(Incident)}s not found"));
}
Response.Headers.AddLinksHeader(CreateLinks(null, pagination, GetSingleRouteName));
return(Ok(result));
}
public ExpandoObject CreateLinkedentityWithmetadataObject <T>(
PaginationMetadata paginationMetadata,
IEnumerable <T> objs, IEnumerable <LinkDto> links)
{
var objWithMetadata = new ExpandoObject();
((IDictionary <string, object>)objWithMetadata).Add("metadata", paginationMetadata);
((IDictionary <string, object>)objWithMetadata).Add("records", objs);
((IDictionary <string, object>)objWithMetadata).Add("links", links);
return(objWithMetadata);
}
public static APIServiceResult <T> OK(T data, PaginationMetadata paginationMetadata)
{
return(new APIServiceResult <T>
{
Data = data,
PaginationMetadata = paginationMetadata,
Succeeded = true,
StatusCode = HttpStatusCode.OK,
HasData = data != null && ((!typeof(T).IsAssignableFrom(typeof(IList))) ? (data as IList)?.Count > 0 : true)
});
}
public PaginationMetadata PaginationMetadata(QueryParameters queryParameters)
{
PaginationMetadata paginationMetadata = new PaginationMetadata()
{
TotalCount = _operationHistoryRepository.GetCountPerAccount(queryParameters.AccountId),
PageSize = queryParameters.PageCount,
CurrentPage = queryParameters.Page,
};
paginationMetadata.TotalPages = queryParameters.GetTotalPages(paginationMetadata.TotalCount);
return(paginationMetadata);
}
private PaginationMetadata CreatePaginationMetadata(TransactionFilterEntityModel filterModel, int totalRecordCount)
{
var metadata = new PaginationMetadata
{
Page = filterModel.Page,
PageSize = filterModel.PageSize,
TotalPages = PaginationHelper.CalculateTotalPages(filterModel, totalRecordCount),
TotalRecordCount = totalRecordCount
};
return(metadata);
}
