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