Merge remote-tracking branch 'parent/main' into kb_migration

app/services/statuses_search_service.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+class StatusesSearchService < BaseService
+  def call(query, account = nil, options = {})
+    @query   = query&.strip
+    @account = account
+    @options = options
+    @limit   = options[:limit].to_i
+    @offset  = options[:offset].to_i
+    @searchability = options[:searchability]&.to_sym
+
+    status_search_results
+  end
+
+  private
+
+  def status_search_results
+    definition_should = [
+      publicly_searchable,
+      non_publicly_searchable,
+      searchability_limited,
+    ]
+    definition_should << searchability_public if %i(public).include?(@searchability)
+    definition_should << searchability_private if %i(public private).include?(@searchability)
+
+    definition = parsed_query.apply(
+      StatusesIndex.filter(
+        bool: {
+          should: definition_should,
+          minimum_should_match: 1,
+        }
+      )
+    )
+
+    # This is the best way to submit identical queries to multi-indexes though chewy
+    definition.instance_variable_get(:@parameters)[:indices].value[:indices] << PublicStatusesIndex
+
+    results             = definition.collapse(field: :id).order(_id: { order: :desc }).limit(@limit).offset(@offset).objects.compact
+    account_ids         = results.map(&:account_id)
+    account_domains     = results.map(&:account_domain)
+    preloaded_relations = @account.relations_map(account_ids, account_domains)
+
+    results.reject { |status| StatusFilter.new(status, @account, preloaded_relations).filtered? }
+  rescue Faraday::ConnectionFailed, Parslet::ParseFailed
+    []
+  end
+
+  def publicly_searchable
+    {
+      bool: {
+        must_not: {
+          exists: {
+            field: 'searchable_by',
+          },
+        },
+      },
+    }
+  end
+
+  def non_publicly_searchable
+    {
+      bool: {
+        must: [
+          {
+            exists: {
+              field: 'searchable_by',
+            },
+          },
+          {
+            exists: {
+              field: 'searchability',
+            },
+          },
+          {
+            term: { searchable_by: @account.id },
+          },
+        ],
+        must_not: [
+          {
+            term: { searchability: 'limited' },
+          },
+        ],
+      },
+    }
+  end
+
+  def searchability_public
+    {
+      bool: {
+        must: [
+          {
+            exists: {
+              field: 'searchability',
+            },
+          },
+          {
+            term: { searchability: 'public' },
+          },
+        ],
+      },
+    }
+  end
+
+  def searchability_private
+    {
+      bool: {
+        must: [
+          {
+            exists: {
+              field: 'searchability',
+            },
+          },
+          {
+            term: { searchability: 'private' },
+          },
+          {
+            terms: { account_id: following_account_ids },
+          },
+        ],
+      },
+    }
+  end
+
+  def searchability_limited
+    {
+      bool: {
+        must: [
+          {
+            exists: {
+              field: 'searchability',
+            },
+          },
+          {
+            term: { searchability: 'limited' },
+          },
+          {
+            term: { account_id: @account.id },
+          },
+        ],
+      },
+    }
+  end
+
+  def following_account_ids
+    return @following_account_ids if defined?(@following_account_ids)
+
+    account_exists_sql     = Account.where('accounts.id = follows.target_account_id').where(searchability: %w(public private)).reorder(nil).select(1).to_sql
+    status_exists_sql      = Status.where('statuses.account_id = follows.target_account_id').where(reblog_of_id: nil).where(searchability: %w(public private)).reorder(nil).select(1).to_sql
+    following_accounts     = Follow.where(account_id: @account.id).merge(Account.where("EXISTS (#{account_exists_sql})").or(Account.where("EXISTS (#{status_exists_sql})")))
+    @following_account_ids = following_accounts.pluck(:target_account_id)
+  end
+
+  def parsed_query
+    SearchQueryTransformer.new.apply(SearchQueryParser.new.parse(@query))
+  end
+end