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.TwitterAPI.UserView
  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(UserView.render("show_for_admin.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(%{assigns: %{user: admin}} = conn, %{"page" => page_string}) do
  67     with {page, _} <- Integer.parse(page_string),
  68          users <- User.all_except_one(admin, page, @users_page_size),
  69          count <- User.count_all_except_one(admin),
  70          do:
  71            conn
  72            |> json(
  73              UserView.render("index_for_admin.json", %{
  74                users: users,
  75                count: count,
  76                page_size: @users_page_size
  77              })
  78            )
  79   end
  80
  81   def right_add(conn, %{"permission_group" => permission_group, "nickname" => nickname})
  82       when permission_group in ["moderator", "admin"] do
  83     user = User.get_by_nickname(nickname)
  84
  85     info =
  86       %{}
  87       |> Map.put("is_" <> permission_group, true)
  88
  89     info_cng = User.Info.admin_api_update(user.info, info)
  90
  91     cng =
  92       user
  93       |> Ecto.Changeset.change()
  94       |> Ecto.Changeset.put_embed(:info, info_cng)
  95
  96     {:ok, _user} = User.update_and_set_cache(cng)
  97
  98     json(conn, info)
  99   end
 100
 101   def right_add(conn, _) do
 102     conn
 103     |> put_status(404)
 104     |> json(%{error: "No such permission_group"})
 105   end
 106
 107   def right_get(conn, %{"nickname" => nickname}) do
 108     user = User.get_by_nickname(nickname)
 109
 110     conn
 111     |> json(%{
 112       is_moderator: user.info.is_moderator,
 113       is_admin: user.info.is_admin
 114     })
 115   end
 116
 117   def right_delete(
 118         %{assigns: %{user: %User{:nickname => admin_nickname}}} = conn,
 119         %{
 120           "permission_group" => permission_group,
 121           "nickname" => nickname
 122         }
 123       )
 124       when permission_group in ["moderator", "admin"] do
 125     if admin_nickname == nickname do
 126       conn
 127       |> put_status(403)
 128       |> json(%{error: "You can't revoke your own admin status."})
 129     else
 130       user = User.get_by_nickname(nickname)
 131
 132       info =
 133         %{}
 134         |> Map.put("is_" <> permission_group, false)
 135
 136       info_cng = User.Info.admin_api_update(user.info, info)
 137
 138       cng =
 139         Ecto.Changeset.change(user)
 140         |> Ecto.Changeset.put_embed(:info, info_cng)
 141
 142       {:ok, _user} = User.update_and_set_cache(cng)
 143
 144       json(conn, info)
 145     end
 146   end
 147
 148   def right_delete(conn, _) do
 149     conn
 150     |> put_status(404)
 151     |> json(%{error: "No such permission_group"})
 152   end
 153
 154   def set_activation_status(conn, %{"nickname" => nickname, "status" => status}) do
 155     with {:ok, status} <- Ecto.Type.cast(:boolean, status),
 156          %User{} = user <- User.get_by_nickname(nickname),
 157          {:ok, _} <- User.deactivate(user, !status),
 158          do: json_response(conn, :no_content, "")
 159   end
 160
 161   def relay_follow(conn, %{"relay_url" => target}) do
 162     with {:ok, _message} <- Relay.follow(target) do
 163       json(conn, target)
 164     else
 165       _ ->
 166         conn
 167         |> put_status(500)
 168         |> json(target)
 169     end
 170   end
 171
 172   def relay_unfollow(conn, %{"relay_url" => target}) do
 173     with {:ok, _message} <- Relay.unfollow(target) do
 174       json(conn, target)
 175     else
 176       _ ->
 177         conn
 178         |> put_status(500)
 179         |> json(target)
 180     end
 181   end
 182
 183   @doc "Sends registration invite via email"
 184   def email_invite(%{assigns: %{user: user}} = conn, %{"email" => email} = params) do
 185     with true <-
 186            Pleroma.Config.get([:instance, :invites_enabled]) &&
 187              !Pleroma.Config.get([:instance, :registrations_open]),
 188          {:ok, invite_token} <- Pleroma.UserInviteToken.create_token(),
 189          email <-
 190            Pleroma.UserEmail.user_invitation_email(user, invite_token, email, params["name"]),
 191          {:ok, _} <- Pleroma.Mailer.deliver(email) do
 192       json_response(conn, :no_content, "")
 193     end
 194   end
 195
 196   @doc "Get a account registeration invite token (base64 string)"
 197   def get_invite_token(conn, _params) do
 198     {:ok, token} = Pleroma.UserInviteToken.create_token()
 199
 200     conn
 201     |> json(token.token)
 202   end
 203
 204   @doc "Get a password reset token (base64 string) for given nickname"
 205   def get_password_reset(conn, %{"nickname" => nickname}) do
 206     (%User{local: true} = user) = User.get_by_nickname(nickname)
 207     {:ok, token} = Pleroma.PasswordResetToken.create_token(user)
 208
 209     conn
 210     |> json(token.token)
 211   end
 212
 213   def errors(conn, {:param_cast, _}) do
 214     conn
 215     |> put_status(400)
 216     |> json("Invalid parameters")
 217   end
 218
 219   def errors(conn, _) do
 220     conn
 221     |> put_status(500)
 222     |> json("Something went wrong")
 223   end
 224 end