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