public IHttpActionResult GetUserTrades(string id, [FromUri] PagingParameterModel paging, [FromUri] TradeFilteringModel filter, string state = "all")
{
IEnumerable <TradeDTO> tradesForPage;
try
{
tradesForPage = tradeService.GetUserTrades(id, filter.CategoryId, paging?.PageNumber ?? 1, paging?.PageSize ?? 10,
state, filter.StartsOn, filter.EndsOn, filter.MaxPrice, filter.LotName, out int pagesCount, out int totalItemsCount);
string metadata = JsonConvert.SerializeObject(PaginationHelper.GeneratePageMetadata(paging,
totalItemsCount, pagesCount));
HttpContext.Current.Response.Headers.Add("Paging-Headers", metadata);
return(Ok(tradesForPage));
}
catch (AuctionException ex)
{
return(BadRequest(ex.Message));
}
catch (DatabaseException)
{
return(StatusCode(HttpStatusCode.InternalServerError));
}
}
public void CreatePagedReponse_WhenIsInMiddlePage()
{
string baseUrl = "http://site/";
string route = "/page";
string expectedPrevPage = $"http://site//page?pageNumber=2&pageSize=10";
string expectedNextPage = $"http://site//page?pageNumber=4&pageSize=10";
string expectedFistPage = $"http://site//page?pageNumber=1&pageSize=10";
string expectedLastPage = $"http://site//page?pageNumber=10&pageSize=10";
int expectedTotalPage = 10;
int expectedTotalRecords = 100;
int numPage = 3;
var userList = new List <FakeModel>();
PaginationFilter pagFilter = this.getPaginationFilter(numPage, expectedTotalPage);
UriBl uriBl = new UriBl(baseUrl);
var actual = PaginationHelper.CreatePagedReponse <FakeModel>(
userList, pagFilter, expectedTotalRecords, uriBl, route
);
Assert.AreEqual(expectedPrevPage, actual.PreviousPage?.ToString());
Assert.AreEqual(expectedNextPage, actual.NextPage?.ToString());
Assert.AreEqual(expectedFistPage, actual.FirstPage?.ToString());
Assert.AreEqual(expectedLastPage, actual.LastPage?.ToString());
Assert.AreEqual(expectedTotalPage, actual.TotalPages);
Assert.AreEqual(expectedTotalRecords, actual.TotalRecords);
}
public IActionResult menUser(int id, [FromQuery] PaginationFilter filter)
{
var route = Request.Path.Value;
var validFilter = new PaginationFilter(filter.PageNumber, filter.PageSize);
var consulta = from m in _context.Mensaje
join u in _context.Usuario on m.Adminid equals u.Userid
where m.Userid == id
orderby m.Menfecha descending,
m.Menhora descending
select new
{
menid = m.Menid,
mentitulo = m.Mentitulo,
mendetalle = m.Mendetalle,
menfecha = m.Menfecha,
menhora = m.Menhora,
adminnombre = u.Usernombre
};
var data = consulta.Skip((validFilter.PageNumber - 1) * validFilter.PageSize)
.Take(validFilter.PageSize)
.ToList();
var totalRecords = consulta.Count();
var pagedReponse = PaginationHelper.CreatePagedReponse(data, validFilter, totalRecords, uriService, route);
return(Ok(pagedReponse));
}
public IActionResult GetSpecialists([FromQuery] GetSpecialistsListRequest query)
{
var all = UserService.GetAll().Where(x => x.Role == UserRole.Specialist).ToList();
var list = all.Select(x => GetSuperadminSpecialist(x)).ToList();
if (query.SearchQuery != null && query.SearchQuery != "")
{
list = FilterListByQueryString(list, query.SearchQuery).ToHashSet().ToList();
}
var sortedList = SortSpecialistList(list, query.SortBy, query.OrderBy);
var pagination = PaginationHelper.PaginateEntityCollection(sortedList, query);
return(Ok(new GetSpecialistsListResponse
{
Data = pagination.Data,
CurrentPage = pagination.CurrentPage,
PageSize = pagination.PageSize,
TotalPages = pagination.TotalPages,
SortBy = query.SortBy,
OrderBy = query.OrderBy,
TotalItems = all.Count,
SearchQuery = query.SearchQuery
}));
}
public IActionResult pregYrespXuser(int id, [FromQuery] PaginationFilter filter)
{
var route = Request.Path.Value;
var validFilter = new PaginationFilter(filter.PageNumber, filter.PageSize);
var consulta = from p in _context.Pregunta
join r in _context.Respuesta on p.Pregid equals r.Pregid
where r.Userid == id
select new
{
userid = r.Userid,
pregid = p.Pregid,
pregtexto = p.Pregtexto,
pregdetalle = p.Pregdetalle,
respid = r.Respid,
respfecha = r.Respfecha,
resptexto = r.Resptexto,
resphora = r.Resphora
};
var data = consulta.Skip((validFilter.PageNumber - 1) * validFilter.PageSize)
.Take(validFilter.PageSize)
.ToList();
var totalRecords = consulta.Count();
var pagedReponse = PaginationHelper.CreatePagedReponse(data, validFilter, totalRecords, uriService, route);
return(Ok(pagedReponse));
}
public IActionResult predCad(int id, [FromQuery] PaginationFilter filter)
{
var route = Request.Path.Value;
var validFilter = new PaginationFilter(filter.PageNumber, filter.PageSize);
var consulta = from p in _context.Pregunta
where p.Userid == id
where p.Pregestado == true
select new
{
pregid = p.Pregid,
pregtexto = p.Pregtexto,
pregdetalle = p.Pregdetalle,
pregfecha = p.Pregfecha,
preghora = p.Preghora,
pregestado = p.Pregestado,
pregcategoria = p.Catnombre
};
var data = consulta.Skip((validFilter.PageNumber - 1) * validFilter.PageSize)
.Take(validFilter.PageSize)
.ToList();
var totalRecords = consulta.Count();
var pagedReponse = PaginationHelper.CreatePagedReponse(data, validFilter, totalRecords, uriService, route);
return(Ok(pagedReponse));
}
public IActionResult respPregunta(int id, [FromQuery] PaginationFilter filter)
{
var route = Request.Path.Value;
var validFilter = new PaginationFilter(filter.PageNumber, filter.PageSize);
var consulta = from r in _context.Respuesta
join u in _context.Usuario on r.Userid equals u.Userid
join p in _context.Pregunta on r.Pregid equals p.Pregid
where r.Pregid == id
where r.Respid != p.Pregmejorresp
orderby r.Respfecha descending,
r.Resphora descending
select new
{
respid = r.Respid,
respfecha = r.Respfecha,
resptexto = r.Resptexto,
resphora = r.Resphora,
usernick = u.Usernick,
userfoto = u.Userfoto,
userid = r.Userid
};
var data = consulta.Skip((validFilter.PageNumber - 1) * validFilter.PageSize)
.Take(validFilter.PageSize)
.ToList();
var totalRecords = consulta.Count();
var pagedReponse = PaginationHelper.CreatePagedReponse(data, validFilter, totalRecords, uriService, route);
return(Ok(pagedReponse));
}
public IActionResult GetPreguntasUsuario(int id, [FromQuery] PaginationFilter filter)
{
var route = Request.Path.Value;
var validFilter = new PaginationFilter(filter.PageNumber, filter.PageSize);
var consulta = from a in _context.Usuario
join p in _context.Pregunta on a.Userid equals p.Userid
where a.Userid == id
select new
{
puntaje = a.Userpuntaje,
nombre = a.Usernombre,
pregunta = p.Pregtexto,
categoria = p.Catid
};
var data = consulta.Skip((validFilter.PageNumber - 1) * validFilter.PageSize)
.Take(validFilter.PageSize)
.ToList();
/*var data = _context.PreguntaUsuario
* .FromSqlRaw($"select usuario.userpuntaje,usuario.usernombre,pregunta.pregtexto,pregunta.catid from usuario join pregunta on usuario.userid = pregunta.userid where usuario.userid = '{id}'")
* .Skip((validFilter.PageNumber - 1) * validFilter.PageSize)
* .Take(validFilter.PageSize)
* .ToList();*/
//en este bloque no funciona la consulta raw ya que al no existir en la base ese tipo de tabla da error
//en ese caso se usa el lenguaje de consultar linq
var totalRecords = consulta.Count();
var pagedReponse = PaginationHelper.CreatePagedReponse(data, validFilter, totalRecords, uriService, route);
return(Ok(pagedReponse));
}
public async Task <IActionResult> Index(int pageNumber = 1)
{
var cookies = this.HttpContext.Request.Cookies;
var sortStrategyType = this.cookiesService
.GetValueOrDefault <UserSortStrategyType>(cookies, WebConstants.CookieAdminUsersSortTypeKey);
var sortDirection = this.cookiesService
.GetValueOrDefault <SortStrategyDirection>(cookies, WebConstants.CookieAdminUsersSortDirectionKey);
var sortStrategy = UserSortStrategyFactory.GetStrategy(sortStrategyType, sortDirection);
var allUsers = this.userRepository.GetAll();
var totalPagesCount = await PaginationHelper.CountTotalPagesCountAsync(allUsers);
var userServiceModels = await this.adminUsersService.GetSortedUsersAsync(sortStrategy, pageNumber);
var userViewModels = await userServiceModels.To <UserAdminViewModel>().ToArrayAsync();
var model = new AdminUsersViewModel()
{
CurrentPage = pageNumber,
SortStrategyDirection = sortDirection,
SortStrategyType = sortStrategyType,
TotalPagesCount = totalPagesCount,
Users = userViewModels
};
return(View(model));
}
public async Task <ActionResult <PagedResponse <List <PowerMeterTotal> > > > GetPowerMeterTotal([FromQuery] PowerMeterTotalPaginationFilter filter)
{
var userId = HttpContext.User
.Claims
.Where(claim => claim.Type.Equals(ClaimTypes.NameIdentifier))
.First()
.Value;
if (filter.MinDate.HasValue)
{
Console.WriteLine(filter.MinDate.Value);
}
(var pagedData, var totalCount) = await filter.Process(_context.PowerMeterTotal, _context.Thing, new Guid(userId));
var pagedReponse = PaginationHelper.CreatePagedReponse(
await pagedData.ToListAsync(),
filter,
totalCount,
_uriService,
Request
);
return(Ok(pagedReponse));
}
/// <summary>
/// Handles the ListStations request.
/// </summary>
public override async Task <ListStationsResponse> ListStations(ListStationsRequest request, ServerCallContext context)
{
int offset = PaginationHelper.GetOffset(request.PageToken);
int pageSize = request.PageSize == 0 ? DEFAULT_PAGE_SIZE : request.PageSize;
ListStationsResponse response = new ListStationsResponse();
List <StationData> stations = new List <StationData>();
foreach (var station in (System.Enum.GetValues(typeof(Station)) as Station[]).Where((station) => station != Station.Unspecified).Distinct())
{
try
{
var stops = await this.pathDataRepository.GetStops(station);
stations.Add(this.ToStation(station, stops));
}
catch (Exception ex)
{
Log.Logger.Here().Warning(ex, "Failed to load expected station {station}.", station);
}
}
response.Stations.Add(stations.Skip(offset).Take(pageSize));
if (stations.Count > offset + pageSize)
{
response.NextPageToken = PaginationHelper.GetPageToken(offset + pageSize);
}
return(response);
}
public async IAsyncEnumerable <ListResponse <AppUserVM> > UserList(
AppUserFilter filter,
AppUserSort sort,
Paginate paginate)
{
yield return(await HubHelper.WrapAsync(_logger, async() =>
{
IQueryable <AppUser> query = _db.Users
.Include(m => m.UserClaims)
.Include(m => m.UserRoles)
.ThenInclude(m => m.Role);
switch (sort)
{
case AppUserSort.EmailAsc:
query = query.OrderBy(m => m.Email);
break;
case AppUserSort.EmailDesc:
query = query.OrderByDescending(m => m.Email);
break;
}
if (!string.IsNullOrEmpty(filter.Email))
{
query = query.Where(m => EF.Functions.ILike(m.Email, $"%{filter.Email}%"));
}
return await PaginationHelper.FromQueryAsync <AppUser, AppUserVM>(paginate, query);
}));
}
public async Task <PagedResult <UserDto> > GetUsersAsync(bool isCurrentUserAdmin,
string filter = null,
int?pageNumber = null,
int?pageSize = null)
{
var predicate = ExpressionHelper.GetFilterPredicate <UserDb, UserDto>(filter);
IQueryable <UserDb> query;
if (isCurrentUserAdmin)
{
query = _userManager.Users
.AsNoTracking();
}
else
{
var adminUsers = await _userManager.GetUsersInRoleAsync(UserRoles.Admin);
var adminIds = adminUsers?.Select(x => x.Id).ToList();
//filter admin users
query = _userManager.Users.Where(x => !adminIds.Contains(x.Id))
.AsNoTracking();
}
query = query.Where(predicate);
var result = await PaginationHelper.GetPagedResponseAsync <UserDb, UserDto>(
query, pageNumber, pageSize, _mapper);
return(result);
}
public async Task <IActionResult> GetPage(PaginationFilter filter, HttpRequest request)
{
var route = request.Path.Value;
var uri = string.Concat(request.Scheme, "://", request.Host.ToUriComponent());
IUriService uriService = new UriService(uri);
PaginationFilter validFilter = new PaginationFilter(filter.PageNumber, filter.PageSize);
List <User> userList = await userDA.GetPage(validFilter.PageNumber, validFilter.PageSize);
List <UserDTO> userDtoList = new List <UserDTO>();
foreach (User user in userList)
{
userDtoList.Add(ItemToDTO(user));
}
int totalRecords = await userDA.GetRecords();
Information info = InformationHelper.FillInformation(totalRecords, validFilter.PageNumber, validFilter.PageSize);
var pagedResponse = PaginationHelper.CreatePagedReponse <UserDTO>(
userDtoList, info, validFilter, totalRecords, uriService, route
);
return(new OkObjectResult(pagedResponse));
}
public async Task <PaginatedResponse <IAccount> > GetByPagesAsync(string search = null, bool showDeleted = false,
int?skip = null, int?take = null, bool isAscendingOrder = true)
{
/*var data = (await _tableStorage.ExecuteQueryWithPaginationAsync(
* new TableQuery<AccountEntity>()
* {
* //this condition might be not ok
* FilterString = TableQuery.GenerateFilterCondition("Id", QueryComparisons.Equal, search),
* TakeCount = take,
* },
* new PagingInfo
* {
* ElementCount = take,
* CurrentPage = skip / take
* })).ToList();
*/
//TODO refactor before using azure impl
var data = await GetAllAsync(null, search);
return(new PaginatedResponse <IAccount>(
take.HasValue ? data.OrderBy(x => x.Id).Skip(skip ?? 0).Take(PaginationHelper.GetTake(take)).ToList() : data,
skip ?? 0,
take ?? data.Count,
data.Count
));
}
public IActionResult GetImageFiles([FromQuery] GetSearchListRequest query)
{
var all = FileService.GetAll()
.Where(file =>
file.Type == FileType.PNG ||
file.Type == FileType.JPEG ||
file.Type == FileType.GIF ||
file.Type == FileType.BMP)
.OrderByDescending(file => file.ID)
.ToList();
var list = all.Select(file => new FileViewModel(file)).ToList();
if (query.SearchQuery != null && query.SearchQuery != "")
{
list = FileService.FilterFilesByQueryString(list, query.SearchQuery).ToHashSet().ToList();
}
var pagination = PaginationHelper.PaginateEntityCollection(list, query);
return(Ok(new GetSearchListResponse
{
Data = pagination.Data,
CurrentPage = pagination.CurrentPage,
PageSize = pagination.PageSize,
TotalPages = pagination.TotalPages,
TotalItems = pagination.TotalItems,
SearchQuery = query.SearchQuery
}));
}
public async Task <PagedResponse <List <FinanceActiveIndexModel> > > FinanceActionPagination(PaginationFilter filter)
{
using (var uow = UnitOfWorkFactory.Create())
{
var FinanceActionsList = new List <FinanceActiveIndexModel>();
var FinanceActions = uow.FinanceActions.GetPaginationFinanceActions
(PageNumber: filter.PageNumber, PageSize: filter.PageSize, OperationsId: filter.OperationsId,
ProjectsId: filter.ProjectsId, ScoresId: filter.ScoresId, StartDate: filter.StartDate, EndDate: filter.EndDate,
Scores2Id: filter.Scores2Id, CounterPartiesId: filter.CounterPartiesId, UsersId: filter.UsersId, OperationTypesId: filter.OperationTypesId);
foreach (var FinanceAction in FinanceActions.Item1)
{
if (FinanceAction.Discriminator.ToLower() == "transaction")
{
var Transaction = FinanceAction as Transaction;
Transaction.CounterParty = await uow.CounterParties.GetByIdAsync(Transaction.CounterPartyId);
FinanceActionsList.Add(Mapper.Map <FinanceActiveIndexModel>(Transaction));
}
else if (FinanceAction.Discriminator.ToLower() == "remittance")
{
var Remittance = FinanceAction as Remittance;
Remittance.Score2 = await uow.Scores.GetByIdAsync(Remittance.Score2Id);
FinanceActionsList.Add(Mapper.Map <FinanceActiveIndexModel>(Remittance));
}
}
var validFilter = new PaginationFilter(filter.PageNumber, filter.PageSize);
var pagedData = FinanceActionsList;
var totalRecords = FinanceActions.Item2;
var pagedReponse = PaginationHelper.CreatePagedReponse(pagedData, validFilter, totalRecords);
return(pagedReponse);
}
}
public async Task <IActionResult> GetTableDataJsonAsync(int draw, string term, int start, int pageSize, string orderField, string orderDirection, string queryIds)
{
var rolePaginationProvider = new RolePaginationProvider(_dbContext.Roles, _paginationLogger);
var paginationData = await rolePaginationProvider.GetPaginationDataAsync(start, pageSize, term, orderField, orderDirection, queryIds.ToIdsArray <string>());
return(Json(PaginationHelper.GetDataObject(paginationData, draw)));
}
/// <summary> </summary>
public void edit_user(int id, int page)
{
appuser user = ActiveRecordBase <appuser> .Find(id);
if (!userService.checkPrivleage("edit_users") && user != userService.getUser())
{
Flash["error"] = "Sorry you are not able to edit this user.";
RedirectToAction("list");
return;
}
PropertyBag["history"] = PaginationHelper.CreatePagination((IList)ActiveRecordBase <logs> .FindAll(Order.Desc("date"),
new List <AbstractCriterion>()
{
Expression.Eq("nid", user.nid)
}.ToArray()
).ToList(), 15, page);
//media_types imgtype = ActiveRecordBase<media_types>.Find(1); //TODO restore
//PropertyBag["images"] = imgtype.media_typed; //Flash["images"] != null ? Flash["images"] :
//PropertyBag["userimages"] = user.media; //TODO restore
PropertyBag["user"] = user;
PropertyBag["groups"] = ActiveRecordBase <user_group> .FindAll();
RenderView("edit");
}
// GET: Admin/ManageProducts
public ActionResult Index(string keyword = null, int page = 1, string manufactureId = null)
{
ViewBag.Filter = keyword;
int pageSize = PaginationHelper.PageSize();
int totalRow = 0;
Guid?newManufactureId = (Guid?)null;
if (!string.IsNullOrEmpty(manufactureId))
{
newManufactureId = new Guid(manufactureId);
}
var products = _productService.GetIncludeManufacturePaging(keyword, page, newManufactureId, pageSize, out totalRow);
var model = Mapper.Map <IEnumerable <Product>, IEnumerable <ProductViewModel> >(products);
var pagination = new PaginationSet <ProductViewModel>()
{
TotalCount = totalRow,
TotalPages = PaginationHelper.TotalPages(totalRow, pageSize),
Items = model,
Page = page,
MaxPage = PaginationHelper.MaxPage()
};
return(View(pagination));
}
/// <summary> </summary>
public void list_users(int page, int searchId, string target, string filter, Boolean ajax)
{
userService.clearConnections <posting>();
var pageing = new Dictionary <string, int>();
switch (target)
{
case "admin": {
pageing.Add("adminPaging", page); break;
}
case "feu": {
pageing.Add("feuPaging", page); break;
}
}
PropertyBag["groups"] = ActiveRecordBase <user_group> .FindAll();
var userpool = ActiveRecordBase <appuser> .FindAll();
int pag = 0;
PropertyBag["admin_users"] = PaginationHelper.CreatePagination((IList)userpool.Where(x => x.groups.isAdmin == true).ToList(), 15, (pageing.TryGetValue("adminPaging", out pag) ? pag : 0));
pag = 0;
PropertyBag["FEusers"] = PaginationHelper.CreatePagination((IList)userpool.Where(x => x.groups.isAdmin == false).ToList(), 15, (pageing.TryGetValue("feuPaging", out pag) ? pag : 0));
//PropertyBag["user_groups"] = ActiveRecordBase<user_groups>.FindAll();
RenderView("list");
}
public void PageLinksCanGenerate()
{
// Организация
var urlHelper = new Mock <IUrlHelper>();
urlHelper.SetupSequence(proj => proj.Action(It.IsAny <UrlActionContext>()))
.Returns("Test/Page1")
.Returns("Test/Page2")
.Returns("Test/Page3");
var urlHelperF = new Mock <IUrlHelperFactory>();
urlHelperF.Setup(proj2 => proj2.GetUrlHelper(It.IsAny <ActionContext>()))
.Returns(urlHelper.Object);
PaginationHelper paginationHelper = new PaginationHelper(urlHelperF.Object)
{
PageModel = new Pagination
{
CurrentPage = 2,
TotalItems = 28,
ItemsPerPage = 10
},
PageAction = "TestProject"
};
TagHelperContext THcontext = new TagHelperContext(new TagHelperAttributeList(), new Dictionary <object, object>(), "");
var context = new Mock <TagHelperContent>();
TagHelperOutput THoutput = new TagHelperOutput("div", new TagHelperAttributeList(), (cache, encoder) => Task.FromResult(context.Object));
// Действие
paginationHelper.Process(THcontext, THoutput);
// Утверждение
Assert.Equal(@"<a href=""Test/Page1"">1</a>" + @"<a href=""Test/Page2"">2</a>" + @"<a href=""Test/Page3"">3</a>", THoutput.Content.GetContent());
}
public async Task <ActionResult <PagedResponse <List <Thing> > > > GetThing([FromQuery] ThingPaginationFilter filter)
{
var userId = HttpContext.User
.Claims
.Where(claim => claim.Type.Equals(ClaimTypes.NameIdentifier))
.First()
.Value;
if (filter.Owner.HasValue)
{
if (filter.Owner.Value.ToString() != userId & !HttpContext.User.IsInRole("Admin"))
{
return(Forbid());
}
}
var things = Thing.Filter(_context.Thing, new Guid(userId));
(var pagedData, var totalCount) = await filter.Process(things);
var pagedReponse = PaginationHelper.CreatePagedReponse(
await pagedData.ToListAsync(),
filter,
totalCount,
_uriService,
Request
);
return(Ok(pagedReponse));
}
public ActionResult <IEnumerable <Root> > SearchStudies([FromQuery] PaginationFilter filter)
{
try
{
var route = Request.Path.Value;
var validFilter = new PaginationFilter(filter.PageNumber, filter.PageSize, filter.Condition, filter.Country, filter.Sponsor);
//var pagedData = _repoWrapper.StudyStructure.SimpleSearch(validFilter);
var pagedData = _repoWrapper.StudyStructure.FullTextTermSearch(validFilter);
var totalRecords = _repoWrapper.StudyStructure.GetSearchCount(validFilter);
//var totalRecords = 1000;
if (pagedData == null)
{
_logger.LogInformation("No studies found.");
return(NotFound());
}
var pagedReponse = PaginationHelper.CreatePagedReponse <ResultDTO>(pagedData, validFilter, totalRecords, uriService, route);
return(Ok(pagedReponse));
} catch (Exception e)
{
_logger.LogError($"Something went wrong inside SearchStudies action: {e.Message}");
return(StatusCode(404, e.Message));
}
}
public async Task <IActionResult> Index(
AdminBaseCarFilterStrategy filter = AdminBaseCarFilterStrategy.All,
string name = "",
int pageNumber = 1)
{
var cookies = this.HttpContext.Request.Cookies;
var sortDirectionKey = WebConstants.CookieAdminCarsSortDirectionKey;
var sortDirection = this.cookiesService.GetValueOrDefault <SortStrategyDirection>(cookies, sortDirectionKey);
var sortTypeKey = WebConstants.CookieAdminCarsSortTypeKey;
var sortType = this.cookiesService.GetValueOrDefault <AdminBaseCarSortStrategyType>(cookies, sortTypeKey);
var filterStrategy = AdminCarFilterStrategyFactory.GetStrategy(filter, name);
var sortStrategy = AdminBaseCarSortStrategyFactory.GetStrategy <BaseCar>(sortType, sortDirection);
var carServiceModels = this.carsService.GetCars(sortStrategy, filterStrategy);
var carServiceModelsFromCurrentPage = carServiceModels.GetFromPage(pageNumber, WebConstants.PageSize);
var carViewModels = await carServiceModelsFromCurrentPage.To <CarConciseViewModel>().ToArrayAsync();
var totalPagesCount = await PaginationHelper.CountTotalPagesCountAsync(carServiceModels);
var model = new AdminCarsViewModel()
{
Cars = carViewModels,
SortStrategyDirection = sortDirection,
SortStrategyType = sortType,
CurrentPage = pageNumber,
TotalPagesCount = totalPagesCount
};
return(View(model));
}
public async Task <PaginatedResponse <Log> > GetLogsAsync(int page, int pageSize)
{
if (page <= 0 || pageSize <= 0)
{
return(null);
}
int totalLogs = await _logRepository.GetTotalLogs();
if (totalLogs > 0)
{
IEnumerable <LogDto> repoLogs = await _logRepository.GetLogsAsync(page, pageSize);
if (repoLogs == null || !repoLogs.Any())
{
return(null);
}
var logs = new List <Log>();
foreach (var logDto in repoLogs)
{
logs.Add(MapLogDtoToDomain(logDto));
}
return(PaginationHelper <Log> .GeneratePaginatedResponse(pageSize, totalLogs, logs));
}
return(PaginationHelper <Log> .GeneratePaginatedResponse(pageSize, totalLogs, new List <Log>()));
}
public async Task <IActionResult> Search([FromQuery] PaginationFilter filter, string city, string state, string name)
{
var route = Request.Path.Value;
var validFilter = new PaginationFilter(filter.PageNumber, filter.PageSize);
var query = _db.Parks.AsQueryable();
if (city != null)
{
query = query.Where(entry => entry.City == city);
}
if (state != null)
{
query = query.Where(entry => entry.State == state);
}
if (name != null)
{
query = query.Where(entry => entry.Name == name);
}
query = query.Skip((validFilter.PageNumber - 1) * validFilter.PageSize).Take(validFilter.PageSize);
var totalRecords = await _db.Parks.CountAsync();
var pagedResponse = PaginationHelper.CreatePagedReponse <Park>(query.ToList(), validFilter, totalRecords, uriService, route);
return(Ok(pagedResponse));
}
public async Task <IActionResult> GetPagination([FromQuery] PaginationFilter paginationFilter)
{
List <Offer> result;
try
{
result = await this.offerBl.GetPaginationOffersAsync(paginationFilter).ConfigureAwait(false);
foreach (var offer in result)
{
offer.User.Offers = null;
offer.Category.Offers = null;
}
var route = Request.Path.Value;
int totalRecords = await this.offerBl.CountOffers().ConfigureAwait(false);;
var pagedReponse = PaginationHelper.CreatePagedReponse <Offer>(result, paginationFilter, totalRecords, uriBl, route);
return(this.Ok(pagedReponse));
}
catch (Exception ex)
{
this.logger?.LogError(ex, ex.Message);
return(this.StatusCode(StatusCodes.Status500InternalServerError, "Server Error."));
}
}
public async Task <IActionResult> GetAll([FromQuery] CustomerPaginationFilter filter)
{
var route = Request.Path.Value;
var validFilter = new CustomerPaginationFilter(filter.PageNumber, filter.PageSize);
var query = context.Customers.AsQueryable();
//Search by firstname and email
if (!string.IsNullOrEmpty(filter.FirstName))
{
query = query.Where(x => x.FirstName.ToLower().Contains(filter.FirstName.ToLower()));
}
if (!string.IsNullOrEmpty(filter.Email))
{
query = query.Where(x => x.Email.ToLower().Contains(filter.Email.ToLower()));
}
var pagedData = await query.Skip((validFilter.PageNumber - 1) *validFilter.PageSize)
.Take(validFilter.PageSize).ToListAsync();
// calculate total records
var totalRecords = await query.CountAsync();
var pagedReponse = PaginationHelper.CreatePagedReponse(pagedData, validFilter, totalRecords, uriService, route);
return(Ok(pagedReponse));
}
protected static void SetUpHelpers(IEngineContext engineContext, IController controller, IControllerContext controllerContext)
{
var formHelper = new ARFormHelper();
formHelper.SetContext(engineContext);
formHelper.SetController(controller, controllerContext);
var presentationHelper = new PresentationHelper();
presentationHelper.SetContext(engineContext);
presentationHelper.SetController(controller, controllerContext);
var paginationHelper = new PaginationHelper();
paginationHelper.SetContext(engineContext);
paginationHelper.SetController(controller, controllerContext);
var scriptaculous = new ScriptaculousHelper();
scriptaculous.SetContext(engineContext);
scriptaculous.SetController(controller, controllerContext);
var ajaxHelper = new AjaxHelper();
ajaxHelper.SetContext(engineContext);
ajaxHelper.SetController(controller, controllerContext);
controllerContext.Helpers["Scriptaculous"] = scriptaculous;
controllerContext.Helpers["Ajax"] = ajaxHelper;
controllerContext.Helpers["Form"] = formHelper;
controllerContext.Helpers["PresentationHelper"] = presentationHelper;
controllerContext.Helpers["PaginationHelper"] = paginationHelper;
}
public string Show(IPaginatedPage collection)
{
PaginationHelper paginationHelper = new PaginationHelper();
paginationHelper.SetController(Controller);
StringBuilder result = new StringBuilder();
result.AppendFormat("<div class=\"pagination\"><span class=\"pagination-resume\">Showing {0} - {1} of {2}</span>", collection.FirstItem, collection.LastItem, collection.TotalItems);
if (collection.TotalItems >= collection.PageSize)
{
result.Append("<span class=\"pagination-links\">");
if (collection.HasFirst)
result.Append(paginationHelper.CreatePageLinkWithCurrentQueryString(1, "first", null));
else
result.Append("first");
if (collection.HasPrevious)
{
result.Append(" | ");
result.Append(paginationHelper.CreatePageLinkWithCurrentQueryString(collection.PreviousIndex, "prev", null));
}
else
result.Append(" | prev");
if (collection.HasNext)
{
result.Append(" | ");
result.Append(paginationHelper.CreatePageLinkWithCurrentQueryString(collection.NextIndex, "next", null));
}
else
result.Append(" | next");
if (collection.HasLast)
{
result.Append(" | ");
result.Append(paginationHelper.CreatePageLinkWithCurrentQueryString(collection.LastIndex, "last", null));
}
else
result.Append(" | last");
result.Append("</span>");
}
result.Append("</div>");
return result.ToString();
}
private void CreateLink(TextWriter output, PaginationHelper paginationHelper, int pageIndex, string title)
{
if (Context.HasSection("link"))
{
PropertyBag["pageIndex"] = pageIndex;
PropertyBag["title"] = title;
Context.RenderSection("link", output);
}
else
{
output.Write(paginationHelper.CreatePageLink(pageIndex, title, null, QueryStringAsDictionary()));
}
}
public void Init()
{
helper = new PaginationHelper();
}
public void SetUp()
{
_phelper = new PaginationHelper(new[] { "a", "b", "c", "d", "e", "f" }, 4);
}
public void ItemCount()
{
var arr = new[] {"a", "b" };
var ph = new PaginationHelper(arr, 1);
Assert.AreEqual(arr.Length, ph.ItemCount());
}
protected static void SetUpHelpers(IEngineContext engineContext, IController controller, IControllerContext controllerContext)
{
var formHelper = new ARFormHelper();
formHelper.SetContext(engineContext);
formHelper.SetController(controller, controllerContext);
var presentationHelper = new PresentationHelper();
presentationHelper.SetContext(engineContext);
presentationHelper.SetController(controller, controllerContext);
var paginationHelper = new PaginationHelper();
paginationHelper.SetContext(engineContext);
paginationHelper.SetController(controller, controllerContext);
var scriptaculous = new ScriptaculousHelper();
scriptaculous.SetContext(engineContext);
scriptaculous.SetController(controller, controllerContext);
var ajaxHelper = new AjaxHelper();
ajaxHelper.SetContext(engineContext);
ajaxHelper.SetController(controller, controllerContext);
controllerContext.Helpers["Scriptaculous"] = scriptaculous;
controllerContext.Helpers["Ajax"] = ajaxHelper;
controllerContext.Helpers["Form"] = formHelper;
controllerContext.Helpers["PresentationHelper"] = presentationHelper;
controllerContext.Helpers["PaginationHelper"] = paginationHelper;
}
public string PageBrowser(Page page)
{
StringWriter output = new StringWriter();
PaginationHelper helper = new PaginationHelper();
helper.SetController(this.Controller);
if (page.HasFirst)
output.Write(helper.CreatePageLink(1, "First"));
else
output.Write("First");
output.Write(" | ");
if (page.HasPrevious)
output.Write(helper.CreatePageLink(page.PreviousIndex, "Previous"));
else
output.Write("Previous");
output.Write(" | ");
if (page.HasNext)
output.Write(helper.CreatePageLink(page.NextIndex, "Next"));
else
output.Write("Next");
output.Write(" | ");
if (page.HasLast)
output.Write(helper.CreatePageLink(page.LastIndex, "Last"));
else
output.Write("Last");
return output.ToString();
}
protected static void SetUpHelpers(Controller controller)
{
ARFormHelper formHelper = new ARFormHelper();
formHelper.SetController(controller);
ValidationHelper validationHelper = new ValidationHelper();
validationHelper.SetController(controller);
PresentationHelper presentationHelper = new PresentationHelper();
presentationHelper.SetController(controller);
PaginationHelper paginationHelper = new PaginationHelper();
paginationHelper.SetController(controller);
ScriptaculousHelper scriptaculous = new ScriptaculousHelper();
scriptaculous.SetController(controller);
AjaxHelper ajaxHelper = new AjaxHelper();
ajaxHelper.SetController(controller);
controller.PropertyBag["Scriptaculous"] = scriptaculous;
controller.PropertyBag["Ajax"] = ajaxHelper;
controller.PropertyBag["Form"] = formHelper;
controller.PropertyBag["ValidationHelper"] = validationHelper;
controller.PropertyBag["PresentationHelper"] = presentationHelper;
controller.PropertyBag["PaginationHelper"] = paginationHelper;
}
