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

   1 # Pleroma: A lightweight social networking server
   2 # Copyright © 2017-2018 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 Ecto.Changeset
   8   import Mix.Pleroma
   9   alias Pleroma.User
  10   alias Pleroma.UserInviteToken
  11   alias Pleroma.Web.OAuth
  12
  13   @shortdoc "Manages Pleroma users"
  14   @moduledoc """
  15   Manages Pleroma users.
  16
  17   ## Create a new user.
  18
  19       mix pleroma.user new NICKNAME EMAIL [OPTION...]
  20
  21   Options:
  22   - `--name NAME` - the user's name (i.e., "Lain Iwakura")
  23   - `--bio BIO` - the user's bio
  24   - `--password PASSWORD` - the user's password
  25   - `--moderator`/`--no-moderator` - whether the user is a moderator
  26   - `--admin`/`--no-admin` - whether the user is an admin
  27   - `-y`, `--assume-yes`/`--no-assume-yes` - whether to assume yes to all questions
  28
  29   ## Generate an invite link.
  30
  31       mix pleroma.user invite [OPTION...]
  32
  33     Options:
  34     - `--expires_at DATE` - last day on which token is active (e.g. "2019-04-05")
  35     - `--max_use NUMBER` - maximum numbers of token uses
  36
  37   ## List generated invites
  38
  39       mix pleroma.user invites
  40
  41   ## Revoke invite
  42
  43       mix pleroma.user revoke_invite TOKEN OR TOKEN_ID
  44
  45   ## Delete the user's account.
  46
  47       mix pleroma.user rm NICKNAME
  48
  49   ## Delete the user's activities.
  50
  51       mix pleroma.user delete_activities NICKNAME
  52
  53   ## Sign user out from all applications (delete user's OAuth tokens and authorizations).
  54
  55       mix pleroma.user sign_out NICKNAME
  56
  57   ## Deactivate or activate the user's account.
  58
  59       mix pleroma.user toggle_activated NICKNAME
  60
  61   ## Unsubscribe local users from user's account and deactivate it
  62
  63       mix pleroma.user unsubscribe NICKNAME
  64
  65   ## Create a password reset link.
  66
  67       mix pleroma.user reset_password NICKNAME
  68
  69   ## Set the value of the given user's settings.
  70
  71       mix pleroma.user set NICKNAME [OPTION...]
  72
  73   Options:
  74   - `--locked`/`--no-locked` - whether the user's account is locked
  75   - `--moderator`/`--no-moderator` - whether the user is a moderator
  76   - `--admin`/`--no-admin` - whether the user is an admin
  77
  78   ## Add tags to a user.
  79
  80       mix pleroma.user tag NICKNAME TAGS
  81
  82   ## Delete tags from a user.
  83
  84       mix pleroma.user untag NICKNAME TAGS
  85
  86   ## Toggle confirmation of the user's account.
  87
  88       mix pleroma.user toggle_confirmed NICKNAME
  89   """
  90   def run(["new", nickname, email | rest]) do
  91     {options, [], []} =
  92       OptionParser.parse(
  93         rest,
  94         strict: [
  95           name: :string,
  96           bio: :string,
  97           password: :string,
  98           moderator: :boolean,
  99           admin: :boolean,
 100           assume_yes: :boolean
 101         ],
 102         aliases: [
 103           y: :assume_yes
 104         ]
 105       )
 106
 107     name = Keyword.get(options, :name, nickname)
 108     bio = Keyword.get(options, :bio, "")
 109
 110     {password, generated_password?} =
 111       case Keyword.get(options, :password) do
 112         nil ->
 113           {:crypto.strong_rand_bytes(16) |> Base.encode64(), true}
 114
 115         password ->
 116           {password, false}
 117       end
 118
 119     moderator? = Keyword.get(options, :moderator, false)
 120     admin? = Keyword.get(options, :admin, false)
 121     assume_yes? = Keyword.get(options, :assume_yes, false)
 122
 123     shell_info("""
 124     A user will be created with the following information:
 125       - nickname: #{nickname}
 126       - email: #{email}
 127       - password: #{
 128       if(generated_password?, do: "[generated; a reset link will be created]", else: password)
 129     }
 130       - name: #{name}
 131       - bio: #{bio}
 132       - moderator: #{if(moderator?, do: "true", else: "false")}
 133       - admin: #{if(admin?, do: "true", else: "false")}
 134     """)
 135
 136     proceed? = assume_yes? or shell_yes?("Continue?")
 137
 138     if proceed? do
 139       start_pleroma()
 140
 141       params = %{
 142         nickname: nickname,
 143         email: email,
 144         password: password,
 145         password_confirmation: password,
 146         name: name,
 147         bio: bio
 148       }
 149
 150       changeset = User.register_changeset(%User{}, params, need_confirmation: false)
 151       {:ok, _user} = User.register(changeset)
 152
 153       shell_info("User #{nickname} created")
 154
 155       if moderator? do
 156         run(["set", nickname, "--moderator"])
 157       end
 158
 159       if admin? do
 160         run(["set", nickname, "--admin"])
 161       end
 162
 163       if generated_password? do
 164         run(["reset_password", nickname])
 165       end
 166     else
 167       shell_info("User will not be created.")
 168     end
 169   end
 170
 171   def run(["rm", nickname]) do
 172     start_pleroma()
 173
 174     with %User{local: true} = user <- User.get_cached_by_nickname(nickname) do
 175       User.perform(:delete, user)
 176       shell_info("User #{nickname} deleted.")
 177     else
 178       _ ->
 179         shell_error("No local user #{nickname}")
 180     end
 181   end
 182
 183   def run(["toggle_activated", nickname]) do
 184     start_pleroma()
 185
 186     with %User{} = user <- User.get_cached_by_nickname(nickname) do
 187       {:ok, user} = User.deactivate(user, !user.info.deactivated)
 188
 189       shell_info(
 190         "Activation status of #{nickname}: #{if(user.info.deactivated, do: "de", else: "")}activated"
 191       )
 192     else
 193       _ ->
 194         shell_error("No user #{nickname}")
 195     end
 196   end
 197
 198   def run(["reset_password", nickname]) do
 199     start_pleroma()
 200
 201     with %User{local: true} = user <- User.get_cached_by_nickname(nickname),
 202          {:ok, token} <- Pleroma.PasswordResetToken.create_token(user) do
 203       shell_info("Generated password reset token for #{user.nickname}")
 204
 205       IO.puts(
 206         "URL: #{
 207           Pleroma.Web.Router.Helpers.reset_password_url(
 208             Pleroma.Web.Endpoint,
 209             :reset,
 210             token.token
 211           )
 212         }"
 213       )
 214     else
 215       _ ->
 216         shell_error("No local user #{nickname}")
 217     end
 218   end
 219
 220   def run(["unsubscribe", nickname]) do
 221     start_pleroma()
 222
 223     with %User{} = user <- User.get_cached_by_nickname(nickname) do
 224       shell_info("Deactivating #{user.nickname}")
 225       User.deactivate(user)
 226
 227       {:ok, friends} = User.get_friends(user)
 228
 229       Enum.each(friends, fn friend ->
 230         user = User.get_cached_by_id(user.id)
 231
 232         shell_info("Unsubscribing #{friend.nickname} from #{user.nickname}")
 233         User.unfollow(user, friend)
 234       end)
 235
 236       :timer.sleep(500)
 237
 238       user = User.get_cached_by_id(user.id)
 239
 240       if Enum.empty?(user.following) do
 241         shell_info("Successfully unsubscribed all followers from #{user.nickname}")
 242       end
 243     else
 244       _ ->
 245         shell_error("No user #{nickname}")
 246     end
 247   end
 248
 249   def run(["set", nickname | rest]) do
 250     start_pleroma()
 251
 252     {options, [], []} =
 253       OptionParser.parse(
 254         rest,
 255         strict: [
 256           moderator: :boolean,
 257           admin: :boolean,
 258           locked: :boolean
 259         ]
 260       )
 261
 262     with %User{local: true} = user <- User.get_cached_by_nickname(nickname) do
 263       user =
 264         case Keyword.get(options, :moderator) do
 265           nil -> user
 266           value -> set_moderator(user, value)
 267         end
 268
 269       user =
 270         case Keyword.get(options, :locked) do
 271           nil -> user
 272           value -> set_locked(user, value)
 273         end
 274
 275       _user =
 276         case Keyword.get(options, :admin) do
 277           nil -> user
 278           value -> set_admin(user, value)
 279         end
 280     else
 281       _ ->
 282         shell_error("No local user #{nickname}")
 283     end
 284   end
 285
 286   def run(["tag", nickname | tags]) do
 287     start_pleroma()
 288
 289     with %User{} = user <- User.get_cached_by_nickname(nickname) do
 290       user = user |> User.tag(tags)
 291
 292       shell_info("Tags of #{user.nickname}: #{inspect(tags)}")
 293     else
 294       _ ->
 295         shell_error("Could not change user tags for #{nickname}")
 296     end
 297   end
 298
 299   def run(["untag", nickname | tags]) do
 300     start_pleroma()
 301
 302     with %User{} = user <- User.get_cached_by_nickname(nickname) do
 303       user = user |> User.untag(tags)
 304
 305       shell_info("Tags of #{user.nickname}: #{inspect(tags)}")
 306     else
 307       _ ->
 308         shell_error("Could not change user tags for #{nickname}")
 309     end
 310   end
 311
 312   def run(["invite" | rest]) do
 313     {options, [], []} =
 314       OptionParser.parse(rest,
 315         strict: [
 316           expires_at: :string,
 317           max_use: :integer
 318         ]
 319       )
 320
 321     options =
 322       options
 323       |> Keyword.update(:expires_at, {:ok, nil}, fn
 324         nil -> {:ok, nil}
 325         val -> Date.from_iso8601(val)
 326       end)
 327       |> Enum.into(%{})
 328
 329     start_pleroma()
 330
 331     with {:ok, val} <- options[:expires_at],
 332          options = Map.put(options, :expires_at, val),
 333          {:ok, invite} <- UserInviteToken.create_invite(options) do
 334       shell_info("Generated user invite token " <> String.replace(invite.invite_type, "_", " "))
 335
 336       url =
 337         Pleroma.Web.Router.Helpers.redirect_url(
 338           Pleroma.Web.Endpoint,
 339           :registration_page,
 340           invite.token
 341         )
 342
 343       IO.puts(url)
 344     else
 345       error ->
 346         shell_error("Could not create invite token: #{inspect(error)}")
 347     end
 348   end
 349
 350   def run(["invites"]) do
 351     start_pleroma()
 352
 353     shell_info("Invites list:")
 354
 355     UserInviteToken.list_invites()
 356     |> Enum.each(fn invite ->
 357       expire_info =
 358         with expires_at when not is_nil(expires_at) <- invite.expires_at do
 359           " | Expires at: #{Date.to_string(expires_at)}"
 360         end
 361
 362       using_info =
 363         with max_use when not is_nil(max_use) <- invite.max_use do
 364           " | Max use: #{max_use}    Left use: #{max_use - invite.uses}"
 365         end
 366
 367       shell_info(
 368         "ID: #{invite.id} | Token: #{invite.token} | Token type: #{invite.invite_type} | Used: #{
 369           invite.used
 370         }#{expire_info}#{using_info}"
 371       )
 372     end)
 373   end
 374
 375   def run(["revoke_invite", token]) do
 376     start_pleroma()
 377
 378     with {:ok, invite} <- UserInviteToken.find_by_token(token),
 379          {:ok, _} <- UserInviteToken.update_invite(invite, %{used: true}) do
 380       shell_info("Invite for token #{token} was revoked.")
 381     else
 382       _ -> shell_error("No invite found with token #{token}")
 383     end
 384   end
 385
 386   def run(["delete_activities", nickname]) do
 387     start_pleroma()
 388
 389     with %User{local: true} = user <- User.get_cached_by_nickname(nickname) do
 390       {:ok, _} = User.delete_user_activities(user)
 391       shell_info("User #{nickname} statuses deleted.")
 392     else
 393       _ ->
 394         shell_error("No local user #{nickname}")
 395     end
 396   end
 397
 398   def run(["change_email", nickname, email]) do
 399     start_pleroma()
 400     with %User{} = user <- User.get_cached_by_nickname(nickname) do
 401        user
 402        |> User.update_changeset(%{"email" => email})
 403        |> User.update_and_set_cache()
 404        shell_info("#{nickname}'s email updated")
 405     end
 406   end
 407
 408   def run(["send_confirmation", nickname]) do
 409     start_pleroma()
 410     with %User{} = user <- User.get_cached_by_nickname(nickname) do
 411        user
 412        |> Pleroma.Emails.UserEmail.account_confirmation_email()
 413        |> IO.inspect
 414        |> Pleroma.Emails.Mailer.deliver!()
 415        shell_info("#{nickname}'s email sent")
 416     end
 417   end
 418
 419
 420   def run(["toggle_confirmed", nickname]) do
 421     start_pleroma()
 422
 423     with %User{} = user <- User.get_cached_by_nickname(nickname) do
 424       {:ok, user} = User.toggle_confirmation(user)
 425
 426       message = if user.info.confirmation_pending, do: "needs", else: "doesn't need"
 427
 428       shell_info("#{nickname} #{message} confirmation.")
 429     else
 430       _ ->
 431         shell_error("No local user #{nickname}")
 432     end
 433   end
 434
 435   def run(["sign_out", nickname]) do
 436     start_pleroma()
 437
 438     with %User{local: true} = user <- User.get_cached_by_nickname(nickname) do
 439       OAuth.Token.delete_user_tokens(user)
 440       OAuth.Authorization.delete_user_authorizations(user)
 441
 442       shell_info("#{nickname} signed out from all apps.")
 443     else
 444       _ ->
 445         shell_error("No local user #{nickname}")
 446     end
 447   end
 448
 449   defp set_moderator(user, value) do
 450     info_cng = User.Info.admin_api_update(user.info, %{is_moderator: value})
 451
 452     user_cng =
 453       Ecto.Changeset.change(user)
 454       |> put_embed(:info, info_cng)
 455
 456     {:ok, user} = User.update_and_set_cache(user_cng)
 457
 458     shell_info("Moderator status of #{user.nickname}: #{user.info.is_moderator}")
 459     user
 460   end
 461
 462   defp set_admin(user, value) do
 463     info_cng = User.Info.admin_api_update(user.info, %{is_admin: value})
 464
 465     user_cng =
 466       Ecto.Changeset.change(user)
 467       |> put_embed(:info, info_cng)
 468
 469     {:ok, user} = User.update_and_set_cache(user_cng)
 470
 471     shell_info("Admin status of #{user.nickname}: #{user.info.is_admin}")
 472     user
 473   end
 474
 475   defp set_locked(user, value) do
 476     info_cng = User.Info.user_upgrade(user.info, %{locked: value})
 477
 478     user_cng =
 479       Ecto.Changeset.change(user)
 480       |> put_embed(:info, info_cng)
 481
 482     {:ok, user} = User.update_and_set_cache(user_cng)
 483
 484     shell_info("Locked status of #{user.nickname}: #{user.info.locked}")
 485     user
 486   end
 487 end