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