jam-cloud/ruby/lib/jam_ruby/models/feed.rb

module JamRuby
  class Feed < ActiveRecord::Base

    belongs_to :recording, class_name: "JamRuby::Recording", inverse_of: :feed, foreign_key: 'recording_id'
    belongs_to :music_session_history, class_name: "JamRuby::MusicSessionHistory", inverse_of: :feed, foreign_key: 'music_session_id'

    FIXNUM_MAX = (2**(0.size * 8 -2) -1)
    SORT_TYPES = ['date', 'plays', 'likes']
    TIME_RANGES = ['today', 'week', 'month', 'all']
    TYPE_FILTERS = ['session', 'recording', 'all']

    def self.index(params = {})
      limit = params[:limit]
      limit ||= 20
      limit = limit.to_i

      # validate sort
      sort = params[:sort]
      sort ||= 'date'
      raise "not valid sort #{sort}" unless SORT_TYPES.include?(sort)

      start = params[:start]
      if sort == 'date'
        start ||= FIXNUM_MAX
      else
        start ||= 0
      end
      start = start.to_i

      time_range = params[:time_range]
      time_range ||= 'month'
      raise "not valid time_range #{time_range}" unless TIME_RANGES.include?(time_range)

      type_filter = params[:type]
      type_filter ||= 'all'
      raise "not valid type #{type_filter}" unless TYPE_FILTERS.include?(type_filter)

      query = Feed.includes([:recording]).includes([:music_session_history]).limit(limit)

      # handle sort
      if sort == 'date'
        query = query.where("id < #{start}")
        query = query.order('id DESC')
      elsif sort == 'plays'
        query = query.offset(start)
        query = query.order("COALESCE(recordings.play_count, music_sessions_history.play_count) DESC ")
      elsif sort == 'likes'
        query = query.offset(start)
        query = query.order("COALESCE(recordings.like_count, music_sessions_history.like_count) DESC ")
      else
        raise "sort not implemented: #{sort}"
      end

      # handle time range

      # handle type filters
      if type_filter == 'session'
        query = query.where('music_session_id is not NULL')
      elsif type_filter == 'recording'
        query = query.where('recording_id is not NULL')
      end

      if query.length == 0
        [query, nil]
      elsif query.length < limit
        [query, nil]
      else
        if sort == 'date'
          [query, query.last.id]
        else
          [query, start + limit]
        end
      end

    end
  end
end