Exemplo n.º 1
0
        public async Task <IActionResult> GetUsers([FromQuery] UsersPaginationParams paginationParams)
        {
            if (paginationParams.SkipCurrentUser)
            {
                var currentUserId = int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value);

                var userFromRepo = await this._repo.GetUser(currentUserId);

                paginationParams.UserId = currentUserId;

                if (string.IsNullOrEmpty(paginationParams.Gender))
                {
                    paginationParams.Gender = userFromRepo.Gender == "male" ? "female" : "male";
                }
            }

            var users = await this._repo.GetUsers(paginationParams);

            var usersResponse = this._mapper.Map <IEnumerable <UserForListDto> >(users);

            Response.AddPagination(users.CurrentPage,
                                   users.PageSize,
                                   users.TotalRecords,
                                   users.TotalPages);

            return(Ok(usersResponse));
        }
Exemplo n.º 2
0
        public async Task <PagedList <User> > GetUsers(UsersPaginationParams paginationParams)
        {
            var users = this._context.Users.AsQueryable();

            if (paginationParams.UserId != null)
            {
                users = users.Where(u => u.Id != paginationParams.UserId);
            }

            if (!string.IsNullOrEmpty(paginationParams.Gender))
            {
                users = users.Where(u => u.Gender == paginationParams.Gender);
            }

            if (paginationParams.MaxAge.HasValue && paginationParams.MaxAge.Value >= 0)
            {
                var minDob = DateTime.Today.AddYears(-paginationParams.MaxAge.Value - 1);
                users = users.Where(u => u.DateOfBirth >= minDob);
            }

            if (paginationParams.MinAge.HasValue && paginationParams.MinAge.Value >= 0)
            {
                var maxDbo = DateTime.Today.AddYears(-paginationParams.MinAge.Value);
                users = users.Where(u => u.DateOfBirth <= maxDbo);
            }

            if (paginationParams.UserId != null && paginationParams.Likers)
            {
                var userLikers = await GetUserLikers(paginationParams.UserId.Value);

                users = users.Where(u => userLikers.Contains(u.Id));
            }
            else if (paginationParams.UserId != null && paginationParams.Likees)
            {
                var userLikees = await GetUserLikees(paginationParams.UserId.Value);

                users = users.Where(u => userLikees.Contains(u.Id));
            }

            if (!string.IsNullOrEmpty(paginationParams.OrderBy))
            {
                switch (paginationParams.OrderBy.ToLower())
                {
                case "created":
                    users = paginationParams.OrderDirection == "descending" ?
                            users.OrderByDescending(u => u.Created) :
                            users.OrderBy(u => u.Created);
                    break;

                case "known_as":
                    users = paginationParams.OrderDirection == "descending" ?
                            users.OrderByDescending(u => u.KnownAs) :
                            users.OrderBy(u => u.KnownAs);
                    break;

                case "username":
                    users = paginationParams.OrderDirection == "descending" ?
                            users.OrderByDescending(u => u.Username) :
                            users.OrderBy(u => u.Username);
                    break;

                default:
                    users = paginationParams.OrderDirection == "descending" ?
                            users.OrderByDescending(u => u.LastActive) :
                            users.OrderBy(u => u.LastActive);
                    break;
                }
            }
            else
            {
                users = paginationParams.OrderDirection == "descending" ?
                        users.OrderByDescending(u => u.LastActive) :
                        users.OrderBy(u => u.LastActive);
            }

            return(await PagedList <User> .CreateASync(users,
                                                       paginationParams.PageNumber,
                                                       paginationParams.PageSize));
        }