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