public async Task <ActionResult <PaginatedData <Product> > > GetProduct(int?pageSize, int?pageIndex) { int defaultPageIndex = 1; int defaultPageSize = -1; return(await PaginatedData <Product> .CreateAsync(_context.Product.AsNoTracking(), pageIndex ?? defaultPageIndex, pageSize ?? defaultPageSize));; }
public async Task <Result <DataTableResult <UserAttributeTableModel> > > Get(string userId, DataTableRequest dataTableRequest) { ValidationResult validationResult = _dataTableValidator.Validate(dataTableRequest); if (!validationResult.IsValid) { _logger.LogWarning($"Invalid {typeof(DataTableRequest).Name} model"); return(Result.Fail <DataTableResult <UserAttributeTableModel> >(validationResult.Errors)); } PaginationSpecification <UserAttributeEntity, UserAttributeTableModel> paginationSpecification = new PaginationSpecification <UserAttributeEntity, UserAttributeTableModel>(); paginationSpecification.AddFilter(x => x.UserId == userId); paginationSpecification.AddSelect(x => new UserAttributeTableModel( x.Id, x.Key, x.Value)); paginationSpecification.AppalyPaging(dataTableRequest.Start, dataTableRequest.Length); PaginatedData <UserAttributeTableModel> paginatedData = await _userAttributeRepository.GetPaginated(paginationSpecification); DataTableResult <UserAttributeTableModel> dataTableResult = new DataTableResult <UserAttributeTableModel>( draw: dataTableRequest.Draw, recordsTotal: paginatedData.Count, recordsFilterd: paginatedData.Count, error: null, data: paginatedData.Data); return(Result.Ok(dataTableResult)); }
public Result <DataTableResult <PermissionTableModel> > Get(DataTableRequest dataTableRequest) { ValidationResult validationResult = _dataTableValidator.Validate(dataTableRequest); if (!validationResult.IsValid) { _logger.LogWarning($"Invalid {nameof(DataTableRequest)} model"); return(Result.Fail <DataTableResult <PermissionTableModel> >(validationResult.Errors)); } PaginationSpecification <PermissionEntity, PermissionTableModel> paginationSpecification = new PaginationSpecification <PermissionEntity, PermissionTableModel>(); if (!string.IsNullOrEmpty(dataTableRequest.Search)) { paginationSpecification.AddFilter(x => x.Name.ToUpper().Contains(dataTableRequest.Search.ToUpper())); } paginationSpecification.AddSelect(x => new PermissionTableModel( x.Id, x.Name)); paginationSpecification.AppalyPaging(dataTableRequest.Start, dataTableRequest.Length); PaginatedData <PermissionTableModel> paginatedData = _permissionRepository.GetPaginated(paginationSpecification); DataTableResult <PermissionTableModel> dataTableResult = new DataTableResult <PermissionTableModel>( draw: dataTableRequest.Draw, recordsTotal: paginatedData.Count, recordsFilterd: paginatedData.Count, error: null, data: paginatedData.Data); return(Result.Ok(dataTableResult)); }
public async Task <ActionResult <PaginatedData <Sales> > > GetSales(int?pageSize, int?pageIndex) { int defaultPageIndex = 1; int defaultPageSize = 5; return(await PaginatedData <Sales> .CreateAsync(_context.Sales.AsNoTracking(), pageIndex ?? defaultPageIndex, pageSize ?? defaultPageSize));; }
public async Task <PaginatedData <StickerPackOutput> > FindAllStickerPacksAsync( StickerPackSorting sorting, StickerPackNameFilter nameFilter, StickerPackClapsFilter clapsFilter, StickerPackTagsFilter tagsFilter, Pagination pagination ) { var stickerPacks = _stickerPackRepository.FindAll(); stickerPacks = ApplySorting(stickerPacks, sorting.SortBy, sorting.SortType); stickerPacks = ApplyNameFilter(stickerPacks, nameFilter); stickerPacks = ApplyClapsFilter(stickerPacks, clapsFilter); stickerPacks = await ApplyTagsFilterAsync(stickerPacks, tagsFilter); var paginatedStickers = await stickerPacks.PaginateAsync(pagination); var result = new PaginatedData <StickerPackOutput>(paginatedStickers.Total, new List <StickerPackOutput>()); foreach (var stickerPack in paginatedStickers.Data) { var stickers = await _tgBot.GetStickerFilesFromPackAsync(stickerPack.Name); var filePath = await _tgBot.GetFilePathAsync(stickerPack.Name, fileId : stickers.First()); result.Data = result.Data.Append(new StickerPackOutput(stickerPack, filePath, stickers.Count())); } return(result); }
private void AddPodcastsRoute(HttpSupport httpSupport) { httpSupport.AddRoute(@"/podcasts", (ctx, data) => { var request = ctx.Request; if (CheckIfNotPost(request, ctx)) { return; } if (CheckIfNotJson(request, ctx)) { return; } var requestPayload = ReadPayload(request); if (CheckIfNotEmpty(requestPayload, ctx)) { return; } var requestData = JsonConvert.DeserializeObject <PaginatedRequest>(requestPayload); var subscriptions = _adapter.GetPodcastSubscriptions().ToList(); var page = PaginatedData.CreatePage(requestData.Offset, requestData.Limit, subscriptions); ctx.OutputUtf8(JsonConvert.SerializeObject(page), "application/json", Encoding.UTF8); }); }
public async Task <IActionResult> GetData([FromQuery] PaginatedRequest request) { var query = Repository.GetKarma(request.Sort); var data = PaginatedData <KarmaItem> .Create(query, request, entity => new KarmaItem(entity)); var users = await GrillBotService.GetUsersSimpleInfoBatchAsync(data.Data.Select(o => o.UserID)); var position = PaginationHelper.CountSkipValue(request) + 1; foreach (var item in data.Data) { item.User = users.Find(o => o.ID == item.UserID); if (item.User == null) { item.User = SimpleUserInfo.DefaultUser; item.User.ID = item.UserID; } item.Position = position; position++; } data.Data = data.Data.ToList(); return(Ok(data)); }
public PaginatedData <CourseApi> Get(int page = 0, int pageSize = 20) { var totalCourses = new GetTotalCoursesUseCase(_unitOfWork).Execute(); var courses = new GetCoursesUseCase(page, pageSize, _unitOfWork).Execute(); return(PaginatedData <CourseApi> .Create(totalCourses, page, pageSize, CourseApi.FromDomain(courses))); }
public async Task <PaginatedData <ForumPageModel.TopicModel> > BuildForumPageModelTopicsAsync(Guid forumId, QueryOptions options) { var topicsQuery = _dbContext.Posts .Include(x => x.CreatedByUser) .Include(x => x.LastReply).ThenInclude(x => x.CreatedByUser) .Where(x => x.TopicId == null && x.ForumId == forumId && x.Status == PostStatusType.Published); if (!string.IsNullOrWhiteSpace(options.Search)) { topicsQuery = topicsQuery .Where(x => x.Title.Contains(options.Search) || x.Content.Contains(options.Search)); } var topics = await topicsQuery .OrderByDescending(x => x.Pinned) .ThenByDescending(x => x.LastReply != null ? x.LastReply.CreatedOn : x.CreatedOn) .Skip(options.Skip) .Take(options.PageSize) .ToListAsync(); var items = topics.Select(topic => new ForumPageModel.TopicModel { Id = topic.Id, Title = topic.Title, Slug = topic.Slug, TotalReplies = topic.RepliesCount, UserId = topic.CreatedByUser.Id, UserDisplayName = topic.CreatedByUser.DisplayName, TimeStamp = topic.CreatedOn, GravatarHash = _gravatarService.HashEmailForGravatar(topic.CreatedByUser.Email), MostRecentUserId = topic.LastReply?.CreatedBy ?? topic.CreatedBy, MostRecentUserDisplayName = topic.LastReply?.CreatedByUser?.DisplayName ?? topic.CreatedByUser.DisplayName, MostRecentTimeStamp = topic.LastReply?.CreatedOn ?? topic.CreatedOn, Pinned = topic.Pinned, Locked = topic.Locked, HasAnswer = topic.HasAnswer }) .ToList(); var totalRecordsQuery = _dbContext.Posts .Where(x => x.TopicId == null && x.ForumId == forumId && x.Status == PostStatusType.Published); if (!string.IsNullOrWhiteSpace(options.Search)) { totalRecordsQuery = totalRecordsQuery .Where(x => x.Title.Contains(options.Search) || x.Content.Contains(options.Search)); } var totalRecords = await totalRecordsQuery.CountAsync(); var result = new PaginatedData <ForumPageModel.TopicModel>(items, totalRecords, options.PageSize); return(result); }
public PaginatedData <SearchResult> Search(SearchRequest request) { var moviesQuery = Repository.SearchInMovies(request.Keyword); var personsQuery = Repository.SearchInPersons(request.Keyword); var usersQuery = Repository.SearchInUsers(request.Keyword); var ratingsQuery = Repository.SearchInRatings(request.Keyword); var result = new List <SearchResult>(); result.AddRange(Mapper.Map <List <MovieSearchResult> >(moviesQuery).Select(o => new SearchResult() { Type = SearchResultType.Movie, MovieResult = o })); result.AddRange(Mapper.Map <List <PersonSearchResult> >(personsQuery).Select(o => new SearchResult() { Type = SearchResultType.Person, PersonResult = o })); result.AddRange(Mapper.Map <List <UserSearchResult> >(usersQuery).Select(o => new SearchResult() { Type = SearchResultType.User, UserResult = o })); result.AddRange(Mapper.Map <List <RatingSearchResult> >(ratingsQuery).Select(o => new SearchResult() { Type = SearchResultType.Rating, RatingResult = o })); return(PaginatedData <SearchResult> .Create(result, request)); }
public void GetPaginatedData(object obj) { Task.Run(async() => { this.LoadingMessageHUD = "Performing download..."; this.IsLoadingHUD = true; var result = await this.SomeLogic.GetPaginatedData(pageIndex); pageIndex++; this.IsLoadingHUD = false; if (result.Error == null) { using (var updated = PaginatedData.BeginMassUpdate()) { PaginatedData.AddRange(result.Response); } } else { //Device.BeginInvokeOnMainThread(() => { // DialogPrompt.ShowMessage(new Prompt() // { // Title = "Error", // Message = result.Error.Message // }); //}); } }); }
private void AddEpisodesRoute(HttpSupport httpSupport) { httpSupport.AddRoute(@"/episodes", (ctx, data) => { var request = ctx.Request; if (CheckIfNotPost(request, ctx)) { return; } if (CheckIfNotJson(request, ctx)) { return; } var requestPayload = ReadPayload(request); if (CheckIfNotEmpty(requestPayload, ctx)) { return; } var requestData = JsonConvert.DeserializeObject <IdentifiablePaginatedRequest>(requestPayload); if (string.IsNullOrWhiteSpace(requestData.Id)) { ctx.WriteError((int)HttpStatusCode.BadRequest, "invalid id"); return; } var episodes = _adapter.GetEpisodes(requestData.Id).ToList(); var page = PaginatedData.CreatePage(requestData.Offset, requestData.Limit, episodes); ctx.OutputUtf8(JsonConvert.SerializeObject(page), "application/json", Encoding.UTF8); }); }
public async Task <ActionResult <PaginatedData <Customer> > > GetCustomer(int?pageSize, int?pageIndex) { int defaultPageIndex = 1; int defaultPageSize = -1; return(await PaginatedData <Customer> .CreateAsync(_context.Customer.AsNoTracking(), pageIndex ?? defaultPageIndex, pageSize ?? defaultPageSize));; }
public Result <DataTableResult <SessionViewModel> > GetSessions(string userId, DataTableRequest request) { ValidationResult validationResult = _dataTableValidator.Validate(request); if (!validationResult.IsValid) { _logger.LogWarning($"Invlid DataTableRequest"); return(Result.Fail <DataTableResult <SessionViewModel> >(validationResult.Errors)); } PaginationSpecification <SessionEntity, SessionViewModel> specification = new PaginationSpecification <SessionEntity, SessionViewModel>(); specification.AddFilter(x => x.UserId == userId); specification.AppalyPaging(request.Start, request.Length); specification.AddSelect(x => new SessionViewModel( x.Id, x.Ip, x._CreatedDate, x.LastAccess)); PaginatedData <SessionViewModel> paginatedData = _sessionRepository.GetPaginated(specification); DataTableResult <SessionViewModel> dataTableResult = new DataTableResult <SessionViewModel>( draw: request.Draw, recordsTotal: paginatedData.Count, recordsFilterd: paginatedData.Count, error: null, data: paginatedData.Data); return(Result.Ok(dataTableResult)); }
private void GetPage(string connectionId, string id = "", int offset = 0, int limit = 800) { var data = _libraryApiAdapter.GetEpisodes(id).ToList(); var message = PaginatedData.CreateMessage(offset, limit, data, Constants.PodcastEpisodes); _hub.Publish(new PluginResponseAvailableEvent(message, connectionId)); }
public Result <DataTableResult <EmailTableModel> > Get(DataTableRequest dataTableRequest) { ValidationResult validationResult = _dataTableValidator.Validate(dataTableRequest); if (!validationResult.IsValid) { _logger.LogWarning($"Invalid {nameof(DataTableRequest)} model"); return(Result.Fail <DataTableResult <EmailTableModel> >(validationResult.Errors)); } PaginationSpecification <EmailEntity, EmailTableModel> paginationSpecification = new PaginationSpecification <EmailEntity, EmailTableModel>(); paginationSpecification.AddSelect(x => new EmailTableModel( x.Id, x.Type.GetDescription())); paginationSpecification.AppalyPaging(dataTableRequest.Start, dataTableRequest.Length); PaginatedData <EmailTableModel> paginatedData = _emailRepository.GetPaginated(paginationSpecification); DataTableResult <EmailTableModel> dataTableResult = new DataTableResult <EmailTableModel>( draw: dataTableRequest.Draw, recordsFilterd: paginatedData.Count, recordsTotal: paginatedData.Count, error: null, data: paginatedData.Data); return(Result.Ok(dataTableResult)); }
public ActionResult Index(int?id, int?page, int?per_page) { if ((!page.HasValue || !per_page.HasValue) && !id.HasValue) { var completeQuery = from category in db.Categories select new CategoryData { id = category.Id, name = category.Name, description = category.Description }; return(Json(completeQuery.ToList(), JsonRequestBehavior.AllowGet)); } var total = db.Categories.Count(); var total_pages = Math.Ceiling(Convert.ToDouble(total) / Convert.ToDouble(per_page)); var query = from category in db.Categories select category; if (id != null) { query = query.Where(c => c.Id == id); } else { query = query.OrderBy(c => c.Id); query = query.Skip((page.Value - 1) * per_page.Value).Take(per_page.Value); } List <CategoryData> categoriesList = new List <CategoryData>(); foreach (var category in query) { var categoryData = new CategoryData(); categoryData.id = category.Id; categoryData.name = category.Name; categoryData.description = category.Description; categoriesList.Add(categoryData); } if (!id.HasValue) { var paginated = new PaginatedData <CategoryData> { current_page = page.Value, per_page = per_page.ToString(), total_pages = Convert.ToInt32(total_pages), total_entries = total, values = categoriesList }; return(Json(paginated, JsonRequestBehavior.AllowGet)); } else { return(Json(categoriesList[0], JsonRequestBehavior.AllowGet)); } }
public void RefeshData(object obj) { IsRefreshing = true; pageIndex = 1; PaginatedData.Clear(); GetPaginatedData(obj); IsRefreshing = false; }
public ActionResult Index(int? id, int? page, int? per_page) { if ((!page.HasValue || !per_page.HasValue) && !id.HasValue) { var completeQuery = from category in db.Categories select new CategoryData { id = category.Id, name = category.Name, description = category.Description }; return Json(completeQuery.ToList(), JsonRequestBehavior.AllowGet); } var total = db.Categories.Count(); var total_pages = Math.Ceiling(Convert.ToDouble(total) / Convert.ToDouble(per_page)); var query = from category in db.Categories select category; if (id != null) { query = query.Where(c => c.Id == id); } else { query = query.OrderBy(c => c.Id); query = query.Skip((page.Value - 1) * per_page.Value).Take(per_page.Value); } List<CategoryData> categoriesList = new List<CategoryData>(); foreach (var category in query) { var categoryData = new CategoryData(); categoryData.id = category.Id; categoryData.name = category.Name; categoryData.description = category.Description; categoriesList.Add(categoryData); } if (!id.HasValue) { var paginated = new PaginatedData<CategoryData> { current_page = page.Value, per_page = per_page.ToString(), total_pages = Convert.ToInt32(total_pages), total_entries = total, values = categoriesList }; return Json(paginated, JsonRequestBehavior.AllowGet); } else { return Json(categoriesList[0], JsonRequestBehavior.AllowGet); } }
public static PaginatedData <TResult> Transform <TSource, TResult>(this PaginatedData <TSource> paginatedData, Func <TSource, TResult> transform) { return(new PaginatedData <TResult> { Results = paginatedData.Results.Select(transform).ToList(), TotalCount = paginatedData.TotalCount }); }
public Result <DataTableResult <UserTableModel> > GetGroupUsers(string roleId, DataTableRequest request) { ValidationResult validationResult = _dataTableValidator.Validate(request); if (!validationResult.IsValid) { _logger.LogWarning($"Invalid {nameof(DataTableRequest)} model"); return(Result.Fail <DataTableResult <UserTableModel> >(ResultUtils.ToResultError(validationResult.Errors.ToList()))); } BaseSpecification <RoleEntity> roleSpecification = new BaseSpecification <RoleEntity>(); roleSpecification.AddFilter(x => x.Id == roleId); roleSpecification.AddFilter(x => x.Type == RoleTypes.Group); bool existResult = _roleRepository.Exist(roleSpecification); if (!existResult) { _logger.LogWarning($"GroupRole with id {roleId} does not exist"); return(Result.Fail <DataTableResult <UserTableModel> >("no_role", "No Role")); } PaginationSpecification <GroupUserEntity, UserTableModel> baseSpecification = new PaginationSpecification <GroupUserEntity, UserTableModel>(); baseSpecification.AddFilter(x => x.RoleId == roleId); baseSpecification.AddSelect(x => new UserTableModel( x.User.Id, x.User.UserName, x.Group.Name)); if (!string.IsNullOrEmpty(request.Search)) { string search = request.Search.ToUpper(); baseSpecification.AddFilter(x => x.User.Id.ToUpper().Contains(search) || x.User.Email.ToUpper().Contains(search) || x.User.UserName.ToUpper().Contains(search) || x.User.FirstName.ToUpper().Contains(search) || x.User.LastName.ToUpper().Contains(search)); } baseSpecification.AppalyPaging(request.Start, request.Length); baseSpecification.AddInclude(x => x.User); PaginatedData <UserTableModel> paginationData = _groupUserRepository.GetPaginated(baseSpecification); DataTableResult <UserTableModel> result = new DataTableResult <UserTableModel>( draw: request.Draw, recordsTotal: paginationData.Count, recordsFilterd: paginationData.Count, error: null, data: paginationData.Data); return(Result.Ok(result)); }
public Result <DataTableResult <UserListViewModel> > GetAll(DataTableRequest request) { ValidationResult validationResult = _dataTableValidator.Validate(request); if (!validationResult.IsValid) { return(Result.Fail <DataTableResult <UserListViewModel> >(ResultUtils.ToResultError(validationResult.Errors.ToList()))); } PaginationSpecification <AppUserEntity, UserListViewModel> baseSpecification = new PaginationSpecification <AppUserEntity, UserListViewModel>(); if (!string.IsNullOrEmpty(request.Search)) { string search = request.Search.ToUpper(); baseSpecification.AddFilter(x => x.Id.ToUpper().Contains(search) || x.Email.ToUpper().Contains(search) || x.UserName.ToUpper().Contains(search) || x.FirstName.ToUpper().Contains(search) || x.LastName.ToUpper().Contains(search)); } baseSpecification.AppalyPaging(request.Start, request.Length); baseSpecification.AddSelect(x => new UserListViewModel( x.Id, x.UserName, x.Email, x.FirstName, x.LastName)); PaginatedData <UserListViewModel> paginationData = _userRepository.GetPaginated(baseSpecification); DataTableResult <UserListViewModel> result = new DataTableResult <UserListViewModel>( draw: request.Draw, recordsTotal: paginationData.Count, recordsFilterd: paginationData.Count, error: null, data: paginationData.Data); return(Result.Ok(result)); }
public static PaginatedData <T> Paginate <T>( this IEnumerable <T> query, Pagination pagination ) { var result = new PaginatedData <T>(query.Count()); if (null != pagination.Offset) { query = query.Skip((int)pagination.Offset); } if (null != pagination.Limit) { query = query.Take((int)pagination.Limit); } result.Data = query.ToArray(); return(result); }
public Result <DataTableResult <GroupInviteTableModel> > Get(string groupId, DataTableRequest dataTableRequest) { ValidationResult validationResult = _dataTableRequestValidator.Validate(dataTableRequest); if (!validationResult.IsValid) { _logger.LogWarning($"Invalid {nameof(DataTableRequest)} model"); return(Result.Fail <DataTableResult <GroupInviteTableModel> >(validationResult.Errors)); } PaginationSpecification <InviteEntity, GroupInviteTableModel> paginationSpecification = new PaginationSpecification <InviteEntity, GroupInviteTableModel>(); paginationSpecification.AddFilter(x => x.GroupId == groupId); if (!string.IsNullOrEmpty(dataTableRequest.Search)) { paginationSpecification.AddFilter(x => x.Email.ToUpper().Contains(dataTableRequest.Search.ToUpper())); } paginationSpecification.AddSelect(x => new GroupInviteTableModel( x.Id, x.Email, x.GroupRole.Name, x.Status.ToString(), x.ExpiresAt.ToString(DateTimeFormats.DEFAULT_DATE_TIME_FORMAT))); paginationSpecification.AppalyPaging(dataTableRequest.Start, dataTableRequest.Length); PaginatedData <GroupInviteTableModel> paginatedData = _inviteRepository.GetPaginated(paginationSpecification); DataTableResult <GroupInviteTableModel> dataTableResult = new DataTableResult <GroupInviteTableModel>( draw: dataTableRequest.Draw, recordsTotal: paginatedData.Count, recordsFilterd: paginatedData.Count, error: null, data: paginatedData.Data); return(Result.Ok(dataTableResult)); }
public async Task <PaginatedData <TopicPageModel.ReplyModel> > BuildTopicPageModelRepliesAsync(Guid topicId, QueryOptions options) { var repliesQuery = _dbContext.Posts .Include(x => x.CreatedByUser) .Where(x => x.TopicId == topicId && x.Status == StatusType.Published && x.IsAnswer == false); if (!string.IsNullOrWhiteSpace(options.Search)) { repliesQuery = repliesQuery.Where(x => x.Content.Contains(options.Search)); } var replies = await repliesQuery .OrderBy(x => x.CreatedOn) .Skip(options.Skip) .Take(options.PageSize) .ToListAsync(); var items = replies.Select(reply => new TopicPageModel.ReplyModel { Id = reply.Id, Content = Markdown.ToHtml(reply.Content), OriginalContent = reply.Content, IdentityUserId = reply.CreatedByUser.IdentityUserId, UserId = reply.CreatedByUser.Id, UserDisplayName = reply.CreatedByUser.DisplayName, TimeStamp = reply.CreatedOn, GravatarHash = _gravatarService.HashEmailForGravatar(reply.CreatedByUser.Email), IsAnswer = reply.IsAnswer }).ToList(); var totalRecords = await repliesQuery.CountAsync(); var result = new PaginatedData <TopicPageModel.ReplyModel>(items, totalRecords, options.PageSize); return(result); }
public Result <DataTableResult <GroupUserTableModel> > Get(string id, DataTableRequest dataTableRequest) { ValidationResult validationResult = _dataTableValidator.Validate(dataTableRequest); if (!validationResult.IsValid) { _logger.LogWarning($"Invalid DataTableRequest model"); return(Result.Fail <DataTableResult <GroupUserTableModel> >(validationResult.Errors)); } PaginationSpecification <GroupUserEntity, GroupUserTableModel> paginationSpecification = new PaginationSpecification <GroupUserEntity, GroupUserTableModel>(); paginationSpecification.AddFilter(x => x.GroupId == id); if (!string.IsNullOrEmpty(dataTableRequest.Search)) { paginationSpecification.AddFilter(x => x.User.NormalizedUserName.Contains(dataTableRequest.Search.ToUpper())); } paginationSpecification.AddSelect(x => new GroupUserTableModel( x.Id, x.User.Id, x.User.UserName, x.Role.Id, x.Role.Name)); paginationSpecification.AppalyPaging(dataTableRequest.Start, dataTableRequest.Length); PaginatedData <GroupUserTableModel> paginatedData = _groupUserRepository.GetPaginated(paginationSpecification); DataTableResult <GroupUserTableModel> dataTableResult = new DataTableResult <GroupUserTableModel>( draw: dataTableRequest.Draw, recordsTotal: paginatedData.Count, recordsFilterd: paginatedData.Count, error: null, data: paginatedData.Data); return(Result.Ok(dataTableResult)); }
public Result <DataTableResult <RoleListViewModel> > GetAll(DataTableRequest request) { ValidationResult validationResult = _dataTableValidator.Validate(request); if (!validationResult.IsValid) { _logger.LogWarning($"Invalid DataTableRequest model"); return(Result.Fail <DataTableResult <RoleListViewModel> >(ResultUtils.ToResultError(validationResult.Errors.ToList()))); } PaginationSpecification <RoleEntity, RoleListViewModel> baseSpecification = new PaginationSpecification <RoleEntity, RoleListViewModel>(); if (!string.IsNullOrEmpty(request.Search)) { string search = request.Search.ToUpper(); baseSpecification.AddFilter(x => x.Id.ToUpper().Contains(search) || x.Name.ToUpper().Contains(search)); } baseSpecification.AppalyPaging(request.Start, request.Length); baseSpecification.AddSelect(x => new RoleListViewModel( x.Id, x.Name, x.Type.ToString())); PaginatedData <RoleListViewModel> pagedResult = _roleRepository.GetPaginated(baseSpecification); DataTableResult <RoleListViewModel> result = new DataTableResult <RoleListViewModel>( draw: request.Draw, recordsTotal: pagedResult.Count, recordsFilterd: pagedResult.Count, error: null, data: pagedResult.Data); return(Result.Ok(result)); }
public Result <DataTableResult <RoleAssignmentTableModel> > Get(string roleId, DataTableRequest dataTableRequest) { ValidationResult validationResult = _dataTableValidator.Validate(dataTableRequest); if (!validationResult.IsValid) { _logger.LogWarning($"Invalid {nameof(DataTableRequest)} model"); return(Result.Fail <DataTableResult <RoleAssignmentTableModel> >(validationResult.Errors)); } PaginationSpecification <RoleEntity, RoleAssignmentTableModel> paginationSpecification = new PaginationSpecification <RoleEntity, RoleAssignmentTableModel>(); paginationSpecification.AddFilter(x => x.Id != roleId); paginationSpecification.AddFilter(x => x.Type == Core.Data.Enums.Entity.RoleTypes.Group); if (!string.IsNullOrEmpty(dataTableRequest.Search)) { paginationSpecification.AddFilter(x => x.NormalizedName.Contains(dataTableRequest.Search.ToUpper())); } paginationSpecification.AddSelect(x => new RoleAssignmentTableModel( x.Id, x.Name, x.CanBeAssignedBy.Any(c => c.RoleId == roleId))); paginationSpecification.AppalyPaging(dataTableRequest.Start, dataTableRequest.Length); PaginatedData <RoleAssignmentTableModel> paginatedResult = _roleRepository.GetPaginated(paginationSpecification); DataTableResult <RoleAssignmentTableModel> dataTableResult = new DataTableResult <RoleAssignmentTableModel>( draw: dataTableRequest.Draw, recordsTotal: paginatedResult.Count, recordsFilterd: paginatedResult.Count, error: null, data: paginatedResult.Data); return(Result.Ok(dataTableResult)); }
public void GetPaginated_Customer_Succeed(PaginatedData paginatedData) { //Arrange using (var context = new ManagementContext()) { var executor = new SqlExecutor(context.Database.Connection.ConnectionString); executor.ExecuteScript(Path.Combine(Environment.CurrentDirectory, "Scripts", "2 - Customers.sql")); var unitOfWork = new DatabaseUnitOfWork(context); var customerRepository = new CustomerRepository(unitOfWork); //Act PaginatedResult <Customer> result = customerRepository.GetPaginated(null, null, p => p.Id, paginatedData.PageIndex, paginatedData.PageSize); //Assert Assert.AreEqual(paginatedData.ResultCount, result.Result.Count()); Assert.AreEqual(paginatedData.PageIndex, result.PageIndex); Assert.AreEqual(paginatedData.PageSize, result.PageSize); Assert.AreEqual(paginatedData.TotalCount, result.TotalCount); Assert.AreEqual(paginatedData.TotalPageCount, result.TotalPageCount); Assert.AreEqual(paginatedData.HasPreviousPage, result.HasPreviousPage); Assert.AreEqual(paginatedData.HasNextPage, result.HasNextPage); } }
public PaginatedData <SimpleMovie> GetMoviesList(MovieSearchRequest request) { var query = MoviesRepository.GetMovies(request.Name, request.GenreIds, request.Country, request.LengthFrom, request.LengthTo); return(PaginatedData <SimpleMovie> .Create(query, request, entityList => Mapper.Map <List <SimpleMovie> >(entityList))); }
public ActionResult Index(int? id, int? page, int? per_page) { if ((!page.HasValue || !per_page.HasValue) && !id.HasValue) { var completeQuery = from product in db.Products select product; List<ProductData> allProducts = new List<ProductData>(); foreach (var item in completeQuery) { var product = new ProductData { id = item.Id, name = item.Name, description = item.Description, unit_price = item.UnitPrice.ToString(), valid_to = item.ValidTo.ToShortDateString(), category_id = item.Category_Id }; allProducts.Add(product); } return Json(allProducts, JsonRequestBehavior.AllowGet); } var total = db.Products.Count(); var total_pages = Math.Ceiling(Convert.ToDouble(total) / Convert.ToDouble(per_page)); var query = from product in db.Products select product; if (id != null) { query = query.Where(p => p.Id == id); } else { query = query.OrderBy(p => p.Id); query = query.Skip((page.Value - 1) * per_page.Value).Take(per_page.Value); } List<ProductData> productsList = new List<ProductData>(); foreach (var product in query) { var productData = new ProductData(); productData.id = product.Id; productData.name = product.Name; productData.description = product.Description; productData.unit_price = product.UnitPrice.ToString(); productData.valid_to = product.ValidTo.ToShortDateString(); productData.category_id = product.Category_Id; productsList.Add(productData); } if (!id.HasValue) { var paginated = new PaginatedData<ProductData> { current_page = page.Value, per_page = per_page.ToString(), total_pages = Convert.ToInt32(total_pages), total_entries = total, values = productsList }; return Json(paginated, JsonRequestBehavior.AllowGet); } else { return Json(productsList[0], JsonRequestBehavior.AllowGet); } }
public void GetPaginated_Customer_Succeed(PaginatedData paginatedData) { //Arrange using (var context = new ManagementContext()) { var executor = new SqlExecutor(context.Database.Connection.ConnectionString); executor.ExecuteScript(Path.Combine(Environment.CurrentDirectory, "Scripts", "2 - Customers.sql")); var unitOfWork = new DatabaseUnitOfWork(context); var customerRepository = new CustomerRepository(unitOfWork); //Act PaginatedResult<Customer> result = customerRepository.GetPaginated(null, null, p => p.Id, paginatedData.PageIndex, paginatedData.PageSize); //Assert Assert.AreEqual(paginatedData.ResultCount, result.Result.Count()); Assert.AreEqual(paginatedData.PageIndex, result.PageIndex); Assert.AreEqual(paginatedData.PageSize, result.PageSize); Assert.AreEqual(paginatedData.TotalCount, result.TotalCount); Assert.AreEqual(paginatedData.TotalPageCount, result.TotalPageCount); Assert.AreEqual(paginatedData.HasPreviousPage, result.HasPreviousPage); Assert.AreEqual(paginatedData.HasNextPage, result.HasNextPage); } }
public PaginatedData <SimpleUser> GetUsersList(UserSearchRequest request) { var query = Repository.GetUserList(request.Username); return(PaginatedData <SimpleUser> .Create(query, request, entityList => Mapper.Map <List <SimpleUser> >(entityList))); }