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

   1 # Pleroma: A lightweight social networking server
   2 # Copyright © 2017-2020 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.User
   8   import Ecto.Query
   9
  10   @limit 20
  11
  12   def search(query_string, opts \\ []) do
  13     resolve = Keyword.get(opts, :resolve, false)
  14     following = Keyword.get(opts, :following, false)
  15     result_limit = Keyword.get(opts, :limit, @limit)
  16     offset = Keyword.get(opts, :offset, 0)
  17
  18     for_user = Keyword.get(opts, :for_user)
  19
  20     query_string = format_query(query_string)
  21
  22     maybe_resolve(resolve, for_user, query_string)
  23
  24     results =
  25       query_string
  26       |> search_query(for_user, following)
  27       |> Pagination.fetch_paginated(%{"offset" => offset, "limit" => result_limit}, :offset)
  28
  29     results
  30   end
  31
  32   defp format_query(query_string) do
  33     # Strip the beginning @ off if there is a query
  34     query_string = String.trim_leading(query_string, "@")
  35
  36     with [name, domain] <- String.split(query_string, "@") do
  37       encoded_domain =
  38         domain
  39         |> String.replace(~r/[!-\-|@|[-`|{-~|\/|:|\s]+/, "")
  40         |> String.to_charlist()
  41         |> :idna.encode()
  42         |> to_string()
  43
  44       name <> "@" <> encoded_domain
  45     else
  46       _ -> query_string
  47     end
  48   end
  49
  50   defp search_query(query_string, for_user, following) do
  51     for_user
  52     |> base_query(following)
  53     |> filter_blocked_user(for_user)
  54     |> filter_invisible_users()
  55     |> filter_internal_users()
  56     |> filter_blocked_domains(for_user)
  57     |> fts_search(query_string)
  58     |> trigram_rank(query_string)
  59     |> boost_search_rank(for_user)
  60     |> subquery()
  61     |> order_by(desc: :search_rank)
  62     |> maybe_restrict_local(for_user)
  63   end
  64
  65   defp fts_search(query, query_string) do
  66     query_string = to_tsquery(query_string)
  67
  68     from(
  69       u in query,
  70       where:
  71         fragment(
  72           """
  73           (to_tsvector('simple', ?) || to_tsvector('simple', ?)) @@ to_tsquery('simple', ?)
  74           """,
  75           u.name,
  76           u.nickname,
  77           ^query_string
  78         )
  79     )
  80   end
  81
  82   defp to_tsquery(query_string) do
  83     String.trim_trailing(query_string, "@" <> local_domain())
  84     |> String.replace(~r/[!-\/|@|[-`|{-~|:-?]+/, " ")
  85     |> String.trim()
  86     |> String.split()
  87     |> Enum.map(&(&1 <> ":*"))
  88     |> Enum.join(" | ")
  89   end
  90
  91   defp trigram_rank(query, query_string) do
  92     from(
  93       u in query,
  94       select_merge: %{
  95         search_rank:
  96           fragment(
  97             "similarity(?, trim(? || ' ' || coalesce(?, '')))",
  98             ^query_string,
  99             u.nickname,
 100             u.name
 101           )
 102       }
 103     )
 104   end
 105
 106   defp base_query(_user, false), do: User
 107   defp base_query(user, true), do: User.get_followers_query(user)
 108
 109   defp filter_invisible_users(query) do
 110     from(q in query, where: q.invisible == false)
 111   end
 112
 113   defp filter_internal_users(query) do
 114     from(q in query, where: q.actor_type != "Application")
 115   end
 116
 117   defp filter_blocked_user(query, %User{} = blocker) do
 118     query
 119     |> join(:left, [u], b in Pleroma.UserRelationship,
 120       as: :blocks,
 121       on: b.relationship_type == ^:block and b.source_id == ^blocker.id and u.id == b.target_id
 122     )
 123     |> where([blocks: b], is_nil(b.target_id))
 124   end
 125
 126   defp filter_blocked_user(query, _), do: query
 127
 128   defp filter_blocked_domains(query, %User{domain_blocks: domain_blocks})
 129        when length(domain_blocks) > 0 do
 130     domains = Enum.join(domain_blocks, ",")
 131
 132     from(
 133       q in query,
 134       where: fragment("substring(ap_id from '.*://([^/]*)') NOT IN (?)", ^domains)
 135     )
 136   end
 137
 138   defp filter_blocked_domains(query, _), do: query
 139
 140   defp maybe_resolve(true, user, query) do
 141     case {limit(), user} do
 142       {:all, _} -> :noop
 143       {:unauthenticated, %User{}} -> User.get_or_fetch(query)
 144       {:unauthenticated, _} -> :noop
 145       {false, _} -> User.get_or_fetch(query)
 146     end
 147   end
 148
 149   defp maybe_resolve(_, _, _), do: :noop
 150
 151   defp maybe_restrict_local(q, user) do
 152     case {limit(), user} do
 153       {:all, _} -> restrict_local(q)
 154       {:unauthenticated, %User{}} -> q
 155       {:unauthenticated, _} -> restrict_local(q)
 156       {false, _} -> q
 157     end
 158   end
 159
 160   defp limit, do: Pleroma.Config.get([:instance, :limit_to_local_content], :unauthenticated)
 161
 162   defp restrict_local(q), do: where(q, [u], u.local == true)
 163
 164   defp local_domain, do: Pleroma.Config.get([Pleroma.Web.Endpoint, :url, :host])
 165
 166   defp boost_search_rank(query, %User{} = for_user) do
 167     friends_ids = User.get_friends_ids(for_user)
 168     followers_ids = User.get_followers_ids(for_user)
 169
 170     from(u in subquery(query),
 171       select_merge: %{
 172         search_rank:
 173           fragment(
 174             """
 175              CASE WHEN (?) THEN (?) * 1.5
 176              WHEN (?) THEN (?) * 1.3
 177              WHEN (?) THEN (?) * 1.1
 178              ELSE (?) END
 179             """,
 180             u.id in ^friends_ids and u.id in ^followers_ids,
 181             u.search_rank,
 182             u.id in ^friends_ids,
 183             u.search_rank,
 184             u.id in ^followers_ids,
 185             u.search_rank,
 186             u.search_rank
 187           )
 188       }
 189     )
 190   end
 191
 192   defp boost_search_rank(query, _for_user), do: query
 193 end