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   alias Mix.Tasks.Pleroma.Common
   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     Common.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 Common.shell_yes?("Continue?")
 137
 138     if proceed? do
 139       Common.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       Common.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       Common.shell_info("User will not be created.")
 168     end
 169   end
 170
 171   def run(["rm", nickname]) do
 172     Common.start_pleroma()
 173
 174     with %User{local: true} = user <- User.get_cached_by_nickname(nickname) do
 175       User.perform(:delete, user)
 176       Common.shell_info("User #{nickname} deleted.")
 177     else
 178       _ ->
 179         Common.shell_error("No local user #{nickname}")
 180     end
 181   end
 182
 183   def run(["toggle_activated", nickname]) do
 184     Common.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       Common.shell_info(
 190         "Activation status of #{nickname}: #{if(user.info.deactivated, do: "de", else: "")}activated"
 191       )
 192     else
 193       _ ->
 194         Common.shell_error("No user #{nickname}")
 195     end
 196   end
 197
 198   def run(["reset_password", nickname]) do
 199     Common.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       Common.shell_info("Generated password reset token for #{user.nickname}")
 204
 205       IO.puts(
 206         "URL: #{
 207           Pleroma.Web.Router.Helpers.util_url(
 208             Pleroma.Web.Endpoint,
 209             :show_password_reset,
 210             token.token
 211           )
 212         }"
 213       )
 214     else
 215       _ ->
 216         Common.shell_error("No local user #{nickname}")
 217     end
 218   end
 219
 220   def run(["unsubscribe", nickname]) do
 221     Common.start_pleroma()
 222
 223     with %User{} = user <- User.get_cached_by_nickname(nickname) do
 224       Common.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         Common.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         Common.shell_info("Successfully unsubscribed all followers from #{user.nickname}")
 242       end
 243     else
 244       _ ->
 245         Common.shell_error("No user #{nickname}")
 246     end
 247   end
 248
 249   def run(["set", nickname | rest]) do
 250     Common.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         Common.shell_error("No local user #{nickname}")
 283     end
 284   end
 285
 286   def run(["tag", nickname | tags]) do
 287     Common.start_pleroma()
 288
 289     with %User{} = user <- User.get_cached_by_nickname(nickname) do
 290       user = user |> User.tag(tags)
 291
 292       Common.shell_info("Tags of #{user.nickname}: #{inspect(tags)}")
 293     else
 294       _ ->
 295         Common.shell_error("Could not change user tags for #{nickname}")
 296     end
 297   end
 298
 299   def run(["untag", nickname | tags]) do
 300     Common.start_pleroma()
 301
 302     with %User{} = user <- User.get_cached_by_nickname(nickname) do
 303       user = user |> User.untag(tags)
 304
 305       Common.shell_info("Tags of #{user.nickname}: #{inspect(tags)}")
 306     else
 307       _ ->
 308         Common.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     Common.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       Common.shell_info(
 335         "Generated user invite token " <> String.replace(invite.invite_type, "_", " ")
 336       )
 337
 338       url =
 339         Pleroma.Web.Router.Helpers.redirect_url(
 340           Pleroma.Web.Endpoint,
 341           :registration_page,
 342           invite.token
 343         )
 344
 345       IO.puts(url)
 346     else
 347       error ->
 348         Common.shell_error("Could not create invite token: #{inspect(error)}")
 349     end
 350   end
 351
 352   def run(["invites"]) do
 353     Common.start_pleroma()
 354
 355     Common.shell_info("Invites list:")
 356
 357     UserInviteToken.list_invites()
 358     |> Enum.each(fn invite ->
 359       expire_info =
 360         with expires_at when not is_nil(expires_at) <- invite.expires_at do
 361           " | Expires at: #{Date.to_string(expires_at)}"
 362         end
 363
 364       using_info =
 365         with max_use when not is_nil(max_use) <- invite.max_use do
 366           " | Max use: #{max_use}    Left use: #{max_use - invite.uses}"
 367         end
 368
 369       Common.shell_info(
 370         "ID: #{invite.id} | Token: #{invite.token} | Token type: #{invite.invite_type} | Used: #{
 371           invite.used
 372         }#{expire_info}#{using_info}"
 373       )
 374     end)
 375   end
 376
 377   def run(["revoke_invite", token]) do
 378     Common.start_pleroma()
 379
 380     with {:ok, invite} <- UserInviteToken.find_by_token(token),
 381          {:ok, _} <- UserInviteToken.update_invite(invite, %{used: true}) do
 382       Common.shell_info("Invite for token #{token} was revoked.")
 383     else
 384       _ -> Common.shell_error("No invite found with token #{token}")
 385     end
 386   end
 387
 388   def run(["delete_activities", nickname]) do
 389     Common.start_pleroma()
 390
 391     with %User{local: true} = user <- User.get_cached_by_nickname(nickname) do
 392       {:ok, _} = User.delete_user_activities(user)
 393       Common.shell_info("User #{nickname} statuses deleted.")
 394     else
 395       _ ->
 396         Common.shell_error("No local user #{nickname}")
 397     end
 398   end
 399
 400   def run(["toggle_confirmed", nickname]) do
 401     Common.start_pleroma()
 402
 403     with %User{} = user <- User.get_cached_by_nickname(nickname) do
 404       {:ok, user} = User.toggle_confirmation(user)
 405
 406       message = if user.info.confirmation_pending, do: "needs", else: "doesn't need"
 407
 408       Common.shell_info("#{nickname} #{message} confirmation.")
 409     else
 410       _ ->
 411         Common.shell_error("No local user #{nickname}")
 412     end
 413   end
 414
 415   def run(["sign_out", nickname]) do
 416     Common.start_pleroma()
 417
 418     with %User{local: true} = user <- User.get_cached_by_nickname(nickname) do
 419       OAuth.Token.delete_user_tokens(user)
 420       OAuth.Authorization.delete_user_authorizations(user)
 421
 422       Common.shell_info("#{nickname} signed out from all apps.")
 423     else
 424       _ ->
 425         Common.shell_error("No local user #{nickname}")
 426     end
 427   end
 428
 429   defp set_moderator(user, value) do
 430     info_cng = User.Info.admin_api_update(user.info, %{is_moderator: value})
 431
 432     user_cng =
 433       Ecto.Changeset.change(user)
 434       |> put_embed(:info, info_cng)
 435
 436     {:ok, user} = User.update_and_set_cache(user_cng)
 437
 438     Common.shell_info("Moderator status of #{user.nickname}: #{user.info.is_moderator}")
 439     user
 440   end
 441
 442   defp set_admin(user, value) do
 443     info_cng = User.Info.admin_api_update(user.info, %{is_admin: value})
 444
 445     user_cng =
 446       Ecto.Changeset.change(user)
 447       |> put_embed(:info, info_cng)
 448
 449     {:ok, user} = User.update_and_set_cache(user_cng)
 450
 451     Common.shell_info("Admin status of #{user.nickname}: #{user.info.is_admin}")
 452     user
 453   end
 454
 455   defp set_locked(user, value) do
 456     info_cng = User.Info.user_upgrade(user.info, %{locked: value})
 457
 458     user_cng =
 459       Ecto.Changeset.change(user)
 460       |> put_embed(:info, info_cng)
 461
 462     {:ok, user} = User.update_and_set_cache(user_cng)
 463
 464     Common.shell_info("Locked status of #{user.nickname}: #{user.info.locked}")
 465     user
 466   end
 467 end