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

module JamRuby
  class BaseSearch < JsonStore

    attr_accessor :page_count, :results, :page_number

    ANY_VAL_STR = 'any'
    ANY_VAL_INT = -1

    PER_PAGE = 10
    PG_SMALLINT_MAX = 32767

    KEY_SKILL = 'skill_level'
    KEY_GENRES = 'genres'
    KEY_INSTRUMENTS = 'instruments'
    KEY_GIGS = 'concert_gigs'
    KEY_SORT_ORDER = 'sort_order'

    SORT_VALS = %W{ latency distance }
    SORT_ORDERS = { 
      SORT_VALS[0] => 'Latency to Me', 
      SORT_VALS[1] => 'Distance to Me' 
    }

    SKILL_VALS = [ANY_VAL_INT, 1, 2]
    SKILL_LEVELS = { 
      SKILL_VALS[0] => 'Any', 
      SKILL_VALS[1] => 'Amateur',
      SKILL_VALS[2] => 'Pro', 
    }

    GIG_COUNTS = [ANY_VAL_INT, 0, 1, 2, 3, 4]
    GIG_LABELS = { 
      GIG_COUNTS[0] => 'Any',
      GIG_COUNTS[1] => 'under 10', 
      GIG_COUNTS[2] => '10 to 50', 
      GIG_COUNTS[3] => '50 to 100', 
      GIG_COUNTS[4] => 'over 100' 
    }

    INSTRUMENT_PROFICIENCY = {
      1 => 'Beginner',
      2 => 'Intermediate',
      3 => 'Expert',
    }

    JSON_SCHEMA = {
      KEY_SORT_ORDER => SORT_VALS[0],
      KEY_INSTRUMENTS => [],
      KEY_GENRES => [],
      KEY_SKILL => SKILL_VALS[0].to_s,
      KEY_GIGS => GIG_COUNTS[0].to_s,
    }
    JSON_SCHEMA_KEYS = JSON_SCHEMA.keys
    MULTI_VALUE_KEYS = JSON_SCHEMA.collect { |kk,vv| vv.is_a?(Array) ? kk : nil }.compact
    SINGLE_VALUE_KEYS = JSON_SCHEMA.keys - MULTI_VALUE_KEYS

    SEARCH_FILTER_META = {
      per_page: PER_PAGE,
      filter_keys: {
        keys: JSON_SCHEMA_KEYS,
        multi: MULTI_VALUE_KEYS,
        single: SINGLE_VALUE_KEYS,
      },
      sort_order: { keys: SORT_VALS, map: SORT_ORDERS },
    }

    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 self.user_search_filter(user)
      unless ss = user.send(self.name.demodulize.tableize.singularize)
        ss = self.create_search(user)
      end
      ss
    end

    def self.search_filter_json(user)
      self.user_search_filter(user).json
    end

    def self.create_search(user)
      ms = self.new
      ms.user = user
      ms.data_blob = self::JSON_SCHEMA
      ms.save!
      ms
    end

    def self.search_target_class
    end

    def _genres(rel)
      gids = json[KEY_GENRES]
      unless gids.blank?
        gidsql = gids.join("','")
        gpsql = "SELECT player_id FROM genre_players WHERE (player_type = '#{self.class.search_target_class.name}' AND genre_id IN ('#{gidsql}'))"
        rel = rel.where("#{self.class.search_target_class.table_name}.id IN (#{gpsql})")
      end
      rel
    end

    def _instruments(rel)
      rel
    end
    
    def _gigs(rel)
      gg = json[KEY_GIGS].to_i
      rel = rel.where('concert_count = ?',gg) if 0 <= gg
      rel
    end

    def _skills(rel)
      if 0 < (val = json[KEY_SKILL].to_i)
        rel = rel.where(['skill_level = ?', val])
      end
      rel
    end

    def _sort_order(rel)
      val = json[KEY_SORT_ORDER]
      if SORT_VALS[1] == val
        locidispid = self.user.last_jam_locidispid || 0
        my_locid = locidispid / 1000000
        rel = rel.joins("LEFT JOIN geoiplocations AS my_geo ON my_geo.locid = #{my_locid}")
        rel = rel.joins("LEFT JOIN geoiplocations AS other_geo ON users.last_jam_locidispid/1000000 = other_geo.locid")
        rel = rel.group("users.id, my_geo.geog, other_geo.geog")
        rel = rel.order('st_distance(my_geo.geog, other_geo.geog)')
      else
        rel = rel.joins("LEFT JOIN current_scores ON current_scores.a_userid = users.id AND current_scores.b_userid = '#{self.user.id}'")      
        rel = rel.order('current_scores.full_score ASC')
      end
      rel
    end

    def do_search(params={}) 
    end

    def process_results_page(objs)
    end

    def search_includes(rel)
      rel
    end

    def search_results_page(filter=nil, page=1)
      if filter
        self.data_blob = filter
        self.save
      else
        filter = self.data_blob
      end

      rel = do_search(filter)

      @page_number = [page.to_i, 1].max
      rel = rel.paginate(:page => @page_number, :per_page => PER_PAGE)

      rel = self.search_includes(rel)
      @page_count = rel.total_pages

      process_results_page(rel.all)
    end
    
    def reset_filter
      self.data_blob = JSON_SCHEMA
      self.save
    end

    def reset_search_results
      reset_filter
      search_results_page
    end

    def search_type
      self.class.to_s
    end

    def is_blank?
      self.data_blob == JSON_SCHEMA
    end

    def description
    end

  end
end