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()); }
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; }