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