/// <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)));
}
public async Task <SearchVm <QueueLogVm> > GetQueueLog(int queueId, PaginatedQueryM query)
{
var queue = await _dbContext.DataSourceQueues.Include(x => x.DataSource).FirstAsync(x => x.Id == queueId);
switch (queue.DataSource.DataSourceUploadType)
{
case DataSourceUploadTypes.StatUnits:
return(await GetQueueLogForStatUnitUpload(queueId, query));
case DataSourceUploadTypes.Activities:
return(await GetQueueLogForActivityUpload(queueId, query));
default:
throw new ArgumentOutOfRangeException();
}
}
/// <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));
}
public async Task <IActionResult> List([FromQuery] PaginatedQueryM model) => Ok(await _regionsService.ListAsync(model));
public IActionResult GetAllRoles(
[FromQuery] PaginatedQueryM model,
bool onlyActive = true) =>
Ok(_roleService.GetAllPaged(model, onlyActive));
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));
}
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 <IActionResult> GetQueueLog(int queueId, [FromQuery] PaginatedQueryM query) => Ok(await _svc.GetQueueLog(queueId, query));
