public static string GetAll(
PagingQueryParams paging = null,
SortingQueryParams sorting = null,
FilterQueryParams filtering = null)
{
var baseUrl = $"{BaseUrl}";
var queryParams = new Dictionary <string, string>();
if (paging != null)
{
queryParams.Add(nameof(PagingQueryParams.Page), $"{paging.Page}");
queryParams.Add(nameof(PagingQueryParams.PageSize), $"{paging.PageSize}");
}
if (filtering != null)
{
queryParams.Add(nameof(SortingQueryParams.SortQueryExpression), $"{sorting.SortQueryExpression}");
}
if (sorting != null)
{
queryParams.Add(nameof(FilterQueryParams.SearchTerm), $"{filtering.SearchTerm}");
}
return(QueryHelpers.AddQueryString(baseUrl, queryParams));
}
public async Task <IActionResult> GetAll(
[FromQuery] PagingQueryParams pagingParams,
[FromQuery] SortingQueryParams sortingParams,
[FromQuery] FilterQueryParams filteringParams,
CancellationToken cancellationToken = default)
{
return(Ok(await Mediator.Send(new GetItemsQuery(pagingParams, sortingParams, filteringParams),
cancellationToken)));
}
/// <summary>
/// Gets connectors for the specified account.
/// </summary>
/// <param name="accountId">Account ID.</param>
/// <param name="page">Page.</param>
/// <param name="pageSize">Page size.</param>
/// <param name="client">REST client.</param>
/// <returns></returns>
private static List <Connector> Get(int accountId, int page = DefaultPage, int pageSize = DefaultPageSize, IVcRestClient client = null)
{
PagingQueryParams queryParams = new PagingQueryParams(page, pageSize);
List <Connector> connectors = Get <Connector>(BuildGetUrl(accountId), queryParams, new JsonConverter[] { new CallbackJsonConverter() }, client);
foreach (Connector connector in connectors.Where(c => c.MoreNumbers == true))
{
PopulatePhoneNumbers(connector, client);
}
return(connectors);
}
public List <DelegationDTO> GetAll(int userId, PagingQueryParams pagingQueryParams, out int total)
{
var query = _unitOfWork.DelegationRepository.AsQueryable()
.Include(delegation => delegation.DestinationUserRole)
.Include(delegation => delegation.DestinationUserRole.Role)
.Include(delegation => delegation.DestinationUserRole.User)
.Where(delegation => (delegation.SourceUserRole.StartDate == null || delegation.SourceUserRole.StartDate <= DateTime.Today) &&
(delegation.SourceUserRole.EndDate == null || delegation.SourceUserRole.EndDate >= DateTime.Today) &&
delegation.SourceUserRole.UserId == userId);
var result = query.ApplyPaging(pagingQueryParams, out total).ToList();
return(Mapper.Map <List <DelegationDTO> >(result));
}
public async Task <ActionResult> Details(string nickname, PagingQueryParams queryParams)
{
if (queryParams.Take == 0)
{
queryParams.Take = 20;
}
MyHaikusListViewModel model = new MyHaikusListViewModel();
var haikus = (await this.haikusService.GetHaikusForAsync(LoggedUserNickname, queryParams).ConfigureAwait(false)).Select(i => new HaikuListItem()
{
Id = i.Id,
Text = i.Text,
Rating = i.Rating
}).ToList();
var pageData = this.haikusService.GetHaikusForPagingMetadata(LoggedUserNickname);
model.Haikus = new StaticPagedList <HaikuListItem>(haikus, queryParams.Skip / queryParams.Take + 1, queryParams.Take, pageData.TotalCount);
model.QueryParams = new PagingQueryParams()
{
Skip = queryParams.Skip,
Take = queryParams.Take
};
return(View(model));
}
/// <summary>
/// Gets local phone numbers associated to
/// the specified account.
/// </summary>
/// <param name="accountId">Account ID.</param>
/// <param name="page">Page.</param>
/// <param name="pageSize">Page Size.</param>
/// <param name="client">REST client.</param>
/// <returns></returns>
private static List <Number> GetLocal(int accountId, int page = DefaultPage, int pageSize = DefaultPageSize, IVcRestClient client = null)
{
PagingQueryParams queryParams = new PagingQueryParams(page, pageSize);
return(Get <Number>(BuildGetLocalUrl(accountId), queryParams, client: client));
}
protected async Task <PagingQueryResult <TEntity> > PaginarResultado(IQueryable <TEntity> query, PagingQueryParams parameters, int count)
{
var initPage = parameters.CurrentPage > 0 ? parameters.CurrentPage - 1 : 0;
var result = await query.Skip(initPage *parameters.PageSize).Take(parameters.PageSize).ToListAsync();
return(new PagingQueryResult <TEntity>(result, count, parameters.PageSize));
}
public IHttpActionResult FindDelegations([FromUri] string sort = "Id", string sortDir = "ASC")
{
var model = new MyDelegationsModel();
int total;
model.GridModel.Records = _delegationService.GetAll(_connectionInfo.UserId, PagingQueryParams.Create(null, model.GridModel.RowsPerPage, sort, sortDir), out total);
model.GridModel.TotalRecordsCount = total;
return(Ok(model));
}
public GetItemsQuery(PagingQueryParams pagingParams, SortingQueryParams sortingParams, FilterQueryParams filteringParams)
{
PagingParams = pagingParams;
SortingParams = sortingParams;
FilteringParams = filteringParams;
}
public async Task <IEnumerable <HaikuGetDto> > GetHaikusForAsync(string nickname, PagingQueryParams queryParams)
{
var user = await this.UnitOfWork.UsersRepository
.GetUniqueAsync(u => u.Nickname == nickname).ConfigureAwait(false);
var query = this.UnitOfWork.HaikusRepository
.QueryInclude(h => h.User)
.Where(h => h.User.Nickname == nickname)
.OrderByDescending(h => h.DatePublished)
.Skip(queryParams.Skip)
.Take(queryParams.Take);
var haikus = await this.UnitOfWork.HaikusRepository.GetAllAsync(query).ConfigureAwait(false);
return(haikus.Select(h => Mapper.MapHaikuEntityToHaikuGetDto(h)));
}
