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   use Pleroma.Web, :controller
   7   alias Pleroma.User
   8   alias Pleroma.UserInviteToken
   9   alias Pleroma.Web.ActivityPub.Relay
  10   alias Pleroma.Web.AdminAPI.AccountView
  11   alias Pleroma.Web.AdminAPI.Search
  12
  13   import Pleroma.Web.ControllerHelper, only: [json_response: 3]
  14
  15   require Logger
  16
  17   @users_page_size 50
  18
  19   action_fallback(:errors)
  20
  21   def user_delete(conn, %{"nickname" => nickname}) do
  22     User.get_cached_by_nickname(nickname)
  23     |> User.delete()
  24
  25     conn
  26     |> json(nickname)
  27   end
  28
  29   def user_follow(conn, %{"follower" => follower_nick, "followed" => followed_nick}) do
  30     with %User{} = follower <- User.get_cached_by_nickname(follower_nick),
  31          %User{} = followed <- User.get_cached_by_nickname(followed_nick) do
  32       User.follow(follower, followed)
  33     end
  34
  35     conn
  36     |> json("ok")
  37   end
  38
  39   def user_unfollow(conn, %{"follower" => follower_nick, "followed" => followed_nick}) do
  40     with %User{} = follower <- User.get_cached_by_nickname(follower_nick),
  41          %User{} = followed <- User.get_cached_by_nickname(followed_nick) do
  42       User.unfollow(follower, followed)
  43     end
  44
  45     conn
  46     |> json("ok")
  47   end
  48
  49   def users_create(conn, %{"users" => users}) do
  50     result =
  51       Enum.map(users, fn %{"nickname" => nickname, "email" => email, "password" => password} ->
  52         user_data = %{
  53           nickname: nickname,
  54           name: nickname,
  55           email: email,
  56           password: password,
  57           password_confirmation: password,
  58           bio: "."
  59         }
  60
  61         changeset = User.register_changeset(%User{}, user_data, need_confirmation: false)
  62
  63         case User.register(changeset) do
  64           {:ok, user} ->
  65             AccountView.render("created.json", %{user: user})
  66
  67           {:error, changeset} ->
  68             AccountView.render("create-error.json", %{changeset: changeset})
  69         end
  70       end)
  71
  72     conn
  73     |> json(result)
  74   end
  75
  76   def user_show(conn, %{"nickname" => nickname}) do
  77     with %User{} = user <- User.get_cached_by_nickname(nickname) do
  78       conn
  79       |> json(AccountView.render("show.json", %{user: user}))
  80     else
  81       _ -> {:error, :not_found}
  82     end
  83   end
  84
  85   def user_toggle_activation(conn, %{"nickname" => nickname}) do
  86     user = User.get_cached_by_nickname(nickname)
  87
  88     {:ok, updated_user} = User.deactivate(user, !user.info.deactivated)
  89
  90     conn
  91     |> json(AccountView.render("show.json", %{user: updated_user}))
  92   end
  93
  94   def tag_users(conn, %{"nicknames" => nicknames, "tags" => tags}) do
  95     with {:ok, _} <- User.tag(nicknames, tags),
  96          do: json_response(conn, :no_content, "")
  97   end
  98
  99   def untag_users(conn, %{"nicknames" => nicknames, "tags" => tags}) do
 100     with {:ok, _} <- User.untag(nicknames, tags),
 101          do: json_response(conn, :no_content, "")
 102   end
 103
 104   def list_users(conn, params) do
 105     {page, page_size} = page_params(params)
 106     filters = maybe_parse_filters(params["filters"])
 107
 108     search_params = %{
 109       query: params["query"],
 110       page: page,
 111       page_size: page_size,
 112       tags: params["tags"],
 113       name: params["name"],
 114       email: params["email"]
 115     }
 116
 117     with {:ok, users, count} <- Search.user(Map.merge(search_params, filters)),
 118          do:
 119            conn
 120            |> json(
 121              AccountView.render("index.json",
 122                users: users,
 123                count: count,
 124                page_size: page_size
 125              )
 126            )
 127   end
 128
 129   @filters ~w(local external active deactivated is_admin is_moderator)
 130
 131   @spec maybe_parse_filters(String.t()) :: %{required(String.t()) => true} | %{}
 132   defp maybe_parse_filters(filters) when is_nil(filters) or filters == "", do: %{}
 133
 134   defp maybe_parse_filters(filters) do
 135     filters
 136     |> String.split(",")
 137     |> Enum.filter(&Enum.member?(@filters, &1))
 138     |> Enum.map(&String.to_atom(&1))
 139     |> Enum.into(%{}, &{&1, true})
 140   end
 141
 142   def right_add(conn, %{"permission_group" => permission_group, "nickname" => nickname})
 143       when permission_group in ["moderator", "admin"] do
 144     user = User.get_cached_by_nickname(nickname)
 145
 146     info =
 147       %{}
 148       |> Map.put("is_" <> permission_group, true)
 149
 150     info_cng = User.Info.admin_api_update(user.info, info)
 151
 152     cng =
 153       user
 154       |> Ecto.Changeset.change()
 155       |> Ecto.Changeset.put_embed(:info, info_cng)
 156
 157     {:ok, _user} = User.update_and_set_cache(cng)
 158
 159     json(conn, info)
 160   end
 161
 162   def right_add(conn, _) do
 163     conn
 164     |> put_status(404)
 165     |> json(%{error: "No such permission_group"})
 166   end
 167
 168   def right_get(conn, %{"nickname" => nickname}) do
 169     user = User.get_cached_by_nickname(nickname)
 170
 171     conn
 172     |> json(%{
 173       is_moderator: user.info.is_moderator,
 174       is_admin: user.info.is_admin
 175     })
 176   end
 177
 178   def right_delete(
 179         %{assigns: %{user: %User{:nickname => admin_nickname}}} = conn,
 180         %{
 181           "permission_group" => permission_group,
 182           "nickname" => nickname
 183         }
 184       )
 185       when permission_group in ["moderator", "admin"] do
 186     if admin_nickname == nickname do
 187       conn
 188       |> put_status(403)
 189       |> json(%{error: "You can't revoke your own admin status."})
 190     else
 191       user = User.get_cached_by_nickname(nickname)
 192
 193       info =
 194         %{}
 195         |> Map.put("is_" <> permission_group, false)
 196
 197       info_cng = User.Info.admin_api_update(user.info, info)
 198
 199       cng =
 200         Ecto.Changeset.change(user)
 201         |> Ecto.Changeset.put_embed(:info, info_cng)
 202
 203       {:ok, _user} = User.update_and_set_cache(cng)
 204
 205       json(conn, info)
 206     end
 207   end
 208
 209   def right_delete(conn, _) do
 210     conn
 211     |> put_status(404)
 212     |> json(%{error: "No such permission_group"})
 213   end
 214
 215   def set_activation_status(conn, %{"nickname" => nickname, "status" => status}) do
 216     with {:ok, status} <- Ecto.Type.cast(:boolean, status),
 217          %User{} = user <- User.get_cached_by_nickname(nickname),
 218          {:ok, _} <- User.deactivate(user, !status),
 219          do: json_response(conn, :no_content, "")
 220   end
 221
 222   def relay_follow(conn, %{"relay_url" => target}) do
 223     with {:ok, _message} <- Relay.follow(target) do
 224       json(conn, target)
 225     else
 226       _ ->
 227         conn
 228         |> put_status(500)
 229         |> json(target)
 230     end
 231   end
 232
 233   def relay_unfollow(conn, %{"relay_url" => target}) do
 234     with {:ok, _message} <- Relay.unfollow(target) do
 235       json(conn, target)
 236     else
 237       _ ->
 238         conn
 239         |> put_status(500)
 240         |> json(target)
 241     end
 242   end
 243
 244   @doc "Sends registration invite via email"
 245   def email_invite(%{assigns: %{user: user}} = conn, %{"email" => email} = params) do
 246     with true <-
 247            Pleroma.Config.get([:instance, :invites_enabled]) &&
 248              !Pleroma.Config.get([:instance, :registrations_open]),
 249          {:ok, invite_token} <- UserInviteToken.create_invite(),
 250          email <-
 251            Pleroma.Emails.UserEmail.user_invitation_email(
 252              user,
 253              invite_token,
 254              email,
 255              params["name"]
 256            ),
 257          {:ok, _} <- Pleroma.Emails.Mailer.deliver(email) do
 258       json_response(conn, :no_content, "")
 259     end
 260   end
 261
 262   @doc "Get a account registeration invite token (base64 string)"
 263   def get_invite_token(conn, params) do
 264     options = params["invite"] || %{}
 265     {:ok, invite} = UserInviteToken.create_invite(options)
 266
 267     conn
 268     |> json(invite.token)
 269   end
 270
 271   @doc "Get list of created invites"
 272   def invites(conn, _params) do
 273     invites = UserInviteToken.list_invites()
 274
 275     conn
 276     |> json(AccountView.render("invites.json", %{invites: invites}))
 277   end
 278
 279   @doc "Revokes invite by token"
 280   def revoke_invite(conn, %{"token" => token}) do
 281     invite = UserInviteToken.find_by_token!(token)
 282     {:ok, updated_invite} = UserInviteToken.update_invite(invite, %{used: true})
 283
 284     conn
 285     |> json(AccountView.render("invite.json", %{invite: updated_invite}))
 286   end
 287
 288   @doc "Get a password reset token (base64 string) for given nickname"
 289   def get_password_reset(conn, %{"nickname" => nickname}) do
 290     (%User{local: true} = user) = User.get_cached_by_nickname(nickname)
 291     {:ok, token} = Pleroma.PasswordResetToken.create_token(user)
 292
 293     conn
 294     |> json(token.token)
 295   end
 296
 297   def errors(conn, {:error, :not_found}) do
 298     conn
 299     |> put_status(404)
 300     |> json("Not found")
 301   end
 302
 303   def errors(conn, {:param_cast, _}) do
 304     conn
 305     |> put_status(400)
 306     |> json("Invalid parameters")
 307   end
 308
 309   def errors(conn, _) do
 310     conn
 311     |> put_status(500)
 312     |> json("Something went wrong")
 313   end
 314
 315   defp page_params(params) do
 316     {get_page(params["page"]), get_page_size(params["page_size"])}
 317   end
 318
 319   defp get_page(page_string) when is_nil(page_string), do: 1
 320
 321   defp get_page(page_string) do
 322     case Integer.parse(page_string) do
 323       {page, _} -> page
 324       :error -> 1
 325     end
 326   end
 327
 328   defp get_page_size(page_size_string) when is_nil(page_size_string), do: @users_page_size
 329
 330   defp get_page_size(page_size_string) do
 331     case Integer.parse(page_size_string) do
 332       {page_size, _} -> page_size
 333       :error -> @users_page_size
 334     end
 335   end
 336 end