git.squeep.com Git - akkoma/blob - lib/pleroma/web/admin_api/admin_api_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.AdminAPI.AdminAPIController do
   6   @users_page_size 50
   7
   8   use Pleroma.Web, :controller
   9   alias Pleroma.User
  10   alias Pleroma.Web.ActivityPub.Relay
  11   alias Pleroma.Web.MastodonAPI.Admin.AccountView
  12
  13   import Pleroma.Web.ControllerHelper, only: [json_response: 3]
  14
  15   require Logger
  16
  17   action_fallback(:errors)
  18
  19   def user_delete(conn, %{"nickname" => nickname}) do
  20     User.get_by_nickname(nickname)
  21     |> User.delete()
  22
  23     conn
  24     |> json(nickname)
  25   end
  26
  27   def user_create(
  28         conn,
  29         %{"nickname" => nickname, "email" => email, "password" => password}
  30       ) do
  31     user_data = %{
  32       nickname: nickname,
  33       name: nickname,
  34       email: email,
  35       password: password,
  36       password_confirmation: password,
  37       bio: "."
  38     }
  39
  40     changeset = User.register_changeset(%User{}, user_data, confirmed: true)
  41     {:ok, user} = User.register(changeset)
  42
  43     conn
  44     |> json(user.nickname)
  45   end
  46
  47   def user_toggle_activation(conn, %{"nickname" => nickname}) do
  48     user = User.get_by_nickname(nickname)
  49
  50     {:ok, updated_user} = User.deactivate(user, !user.info.deactivated)
  51
  52     conn
  53     |> json(AccountView.render("show.json", %{user: updated_user}))
  54   end
  55
  56   def tag_users(conn, %{"nicknames" => nicknames, "tags" => tags}) do
  57     with {:ok, _} <- User.tag(nicknames, tags),
  58          do: json_response(conn, :no_content, "")
  59   end
  60
  61   def untag_users(conn, %{"nicknames" => nicknames, "tags" => tags}) do
  62     with {:ok, _} <- User.untag(nicknames, tags),
  63          do: json_response(conn, :no_content, "")
  64   end
  65
  66   def list_users(conn, params) do
  67     {page, page_size} = page_params(params)
  68
  69     with {:ok, users, count} <- User.all_for_admin(page, page_size),
  70          do:
  71            conn
  72            |> json(
  73              AccountView.render("index.json",
  74                users: users,
  75                count: count,
  76                page_size: page_size
  77              )
  78            )
  79   end
  80
  81   def search_users(%{assigns: %{user: admin}} = conn, %{"query" => query} = params) do
  82     {page, page_size} = page_params(params)
  83
  84     with {:ok, users, count} <-
  85            User.search_for_admin(query, %{
  86              admin: admin,
  87              local: params["local"] == "true",
  88              page: page,
  89              page_size: page_size
  90            }),
  91          do:
  92            conn
  93            |> json(
  94              AccountView.render("index.json",
  95                users: users,
  96                count: count,
  97                page_size: page_size
  98              )
  99            )
 100   end
 101
 102   def right_add(conn, %{"permission_group" => permission_group, "nickname" => nickname})
 103       when permission_group in ["moderator", "admin"] do
 104     user = User.get_by_nickname(nickname)
 105
 106     info =
 107       %{}
 108       |> Map.put("is_" <> permission_group, true)
 109
 110     info_cng = User.Info.admin_api_update(user.info, info)
 111
 112     cng =
 113       user
 114       |> Ecto.Changeset.change()
 115       |> Ecto.Changeset.put_embed(:info, info_cng)
 116
 117     {:ok, _user} = User.update_and_set_cache(cng)
 118
 119     json(conn, info)
 120   end
 121
 122   def right_add(conn, _) do
 123     conn
 124     |> put_status(404)
 125     |> json(%{error: "No such permission_group"})
 126   end
 127
 128   def right_get(conn, %{"nickname" => nickname}) do
 129     user = User.get_by_nickname(nickname)
 130
 131     conn
 132     |> json(%{
 133       is_moderator: user.info.is_moderator,
 134       is_admin: user.info.is_admin
 135     })
 136   end
 137
 138   def right_delete(
 139         %{assigns: %{user: %User{:nickname => admin_nickname}}} = conn,
 140         %{
 141           "permission_group" => permission_group,
 142           "nickname" => nickname
 143         }
 144       )
 145       when permission_group in ["moderator", "admin"] do
 146     if admin_nickname == nickname do
 147       conn
 148       |> put_status(403)
 149       |> json(%{error: "You can't revoke your own admin status."})
 150     else
 151       user = User.get_by_nickname(nickname)
 152
 153       info =
 154         %{}
 155         |> Map.put("is_" <> permission_group, false)
 156
 157       info_cng = User.Info.admin_api_update(user.info, info)
 158
 159       cng =
 160         Ecto.Changeset.change(user)
 161         |> Ecto.Changeset.put_embed(:info, info_cng)
 162
 163       {:ok, _user} = User.update_and_set_cache(cng)
 164
 165       json(conn, info)
 166     end
 167   end
 168
 169   def right_delete(conn, _) do
 170     conn
 171     |> put_status(404)
 172     |> json(%{error: "No such permission_group"})
 173   end
 174
 175   def set_activation_status(conn, %{"nickname" => nickname, "status" => status}) do
 176     with {:ok, status} <- Ecto.Type.cast(:boolean, status),
 177          %User{} = user <- User.get_by_nickname(nickname),
 178          {:ok, _} <- User.deactivate(user, !status),
 179          do: json_response(conn, :no_content, "")
 180   end
 181
 182   def relay_follow(conn, %{"relay_url" => target}) do
 183     with {:ok, _message} <- Relay.follow(target) do
 184       json(conn, target)
 185     else
 186       _ ->
 187         conn
 188         |> put_status(500)
 189         |> json(target)
 190     end
 191   end
 192
 193   def relay_unfollow(conn, %{"relay_url" => target}) do
 194     with {:ok, _message} <- Relay.unfollow(target) do
 195       json(conn, target)
 196     else
 197       _ ->
 198         conn
 199         |> put_status(500)
 200         |> json(target)
 201     end
 202   end
 203
 204   @doc "Sends registration invite via email"
 205   def email_invite(%{assigns: %{user: user}} = conn, %{"email" => email} = params) do
 206     with true <-
 207            Pleroma.Config.get([:instance, :invites_enabled]) &&
 208              !Pleroma.Config.get([:instance, :registrations_open]),
 209          {:ok, invite_token} <- Pleroma.UserInviteToken.create_token(),
 210          email <-
 211            Pleroma.UserEmail.user_invitation_email(user, invite_token, email, params["name"]),
 212          {:ok, _} <- Pleroma.Mailer.deliver(email) do
 213       json_response(conn, :no_content, "")
 214     end
 215   end
 216
 217   @doc "Get a account registeration invite token (base64 string)"
 218   def get_invite_token(conn, _params) do
 219     {:ok, token} = Pleroma.UserInviteToken.create_token()
 220
 221     conn
 222     |> json(token.token)
 223   end
 224
 225   @doc "Get a password reset token (base64 string) for given nickname"
 226   def get_password_reset(conn, %{"nickname" => nickname}) do
 227     (%User{local: true} = user) = User.get_by_nickname(nickname)
 228     {:ok, token} = Pleroma.PasswordResetToken.create_token(user)
 229
 230     conn
 231     |> json(token.token)
 232   end
 233
 234   def errors(conn, {:param_cast, _}) do
 235     conn
 236     |> put_status(400)
 237     |> json("Invalid parameters")
 238   end
 239
 240   def errors(conn, _) do
 241     conn
 242     |> put_status(500)
 243     |> json("Something went wrong")
 244   end
 245
 246   defp page_params(params) do
 247     {get_page(params["page"]), get_page_size(params["page_size"])}
 248   end
 249
 250   defp get_page(page_string) when is_nil(page_string), do: 1
 251
 252   defp get_page(page_string) do
 253     case Integer.parse(page_string) do
 254       {page, _} -> page
 255       :error -> 1
 256     end
 257   end
 258
 259   defp get_page_size(page_size_string) when is_nil(page_size_string), do: @users_page_size
 260
 261   defp get_page_size(page_size_string) do
 262     case Integer.parse(page_size_string) do
 263       {page_size, _} -> page_size
 264       :error -> @users_page_size
 265     end
 266   end
 267 end