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

   1 # Pleroma: A lightweight social networking server
   2 # Copyright © 2017-2021 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 Mix.Pleroma
   8   alias Ecto.Changeset
   9   alias Pleroma.User
  10   alias Pleroma.Web.ActivityPub.ActivityPub
  11   alias Pleroma.UserInviteToken
  12   alias Pleroma.Web.ActivityPub.Builder
  13   alias Pleroma.Web.ActivityPub.Pipeline
  14
  15   @shortdoc "Manages Pleroma users"
  16   @moduledoc File.read!("docs/docs/administration/CLI_tasks/user.md")
  17
  18   def run(["new", nickname, email | rest]) do
  19     {options, [], []} =
  20       OptionParser.parse(
  21         rest,
  22         strict: [
  23           name: :string,
  24           bio: :string,
  25           password: :string,
  26           moderator: :boolean,
  27           admin: :boolean,
  28           assume_yes: :boolean
  29         ],
  30         aliases: [
  31           y: :assume_yes
  32         ]
  33       )
  34
  35     name = Keyword.get(options, :name, nickname)
  36     bio = Keyword.get(options, :bio, "")
  37
  38     {password, generated_password?} =
  39       case Keyword.get(options, :password) do
  40         nil ->
  41           {:crypto.strong_rand_bytes(16) |> Base.encode64(), true}
  42
  43         password ->
  44           {password, false}
  45       end
  46
  47     moderator? = Keyword.get(options, :moderator, false)
  48     admin? = Keyword.get(options, :admin, false)
  49     assume_yes? = Keyword.get(options, :assume_yes, false)
  50
  51     shell_info("""
  52     A user will be created with the following information:
  53       - nickname: #{nickname}
  54       - email: #{email}
  55       - password: #{if(generated_password?, do: "[generated; a reset link will be created]", else: password)}
  56       - name: #{name}
  57       - bio: #{bio}
  58       - moderator: #{if(moderator?, do: "true", else: "false")}
  59       - admin: #{if(admin?, do: "true", else: "false")}
  60     """)
  61
  62     proceed? = assume_yes? or shell_prompt("Continue?", "n") in ~w(Yn Y y)
  63
  64     if proceed? do
  65       start_pleroma()
  66
  67       params = %{
  68         nickname: nickname,
  69         email: email,
  70         password: password,
  71         password_confirmation: password,
  72         name: name,
  73         bio: bio
  74       }
  75
  76       changeset = User.register_changeset(%User{}, params, is_confirmed: true)
  77       {:ok, _user} = User.register(changeset)
  78
  79       shell_info("User #{nickname} created")
  80
  81       if moderator? do
  82         run(["set", nickname, "--moderator"])
  83       end
  84
  85       if admin? do
  86         run(["set", nickname, "--admin"])
  87       end
  88
  89       if generated_password? do
  90         run(["reset_password", nickname])
  91       end
  92     else
  93       shell_info("User will not be created.")
  94     end
  95   end
  96
  97   def run(["rm", nickname]) do
  98     start_pleroma()
  99
 100     with %User{local: true} = user <- User.get_cached_by_nickname(nickname),
 101          {:ok, delete_data, _} <- Builder.delete(user, user.ap_id),
 102          {:ok, _delete, _} <- Pipeline.common_pipeline(delete_data, local: true) do
 103       shell_info("User #{nickname} deleted.")
 104     else
 105       _ -> shell_error("No local user #{nickname}")
 106     end
 107   end
 108
 109   def run(["reset_password", nickname]) do
 110     start_pleroma()
 111
 112     with %User{local: true} = user <- User.get_cached_by_nickname(nickname),
 113          {:ok, token} <- Pleroma.PasswordResetToken.create_token(user) do
 114       shell_info("Generated password reset token for #{user.nickname}")
 115
 116       IO.puts(
 117         "URL: #{Pleroma.Web.Router.Helpers.reset_password_url(Pleroma.Web.Endpoint,
 118         :reset,
 119         token.token)}"
 120       )
 121     else
 122       _ ->
 123         shell_error("No local user #{nickname}")
 124     end
 125   end
 126
 127   def run(["reset_mfa", nickname]) do
 128     start_pleroma()
 129
 130     with %User{local: true} = user <- User.get_cached_by_nickname(nickname),
 131          {:ok, _token} <- Pleroma.MFA.disable(user) do
 132       shell_info("Multi-Factor Authentication disabled for #{user.nickname}")
 133     else
 134       _ ->
 135         shell_error("No local user #{nickname}")
 136     end
 137   end
 138
 139   def run(["activate", nickname]) do
 140     start_pleroma()
 141
 142     with %User{} = user <- User.get_cached_by_nickname(nickname),
 143          false <- user.is_active do
 144       User.set_activation(user, true)
 145       :timer.sleep(500)
 146
 147       shell_info("Successfully activated #{nickname}")
 148     else
 149       true ->
 150         shell_info("User #{nickname} already activated")
 151
 152       _ ->
 153         shell_error("No user #{nickname}")
 154     end
 155   end
 156
 157   def run(["deactivate", nickname]) do
 158     start_pleroma()
 159
 160     with %User{} = user <- User.get_cached_by_nickname(nickname),
 161          true <- user.is_active do
 162       User.set_activation(user, false)
 163       :timer.sleep(500)
 164
 165       user = User.get_cached_by_id(user.id)
 166
 167       if Enum.empty?(Enum.filter(User.get_friends(user), & &1.local)) do
 168         shell_info("Successfully deactivated #{nickname} and unsubscribed all local followers")
 169       end
 170     else
 171       false ->
 172         shell_info("User #{nickname} already deactivated")
 173
 174       _ ->
 175         shell_error("No user #{nickname}")
 176     end
 177   end
 178
 179   def run(["deactivate_all_from_instance", instance]) do
 180     start_pleroma()
 181
 182     Pleroma.User.Query.build(%{nickname: "@#{instance}"})
 183     |> Pleroma.Repo.chunk_stream(500, :batches)
 184     |> Stream.each(fn users ->
 185       users
 186       |> Enum.each(fn user ->
 187         run(["deactivate", user.nickname])
 188       end)
 189     end)
 190     |> Stream.run()
 191   end
 192
 193   def run(["set", nickname | rest]) do
 194     start_pleroma()
 195
 196     {options, [], []} =
 197       OptionParser.parse(
 198         rest,
 199         strict: [
 200           admin: :boolean,
 201           confirmed: :boolean,
 202           locked: :boolean,
 203           moderator: :boolean
 204         ]
 205       )
 206
 207     with %User{local: true} = user <- User.get_cached_by_nickname(nickname) do
 208       user =
 209         case Keyword.get(options, :admin) do
 210           nil -> user
 211           value -> set_admin(user, value)
 212         end
 213
 214       user =
 215         case Keyword.get(options, :confirmed) do
 216           nil -> user
 217           value -> set_confirmation(user, value)
 218         end
 219
 220       user =
 221         case Keyword.get(options, :locked) do
 222           nil -> user
 223           value -> set_locked(user, value)
 224         end
 225
 226       _user =
 227         case Keyword.get(options, :moderator) do
 228           nil -> user
 229           value -> set_moderator(user, value)
 230         end
 231     else
 232       _ ->
 233         shell_error("No local user #{nickname}")
 234     end
 235   end
 236
 237   def run(["tag", nickname | tags]) do
 238     start_pleroma()
 239
 240     with %User{} = user <- User.get_cached_by_nickname(nickname) do
 241       user = user |> User.tag(tags)
 242
 243       shell_info("Tags of #{user.nickname}: #{inspect(user.tags)}")
 244     else
 245       _ ->
 246         shell_error("Could not change user tags for #{nickname}")
 247     end
 248   end
 249
 250   def run(["untag", nickname | tags]) do
 251     start_pleroma()
 252
 253     with %User{} = user <- User.get_cached_by_nickname(nickname) do
 254       user = user |> User.untag(tags)
 255
 256       shell_info("Tags of #{user.nickname}: #{inspect(user.tags)}")
 257     else
 258       _ ->
 259         shell_error("Could not change user tags for #{nickname}")
 260     end
 261   end
 262
 263   def run(["refetch_public_keys"]) do
 264     start_pleroma()
 265
 266     Pleroma.User.Query.build(%{
 267       external: true,
 268       is_active: true
 269     })
 270     |> refetch_public_keys()
 271   end
 272
 273   def run(["refetch_public_keys" | rest]) do
 274     start_pleroma()
 275
 276     Pleroma.User.Query.build(%{
 277       ap_id: rest
 278     })
 279     |> refetch_public_keys()
 280   end
 281
 282   def run(["invite" | rest]) do
 283     {options, [], []} =
 284       OptionParser.parse(rest,
 285         strict: [
 286           expires_at: :string,
 287           max_use: :integer
 288         ]
 289       )
 290
 291     options =
 292       options
 293       |> Keyword.update(:expires_at, {:ok, nil}, fn
 294         nil -> {:ok, nil}
 295         val -> Date.from_iso8601(val)
 296       end)
 297       |> Enum.into(%{})
 298
 299     start_pleroma()
 300
 301     with {:ok, val} <- options[:expires_at],
 302          options = Map.put(options, :expires_at, val),
 303          {:ok, invite} <- UserInviteToken.create_invite(options) do
 304       shell_info("Generated user invite token " <> String.replace(invite.invite_type, "_", " "))
 305
 306       url =
 307         Pleroma.Web.Router.Helpers.redirect_url(
 308           Pleroma.Web.Endpoint,
 309           :registration_page,
 310           invite.token
 311         )
 312
 313       IO.puts(url)
 314     else
 315       error ->
 316         shell_error("Could not create invite token: #{inspect(error)}")
 317     end
 318   end
 319
 320   def run(["invites"]) do
 321     start_pleroma()
 322
 323     shell_info("Invites list:")
 324
 325     UserInviteToken.list_invites()
 326     |> Enum.each(fn invite ->
 327       expire_info =
 328         with expires_at when not is_nil(expires_at) <- invite.expires_at do
 329           " | Expires at: #{Date.to_string(expires_at)}"
 330         end
 331
 332       using_info =
 333         with max_use when not is_nil(max_use) <- invite.max_use do
 334           " | Max use: #{max_use}    Left use: #{max_use - invite.uses}"
 335         end
 336
 337       shell_info(
 338         "ID: #{invite.id} | Token: #{invite.token} | Token type: #{invite.invite_type} | Used: #{invite.used}#{expire_info}#{using_info}"
 339       )
 340     end)
 341   end
 342
 343   def run(["revoke_invite", token]) do
 344     start_pleroma()
 345
 346     with {:ok, invite} <- UserInviteToken.find_by_token(token),
 347          {:ok, _} <- UserInviteToken.update_invite(invite, %{used: true}) do
 348       shell_info("Invite for token #{token} was revoked.")
 349     else
 350       _ -> shell_error("No invite found with token #{token}")
 351     end
 352   end
 353
 354   def run(["delete_activities", nickname]) do
 355     start_pleroma()
 356
 357     with %User{local: true} = user <- User.get_cached_by_nickname(nickname) do
 358       User.delete_user_activities(user)
 359       shell_info("User #{nickname} statuses deleted.")
 360     else
 361       _ ->
 362         shell_error("No local user #{nickname}")
 363     end
 364   end
 365
 366   def run(["change_email", nickname, email]) do
 367     start_pleroma()
 368
 369     with %User{} = user <- User.get_cached_by_nickname(nickname) do
 370       user
 371       |> User.update_changeset(%{"email" => email})
 372       |> User.update_and_set_cache()
 373
 374       shell_info("#{nickname}'s email updated")
 375     end
 376   end
 377
 378   def run(["show", nickname]) do
 379     start_pleroma()
 380
 381     user =
 382       nickname
 383       |> User.get_cached_by_nickname()
 384
 385     shell_info("#{inspect(user)}")
 386   end
 387
 388   def run(["send_confirmation", nickname]) do
 389     start_pleroma()
 390
 391     with %User{} = user <- User.get_cached_by_nickname(nickname) do
 392       user
 393       |> Pleroma.Emails.UserEmail.account_confirmation_email()
 394       |> Pleroma.Emails.Mailer.deliver!()
 395
 396       shell_info("#{nickname}'s email sent")
 397     end
 398   end
 399
 400   def run(["confirm", nickname]) do
 401     start_pleroma()
 402
 403     with %User{} = user <- User.get_cached_by_nickname(nickname) do
 404       {:ok, user} = User.confirm(user)
 405
 406       message = if !user.is_confirmed, do: "needs", else: "doesn't need"
 407
 408       shell_info("#{nickname} #{message} confirmation.")
 409     else
 410       _ ->
 411         shell_error("No local user #{nickname}")
 412     end
 413   end
 414
 415   def run(["confirm_all"]) do
 416     start_pleroma()
 417
 418     Pleroma.User.Query.build(%{
 419       local: true,
 420       is_active: true,
 421       is_moderator: false,
 422       is_admin: false,
 423       invisible: false
 424     })
 425     |> Pleroma.Repo.chunk_stream(500, :batches)
 426     |> Stream.each(fn users ->
 427       users
 428       |> Enum.each(fn user -> User.set_confirmation(user, true) end)
 429     end)
 430     |> Stream.run()
 431   end
 432
 433   def run(["unconfirm_all"]) do
 434     start_pleroma()
 435
 436     Pleroma.User.Query.build(%{
 437       local: true,
 438       is_active: true,
 439       is_moderator: false,
 440       is_admin: false,
 441       invisible: false
 442     })
 443     |> Pleroma.Repo.chunk_stream(500, :batches)
 444     |> Stream.each(fn users ->
 445       users
 446       |> Enum.each(fn user -> User.set_confirmation(user, false) end)
 447     end)
 448     |> Stream.run()
 449   end
 450
 451   def run(["sign_out", nickname]) do
 452     start_pleroma()
 453
 454     with %User{local: true} = user <- User.get_cached_by_nickname(nickname) do
 455       User.global_sign_out(user)
 456
 457       shell_info("#{nickname} signed out from all apps.")
 458     else
 459       _ ->
 460         shell_error("No local user #{nickname}")
 461     end
 462   end
 463
 464   def run(["blocking", nickname]) do
 465     start_pleroma()
 466
 467     with %User{local: true} = user <- User.get_cached_by_nickname(nickname) do
 468       blocks = User.following_ap_ids(user)
 469       IO.puts("#{inspect(blocks)}")
 470     end
 471   end
 472
 473   def run(["timeline_query", nickname]) do
 474     start_pleroma()
 475
 476     params = %{local: true}
 477
 478     with %User{local: true} = user <- User.get_cached_by_nickname(nickname) do
 479       followed_hashtags =
 480         user
 481         |> User.followed_hashtags()
 482         |> Enum.map(& &1.id)
 483
 484       params =
 485         params
 486         |> Map.put(:type, ["Create", "Announce"])
 487         |> Map.put(:limit, 20)
 488         |> Map.put(:blocking_user, user)
 489         |> Map.put(:muting_user, user)
 490         |> Map.put(:reply_filtering_user, user)
 491         |> Map.put(:announce_filtering_user, user)
 492         |> Map.put(:user, user)
 493         |> Map.put(:local_only, params[:local])
 494         |> Map.put(:hashtags, followed_hashtags)
 495         |> Map.delete(:local)
 496
 497       _activities =
 498         [user.ap_id | User.following(user)]
 499         |> ActivityPub.fetch_activities(params)
 500     end
 501   end
 502
 503   def run(["list"]) do
 504     start_pleroma()
 505
 506     Pleroma.User.Query.build(%{local: true})
 507     |> Pleroma.Repo.chunk_stream(500, :batches)
 508     |> Stream.each(fn users ->
 509       users
 510       |> Enum.each(fn user ->
 511         shell_info(
 512           "#{user.nickname} moderator: #{user.is_moderator}, admin: #{user.is_admin}, locked: #{user.is_locked}, is_active: #{user.is_active}"
 513         )
 514       end)
 515     end)
 516     |> Stream.run()
 517   end
 518
 519   def run(["fix_follow_state", local_user, remote_user]) do
 520     start_pleroma()
 521
 522     with {:local, %User{} = local} <- {:local, User.get_by_nickname(local_user)},
 523          {:remote, %User{} = remote} <- {:remote, User.get_by_nickname(remote_user)},
 524          {:follow_data, %{data: %{"state" => request_state}}} <-
 525            {:follow_data, Pleroma.Web.ActivityPub.Utils.fetch_latest_follow(local, remote)} do
 526       calculated_state = User.following?(local, remote)
 527
 528       IO.puts(
 529         "Request state is #{request_state}, vs calculated state of following=#{calculated_state}"
 530       )
 531
 532       if calculated_state == false && request_state == "accept" do
 533         IO.puts("Discrepancy found, fixing")
 534         Pleroma.Web.CommonAPI.reject_follow_request(local, remote)
 535         shell_info("Relationship fixed")
 536       else
 537         shell_info("No discrepancy found")
 538       end
 539     else
 540       {:local, _} ->
 541         shell_error("No local user #{local_user}")
 542
 543       {:remote, _} ->
 544         shell_error("No remote user #{remote_user}")
 545
 546       {:follow_data, _} ->
 547         shell_error("No follow data for #{local_user} and #{remote_user}")
 548     end
 549   end
 550
 551   def run(["convert_id", id]) do
 552     {:ok, uuid} = FlakeId.Ecto.Type.dump(id)
 553     {:ok, raw_id} = Ecto.UUID.load(uuid)
 554     shell_info(raw_id)
 555   end
 556
 557   defp refetch_public_keys(query) do
 558     query
 559     |> Pleroma.Repo.chunk_stream(50, :batches)
 560     |> Stream.each(fn users ->
 561       users
 562       |> Enum.each(fn user ->
 563         IO.puts("Re-Resolving: #{user.ap_id}")
 564
 565         with {:ok, user} <- Pleroma.User.fetch_by_ap_id(user.ap_id),
 566              changeset <- Pleroma.User.update_changeset(user),
 567              {:ok, _user} <- Pleroma.User.update_and_set_cache(changeset) do
 568           :ok
 569         else
 570           error -> IO.puts("Could not resolve: #{user.ap_id}, #{inspect(error)}")
 571         end
 572       end)
 573     end)
 574     |> Stream.run()
 575   end
 576
 577   defp set_moderator(user, value) do
 578     {:ok, user} =
 579       user
 580       |> Changeset.change(%{is_moderator: value})
 581       |> User.update_and_set_cache()
 582
 583     shell_info("Moderator status of #{user.nickname}: #{user.is_moderator}")
 584     user
 585   end
 586
 587   defp set_admin(user, value) do
 588     {:ok, user} = User.admin_api_update(user, %{is_admin: value})
 589
 590     shell_info("Admin status of #{user.nickname}: #{user.is_admin}")
 591     user
 592   end
 593
 594   defp set_locked(user, value) do
 595     {:ok, user} =
 596       user
 597       |> Changeset.change(%{is_locked: value})
 598       |> User.update_and_set_cache()
 599
 600     shell_info("Locked status of #{user.nickname}: #{user.is_locked}")
 601     user
 602   end
 603
 604   defp set_confirmation(user, value) do
 605     {:ok, user} = User.set_confirmation(user, value)
 606
 607     shell_info("Confirmation status of #{user.nickname}: #{user.is_confirmed}")
 608     user
 609   end
 610 end