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