public async Task <PagedResultDto <NameValueDto> > FindRoles(FindUsersInput input)
        {
            var roleIdsInOrganizationUnit = _organizationUnitRoleRepository.GetAll()
                                            .Where(uou => uou.OrganizationUnitId == input.OrganizationUnitId)
                                            .Select(uou => uou.RoleId);

            var query = _roleManager.Roles
                        .Where(role => !roleIdsInOrganizationUnit.Contains(role.Id))
                        .WhereIf(
                !input.FilterText.IsNullOrWhiteSpace(),
                role =>
                role.DisplayName.Contains(input.FilterText)
                );

            var userCount = await query.CountAsync();

            var users = await query
                        .OrderBy(r => r.DisplayName)
                        .PageBy(input)
                        .ToListAsync();

            return(new PagedResultDto <NameValueDto>(
                       userCount,
                       users.Select(role =>
                                    new NameValueDto(
                                        $"{role.DisplayName}",
                                        role.Id.ToString()
                                        )
                                    ).ToList()
                       ));
        }
        //[AbpAllowAnonymous]
        public async Task <PagedResultDto <NameValueDto> > FindUsers(FindUsersInput input)
        {
            var userIdsInOrganizationUnit = _userOrganizationUnitRepository.GetAll()
                                            .Where(uou => uou.OrganizationUnitId == input.OrganizationUnitId)
                                            .Select(uou => uou.UserId);

            var query = UserManager.Users
                        .Where(user => !userIdsInOrganizationUnit.Contains(user.Id))
                        .WhereIf(!input.FilterText.IsNullOrWhiteSpace(),
                                 user =>
                                 user.UserName.Contains(input.FilterText) ||
                                 user.EmailAddress.Contains(input.FilterText)
                                 );

            var userCount = await query.CountAsync();

            var users = await query
                        .OrderBy(u => u.UserName)
                        .PageBy(input)
                        .ToListAsync();

            return(new PagedResultDto <NameValueDto>(
                       userCount,
                       users.Select(user =>
                                    new NameValueDto(
                                        $"{user.UserName} ({user.EmailAddress})",
                                        user.Id.ToString()
                                        )
                                    ).ToList()
                       ));
        }
Esempio n. 3
0
        public async Task <PagedResultOutput <NameValueDto> > FindUsers(FindUsersInput input)
        {
            if (AbpSession.MultiTenancySide == MultiTenancySides.Host && input.TenantId.HasValue)
            {
                CurrentUnitOfWork.SetFilterParameter(AbpDataFilters.MayHaveTenant, AbpDataFilters.Parameters.TenantId, input.TenantId.Value);
            }

            var query = UserManager.Users
                        .WhereIf(
                !input.Filter.IsNullOrWhiteSpace(),
                u =>
                u.Name.Contains(input.Filter) ||
                u.Surname.Contains(input.Filter) ||
                u.UserName.Contains(input.Filter) ||
                u.EmailAddress.Contains(input.Filter)
                );

            var userCount = await query.CountAsync();

            var users = await query
                        .OrderBy(u => u.Name)
                        .ThenBy(u => u.Surname)
                        .PageBy(input)
                        .ToListAsync();

            return(new PagedResultOutput <NameValueDto>(
                       userCount,
                       users.Select(u =>
                                    new NameValueDto(
                                        u.Name + " " + u.Surname + " (" + u.EmailAddress + ")",
                                        u.Id.ToString()
                                        )
                                    ).ToList()
                       ));
        }
        public async Task <PagedResultOutput <NameValueDto> > FindUsers(FindUsersInput input)
        {
            if (this.AbpSession.MultiTenancySide == MultiTenancySides.Host && input.TenantId.HasValue)
            {
                IActiveUnitOfWork currentUnitOfWork = this.CurrentUnitOfWork;
                int?tenantId = input.TenantId;
                currentUnitOfWork.SetFilterParameter("MayHaveTenant", "tenantId", tenantId.Value);
            }
            IQueryable <User> users  = this.UserManager.Users;
            IQueryable <User> users1 = users.WhereIf <User>(!input.Filter.IsNullOrWhiteSpace(), (User u) => u.Name.Contains(input.Filter) || u.Surname.Contains(input.Filter) || u.UserName.Contains(input.Filter) || u.EmailAddress.Contains(input.Filter));
            int num = await users1.CountAsync <User>();

            IQueryable <User>        users2 = users1;
            IOrderedQueryable <User> name   =
                from u in users2
                orderby u.Name
                select u;
            List <User> listAsync = await name.ThenBy <User, string>((User u) => u.Surname).PageBy <User>(input).ToListAsync <User>();

            List <User> users3 = listAsync;
            int         num1   = num;
            List <User> users4 = users3;
            PagedResultOutput <NameValueDto> pagedResultOutput = new PagedResultOutput <NameValueDto>(num1, (
                                                                                                          from u in users4
                                                                                                          select new NameValueDto(string.Concat(new string[] { u.Name, " ", u.Surname, " (", u.EmailAddress, ")" }), u.Id.ToString())).ToList <NameValueDto>());

            return(pagedResultOutput);
        }
Esempio n. 5
0
        public async Task <PagedResultDto <NameValueDto> > FindUsers(FindUsersInput input)
        {
            if (AbpSession.TenantId != null)
            {
                //Prevent tenants to get other tenant's users.
                input.TenantId = AbpSession.TenantId;
            }

            using (CurrentUnitOfWork.SetTenantId(input.TenantId))
            {
                var query = UserManager.Users
                            .WhereIf(
                    !input.Filter.IsNullOrWhiteSpace(),
                    u =>
                    u.Name.Contains(input.Filter) ||
                    u.Surname.Contains(input.Filter) ||
                    u.UserName.Contains(input.Filter) ||
                    u.EmailAddress.Contains(input.Filter)
                    );

                var userCount = await query.CountAsync();

                var users = await query
                            .OrderBy(u => u.Name)
                            .ThenBy(u => u.Surname)
                            .PageBy(input)
                            .ToListAsync();

                return(new PagedResultDto <NameValueDto>(
                           userCount,
                           users.Select(u =>
                                        new NameValueDto(
                                            u.FullName + " (" + u.EmailAddress + ")",
                                            u.Id.ToString()
                                            )
                                        ).ToList()
                           ));
            }
        }
 public async Task <PagedResultDto <NameValueDto> > FindUsers(FindUsersInput input)
 {
     return(await ApiClient.PostAsync <PagedResultDto <NameValueDto> >(GetEndpoint(nameof(FindUsers)), input));
 }