public async Task <PagedResultDto <IdentityUserDto> > GetAll(GetIdentityUsersInput input)
{
List <Guid> orgIds = null;
//TODO：
//if (input.OrgId.HasValue)
//{
// var org = await _orgRepository.GetAsync(input.OrgId.Value);
// orgIds = await _orgRepository.Where(_ => _.CascadeId.Contains(org.CascadeId)).Select(_ => _.Id).ToListAsync();
//}
var totalCount = await UserRepository.GetCountAsync(input.Filter);
//TODO：
var items = await UserRepository.GetListAsync(input.Sorting, input.MaxResultCount, input.SkipCount, input.Filter);
//TODO：
//var orgs = await _orgRepository.Where(_ => items.Select(i => i.OrgId).Contains(_.Id)).ToListAsync();
var dtos = ObjectMapper.Map <List <IdentityUser>, List <IdentityUserDto> >(items);
//TODO：
//foreach (var dto in dtos)
//{
// dto.OrgIdToName = orgs.FirstOrDefault(_ => _.Id == dto.OrgId)?.Name;
//}
return(new PagedResultDto <IdentityUserDto>(totalCount, dtos));
}
public override async Task <PagedResultDto <IdentityUserDto> > GetListAsync([FromQuery] GetIdentityUsersInput input)
{
using (dataFilter.Disable())
{
return(await UserAppService.GetListAsync(input));
}
}
public virtual async Task <PagedResultDto <IdentityUserDto> > GetListAsync(GetIdentityUsersInput input)
{
return(await RequestAsync <PagedResultDto <IdentityUserDto> >(nameof(GetListAsync), new ClientProxyRequestTypeValue
{
{ typeof(GetIdentityUsersInput), input }
}));
}
public async Task <PagedResultDto <IdentityUserDto> > ListAsync(GetUserListInput input)
{
var request = new GetIdentityUsersInput();
request.Filter = input.filter?.Trim();
request.MaxResultCount = input.PageSize;
request.SkipCount = (input.pageIndex - 1) * input.PageSize;
request.Sorting = " LastModificationTime desc";
return(await _identityUserAppService.GetListAsync(request));
}
public virtual async Task <PagedResultDto <IdentityUserDto> > GetListAsync(GetIdentityUsersInput input)
{
var count = await UserRepository.GetCountAsync(input.Filter);
var list = await UserRepository.GetListAsync(input.Sorting, input.MaxResultCount, input.SkipCount, input.Filter);
return(new PagedResultDto <IdentityUserDto>(
count,
ObjectMapper.Map <List <IdentityUser>, List <IdentityUserDto> >(list)
));
}
public override async Task <PagedResultDto <IdentityUserDto> > GetListAsync(GetIdentityUsersInput input)
{
var query = _userRepository
.Where(u => !EF.Property <bool>(u, "IsHostUser"))
.WhereIf(!input.Filter.IsNullOrEmpty(),
u =>
u.UserName.Contains(input.Filter) ||
u.PhoneNumber.Contains(input.Filter) ||
u.Surname.Contains(input.Filter));
var count = await query.CountAsync();
var list = await query.PageBy(input).ToListAsync();
return(new PagedResultDto <IdentityUserDto>(
count,
ObjectMapper.Map <List <IdentityUser>, List <IdentityUserDto> >(list)
));
}
public virtual async Task <PagedResultDto <IdentityUserDto> > GetUsersAsync(Guid id, GetIdentityUsersInput input)
{
return(await OrganizationUnitAppService.GetUsersAsync(id, input));
}
public Task <PagedResultDto <IdentityUserDto> > GetAll(GetIdentityUsersInput input)
{
return(_userAppService.GetAll(input));
}
public Task <PagedResultDto <IdentityUserDto> > GetUsersAsync(Guid?ouId, GetIdentityUsersInput usersInput)
{
return(UnitAppService.GetUsersAsync(ouId, usersInput));
}
public virtual async Task <PagedResultDto <IdentityUserDto> > GetUsersAsync(Guid id, GetIdentityUsersInput input)
{
var origanizationUnit = await OrganizationUnitRepository.GetAsync(id);
var origanizationUnitUserCount = await OrganizationUnitRepository
.GetMembersCountAsync(origanizationUnit, input.Filter);
var origanizationUnitUsers = await OrganizationUnitRepository
.GetMembersAsync(origanizationUnit,
input.Sorting, input.MaxResultCount,
input.SkipCount, input.Filter);
return(new PagedResultDto <IdentityUserDto>(origanizationUnitUserCount,
ObjectMapper.Map <List <IdentityUser>, List <IdentityUserDto> >(origanizationUnitUsers)));
}
public virtual async Task <PagedResultDto <IdentityUserDto> > GetUsersAsync(Guid?ouId, GetIdentityUsersInput userInput)
{
if (!ouId.HasValue)
{
return(await UserAppService.GetListAsync(userInput));
}
IEnumerable <IdentityUser> list = new List <IdentityUser>();
var ou = await UnitRepository.GetAsync(ouId.Value);
var selfAndChildren = await UnitRepository.GetAllChildrenWithParentCodeAsync(ou.Code, ou.Id);
selfAndChildren.Add(ou);
//Consider submitting PR to get its own overloading method containing all the members of the child node
foreach (var child in selfAndChildren)
{
// Find child nodes where users have duplicates (users can have multiple organizations)
//count += await UnitRepository.GetMembersCountAsync(child, usersInput.Filter);
list = Enumerable.Union(list, await UnitRepository.GetMembersAsync(
child,
userInput.Sorting,
//usersInput.MaxResultCount, // So let's think about looking up all the members of the subset
//usersInput.SkipCount,
filter: userInput.Filter
));
}
return(new PagedResultDto <IdentityUserDto>(
list.Count(),
ObjectMapper.Map <List <IdentityUser>, List <IdentityUserDto> >(
list.Skip(userInput.SkipCount).Take(userInput.MaxResultCount)
.ToList()
)
));
}
public override Task <PagedResultDto <IdentityUserDto> > GetListAsync(GetIdentityUsersInput input)
{
return(base.GetListAsync(input));
}
public virtual async Task <PagedResult <IdentityUserDto> > GetListAsync(GetIdentityUsersInput input)
{
var result = await _userAppService.GetListAsync(input);
return(new PagedResult <IdentityUserDto>(result.TotalCount, result.Items));
}
public virtual Task <PagedResultDto <IdentityUserDto> > GetListAsync(GetIdentityUsersInput input)
{
return(UserAppService.GetListAsync(input));
}
