git.squeep.com Git - akkoma/blob - lib/mix/tasks/pleroma/user.ex

   1 # Pleroma: A lightweight social networking server
   2 # Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
   3 # SPDX-License-Identifier: AGPL-3.0-only
   4
   5 defmodule Mix.Tasks.Pleroma.User do
   6   use Mix.Task
   7   import Mix.Pleroma
   8   alias Ecto.Changeset
   9   alias Pleroma.User
  10   alias Pleroma.UserInviteToken
  11   alias Pleroma.Web.ActivityPub.Builder
  12   alias Pleroma.Web.ActivityPub.Pipeline
  13
  14   @shortdoc "Manages Pleroma users"
  15   @moduledoc File.read!("docs/administration/CLI_tasks/user.md")
  16
  17   def run(["new", nickname, email | rest]) do
  18     {options, [], []} =
  19       OptionParser.parse(
  20         rest,
  21         strict: [
  22           name: :string,
  23           bio: :string,
  24           password: :string,
  25           moderator: :boolean,
  26           admin: :boolean,
  27           assume_yes: :boolean
  28         ],
  29         aliases: [
  30           y: :assume_yes
  31         ]
  32       )
  33
  34     name = Keyword.get(options, :name, nickname)
  35     bio = Keyword.get(options, :bio, "")
  36
  37     {password, generated_password?} =
  38       case Keyword.get(options, :password) do
  39         nil ->
  40           {:crypto.strong_rand_bytes(16) |> Base.encode64(), true}
  41
  42         password ->
  43           {password, false}
  44       end
  45
  46     moderator? = Keyword.get(options, :moderator, false)
  47     admin? = Keyword.get(options, :admin, false)
  48     assume_yes? = Keyword.get(options, :assume_yes, false)
  49
  50     shell_info("""
  51     A user will be created with the following information:
  52       - nickname: #{nickname}
  53       - email: #{email}
  54       - password: #{
  55       if(generated_password?, do: "[generated; a reset link will be created]", else: password)
  56     }
  57       - name: #{name}
  58       - bio: #{bio}
  59       - moderator: #{if(moderator?, do: "true", else: "false")}
  60       - admin: #{if(admin?, do: "true", else: "false")}
  61     """)
  62
  63     proceed? = assume_yes? or shell_yes?("Continue?")
  64
  65     if proceed? do
  66       start_pleroma()
  67
  68       params = %{
  69         nickname: nickname,
  70         email: email,
  71         password: password,
  72         password_confirmation: password,
  73         name: name,
  74         bio: bio
  75       }
  76
  77       changeset = User.register_changeset(%User{}, params, need_confirmation: false)
  78       {:ok, _user} = User.register(changeset)
  79
  80       shell_info("User #{nickname} created")
  81
  82       if moderator? do
  83         run(["set", nickname, "--moderator"])
  84       end
  85
  86       if admin? do
  87         run(["set", nickname, "--admin"])
  88       end
  89
  90       if generated_password? do
  91         run(["reset_password", nickname])
  92       end
  93     else
  94       shell_info("User will not be created.")
  95     end
  96   end
  97
  98   def run(["rm", nickname]) do
  99     start_pleroma()
 100
 101     with %User{local: true} = user <- User.get_cached_by_nickname(nickname),
 102          {:ok, delete_data, _} <- Builder.delete(user, user.ap_id),
 103          {:ok, _delete, _} <- Pipeline.common_pipeline(delete_data, local: true) do
 104       shell_info("User #{nickname} deleted.")
 105     else
 106       _ -> shell_error("No local user #{nickname}")
 107     end
 108   end
 109
 110   def run(["toggle_activated", nickname]) do
 111     start_pleroma()
 112
 113     with %User{} = user <- User.get_cached_by_nickname(nickname) do
 114       {:ok, user} = User.deactivate(user, !user.deactivated)
 115
 116       shell_info(
 117         "Activation status of #{nickname}: #{if(user.deactivated, do: "de", else: "")}activated"
 118       )
 119     else
 120       _ ->
 121         shell_error("No user #{nickname}")
 122     end
 123   end
 124
 125   def run(["reset_password", nickname]) do
 126     start_pleroma()
 127
 128     with %User{local: true} = user <- User.get_cached_by_nickname(nickname),
 129          {:ok, token} <- Pleroma.PasswordResetToken.create_token(user) do
 130       shell_info("Generated password reset token for #{user.nickname}")
 131
 132       IO.puts(
 133         "URL: #{
 134           Pleroma.Web.Router.Helpers.reset_password_url(
 135             Pleroma.Web.Endpoint,
 136             :reset,
 137             token.token
 138           )
 139         }"
 140       )
 141     else
 142       _ ->
 143         shell_error("No local user #{nickname}")
 144     end
 145   end
 146
 147   def run(["unsubscribe", nickname]) do
 148     start_pleroma()
 149
 150     with %User{} = user <- User.get_cached_by_nickname(nickname) do
 151       shell_info("Deactivating #{user.nickname}")
 152       User.deactivate(user)
 153
 154       user
 155       |> User.get_friends()
 156       |> Enum.each(fn friend ->
 157         user = User.get_cached_by_id(user.id)
 158
 159         shell_info("Unsubscribing #{friend.nickname} from #{user.nickname}")
 160         User.unfollow(user, friend)
 161       end)
 162
 163       :timer.sleep(500)
 164
 165       user = User.get_cached_by_id(user.id)
 166
 167       if Enum.empty?(User.get_friends(user)) do
 168         shell_info("Successfully unsubscribed all followers from #{user.nickname}")
 169       end
 170     else
 171       _ ->
 172         shell_error("No user #{nickname}")
 173     end
 174   end
 175
 176   def run(["unsubscribe_all_from_instance", instance]) do
 177     start_pleroma()
 178
 179     Pleroma.User.Query.build(%{nickname: "@#{instance}"})
 180     |> Pleroma.RepoStreamer.chunk_stream(500)
 181     |> Stream.each(fn users ->
 182       users
 183       |> Enum.each(fn user ->
 184         run(["unsubscribe", user.nickname])
 185       end)
 186     end)
 187     |> Stream.run()
 188   end
 189
 190   def run(["set", nickname | rest]) do
 191     start_pleroma()
 192
 193     {options, [], []} =
 194       OptionParser.parse(
 195         rest,
 196         strict: [
 197           moderator: :boolean,
 198           admin: :boolean,
 199           locked: :boolean
 200         ]
 201       )
 202
 203     with %User{local: true} = user <- User.get_cached_by_nickname(nickname) do
 204       user =
 205         case Keyword.get(options, :moderator) do
 206           nil -> user
 207           value -> set_moderator(user, value)
 208         end
 209
 210       user =
 211         case Keyword.get(options, :locked) do
 212           nil -> user
 213           value -> set_locked(user, value)
 214         end
 215
 216       _user =
 217         case Keyword.get(options, :admin) do
 218           nil -> user
 219           value -> set_admin(user, value)
 220         end
 221     else
 222       _ ->
 223         shell_error("No local user #{nickname}")
 224     end
 225   end
 226
 227   def run(["tag", nickname | tags]) do
 228     start_pleroma()
 229
 230     with %User{} = user <- User.get_cached_by_nickname(nickname) do
 231       user = user |> User.tag(tags)
 232
 233       shell_info("Tags of #{user.nickname}: #{inspect(tags)}")
 234     else
 235       _ ->
 236         shell_error("Could not change user tags for #{nickname}")
 237     end
 238   end
 239
 240   def run(["untag", nickname | tags]) do
 241     start_pleroma()
 242
 243     with %User{} = user <- User.get_cached_by_nickname(nickname) do
 244       user = user |> User.untag(tags)
 245
 246       shell_info("Tags of #{user.nickname}: #{inspect(tags)}")
 247     else
 248       _ ->
 249         shell_error("Could not change user tags for #{nickname}")
 250     end
 251   end
 252
 253   def run(["invite" | rest]) do
 254     {options, [], []} =
 255       OptionParser.parse(rest,
 256         strict: [
 257           expires_at: :string,
 258           max_use: :integer
 259         ]
 260       )
 261
 262     options =
 263       options
 264       |> Keyword.update(:expires_at, {:ok, nil}, fn
 265         nil -> {:ok, nil}
 266         val -> Date.from_iso8601(val)
 267       end)
 268       |> Enum.into(%{})
 269
 270     start_pleroma()
 271
 272     with {:ok, val} <- options[:expires_at],
 273          options = Map.put(options, :expires_at, val),
 274          {:ok, invite} <- UserInviteToken.create_invite(options) do
 275       shell_info("Generated user invite token " <> String.replace(invite.invite_type, "_", " "))
 276
 277       url =
 278         Pleroma.Web.Router.Helpers.redirect_url(
 279           Pleroma.Web.Endpoint,
 280           :registration_page,
 281           invite.token
 282         )
 283
 284       IO.puts(url)
 285     else
 286       error ->
 287         shell_error("Could not create invite token: #{inspect(error)}")
 288     end
 289   end
 290
 291   def run(["invites"]) do
 292     start_pleroma()
 293
 294     shell_info("Invites list:")
 295
 296     UserInviteToken.list_invites()
 297     |> Enum.each(fn invite ->
 298       expire_info =
 299         with expires_at when not is_nil(expires_at) <- invite.expires_at do
 300           " | Expires at: #{Date.to_string(expires_at)}"
 301         end
 302
 303       using_info =
 304         with max_use when not is_nil(max_use) <- invite.max_use do
 305           " | Max use: #{max_use}    Left use: #{max_use - invite.uses}"
 306         end
 307
 308       shell_info(
 309         "ID: #{invite.id} | Token: #{invite.token} | Token type: #{invite.invite_type} | Used: #{
 310           invite.used
 311         }#{expire_info}#{using_info}"
 312       )
 313     end)
 314   end
 315
 316   def run(["revoke_invite", token]) do
 317     start_pleroma()
 318
 319     with {:ok, invite} <- UserInviteToken.find_by_token(token),
 320          {:ok, _} <- UserInviteToken.update_invite(invite, %{used: true}) do
 321       shell_info("Invite for token #{token} was revoked.")
 322     else
 323       _ -> shell_error("No invite found with token #{token}")
 324     end
 325   end
 326
 327   def run(["delete_activities", nickname]) do
 328     start_pleroma()
 329
 330     with %User{local: true} = user <- User.get_cached_by_nickname(nickname) do
 331       User.delete_user_activities(user)
 332       shell_info("User #{nickname} statuses deleted.")
 333     else
 334       _ ->
 335         shell_error("No local user #{nickname}")
 336     end
 337   end
 338
 339   def run(["toggle_confirmed", nickname]) do
 340     start_pleroma()
 341
 342     with %User{} = user <- User.get_cached_by_nickname(nickname) do
 343       {:ok, user} = User.toggle_confirmation(user)
 344
 345       message = if user.confirmation_pending, do: "needs", else: "doesn't need"
 346
 347       shell_info("#{nickname} #{message} confirmation.")
 348     else
 349       _ ->
 350         shell_error("No local user #{nickname}")
 351     end
 352   end
 353
 354   def run(["sign_out", nickname]) do
 355     start_pleroma()
 356
 357     with %User{local: true} = user <- User.get_cached_by_nickname(nickname) do
 358       User.global_sign_out(user)
 359
 360       shell_info("#{nickname} signed out from all apps.")
 361     else
 362       _ ->
 363         shell_error("No local user #{nickname}")
 364     end
 365   end
 366
 367   def run(["list"]) do
 368     start_pleroma()
 369
 370     Pleroma.User.Query.build(%{local: true})
 371     |> Pleroma.RepoStreamer.chunk_stream(500)
 372     |> Stream.each(fn users ->
 373       users
 374       |> Enum.each(fn user ->
 375         shell_info(
 376           "#{user.nickname} moderator: #{user.is_moderator}, admin: #{user.is_admin}, locked: #{
 377             user.locked
 378           }, deactivated: #{user.deactivated}"
 379         )
 380       end)
 381     end)
 382     |> Stream.run()
 383   end
 384
 385   defp set_moderator(user, value) do
 386     {:ok, user} =
 387       user
 388       |> Changeset.change(%{is_moderator: value})
 389       |> User.update_and_set_cache()
 390
 391     shell_info("Moderator status of #{user.nickname}: #{user.is_moderator}")
 392     user
 393   end
 394
 395   defp set_admin(user, value) do
 396     {:ok, user} = User.admin_api_update(user, %{is_admin: value})
 397
 398     shell_info("Admin status of #{user.nickname}: #{user.is_admin}")
 399     user
 400   end
 401
 402   defp set_locked(user, value) do
 403     {:ok, user} =
 404       user
 405       |> Changeset.change(%{locked: value})
 406       |> User.update_and_set_cache()
 407
 408     shell_info("Locked status of #{user.nickname}: #{user.locked}")
 409     user
 410   end
 411 end