public async Task <PagedList <PlanModel> > GetAllPlansAsync(TrainingPlanParams trainingPlanParams)
        {
            var trainingPlans = _dataContext.TrainingPlanModel
                                .Include(t => t.Trainings).ThenInclude(t => t.Monday)
                                .Include(t => t.Trainings).ThenInclude(t => t.Tuesday)
                                .Include(t => t.Trainings).ThenInclude(t => t.Wednesday)
                                .Include(t => t.Trainings).ThenInclude(t => t.Thursday)
                                .Include(t => t.Trainings).ThenInclude(t => t.Friday)
                                .Include(t => t.Trainings).ThenInclude(t => t.Saturday)
                                .Include(t => t.Trainings).ThenInclude(t => t.Sunday)
                                .OrderByDescending(p => p.LikeCounter);

            if (!string.IsNullOrEmpty(trainingPlanParams.OrderBy))
            {
                switch (trainingPlanParams.OrderBy)
                {
                case "Newest":
                    trainingPlans = trainingPlans.OrderByDescending(p => p.DateOfCreated);
                    break;

                case "Oldest":
                    trainingPlans = trainingPlans.OrderBy(p => p.DateOfCreated);
                    break;

                default:
                    trainingPlans = trainingPlans.OrderByDescending(p => p.LikeCounter);
                    break;
                }
            }

            return(await PagedList <PlanModel> .CreateListAsync(trainingPlans, trainingPlanParams.PageSize, trainingPlanParams.PageNumber));
        }
        public async Task <IActionResult> GetAllPlansAsync([FromQuery] TrainingPlanParams planParams)
        {
            var plans = await _unitOfWork.Plans.GetAllPlansAsync(planParams);

            if (plans.Count == 0)
            {
                return(NoContent());
            }

            var trainingPlansToReturn = _mapper.Map <IEnumerable <PlanForReturnDTO> >(plans);

            Response.AddPagination(plans.CurrentPage, plans.PageSize, plans.TotalCount, plans.TotalPages);

            return(Ok(trainingPlansToReturn));
        }
        public async Task <IActionResult> GetAllPlansForUserAsync(int userId, int id, [FromQuery] TrainingPlanParams trainingPlanParams)
        {
            var user = await _unitOfWork.Users.FindOneAsync(u => u.UserId == id);

            if (user == null)
            {
                return(BadRequest("Error: The user cannot be found!"));
            }

            var plans = await _unitOfWork.Plans.GetAllPlansForUserAsync(userId, trainingPlanParams);

            if (plans.Count == 0)
            {
                return(NoContent());
            }

            var trainingPlansToReturn = _mapper.Map <IEnumerable <PlanForReturnDTO> >(plans);

            Response.AddPagination(plans.CurrentPage, plans.PageSize, plans.TotalCount, plans.TotalPages);

            return(Ok(trainingPlansToReturn));
        }
        public async Task <PagedList <PlanModel> > GetAllPlansForUserAsync(int whoseUserId, TrainingPlanParams trainingPlanParams)
        {
            var trainingPlans = _dataContext.TrainingPlanModel.Where(p => p.UserId == whoseUserId).Include(p => p.Trainings).OrderByDescending(p => p.LikeCounter);

            if (!string.IsNullOrEmpty(trainingPlanParams.OrderBy))
            {
                switch (trainingPlanParams.OrderBy)
                {
                case "Newest":
                    trainingPlans = trainingPlans.OrderByDescending(p => p.DateOfCreated);
                    break;

                case "Oldest":
                    trainingPlans = trainingPlans.OrderBy(p => p.DateOfCreated);
                    break;

                default:
                    trainingPlans = trainingPlans.OrderByDescending(p => p.LikeCounter);
                    break;
                }
            }

            return(await PagedList <PlanModel> .CreateListAsync(trainingPlans, trainingPlanParams.PageSize, trainingPlanParams.PageNumber));
        }