git.squeep.com Git - akkoma/blob - lib/pleroma/web/mastodon_api/controllers/search_controller.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.Web.MastodonAPI.SearchController do
   6   use Pleroma.Web, :controller
   7
   8   alias Pleroma.Activity
   9   alias Pleroma.Plugs.OAuthScopesPlug
  10   alias Pleroma.Plugs.RateLimiter
  11   alias Pleroma.Repo
  12   alias Pleroma.User
  13   alias Pleroma.Web
  14   alias Pleroma.Web.MastodonAPI.AccountView
  15   alias Pleroma.Web.MastodonAPI.StatusView
  16
  17   require Logger
  18
  19   plug(Pleroma.Web.ApiSpec.CastAndValidate)
  20
  21   # Note: Mastodon doesn't allow unauthenticated access (requires read:accounts / read:search)
  22   plug(OAuthScopesPlug, %{scopes: ["read:search"], fallback: :proceed_unauthenticated})
  23
  24   # Note: on private instances auth is required (EnsurePublicOrAuthenticatedPlug is not skipped)
  25
  26   plug(RateLimiter, [name: :search] when action in [:search, :search2, :account_search])
  27
  28   defdelegate open_api_operation(action), to: Pleroma.Web.ApiSpec.SearchOperation
  29
  30   def account_search(%{assigns: %{user: user}} = conn, %{q: query} = params) do
  31     accounts = User.search(query, search_options(params, user))
  32
  33     conn
  34     |> put_view(AccountView)
  35     |> render("index.json", users: accounts, for: user, as: :user)
  36   end
  37
  38   def search2(conn, params), do: do_search(:v2, conn, params)
  39   def search(conn, params), do: do_search(:v1, conn, params)
  40
  41   defp do_search(version, %{assigns: %{user: user}} = conn, %{q: query} = params) do
  42     options = search_options(params, user)
  43     timeout = Keyword.get(Repo.config(), :timeout, 15_000)
  44     default_values = %{"statuses" => [], "accounts" => [], "hashtags" => []}
  45
  46     result =
  47       default_values
  48       |> Enum.map(fn {resource, default_value} ->
  49         if params[:type] in [nil, resource] do
  50           {resource, fn -> resource_search(version, resource, query, options) end}
  51         else
  52           {resource, fn -> default_value end}
  53         end
  54       end)
  55       |> Task.async_stream(fn {resource, f} -> {resource, with_fallback(f)} end,
  56         timeout: timeout,
  57         on_timeout: :kill_task
  58       )
  59       |> Enum.reduce(default_values, fn
  60         {:ok, {resource, result}}, acc ->
  61           Map.put(acc, resource, result)
  62
  63         _error, acc ->
  64           acc
  65       end)
  66
  67     json(conn, result)
  68   end
  69
  70   defp search_options(params, user) do
  71     [
  72       resolve: params[:resolve],
  73       following: params[:following],
  74       limit: params[:limit],
  75       offset: params[:offset],
  76       type: params[:type],
  77       author: get_author(params),
  78       for_user: user
  79     ]
  80     |> Enum.filter(&elem(&1, 1))
  81   end
  82
  83   defp resource_search(_, "accounts", query, options) do
  84     accounts = with_fallback(fn -> User.search(query, options) end)
  85
  86     AccountView.render("index.json",
  87       users: accounts,
  88       for: options[:for_user],
  89       as: :user,
  90       skip_relationships: true
  91     )
  92   end
  93
  94   defp resource_search(_, "statuses", query, options) do
  95     statuses = with_fallback(fn -> Activity.search(options[:for_user], query, options) end)
  96
  97     StatusView.render("index.json",
  98       activities: statuses,
  99       for: options[:for_user],
 100       as: :activity
 101     )
 102   end
 103
 104   defp resource_search(:v2, "hashtags", query, _options) do
 105     tags_path = Web.base_url() <> "/tag/"
 106
 107     query
 108     |> prepare_tags()
 109     |> Enum.map(fn tag ->
 110       tag = String.trim_leading(tag, "#")
 111       %{name: tag, url: tags_path <> tag}
 112     end)
 113   end
 114
 115   defp resource_search(:v1, "hashtags", query, _options) do
 116     query
 117     |> prepare_tags()
 118     |> Enum.map(fn tag -> String.trim_leading(tag, "#") end)
 119   end
 120
 121   defp prepare_tags(query) do
 122     query
 123     |> String.split()
 124     |> Enum.uniq()
 125     |> Enum.filter(fn tag -> String.starts_with?(tag, "#") end)
 126   end
 127
 128   defp with_fallback(f, fallback \\ []) do
 129     try do
 130       f.()
 131     rescue
 132       error ->
 133         Logger.error("#{__MODULE__} search error: #{inspect(error)}")
 134         fallback
 135     end
 136   end
 137
 138   defp get_author(%{account_id: account_id}) when is_binary(account_id),
 139     do: User.get_cached_by_id(account_id)
 140
 141   defp get_author(_params), do: nil
 142 end