Git of dcc - anni/blob - lib/pleroma/web/mastodon_api/controllers/search_controller.ex

   1 # Pleroma: A lightweight social networking server
   2 # Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
   3 # SPDX-License-Identifier: AGPL-3.0-only
   4
   5 defmodule Pleroma.Web.MastodonAPI.SearchController do
   6   use Pleroma.Web, :controller
   7
   8   alias Pleroma.Repo
   9   alias Pleroma.User
  10   alias Pleroma.Web.ControllerHelper
  11   alias Pleroma.Web.Endpoint
  12   alias Pleroma.Web.MastodonAPI.AccountView
  13   alias Pleroma.Web.MastodonAPI.StatusView
  14   alias Pleroma.Web.Plugs.OAuthScopesPlug
  15   alias Pleroma.Web.Plugs.RateLimiter
  16
  17   require Logger
  18
  19   @search_limit 40
  20
  21   plug(Pleroma.Web.ApiSpec.CastAndValidate, replace_params: false)
  22
  23   # Note: Mastodon doesn't allow unauthenticated access (requires read:accounts / read:search)
  24   plug(OAuthScopesPlug, %{scopes: ["read:search"], fallback: :proceed_unauthenticated})
  25
  26   # Note: on private instances auth is required (EnsurePublicOrAuthenticatedPlug is not skipped)
  27
  28   plug(RateLimiter, [name: :search] when action in [:search, :search2, :account_search])
  29
  30   defdelegate open_api_operation(action), to: Pleroma.Web.ApiSpec.SearchOperation
  31
  32   def account_search(
  33         %{assigns: %{user: user}, private: %{open_api_spex: %{params: %{q: query} = params}}} =
  34           conn,
  35         _
  36       ) do
  37     accounts = User.search(query, search_options(params, user))
  38
  39     conn
  40     |> put_view(AccountView)
  41     |> render("index.json",
  42       users: accounts,
  43       for: user,
  44       as: :user
  45     )
  46   end
  47
  48   def search2(conn, params), do: do_search(:v2, conn, params)
  49   def search(conn, params), do: do_search(:v1, conn, params)
  50
  51   defp do_search(
  52          version,
  53          %{assigns: %{user: user}, private: %{open_api_spex: %{params: %{q: query} = params}}} =
  54            conn,
  55          _
  56        ) do
  57     query = String.trim(query)
  58     options = search_options(params, user)
  59     timeout = Keyword.get(Repo.config(), :timeout, 15_000)
  60     default_values = %{"statuses" => [], "accounts" => [], "hashtags" => []}
  61
  62     result =
  63       default_values
  64       |> Enum.map(fn {resource, default_value} ->
  65         if params[:type] in [nil, resource] do
  66           {resource, fn -> resource_search(version, resource, query, options) end}
  67         else
  68           {resource, fn -> default_value end}
  69         end
  70       end)
  71       |> Task.async_stream(fn {resource, f} -> {resource, with_fallback(f)} end,
  72         timeout: timeout,
  73         on_timeout: :kill_task
  74       )
  75       |> Enum.reduce(default_values, fn
  76         {:ok, {resource, result}}, acc ->
  77           Map.put(acc, resource, result)
  78
  79         _error, acc ->
  80           acc
  81       end)
  82
  83     json(conn, result)
  84   end
  85
  86   defp search_options(params, user) do
  87     [
  88       resolve: params[:resolve],
  89       following: params[:following],
  90       limit: min(params[:limit], @search_limit),
  91       offset: params[:offset],
  92       type: params[:type],
  93       author: get_author(params),
  94       embed_relationships: ControllerHelper.embed_relationships?(params),
  95       for_user: user
  96     ]
  97     |> Enum.filter(&elem(&1, 1))
  98   end
  99
 100   defp resource_search(_, "accounts", query, options) do
 101     accounts = with_fallback(fn -> User.search(query, options) end)
 102
 103     AccountView.render("index.json",
 104       users: accounts,
 105       for: options[:for_user],
 106       embed_relationships: options[:embed_relationships]
 107     )
 108   end
 109
 110   defp resource_search(_, "statuses", query, options) do
 111     statuses = with_fallback(fn -> Pleroma.Search.search(query, options) end)
 112
 113     StatusView.render("index.json",
 114       activities: statuses,
 115       for: options[:for_user],
 116       as: :activity
 117     )
 118   end
 119
 120   defp resource_search(:v2, "hashtags", query, options) do
 121     tags_path = Endpoint.url() <> "/tag/"
 122
 123     query
 124     |> prepare_tags(options)
 125     |> Enum.map(fn tag ->
 126       %{name: tag, url: tags_path <> tag}
 127     end)
 128   end
 129
 130   defp resource_search(:v1, "hashtags", query, options) do
 131     prepare_tags(query, options)
 132   end
 133
 134   defp prepare_tags(query, options) do
 135     tags =
 136       query
 137       |> preprocess_uri_query()
 138       |> String.split(~r/[^#\w]+/u, trim: true)
 139       |> Enum.uniq_by(&String.downcase/1)
 140
 141     explicit_tags = Enum.filter(tags, fn tag -> String.starts_with?(tag, "#") end)
 142
 143     tags =
 144       if Enum.any?(explicit_tags) do
 145         explicit_tags
 146       else
 147         tags
 148       end
 149
 150     tags = Enum.map(tags, fn tag -> String.trim_leading(tag, "#") end)
 151
 152     tags =
 153       if Enum.empty?(explicit_tags) && !options[:skip_joined_tag] do
 154         add_joined_tag(tags)
 155       else
 156         tags
 157       end
 158
 159     Pleroma.Pagination.paginate_list(tags, options)
 160   end
 161
 162   defp add_joined_tag(tags) do
 163     tags
 164     |> Kernel.++([joined_tag(tags)])
 165     |> Enum.uniq_by(&String.downcase/1)
 166   end
 167
 168   # If `query` is a URI, returns last component of its path, otherwise returns `query`
 169   defp preprocess_uri_query(query) do
 170     if query =~ ~r/https?:\/\// do
 171       query
 172       |> String.trim_trailing("/")
 173       |> URI.parse()
 174       |> Map.get(:path)
 175       |> String.split("/")
 176       |> Enum.at(-1)
 177     else
 178       query
 179     end
 180   end
 181
 182   defp joined_tag(tags) do
 183     tags
 184     |> Enum.map(fn tag -> String.capitalize(tag) end)
 185     |> Enum.join()
 186   end
 187
 188   defp with_fallback(f, fallback \\ []) do
 189     try do
 190       f.()
 191     rescue
 192       error ->
 193         Logger.error("#{__MODULE__} search error: #{inspect(error)}")
 194         fallback
 195     end
 196   end
 197
 198   defp get_author(%{account_id: account_id}) when is_binary(account_id),
 199     do: User.get_cached_by_id(account_id)
 200
 201   defp get_author(_params), do: nil
 202 end