// GetRecommendations gets all recommendations.
func (s *Setup) GetRecommendations(w http.ResponseWriter, r *http.Request) {
    params := r.URL.Query()

    var redisKey string

    if params["page"] != nil {
        redisKey = fmt.Sprintf("recommendation?page=%s", params["page"][0])
    } else {
        redisKey = "recommendation"
    }

    var recommendation *model.RecommendationResult

    cache, err := s.CheckCache(redisKey, recommendation)
    if err != nil {
        helper.DecodeError(w, r, s.l, errUnmarshal, http.StatusInternalServerError)
        return
    }

    if cache {
        json.NewEncoder(w).Encode(recommendation)
        return
    }

    total, err := s.h.GetRecommendationTotalRows()
    if err != nil {
        helper.DecodeError(w, r, s.l, errFetch, http.StatusInternalServerError)
        return
    }

    newPage, err := helper.PageParser(params)
    if err != nil {
        helper.DecodeError(w, r, s.l, errParseInt, http.StatusInternalServerError)
        return
    }

    chapter := &tome.Chapter{NewPage: newPage, TotalResults: total}

    if err := chapter.Paginate(); err != nil {
        helper.DecodeError(w, r, s.l, err.Error(), http.StatusInternalServerError)
        return
    }

    result, err := s.h.GetRecommendations(chapter.Offset, chapter.Limit)
    if err != nil {
        helper.DecodeError(w, r, s.l, errFetch, http.StatusInternalServerError)
        return
    }

    resultFinal := &model.RecommendationResult{
        Data:    result,
        Chapter: chapter,
    }

    err = s.SetCache(redisKey, resultFinal)
    if err != nil {
        helper.DecodeError(w, r, s.l, errMarhsal, http.StatusInternalServerError)
        return
    }

    w.WriteHeader(http.StatusOK)
    json.NewEncoder(w).Encode(resultFinal)
}