git.squeep.com Git - akkoma/blob - lib/pleroma/web/mastodon_api/controllers/account_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.AccountController do
   6   use Pleroma.Web, :controller
   7
   8   import Pleroma.Web.ControllerHelper, only: [add_link_headers: 2, truthy_param?: 1]
   9
  10   alias Pleroma.User
  11   alias Pleroma.Web.CommonAPI
  12   alias Pleroma.Web.ActivityPub.ActivityPub
  13   alias Pleroma.Web.MastodonAPI.StatusView
  14   alias Pleroma.Web.MastodonAPI.MastodonAPI
  15   alias Pleroma.Web.MastodonAPI.ListView
  16   alias Pleroma.Plugs.RateLimiter
  17
  18   require Pleroma.Constants
  19
  20   @relations ~w(follow unfollow)a
  21
  22   plug(RateLimiter, {:relations_id_action, params: ["id", "uri"]} when action in @relations)
  23   plug(RateLimiter, :relations_actions when action in @relations)
  24   plug(:assign_account when action not in [:show, :statuses, :follows])
  25
  26   action_fallback(Pleroma.Web.MastodonAPI.FallbackController)
  27
  28   @doc "GET /api/v1/accounts/:id"
  29   def show(%{assigns: %{user: for_user}} = conn, %{"id" => nickname_or_id}) do
  30     with %User{} = user <- User.get_cached_by_nickname_or_id(nickname_or_id, for: for_user),
  31          true <- User.auth_active?(user) || user.id == for_user.id || User.superuser?(for_user) do
  32       render(conn, "show.json", user: user, for: for_user)
  33     else
  34       _e -> render_error(conn, :not_found, "Can't find user")
  35     end
  36   end
  37
  38   @doc "GET /api/v1/accounts/:id/statuses"
  39   def statuses(%{assigns: %{user: reading_user}} = conn, params) do
  40     with %User{} = user <- User.get_cached_by_nickname_or_id(params["id"], for: reading_user) do
  41       params = Map.put(params, "tag", params["tagged"])
  42       activities = ActivityPub.fetch_user_activities(user, reading_user, params)
  43
  44       conn
  45       |> add_link_headers(activities)
  46       |> put_view(StatusView)
  47       |> render("index.json", activities: activities, for: reading_user, as: :activity)
  48     end
  49   end
  50
  51   @doc "GET /api/v1/accounts/:id/followers"
  52   def followers(%{assigns: %{user: for_user, account: user}} = conn, params) do
  53     followers =
  54       cond do
  55         for_user && user.id == for_user.id -> MastodonAPI.get_followers(user, params)
  56         user.info.hide_followers -> []
  57         true -> MastodonAPI.get_followers(user, params)
  58       end
  59
  60     conn
  61     |> add_link_headers(followers)
  62     |> render("index.json", for: for_user, users: followers, as: :user)
  63   end
  64
  65   @doc "GET /api/v1/accounts/:id/following"
  66   def following(%{assigns: %{user: for_user, account: user}} = conn, params) do
  67     followers =
  68       cond do
  69         for_user && user.id == for_user.id -> MastodonAPI.get_friends(user, params)
  70         user.info.hide_follows -> []
  71         true -> MastodonAPI.get_friends(user, params)
  72       end
  73
  74     conn
  75     |> add_link_headers(followers)
  76     |> render("index.json", for: for_user, users: followers, as: :user)
  77   end
  78
  79   @doc "GET /api/v1/accounts/:id/lists"
  80   def lists(%{assigns: %{user: user, account: account}} = conn, _params) do
  81     lists = Pleroma.List.get_lists_account_belongs(user, account)
  82
  83     conn
  84     |> put_view(ListView)
  85     |> render("index.json", lists: lists)
  86   end
  87
  88   @doc "GET /api/v1/pleroma/accounts/:id/favourites"
  89   def favourites(%{assigns: %{account: %{info: %{hide_favorites: true}}}} = conn, _params) do
  90     render_error(conn, :forbidden, "Can't get favorites")
  91   end
  92
  93   def favourites(%{assigns: %{user: for_user, account: user}} = conn, params) do
  94     params =
  95       params
  96       |> Map.put("type", "Create")
  97       |> Map.put("favorited_by", user.ap_id)
  98       |> Map.put("blocking_user", for_user)
  99
 100     recipients =
 101       if for_user do
 102         [Pleroma.Constants.as_public()] ++ [for_user.ap_id | for_user.following]
 103       else
 104         [Pleroma.Constants.as_public()]
 105       end
 106
 107     activities =
 108       recipients
 109       |> ActivityPub.fetch_activities(params)
 110       |> Enum.reverse()
 111
 112     conn
 113     |> add_link_headers(activities)
 114     |> put_view(StatusView)
 115     |> render("index.json", activities: activities, for: for_user, as: :activity)
 116   end
 117
 118   @doc "POST /api/v1/pleroma/accounts/:id/subscribe"
 119   def subscribe(%{assigns: %{user: user, account: subscription_target}} = conn, _params) do
 120     with {:ok, subscription_target} <- User.subscribe(user, subscription_target) do
 121       render(conn, "relationship.json", user: user, target: subscription_target)
 122     else
 123       {:error, message} ->
 124         conn
 125         |> put_status(:forbidden)
 126         |> json(%{error: message})
 127     end
 128   end
 129
 130   @doc "POST /api/v1/pleroma/accounts/:id/unsubscribe"
 131   def unsubscribe(%{assigns: %{user: user, account: subscription_target}} = conn, _params) do
 132     with {:ok, subscription_target} <- User.unsubscribe(user, subscription_target) do
 133       render(conn, "relationship.json", user: user, target: subscription_target)
 134     else
 135       {:error, message} ->
 136         conn
 137         |> put_status(:forbidden)
 138         |> json(%{error: message})
 139     end
 140   end
 141
 142   @doc "POST /api/v1/accounts/:id/follow"
 143   def follow(%{assigns: %{user: %{id: id}, account: %{id: id}}}, _params) do
 144     {:error, :not_found}
 145   end
 146
 147   def follow(%{assigns: %{user: follower, account: followed}} = conn, _params) do
 148     with {:ok, follower} <- MastodonAPI.follow(follower, followed, conn.params) do
 149       render(conn, "relationship.json", user: follower, target: followed)
 150     else
 151       {:error, message} ->
 152         conn
 153         |> put_status(:forbidden)
 154         |> json(%{error: message})
 155     end
 156   end
 157
 158   @doc "POST /api/v1/pleroma/:id/unfollow"
 159   def unfollow(%{assigns: %{user: %{id: id}, account: %{id: id}}}, _params) do
 160     {:error, :not_found}
 161   end
 162
 163   def unfollow(%{assigns: %{user: follower, account: followed}} = conn, _params) do
 164     with {:ok, follower} <- CommonAPI.unfollow(follower, followed) do
 165       render(conn, "relationship.json", user: follower, target: followed)
 166     end
 167   end
 168
 169   @doc "POST /api/v1/accounts/:id/mute"
 170   def mute(%{assigns: %{user: muter, account: muted}} = conn, params) do
 171     notifications? = params |> Map.get("notifications", true) |> truthy_param?()
 172
 173     with {:ok, muter} <- User.mute(muter, muted, notifications?) do
 174       render(conn, "relationship.json", user: muter, target: muted)
 175     else
 176       {:error, message} ->
 177         conn
 178         |> put_status(:forbidden)
 179         |> json(%{error: message})
 180     end
 181   end
 182
 183   @doc "POST /api/v1/accounts/:id/unmute"
 184   def unmute(%{assigns: %{user: muter, account: muted}} = conn, _params) do
 185     with {:ok, muter} <- User.unmute(muter, muted) do
 186       render(conn, "relationship.json", user: muter, target: muted)
 187     else
 188       {:error, message} ->
 189         conn
 190         |> put_status(:forbidden)
 191         |> json(%{error: message})
 192     end
 193   end
 194
 195   @doc "POST /api/v1/accounts/:id/block"
 196   def block(%{assigns: %{user: blocker, account: blocked}} = conn, _params) do
 197     with {:ok, blocker} <- User.block(blocker, blocked),
 198          {:ok, _activity} <- ActivityPub.block(blocker, blocked) do
 199       render(conn, "relationship.json", user: blocker, target: blocked)
 200     else
 201       {:error, message} ->
 202         conn
 203         |> put_status(:forbidden)
 204         |> json(%{error: message})
 205     end
 206   end
 207
 208   @doc "POST /api/v1/accounts/:id/unblock"
 209   def unblock(%{assigns: %{user: blocker, account: blocked}} = conn, _params) do
 210     with {:ok, blocker} <- User.unblock(blocker, blocked),
 211          {:ok, _activity} <- ActivityPub.unblock(blocker, blocked) do
 212       render(conn, "relationship.json", user: blocker, target: blocked)
 213     else
 214       {:error, message} ->
 215         conn
 216         |> put_status(:forbidden)
 217         |> json(%{error: message})
 218     end
 219   end
 220
 221   defp assign_account(%{params: %{"id" => id}} = conn, _) do
 222     case User.get_cached_by_id(id) do
 223       %User{} = account -> assign(conn, :account, account)
 224       nil -> Pleroma.Web.MastodonAPI.FallbackController.call(conn, {:error, :not_found}) |> halt()
 225     end
 226   end
 227 end