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