Merge branch 'split-masto-api/accounts' into 'develop'

Extract account actions from `MastodonAPIController` to `AccountController`

See merge request pleroma/pleroma!1731

1 files changed, 6 insertions, 485 deletions

diff --git a/lib/pleroma/web/mastodon_api/controllers/mastodon_api_controller.ex b/lib/pleroma/web/mastodon_api/controllers/mastodon_api_controller.ex
index 3bdcea0f7..30a2bf0e0 100644
--- a/lib/pleroma/web/mastodon_api/controllers/mastodon_api_controller.ex
+++ b/lib/pleroma/web/mastodon_api/controllers/mastodon_api_controller.ex
@@ -5,14 +5,11 @@
 defmodule Pleroma.Web.MastodonAPI.MastodonAPIController do
   use Pleroma.Web, :controller
 
-  import Pleroma.Web.ControllerHelper,
-    only: [json_response: 3, add_link_headers: 2, truthy_param?: 1]
+  import Pleroma.Web.ControllerHelper, only: [add_link_headers: 2]
 
-  alias Ecto.Changeset
   alias Pleroma.Activity
   alias Pleroma.Bookmark
   alias Pleroma.Config
-  alias Pleroma.Emoji
   alias Pleroma.HTTP
   alias Pleroma.Object
   alias Pleroma.Pagination
@@ -26,8 +23,6 @@ defmodule Pleroma.Web.MastodonAPI.MastodonAPIController do
   alias Pleroma.Web.CommonAPI
   alias Pleroma.Web.MastodonAPI.AccountView
   alias Pleroma.Web.MastodonAPI.AppView
-  alias Pleroma.Web.MastodonAPI.ListView
-  alias Pleroma.Web.MastodonAPI.MastodonAPI
   alias Pleroma.Web.MastodonAPI.MastodonView
   alias Pleroma.Web.MastodonAPI.StatusView
   alias Pleroma.Web.MediaProxy
@@ -38,20 +33,8 @@ defmodule Pleroma.Web.MastodonAPI.MastodonAPIController do
   alias Pleroma.Web.TwitterAPI.TwitterAPI
 
   require Logger
-  require Pleroma.Constants
 
-  @rate_limited_relations_actions ~w(follow unfollow)a
-
-  plug(
-    RateLimiter,
-    {:relations_id_action, params: ["id", "uri"]} when action in @rate_limited_relations_actions
-  )
-
-  plug(RateLimiter, :relations_actions when action in @rate_limited_relations_actions)
-  plug(RateLimiter, :app_account_creation when action == :account_register)
-  plug(RateLimiter, :search when action in [:search, :search2, :account_search])
   plug(RateLimiter, :password_reset when action == :password_reset)
-  plug(RateLimiter, :account_confirmation_resend when action == :account_confirmation_resend)
 
   @local_mastodon_name "Mastodon-Local"
 
@@ -74,180 +57,6 @@ defmodule Pleroma.Web.MastodonAPI.MastodonAPIController do
     end
   end
 
-  defp add_if_present(
-         map,
-         params,
-         params_field,
-         map_field,
-         value_function \\ fn x -> {:ok, x} end
-       ) do
-    if Map.has_key?(params, params_field) do
-      case value_function.(params[params_field]) do
-        {:ok, new_value} -> Map.put(map, map_field, new_value)
-        :error -> map
-      end
-    else
-      map
-    end
-  end
-
-  def update_credentials(%{assigns: %{user: user}} = conn, params) do
-    original_user = user
-
-    user_params =
-      %{}
-      |> add_if_present(params, "display_name", :name)
-      |> add_if_present(params, "note", :bio, fn value -> {:ok, User.parse_bio(value, user)} end)
-      |> add_if_present(params, "avatar", :avatar, fn value ->
-        with %Plug.Upload{} <- value,
-             {:ok, object} <- ActivityPub.upload(value, type: :avatar) do
-          {:ok, object.data}
-        else
-          _ -> :error
-        end
-      end)
-
-    emojis_text = (user_params["display_name"] || "") <> (user_params["note"] || "")
-
-    user_info_emojis =
-      user.info
-      |> Map.get(:emoji, [])
-      |> Enum.concat(Emoji.Formatter.get_emoji_map(emojis_text))
-      |> Enum.dedup()
-
-    info_params =
-      [
-        :no_rich_text,
-        :locked,
-        :hide_followers_count,
-        :hide_follows_count,
-        :hide_followers,
-        :hide_follows,
-        :hide_favorites,
-        :show_role,
-        :skip_thread_containment,
-        :discoverable
-      ]
-      |> Enum.reduce(%{}, fn key, acc ->
-        add_if_present(acc, params, to_string(key), key, fn value ->
-          {:ok, truthy_param?(value)}
-        end)
-      end)
-      |> add_if_present(params, "default_scope", :default_scope)
-      |> add_if_present(params, "fields", :fields, fn fields ->
-        fields = Enum.map(fields, fn f -> Map.update!(f, "value", &AutoLinker.link(&1)) end)
-
-        {:ok, fields}
-      end)
-      |> add_if_present(params, "fields", :raw_fields)
-      |> add_if_present(params, "pleroma_settings_store", :pleroma_settings_store, fn value ->
-        {:ok, Map.merge(user.info.pleroma_settings_store, value)}
-      end)
-      |> add_if_present(params, "header", :banner, fn value ->
-        with %Plug.Upload{} <- value,
-             {:ok, object} <- ActivityPub.upload(value, type: :banner) do
-          {:ok, object.data}
-        else
-          _ -> :error
-        end
-      end)
-      |> add_if_present(params, "pleroma_background_image", :background, fn value ->
-        with %Plug.Upload{} <- value,
-             {:ok, object} <- ActivityPub.upload(value, type: :background) do
-          {:ok, object.data}
-        else
-          _ -> :error
-        end
-      end)
-      |> Map.put(:emoji, user_info_emojis)
-
-    changeset =
-      user
-      |> User.update_changeset(user_params)
-      |> User.change_info(&User.Info.profile_update(&1, info_params))
-
-    with {:ok, user} <- User.update_and_set_cache(changeset) do
-      if original_user != user, do: CommonAPI.update(user)
-
-      json(
-        conn,
-        AccountView.render("account.json", %{user: user, for: user, with_pleroma_settings: true})
-      )
-    else
-      _e -> render_error(conn, :forbidden, "Invalid request")
-    end
-  end
-
-  def update_avatar(%{assigns: %{user: user}} = conn, %{"img" => ""}) do
-    change = Changeset.change(user, %{avatar: nil})
-    {:ok, user} = User.update_and_set_cache(change)
-    CommonAPI.update(user)
-
-    json(conn, %{url: nil})
-  end
-
-  def update_avatar(%{assigns: %{user: user}} = conn, params) do
-    {:ok, object} = ActivityPub.upload(params, type: :avatar)
-    change = Changeset.change(user, %{avatar: object.data})
-    {:ok, user} = User.update_and_set_cache(change)
-    CommonAPI.update(user)
-    %{"url" => [%{"href" => href} | _]} = object.data
-
-    json(conn, %{url: href})
-  end
-
-  def update_banner(%{assigns: %{user: user}} = conn, %{"banner" => ""}) do
-    new_info = %{"banner" => %{}}
-
-    with {:ok, user} <- User.update_info(user, &User.Info.profile_update(&1, new_info)) do
-      CommonAPI.update(user)
-      json(conn, %{url: nil})
-    end
-  end
-
-  def update_banner(%{assigns: %{user: user}} = conn, params) do
-    with {:ok, object} <- ActivityPub.upload(%{"img" => params["banner"]}, type: :banner),
-         new_info <- %{"banner" => object.data},
-         {:ok, user} <- User.update_info(user, &User.Info.profile_update(&1, new_info)) do
-      CommonAPI.update(user)
-      %{"url" => [%{"href" => href} | _]} = object.data
-
-      json(conn, %{url: href})
-    end
-  end
-
-  def update_background(%{assigns: %{user: user}} = conn, %{"img" => ""}) do
-    new_info = %{"background" => %{}}
-
-    with {:ok, _user} <- User.update_info(user, &User.Info.profile_update(&1, new_info)) do
-      json(conn, %{url: nil})
-    end
-  end
-
-  def update_background(%{assigns: %{user: user}} = conn, params) do
-    with {:ok, object} <- ActivityPub.upload(params, type: :background),
-         new_info <- %{"background" => object.data},
-         {:ok, _user} <- User.update_info(user, &User.Info.profile_update(&1, new_info)) do
-      %{"url" => [%{"href" => href} | _]} = object.data
-
-      json(conn, %{url: href})
-    end
-  end
-
-  def verify_credentials(%{assigns: %{user: user}} = conn, _) do
-    chat_token = Phoenix.Token.sign(conn, "user socket", user.id)
-
-    account =
-      AccountView.render("account.json", %{
-        user: user,
-        for: user,
-        with_pleroma_settings: true,
-        with_chat_token: chat_token
-      })
-
-    json(conn, account)
-  end
-
   def verify_app_credentials(%{assigns: %{user: _user, token: token}} = conn, _) do
     with %Token{app: %App{} = app} <- Repo.preload(token, :app) do
       conn
@@ -256,16 +65,6 @@ defmodule Pleroma.Web.MastodonAPI.MastodonAPIController do
     end
   end
 
-  def user(%{assigns: %{user: for_user}} = conn, %{"id" => nickname_or_id}) do
-    with %User{} = user <- User.get_cached_by_nickname_or_id(nickname_or_id, for: for_user),
-         true <- User.auth_active?(user) || user.id == for_user.id || User.superuser?(for_user) do
-      account = AccountView.render("account.json", %{user: user, for: for_user})
-      json(conn, account)
-    else
-      _e -> render_error(conn, :not_found, "Can't find user")
-    end
-  end
-
   @mastodon_api_level "2.7.2"
 
   def masto_instance(conn, _params) do
@@ -318,25 +117,6 @@ defmodule Pleroma.Web.MastodonAPI.MastodonAPIController do
     json(conn, mastodon_emoji)
   end
 
-  def user_statuses(%{assigns: %{user: reading_user}} = conn, params) do
-    with %User{} = user <- User.get_cached_by_nickname_or_id(params["id"], for: reading_user) do
-      params =
-        params
-        |> Map.put("tag", params["tagged"])
-
-      activities = ActivityPub.fetch_user_activities(user, reading_user, params)
-
-      conn
-      |> add_link_headers(activities)
-      |> put_view(StatusView)
-      |> render("index.json", %{
-        activities: activities,
-        for: reading_user,
-        as: :activity
-      })
-    end
-  end
-
   def get_poll(%{assigns: %{user: user}} = conn, %{"id" => id}) do
     with %Object{} = object <- Object.get_by_id_and_maybe_refetch(id, interval: 60),
          %Activity{} = activity <- Activity.get_create_by_object_ap_id(object.data["id"]),
@@ -387,17 +167,6 @@ defmodule Pleroma.Web.MastodonAPI.MastodonAPIController do
     end
   end
 
-  def relationships(%{assigns: %{user: user}} = conn, %{"id" => id}) do
-    targets = User.get_all_by_ids(List.wrap(id))
-
-    conn
-    |> put_view(AccountView)
-    |> render("relationships.json", %{user: user, targets: targets})
-  end
-
-  # Instead of returning a 400 when no "id" params is present, Mastodon returns an empty array.
-  def relationships(%{assigns: %{user: _user}} = conn, _), do: json(conn, [])
-
   def update_media(
         %{assigns: %{user: user}} = conn,
         %{"id" => id, "description" => description} = _
@@ -453,118 +222,17 @@ defmodule Pleroma.Web.MastodonAPI.MastodonAPIController do
     json(conn, mascot)
   end
 
-  def followers(%{assigns: %{user: for_user}} = conn, %{"id" => id} = params) do
-    with %User{} = user <- User.get_cached_by_id(id),
-         followers <- MastodonAPI.get_followers(user, params) do
-      followers =
-        cond do
-          for_user && user.id == for_user.id -> followers
-          user.info.hide_followers -> []
-          true -> followers
-        end
-
-      conn
-      |> add_link_headers(followers)
-      |> put_view(AccountView)
-      |> render("accounts.json", %{for: for_user, users: followers, as: :user})
-    end
-  end
-
-  def following(%{assigns: %{user: for_user}} = conn, %{"id" => id} = params) do
-    with %User{} = user <- User.get_cached_by_id(id),
-         followers <- MastodonAPI.get_friends(user, params) do
-      followers =
-        cond do
-          for_user && user.id == for_user.id -> followers
-          user.info.hide_follows -> []
-          true -> followers
-        end
-
-      conn
-      |> add_link_headers(followers)
-      |> put_view(AccountView)
-      |> render("accounts.json", %{for: for_user, users: followers, as: :user})
-    end
-  end
-
-  def follow(%{assigns: %{user: follower}} = conn, %{"id" => id}) do
-    with {_, %User{} = followed} <- {:followed, User.get_cached_by_id(id)},
-         {_, true} <- {:followed, follower.id != followed.id},
-         {:ok, follower} <- MastodonAPI.follow(follower, followed, conn.params) do
-      conn
-      |> put_view(AccountView)
-      |> render("relationship.json", %{user: follower, target: followed})
-    else
-      {:followed, _} ->
-        {:error, :not_found}
-
-      {:error, message} ->
-        conn
-        |> put_status(:forbidden)
-        |> json(%{error: message})
-    end
-  end
-
-  def follow(%{assigns: %{user: follower}} = conn, %{"uri" => uri}) do
+  def follows(%{assigns: %{user: follower}} = conn, %{"uri" => uri}) do
     with {_, %User{} = followed} <- {:followed, User.get_cached_by_nickname(uri)},
          {_, true} <- {:followed, follower.id != followed.id},
          {:ok, follower, followed, _} <- CommonAPI.follow(follower, followed) do
       conn
       |> put_view(AccountView)
-      |> render("account.json", %{user: followed, for: follower})
-    else
-      {:followed, _} ->
-        {:error, :not_found}
-
-      {:error, message} ->
-        conn
-        |> put_status(:forbidden)
-        |> json(%{error: message})
-    end
-  end
-
-  def unfollow(%{assigns: %{user: follower}} = conn, %{"id" => id}) do
-    with {_, %User{} = followed} <- {:followed, User.get_cached_by_id(id)},
-         {_, true} <- {:followed, follower.id != followed.id},
-         {:ok, follower} <- CommonAPI.unfollow(follower, followed) do
-      conn
-      |> put_view(AccountView)
-      |> render("relationship.json", %{user: follower, target: followed})
+      |> render("show.json", %{user: followed, for: follower})
     else
       {:followed, _} ->
         {:error, :not_found}
 
-      error ->
-        error
-    end
-  end
-
-  def mute(%{assigns: %{user: muter}} = conn, %{"id" => id} = params) do
-    notifications =
-      if Map.has_key?(params, "notifications"),
-        do: params["notifications"] in [true, "True", "true", "1"],
-        else: true
-
-    with %User{} = muted <- User.get_cached_by_id(id),
-         {:ok, muter} <- User.mute(muter, muted, notifications) do
-      conn
-      |> put_view(AccountView)
-      |> render("relationship.json", %{user: muter, target: muted})
-    else
-      {:error, message} ->
-        conn
-        |> put_status(:forbidden)
-        |> json(%{error: message})
-    end
-  end
-
-  def unmute(%{assigns: %{user: muter}} = conn, %{"id" => id}) do
-    with %User{} = muted <- User.get_cached_by_id(id),
-         {:ok, muter} <- User.unmute(muter, muted) do
-      conn
-      |> put_view(AccountView)
-      |> render("relationship.json", %{user: muter, target: muted})
-    else
       {:error, message} ->
         conn
         |> put_status(:forbidden)
@@ -574,72 +242,18 @@ defmodule Pleroma.Web.MastodonAPI.MastodonAPIController do
 
   def mutes(%{assigns: %{user: user}} = conn, _) do
     with muted_accounts <- User.muted_users(user) do
-      res = AccountView.render("accounts.json", users: muted_accounts, for: user, as: :user)
+      res = AccountView.render("index.json", users: muted_accounts, for: user, as: :user)
       json(conn, res)
     end
   end
 
-  def block(%{assigns: %{user: blocker}} = conn, %{"id" => id}) do
-    with %User{} = blocked <- User.get_cached_by_id(id),
-         {:ok, blocker} <- User.block(blocker, blocked),
-         {:ok, _activity} <- ActivityPub.block(blocker, blocked) do
-      conn
-      |> put_view(AccountView)
-      |> render("relationship.json", %{user: blocker, target: blocked})
-    else
-      {:error, message} ->
-        conn
-        |> put_status(:forbidden)
-        |> json(%{error: message})
-    end
-  end
-
-  def unblock(%{assigns: %{user: blocker}} = conn, %{"id" => id}) do
-    with %User{} = blocked <- User.get_cached_by_id(id),
-         {:ok, blocker} <- User.unblock(blocker, blocked),
-         {:ok, _activity} <- ActivityPub.unblock(blocker, blocked) do
-      conn
-      |> put_view(AccountView)
-      |> render("relationship.json", %{user: blocker, target: blocked})
-    else
-      {:error, message} ->
-        conn
-        |> put_status(:forbidden)
-        |> json(%{error: message})
-    end
-  end
-
   def blocks(%{assigns: %{user: user}} = conn, _) do
     with blocked_accounts <- User.blocked_users(user) do
-      res = AccountView.render("accounts.json", users: blocked_accounts, for: user, as: :user)
+      res = AccountView.render("index.json", users: blocked_accounts, for: user, as: :user)
       json(conn, res)
     end
   end
 
-  def subscribe(%{assigns: %{user: user}} = conn, %{"id" => id}) do
-    with %User{} = subscription_target <- User.get_cached_by_id(id),
-         {:ok, subscription_target} = User.subscribe(user, subscription_target) do
-      conn
-      |> put_view(AccountView)
-      |> render("relationship.json", %{user: user, target: subscription_target})
-    else
-      nil -> {:error, :not_found}
-      e -> e
-    end
-  end
-
-  def unsubscribe(%{assigns: %{user: user}} = conn, %{"id" => id}) do
-    with %User{} = subscription_target <- User.get_cached_by_id(id),
-         {:ok, subscription_target} = User.unsubscribe(user, subscription_target) do
-      conn
-      |> put_view(AccountView)
-      |> render("relationship.json", %{user: user, target: subscription_target})
-    else
-      nil -> {:error, :not_found}
-      e -> e
-    end
-  end
-
   def favourites(%{assigns: %{user: user}} = conn, params) do
     params =
       params
@@ -657,37 +271,6 @@ defmodule Pleroma.Web.MastodonAPI.MastodonAPIController do
     |> render("index.json", %{activities: activities, for: user, as: :activity})
   end
 
-  def user_favourites(%{assigns: %{user: for_user}} = conn, %{"id" => id} = params) do
-    with %User{} = user <- User.get_by_id(id),
-         false <- user.info.hide_favorites do
-      params =
-        params
-        |> Map.put("type", "Create")
-        |> Map.put("favorited_by", user.ap_id)
-        |> Map.put("blocking_user", for_user)
-
-      recipients =
-        if for_user do
-          [Pleroma.Constants.as_public()] ++ [for_user.ap_id | for_user.following]
-        else
-          [Pleroma.Constants.as_public()]
-        end
-
-      activities =
-        recipients
-        |> ActivityPub.fetch_activities(params)
-        |> Enum.reverse()
-
-      conn
-      |> add_link_headers(activities)
-      |> put_view(StatusView)
-      |> render("index.json", %{activities: activities, for: for_user, as: :activity})
-    else
-      nil -> {:error, :not_found}
-      true -> render_error(conn, :forbidden, "Can't get favorites")
-    end
-  end
-
   def bookmarks(%{assigns: %{user: user}} = conn, params) do
     user = User.get_cached_by_id(user.id)
 
@@ -705,14 +288,6 @@ defmodule Pleroma.Web.MastodonAPI.MastodonAPIController do
     |> render("index.json", %{activities: activities, for: user, as: :activity})
   end
 
-  def account_lists(%{assigns: %{user: user}} = conn, %{"id" => account_id}) do
-    lists = Pleroma.List.get_lists_account_belongs(user, account_id)
-
-    conn
-    |> put_view(ListView)
-    |> render("index.json", %{lists: lists})
-  end
-
   def index(%{assigns: %{user: user}} = conn, _params) do
     token = get_session(conn, :oauth_token)
 
@@ -721,8 +296,7 @@ defmodule Pleroma.Web.MastodonAPI.MastodonAPIController do
 
       limit = Config.get([:instance, :limit])
 
-      accounts =
-        Map.put(%{}, user.id, AccountView.render("account.json", %{user: user, for: user}))
+      accounts = Map.put(%{}, user.id, AccountView.render("show.json", %{user: user, for: user}))
 
       initial_state =
         %{
@@ -943,49 +517,6 @@ defmodule Pleroma.Web.MastodonAPI.MastodonAPIController do
     end
   end
 
-  def account_register(
-        %{assigns: %{app: app}} = conn,
-        %{"username" => nickname, "email" => _, "password" => _, "agreement" => true} = params
-      ) do
-    params =
-      params
-      |> Map.take([
-        "email",
-        "captcha_solution",
-        "captcha_token",
-        "captcha_answer_data",
-        "token",
-        "password"
-      ])
-      |> Map.put("nickname", nickname)
-      |> Map.put("fullname", params["fullname"] || nickname)
-      |> Map.put("bio", params["bio"] || "")
-      |> Map.put("confirm", params["password"])
-
-    with {:ok, user} <- TwitterAPI.register_user(params, need_confirmation: true),
-         {:ok, token} <- Token.create_token(app, user, %{scopes: app.scopes}) do
-      json(conn, %{
-        token_type: "Bearer",
-        access_token: token.token,
-        scope: app.scopes,
-        created_at: Token.Utils.format_created_at(token)
-      })
-    else
-      {:error, errors} ->
-        conn
-        |> put_status(:bad_request)
-        |> json(errors)
-    end
-  end
-
-  def account_register(%{assigns: %{app: _app}} = conn, _) do
-    render_error(conn, :bad_request, "Missing parameters")
-  end
-
-  def account_register(conn, _) do
-    render_error(conn, :forbidden, "Invalid credentials")
-  end
-
   def password_reset(conn, params) do
     nickname_or_email = params["email"] || params["nickname"]
 
@@ -1002,16 +533,6 @@ defmodule Pleroma.Web.MastodonAPI.MastodonAPIController do
     end
   end
 
-  def account_confirmation_resend(conn, params) do
-    nickname_or_email = params["email"] || params["nickname"]
-
-    with %User{} = user <- User.get_by_nickname_or_email(nickname_or_email),
-         {:ok, _} <- User.try_send_confirmation_email(user) do
-      conn
-      |> json_response(:no_content, "")
-    end
-  end
-
   def try_render(conn, target, params)
       when is_binary(target) do
     case render(conn, target, params) do