private static List <AzureUser> GetSorted(this List <AzureUser> users, UserSortingParameters sorting)
{
if (sorting.Sort == Consts.UsersSorting.City)
{
users = sorting.By == Consts.UsersSorting.Descending ? users.OrderByDescending(x => x.City).ToList() : users.OrderBy(x => x.City).ToList();
}
if (sorting.Sort == Consts.UsersSorting.Id)
{
users = sorting.By == Consts.UsersSorting.Descending ? users.OrderByDescending(x => x.ObjectId).ToList() : users.OrderBy(x => x.ObjectId).ToList();
}
if (sorting.Sort == Consts.UsersSorting.Name)
{
users = sorting.By == Consts.UsersSorting.Descending ? users.OrderByDescending(x => x.DisplayName).ToList() : users.OrderBy(x => x.DisplayName).ToList();
}
if (sorting.Sort == Consts.UsersSorting.Role)
{
users = sorting.By == Consts.UsersSorting.Descending ? users.OrderByDescending(x => x.Role).ToList() : users.OrderBy(x => x.Role).ToList();
}
if (sorting.Sort == Consts.UsersSorting.State)
{
users = sorting.By == Consts.UsersSorting.Descending ? users.OrderByDescending(x => x.State).ToList() : users.OrderBy(x => x.State).ToList();
}
return(users);
}
public static List <AzureUser> GetByParameters(this List <AzureUser> users, UserFilteringParams filters = null, UserSortingParameters sorting = null)
{
if (filters != null)
{
users = users.GetFiltered(filters);
}
if (sorting != null)
{
users = users.GetSorted(sorting);
}
return(users.Skip(filters?.Offset ?? 0)
.Take(filters?.Limit ?? users.Count).ToList());
}
public async Task <IActionResult> Get([FromQuery] UserFilteringParams filter, [FromQuery] UserSortingParameters sorting)
{
try
{
var currentUser = new UserIdentityParams
{
Id = HttpContext.User.Claims.FirstOrDefault(x => x.Type == Consts.UserIdPropertyName)?.Value,
Role = HttpContext.User.Claims.FirstOrDefault(x => x.Type == Consts.RoleClaimType)?.Value,
CompanyId = HttpContext.User.Claims.FirstOrDefault(x => x.Type == Consts.CompanyIdClaimType)?.Value
};
var users = await _userService.GetAllUsersAsync(currentUser, filter, sorting);
_logger.LogInformation("Get all users requested by user with object id {id}, users: {users}", currentUser.Id, string.Join(",", users.Result.Select(user => $"{user.GivenName ?? ""} {user.Surname ?? ""}")));
return(Ok(users));
}
catch (ArgumentException ex)
{
return(BadRequest(ex.Message));
}
catch (AccessException)
{
return(new ContentResult {
StatusCode = 403
});
}
}
public IActionResult GetTotalInCompanies([FromQuery] List <string> companyIds, [FromQuery] UserSortingParameters sorting, [FromQuery] LazyLoadParameters lazyParameters)
{
try
{
var userRole = HttpContext.User.Claims.FirstOrDefault(x => x.Type == Consts.RoleClaimType)?.Value;
if (!string.IsNullOrEmpty(userRole) && !Consts.Roles.GlobalAdmins.Contains(userRole.ToLower()))
{
return(new ContentResult {
StatusCode = 403
});
}
var usersCount = _userService.GetUsersCountInCompanies(companyIds, sorting, lazyParameters);
return(Ok(usersCount));
}
catch (ArgumentException ex)
{
return(BadRequest(ex.Message));
}
}
/// <inheritdoc />
public async Task <LazyLoadedResult <Profile> > GetAllUsersAsync(UserIdentityParams user, UserFilteringParams filter = null, UserSortingParameters sorting = null)
{
await _permissionService.CheckPermissionExpiration();
if (_permissionService.CheckPermission(user.Role, new string[] { Consts.UsersReadPermission.ReadAll }))
{
return(await GetUsers(filter, sorting));
}
if (_permissionService.CheckPermission(user.Role, new string[] { Consts.UsersReadPermission.ReadInCompany }))
{
filter.CompanyId = new List <string> {
user.CompanyId
};
return(await GetUsers(filter, sorting));
}
if (_permissionService.CheckPermission(user.Role, new string[] { Consts.UsersReadPermission.ReadOnlyRequester }))
{
var salesRep = await GetUserByIdAsync(user.Id.ToString(), user);
salesRep.AvatarUrl = FormUrlForDownloadUserAvatar(salesRep.ObjectId);
return(new LazyLoadedResult <Profile>()
{
Result = new List <Profile> {
salesRep.Adapt <Profile>()
},
Limit = 1,
Offset = 0,
Total = 1
});
}
throw new ArgumentException("Can not check you permission");
}
private async Task <LazyLoadedResult <Profile> > GetUsers(UserFilteringParams filter = null, UserSortingParameters sorting = null)
{
var statuses = await _requestStatusRepository.GetAsync();
var users = _cache.Get <IEnumerable <AzureUser> >(Consts.Cache.UsersKey)
.Join(statuses, user => user.StatusId, status => status.Id, (user, status) =>
{
user.RequestStatus = status;
return(user);
}).ToList();
var searchedUsers = users.GetByParameters(filter, sorting);
searchedUsers.ForEach(x => x.AvatarUrl = FormUrlForDownloadUserAvatar(x.ObjectId));
return(await Task.FromResult(new LazyLoadedResult <Profile>
{
Result = searchedUsers?.Adapt <IEnumerable <Profile> >(),
Limit = filter?.Limit,
Offset = filter?.Offset,
Total = searchedUsers?.Count
}));
}
/// <inheritdoc />
public Dictionary <string, int> GetUsersCountInCompanies(List <string> companyIds, UserSortingParameters sorting, LazyLoadParameters lazyParameters)
{
var result = new Dictionary <string, int>();
var usersInCache = _cache.Get <List <AzureUser> >(Consts.Cache.UsersKey);
if (companyIds != null && companyIds.Any())
{
foreach (var companyId in companyIds)
{
var usersInCompanyCount = usersInCache.Where(x => x.CompanyId == companyId).Count();
result.Add(companyId, usersInCompanyCount);
}
return(result);
}
var grouped = usersInCache.GroupBy(x => x.CompanyId);
if (sorting?.By == Consts.UsersSorting.Descending)
{
grouped = grouped.OrderByDescending(x => x.Count());
}
if (sorting?.By == Consts.UsersSorting.Ascending)
{
grouped = grouped.OrderBy(x => x.Count());
}
grouped = grouped.Where(x => x.Key != null)
.Skip(lazyParameters?.Offset ?? 0)
.Take(lazyParameters?.Limit ?? grouped.Count());
foreach (var value in grouped)
{
result.Add(value.Key, value.Count());
}
return(result);
}
