public async Task <IActionResult> GetAll(
[FromQuery] GetAllOrdersQuery filterModel,
[FromQuery] PaginationQuery paginModel
)
{
int requestedUserId = int.Parse(HttpContext.GetUserIdFromRequest());
var pagination = _mapper.Map <PaginationFilter>(paginModel);
var filter = _mapper.Map <GetAllOrdersFilter>(filterModel);
var orders = await _orderService
.GetAllAsync(pagination, filter, requestedUserId);
int totalOrders = await _orderService
.CountAllAsync(pagination, filter, requestedUserId);
var responseOrders = _mapper
.Map <List <OrderResponse> >(orders);
var paginationOrdersResponse = PaginationHelpers
.CreatePaginatedResponse(
_uriService,
pagination,
responseOrders,
totalOrders,
ApiRoutes.Order.GetAll
);
return(Ok(paginationOrdersResponse));
}
// [Cached(600)]
public async Task <ActionResult> GetAllProjectsByUser([FromRoute] string username, [FromQuery] GetAllProjectsQuery query, [FromQuery] PaginationQuery paginationQuery)
{
var user = await _userManager.FindByNameAsync(username).ConfigureAwait(false);
if (user == null)
{
return(new NotFoundResult());
}
var pagination = _mapper.Map <PaginationFilter>(paginationQuery);
var filter = _mapper.Map <GetAllProjectsFilter>(query);
filter.CreatorUsername = username;
if (HttpContext.User.Identity.IsAuthenticated)
{
filter.CurrentUserId = HttpContext.GetUserId();
}
var projects = await _projectService.GetProjectsAsync(filter, pagination).ConfigureAwait(false);
var projectsResponse = _mapper.Map <List <ProjectResponse> >(projects.list);
if (pagination == null || pagination.PageNumber < 1 || pagination.PageSize < 1)
{
return(Ok(new PagedResponse <ProjectResponse>(projectsResponse, projects.count)));
}
var paginationResponse = PaginationHelpers.CreatePaginatedResponse(_uriService, pagination, projectsResponse, projects.count);
return(Ok(paginationResponse));
}
protected override PagedResponse <AuditDto> Handle(SearchAuditsQuery request)
{
int total = 0;
if (request == null)
{
var response = _mapper.ProjectTo <AuditDto>(_dbContext.Audits).OrderBy(a => a.Id).ToList();
total = _dbContext.Audits.Count();
return(new PagedResponse <AuditDto>(response, total));
}
_logger.LogInformation(
"----- Handling query: {RequestName} - ({@Request})",
request.GetGenericTypeName(),
request);
var pagination = _mapper.Map <PaginationFilter>(request);
var skip = (request.PageNumber) * request.PageSize;
var audits = _mapper.ProjectTo <AuditDto>(_dbContext.Audits)
.Where(a => string.IsNullOrEmpty(request.DescriptionContains) || a.Description.Contains(request.DescriptionContains))
.Where(a => string.IsNullOrEmpty(request.PropertiesContains) || a.Properties.Contains(request.PropertiesContains))
.OrderBy(a => a.Id)
.Skip(skip).Take(request.PageSize).ToList();
total = _dbContext.Audits.Count();
var paginationResponse = PaginationHelpers.CreatePaginatedResponse(_uriService, pagination, audits, total);
return(paginationResponse);
}
public async Task <IActionResult> GetAllCategories([FromQuery] PaginationQuery paginationQuery)
{
IQueryable <Category> categories = _categoryRepository.Categories;
Task <int> countTask = _categoryRepository.Categories.CountAsync();
categories = categories.OrderBy(c => c.CategoryName);
if (paginationQuery != null)
{
categories = categories.Skip(paginationQuery.PageSize * (paginationQuery.PageNumber - 1)).Take(paginationQuery.PageSize);
}
if (paginationQuery == null || paginationQuery.PageNumber < 1 || paginationQuery.PageSize < 1)
{
paginationQuery = new PaginationQuery
{
PageNumber = 0,
PageSize = 0,
};
}
Task <Category[]> categoriesTask = categories.ToArrayAsync();
BaseResponse <IEnumerable <Category> > paginationResponse = PaginationHelpers.CreatePaginatedResponse(_uriService, new PaginationFilter(paginationQuery), await categoriesTask, await countTask);
return(Ok(paginationResponse));
}
public async Task <IActionResult> GetAll([FromQuery] GetAllPostsQuery query, [FromQuery] PaginationQuery paginationQuery)
{
var paginationFilter = new PaginationFilter
{
PageNumber = paginationQuery.PageNumber,
PageSize = paginationQuery.PageSize
};
var getAllPostsFilter = new GetAllPostsFilter
{
UserId = query.UserId
};
var posts = await _postService.GetPostsAsync(getAllPostsFilter, paginationFilter);
var postResponse = posts.Select(post => new PostResponse
{
Id = post.Id,
Name = post.Name
}).ToList();
if (paginationFilter is null || paginationFilter.PageNumber < 1 || paginationFilter.PageSize < 1)
{
return(Ok(new PagedResponse <PostResponse>(postResponse)));
}
var paginationResponse = PaginationHelpers.CreatePaginatedResponse(_uriService, paginationFilter, postResponse);
return(Ok(paginationResponse));
}
// [Cached(600)]
public async Task <IActionResult> GetAllProjectAdminsByUserProject([FromRoute] string username, [FromRoute] string projectName, [FromQuery] GetAllProjectAdminsQuery query, [FromQuery] PaginationQuery paginationQuery)
{
var user = await _userService.GetUserByUserNameAsync(username).ConfigureAwait(false);
if (user == null)
{
return(NotFound());
}
var project = await _projectService.GetProjectByUserAsync(username, projectName).ConfigureAwait(false);
if (project == null)
{
return(NotFound());
}
var pagination = _mapper.Map <PaginationFilter>(paginationQuery);
// var filter = _mapper.Map<GetAllProjectAdminsFilter>(query);
var(list, count) = await _projectAdminService.GetAllProjectAdminsAsync(project.Id, pagination).ConfigureAwait(false);
var adminsResponse = _mapper.Map <List <DragonflyUserResponse> >(list);
if (pagination == null || pagination.PageNumber < 1 || pagination.PageSize < 1)
{
return(Ok(new PagedResponse <DragonflyUserResponse>(adminsResponse, count)));
}
var paginationResponse = PaginationHelpers.CreatePaginatedResponse(_uriService, pagination, adminsResponse, count);
return(Ok(paginationResponse));
}
public async Task <IActionResult> GetAll([FromQuery] PaginationQuery paginationQuery)
{
var pagination = _mapper.Map <PaginationFilter>(paginationQuery);
// Pegando autores cacheados
var authorsResponse = _cacheService
.GetCachedResponse <List <AuthorResponse> >(
ApiRoutes.Authors.GetAll);
if (authorsResponse == null)
{
var authors = await _authorService
.GetAuthorsAsync(pagination)
.ConfigureAwait(false);
authorsResponse = _mapper.Map <List <AuthorResponse> >(authors);
_cacheService.SetCacheResponse(
ApiRoutes.Authors.GetAll,
authorsResponse,
TimeSpan.FromMinutes(2));
}
if (pagination == null || pagination.PageNumber < 1 || pagination.PageSize < 1)
{
return(Ok(new PagedResponse <AuthorResponse>(authorsResponse)));
}
var paginationResponse = PaginationHelpers
.CreatePaginatedResponse(_uriService, pagination, authorsResponse);
return(Ok(paginationResponse));
}
public IActionResult All(string search = null, int currentPage = 1)
{
var logsTotal = this.logService.Total(search);
var totalPages = PaginationHelpers.GetTotalPages(logsTotal);
currentPage = PaginationHelpers.GetValidCurrentPage(currentPage, totalPages);
var logsCurrentPage = this.logService.All(search, currentPage, WebConstants.PageSize);
var model = new LogPageListingModel
{
Logs = logsCurrentPage,
Pagination = new PaginationModel
{
Controller = WebConstants.LogsControllerName,
Action = nameof(All),
SearchTerm = search,
CurrentPage = currentPage,
TotalPages = totalPages
}
};
return(this.View(model));
}
public async Task <IActionResult> GetAll(
[FromQuery] GetAllRequestImportProductsQuery filterModel,
[FromQuery] PaginationQuery paginModel)
{
var pagination = _mapper.Map <PaginationFilter>(paginModel);
var filter = _mapper.Map <GetAllRequestImportProductsFilter>(filterModel);
var requestImportProducts = await _requestImportProductService
.GetAllAsync(pagination, filter);
int totalRequestImportProducts = await _requestImportProductService
.CountAllAsync(pagination, filter);
var responseRequestImportProducts = _mapper
.Map <List <RequestImportProductResponse> >(requestImportProducts);
var paginationRequestImportProductsResponse = PaginationHelpers
.CreatePaginatedResponse(
_uriService,
pagination,
responseRequestImportProducts,
totalRequestImportProducts,
ApiRoutes.RequestImportProduct.GetAll
);
return(Ok(paginationRequestImportProductsResponse));
}
protected override PagedResponse <AuditDto> Handle(GetAuditsQuery request)
{
int total = 0;
_logger.LogInformation(
"----- Handling query: {RequestName} - ({@Request})",
request.GetGenericTypeName(),
request);
if (request == null)
{
var response = _mapper.ProjectTo <AuditDto>(_dbContext.Audits).OrderBy(a => a.Id).ToList();
total = _dbContext.Audits.Count();
return(new PagedResponse <AuditDto>(response, total));
}
var pagination = _mapper.Map <PaginationFilter>(request);
var skip = (request.PageNumber) * request.PageSize;
var audits = _mapper.ProjectTo <AuditDto>(_dbContext.Audits.Include(a => a.AuditApplication)).OrderBy(a => a.Id)
.Skip(skip).Take(request.PageSize).ToList();
total = _dbContext.Audits.Count();
var paginationResponse = PaginationHelpers.CreatePaginatedResponse(_uriService, pagination, audits, total);
return(paginationResponse);
}
// [Cached(600)]
public async Task <IActionResult> GetAllIssueStagesByUserProject([FromRoute] string username, [FromRoute] string projectName, [FromQuery] GetAllIssueStagesQuery query, [FromQuery] PaginationQuery paginationQuery)
{
var project = await _projectService.GetProjectByUserAsync(username, projectName).ConfigureAwait(false);
if (project == null)
{
return(NotFound());
}
var pagination = _mapper.Map <PaginationFilter>(paginationQuery);
var filter = _mapper.Map <GetAllIssueStagesFilter>(query);
filter.ProjectId = project.Id;
var issueStages = await _issueStageService.GetIssueStagesByProjectAsync(project.Id, null).ConfigureAwait(false);
var issueStagesResponse = _mapper.Map <List <IssueStageResponse> >(issueStages.list);
if (pagination == null || pagination.PageNumber < 1 || pagination.PageSize < 1)
{
return(Ok(new PagedResponse <IssueStageResponse>(issueStagesResponse, issueStages.count)));
}
var paginationResponse = PaginationHelpers.CreatePaginatedResponse(_uriService, pagination, issueStagesResponse, issueStages.count);
return(Ok(paginationResponse));
}
public async Task <IActionResult> GetAll(
[FromQuery] GetAllProductTierTransferReportsQuery filterModel,
[FromQuery] PaginationQuery paginModel
)
{
var pagination = _mapper.Map <PaginationFilter>(paginModel);
var filter = _mapper.Map <GetAllProductTierTransferReportsFilter>(filterModel);
var productTierTransferReports = await _productTierTransferReportService
.GetAllAsync(pagination, filter);
int totalProductTierTransferReports = await _productTierTransferReportService
.CountAllAsync(pagination, filter);
var responseProductTierTransferReports = _mapper
.Map <List <ProductTierTransferReportResponse> >(productTierTransferReports);
var paginationProductTransferReportsResponse = PaginationHelpers
.CreatePaginatedResponse(
_uriService,
pagination,
responseProductTierTransferReports,
totalProductTierTransferReports,
ApiRoutes.ProductTierTransferReport.GetAll
);
return(Ok(paginationProductTransferReportsResponse));
}
public async Task <IActionResult> GetRepliesAsync([FromRoute] Guid commentId,
[FromQuery] PaginationQuery paginationQuery)
{
var paginationFilter = _mapper.Map <PaginationFilter>(paginationQuery);
var comment = await _commentService.GetCommentByIdAsync(commentId);
if (comment == null)
{
return(NotFound());
}
var replies = await _commentService.GetRepliesByCommentAsync(commentId, paginationFilter);
var response = _mapper.Map <List <CommentResponse> >(replies);
foreach (var reply in response)
{
reply.Liked =
await _likeService.LikedByUserAsync(HttpContext.GetUserId(), comment.Id.ToString(),
nameof(Comment));
}
var paginationResponse =
PaginationHelpers.CreatePaginatedResponse(_uriService, paginationFilter, response);
return(Ok(paginationResponse));
}
public async Task <IActionResult> GetAll([FromQuery] PaginacaoQuery pagination, [FromServices] IUriServico uriServico)
{
var usuariosResponse = CacheServico
.GetCachedResponse <IReadOnlyList <UsuarioResponse> >(
ApiRotas.Usuario.GetAll);
if (usuariosResponse is null)
{
var usuarios = await _usuarioServico
.ObterUsuariosAsync(pagination);
usuariosResponse = Mapper
.Map <IReadOnlyList <UsuarioResponse> >(usuarios);
CacheServico.SetCacheResponse(
ApiRotas.Usuario.GetAll,
usuariosResponse,
TimeSpan.FromMinutes(2));
}
if (pagination == null || pagination.NumeroPagina < 1 || pagination.QuantidadePagina < 1)
{
return(Ok(new PagedResponse <UsuarioResponse>(usuariosResponse)));
}
var paginationResponse = PaginationHelpers
.CriarRespostaPaginada(uriServico, pagination, usuariosResponse.ToList());
return(Ok(paginationResponse));
}
public async Task <IActionResult> GetAllEffects([FromQuery] PaginationQuery paginationQuery)
{
IQueryable <Effect> effects = _effectRepository.Effects;
Task <int> countTask = _effectRepository.Effects.CountAsync();
effects = effects.OrderBy(c => c.Name);
if (paginationQuery != null)
{
effects = effects.Skip(paginationQuery.PageSize * (paginationQuery.PageNumber - 1)).Take(paginationQuery.PageSize);
}
if (paginationQuery == null || paginationQuery.PageNumber < 1 || paginationQuery.PageSize < 1)
{
paginationQuery = new PaginationQuery
{
PageNumber = 0,
PageSize = 0,
};
}
Task <Effect[]> effectTask = effects.ToArrayAsync();
BaseResponse <IEnumerable <Effect> > paginationResponse = PaginationHelpers.CreatePaginatedResponse(_uriService, new PaginationFilter(paginationQuery), await effectTask, await countTask);
return(Ok(paginationResponse));
}
public async Task <IActionResult> GetAll([FromQuery] PaginacaoQuery pagination)
{
var quadrasResponse = CacheServico
.GetCachedResponse <IReadOnlyList <QuadraResponse> >(
ApiRotas.Quadra.GetAll);
if (quadrasResponse is null)
{
var quadra = await _quadraServico
.ObterQuadrasAsync(pagination);
quadrasResponse = Mapper
.Map <IReadOnlyList <QuadraResponse> >(quadra);
CacheServico.SetCacheResponse(
ApiRotas.Quadra.GetAll,
quadrasResponse,
TimeSpan.FromMinutes(2));
}
if (pagination == null || pagination.NumeroPagina < 1 || pagination.QuantidadePagina < 1)
{
return(Ok(new PagedResponse <QuadraResponse>(quadrasResponse)));
}
var paginationResponse = PaginationHelpers
.CriarRespostaPaginada(UriServico, pagination, quadrasResponse.ToList());
return(Ok(paginationResponse));
}
public IActionResult GetAll([FromQuery] PaginationQuery paginationQuery)
{
var pagination = _mapper.Map <PaginationFilter>(paginationQuery);
var result = new List <TestDocumentResponse>();
var paginationResponse = PaginationHelpers.CreatePaginatedResponse(_uriService, pagination, result);
return(Ok(paginationResponse));
}
public async Task <IActionResult> GetAll([FromQuery] PaginationQuery paginationQuery)
{
var pagination = _mapper.Map <PaginationFilter>(paginationQuery);
var tests = await _mongoService.GetAllAsync(pagination);
var testsResponse = _mapper.Map <List <TestMongoDocumentResponse> >(tests);
var paginationResponse = PaginationHelpers.CreatePaginatedResponse(_uriService, pagination, testsResponse);
return(Ok(paginationResponse));
}
//[Cached(600)]
public async Task<IActionResult> GetAllAsync([FromQuery] GetAllPostsQuery postQuery, [FromQuery]PaginationQuery query) {
var pagination = _mapper.Map<PaginationFilter>(query);
var filter = _mapper.Map<GetAllPostsFilter>(postQuery);
var posts = await _postService.GetPostsAsync(filter, pagination);
var postResponse = _mapper.Map<List<PostResponse>>(posts);
if (pagination == null || pagination.PageNumber < 1 || pagination.PageSize < 1) {
return Ok(new PagedResponse<PostResponse>(postResponse));
}
var paginationResponse = PaginationHelpers.CreatePaginatedResponse(_uriService, pagination, postResponse);
return Ok(paginationResponse);
}
public async Task<PagedResponse<DealerDto>> Handle(GetAllDealersQuery request, CancellationToken cancellationToken)
{
var paginationFilter = _mapper.Map<PaginationFilter>(request.PaginationQuery);
var orders = await _dealersRepository.GetAllDealersAsync(paginationFilter);
var mappedDealers = _mapper.Map<List<DealerDto>>(orders);
if (paginationFilter == null || paginationFilter.PageNumber < 1 || paginationFilter.PageSize < 1)
{
return new PagedResponse<DealerDto>(mappedDealers);
}
return PaginationHelpers.CreatePaginatedResponse(_uriService, paginationFilter, mappedDealers);
}
public async Task <IActionResult> GetAllBrands([FromQuery] BrandFilterQuery filterQuery, [FromQuery] PaginationQuery paginationQuery)
{
var pagination = _mapper.Map <PaginationParams>(paginationQuery);
var filter = _mapper.Map <BrandFilterParams>(filterQuery);
var brands = await _brandService.GetAllBrandsAsync(filter, pagination);
var paginationResponse =
PaginationHelpers.CreatePaginatedResponse(_uriGeneratorService, pagination, brands);
return(Ok(paginationResponse));
}
public async Task <IActionResult> GetAllStores([FromQuery] StoreFilterQuery filterQuery, [FromQuery] PaginationQuery paginationQuery)
{
var filter = _mapper.Map <StoreFilterParams>(filterQuery);
var pagination = _mapper.Map <PaginationParams>(paginationQuery);
var storeResult = await _storeService.GetAllStoresAsync(filter, pagination);
var paginationResponse =
PaginationHelpers.CreatePaginatedResponse(_uriGeneratorService, pagination, storeResult);
return(Ok(paginationResponse));
}
// [Cached(600)]
public async Task <IActionResult> GetAllProjectIssuesByUser([FromRoute] string username, [FromRoute] string projectName, [FromQuery] GetAllIssuesQuery query, [FromQuery] PaginationQuery paginationQuery)
{
if (string.IsNullOrEmpty(username))
{
return(NotFound(new Response <string>()
{
Errors = new List <string> {
"No username"
}
}));
}
var user = await _userService.GetUserByUserNameAsync(username).ConfigureAwait(false);
if (user == null)
{
return(NotFound(new Response <string>()
{
Errors = new List <string> {
"User not found"
}
}));
}
var pagination = _mapper.Map <PaginationFilter>(paginationQuery);
var filter = _mapper.Map <GetAllIssuesFilter>(query);
var project = await _projectService.GetProjectByUserAsync(username, projectName).ConfigureAwait(false);
if (project == null)
{
return(NotFound(new Response <string>()
{
Errors = new List <string> {
"Project not found"
}
}));
}
// filter.ProjectName = projectName;
// filter.AuthorUsername = username;
filter.ProjectId = project.Id;
var issues = await _issueService.GetIssuesAsync(filter, pagination).ConfigureAwait(false);
var issuesResponse = _mapper.Map <List <IssueResponse> >(issues.list);
if (pagination == null || pagination.PageNumber < 1 || pagination.PageSize < 1)
{
return(Ok(new PagedResponse <IssueResponse>(issuesResponse, issues.count)));
}
var paginationResponse = PaginationHelpers.CreatePaginatedResponse(_uriService, pagination, issuesResponse, issues.count);
return(Ok(paginationResponse));
}
public async Task <IActionResult> GetAll([FromQuery] PaginationQuery paginationQuery)
{
var paginationFilter = _mapper.Map <PaginationFilter>(paginationQuery);
var artists = await _artistService.getAllArtistAsync(paginationFilter);
if (paginationFilter == null || paginationFilter.PageNumber < 1 || paginationFilter.PageSize < 1)
{
return(Ok(new PagedResponse <ArtistViewModel>(artists)));
}
//dicky
var paginationResponse = PaginationHelpers.CreatePaginatedResponse(_userService, paginationFilter, artists);
return(Ok(paginationResponse));
}
public async Task <IActionResult> GetCustomers(
[FromQuery] CustomerFilterQuery filterQuery,
[FromQuery] PaginationQuery paginationQuery)
{
var pagination = _mapper.Map <PaginationParams>(paginationQuery);
var filter = _mapper.Map <CustomerFilterQuery, CustomerFilterParams>(filterQuery);
var customers = (await _customerService.GetAllCustomersAsync(filter, pagination)).ToArray();
var paginationResponse =
PaginationHelpers.CreatePaginatedQueryResponse(_uriGeneratorService, pagination, customers, customers.Count());
return(Ok(paginationResponse));
}
public async Task <IActionResult> GetCountries([FromQuery] PaginationQuery paginationQuery)
{
var pagination = _mapper.Map <PaginationParams>(paginationQuery);
var result = await _locationService.GetCountriesAsync(pagination);
if (pagination == null || !pagination.IsValidPagination())
{
return(Ok(new PagedResponse <CountryDto>(result)));
}
var paginatedResponse = PaginationHelpers.CreatePaginatedResponse(_uriGeneratorService, pagination, result);
return(Ok(paginatedResponse));
}
public ActionResult <List <Announce> > GetAll([FromQuery] GetAllAnnouncesQuery query, [FromQuery] PaginationQuery paginationQuery)
{
var filter = _mapper.Map <GetAllAnnouncesFilter>(query);
var paginationFilter = _mapper.Map <PaginationFilter>(paginationQuery);
var announces = _announceService.Get(filter, paginationFilter);
if (paginationFilter == null || paginationFilter.PageNumber < 1 || paginationFilter.PageSize < 1)
{
return(Ok(new PagedResponse <Announce>(announces)));
}
var paginationResponse = PaginationHelpers.CreatePaginatedResponse(_uriService, paginationFilter, announces, ApiRoutes.Announce.GetAll, filter);
return(Ok(paginationResponse));
}
public async Task <IActionResult> Get([FromQuery] string postName, [FromQuery] string threadId, [FromQuery] PaginationQuery paginationQuery, string orderBy)
{
var pagination = _mapper.Map <PaginationFilter>(paginationQuery);
var postsResponce = await _postService.GetAllAsync(postName, threadId, pagination, orderBy);
var dto = _mapper.Map <IEnumerable <Post>, IEnumerable <PostResponse> >(postsResponce.Resource);
if (pagination == null || pagination.PageNumber < 1 || pagination.PageSize < 1)
{
return(Ok(new PageResponse <PostResponse>(dto)));
}
var paginationResponse = PaginationHelpers.CreatePaginatedResponse(_uriService, pagination, dto, postsResponce.amountOfPosts, ApiRoutes.Posts.GetAll);
return(Ok(paginationResponse));
}
public async Task <IActionResult> GetAllAsynk([FromQuery] PaginationQuery paginationQuery)
{
var pagination = _mapper.Map <PaginationFilter>(paginationQuery);
var posts = await _productService.GetProductsAsynk(pagination);
var productResponse = _mapper.Map <List <ProductResponse> >(posts);
if (pagination == null || pagination.PageNumber < 1 || pagination.PageSize < 1)
{
return(Ok(new PagedResponse <ProductResponse>(productResponse)));
}
var paginationResponse = PaginationHelpers.CreatePaginatedResponse(_uriService, pagination, productResponse);
return(Ok(paginationResponse));
}
public async Task <ActionResult> GetAll([FromQuery] GetAllUsersQuery query, [FromQuery] PaginationQuery paginationQuery)
{
var pagination = _mapper.Map <PaginationFilter>(paginationQuery);
var filter = _mapper.Map <GetAllUsersFilter>(query);
var users = await _userService.GetUsersAsync(filter, pagination).ConfigureAwait(false);
var usersResponse = _mapper.Map <List <DragonflyUserResponse> >(users.list);
if (pagination == null || pagination.PageNumber < 1 || pagination.PageSize < 1)
{
return(Ok(new PagedResponse <DragonflyUserResponse>(usersResponse, users.count)));
}
var paginationResponse = PaginationHelpers.CreatePaginatedResponse(_uriService, pagination, usersResponse, users.count);
return(Ok(paginationResponse));
}
