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