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

   1 # Pleroma: A lightweight social networking server
   2 # Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
   3 # SPDX-License-Identifier: AGPL-3.0-only
   4
   5 defmodule Pleroma.User do
   6   use Ecto.Schema
   7
   8   import Ecto.Changeset
   9   import Ecto.Query
  10   import Ecto, only: [assoc: 2]
  11
  12   alias Ecto.Multi
  13   alias Pleroma.Activity
  14   alias Pleroma.Config
  15   alias Pleroma.Conversation.Participation
  16   alias Pleroma.Delivery
  17   alias Pleroma.EctoType.ActivityPub.ObjectValidators
  18   alias Pleroma.Emoji
  19   alias Pleroma.FollowingRelationship
  20   alias Pleroma.Formatter
  21   alias Pleroma.HTML
  22   alias Pleroma.Keys
  23   alias Pleroma.MFA
  24   alias Pleroma.Notification
  25   alias Pleroma.Object
  26   alias Pleroma.Registration
  27   alias Pleroma.Repo
  28   alias Pleroma.User
  29   alias Pleroma.UserRelationship
  30   alias Pleroma.Web
  31   alias Pleroma.Web.ActivityPub.ActivityPub
  32   alias Pleroma.Web.ActivityPub.Builder
  33   alias Pleroma.Web.ActivityPub.Pipeline
  34   alias Pleroma.Web.ActivityPub.Utils
  35   alias Pleroma.Web.CommonAPI
  36   alias Pleroma.Web.CommonAPI.Utils, as: CommonUtils
  37   alias Pleroma.Web.OAuth
  38   alias Pleroma.Web.RelMe
  39   alias Pleroma.Workers.BackgroundWorker
  40
  41   require Logger
  42
  43   @type t :: %__MODULE__{}
  44   @type account_status ::
  45           :active
  46           | :deactivated
  47           | :password_reset_pending
  48           | :confirmation_pending
  49           | :approval_pending
  50   @primary_key {:id, FlakeId.Ecto.CompatType, autogenerate: true}
  51
  52   # credo:disable-for-next-line Credo.Check.Readability.MaxLineLength
  53   @email_regex ~r/^[a-zA-Z0-9.!#$%&'*+\/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/
  54
  55   @strict_local_nickname_regex ~r/^[a-zA-Z\d]+$/
  56   @extended_local_nickname_regex ~r/^[a-zA-Z\d_-]+$/
  57
  58   # AP ID user relationships (blocks, mutes etc.)
  59   # Format: [rel_type: [outgoing_rel: :outgoing_rel_target, incoming_rel: :incoming_rel_source]]
  60   @user_relationships_config [
  61     block: [
  62       blocker_blocks: :blocked_users,
  63       blockee_blocks: :blocker_users
  64     ],
  65     mute: [
  66       muter_mutes: :muted_users,
  67       mutee_mutes: :muter_users
  68     ],
  69     reblog_mute: [
  70       reblog_muter_mutes: :reblog_muted_users,
  71       reblog_mutee_mutes: :reblog_muter_users
  72     ],
  73     notification_mute: [
  74       notification_muter_mutes: :notification_muted_users,
  75       notification_mutee_mutes: :notification_muter_users
  76     ],
  77     # Note: `inverse_subscription` relationship is inverse: subscriber acts as relationship target
  78     inverse_subscription: [
  79       subscribee_subscriptions: :subscriber_users,
  80       subscriber_subscriptions: :subscribee_users
  81     ]
  82   ]
  83
  84   schema "users" do
  85     field(:bio, :string, default: "")
  86     field(:raw_bio, :string)
  87     field(:email, :string)
  88     field(:name, :string)
  89     field(:nickname, :string)
  90     field(:password_hash, :string)
  91     field(:password, :string, virtual: true)
  92     field(:password_confirmation, :string, virtual: true)
  93     field(:keys, :string)
  94     field(:public_key, :string)
  95     field(:ap_id, :string)
  96     field(:avatar, :map, default: %{})
  97     field(:local, :boolean, default: true)
  98     field(:follower_address, :string)
  99     field(:following_address, :string)
 100     field(:search_rank, :float, virtual: true)
 101     field(:search_type, :integer, virtual: true)
 102     field(:tags, {:array, :string}, default: [])
 103     field(:last_refreshed_at, :naive_datetime_usec)
 104     field(:last_digest_emailed_at, :naive_datetime)
 105     field(:banner, :map, default: %{})
 106     field(:background, :map, default: %{})
 107     field(:note_count, :integer, default: 0)
 108     field(:follower_count, :integer, default: 0)
 109     field(:following_count, :integer, default: 0)
 110     field(:is_locked, :boolean, default: false)
 111     field(:confirmation_pending, :boolean, default: false)
 112     field(:password_reset_pending, :boolean, default: false)
 113     field(:approval_pending, :boolean, default: false)
 114     field(:registration_reason, :string, default: nil)
 115     field(:confirmation_token, :string, default: nil)
 116     field(:default_scope, :string, default: "public")
 117     field(:domain_blocks, {:array, :string}, default: [])
 118     field(:deactivated, :boolean, default: false)
 119     field(:no_rich_text, :boolean, default: false)
 120     field(:ap_enabled, :boolean, default: false)
 121     field(:is_moderator, :boolean, default: false)
 122     field(:is_admin, :boolean, default: false)
 123     field(:show_role, :boolean, default: true)
 124     field(:mastofe_settings, :map, default: nil)
 125     field(:uri, ObjectValidators.Uri, default: nil)
 126     field(:hide_followers_count, :boolean, default: false)
 127     field(:hide_follows_count, :boolean, default: false)
 128     field(:hide_followers, :boolean, default: false)
 129     field(:hide_follows, :boolean, default: false)
 130     field(:hide_favorites, :boolean, default: true)
 131     field(:pinned_activities, {:array, :string}, default: [])
 132     field(:email_notifications, :map, default: %{"digest" => false})
 133     field(:mascot, :map, default: nil)
 134     field(:emoji, :map, default: %{})
 135     field(:pleroma_settings_store, :map, default: %{})
 136     field(:fields, {:array, :map}, default: [])
 137     field(:raw_fields, {:array, :map}, default: [])
 138     field(:is_discoverable, :boolean, default: false)
 139     field(:invisible, :boolean, default: false)
 140     field(:allow_following_move, :boolean, default: true)
 141     field(:skip_thread_containment, :boolean, default: false)
 142     field(:actor_type, :string, default: "Person")
 143     field(:also_known_as, {:array, :string}, default: [])
 144     field(:inbox, :string)
 145     field(:shared_inbox, :string)
 146     field(:accepts_chat_messages, :boolean, default: nil)
 147
 148     embeds_one(
 149       :notification_settings,
 150       Pleroma.User.NotificationSetting,
 151       on_replace: :update
 152     )
 153
 154     has_many(:notifications, Notification)
 155     has_many(:registrations, Registration)
 156     has_many(:deliveries, Delivery)
 157
 158     has_many(:outgoing_relationships, UserRelationship, foreign_key: :source_id)
 159     has_many(:incoming_relationships, UserRelationship, foreign_key: :target_id)
 160
 161     for {relationship_type,
 162          [
 163            {outgoing_relation, outgoing_relation_target},
 164            {incoming_relation, incoming_relation_source}
 165          ]} <- @user_relationships_config do
 166       # Definitions of `has_many` relations: :blocker_blocks, :muter_mutes, :reblog_muter_mutes,
 167       #   :notification_muter_mutes, :subscribee_subscriptions
 168       has_many(outgoing_relation, UserRelationship,
 169         foreign_key: :source_id,
 170         where: [relationship_type: relationship_type]
 171       )
 172
 173       # Definitions of `has_many` relations: :blockee_blocks, :mutee_mutes, :reblog_mutee_mutes,
 174       #   :notification_mutee_mutes, :subscriber_subscriptions
 175       has_many(incoming_relation, UserRelationship,
 176         foreign_key: :target_id,
 177         where: [relationship_type: relationship_type]
 178       )
 179
 180       # Definitions of `has_many` relations: :blocked_users, :muted_users, :reblog_muted_users,
 181       #   :notification_muted_users, :subscriber_users
 182       has_many(outgoing_relation_target, through: [outgoing_relation, :target])
 183
 184       # Definitions of `has_many` relations: :blocker_users, :muter_users, :reblog_muter_users,
 185       #   :notification_muter_users, :subscribee_users
 186       has_many(incoming_relation_source, through: [incoming_relation, :source])
 187     end
 188
 189     # `:blocks` is deprecated (replaced with `blocked_users` relation)
 190     field(:blocks, {:array, :string}, default: [])
 191     # `:mutes` is deprecated (replaced with `muted_users` relation)
 192     field(:mutes, {:array, :string}, default: [])
 193     # `:muted_reblogs` is deprecated (replaced with `reblog_muted_users` relation)
 194     field(:muted_reblogs, {:array, :string}, default: [])
 195     # `:muted_notifications` is deprecated (replaced with `notification_muted_users` relation)
 196     field(:muted_notifications, {:array, :string}, default: [])
 197     # `:subscribers` is deprecated (replaced with `subscriber_users` relation)
 198     field(:subscribers, {:array, :string}, default: [])
 199
 200     embeds_one(
 201       :multi_factor_authentication_settings,
 202       MFA.Settings,
 203       on_replace: :delete
 204     )
 205
 206     timestamps()
 207   end
 208
 209   for {_relationship_type, [{_outgoing_relation, outgoing_relation_target}, _]} <-
 210         @user_relationships_config do
 211     # `def blocked_users_relation/2`, `def muted_users_relation/2`,
 212     #   `def reblog_muted_users_relation/2`, `def notification_muted_users/2`,
 213     #   `def subscriber_users/2`
 214     def unquote(:"#{outgoing_relation_target}_relation")(user, restrict_deactivated? \\ false) do
 215       target_users_query = assoc(user, unquote(outgoing_relation_target))
 216
 217       if restrict_deactivated? do
 218         restrict_deactivated(target_users_query)
 219       else
 220         target_users_query
 221       end
 222     end
 223
 224     # `def blocked_users/2`, `def muted_users/2`, `def reblog_muted_users/2`,
 225     #   `def notification_muted_users/2`, `def subscriber_users/2`
 226     def unquote(outgoing_relation_target)(user, restrict_deactivated? \\ false) do
 227       __MODULE__
 228       |> apply(unquote(:"#{outgoing_relation_target}_relation"), [
 229         user,
 230         restrict_deactivated?
 231       ])
 232       |> Repo.all()
 233     end
 234
 235     # `def blocked_users_ap_ids/2`, `def muted_users_ap_ids/2`, `def reblog_muted_users_ap_ids/2`,
 236     #   `def notification_muted_users_ap_ids/2`, `def subscriber_users_ap_ids/2`
 237     def unquote(:"#{outgoing_relation_target}_ap_ids")(user, restrict_deactivated? \\ false) do
 238       __MODULE__
 239       |> apply(unquote(:"#{outgoing_relation_target}_relation"), [
 240         user,
 241         restrict_deactivated?
 242       ])
 243       |> select([u], u.ap_id)
 244       |> Repo.all()
 245     end
 246   end
 247
 248   def cached_blocked_users_ap_ids(user) do
 249     Cachex.fetch!(:user_cache, "blocked_users_ap_ids:#{user.ap_id}", fn _ ->
 250       blocked_users_ap_ids(user)
 251     end)
 252   end
 253
 254   def cached_muted_users_ap_ids(user) do
 255     Cachex.fetch!(:user_cache, "muted_users_ap_ids:#{user.ap_id}", fn _ ->
 256       muted_users_ap_ids(user)
 257     end)
 258   end
 259
 260   defdelegate following_count(user), to: FollowingRelationship
 261   defdelegate following(user), to: FollowingRelationship
 262   defdelegate following?(follower, followed), to: FollowingRelationship
 263   defdelegate following_ap_ids(user), to: FollowingRelationship
 264   defdelegate get_follow_requests(user), to: FollowingRelationship
 265   defdelegate search(query, opts \\ []), to: User.Search
 266
 267   @doc """
 268   Dumps Flake Id to SQL-compatible format (16-byte UUID).
 269   E.g. "9pQtDGXuq4p3VlcJEm" -> <<0, 0, 1, 110, 179, 218, 42, 92, 213, 41, 44, 227, 95, 213, 0, 0>>
 270   """
 271   def binary_id(source_id) when is_binary(source_id) do
 272     with {:ok, dumped_id} <- FlakeId.Ecto.CompatType.dump(source_id) do
 273       dumped_id
 274     else
 275       _ -> source_id
 276     end
 277   end
 278
 279   def binary_id(source_ids) when is_list(source_ids) do
 280     Enum.map(source_ids, &binary_id/1)
 281   end
 282
 283   def binary_id(%User{} = user), do: binary_id(user.id)
 284
 285   @doc "Returns status account"
 286   @spec account_status(User.t()) :: account_status()
 287   def account_status(%User{deactivated: true}), do: :deactivated
 288   def account_status(%User{password_reset_pending: true}), do: :password_reset_pending
 289   def account_status(%User{local: true, approval_pending: true}), do: :approval_pending
 290
 291   def account_status(%User{local: true, confirmation_pending: true}) do
 292     if Config.get([:instance, :account_activation_required]) do
 293       :confirmation_pending
 294     else
 295       :active
 296     end
 297   end
 298
 299   def account_status(%User{}), do: :active
 300
 301   @spec visible_for(User.t(), User.t() | nil) ::
 302           :visible
 303           | :invisible
 304           | :restricted_unauthenticated
 305           | :deactivated
 306           | :confirmation_pending
 307   def visible_for(user, for_user \\ nil)
 308
 309   def visible_for(%User{invisible: true}, _), do: :invisible
 310
 311   def visible_for(%User{id: user_id}, %User{id: user_id}), do: :visible
 312
 313   def visible_for(%User{} = user, nil) do
 314     if restrict_unauthenticated?(user) do
 315       :restrict_unauthenticated
 316     else
 317       visible_account_status(user)
 318     end
 319   end
 320
 321   def visible_for(%User{} = user, for_user) do
 322     if superuser?(for_user) do
 323       :visible
 324     else
 325       visible_account_status(user)
 326     end
 327   end
 328
 329   def visible_for(_, _), do: :invisible
 330
 331   defp restrict_unauthenticated?(%User{local: true}) do
 332     Config.restrict_unauthenticated_access?(:profiles, :local)
 333   end
 334
 335   defp restrict_unauthenticated?(%User{local: _}) do
 336     Config.restrict_unauthenticated_access?(:profiles, :remote)
 337   end
 338
 339   defp visible_account_status(user) do
 340     status = account_status(user)
 341
 342     if status in [:active, :password_reset_pending] do
 343       :visible
 344     else
 345       status
 346     end
 347   end
 348
 349   @spec superuser?(User.t()) :: boolean()
 350   def superuser?(%User{local: true, is_admin: true}), do: true
 351   def superuser?(%User{local: true, is_moderator: true}), do: true
 352   def superuser?(_), do: false
 353
 354   @spec invisible?(User.t()) :: boolean()
 355   def invisible?(%User{invisible: true}), do: true
 356   def invisible?(_), do: false
 357
 358   def avatar_url(user, options \\ []) do
 359     case user.avatar do
 360       %{"url" => [%{"href" => href} | _]} ->
 361         href
 362
 363       _ ->
 364         unless options[:no_default] do
 365           Config.get([:assets, :default_user_avatar], "#{Web.base_url()}/images/avi.png")
 366         end
 367     end
 368   end
 369
 370   def banner_url(user, options \\ []) do
 371     case user.banner do
 372       %{"url" => [%{"href" => href} | _]} -> href
 373       _ -> !options[:no_default] && "#{Web.base_url()}/images/banner.png"
 374     end
 375   end
 376
 377   # Should probably be renamed or removed
 378   def ap_id(%User{nickname: nickname}), do: "#{Web.base_url()}/users/#{nickname}"
 379
 380   def ap_followers(%User{follower_address: fa}) when is_binary(fa), do: fa
 381   def ap_followers(%User{} = user), do: "#{ap_id(user)}/followers"
 382
 383   @spec ap_following(User.t()) :: String.t()
 384   def ap_following(%User{following_address: fa}) when is_binary(fa), do: fa
 385   def ap_following(%User{} = user), do: "#{ap_id(user)}/following"
 386
 387   @spec restrict_deactivated(Ecto.Query.t()) :: Ecto.Query.t()
 388   def restrict_deactivated(query) do
 389     from(u in query, where: u.deactivated != ^true)
 390   end
 391
 392   defp truncate_fields_param(params) do
 393     if Map.has_key?(params, :fields) do
 394       Map.put(params, :fields, Enum.map(params[:fields], &truncate_field/1))
 395     else
 396       params
 397     end
 398   end
 399
 400   defp truncate_if_exists(params, key, max_length) do
 401     if Map.has_key?(params, key) and is_binary(params[key]) do
 402       {value, _chopped} = String.split_at(params[key], max_length)
 403       Map.put(params, key, value)
 404     else
 405       params
 406     end
 407   end
 408
 409   defp fix_follower_address(%{follower_address: _, following_address: _} = params), do: params
 410
 411   defp fix_follower_address(%{nickname: nickname} = params),
 412     do: Map.put(params, :follower_address, ap_followers(%User{nickname: nickname}))
 413
 414   defp fix_follower_address(params), do: params
 415
 416   def remote_user_changeset(struct \\ %User{local: false}, params) do
 417     bio_limit = Config.get([:instance, :user_bio_length], 5000)
 418     name_limit = Config.get([:instance, :user_name_length], 100)
 419
 420     name =
 421       case params[:name] do
 422         name when is_binary(name) and byte_size(name) > 0 -> name
 423         _ -> params[:nickname]
 424       end
 425
 426     params =
 427       params
 428       |> Map.put(:name, name)
 429       |> Map.put_new(:last_refreshed_at, NaiveDateTime.utc_now())
 430       |> truncate_if_exists(:name, name_limit)
 431       |> truncate_if_exists(:bio, bio_limit)
 432       |> truncate_fields_param()
 433       |> fix_follower_address()
 434
 435     struct
 436     |> cast(
 437       params,
 438       [
 439         :bio,
 440         :emoji,
 441         :ap_id,
 442         :inbox,
 443         :shared_inbox,
 444         :nickname,
 445         :public_key,
 446         :avatar,
 447         :ap_enabled,
 448         :banner,
 449         :is_locked,
 450         :last_refreshed_at,
 451         :uri,
 452         :follower_address,
 453         :following_address,
 454         :hide_followers,
 455         :hide_follows,
 456         :hide_followers_count,
 457         :hide_follows_count,
 458         :follower_count,
 459         :fields,
 460         :following_count,
 461         :is_discoverable,
 462         :invisible,
 463         :actor_type,
 464         :also_known_as,
 465         :accepts_chat_messages
 466       ]
 467     )
 468     |> cast(params, [:name], empty_values: [])
 469     |> validate_required([:ap_id])
 470     |> validate_required([:name], trim: false)
 471     |> unique_constraint(:nickname)
 472     |> validate_format(:nickname, @email_regex)
 473     |> validate_length(:bio, max: bio_limit)
 474     |> validate_length(:name, max: name_limit)
 475     |> validate_fields(true)
 476   end
 477
 478   def update_changeset(struct, params \\ %{}) do
 479     bio_limit = Config.get([:instance, :user_bio_length], 5000)
 480     name_limit = Config.get([:instance, :user_name_length], 100)
 481
 482     struct
 483     |> cast(
 484       params,
 485       [
 486         :bio,
 487         :raw_bio,
 488         :name,
 489         :emoji,
 490         :avatar,
 491         :public_key,
 492         :inbox,
 493         :shared_inbox,
 494         :is_locked,
 495         :no_rich_text,
 496         :default_scope,
 497         :banner,
 498         :hide_follows,
 499         :hide_followers,
 500         :hide_followers_count,
 501         :hide_follows_count,
 502         :hide_favorites,
 503         :allow_following_move,
 504         :background,
 505         :show_role,
 506         :skip_thread_containment,
 507         :fields,
 508         :raw_fields,
 509         :pleroma_settings_store,
 510         :is_discoverable,
 511         :actor_type,
 512         :also_known_as,
 513         :accepts_chat_messages
 514       ]
 515     )
 516     |> unique_constraint(:nickname)
 517     |> validate_format(:nickname, local_nickname_regex())
 518     |> validate_length(:bio, max: bio_limit)
 519     |> validate_length(:name, min: 1, max: name_limit)
 520     |> validate_inclusion(:actor_type, ["Person", "Service"])
 521     |> put_fields()
 522     |> put_emoji()
 523     |> put_change_if_present(:bio, &{:ok, parse_bio(&1, struct)})
 524     |> put_change_if_present(:avatar, &put_upload(&1, :avatar))
 525     |> put_change_if_present(:banner, &put_upload(&1, :banner))
 526     |> put_change_if_present(:background, &put_upload(&1, :background))
 527     |> put_change_if_present(
 528       :pleroma_settings_store,
 529       &{:ok, Map.merge(struct.pleroma_settings_store, &1)}
 530     )
 531     |> validate_fields(false)
 532   end
 533
 534   defp put_fields(changeset) do
 535     if raw_fields = get_change(changeset, :raw_fields) do
 536       raw_fields =
 537         raw_fields
 538         |> Enum.filter(fn %{"name" => n} -> n != "" end)
 539
 540       fields =
 541         raw_fields
 542         |> Enum.map(fn f -> Map.update!(f, "value", &parse_fields(&1)) end)
 543
 544       changeset
 545       |> put_change(:raw_fields, raw_fields)
 546       |> put_change(:fields, fields)
 547     else
 548       changeset
 549     end
 550   end
 551
 552   defp parse_fields(value) do
 553     value
 554     |> Formatter.linkify(mentions_format: :full)
 555     |> elem(0)
 556   end
 557
 558   defp put_emoji(changeset) do
 559     emojified_fields = [:bio, :name, :raw_fields]
 560
 561     if Enum.any?(changeset.changes, fn {k, _} -> k in emojified_fields end) do
 562       bio = Emoji.Formatter.get_emoji_map(get_field(changeset, :bio))
 563       name = Emoji.Formatter.get_emoji_map(get_field(changeset, :name))
 564
 565       emoji = Map.merge(bio, name)
 566
 567       emoji =
 568         changeset
 569         |> get_field(:raw_fields)
 570         |> Enum.reduce(emoji, fn x, acc ->
 571           Map.merge(acc, Emoji.Formatter.get_emoji_map(x["name"] <> x["value"]))
 572         end)
 573
 574       put_change(changeset, :emoji, emoji)
 575     else
 576       changeset
 577     end
 578   end
 579
 580   defp put_change_if_present(changeset, map_field, value_function) do
 581     with {:ok, value} <- fetch_change(changeset, map_field),
 582          {:ok, new_value} <- value_function.(value) do
 583       put_change(changeset, map_field, new_value)
 584     else
 585       _ -> changeset
 586     end
 587   end
 588
 589   defp put_upload(value, type) do
 590     with %Plug.Upload{} <- value,
 591          {:ok, object} <- ActivityPub.upload(value, type: type) do
 592       {:ok, object.data}
 593     end
 594   end
 595
 596   def update_as_admin_changeset(struct, params) do
 597     struct
 598     |> update_changeset(params)
 599     |> cast(params, [:email])
 600     |> delete_change(:also_known_as)
 601     |> unique_constraint(:email)
 602     |> validate_format(:email, @email_regex)
 603     |> validate_inclusion(:actor_type, ["Person", "Service"])
 604   end
 605
 606   @spec update_as_admin(User.t(), map()) :: {:ok, User.t()} | {:error, Changeset.t()}
 607   def update_as_admin(user, params) do
 608     params = Map.put(params, "password_confirmation", params["password"])
 609     changeset = update_as_admin_changeset(user, params)
 610
 611     if params["password"] do
 612       reset_password(user, changeset, params)
 613     else
 614       User.update_and_set_cache(changeset)
 615     end
 616   end
 617
 618   def password_update_changeset(struct, params) do
 619     struct
 620     |> cast(params, [:password, :password_confirmation])
 621     |> validate_required([:password, :password_confirmation])
 622     |> validate_confirmation(:password)
 623     |> put_password_hash()
 624     |> put_change(:password_reset_pending, false)
 625   end
 626
 627   @spec reset_password(User.t(), map()) :: {:ok, User.t()} | {:error, Changeset.t()}
 628   def reset_password(%User{} = user, params) do
 629     reset_password(user, user, params)
 630   end
 631
 632   def reset_password(%User{id: user_id} = user, struct, params) do
 633     multi =
 634       Multi.new()
 635       |> Multi.update(:user, password_update_changeset(struct, params))
 636       |> Multi.delete_all(:tokens, OAuth.Token.Query.get_by_user(user_id))
 637       |> Multi.delete_all(:auth, OAuth.Authorization.delete_by_user_query(user))
 638
 639     case Repo.transaction(multi) do
 640       {:ok, %{user: user} = _} -> set_cache(user)
 641       {:error, _, changeset, _} -> {:error, changeset}
 642     end
 643   end
 644
 645   def update_password_reset_pending(user, value) do
 646     user
 647     |> change()
 648     |> put_change(:password_reset_pending, value)
 649     |> update_and_set_cache()
 650   end
 651
 652   def force_password_reset_async(user) do
 653     BackgroundWorker.enqueue("force_password_reset", %{"user_id" => user.id})
 654   end
 655
 656   @spec force_password_reset(User.t()) :: {:ok, User.t()} | {:error, Ecto.Changeset.t()}
 657   def force_password_reset(user), do: update_password_reset_pending(user, true)
 658
 659   # Used to auto-register LDAP accounts which won't have a password hash stored locally
 660   def register_changeset_ldap(struct, params = %{password: password})
 661       when is_nil(password) do
 662     params = Map.put_new(params, :accepts_chat_messages, true)
 663
 664     params =
 665       if Map.has_key?(params, :email) do
 666         Map.put_new(params, :email, params[:email])
 667       else
 668         params
 669       end
 670
 671     struct
 672     |> cast(params, [
 673       :name,
 674       :nickname,
 675       :email,
 676       :accepts_chat_messages
 677     ])
 678     |> validate_required([:name, :nickname])
 679     |> unique_constraint(:nickname)
 680     |> validate_exclusion(:nickname, Config.get([User, :restricted_nicknames]))
 681     |> validate_format(:nickname, local_nickname_regex())
 682     |> put_ap_id()
 683     |> unique_constraint(:ap_id)
 684     |> put_following_and_follower_address()
 685   end
 686
 687   def register_changeset(struct, params \\ %{}, opts \\ []) do
 688     bio_limit = Config.get([:instance, :user_bio_length], 5000)
 689     name_limit = Config.get([:instance, :user_name_length], 100)
 690     reason_limit = Config.get([:instance, :registration_reason_length], 500)
 691     params = Map.put_new(params, :accepts_chat_messages, true)
 692
 693     need_confirmation? =
 694       if is_nil(opts[:need_confirmation]) do
 695         Config.get([:instance, :account_activation_required])
 696       else
 697         opts[:need_confirmation]
 698       end
 699
 700     need_approval? =
 701       if is_nil(opts[:need_approval]) do
 702         Config.get([:instance, :account_approval_required])
 703       else
 704         opts[:need_approval]
 705       end
 706
 707     struct
 708     |> confirmation_changeset(need_confirmation: need_confirmation?)
 709     |> approval_changeset(need_approval: need_approval?)
 710     |> cast(params, [
 711       :bio,
 712       :raw_bio,
 713       :email,
 714       :name,
 715       :nickname,
 716       :password,
 717       :password_confirmation,
 718       :emoji,
 719       :accepts_chat_messages,
 720       :registration_reason
 721     ])
 722     |> validate_required([:name, :nickname, :password, :password_confirmation])
 723     |> validate_confirmation(:password)
 724     |> unique_constraint(:email)
 725     |> validate_format(:email, @email_regex)
 726     |> validate_change(:email, fn :email, email ->
 727       valid? =
 728         Config.get([User, :email_blacklist])
 729         |> Enum.all?(fn blacklisted_domain ->
 730           !String.ends_with?(email, ["@" <> blacklisted_domain, "." <> blacklisted_domain])
 731         end)
 732
 733       if valid?, do: [], else: [email: "Invalid email"]
 734     end)
 735     |> unique_constraint(:nickname)
 736     |> validate_exclusion(:nickname, Config.get([User, :restricted_nicknames]))
 737     |> validate_format(:nickname, local_nickname_regex())
 738     |> validate_length(:bio, max: bio_limit)
 739     |> validate_length(:name, min: 1, max: name_limit)
 740     |> validate_length(:registration_reason, max: reason_limit)
 741     |> maybe_validate_required_email(opts[:external])
 742     |> put_password_hash
 743     |> put_ap_id()
 744     |> unique_constraint(:ap_id)
 745     |> put_following_and_follower_address()
 746   end
 747
 748   def maybe_validate_required_email(changeset, true), do: changeset
 749
 750   def maybe_validate_required_email(changeset, _) do
 751     if Config.get([:instance, :account_activation_required]) do
 752       validate_required(changeset, [:email])
 753     else
 754       changeset
 755     end
 756   end
 757
 758   defp put_ap_id(changeset) do
 759     ap_id = ap_id(%User{nickname: get_field(changeset, :nickname)})
 760     put_change(changeset, :ap_id, ap_id)
 761   end
 762
 763   defp put_following_and_follower_address(changeset) do
 764     followers = ap_followers(%User{nickname: get_field(changeset, :nickname)})
 765
 766     changeset
 767     |> put_change(:follower_address, followers)
 768   end
 769
 770   defp autofollow_users(user) do
 771     candidates = Config.get([:instance, :autofollowed_nicknames])
 772
 773     autofollowed_users =
 774       User.Query.build(%{nickname: candidates, local: true, deactivated: false})
 775       |> Repo.all()
 776
 777     follow_all(user, autofollowed_users)
 778   end
 779
 780   defp autofollowing_users(user) do
 781     candidates = Config.get([:instance, :autofollowing_nicknames])
 782
 783     User.Query.build(%{nickname: candidates, local: true, deactivated: false})
 784     |> Repo.all()
 785     |> Enum.each(&follow(&1, user, :follow_accept))
 786
 787     {:ok, :success}
 788   end
 789
 790   @doc "Inserts provided changeset, performs post-registration actions (confirmation email sending etc.)"
 791   def register(%Ecto.Changeset{} = changeset) do
 792     with {:ok, user} <- Repo.insert(changeset) do
 793       post_register_action(user)
 794     end
 795   end
 796
 797   def post_register_action(%User{} = user) do
 798     with {:ok, user} <- autofollow_users(user),
 799          {:ok, _} <- autofollowing_users(user),
 800          {:ok, user} <- set_cache(user),
 801          {:ok, _} <- send_welcome_email(user),
 802          {:ok, _} <- send_welcome_message(user),
 803          {:ok, _} <- send_welcome_chat_message(user),
 804          {:ok, _} <- try_send_confirmation_email(user) do
 805       {:ok, user}
 806     end
 807   end
 808
 809   def send_welcome_message(user) do
 810     if User.WelcomeMessage.enabled?() do
 811       User.WelcomeMessage.post_message(user)
 812       {:ok, :enqueued}
 813     else
 814       {:ok, :noop}
 815     end
 816   end
 817
 818   def send_welcome_chat_message(user) do
 819     if User.WelcomeChatMessage.enabled?() do
 820       User.WelcomeChatMessage.post_message(user)
 821       {:ok, :enqueued}
 822     else
 823       {:ok, :noop}
 824     end
 825   end
 826
 827   def send_welcome_email(%User{email: email} = user) when is_binary(email) do
 828     if User.WelcomeEmail.enabled?() do
 829       User.WelcomeEmail.send_email(user)
 830       {:ok, :enqueued}
 831     else
 832       {:ok, :noop}
 833     end
 834   end
 835
 836   def send_welcome_email(_), do: {:ok, :noop}
 837
 838   @spec try_send_confirmation_email(User.t()) :: {:ok, :enqueued | :noop}
 839   def try_send_confirmation_email(%User{confirmation_pending: true, email: email} = user)
 840       when is_binary(email) do
 841     if Config.get([:instance, :account_activation_required]) do
 842       send_confirmation_email(user)
 843       {:ok, :enqueued}
 844     else
 845       {:ok, :noop}
 846     end
 847   end
 848
 849   def try_send_confirmation_email(_), do: {:ok, :noop}
 850
 851   @spec send_confirmation_email(Uset.t()) :: User.t()
 852   def send_confirmation_email(%User{} = user) do
 853     user
 854     |> Pleroma.Emails.UserEmail.account_confirmation_email()
 855     |> Pleroma.Emails.Mailer.deliver_async()
 856
 857     user
 858   end
 859
 860   def needs_update?(%User{local: true}), do: false
 861
 862   def needs_update?(%User{local: false, last_refreshed_at: nil}), do: true
 863
 864   def needs_update?(%User{local: false} = user) do
 865     NaiveDateTime.diff(NaiveDateTime.utc_now(), user.last_refreshed_at) >= 86_400
 866   end
 867
 868   def needs_update?(_), do: true
 869
 870   @spec maybe_direct_follow(User.t(), User.t()) :: {:ok, User.t()} | {:error, String.t()}
 871
 872   # "Locked" (self-locked) users demand explicit authorization of follow requests
 873   def maybe_direct_follow(%User{} = follower, %User{local: true, is_locked: true} = followed) do
 874     follow(follower, followed, :follow_pending)
 875   end
 876
 877   def maybe_direct_follow(%User{} = follower, %User{local: true} = followed) do
 878     follow(follower, followed)
 879   end
 880
 881   def maybe_direct_follow(%User{} = follower, %User{} = followed) do
 882     if not ap_enabled?(followed) do
 883       follow(follower, followed)
 884     else
 885       {:ok, follower, followed}
 886     end
 887   end
 888
 889   @doc "A mass follow for local users. Respects blocks in both directions but does not create activities."
 890   @spec follow_all(User.t(), list(User.t())) :: {atom(), User.t()}
 891   def follow_all(follower, followeds) do
 892     followeds
 893     |> Enum.reject(fn followed -> blocks?(follower, followed) || blocks?(followed, follower) end)
 894     |> Enum.each(&follow(follower, &1, :follow_accept))
 895
 896     set_cache(follower)
 897   end
 898
 899   def follow(%User{} = follower, %User{} = followed, state \\ :follow_accept) do
 900     deny_follow_blocked = Config.get([:user, :deny_follow_blocked])
 901
 902     cond do
 903       followed.deactivated ->
 904         {:error, "Could not follow user: #{followed.nickname} is deactivated."}
 905
 906       deny_follow_blocked and blocks?(followed, follower) ->
 907         {:error, "Could not follow user: #{followed.nickname} blocked you."}
 908
 909       true ->
 910         FollowingRelationship.follow(follower, followed, state)
 911     end
 912   end
 913
 914   def unfollow(%User{ap_id: ap_id}, %User{ap_id: ap_id}) do
 915     {:error, "Not subscribed!"}
 916   end
 917
 918   @spec unfollow(User.t(), User.t()) :: {:ok, User.t(), Activity.t()} | {:error, String.t()}
 919   def unfollow(%User{} = follower, %User{} = followed) do
 920     case do_unfollow(follower, followed) do
 921       {:ok, follower, followed} ->
 922         {:ok, follower, Utils.fetch_latest_follow(follower, followed)}
 923
 924       error ->
 925         error
 926     end
 927   end
 928
 929   @spec do_unfollow(User.t(), User.t()) :: {:ok, User.t(), User.t()} | {:error, String.t()}
 930   defp do_unfollow(%User{} = follower, %User{} = followed) do
 931     case get_follow_state(follower, followed) do
 932       state when state in [:follow_pending, :follow_accept] ->
 933         FollowingRelationship.unfollow(follower, followed)
 934
 935       nil ->
 936         {:error, "Not subscribed!"}
 937     end
 938   end
 939
 940   @doc "Returns follow state as Pleroma.FollowingRelationship.State value"
 941   def get_follow_state(%User{} = follower, %User{} = following) do
 942     following_relationship = FollowingRelationship.get(follower, following)
 943     get_follow_state(follower, following, following_relationship)
 944   end
 945
 946   def get_follow_state(
 947         %User{} = follower,
 948         %User{} = following,
 949         following_relationship
 950       ) do
 951     case {following_relationship, following.local} do
 952       {nil, false} ->
 953         case Utils.fetch_latest_follow(follower, following) do
 954           %Activity{data: %{"state" => state}} when state in ["pending", "accept"] ->
 955             FollowingRelationship.state_to_enum(state)
 956
 957           _ ->
 958             nil
 959         end
 960
 961       {%{state: state}, _} ->
 962         state
 963
 964       {nil, _} ->
 965         nil
 966     end
 967   end
 968
 969   def locked?(%User{} = user) do
 970     user.is_locked || false
 971   end
 972
 973   def get_by_id(id) do
 974     Repo.get_by(User, id: id)
 975   end
 976
 977   def get_by_ap_id(ap_id) do
 978     Repo.get_by(User, ap_id: ap_id)
 979   end
 980
 981   def get_all_by_ap_id(ap_ids) do
 982     from(u in __MODULE__,
 983       where: u.ap_id in ^ap_ids
 984     )
 985     |> Repo.all()
 986   end
 987
 988   def get_all_by_ids(ids) do
 989     from(u in __MODULE__, where: u.id in ^ids)
 990     |> Repo.all()
 991   end
 992
 993   # This is mostly an SPC migration fix. This guesses the user nickname by taking the last part
 994   # of the ap_id and the domain and tries to get that user
 995   def get_by_guessed_nickname(ap_id) do
 996     domain = URI.parse(ap_id).host
 997     name = List.last(String.split(ap_id, "/"))
 998     nickname = "#{name}@#{domain}"
 999
1000     get_cached_by_nickname(nickname)
1001   end
1002
1003   def set_cache({:ok, user}), do: set_cache(user)
1004   def set_cache({:error, err}), do: {:error, err}
1005
1006   def set_cache(%User{} = user) do
1007     Cachex.put(:user_cache, "ap_id:#{user.ap_id}", user)
1008     Cachex.put(:user_cache, "nickname:#{user.nickname}", user)
1009     Cachex.put(:user_cache, "friends_ap_ids:#{user.nickname}", get_user_friends_ap_ids(user))
1010     {:ok, user}
1011   end
1012
1013   def update_and_set_cache(struct, params) do
1014     struct
1015     |> update_changeset(params)
1016     |> update_and_set_cache()
1017   end
1018
1019   def update_and_set_cache(changeset) do
1020     with {:ok, user} <- Repo.update(changeset, stale_error_field: :id) do
1021       set_cache(user)
1022     end
1023   end
1024
1025   def get_user_friends_ap_ids(user) do
1026     from(u in User.get_friends_query(user), select: u.ap_id)
1027     |> Repo.all()
1028   end
1029
1030   @spec get_cached_user_friends_ap_ids(User.t()) :: [String.t()]
1031   def get_cached_user_friends_ap_ids(user) do
1032     Cachex.fetch!(:user_cache, "friends_ap_ids:#{user.ap_id}", fn _ ->
1033       get_user_friends_ap_ids(user)
1034     end)
1035   end
1036
1037   def invalidate_cache(user) do
1038     Cachex.del(:user_cache, "ap_id:#{user.ap_id}")
1039     Cachex.del(:user_cache, "nickname:#{user.nickname}")
1040     Cachex.del(:user_cache, "friends_ap_ids:#{user.ap_id}")
1041     Cachex.del(:user_cache, "blocked_users_ap_ids:#{user.ap_id}")
1042     Cachex.del(:user_cache, "muted_users_ap_ids:#{user.ap_id}")
1043   end
1044
1045   @spec get_cached_by_ap_id(String.t()) :: User.t() | nil
1046   def get_cached_by_ap_id(ap_id) do
1047     key = "ap_id:#{ap_id}"
1048
1049     with {:ok, nil} <- Cachex.get(:user_cache, key),
1050          user when not is_nil(user) <- get_by_ap_id(ap_id),
1051          {:ok, true} <- Cachex.put(:user_cache, key, user) do
1052       user
1053     else
1054       {:ok, user} -> user
1055       nil -> nil
1056     end
1057   end
1058
1059   def get_cached_by_id(id) do
1060     key = "id:#{id}"
1061
1062     ap_id =
1063       Cachex.fetch!(:user_cache, key, fn _ ->
1064         user = get_by_id(id)
1065
1066         if user do
1067           Cachex.put(:user_cache, "ap_id:#{user.ap_id}", user)
1068           {:commit, user.ap_id}
1069         else
1070           {:ignore, ""}
1071         end
1072       end)
1073
1074     get_cached_by_ap_id(ap_id)
1075   end
1076
1077   def get_cached_by_nickname(nickname) do
1078     key = "nickname:#{nickname}"
1079
1080     Cachex.fetch!(:user_cache, key, fn ->
1081       case get_or_fetch_by_nickname(nickname) do
1082         {:ok, user} -> {:commit, user}
1083         {:error, _error} -> {:ignore, nil}
1084       end
1085     end)
1086   end
1087
1088   def get_cached_by_nickname_or_id(nickname_or_id, opts \\ []) do
1089     restrict_to_local = Config.get([:instance, :limit_to_local_content])
1090
1091     cond do
1092       is_integer(nickname_or_id) or FlakeId.flake_id?(nickname_or_id) ->
1093         get_cached_by_id(nickname_or_id) || get_cached_by_nickname(nickname_or_id)
1094
1095       restrict_to_local == false or not String.contains?(nickname_or_id, "@") ->
1096         get_cached_by_nickname(nickname_or_id)
1097
1098       restrict_to_local == :unauthenticated and match?(%User{}, opts[:for]) ->
1099         get_cached_by_nickname(nickname_or_id)
1100
1101       true ->
1102         nil
1103     end
1104   end
1105
1106   @spec get_by_nickname(String.t()) :: User.t() | nil
1107   def get_by_nickname(nickname) do
1108     Repo.get_by(User, nickname: nickname) ||
1109       if Regex.match?(~r(@#{Pleroma.Web.Endpoint.host()})i, nickname) do
1110         Repo.get_by(User, nickname: local_nickname(nickname))
1111       end
1112   end
1113
1114   def get_by_email(email), do: Repo.get_by(User, email: email)
1115
1116   def get_by_nickname_or_email(nickname_or_email) do
1117     get_by_nickname(nickname_or_email) || get_by_email(nickname_or_email)
1118   end
1119
1120   def fetch_by_nickname(nickname), do: ActivityPub.make_user_from_nickname(nickname)
1121
1122   def get_or_fetch_by_nickname(nickname) do
1123     with %User{} = user <- get_by_nickname(nickname) do
1124       {:ok, user}
1125     else
1126       _e ->
1127         with [_nick, _domain] <- String.split(nickname, "@"),
1128              {:ok, user} <- fetch_by_nickname(nickname) do
1129           {:ok, user}
1130         else
1131           _e -> {:error, "not found " <> nickname}
1132         end
1133     end
1134   end
1135
1136   @spec get_followers_query(User.t(), pos_integer() | nil) :: Ecto.Query.t()
1137   def get_followers_query(%User{} = user, nil) do
1138     User.Query.build(%{followers: user, deactivated: false})
1139   end
1140
1141   def get_followers_query(%User{} = user, page) do
1142     user
1143     |> get_followers_query(nil)
1144     |> User.Query.paginate(page, 20)
1145   end
1146
1147   @spec get_followers_query(User.t()) :: Ecto.Query.t()
1148   def get_followers_query(%User{} = user), do: get_followers_query(user, nil)
1149
1150   @spec get_followers(User.t(), pos_integer() | nil) :: {:ok, list(User.t())}
1151   def get_followers(%User{} = user, page \\ nil) do
1152     user
1153     |> get_followers_query(page)
1154     |> Repo.all()
1155   end
1156
1157   @spec get_external_followers(User.t(), pos_integer() | nil) :: {:ok, list(User.t())}
1158   def get_external_followers(%User{} = user, page \\ nil) do
1159     user
1160     |> get_followers_query(page)
1161     |> User.Query.build(%{external: true})
1162     |> Repo.all()
1163   end
1164
1165   def get_followers_ids(%User{} = user, page \\ nil) do
1166     user
1167     |> get_followers_query(page)
1168     |> select([u], u.id)
1169     |> Repo.all()
1170   end
1171
1172   @spec get_friends_query(User.t(), pos_integer() | nil) :: Ecto.Query.t()
1173   def get_friends_query(%User{} = user, nil) do
1174     User.Query.build(%{friends: user, deactivated: false})
1175   end
1176
1177   def get_friends_query(%User{} = user, page) do
1178     user
1179     |> get_friends_query(nil)
1180     |> User.Query.paginate(page, 20)
1181   end
1182
1183   @spec get_friends_query(User.t()) :: Ecto.Query.t()
1184   def get_friends_query(%User{} = user), do: get_friends_query(user, nil)
1185
1186   def get_friends(%User{} = user, page \\ nil) do
1187     user
1188     |> get_friends_query(page)
1189     |> Repo.all()
1190   end
1191
1192   def get_friends_ap_ids(%User{} = user) do
1193     user
1194     |> get_friends_query(nil)
1195     |> select([u], u.ap_id)
1196     |> Repo.all()
1197   end
1198
1199   def get_friends_ids(%User{} = user, page \\ nil) do
1200     user
1201     |> get_friends_query(page)
1202     |> select([u], u.id)
1203     |> Repo.all()
1204   end
1205
1206   def increase_note_count(%User{} = user) do
1207     User
1208     |> where(id: ^user.id)
1209     |> update([u], inc: [note_count: 1])
1210     |> select([u], u)
1211     |> Repo.update_all([])
1212     |> case do
1213       {1, [user]} -> set_cache(user)
1214       _ -> {:error, user}
1215     end
1216   end
1217
1218   def decrease_note_count(%User{} = user) do
1219     User
1220     |> where(id: ^user.id)
1221     |> update([u],
1222       set: [
1223         note_count: fragment("greatest(0, note_count - 1)")
1224       ]
1225     )
1226     |> select([u], u)
1227     |> Repo.update_all([])
1228     |> case do
1229       {1, [user]} -> set_cache(user)
1230       _ -> {:error, user}
1231     end
1232   end
1233
1234   def update_note_count(%User{} = user, note_count \\ nil) do
1235     note_count =
1236       note_count ||
1237         from(
1238           a in Object,
1239           where: fragment("?->>'actor' = ? and ?->>'type' = 'Note'", a.data, ^user.ap_id, a.data),
1240           select: count(a.id)
1241         )
1242         |> Repo.one()
1243
1244     user
1245     |> cast(%{note_count: note_count}, [:note_count])
1246     |> update_and_set_cache()
1247   end
1248
1249   @spec maybe_fetch_follow_information(User.t()) :: User.t()
1250   def maybe_fetch_follow_information(user) do
1251     with {:ok, user} <- fetch_follow_information(user) do
1252       user
1253     else
1254       e ->
1255         Logger.error("Follower/Following counter update for #{user.ap_id} failed.\n#{inspect(e)}")
1256
1257         user
1258     end
1259   end
1260
1261   def fetch_follow_information(user) do
1262     with {:ok, info} <- ActivityPub.fetch_follow_information_for_user(user) do
1263       user
1264       |> follow_information_changeset(info)
1265       |> update_and_set_cache()
1266     end
1267   end
1268
1269   defp follow_information_changeset(user, params) do
1270     user
1271     |> cast(params, [
1272       :hide_followers,
1273       :hide_follows,
1274       :follower_count,
1275       :following_count,
1276       :hide_followers_count,
1277       :hide_follows_count
1278     ])
1279   end
1280
1281   @spec update_follower_count(User.t()) :: {:ok, User.t()}
1282   def update_follower_count(%User{} = user) do
1283     if user.local or !Config.get([:instance, :external_user_synchronization]) do
1284       follower_count = FollowingRelationship.follower_count(user)
1285
1286       user
1287       |> follow_information_changeset(%{follower_count: follower_count})
1288       |> update_and_set_cache
1289     else
1290       {:ok, maybe_fetch_follow_information(user)}
1291     end
1292   end
1293
1294   @spec update_following_count(User.t()) :: {:ok, User.t()}
1295   def update_following_count(%User{local: false} = user) do
1296     if Config.get([:instance, :external_user_synchronization]) do
1297       {:ok, maybe_fetch_follow_information(user)}
1298     else
1299       {:ok, user}
1300     end
1301   end
1302
1303   def update_following_count(%User{local: true} = user) do
1304     following_count = FollowingRelationship.following_count(user)
1305
1306     user
1307     |> follow_information_changeset(%{following_count: following_count})
1308     |> update_and_set_cache()
1309   end
1310
1311   @spec get_users_from_set([String.t()], keyword()) :: [User.t()]
1312   def get_users_from_set(ap_ids, opts \\ []) do
1313     local_only = Keyword.get(opts, :local_only, true)
1314     criteria = %{ap_id: ap_ids, deactivated: false}
1315     criteria = if local_only, do: Map.put(criteria, :local, true), else: criteria
1316
1317     User.Query.build(criteria)
1318     |> Repo.all()
1319   end
1320
1321   @spec get_recipients_from_activity(Activity.t()) :: [User.t()]
1322   def get_recipients_from_activity(%Activity{recipients: to, actor: actor}) do
1323     to = [actor | to]
1324
1325     query = User.Query.build(%{recipients_from_activity: to, local: true, deactivated: false})
1326
1327     query
1328     |> Repo.all()
1329   end
1330
1331   @spec mute(User.t(), User.t(), map()) ::
1332           {:ok, list(UserRelationship.t())} | {:error, String.t()}
1333   def mute(%User{} = muter, %User{} = mutee, params \\ %{}) do
1334     notifications? = Map.get(params, :notifications, true)
1335     expires_in = Map.get(params, :expires_in, 0)
1336
1337     with {:ok, user_mute} <- UserRelationship.create_mute(muter, mutee),
1338          {:ok, user_notification_mute} <-
1339            (notifications? && UserRelationship.create_notification_mute(muter, mutee)) ||
1340              {:ok, nil} do
1341       if expires_in > 0 do
1342         Pleroma.Workers.MuteExpireWorker.enqueue(
1343           "unmute_user",
1344           %{"muter_id" => muter.id, "mutee_id" => mutee.id},
1345           schedule_in: expires_in
1346         )
1347       end
1348
1349       Cachex.del(:user_cache, "muted_users_ap_ids:#{muter.ap_id}")
1350
1351       {:ok, Enum.filter([user_mute, user_notification_mute], & &1)}
1352     end
1353   end
1354
1355   def unmute(%User{} = muter, %User{} = mutee) do
1356     with {:ok, user_mute} <- UserRelationship.delete_mute(muter, mutee),
1357          {:ok, user_notification_mute} <-
1358            UserRelationship.delete_notification_mute(muter, mutee) do
1359       Cachex.del(:user_cache, "muted_users_ap_ids:#{muter.ap_id}")
1360       {:ok, [user_mute, user_notification_mute]}
1361     end
1362   end
1363
1364   def unmute(muter_id, mutee_id) do
1365     with {:muter, %User{} = muter} <- {:muter, User.get_by_id(muter_id)},
1366          {:mutee, %User{} = mutee} <- {:mutee, User.get_by_id(mutee_id)} do
1367       unmute(muter, mutee)
1368     else
1369       {who, result} = error ->
1370         Logger.warn(
1371           "User.unmute/2 failed. #{who}: #{result}, muter_id: #{muter_id}, mutee_id: #{mutee_id}"
1372         )
1373
1374         {:error, error}
1375     end
1376   end
1377
1378   def subscribe(%User{} = subscriber, %User{} = target) do
1379     deny_follow_blocked = Config.get([:user, :deny_follow_blocked])
1380
1381     if blocks?(target, subscriber) and deny_follow_blocked do
1382       {:error, "Could not subscribe: #{target.nickname} is blocking you"}
1383     else
1384       # Note: the relationship is inverse: subscriber acts as relationship target
1385       UserRelationship.create_inverse_subscription(target, subscriber)
1386     end
1387   end
1388
1389   def subscribe(%User{} = subscriber, %{ap_id: ap_id}) do
1390     with %User{} = subscribee <- get_cached_by_ap_id(ap_id) do
1391       subscribe(subscriber, subscribee)
1392     end
1393   end
1394
1395   def unsubscribe(%User{} = unsubscriber, %User{} = target) do
1396     # Note: the relationship is inverse: subscriber acts as relationship target
1397     UserRelationship.delete_inverse_subscription(target, unsubscriber)
1398   end
1399
1400   def unsubscribe(%User{} = unsubscriber, %{ap_id: ap_id}) do
1401     with %User{} = user <- get_cached_by_ap_id(ap_id) do
1402       unsubscribe(unsubscriber, user)
1403     end
1404   end
1405
1406   def block(%User{} = blocker, %User{} = blocked) do
1407     # sever any follow relationships to prevent leaks per activitypub (Pleroma issue #213)
1408     blocker =
1409       if following?(blocker, blocked) do
1410         {:ok, blocker, _} = unfollow(blocker, blocked)
1411         blocker
1412       else
1413         blocker
1414       end
1415
1416     # clear any requested follows as well
1417     blocked =
1418       case CommonAPI.reject_follow_request(blocked, blocker) do
1419         {:ok, %User{} = updated_blocked} -> updated_blocked
1420         nil -> blocked
1421       end
1422
1423     unsubscribe(blocked, blocker)
1424
1425     unfollowing_blocked = Config.get([:activitypub, :unfollow_blocked], true)
1426     if unfollowing_blocked && following?(blocked, blocker), do: unfollow(blocked, blocker)
1427
1428     {:ok, blocker} = update_follower_count(blocker)
1429     {:ok, blocker, _} = Participation.mark_all_as_read(blocker, blocked)
1430     add_to_block(blocker, blocked)
1431   end
1432
1433   # helper to handle the block given only an actor's AP id
1434   def block(%User{} = blocker, %{ap_id: ap_id}) do
1435     block(blocker, get_cached_by_ap_id(ap_id))
1436   end
1437
1438   def unblock(%User{} = blocker, %User{} = blocked) do
1439     remove_from_block(blocker, blocked)
1440   end
1441
1442   # helper to handle the block given only an actor's AP id
1443   def unblock(%User{} = blocker, %{ap_id: ap_id}) do
1444     unblock(blocker, get_cached_by_ap_id(ap_id))
1445   end
1446
1447   def mutes?(nil, _), do: false
1448   def mutes?(%User{} = user, %User{} = target), do: mutes_user?(user, target)
1449
1450   def mutes_user?(%User{} = user, %User{} = target) do
1451     UserRelationship.mute_exists?(user, target)
1452   end
1453
1454   @spec muted_notifications?(User.t() | nil, User.t() | map()) :: boolean()
1455   def muted_notifications?(nil, _), do: false
1456
1457   def muted_notifications?(%User{} = user, %User{} = target),
1458     do: UserRelationship.notification_mute_exists?(user, target)
1459
1460   def blocks?(nil, _), do: false
1461
1462   def blocks?(%User{} = user, %User{} = target) do
1463     blocks_user?(user, target) ||
1464       (blocks_domain?(user, target) and not User.following?(user, target))
1465   end
1466
1467   def blocks_user?(%User{} = user, %User{} = target) do
1468     UserRelationship.block_exists?(user, target)
1469   end
1470
1471   def blocks_user?(_, _), do: false
1472
1473   def blocks_domain?(%User{} = user, %User{} = target) do
1474     domain_blocks = Pleroma.Web.ActivityPub.MRF.subdomains_regex(user.domain_blocks)
1475     %{host: host} = URI.parse(target.ap_id)
1476     Pleroma.Web.ActivityPub.MRF.subdomain_match?(domain_blocks, host)
1477   end
1478
1479   def blocks_domain?(_, _), do: false
1480
1481   def subscribed_to?(%User{} = user, %User{} = target) do
1482     # Note: the relationship is inverse: subscriber acts as relationship target
1483     UserRelationship.inverse_subscription_exists?(target, user)
1484   end
1485
1486   def subscribed_to?(%User{} = user, %{ap_id: ap_id}) do
1487     with %User{} = target <- get_cached_by_ap_id(ap_id) do
1488       subscribed_to?(user, target)
1489     end
1490   end
1491
1492   @doc """
1493   Returns map of outgoing (blocked, muted etc.) relationships' user AP IDs by relation type.
1494   E.g. `outgoing_relationships_ap_ids(user, [:block])` -> `%{block: ["https://some.site/users/userapid"]}`
1495   """
1496   @spec outgoing_relationships_ap_ids(User.t(), list(atom())) :: %{atom() => list(String.t())}
1497   def outgoing_relationships_ap_ids(_user, []), do: %{}
1498
1499   def outgoing_relationships_ap_ids(nil, _relationship_types), do: %{}
1500
1501   def outgoing_relationships_ap_ids(%User{} = user, relationship_types)
1502       when is_list(relationship_types) do
1503     db_result =
1504       user
1505       |> assoc(:outgoing_relationships)
1506       |> join(:inner, [user_rel], u in assoc(user_rel, :target))
1507       |> where([user_rel, u], user_rel.relationship_type in ^relationship_types)
1508       |> select([user_rel, u], [user_rel.relationship_type, fragment("array_agg(?)", u.ap_id)])
1509       |> group_by([user_rel, u], user_rel.relationship_type)
1510       |> Repo.all()
1511       |> Enum.into(%{}, fn [k, v] -> {k, v} end)
1512
1513     Enum.into(
1514       relationship_types,
1515       %{},
1516       fn rel_type -> {rel_type, db_result[rel_type] || []} end
1517     )
1518   end
1519
1520   def incoming_relationships_ungrouped_ap_ids(user, relationship_types, ap_ids \\ nil)
1521
1522   def incoming_relationships_ungrouped_ap_ids(_user, [], _ap_ids), do: []
1523
1524   def incoming_relationships_ungrouped_ap_ids(nil, _relationship_types, _ap_ids), do: []
1525
1526   def incoming_relationships_ungrouped_ap_ids(%User{} = user, relationship_types, ap_ids)
1527       when is_list(relationship_types) do
1528     user
1529     |> assoc(:incoming_relationships)
1530     |> join(:inner, [user_rel], u in assoc(user_rel, :source))
1531     |> where([user_rel, u], user_rel.relationship_type in ^relationship_types)
1532     |> maybe_filter_on_ap_id(ap_ids)
1533     |> select([user_rel, u], u.ap_id)
1534     |> distinct(true)
1535     |> Repo.all()
1536   end
1537
1538   defp maybe_filter_on_ap_id(query, ap_ids) when is_list(ap_ids) do
1539     where(query, [user_rel, u], u.ap_id in ^ap_ids)
1540   end
1541
1542   defp maybe_filter_on_ap_id(query, _ap_ids), do: query
1543
1544   def deactivate_async(user, status \\ true) do
1545     BackgroundWorker.enqueue("deactivate_user", %{"user_id" => user.id, "status" => status})
1546   end
1547
1548   def deactivate(user, status \\ true)
1549
1550   def deactivate(users, status) when is_list(users) do
1551     Repo.transaction(fn ->
1552       for user <- users, do: deactivate(user, status)
1553     end)
1554   end
1555
1556   def deactivate(%User{} = user, status) do
1557     with {:ok, user} <- set_activation_status(user, status) do
1558       user
1559       |> get_followers()
1560       |> Enum.filter(& &1.local)
1561       |> Enum.each(&set_cache(update_following_count(&1)))
1562
1563       # Only update local user counts, remote will be update during the next pull.
1564       user
1565       |> get_friends()
1566       |> Enum.filter(& &1.local)
1567       |> Enum.each(&do_unfollow(user, &1))
1568
1569       {:ok, user}
1570     end
1571   end
1572
1573   def approve(users) when is_list(users) do
1574     Repo.transaction(fn ->
1575       Enum.map(users, fn user ->
1576         with {:ok, user} <- approve(user), do: user
1577       end)
1578     end)
1579   end
1580
1581   def approve(%User{} = user) do
1582     change(user, approval_pending: false)
1583     |> update_and_set_cache()
1584   end
1585
1586   def update_notification_settings(%User{} = user, settings) do
1587     user
1588     |> cast(%{notification_settings: settings}, [])
1589     |> cast_embed(:notification_settings)
1590     |> validate_required([:notification_settings])
1591     |> update_and_set_cache()
1592   end
1593
1594   @spec purge_user_changeset(User.t()) :: Changeset.t()
1595   def purge_user_changeset(user) do
1596     # "Right to be forgotten"
1597     # https://gdpr.eu/right-to-be-forgotten/
1598     change(user, %{
1599       bio: "",
1600       raw_bio: nil,
1601       email: nil,
1602       name: nil,
1603       password_hash: nil,
1604       keys: nil,
1605       public_key: nil,
1606       avatar: %{},
1607       tags: [],
1608       last_refreshed_at: nil,
1609       last_digest_emailed_at: nil,
1610       banner: %{},
1611       background: %{},
1612       note_count: 0,
1613       follower_count: 0,
1614       following_count: 0,
1615       is_locked: false,
1616       confirmation_pending: false,
1617       password_reset_pending: false,
1618       approval_pending: false,
1619       registration_reason: nil,
1620       confirmation_token: nil,
1621       domain_blocks: [],
1622       deactivated: true,
1623       ap_enabled: false,
1624       is_moderator: false,
1625       is_admin: false,
1626       mastofe_settings: nil,
1627       mascot: nil,
1628       emoji: %{},
1629       pleroma_settings_store: %{},
1630       fields: [],
1631       raw_fields: [],
1632       is_discoverable: false,
1633       also_known_as: []
1634     })
1635   end
1636
1637   def delete(users) when is_list(users) do
1638     for user <- users, do: delete(user)
1639   end
1640
1641   def delete(%User{} = user) do
1642     BackgroundWorker.enqueue("delete_user", %{"user_id" => user.id})
1643   end
1644
1645   defp delete_and_invalidate_cache(%User{} = user) do
1646     invalidate_cache(user)
1647     Repo.delete(user)
1648   end
1649
1650   defp delete_or_deactivate(%User{local: false} = user), do: delete_and_invalidate_cache(user)
1651
1652   defp delete_or_deactivate(%User{local: true} = user) do
1653     status = account_status(user)
1654
1655     case status do
1656       :confirmation_pending ->
1657         delete_and_invalidate_cache(user)
1658
1659       :approval_pending ->
1660         delete_and_invalidate_cache(user)
1661
1662       _ ->
1663         user
1664         |> purge_user_changeset()
1665         |> update_and_set_cache()
1666     end
1667   end
1668
1669   def perform(:force_password_reset, user), do: force_password_reset(user)
1670
1671   @spec perform(atom(), User.t()) :: {:ok, User.t()}
1672   def perform(:delete, %User{} = user) do
1673     # Remove all relationships
1674     user
1675     |> get_followers()
1676     |> Enum.each(fn follower ->
1677       ActivityPub.unfollow(follower, user)
1678       unfollow(follower, user)
1679     end)
1680
1681     user
1682     |> get_friends()
1683     |> Enum.each(fn followed ->
1684       ActivityPub.unfollow(user, followed)
1685       unfollow(user, followed)
1686     end)
1687
1688     delete_user_activities(user)
1689     delete_notifications_from_user_activities(user)
1690
1691     delete_outgoing_pending_follow_requests(user)
1692
1693     delete_or_deactivate(user)
1694   end
1695
1696   def perform(:deactivate_async, user, status), do: deactivate(user, status)
1697
1698   @spec external_users_query() :: Ecto.Query.t()
1699   def external_users_query do
1700     User.Query.build(%{
1701       external: true,
1702       active: true,
1703       order_by: :id
1704     })
1705   end
1706
1707   @spec external_users(keyword()) :: [User.t()]
1708   def external_users(opts \\ []) do
1709     query =
1710       external_users_query()
1711       |> select([u], struct(u, [:id, :ap_id]))
1712
1713     query =
1714       if opts[:max_id],
1715         do: where(query, [u], u.id > ^opts[:max_id]),
1716         else: query
1717
1718     query =
1719       if opts[:limit],
1720         do: limit(query, ^opts[:limit]),
1721         else: query
1722
1723     Repo.all(query)
1724   end
1725
1726   def delete_notifications_from_user_activities(%User{ap_id: ap_id}) do
1727     Notification
1728     |> join(:inner, [n], activity in assoc(n, :activity))
1729     |> where([n, a], fragment("? = ?", a.actor, ^ap_id))
1730     |> Repo.delete_all()
1731   end
1732
1733   def delete_user_activities(%User{ap_id: ap_id} = user) do
1734     ap_id
1735     |> Activity.Queries.by_actor()
1736     |> Repo.chunk_stream(50, :batches)
1737     |> Stream.each(fn activities ->
1738       Enum.each(activities, fn activity -> delete_activity(activity, user) end)
1739     end)
1740     |> Stream.run()
1741   end
1742
1743   defp delete_activity(%{data: %{"type" => "Create", "object" => object}} = activity, user) do
1744     with {_, %Object{}} <- {:find_object, Object.get_by_ap_id(object)},
1745          {:ok, delete_data, _} <- Builder.delete(user, object) do
1746       Pipeline.common_pipeline(delete_data, local: user.local)
1747     else
1748       {:find_object, nil} ->
1749         # We have the create activity, but not the object, it was probably pruned.
1750         # Insert a tombstone and try again
1751         with {:ok, tombstone_data, _} <- Builder.tombstone(user.ap_id, object),
1752              {:ok, _tombstone} <- Object.create(tombstone_data) do
1753           delete_activity(activity, user)
1754         end
1755
1756       e ->
1757         Logger.error("Could not delete #{object} created by #{activity.data["ap_id"]}")
1758         Logger.error("Error: #{inspect(e)}")
1759     end
1760   end
1761
1762   defp delete_activity(%{data: %{"type" => type}} = activity, user)
1763        when type in ["Like", "Announce"] do
1764     {:ok, undo, _} = Builder.undo(user, activity)
1765     Pipeline.common_pipeline(undo, local: user.local)
1766   end
1767
1768   defp delete_activity(_activity, _user), do: "Doing nothing"
1769
1770   defp delete_outgoing_pending_follow_requests(user) do
1771     user
1772     |> FollowingRelationship.outgoing_pending_follow_requests_query()
1773     |> Repo.delete_all()
1774   end
1775
1776   def html_filter_policy(%User{no_rich_text: true}) do
1777     Pleroma.HTML.Scrubber.TwitterText
1778   end
1779
1780   def html_filter_policy(_), do: Config.get([:markup, :scrub_policy])
1781
1782   def fetch_by_ap_id(ap_id), do: ActivityPub.make_user_from_ap_id(ap_id)
1783
1784   def get_or_fetch_by_ap_id(ap_id) do
1785     cached_user = get_cached_by_ap_id(ap_id)
1786
1787     maybe_fetched_user = needs_update?(cached_user) && fetch_by_ap_id(ap_id)
1788
1789     case {cached_user, maybe_fetched_user} do
1790       {_, {:ok, %User{} = user}} ->
1791         {:ok, user}
1792
1793       {%User{} = user, _} ->
1794         {:ok, user}
1795
1796       _ ->
1797         {:error, :not_found}
1798     end
1799   end
1800
1801   @doc """
1802   Creates an internal service actor by URI if missing.
1803   Optionally takes nickname for addressing.
1804   """
1805   @spec get_or_create_service_actor_by_ap_id(String.t(), String.t()) :: User.t() | nil
1806   def get_or_create_service_actor_by_ap_id(uri, nickname) do
1807     {_, user} =
1808       case get_cached_by_ap_id(uri) do
1809         nil ->
1810           with {:error, %{errors: errors}} <- create_service_actor(uri, nickname) do
1811             Logger.error("Cannot create service actor: #{uri}/.\n#{inspect(errors)}")
1812             {:error, nil}
1813           end
1814
1815         %User{invisible: false} = user ->
1816           set_invisible(user)
1817
1818         user ->
1819           {:ok, user}
1820       end
1821
1822     user
1823   end
1824
1825   @spec set_invisible(User.t()) :: {:ok, User.t()}
1826   defp set_invisible(user) do
1827     user
1828     |> change(%{invisible: true})
1829     |> update_and_set_cache()
1830   end
1831
1832   @spec create_service_actor(String.t(), String.t()) ::
1833           {:ok, User.t()} | {:error, Ecto.Changeset.t()}
1834   defp create_service_actor(uri, nickname) do
1835     %User{
1836       invisible: true,
1837       local: true,
1838       ap_id: uri,
1839       nickname: nickname,
1840       follower_address: uri <> "/followers"
1841     }
1842     |> change
1843     |> unique_constraint(:nickname)
1844     |> Repo.insert()
1845     |> set_cache()
1846   end
1847
1848   def public_key(%{public_key: public_key_pem}) when is_binary(public_key_pem) do
1849     key =
1850       public_key_pem
1851       |> :public_key.pem_decode()
1852       |> hd()
1853       |> :public_key.pem_entry_decode()
1854
1855     {:ok, key}
1856   end
1857
1858   def public_key(_), do: {:error, "key not found"}
1859
1860   def get_public_key_for_ap_id(ap_id) do
1861     with {:ok, %User{} = user} <- get_or_fetch_by_ap_id(ap_id),
1862          {:ok, public_key} <- public_key(user) do
1863       {:ok, public_key}
1864     else
1865       _ -> :error
1866     end
1867   end
1868
1869   def ap_enabled?(%User{local: true}), do: true
1870   def ap_enabled?(%User{ap_enabled: ap_enabled}), do: ap_enabled
1871   def ap_enabled?(_), do: false
1872
1873   @doc "Gets or fetch a user by uri or nickname."
1874   @spec get_or_fetch(String.t()) :: {:ok, User.t()} | {:error, String.t()}
1875   def get_or_fetch("http" <> _host = uri), do: get_or_fetch_by_ap_id(uri)
1876   def get_or_fetch(nickname), do: get_or_fetch_by_nickname(nickname)
1877
1878   # wait a period of time and return newest version of the User structs
1879   # this is because we have synchronous follow APIs and need to simulate them
1880   # with an async handshake
1881   def wait_and_refresh(_, %User{local: true} = a, %User{local: true} = b) do
1882     with %User{} = a <- get_cached_by_id(a.id),
1883          %User{} = b <- get_cached_by_id(b.id) do
1884       {:ok, a, b}
1885     else
1886       nil -> :error
1887     end
1888   end
1889
1890   def wait_and_refresh(timeout, %User{} = a, %User{} = b) do
1891     with :ok <- :timer.sleep(timeout),
1892          %User{} = a <- get_cached_by_id(a.id),
1893          %User{} = b <- get_cached_by_id(b.id) do
1894       {:ok, a, b}
1895     else
1896       nil -> :error
1897     end
1898   end
1899
1900   def parse_bio(bio) when is_binary(bio) and bio != "" do
1901     bio
1902     |> CommonUtils.format_input("text/plain", mentions_format: :full)
1903     |> elem(0)
1904   end
1905
1906   def parse_bio(_), do: ""
1907
1908   def parse_bio(bio, user) when is_binary(bio) and bio != "" do
1909     # TODO: get profile URLs other than user.ap_id
1910     profile_urls = [user.ap_id]
1911
1912     bio
1913     |> CommonUtils.format_input("text/plain",
1914       mentions_format: :full,
1915       rel: &RelMe.maybe_put_rel_me(&1, profile_urls)
1916     )
1917     |> elem(0)
1918   end
1919
1920   def parse_bio(_, _), do: ""
1921
1922   def tag(user_identifiers, tags) when is_list(user_identifiers) do
1923     Repo.transaction(fn ->
1924       for user_identifier <- user_identifiers, do: tag(user_identifier, tags)
1925     end)
1926   end
1927
1928   def tag(nickname, tags) when is_binary(nickname),
1929     do: tag(get_by_nickname(nickname), tags)
1930
1931   def tag(%User{} = user, tags),
1932     do: update_tags(user, Enum.uniq((user.tags || []) ++ normalize_tags(tags)))
1933
1934   def untag(user_identifiers, tags) when is_list(user_identifiers) do
1935     Repo.transaction(fn ->
1936       for user_identifier <- user_identifiers, do: untag(user_identifier, tags)
1937     end)
1938   end
1939
1940   def untag(nickname, tags) when is_binary(nickname),
1941     do: untag(get_by_nickname(nickname), tags)
1942
1943   def untag(%User{} = user, tags),
1944     do: update_tags(user, (user.tags || []) -- normalize_tags(tags))
1945
1946   defp update_tags(%User{} = user, new_tags) do
1947     {:ok, updated_user} =
1948       user
1949       |> change(%{tags: new_tags})
1950       |> update_and_set_cache()
1951
1952     updated_user
1953   end
1954
1955   defp normalize_tags(tags) do
1956     [tags]
1957     |> List.flatten()
1958     |> Enum.map(&String.downcase/1)
1959   end
1960
1961   defp local_nickname_regex do
1962     if Config.get([:instance, :extended_nickname_format]) do
1963       @extended_local_nickname_regex
1964     else
1965       @strict_local_nickname_regex
1966     end
1967   end
1968
1969   def local_nickname(nickname_or_mention) do
1970     nickname_or_mention
1971     |> full_nickname()
1972     |> String.split("@")
1973     |> hd()
1974   end
1975
1976   def full_nickname(nickname_or_mention),
1977     do: String.trim_leading(nickname_or_mention, "@")
1978
1979   def error_user(ap_id) do
1980     %User{
1981       name: ap_id,
1982       ap_id: ap_id,
1983       nickname: "erroruser@example.com",
1984       inserted_at: NaiveDateTime.utc_now()
1985     }
1986   end
1987
1988   @spec all_superusers() :: [User.t()]
1989   def all_superusers do
1990     User.Query.build(%{super_users: true, local: true, deactivated: false})
1991     |> Repo.all()
1992   end
1993
1994   def muting_reblogs?(%User{} = user, %User{} = target) do
1995     UserRelationship.reblog_mute_exists?(user, target)
1996   end
1997
1998   def showing_reblogs?(%User{} = user, %User{} = target) do
1999     not muting_reblogs?(user, target)
2000   end
2001
2002   @doc """
2003   The function returns a query to get users with no activity for given interval of days.
2004   Inactive users are those who didn't read any notification, or had any activity where
2005   the user is the activity's actor, during `inactivity_threshold` days.
2006   Deactivated users will not appear in this list.
2007
2008   ## Examples
2009
2010       iex> Pleroma.User.list_inactive_users()
2011       %Ecto.Query{}
2012   """
2013   @spec list_inactive_users_query(integer()) :: Ecto.Query.t()
2014   def list_inactive_users_query(inactivity_threshold \\ 7) do
2015     negative_inactivity_threshold = -inactivity_threshold
2016     now = NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
2017     # Subqueries are not supported in `where` clauses, join gets too complicated.
2018     has_read_notifications =
2019       from(n in Pleroma.Notification,
2020         where: n.seen == true,
2021         group_by: n.id,
2022         having: max(n.updated_at) > datetime_add(^now, ^negative_inactivity_threshold, "day"),
2023         select: n.user_id
2024       )
2025       |> Pleroma.Repo.all()
2026
2027     from(u in Pleroma.User,
2028       left_join: a in Pleroma.Activity,
2029       on: u.ap_id == a.actor,
2030       where: not is_nil(u.nickname),
2031       where: u.deactivated != ^true,
2032       where: u.id not in ^has_read_notifications,
2033       group_by: u.id,
2034       having:
2035         max(a.inserted_at) < datetime_add(^now, ^negative_inactivity_threshold, "day") or
2036           is_nil(max(a.inserted_at))
2037     )
2038   end
2039
2040   @doc """
2041   Enable or disable email notifications for user
2042
2043   ## Examples
2044
2045       iex> Pleroma.User.switch_email_notifications(Pleroma.User{email_notifications: %{"digest" => false}}, "digest", true)
2046       Pleroma.User{email_notifications: %{"digest" => true}}
2047
2048       iex> Pleroma.User.switch_email_notifications(Pleroma.User{email_notifications: %{"digest" => true}}, "digest", false)
2049       Pleroma.User{email_notifications: %{"digest" => false}}
2050   """
2051   @spec switch_email_notifications(t(), String.t(), boolean()) ::
2052           {:ok, t()} | {:error, Ecto.Changeset.t()}
2053   def switch_email_notifications(user, type, status) do
2054     User.update_email_notifications(user, %{type => status})
2055   end
2056
2057   @doc """
2058   Set `last_digest_emailed_at` value for the user to current time
2059   """
2060   @spec touch_last_digest_emailed_at(t()) :: t()
2061   def touch_last_digest_emailed_at(user) do
2062     now = NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
2063
2064     {:ok, updated_user} =
2065       user
2066       |> change(%{last_digest_emailed_at: now})
2067       |> update_and_set_cache()
2068
2069     updated_user
2070   end
2071
2072   @spec toggle_confirmation(User.t()) :: {:ok, User.t()} | {:error, Changeset.t()}
2073   def toggle_confirmation(%User{} = user) do
2074     user
2075     |> confirmation_changeset(need_confirmation: !user.confirmation_pending)
2076     |> update_and_set_cache()
2077   end
2078
2079   @spec toggle_confirmation([User.t()]) :: [{:ok, User.t()} | {:error, Changeset.t()}]
2080   def toggle_confirmation(users) do
2081     Enum.map(users, &toggle_confirmation/1)
2082   end
2083
2084   @spec need_confirmation(User.t(), boolean()) :: {:ok, User.t()} | {:error, Changeset.t()}
2085   def need_confirmation(%User{} = user, bool) do
2086     user
2087     |> confirmation_changeset(need_confirmation: bool)
2088     |> update_and_set_cache()
2089   end
2090
2091   def get_mascot(%{mascot: %{} = mascot}) when not is_nil(mascot) do
2092     mascot
2093   end
2094
2095   def get_mascot(%{mascot: mascot}) when is_nil(mascot) do
2096     # use instance-default
2097     config = Config.get([:assets, :mascots])
2098     default_mascot = Config.get([:assets, :default_mascot])
2099     mascot = Keyword.get(config, default_mascot)
2100
2101     %{
2102       "id" => "default-mascot",
2103       "url" => mascot[:url],
2104       "preview_url" => mascot[:url],
2105       "pleroma" => %{
2106         "mime_type" => mascot[:mime_type]
2107       }
2108     }
2109   end
2110
2111   def ensure_keys_present(%{keys: keys} = user) when not is_nil(keys), do: {:ok, user}
2112
2113   def ensure_keys_present(%User{} = user) do
2114     with {:ok, pem} <- Keys.generate_rsa_pem() do
2115       user
2116       |> cast(%{keys: pem}, [:keys])
2117       |> validate_required([:keys])
2118       |> update_and_set_cache()
2119     end
2120   end
2121
2122   def get_ap_ids_by_nicknames(nicknames) do
2123     from(u in User,
2124       where: u.nickname in ^nicknames,
2125       select: u.ap_id
2126     )
2127     |> Repo.all()
2128   end
2129
2130   defp put_password_hash(
2131          %Ecto.Changeset{valid?: true, changes: %{password: password}} = changeset
2132        ) do
2133     change(changeset, password_hash: Pbkdf2.hash_pwd_salt(password))
2134   end
2135
2136   defp put_password_hash(changeset), do: changeset
2137
2138   def is_internal_user?(%User{nickname: nil}), do: true
2139   def is_internal_user?(%User{local: true, nickname: "internal." <> _}), do: true
2140   def is_internal_user?(_), do: false
2141
2142   # A hack because user delete activities have a fake id for whatever reason
2143   # TODO: Get rid of this
2144   def get_delivered_users_by_object_id("pleroma:fake_object_id"), do: []
2145
2146   def get_delivered_users_by_object_id(object_id) do
2147     from(u in User,
2148       inner_join: delivery in assoc(u, :deliveries),
2149       where: delivery.object_id == ^object_id
2150     )
2151     |> Repo.all()
2152   end
2153
2154   def change_email(user, email) do
2155     user
2156     |> cast(%{email: email}, [:email])
2157     |> validate_required([:email])
2158     |> unique_constraint(:email)
2159     |> validate_format(:email, @email_regex)
2160     |> update_and_set_cache()
2161   end
2162
2163   # Internal function; public one is `deactivate/2`
2164   defp set_activation_status(user, deactivated) do
2165     user
2166     |> cast(%{deactivated: deactivated}, [:deactivated])
2167     |> update_and_set_cache()
2168   end
2169
2170   def update_banner(user, banner) do
2171     user
2172     |> cast(%{banner: banner}, [:banner])
2173     |> update_and_set_cache()
2174   end
2175
2176   def update_background(user, background) do
2177     user
2178     |> cast(%{background: background}, [:background])
2179     |> update_and_set_cache()
2180   end
2181
2182   def roles(%{is_moderator: is_moderator, is_admin: is_admin}) do
2183     %{
2184       admin: is_admin,
2185       moderator: is_moderator
2186     }
2187   end
2188
2189   def validate_fields(changeset, remote? \\ false) do
2190     limit_name = if remote?, do: :max_remote_account_fields, else: :max_account_fields
2191     limit = Config.get([:instance, limit_name], 0)
2192
2193     changeset
2194     |> validate_length(:fields, max: limit)
2195     |> validate_change(:fields, fn :fields, fields ->
2196       if Enum.all?(fields, &valid_field?/1) do
2197         []
2198       else
2199         [fields: "invalid"]
2200       end
2201     end)
2202   end
2203
2204   defp valid_field?(%{"name" => name, "value" => value}) do
2205     name_limit = Config.get([:instance, :account_field_name_length], 255)
2206     value_limit = Config.get([:instance, :account_field_value_length], 255)
2207
2208     is_binary(name) && is_binary(value) && String.length(name) <= name_limit &&
2209       String.length(value) <= value_limit
2210   end
2211
2212   defp valid_field?(_), do: false
2213
2214   defp truncate_field(%{"name" => name, "value" => value}) do
2215     {name, _chopped} =
2216       String.split_at(name, Config.get([:instance, :account_field_name_length], 255))
2217
2218     {value, _chopped} =
2219       String.split_at(value, Config.get([:instance, :account_field_value_length], 255))
2220
2221     %{"name" => name, "value" => value}
2222   end
2223
2224   def admin_api_update(user, params) do
2225     user
2226     |> cast(params, [
2227       :is_moderator,
2228       :is_admin,
2229       :show_role
2230     ])
2231     |> update_and_set_cache()
2232   end
2233
2234   @doc "Signs user out of all applications"
2235   def global_sign_out(user) do
2236     OAuth.Authorization.delete_user_authorizations(user)
2237     OAuth.Token.delete_user_tokens(user)
2238   end
2239
2240   def mascot_update(user, url) do
2241     user
2242     |> cast(%{mascot: url}, [:mascot])
2243     |> validate_required([:mascot])
2244     |> update_and_set_cache()
2245   end
2246
2247   def mastodon_settings_update(user, settings) do
2248     user
2249     |> cast(%{mastofe_settings: settings}, [:mastofe_settings])
2250     |> validate_required([:mastofe_settings])
2251     |> update_and_set_cache()
2252   end
2253
2254   @spec confirmation_changeset(User.t(), keyword()) :: Changeset.t()
2255   def confirmation_changeset(user, need_confirmation: need_confirmation?) do
2256     params =
2257       if need_confirmation? do
2258         %{
2259           confirmation_pending: true,
2260           confirmation_token: :crypto.strong_rand_bytes(32) |> Base.url_encode64()
2261         }
2262       else
2263         %{
2264           confirmation_pending: false,
2265           confirmation_token: nil
2266         }
2267       end
2268
2269     cast(user, params, [:confirmation_pending, :confirmation_token])
2270   end
2271
2272   @spec approval_changeset(User.t(), keyword()) :: Changeset.t()
2273   def approval_changeset(user, need_approval: need_approval?) do
2274     params = if need_approval?, do: %{approval_pending: true}, else: %{approval_pending: false}
2275     cast(user, params, [:approval_pending])
2276   end
2277
2278   def add_pinnned_activity(user, %Pleroma.Activity{id: id}) do
2279     if id not in user.pinned_activities do
2280       max_pinned_statuses = Config.get([:instance, :max_pinned_statuses], 0)
2281       params = %{pinned_activities: user.pinned_activities ++ [id]}
2282
2283       # if pinned activity was scheduled for deletion, we remove job
2284       if expiration = Pleroma.Workers.PurgeExpiredActivity.get_expiration(id) do
2285         Oban.cancel_job(expiration.id)
2286       end
2287
2288       user
2289       |> cast(params, [:pinned_activities])
2290       |> validate_length(:pinned_activities,
2291         max: max_pinned_statuses,
2292         message: "You have already pinned the maximum number of statuses"
2293       )
2294     else
2295       change(user)
2296     end
2297     |> update_and_set_cache()
2298   end
2299
2300   def remove_pinnned_activity(user, %Pleroma.Activity{id: id, data: data}) do
2301     params = %{pinned_activities: List.delete(user.pinned_activities, id)}
2302
2303     # if pinned activity was scheduled for deletion, we reschedule it for deletion
2304     if data["expires_at"] do
2305       # MRF.ActivityExpirationPolicy used UTC timestamps for expires_at in original implementation
2306       {:ok, expires_at} =
2307         data["expires_at"] |> Pleroma.EctoType.ActivityPub.ObjectValidators.DateTime.cast()
2308
2309       Pleroma.Workers.PurgeExpiredActivity.enqueue(%{
2310         activity_id: id,
2311         expires_at: expires_at
2312       })
2313     end
2314
2315     user
2316     |> cast(params, [:pinned_activities])
2317     |> update_and_set_cache()
2318   end
2319
2320   def update_email_notifications(user, settings) do
2321     email_notifications =
2322       user.email_notifications
2323       |> Map.merge(settings)
2324       |> Map.take(["digest"])
2325
2326     params = %{email_notifications: email_notifications}
2327     fields = [:email_notifications]
2328
2329     user
2330     |> cast(params, fields)
2331     |> validate_required(fields)
2332     |> update_and_set_cache()
2333   end
2334
2335   defp set_domain_blocks(user, domain_blocks) do
2336     params = %{domain_blocks: domain_blocks}
2337
2338     user
2339     |> cast(params, [:domain_blocks])
2340     |> validate_required([:domain_blocks])
2341     |> update_and_set_cache()
2342   end
2343
2344   def block_domain(user, domain_blocked) do
2345     set_domain_blocks(user, Enum.uniq([domain_blocked | user.domain_blocks]))
2346   end
2347
2348   def unblock_domain(user, domain_blocked) do
2349     set_domain_blocks(user, List.delete(user.domain_blocks, domain_blocked))
2350   end
2351
2352   @spec add_to_block(User.t(), User.t()) ::
2353           {:ok, UserRelationship.t()} | {:error, Ecto.Changeset.t()}
2354   defp add_to_block(%User{} = user, %User{} = blocked) do
2355     with {:ok, relationship} <- UserRelationship.create_block(user, blocked) do
2356       Cachex.del(:user_cache, "blocked_users_ap_ids:#{user.ap_id}")
2357       {:ok, relationship}
2358     end
2359   end
2360
2361   @spec add_to_block(User.t(), User.t()) ::
2362           {:ok, UserRelationship.t()} | {:ok, nil} | {:error, Ecto.Changeset.t()}
2363   defp remove_from_block(%User{} = user, %User{} = blocked) do
2364     with {:ok, relationship} <- UserRelationship.delete_block(user, blocked) do
2365       Cachex.del(:user_cache, "blocked_users_ap_ids:#{user.ap_id}")
2366       {:ok, relationship}
2367     end
2368   end
2369
2370   def set_invisible(user, invisible) do
2371     params = %{invisible: invisible}
2372
2373     user
2374     |> cast(params, [:invisible])
2375     |> validate_required([:invisible])
2376     |> update_and_set_cache()
2377   end
2378
2379   def sanitize_html(%User{} = user) do
2380     sanitize_html(user, nil)
2381   end
2382
2383   # User data that mastodon isn't filtering (treated as plaintext):
2384   # - field name
2385   # - display name
2386   def sanitize_html(%User{} = user, filter) do
2387     fields =
2388       Enum.map(user.fields, fn %{"name" => name, "value" => value} ->
2389         %{
2390           "name" => name,
2391           "value" => HTML.filter_tags(value, Pleroma.HTML.Scrubber.LinksOnly)
2392         }
2393       end)
2394
2395     user
2396     |> Map.put(:bio, HTML.filter_tags(user.bio, filter))
2397     |> Map.put(:fields, fields)
2398   end
2399 end