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

   1 defmodule Mix.Tasks.Pleroma.User do
   2   use Mix.Task
   3   import Ecto.Changeset
   4   alias Pleroma.{Repo, User}
   5   alias Mix.Tasks.Pleroma.Common
   6
   7   @shortdoc "Manages Pleroma users"
   8   @moduledoc """
   9   Manages Pleroma users.
  10
  11   ## Create a new user.
  12
  13       mix pleroma.user new NICKNAME EMAIL [OPTION...]
  14
  15   Options:
  16   - `--name NAME` - the user's name (i.e., "Lain Iwakura")
  17   - `--bio BIO` - the user's bio
  18   - `--password PASSWORD` - the user's password
  19   - `--moderator`/`--no-moderator` - whether the user is a moderator
  20   - `--admin`/`--no-admin` - whether the user is an admin
  21
  22   ## Generate an invite link.
  23
  24      mix pleroma.user invite
  25
  26   ## Delete the user's account.
  27
  28       mix pleroma.user rm NICKNAME
  29
  30   ## Deactivate or activate the user's account.
  31
  32       mix pleroma.user toggle_activated NICKNAME
  33
  34   ## Create a password reset link.
  35
  36       mix pleroma.user reset_password NICKNAME
  37
  38   ## Set the value of the given user's settings.
  39
  40       mix pleroma.user set NICKNAME [OPTION...]
  41
  42   Options:
  43   - `--locked`/`--no-locked` - whether the user's account is locked
  44   - `--moderator`/`--no-moderator` - whether the user is a moderator
  45   - `--admin`/`--no-admin` - whether the user is an admin
  46   """
  47   def run(["new", nickname, email | rest]) do
  48     {options, [], []} =
  49       OptionParser.parse(
  50         rest,
  51         strict: [
  52           name: :string,
  53           bio: :string,
  54           password: :string,
  55           moderator: :boolean,
  56           admin: :boolean
  57         ]
  58       )
  59
  60     name = Keyword.get(options, :name, nickname)
  61     bio = Keyword.get(options, :bio, "")
  62
  63     {password, generated_password?} =
  64       case Keyword.get(options, :password) do
  65         nil ->
  66           {:crypto.strong_rand_bytes(16) |> Base.encode64(), true}
  67
  68         password ->
  69           {password, false}
  70       end
  71
  72     moderator? = Keyword.get(options, :moderator, false)
  73     admin? = Keyword.get(options, :admin, false)
  74
  75     Mix.shell().info("""
  76     A user will be created with the following information:
  77       - nickname: #{nickname}
  78       - email: #{email}
  79       - password: #{
  80       if(generated_password?, do: "[generated; a reset link will be created]", else: password)
  81     }
  82       - name: #{name}
  83       - bio: #{bio}
  84       - moderator: #{if(moderator?, do: "true", else: "false")}
  85       - admin: #{if(admin?, do: "true", else: "false")}
  86     """)
  87
  88     proceed? = Mix.shell().yes?("Continue?")
  89
  90     unless not proceed? do
  91       Common.start_pleroma()
  92
  93       params =
  94         %{
  95           nickname: nickname,
  96           email: email,
  97           password: password,
  98           password_confirmation: password,
  99           name: name,
 100           bio: bio
 101         }
 102         |> IO.inspect()
 103
 104       user = User.register_changeset(%User{}, params)
 105       Repo.insert!(user)
 106
 107       Mix.shell().info("User #{nickname} created")
 108
 109       if moderator? do
 110         run(["set", nickname, "--moderator"])
 111       end
 112
 113       if admin? do
 114         run(["set", nickname, "--admin"])
 115       end
 116
 117       if generated_password? do
 118         run(["reset_password", nickname])
 119       end
 120     else
 121       Mix.shell().info("User will not be created.")
 122     end
 123   end
 124
 125   def run(["rm", nickname]) do
 126     Common.start_pleroma()
 127
 128     with %User{local: true} = user <- User.get_by_nickname(nickname) do
 129       User.delete(user)
 130       Mix.shell().info("User #{nickname} deleted.")
 131     else
 132       _ ->
 133         Mix.shell().error("No local user #{nickname}")
 134     end
 135   end
 136
 137   def run(["toggle_activated", nickname]) do
 138     Common.start_pleroma()
 139
 140     with %User{} = user <- User.get_by_nickname(nickname) do
 141       User.deactivate(user, !user.info["deactivated"])
 142       Mix.shell().info("Activation status of #{nickname}: #{user.info["deactivated"]}")
 143     else
 144       _ ->
 145         Mix.shell().error("No user #{nickname}")
 146     end
 147   end
 148
 149   def run(["reset_password", nickname]) do
 150     Common.start_pleroma()
 151
 152     with %User{local: true} = user <- User.get_by_nickname(nickname),
 153          {:ok, token} <- Pleroma.PasswordResetToken.create_token(user) do
 154       Mix.shell().info("Generated password reset token for #{user.nickname}")
 155
 156       IO.puts(
 157         "URL: #{
 158           Pleroma.Web.Router.Helpers.util_url(
 159             Pleroma.Web.Endpoint,
 160             :show_password_reset,
 161             token.token
 162           )
 163         }"
 164       )
 165     else
 166       _ ->
 167         Mix.shell().error("No local user #{nickname}")
 168     end
 169   end
 170
 171   def run(["unsubscribe", nickname]) do
 172     Common.start_pleroma()
 173
 174     with %User{} = user <- User.get_by_nickname(nickname) do
 175       Mix.shell().info("Deactivating #{user.nickname}")
 176       User.deactivate(user)
 177
 178       {:ok, friends} = User.get_friends(user)
 179
 180       Enum.each(friends, fn friend ->
 181         user = Repo.get(User, user.id)
 182
 183         Mix.shell().info("Unsubscribing #{friend.nickname} from #{user.nickname}")
 184         User.unfollow(user, friend)
 185       end)
 186
 187       :timer.sleep(500)
 188
 189       user = Repo.get(User, user.id)
 190
 191       if length(user.following) == 0 do
 192         Mix.shell().info("Successfully unsubscribed all followers from #{user.nickname}")
 193       end
 194     else
 195       _ ->
 196         Mix.shell().error("No user #{nickname}")
 197     end
 198   end
 199
 200   def run(["set", nickname | rest]) do
 201     Common.start_pleroma()
 202
 203     {options, [], []} =
 204       OptionParser.parse(
 205         rest,
 206         strict: [
 207           moderator: :boolean,
 208           admin: :boolean,
 209           locked: :boolean
 210         ]
 211       )
 212
 213     with %User{local: true} = user <- User.get_by_nickname(nickname) do
 214       case Keyword.get(options, :moderator) do
 215         nil -> nil
 216         value -> set_moderator(user, value)
 217       end
 218
 219       case Keyword.get(options, :locked) do
 220         nil -> nil
 221         value -> set_locked(user, value)
 222       end
 223
 224       case Keyword.get(options, :admin) do
 225         nil -> nil
 226         value -> set_admin(user, value)
 227       end
 228     else
 229       _ ->
 230         Mix.shell().error("No local user #{nickname}")
 231     end
 232   end
 233
 234   defp set_moderator(user, value) do
 235     info_cng = User.Info.admin_api_update(user.info, %{is_moderator: value})
 236
 237     user_cng =
 238       Ecto.Changeset.change(user)
 239       |> put_embed(:info, info_cng)
 240
 241     {:ok, user} = User.update_and_set_cache(user_cng)
 242
 243     Mix.shell().info("Moderator status of #{user.nickname}: #{user.info.is_moderator}")
 244   end
 245
 246   defp set_admin(user, value) do
 247     info_cng = User.Info.admin_api_update(user.info, %{is_admin: value})
 248
 249     user_cng =
 250       Ecto.Changeset.change(user)
 251       |> put_embed(:info, info_cng)
 252
 253     {:ok, user} = User.update_and_set_cache(user_cng)
 254
 255     Mix.shell().info("Admin status of #{user.nickname}: #{user.info.is_moderator}")
 256   end
 257
 258   defp set_locked(user, value) do
 259     info_cng = User.Info.user_upgrade(user.info, %{locked: value})
 260
 261     user_cng =
 262       Ecto.Changeset.change(user)
 263       |> put_embed(:info, info_cng)
 264
 265     {:ok, user} = User.update_and_set_cache(user_cng)
 266
 267     Mix.shell().info("Locked status of #{user.nickname}: #{user.info.locked}")
 268   end
 269
 270   def run(["invite"]) do
 271     Common.start_pleroma()
 272
 273     with {:ok, token} <- Pleroma.UserInviteToken.create_token() do
 274       Mix.shell().info("Generated user invite token")
 275
 276       url =
 277         Pleroma.Web.Router.Helpers.redirect_url(
 278           Pleroma.Web.Endpoint,
 279           :registration_page,
 280           token.token
 281         )
 282
 283       IO.puts(url)
 284     else
 285       _ ->
 286         Mix.shell().error("Could not create invite token.")
 287     end
 288   end
 289 end