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

module JamRuby

  # not a active_record model; just a search result container
  class Search
    attr_accessor :results, :search_type
    attr_accessor :user_counters, :page_num, :page_count

    LIMIT = 10

    SEARCH_TEXT_TYPES = [:musicians, :bands, :fans]
    SEARCH_TEXT_TYPE_ID = :search_text_type

    def self.band_search(txt, user = nil)
      self.text_search({ SEARCH_TEXT_TYPE_ID => :bands, :query => txt }, user)
    end

    def self.fan_search(txt, user = nil)
      self.text_search({ SEARCH_TEXT_TYPE_ID => :fans, :query => txt }, user)
    end

    def self.musician_search(txt, user = nil)
      self.text_search({ SEARCH_TEXT_TYPE_ID => :musicians, :query => txt }, user)
    end

    def self.session_invite_search(query, user)
      srch = Search.new
      srch.search_type = :session_invite
      like_str = "%#{query.downcase}%"
      rel = User
        .musicians
        .where(["users.id IN (SELECT friend_id FROM friendships WHERE user_id = '#{user.id}')"])
        .where(["first_name ILIKE ? OR last_name ILIKE ?", like_str, like_str])
        .limit(10)
        .order([:last_name, :first_name])
      srch.results = rel.all
      srch
    end

    def self.text_search(params, user = nil)
      srch = Search.new
      unless (params.blank? || params[:query].blank? || 2 > params[:query].length)
        srch.text_search(params, user)
      end
      srch
    end

    def text_search(params, user = nil)
      tsquery = Search.create_tsquery(params[:query])
      return [] if tsquery.blank?

      rel = case params[SEARCH_TEXT_TYPE_ID].to_s
            when 'bands'
              @search_type = :bands
              Band.scoped
            when 'fans'
              @search_type = :fans
              User.fans
            else
              @search_type = :musicians
              User.musicians
            end
      @results = rel.where("(name_tsv @@ to_tsquery('jamenglish', ?))", tsquery).limit(10)
      @results
    end

    def initialize(search_results=nil)
      @results = []
      self
    end
    
    def self.create_tsquery(query)
      return nil if query.blank?

      search_terms = query.split
      return nil if search_terms.length == 0

      args = nil
      search_terms.each do |search_term|
        if args == nil  
          args = search_term
        else
          args = args + " & " + search_term
        end
      end
      args = args + ":*"
      args
    end

    PARAM_SESSION_INVITE = :srch_sessinv
    PARAM_MUSICIAN = :srch_m
    PARAM_BAND = :srch_b
    PARAM_FEED = :srch_f

    F_PER_PAGE = B_PER_PAGE = M_PER_PAGE = 20
    M_MILES_DEFAULT = 500
    B_MILES_DEFAULT = 0

    M_ORDER_FOLLOWS = ['Most Followed', :followed]
    M_ORDER_PLAYS = ['Most Plays', :plays]
    M_ORDER_PLAYING = ['Playing Now', :playing]
    ORDERINGS = B_ORDERINGS = M_ORDERINGS = [M_ORDER_FOLLOWS, M_ORDER_PLAYS, M_ORDER_PLAYING]
    B_ORDERING_KEYS = M_ORDERING_KEYS = M_ORDERINGS.collect { |oo| oo[1] }

    DISTANCE_OPTS = B_DISTANCE_OPTS = M_DISTANCE_OPTS = [['Any', 0], [1000.to_s, 1000], [500.to_s, 500], [250.to_s, 250], [100.to_s, 100], [50.to_s, 50], [25.to_s, 25]]

    F_SORT_RECENT = ['Most Recent', :date]
    F_SORT_OLDEST = ['Most Liked', :likes]
    F_SORT_LENGTH = ['Most Played', :plays]
    F_SORT_OPTS = [F_SORT_RECENT, F_SORT_LENGTH, F_SORT_OLDEST]

    SHOW_BOTH = ['Sessions & Recordings', :all]
    SHOW_SESSIONS = ['Sessions', :music_session]
    SHOW_RECORDINGS = ['Recordings', :recording]
    SHOW_OPTS = [SHOW_BOTH, SHOW_SESSIONS, SHOW_RECORDINGS]

    DATE_OPTS = [['Today', 'today'], ['This Week', 'week'], ['This Month', 'month'], ['All Time', 'all']]

    def self.order_param(params, keys=M_ORDERING_KEYS)
      ordering = params[:orderby]
      ordering.blank? ? keys[0] : keys.detect { |oo| oo.to_s == ordering }
    end

    def self.musician_filter(params={}, current_user=nil)
      rel = User.musicians
      unless (instrument = params[:instrument]).blank?
        rel = rel.joins("RIGHT JOIN musicians_instruments AS minst ON minst.user_id = users.id")
          .where(['minst.instrument_id = ? AND users.id IS NOT NULL', instrument])
      end

      rel = MaxMindGeo.where_latlng(rel, params, current_user)

      sel_str = 'users.*'
      case ordering = self.order_param(params)
      when :plays  # FIXME:  double counting?
        sel_str = "COUNT(records)+COUNT(sessions) AS play_count, #{sel_str}"
        rel = rel.joins("LEFT JOIN music_sessions AS sessions ON sessions.user_id = users.id")
          .joins("LEFT JOIN recordings AS records ON records.owner_id = users.id")
          .group("users.id")
          .order("play_count DESC, users.created_at DESC")
      when :followed
        sel_str = "COUNT(follows) AS search_follow_count, #{sel_str}"
        rel = rel.joins("LEFT JOIN follows ON follows.followable_id = users.id")
          .group("users.id")
          .order("COUNT(follows) DESC, users.created_at DESC")
      when :playing
        rel = rel.joins("LEFT JOIN connections ON connections.user_id = users.id")
          .where(['connections.music_session_id IS NOT NULL AND connections.aasm_state != ?',
                  'expired'])
          .order("users.created_at DESC")
      end

      rel = rel.select(sel_str)
      rel, page = self.relation_pagination(rel, params)
      rel = rel.includes([:instruments, :followings, :friends])

      objs = rel.all
      srch = Search.new
      srch.search_type = :musicians_filter
      srch.page_num, srch.page_count = page, objs.total_pages
      srch.musician_results_for_user(objs, current_user)
    end

    def self.relation_pagination(rel, params)
      perpage = [(params[:per_page] || M_PER_PAGE).to_i, 100].min
      page = [params[:page].to_i, 1].max
      [rel.paginate(:page => page, :per_page => perpage), page]
    end

    RESULT_FOLLOW = :follows
    RESULT_FRIEND = :friends

    COUNT_FRIEND = :count_friend
    COUNT_FOLLOW = :count_follow
    COUNT_RECORD = :count_record
    COUNT_SESSION = :count_session
    COUNTERS = [COUNT_FRIEND, COUNT_FOLLOW, COUNT_RECORD, COUNT_SESSION]

    def musician_results_for_user(_results, user)
      @results = _results
      if user
        @user_counters = @results.inject({}) { |hh,val| hh[val.id] = []; hh }
        mids = "'#{@results.map(&:id).join("','")}'"

        # this gets counts for each search result on friends/follows/records/sessions
        @results.each do |uu|
          counters = { }
          counters[COUNT_FRIEND] = Friendship.where(:user_id => uu.id).count
          counters[COUNT_FOLLOW] = Follow.where(:followable_id => uu.id).count
          counters[COUNT_RECORD] = ClaimedRecording.where(:user_id => uu.id).count
          counters[COUNT_SESSION] = MusicSession.where(:user_id => uu.id).count
          @user_counters[uu.id] << counters
        end

        # this section determines follow/like/friend status for each search result
        # so that action links can be activated or not
        rel = User.select("users.id AS uid")
        rel = rel.joins("LEFT JOIN follows ON follows.user_id = '#{user.id}'")
        rel = rel.where(["users.id IN (#{mids}) AND follows.followable_id = users.id"])
        rel.all.each { |val| @user_counters[val.uid] << RESULT_FOLLOW }

        rel = User.select("users.id AS uid")
        rel = rel.joins("LEFT JOIN friendships AS friends ON friends.friend_id = '#{user.id}'")
        rel = rel.where(["users.id IN (#{mids}) AND friends.user_id = users.id"])
        rel.all.each { |val| @user_counters[val.uid] << RESULT_FRIEND }

      else
        @user_counters = {}
      end
      self
    end

    private 

    def _count(musician, key)
      if mm = @user_counters[musician.id] 
        return mm.detect { |ii| ii.is_a?(Hash) }[key]
      end if @user_counters
      0
    end

    public

    def session_invite_search?
      :session_invite == @search_type 
    end

    def musicians_text_search?
      :musicians == @search_type 
    end

    def fans_text_search?
      :fans == @search_type 
    end

    def bands_text_search?
      :bands == @search_type 
    end

    def musicians_filter_search?
      :musicians_filter == @search_type
    end

    def bands_filter_search?
      :band_filter == @search_type
    end

    def follow_count(musician)
      _count(musician, COUNT_FOLLOW)
    end

    def friend_count(musician)
      _count(musician, COUNT_FRIEND)
    end

    def record_count(musician)
      _count(musician, COUNT_RECORD)
    end

    def session_count(musician)
      _count(musician, COUNT_SESSION)
    end

    def is_friend?(musician)
      if mm = @user_counters[musician.id] 
        return mm.include?(RESULT_FRIEND)
      end if @user_counters
      false
    end
    def is_follower?(musician)
      if mm = @user_counters[musician.id] 
        return mm.include?(RESULT_FOLLOW)
      end if @user_counters
      false
    end

    def self.new_musicians(usr, since_date=Time.now - 1.week, max_count=50, radius=M_MILES_DEFAULT)
      rel = User.musicians
        .where(['created_at >= ? AND users.id != ?', since_date, usr.id])
        .within(radius, :origin => [usr.lat, usr.lng])
        .order('created_at DESC')
        .limit(max_count)
      objs = rel.all.to_a
      if block_given?
        yield(objs) if 0 < objs.count
      else
        return objs
      end
    end

    def self.band_filter(params={}, current_user=nil)
      rel = Band.scoped

      unless (genre = params[:genre]).blank?
        rel = Band.joins("RIGHT JOIN bands_genres AS bgenres ON bgenres.band_id = bands.id")
          .where(['bgenres.genre_id = ? AND bands.id IS NOT NULL', genre])
      end

      rel = MaxMindGeo.where_latlng(rel, params, current_user)

      sel_str = 'bands.*'
      case ordering = self.order_param(params)
      when :plays  # FIXME:  double counting?
        sel_str = "COUNT(records)+COUNT(msh) AS play_count, #{sel_str}"
        rel = rel.joins("LEFT JOIN music_sessions AS msh ON msh.band_id = bands.id")
          .joins("LEFT JOIN recordings AS records ON records.band_id = bands.id")
          .group("bands.id")
          .order("play_count DESC, bands.created_at DESC")
      when :followed
        sel_str = "COUNT(follows) AS search_follow_count, #{sel_str}"
        rel = rel.joins("LEFT JOIN follows ON follows.followable_id = bands.id")
          .group("bands.id")
          .order("COUNT(follows) DESC, bands.created_at DESC")
      when :playing
        rel = rel.joins("LEFT JOIN music_sessions AS msh ON msh.band_id = bands.id")
          .where('msh.music_session_id IS NOT NULL AND msh.session_removed_at IS NULL')
          .order("bands.created_at DESC")
      end

      rel = rel.select(sel_str)
      rel, page = self.relation_pagination(rel, params)
      rel = rel.includes([{ :users => :instruments }, :genres ])

      objs = rel.all
      srch = Search.new
      srch.search_type = :band_filter
      srch.page_num, srch.page_count = page, objs.total_pages
      srch.band_results_for_user(objs, current_user)
    end

    def band_results_for_user(_results, user)
      @results = _results
      if user
        @user_counters = @results.inject({}) { |hh,val| hh[val.id] = []; hh }
        mids = "'#{@results.map(&:id).join("','")}'"

        # this gets counts for each search result 
        @results.each do |bb|
          counters = { }
          counters[COUNT_FOLLOW] = Follow.where(:followable_id => bb.id).count
          counters[COUNT_RECORD] = Recording.where(:band_id => bb.id).count
          counters[COUNT_SESSION] = MusicSession.where(:band_id => bb.id).count
          @user_counters[bb.id] << counters
        end

        # this section determines follow/like/friend status for each search result
        # so that action links can be activated or not

        rel = Band.select("bands.id AS bid")
        rel = rel.joins("LEFT JOIN follows ON follows.user_id = '#{user.id}'")
        rel = rel.where(["bands.id IN (#{mids}) AND follows.followable_id = bands.id"])
        rel.all.each { |val| @user_counters[val.bid] << RESULT_FOLLOW }

      else
        @user_counters = {}
      end
      self
    end

  end
end