public async Task <ActionResult <FoundUsersPageDto> > GetAllUsers([FromQuery] int pageNumber = 1, int pageSize = 10)
        {
            var model = await _accountBl.GetUsersList(pageNumber, pageSize);

            var outputModel = new UsersPageDto()
            {
                Items      = _mapper.Map <IEnumerable <User>, IEnumerable <UserMinimalDto> >(model.List),
                PageNumber = pageNumber,
                PageSize   = pageSize,
                TotalItems = model.TotalItems
            };

            return(new OkObjectResult(outputModel));
        }
Example #2
0
        public async Task<IHttpActionResult> GetUsers(int page = 1, string role = null)
        {
            List<ApplicationUser> users;

            // Variables initialized depending on whether role specified
            int totalUsers;
            int maxPage;
            int skipUsers;

            // If no role specified, just query the last 30 users
            if (string.IsNullOrWhiteSpace(role))
            {
                totalUsers = await _db.Users.CountAsync();
                // The maximum number of pages, rounded up
                maxPage = ((totalUsers + pageSize + 1) / pageSize);
                page = Math.Max(1, page);
                page = Math.Min(maxPage, page);
                skipUsers = (page - 1) * pageSize;

                users = await  _db.Users
                    .OrderBy(u => u.Id)
                    .Include(u => u.Roles)
                    .Skip(skipUsers)
                    .Take(pageSize)
                    .ToListAsync();
            }
            else
            {
                var roleId = RoleManager.GetRoleIdFromRoleName(role);

                totalUsers = await _db.Users
                    .Where(u => u.Roles.Any(r => r.RoleId == roleId))
                    .CountAsync();

                // The maximum number of pages, rounded up
                maxPage = ((totalUsers + pageSize - 1) / pageSize);
                page = Math.Max(1, page);
                page = Math.Min(maxPage, page);
                skipUsers = (page - 1) * pageSize;

                users = await _db.Users
                    .Where(u => u.Roles.Any(r => r.RoleId == roleId))
                    .OrderBy(u=> u.Id)
                    .Include(u => u.Roles)
                    .Skip(skipUsers)
                    .Take(pageSize)
                    .ToListAsync();
            }

            UsersPageDto result = new UsersPageDto()
            {
                Users = new List<UserDto>(),
                HasNext = (page < maxPage),
                HasPrev = (page > 1),
                NumPages = maxPage,
                CurrentCount = totalUsers
            };

            // Convert the user objects to a list of serializable data transfer objects
            foreach (var user in users)
            {   
                result.Users.Add(ToDto.UserToDto(user));
            }

            return Ok(result);
        }
Example #3
0
        public async Task <IHttpActionResult> GetUsers(int page = 1, string role = null)
        {
            List <ApplicationUser> users;

            // Variables initialized depending on whether role specified
            int totalUsers;
            int maxPage;
            int skipUsers;

            // If no role specified, just query the last 30 users
            if (string.IsNullOrWhiteSpace(role))
            {
                totalUsers = await _db.Users.CountAsync();

                // The maximum number of pages, rounded up
                maxPage   = ((totalUsers + pageSize + 1) / pageSize);
                page      = Math.Max(1, page);
                page      = Math.Min(maxPage, page);
                skipUsers = (page - 1) * pageSize;

                users = await _db.Users
                        .OrderBy(u => u.Id)
                        .Include(u => u.Roles)
                        .Skip(skipUsers)
                        .Take(pageSize)
                        .ToListAsync();
            }
            else
            {
                var roleId = RoleManager.GetRoleIdFromRoleName(role);

                totalUsers = await _db.Users
                             .Where(u => u.Roles.Any(r => r.RoleId == roleId))
                             .CountAsync();

                // The maximum number of pages, rounded up
                maxPage   = ((totalUsers + pageSize - 1) / pageSize);
                page      = Math.Max(1, page);
                page      = Math.Min(maxPage, page);
                skipUsers = (page - 1) * pageSize;

                users = await _db.Users
                        .Where(u => u.Roles.Any(r => r.RoleId == roleId))
                        .OrderBy(u => u.Id)
                        .Include(u => u.Roles)
                        .Skip(skipUsers)
                        .Take(pageSize)
                        .ToListAsync();
            }

            UsersPageDto result = new UsersPageDto()
            {
                Users        = new List <UserDto>(),
                HasNext      = (page < maxPage),
                HasPrev      = (page > 1),
                NumPages     = maxPage,
                CurrentCount = totalUsers
            };

            // Convert the user objects to a list of serializable data transfer objects
            foreach (var user in users)
            {
                result.Users.Add(ToDto.UserToDto(user));
            }

            return(Ok(result));
        }