public static ActivityFilteredResult Map(ActivityFilteredResultModel model)
        {
            if (model == null)
            {
                return(null);
            }

            var mappedActivities = new List <ActivityDto>();

            if (model == null || model.Activities == null)
            {
                return(null);
            }

            foreach (var act in model.Activities)
            {
                mappedActivities.Add(ActivityMapper.Map(act));
            }

            var result = new ActivityFilteredResult
            {
                Activities  = mappedActivities,
                CurrentPage = model.CurrentPage,
                TotalPages  = model.TotalPages
            };

            return(result);
        }
        public ActivityFilteredResultModel GetActiveActivitiesFiltered(int type, int edition,
                                                                       string title, int currentPage)
        {
            int activitiesPerPage = 10;

            var activeStatus = _unitOfWork.ActivityStatusRepository
                               .GetById((int)ActivityStatusEnum.ACT);

            var currentEdition = _unitOfWork.EditionRepository
                                 .GetById(edition);

            if (currentEdition == null || activeStatus == null)
            {
                return(null);
            }

            int skipByPagination = (currentPage - 1) * activitiesPerPage;

            var activities = _unitOfWork.ActivityRepository
                             .GetActiveActivitiesFiltered(activeStatus.Id, type, currentEdition.Id,
                                                          title, skipByPagination, activitiesPerPage);

            var models = new List <ActivityModel>();

            foreach (var act in activities)
            {
                models.Add(ActivityMapper.Map(act));
            }

            int totalActivities = _unitOfWork.ActivityRepository
                                  .GetTotalActivities(activeStatus.Id, type, currentEdition.Id, title);

            double actsPerPage = totalActivities / activitiesPerPage;
            var    totalPages  = (int)Math.Ceiling(actsPerPage);

            var result = new ActivityFilteredResultModel
            {
                Activities  = models,
                CurrentPage = currentPage,
                TotalPages  = totalPages
            };

            return(result);
        }