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
   6   @shortdoc "Manages Pleroma users"
   7   @moduledoc """
   8   Manages Pleroma users.
   9
  10   ## Create a new user.
  11
  12       mix pleroma.user new NICKNAME EMAIL [OPTION...]
  13
  14   Options:
  15   - `--name NAME` - the user's name (i.e., "Lain Iwakura")
  16   - `--bio BIO` - the user's bio
  17   - `--password PASSWORD` - the user's password
  18   - `--moderator`/`--no-moderator` - whether the user is a moderator
  19   - `--admin`/`--no-admin` - whether the user is an admin
  20
  21   ## Generate an invite link.
  22
  23      mix pleroma.user invite
  24
  25   ## Delete the user's account.
  26
  27       mix pleroma.user rm NICKNAME
  28
  29   ## Deactivate or activate the user's account.
  30
  31       mix pleroma.user toggle_activated NICKNAME
  32
  33   ## Create a password reset link.
  34
  35       mix pleroma.user reset_password NICKNAME
  36
  37   ## Set the value of the given user's settings.
  38
  39       mix pleroma.user set NICKNAME [OPTION...]
  40
  41   Options:
  42   - `--locked`/`--no-locked` - whether the user's account is locked
  43   - `--moderator`/`--no-moderator` - whether the user is a moderator
  44   - `--admin`/`--no-admin` - whether the user is an admin
  45   """
  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       Mix.Task.run("app.start")
  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     Mix.Task.run("app.start")
 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     Mix.Task.run("app.start")
 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     Mix.Task.run("app.start")
 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     Mix.Task.run("app.start")
 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     Application.ensure_all_started(: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 =
 236       user.info
 237       |> Map.put("is_moderator", value)
 238
 239     info_cng = User.Info.admin_api_update(user.info, %{is_moderator: value})
 240     user_cng =
 241                Ecto.Changeset.change(user)
 242                |> put_embed(:info, info_cng)
 243
 244     {:ok, user} = User.update_and_set_cache(user_cng)
 245
 246     Mix.shell().info("Moderator status of #{user.nickname}: #{user.info.is_moderator}")
 247   end
 248
 249   defp set_admin(user, value) do
 250     info =
 251       user.info
 252       |> Map.put("is_admin", value)
 253
 254     info_cng = User.Info.admin_api_update(user.info, %{is_admin: value})
 255     user_cng =
 256                Ecto.Changeset.change(user)
 257                |> put_embed(:info, info_cng)
 258
 259     {:ok, user} = User.update_and_set_cache(user_cng)
 260
 261     Mix.shell().info("Admin status of #{user.nickname}: #{user.info.is_moderator}")
 262   end
 263
 264   defp set_locked(user, value) do
 265     info =
 266       user.info
 267       |> Map.put("locked", value)
 268
 269     info_cng = User.Info.user_upgrade(user.info, %{locked: value})
 270     user_cng =
 271                Ecto.Changeset.change(user)
 272                |> put_embed(:info, info_cng)
 273
 274     {:ok, user} = User.update_and_set_cache(user_cng)
 275
 276     Mix.shell().info("Locked status of #{user.nickname}: #{user.info.locked}")
 277   end
 278
 279   def run(["invite"]) do
 280     Mix.Task.run("app.start")
 281
 282     with {:ok, token} <- Pleroma.UserInviteToken.create_token() do
 283       Mix.shell().info("Generated user invite token")
 284
 285       url =
 286         Pleroma.Web.Router.Helpers.redirect_url(
 287           Pleroma.Web.Endpoint,
 288           :registration_page,
 289           token.token
 290         )
 291
 292       IO.puts(url)
 293     else
 294       _ ->
 295         Mix.shell().error("Could not create invite token.")
 296     end
 297   end
 298 end