app/services/account_search_service.rb

   1 # frozen_string_literal: true
   2
   3 class AccountSearchService < BaseService
   4   attr_reader :query, :limit, :offset, :options, :account
   5
   6   def call(query, account = nil, options = {})
   7     @acct_hint = query.start_with?('@')
   8     @query     = query.strip.gsub(/\A@/, '')
   9     @limit     = options[:limit].to_i
  10     @offset    = options[:offset].to_i
  11     @options   = options
  12     @account   = account
  13
  14     search_service_results.compact.uniq
  15   end
  16
  17   private
  18
  19   def search_service_results
  20     return [] if query.blank? || limit < 1
  21
  22     [exact_match] + search_results
  23   end
  24
  25   def exact_match
  26     return unless offset.zero? && username_complete?
  27
  28     return @exact_match if defined?(@exact_match)
  29
  30     @exact_match = begin
  31       if options[:resolve]
  32         ResolveAccountService.new.call(query)
  33       elsif domain_is_local?
  34         Account.find_local(query_username)
  35       else
  36         Account.find_remote(query_username, query_domain)
  37       end
  38     end
  39   end
  40
  41   def search_results
  42     return [] if limit_for_non_exact_results.zero?
  43
  44     @search_results ||= begin
  45       results = from_elasticsearch if Chewy.enabled?
  46       results ||= from_database
  47       results
  48     end
  49   end
  50
  51   def from_database
  52     if account
  53       advanced_search_results
  54     else
  55       simple_search_results
  56     end
  57   end
  58
  59   def advanced_search_results
  60     Account.advanced_search_for(terms_for_query, account, limit_for_non_exact_results, options[:following], offset)
  61   end
  62
  63   def simple_search_results
  64     Account.search_for(terms_for_query, limit_for_non_exact_results, offset)
  65   end
  66
  67   def from_elasticsearch
  68     must_clauses   = [{ multi_match: { query: terms_for_query, fields: likely_acct? ? %w(acct.edge_ngram acct) : %w(acct.edge_ngram acct display_name.edge_ngram display_name), type: 'most_fields', operator: 'and' } }]
  69     should_clauses = []
  70
  71     if account
  72       return [] if options[:following] && following_ids.empty?
  73
  74       if options[:following]
  75         must_clauses << { terms: { id: following_ids } }
  76       elsif following_ids.any?
  77         should_clauses << { terms: { id: following_ids, boost: 100 } }
  78       end
  79     end
  80
  81     query     = { bool: { must: must_clauses, should: should_clauses } }
  82     functions = [reputation_score_function, followers_score_function, time_distance_function]
  83
  84     records = AccountsIndex.query(function_score: { query: query, functions: functions, boost_mode: 'multiply', score_mode: 'avg' })
  85                            .limit(limit_for_non_exact_results)
  86                            .offset(offset)
  87                            .objects
  88                            .compact
  89
  90     ActiveRecord::Associations::Preloader.new.preload(records, :account_stat)
  91
  92     records
  93   rescue Faraday::ConnectionFailed, Parslet::ParseFailed
  94     nil
  95   end
  96
  97   def reputation_score_function
  98     {
  99       script_score: {
 100         script: {
 101           source: "(doc['followers_count'].value + 0.0) / (doc['followers_count'].value + doc['following_count'].value + 1)",
 102         },
 103       },
 104     }
 105   end
 106
 107   def followers_score_function
 108     {
 109       field_value_factor: {
 110         field: 'followers_count',
 111         modifier: 'log2p',
 112         missing: 0,
 113       },
 114     }
 115   end
 116
 117   def time_distance_function
 118     {
 119       gauss: {
 120         last_status_at: {
 121           scale: '30d',
 122           offset: '30d',
 123           decay: 0.3,
 124         },
 125       },
 126     }
 127   end
 128
 129   def following_ids
 130     @following_ids ||= account.active_relationships.pluck(:target_account_id)
 131   end
 132
 133   def limit_for_non_exact_results
 134     if exact_match?
 135       limit - 1
 136     else
 137       limit
 138     end
 139   end
 140
 141   def terms_for_query
 142     if domain_is_local?
 143       query_username
 144     else
 145       query
 146     end
 147   end
 148
 149   def split_query_string
 150     @split_query_string ||= query.split('@')
 151   end
 152
 153   def query_username
 154     @query_username ||= split_query_string.first || ''
 155   end
 156
 157   def query_domain
 158     @query_domain ||= query_without_split? ? nil : split_query_string.last
 159   end
 160
 161   def query_without_split?
 162     split_query_string.size == 1
 163   end
 164
 165   def domain_is_local?
 166     @domain_is_local ||= TagManager.instance.local_domain?(query_domain)
 167   end
 168
 169   def exact_match?
 170     exact_match.present?
 171   end
 172
 173   def username_complete?
 174     query.include?('@') && "@#{query}" =~ Account::MENTION_RE
 175   end
 176
 177   def likely_acct?
 178     @acct_hint || username_complete?
 179   end
 180 end