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