Example #1
0
        public async Task <PagedResultDto <BaseIdentityUserDto> > GetAll(GetBaseIdentityUsersInput input)
        {
            var orgQueryable = await _orgRepository.GetQueryableAsync();

            var userOrgQueryable = await _userOrgsRepository.GetQueryableAsync();

            if (input.OrganizationId.HasValue)
            {
                var userDbSet = await UserRepository.GetDbSetAsync();

                var org = await _orgRepository.GetAsync(input.OrganizationId.Value);

                var orgs = await(await _orgRepository.GetQueryableAsync()).Where(_ => _.CascadeId.Contains(org.CascadeId)).ToListAsync();

                var totalCount = await userOrgQueryable.Where(_ => orgs.Select(o => o.Id).Contains(_.OrganizationId))
                                 .GroupBy(_ => _.UserId)
                                 .LongCountAsync();

                //TODO: Redis Query
                var userIds = await userOrgQueryable.Where(_ => orgs.Select(o => o.Id).Contains(_.OrganizationId))
                              .Select(_ => _.UserId)
                              .Distinct()
                              .Skip(input.SkipCount)
                              .Take(input.MaxResultCount)
                              .ToListAsync();

                var items = await userDbSet.WhereIf(!string.IsNullOrWhiteSpace(input.Filter), _ => _.UserName.Contains(input.Filter))
                            .Where(_ => userIds.Contains(_.Id)).ToListAsync();

                var userOrgs = await userOrgQueryable.Where(_ => items.Select(i => i.Id).Contains(_.UserId))
                               .ToListAsync();

                var allOrg = await orgQueryable.Where(_ => userOrgs.Select(uo => uo.OrganizationId).Contains(_.Id))
                             .OrderBy(_ => _.CascadeId)
                             .ToListAsync();

                var dtos = ObjectMapper.Map <List <IdentityUser>, List <BaseIdentityUserDto> >(items);

                foreach (var dto in dtos)
                {
                    var oids = userOrgs.Where(_ => _.UserId == dto.Id).Select(_ => _.OrganizationId);
                    dto.OrganizationNames = string.Join(", ", allOrg.Where(_ => oids.Contains(_.Id)).Select(_ => _.Name).ToArray());
                }
                return(new PagedResultDto <BaseIdentityUserDto>(totalCount, dtos));
            }
            else
            {
                var totalCount = await UserRepository.GetCountAsync(input.Filter);

                var items = await UserRepository.GetListAsync(input.Sorting, input.MaxResultCount, input.SkipCount, input.Filter);

                //TODO: Redis Query
                var userOrgs = await userOrgQueryable.Where(_ => items.Select(i => i.Id).Contains(_.UserId))
                               .ToListAsync();

                var orgs = await orgQueryable.Where(_ => userOrgs.Select(uo => uo.OrganizationId).Contains(_.Id))
                           .OrderBy(_ => _.CascadeId)
                           .ToListAsync();

                var dtos = ObjectMapper.Map <List <IdentityUser>, List <BaseIdentityUserDto> >(items);
                foreach (var dto in dtos)
                {
                    var oids = userOrgs.Where(_ => _.UserId == dto.Id).Select(_ => _.OrganizationId);
                    dto.OrganizationNames = string.Join(", ", orgs.Where(_ => oids.Contains(_.Id)).Select(_ => _.Name).ToArray());
                }
                return(new PagedResultDto <BaseIdentityUserDto>(totalCount, dtos));
            }
        }
Example #2
0
 public Task <PagedResultDto <BaseIdentityUserDto> > GetAll(GetBaseIdentityUsersInput input)
 {
     return(_userAppService.GetAll(input));
 }