git.squeep.com Git - akkoma/blob - lib/pleroma/user/search.ex

   1 # Pleroma: A lightweight social networking server
   2 # Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
   3 # SPDX-License-Identifier: AGPL-3.0-only
   4
   5 defmodule Pleroma.User.Search do
   6   alias Pleroma.Pagination
   7   alias Pleroma.Repo
   8   alias Pleroma.User
   9   import Ecto.Query
  10
  11   @similarity_threshold 0.25
  12   @limit 20
  13
  14   def search(query_string, opts \\ []) do
  15     resolve = Keyword.get(opts, :resolve, false)
  16     following = Keyword.get(opts, :following, false)
  17     result_limit = Keyword.get(opts, :limit, @limit)
  18     offset = Keyword.get(opts, :offset, 0)
  19
  20     for_user = Keyword.get(opts, :for_user)
  21
  22     query_string = format_query(query_string)
  23
  24     maybe_resolve(resolve, for_user, query_string)
  25
  26     {:ok, results} =
  27       Repo.transaction(fn ->
  28         Ecto.Adapters.SQL.query(
  29           Repo,
  30           "select set_limit(#{@similarity_threshold})",
  31           []
  32         )
  33
  34         query_string
  35         |> search_query(for_user, following)
  36         |> Pagination.fetch_paginated(%{"offset" => offset, "limit" => result_limit}, :offset)
  37       end)
  38
  39     results
  40   end
  41
  42   defp format_query(query_string) do
  43     # Strip the beginning @ off if there is a query
  44     query_string = String.trim_leading(query_string, "@")
  45
  46     with [name, domain] <- String.split(query_string, "@"),
  47          formatted_domain <- String.replace(domain, ~r/[!-\-|@|[-`|{-~|\/|:]+/, "") do
  48       name <> "@" <> to_string(:idna.encode(formatted_domain))
  49     else
  50       _ -> query_string
  51     end
  52   end
  53
  54   defp search_query(query_string, for_user, following) do
  55     for_user
  56     |> base_query(following)
  57     |> filter_blocked_user(for_user)
  58     |> filter_blocked_domains(for_user)
  59     |> search_subqueries(query_string)
  60     |> union_subqueries
  61     |> distinct_query()
  62     |> boost_search_rank_query(for_user)
  63     |> subquery()
  64     |> order_by(desc: :search_rank)
  65     |> maybe_restrict_local(for_user)
  66   end
  67
  68   defp base_query(_user, false), do: User
  69   defp base_query(user, true), do: User.get_followers_query(user)
  70
  71   defp filter_blocked_user(query, %User{info: %{blocks: blocks}})
  72        when length(blocks) > 0 do
  73     from(q in query, where: not (q.ap_id in ^blocks))
  74   end
  75
  76   defp filter_blocked_user(query, _), do: query
  77
  78   defp filter_blocked_domains(query, %User{info: %{domain_blocks: domain_blocks}})
  79        when length(domain_blocks) > 0 do
  80     domains = Enum.join(domain_blocks, ",")
  81
  82     from(
  83       q in query,
  84       where: fragment("substring(ap_id from '.*://([^/]*)') NOT IN (?)", ^domains)
  85     )
  86   end
  87
  88   defp filter_blocked_domains(query, _), do: query
  89
  90   defp union_subqueries({fts_subquery, trigram_subquery}) do
  91     from(s in trigram_subquery, union_all: ^fts_subquery)
  92   end
  93
  94   defp search_subqueries(base_query, query_string) do
  95     {
  96       fts_search_subquery(base_query, query_string),
  97       trigram_search_subquery(base_query, query_string)
  98     }
  99   end
 100
 101   defp distinct_query(q) do
 102     from(s in subquery(q), order_by: s.search_type, distinct: s.id)
 103   end
 104
 105   defp maybe_resolve(true, user, query) do
 106     case {limit(), user} do
 107       {:all, _} -> :noop
 108       {:unauthenticated, %User{}} -> User.get_or_fetch(query)
 109       {:unauthenticated, _} -> :noop
 110       {false, _} -> User.get_or_fetch(query)
 111     end
 112   end
 113
 114   defp maybe_resolve(_, _, _), do: :noop
 115
 116   defp maybe_restrict_local(q, user) do
 117     case {limit(), user} do
 118       {:all, _} -> restrict_local(q)
 119       {:unauthenticated, %User{}} -> q
 120       {:unauthenticated, _} -> restrict_local(q)
 121       {false, _} -> q
 122     end
 123   end
 124
 125   defp limit, do: Pleroma.Config.get([:instance, :limit_to_local_content], :unauthenticated)
 126
 127   defp restrict_local(q), do: where(q, [u], u.local == true)
 128
 129   defp boost_search_rank_query(query, nil), do: query
 130
 131   defp boost_search_rank_query(query, for_user) do
 132     friends_ids = User.get_friends_ids(for_user)
 133     followers_ids = User.get_followers_ids(for_user)
 134
 135     from(u in subquery(query),
 136       select_merge: %{
 137         search_rank:
 138           fragment(
 139             """
 140              CASE WHEN (?) THEN 0.5 + (?) * 1.3
 141              WHEN (?) THEN 0.5 + (?) * 1.2
 142              WHEN (?) THEN (?) * 1.1
 143              ELSE (?) END
 144             """,
 145             u.id in ^friends_ids and u.id in ^followers_ids,
 146             u.search_rank,
 147             u.id in ^friends_ids,
 148             u.search_rank,
 149             u.id in ^followers_ids,
 150             u.search_rank,
 151             u.search_rank
 152           )
 153       }
 154     )
 155   end
 156
 157   @spec fts_search_subquery(User.t() | Ecto.Query.t(), String.t()) :: Ecto.Query.t()
 158   defp fts_search_subquery(query, term) do
 159     processed_query =
 160       String.trim_trailing(term, "@" <> local_domain())
 161       |> String.replace(~r/[!-\/|@|[-`|{-~|:-?]+/, " ")
 162       |> String.trim()
 163       |> String.split()
 164       |> Enum.map(&(&1 <> ":*"))
 165       |> Enum.join(" | ")
 166
 167     from(
 168       u in query,
 169       select_merge: %{
 170         search_type: ^0,
 171         search_rank:
 172           fragment(
 173             """
 174             ts_rank_cd(
 175               setweight(to_tsvector('simple', regexp_replace(?, '\\W', ' ', 'g')), 'A') ||
 176               setweight(to_tsvector('simple', regexp_replace(coalesce(?, ''), '\\W', ' ', 'g')), 'B'),
 177               to_tsquery('simple', ?),
 178               32
 179             )
 180             """,
 181             u.nickname,
 182             u.name,
 183             ^processed_query
 184           )
 185       },
 186       where:
 187         fragment(
 188           """
 189             (setweight(to_tsvector('simple', regexp_replace(?, '\\W', ' ', 'g')), 'A') ||
 190             setweight(to_tsvector('simple', regexp_replace(coalesce(?, ''), '\\W', ' ', 'g')), 'B')) @@ to_tsquery('simple', ?)
 191           """,
 192           u.nickname,
 193           u.name,
 194           ^processed_query
 195         )
 196     )
 197     |> User.restrict_deactivated()
 198   end
 199
 200   @spec trigram_search_subquery(User.t() | Ecto.Query.t(), String.t()) :: Ecto.Query.t()
 201   defp trigram_search_subquery(query, term) do
 202     term = String.trim_trailing(term, "@" <> local_domain())
 203
 204     from(
 205       u in query,
 206       select_merge: %{
 207         # ^1 gives 'Postgrex expected a binary, got 1' for some weird reason
 208         search_type: fragment("?", 1),
 209         search_rank:
 210           fragment(
 211             "similarity(?, trim(? || ' ' || coalesce(?, '')))",
 212             ^term,
 213             u.nickname,
 214             u.name
 215           )
 216       },
 217       where: fragment("trim(? || ' ' || coalesce(?, '')) % ?", u.nickname, u.name, ^term)
 218     )
 219     |> User.restrict_deactivated()
 220   end
 221
 222   defp local_domain, do: Pleroma.Config.get([Pleroma.Web.Endpoint, :url, :host])
 223 end