public IQueryable <UserEntity> GetUsersQuery(UserListFilter filter, List <long> userIds, UsersIncludes includes)
{
var query = GetBaseQuery(includes, false)
.Where(o => o.GuildID == filter.Guild.Id.ToString());
if (userIds != null)
{
query = query.Where(o => userIds.Contains(o.ID));
}
if (!string.IsNullOrEmpty(filter.InviteCode))
{
query = query.Where(o => o.UsedInviteCode.Contains(filter.InviteCode));
}
if (filter.OnlyWebAdmin)
{
query = query.Where(o => o.WebAdminPassword != null);
}
if (filter.OnlyApiAccess)
{
query = query.Where(o => o.ApiToken != null);
}
if (filter.OnlyBotAdmin)
{
query = query.Where(o => (o.Flags & (int)UserFlags.BotAdmin) != 0);
}
return(OrderUsers(query, filter.Desc, filter.Order));
}
public ListResult <UserListItem> List(ListCommand cmd, UserListFilter filter, IEnumerable <int> selectedIDs = null)
{
var list = UserRepository.List(cmd, filter, selectedIDs, out var totalRecords);
return(new ListResult <UserListItem>
{
Data = list.ToList(),
TotalRecords = totalRecords
});
}
public ActionResult _Index(
string tabId,
int parentId,
GridCommand command,
[Bind(Prefix = "searchQuery")][ModelBinder(typeof(JsonStringModelBinder <UserListFilter>))] UserListFilter filter)
{
var serviceResult = _service.List(command.GetListCommand(), filter);
return(new TelerikResult(serviceResult.Data, serviceResult.TotalRecords));
}
public ActionResult _MultipleSelect(
string tabId, [FromForm(Name = "IDs")] string ids, int page, int pageSize, string orderBy,
[Bind(Prefix = "searchQuery")]
[ModelBinder(typeof(JsonStringModelBinder <UserListFilter>))] UserListFilter filter)
{
var selectedIDs = Converter.ToInt32Collection(ids, ',');
var listCommand = GetListCommand(page, pageSize, orderBy);
var serviceResult = _service.List(listCommand, filter, selectedIDs);
return(new TelerikResult(serviceResult.Data, serviceResult.TotalRecords));
}
public ActionResult _MultipleSelect(
string tabId,
string IDs,
GridCommand command,
[Bind(Prefix = "searchQuery")][ModelBinder(typeof(JsonStringModelBinder <UserListFilter>))] UserListFilter filter)
{
var selectedIDs = Converter.ToInt32Collection(IDs, ',');
var serviceResult = _service.List(command.GetListCommand(), filter, selectedIDs);
return(new TelerikResult(serviceResult.Data, serviceResult.TotalRecords));
}
public async Task <IEnumerable <UserDto> > GetAll(ApiFilter filter)
{
var result = new List <UserDto>();
try
{
var query = _context.Users.AsQueryable();
var _filter = new UserListFilter();
if (!string.IsNullOrEmpty(filter.Filter))
{
_filter = JsonConvert.DeserializeObject <UserListFilter>(filter.Filter);
}
// Registros a limitar
query.Take(filter.Take);
// Condiciones
query = query.Where(x => _filter.Name == null || (x.Name + "" + x.Lastname).Contains(_filter.Name));
// Ordenamiento
if (!string.IsNullOrEmpty(filter.Sort))
{
if (filter.Sort.ToLower().Equals("name"))
{
if (!filter.Descending)
{
query = query.OrderBy(x => x.Name);
}
else
{
query = query.OrderByDescending(x => x.Name);
}
}
}
// Iteramos para mapear el automapper
foreach (var user in await query.ToListAsync())
{
result.Add(
Mapper.Map <UserDto>(user)
);
}
}
catch (Exception e)
{
// Error logging
}
return(result);
}
public ActionResult _Index(
string tabId,
int parentId,
int page,
int pageSize,
[Bind(Prefix = "searchQuery")][ModelBinder(typeof(JsonStringModelBinder <UserListFilter>))] UserListFilter filter,
string orderBy)
{
var listCommand = GetListCommand(page, pageSize, orderBy);
var serviceResult = _service.List(listCommand, filter);
return(new TelerikResult(serviceResult.Data, serviceResult.TotalRecords));
}
public async Task No_Ambiguous_List_Calls()
{
// This test simply ensures each of the three ListAsync methods can be called without an ambiguous call error
var userFilter = new UserListFilter();
var listFilter = userFilter.AsListFilter();
var cancellationToken = new CancellationTokenSource().Token;
var result = await Fixture.Service.ListAsync();
result = await Fixture.Service.ListAsync(cancellationToken);
result = await Fixture.Service.ListAsync(userFilter);
result = await Fixture.Service.ListAsync(userFilter, cancellationToken);
result = await Fixture.Service.ListAsync(listFilter);
result = await Fixture.Service.ListAsync(listFilter, cancellationToken);
}
internal static IEnumerable <UserListItem> List(ListCommand cmd, UserListFilter filter, IEnumerable <int> selectedIDs, out int totalRecords)
{
using (var scope = new QPConnectionScope())
{
var options = new UserPageOptions
{
SortExpression = !string.IsNullOrWhiteSpace(cmd.SortExpression) ? UserListItem.TranslateSortExpression(cmd.SortExpression) : null,
StartRecord = cmd.StartRecord,
PageSize = cmd.PageSize,
SelectedIDs = selectedIDs
};
if (filter != null)
{
options.Email = filter.Email;
options.FirstName = filter.FirstName;
options.LastName = filter.LastName;
options.Login = filter.Login;
}
var rows = Common.GetUserPage(scope.DbConnection, options, out totalRecords);
return(MapperFacade.UserListItemRowMapper.GetBizList(rows.ToList()));
}
}
public async Task <object> PostUserFilter(UserListFilter filter) => await ApplyFilterAsync(filter).ConfigureAwait(false);
/// <summary>
/// Gets a list of up to 250 of the users.
/// </summary>
public virtual async Task <ListResult <User> > ListAsync(UserListFilter filter, CancellationToken cancellationToken = default)
{
return(await ListAsync(filter?.AsListFilter(), cancellationToken));
}
/// <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)
));
}
public async Task <IActionResult> GetAllUsers([FromQuery] UserListFilter filter)
{
var users = await _userService.GetAllPagedAsync(filter);
return(Ok(users));
}
public Task <IEnumerable <UserInfo> > GetUserListAsync(UserListFilter filter)
{
throw new NotImplementedException();
}
