/// <summary> /// Method for getting a list of all roles /// </summary> /// <param name = "model"> Search Model </param> /// <param name = "onlyActive"> Activity flag </param> /// <returns> </returns> public RoleListVm GetAllPaged(PaginatedQueryM model, bool onlyActive) { var listRoles = onlyActive ? _context.Roles.Where(x => x.Status == RoleStatuses.Active) : _context.Roles; var total = listRoles.Count(); var roles = listRoles .Skip(Pagination.CalculateSkip(model.PageSize, model.Page, total)) .Take(model.PageSize) .OrderBy(x => x.Name) .ToList(); var rolesIds = roles.Select(v => v.Id).ToList(); var usersCount = (from u in _context.Users join ur in _context.UserRoles on u.Id equals ur.UserId join r in _context.Roles on ur.RoleId equals r.Id where rolesIds.Contains(r.Id) && u.Status == UserStatuses.Active group r by r.Id into g select new { RoleId = g.Key, Count = g.Count() }).ToDictionary(v => v.RoleId, v => v.Count); foreach (var role in roles) { usersCount.TryGetValue(role.Id, out var value); role.ActiveUsers = value; } return(RoleListVm.Create(roles.Select(RoleVm.Create), total, (int)Math.Ceiling((double)total / model.PageSize))); }
/// <summary> /// Method returning a list of all addresses /// </summary> /// <param name = "page"> Page </param> /// <param name = "pageSize"> Page size </param> /// <param name = "predicate"> Predicate </param> /// <returns> </returns> public async Task <AddressListModel> GetAsync( int page, int pageSize, Expression <Func <Address, bool> > predicate = null) { IQueryable <Address> query = _context.Address.Include(x => x.Region); if (predicate != null) { query = query.Where(predicate); } var total = await query.CountAsync(); var resultGroup = await query .Skip(Pagination.CalculateSkip(pageSize, page, total)) .Take(pageSize) .ToListAsync(); return(new AddressListModel { TotalCount = total, CurrentPage = page, Addresses = Mapper.Map <IList <AddressModel> >(resultGroup ?? new List <Address>()), PageSize = pageSize, TotalPages = (int)Math.Ceiling((double)total / pageSize) }); }
private async Task <SearchVm <QueueLogVm> > GetQueueLogForActivityUpload(int queueId, PaginatedQueryM query) { var orderBy = string.IsNullOrEmpty(query.SortBy) ? nameof(DataUploadingLog.Id) : query.SortBy; var orderRule = query.SortAscending ? "ASC" : "DESC"; var filtered = _dbContext.DataUploadingLogs .Where(x => x.DataSourceQueueId == queueId) .OrderBy($"{orderBy} {orderRule}") .GroupBy(x => x.TargetStatId); var total = await filtered.CountAsync(); var result = (await filtered .Skip(Pagination.CalculateSkip(query.PageSize, query.Page, total)) .Take(query.PageSize) .AsNoTracking() .ToListAsync()) .Select(x => new DataUploadingLog { DataSourceQueue = x.FirstOrDefault()?.DataSourceQueue, EndImportDate = x.Select(y => y.EndImportDate).Max(), StartImportDate = x.Select(y => y.StartImportDate).Max(), TargetStatId = x.FirstOrDefault()?.TargetStatId, StatUnitName = x.FirstOrDefault()?.StatUnitName, Status = x.Any(y => y.Status == DataUploadingLogStatuses.Error) ? DataUploadingLogStatuses.Error : x.Any(y => y.Status == DataUploadingLogStatuses.Warning) ? DataUploadingLogStatuses.Warning : DataUploadingLogStatuses.Done, Note = x.FirstOrDefault()?.Note, }); return(SearchVm <QueueLogVm> .Create(result.Select(QueueLogVm.Create), total)); }
public async Task <SearchVm <QueueVm> > GetAllDataSourceQueues(SearchQueryM query) { var sortBy = string.IsNullOrEmpty(query.SortBy) ? "Id" : query.SortBy; var orderRule = query.OrderByValue == OrderRule.Asc && !string.IsNullOrEmpty(query.SortBy) ? "ASC" : "DESC"; var filtered = _dbContext.DataSourceQueues .Include(x => x.DataSource) .Include(x => x.User) .AsNoTracking(); if (query.Status.HasValue) { filtered = filtered.Where(x => x.Status == query.Status.Value); } if (query.DateFrom.HasValue && query.DateTo.HasValue) { filtered = filtered.Where(x => x.StartImportDate >= query.DateFrom.Value && x.StartImportDate <= query.DateTo.Value); } else { if (query.DateFrom.HasValue) { filtered = filtered.Where(x => x.StartImportDate >= query.DateFrom.Value); } if (query.DateTo.HasValue) { filtered = filtered.Where(x => x.StartImportDate <= query.DateTo.Value); } } filtered = filtered.OrderBy($"{sortBy} {orderRule}"); var total = await filtered.CountAsync(); var result = await filtered .Skip(Pagination.CalculateSkip(query.PageSize, query.Page, total)) .Take(query.PageSize) .AsNoTracking() .ToListAsync(); return(SearchVm <QueueVm> .Create(result.Select(QueueVm.Create), total)); }
/// <summary> /// Method for obtaining a list of regions /// </summary> /// <param name = "model"> Model </param> /// <param name = "predicate"> Predicate </param> /// <returns> </returns> public async Task <SearchVm <Region> > ListAsync(PaginatedQueryM model, Expression <Func <Region, bool> > predicate = null) { IQueryable <Region> query = _context.Regions; if (predicate != null) { query = query.Where(predicate); } var total = await query.CountAsync(); var regions = await query.OrderBy(v => v.Code) .Skip(Pagination.CalculateSkip(model.PageSize, model.Page, total)) .Take(model.PageSize) .ToListAsync(); return(SearchVm <Region> .Create(regions, total)); }
private async Task <SearchVm <QueueLogVm> > GetQueueLogForStatUnitUpload(int queueId, PaginatedQueryM query) { var orderBy = string.IsNullOrEmpty(query.SortBy) ? nameof(DataUploadingLog.Id) : query.SortBy; var orderRule = query.SortAscending ? "ASC" : "DESC"; var filtered = _dbContext.DataUploadingLogs .Where(x => x.DataSourceQueueId == queueId) .OrderBy($"{orderBy} {orderRule}"); var total = await filtered.CountAsync(); var result = await filtered .Skip(Pagination.CalculateSkip(query.PageSize, query.Page, total)) .Take(query.PageSize) .AsNoTracking() .ToListAsync(); return(SearchVm <QueueLogVm> .Create(result.Select(QueueLogVm.Create), total)); }
/// <summary> /// Method for obtaining all data sources /// </summary> /// <param name = "query"> Request </param> /// <returns> </returns> public async Task <SearchVm <DataSourceVm> > GetAllDataSources(SearchQueryM query) { var wildcard = query.Wildcard; var statUnitType = query.StatUnitType; var priority = (DataSourcePriority)query.Priority; var allowedOperations = (DataSourceAllowedOperation)query.AllowedOperations; var sortBy = string.IsNullOrEmpty(query.SortBy) ? "Id" : query.SortBy; var orderRule = query.OrderByValue == OrderRule.Asc ? "ASC" : "DESC"; var filtered = _context.DataSources .AsNoTracking() .Where(ds => string.IsNullOrEmpty(wildcard) || ds.Name.ToLower().Contains(wildcard.ToLower())) .Where(ds => statUnitType == 0 || ds.StatUnitType == (StatUnitTypes)statUnitType) .Where(ds => priority == 0 || ds.Priority == priority) .Where(ds => allowedOperations == 0 || ds.AllowedOperations == allowedOperations) .OrderBy($"{sortBy} {orderRule}"); var total = await filtered.CountAsync(); if (query.GetAll) { var res = await filtered.ToListAsync(); return(SearchVm <DataSourceVm> .Create(res.Select(DataSourceVm.Create), total)); } var result = await filtered .Skip(Pagination.CalculateSkip(query.PageSize, query.Page, total)) .Take(query.PageSize) .ToListAsync(); return(SearchVm <DataSourceVm> .Create(result.Select(DataSourceVm.Create), total)); }
/// <summary> /// Method to get all users /// </summary> /// <param name = "filter"> Filter </param> /// <returns> </returns> public async Task <UserListVm> GetAllPagedAsync(UserListFilter filter) { var query = _context.Users.AsNoTracking(); if (filter.Status.HasValue) { query = query.Where(u => u.Status == filter.Status.Value); } if (filter.RoleId != null) { query = query.Where(u => u.UserRoles.Any(v => v.RoleId == filter.RoleId)); } if (filter.UserName != null) { query = query.Where(u => u.Name.ToLower().Contains(filter.UserName.ToLower())); } if (filter.Description != null) { query = query.Where(u => u.Description.Contains(filter.Description)); } var total = query.Count(); var orderable = total == 0 ? Array.Empty <UserListItemVm>().AsQueryable() : query.Select(UserListItemVm.Creator); if (filter.SortBy != null) { //TODO: USE LINQ DYNAMIC + ATTRIBUTES switch (filter.SortBy.UpperFirstLetter()) { case nameof(UserListItemVm.Name): orderable = Order(orderable, v => v.Name, filter.SortAscending); break; case nameof(UserListItemVm.CreationDate): orderable = Order(orderable, v => v.CreationDate, filter.SortAscending); break; case nameof(UserListItemVm.Description): orderable = Order(orderable, v => v.Description, filter.SortAscending); break; default: orderable = Order(orderable, v => v.Status, filter.SortAscending); break; } } var users = orderable .Skip(Pagination.CalculateSkip(filter.PageSize, filter.Page, total)) .Take(filter.PageSize); var usersList = users.ToList(); var userIds = usersList.Select(v => v.Id).ToList(); var roles = from userRole in _context.UserRoles join role in _context.Roles on userRole.RoleId equals role.Id where userIds.Contains(userRole.UserId) select new { userRole.UserId, role.Id, role.Name }; var lookup = roles.ToLookup( v => v.UserId, v => new UserRoleVm { Id = v.Id, Name = v.Name } ); var allRegions = await _regionsService.GetAllRegionTreeAsync(nameof(Resource.UserRegions)); foreach (var user in usersList) { user.Roles = lookup[user.Id].ToList(); } return(UserListVm.Create( usersList, allRegions, total, (int)Math.Ceiling((double)total / filter.PageSize) )); }