public List <RulebookDTO> GetRulebooksFiltered(RulebookFilter filter)
        {
            var elementsByPage = 3;

            var rulebooksFiltered = repository.FilterRulebooks(filter.Title,
                                                               filter.Asc, filter.Year);

            if (rulebooksFiltered == null || rulebooksFiltered.Count == 0)
            {
                return(null);
            }

            List <Rulebook> paginationResult;

            if (rulebooksFiltered.Count > elementsByPage)
            {
                paginationResult = rulebooksFiltered
                                   .Skip(filter.Page * elementsByPage)
                                   .Take(elementsByPage)
                                   .ToList();
            }
            else
            {
                paginationResult = rulebooksFiltered;
            }

            var result = RulebookDTOMapper.Map(paginationResult);

            return(result);
        }
        public RulebookDTO GetRulebookById(int id)
        {
            var rulebookById = repository.Find(id);

            if (rulebookById == null)
            {
                return(null);
            }

            var rulebookDTO = RulebookDTOMapper.Map(rulebookById);

            return(rulebookDTO);
        }
        public List <RulebookStarsDTO> GetAllRulebooksWithStars()
        {
            var allRulebooks = repository.GetAll();

            if (allRulebooks == null || allRulebooks.Count == 0)
            {
                return(null);
            }

            var rulebooksDTOs = RulebookDTOMapper.MapWithStars(allRulebooks);

            return(rulebooksDTOs);
        }