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, _} <- try_send_confirmation_email(user) do
 738       {:ok, user}
 739     end
 740   end
 741
 742   def send_welcome_message(user) do
 743     if User.WelcomeMessage.enabled?() do
 744       User.WelcomeMessage.post_message(user)
 745       {:ok, :enqueued}
 746     else
 747       {:ok, :noop}
 748     end
 749   end
 750
 751   def send_welcome_email(%User{email: email} = user) when is_binary(email) do
 752     if User.WelcomeEmail.enabled?() do
 753       User.WelcomeEmail.send_email(user)
 754       {:ok, :enqueued}
 755     else
 756       {:ok, :noop}
 757     end
 758   end
 759
 760   def send_welcome_email(_), do: {:ok, :noop}
 761
 762   @spec try_send_confirmation_email(User.t()) :: {:ok, :enqueued | :noop}
 763   def try_send_confirmation_email(%User{confirmation_pending: true} = user) do
 764     if Config.get([:instance, :account_activation_required]) do
 765       send_confirmation_email(user)
 766       {:ok, :enqueued}
 767     else
 768       {:ok, :noop}
 769     end
 770   end
 771
 772   def try_send_confirmation_email(_), do: {:ok, :noop}
 773
 774   @spec send_confirmation_email(Uset.t()) :: User.t()
 775   def send_confirmation_email(%User{} = user) do
 776     user
 777     |> Pleroma.Emails.UserEmail.account_confirmation_email()
 778     |> Pleroma.Emails.Mailer.deliver_async()
 779
 780     user
 781   end
 782
 783   def needs_update?(%User{local: true}), do: false
 784
 785   def needs_update?(%User{local: false, last_refreshed_at: nil}), do: true
 786
 787   def needs_update?(%User{local: false} = user) do
 788     NaiveDateTime.diff(NaiveDateTime.utc_now(), user.last_refreshed_at) >= 86_400
 789   end
 790
 791   def needs_update?(_), do: true
 792
 793   @spec maybe_direct_follow(User.t(), User.t()) :: {:ok, User.t()} | {:error, String.t()}
 794
 795   # "Locked" (self-locked) users demand explicit authorization of follow requests
 796   def maybe_direct_follow(%User{} = follower, %User{local: true, locked: true} = followed) do
 797     follow(follower, followed, :follow_pending)
 798   end
 799
 800   def maybe_direct_follow(%User{} = follower, %User{local: true} = followed) do
 801     follow(follower, followed)
 802   end
 803
 804   def maybe_direct_follow(%User{} = follower, %User{} = followed) do
 805     if not ap_enabled?(followed) do
 806       follow(follower, followed)
 807     else
 808       {:ok, follower}
 809     end
 810   end
 811
 812   @doc "A mass follow for local users. Respects blocks in both directions but does not create activities."
 813   @spec follow_all(User.t(), list(User.t())) :: {atom(), User.t()}
 814   def follow_all(follower, followeds) do
 815     followeds
 816     |> Enum.reject(fn followed -> blocks?(follower, followed) || blocks?(followed, follower) end)
 817     |> Enum.each(&follow(follower, &1, :follow_accept))
 818
 819     set_cache(follower)
 820   end
 821
 822   defdelegate following(user), to: FollowingRelationship
 823
 824   def follow(%User{} = follower, %User{} = followed, state \\ :follow_accept) do
 825     deny_follow_blocked = Config.get([:user, :deny_follow_blocked])
 826
 827     cond do
 828       followed.deactivated ->
 829         {:error, "Could not follow user: #{followed.nickname} is deactivated."}
 830
 831       deny_follow_blocked and blocks?(followed, follower) ->
 832         {:error, "Could not follow user: #{followed.nickname} blocked you."}
 833
 834       true ->
 835         FollowingRelationship.follow(follower, followed, state)
 836
 837         {:ok, _} = update_follower_count(followed)
 838
 839         follower
 840         |> update_following_count()
 841     end
 842   end
 843
 844   def unfollow(%User{ap_id: ap_id}, %User{ap_id: ap_id}) do
 845     {:error, "Not subscribed!"}
 846   end
 847
 848   @spec unfollow(User.t(), User.t()) :: {:ok, User.t(), Activity.t()} | {:error, String.t()}
 849   def unfollow(%User{} = follower, %User{} = followed) do
 850     case do_unfollow(follower, followed) do
 851       {:ok, follower, followed} ->
 852         {:ok, follower, Utils.fetch_latest_follow(follower, followed)}
 853
 854       error ->
 855         error
 856     end
 857   end
 858
 859   @spec do_unfollow(User.t(), User.t()) :: {:ok, User.t(), User.t()} | {:error, String.t()}
 860   defp do_unfollow(%User{} = follower, %User{} = followed) do
 861     case get_follow_state(follower, followed) do
 862       state when state in [:follow_pending, :follow_accept] ->
 863         FollowingRelationship.unfollow(follower, followed)
 864         {:ok, followed} = update_follower_count(followed)
 865
 866         {:ok, follower} =
 867           follower
 868           |> update_following_count()
 869
 870         {:ok, follower, followed}
 871
 872       nil ->
 873         {:error, "Not subscribed!"}
 874     end
 875   end
 876
 877   defdelegate following?(follower, followed), to: FollowingRelationship
 878
 879   @doc "Returns follow state as Pleroma.FollowingRelationship.State value"
 880   def get_follow_state(%User{} = follower, %User{} = following) do
 881     following_relationship = FollowingRelationship.get(follower, following)
 882     get_follow_state(follower, following, following_relationship)
 883   end
 884
 885   def get_follow_state(
 886         %User{} = follower,
 887         %User{} = following,
 888         following_relationship
 889       ) do
 890     case {following_relationship, following.local} do
 891       {nil, false} ->
 892         case Utils.fetch_latest_follow(follower, following) do
 893           %Activity{data: %{"state" => state}} when state in ["pending", "accept"] ->
 894             FollowingRelationship.state_to_enum(state)
 895
 896           _ ->
 897             nil
 898         end
 899
 900       {%{state: state}, _} ->
 901         state
 902
 903       {nil, _} ->
 904         nil
 905     end
 906   end
 907
 908   def locked?(%User{} = user) do
 909     user.locked || false
 910   end
 911
 912   def get_by_id(id) do
 913     Repo.get_by(User, id: id)
 914   end
 915
 916   def get_by_ap_id(ap_id) do
 917     Repo.get_by(User, ap_id: ap_id)
 918   end
 919
 920   def get_all_by_ap_id(ap_ids) do
 921     from(u in __MODULE__,
 922       where: u.ap_id in ^ap_ids
 923     )
 924     |> Repo.all()
 925   end
 926
 927   def get_all_by_ids(ids) do
 928     from(u in __MODULE__, where: u.id in ^ids)
 929     |> Repo.all()
 930   end
 931
 932   # This is mostly an SPC migration fix. This guesses the user nickname by taking the last part
 933   # of the ap_id and the domain and tries to get that user
 934   def get_by_guessed_nickname(ap_id) do
 935     domain = URI.parse(ap_id).host
 936     name = List.last(String.split(ap_id, "/"))
 937     nickname = "#{name}@#{domain}"
 938
 939     get_cached_by_nickname(nickname)
 940   end
 941
 942   def set_cache({:ok, user}), do: set_cache(user)
 943   def set_cache({:error, err}), do: {:error, err}
 944
 945   def set_cache(%User{} = user) do
 946     Cachex.put(:user_cache, "ap_id:#{user.ap_id}", user)
 947     Cachex.put(:user_cache, "nickname:#{user.nickname}", user)
 948     Cachex.put(:user_cache, "friends_ap_ids:#{user.nickname}", get_user_friends_ap_ids(user))
 949     {:ok, user}
 950   end
 951
 952   def update_and_set_cache(struct, params) do
 953     struct
 954     |> update_changeset(params)
 955     |> update_and_set_cache()
 956   end
 957
 958   def update_and_set_cache(changeset) do
 959     with {:ok, user} <- Repo.update(changeset, stale_error_field: :id) do
 960       set_cache(user)
 961     end
 962   end
 963
 964   def get_user_friends_ap_ids(user) do
 965     from(u in User.get_friends_query(user), select: u.ap_id)
 966     |> Repo.all()
 967   end
 968
 969   @spec get_cached_user_friends_ap_ids(User.t()) :: [String.t()]
 970   def get_cached_user_friends_ap_ids(user) do
 971     Cachex.fetch!(:user_cache, "friends_ap_ids:#{user.ap_id}", fn _ ->
 972       get_user_friends_ap_ids(user)
 973     end)
 974   end
 975
 976   def invalidate_cache(user) do
 977     Cachex.del(:user_cache, "ap_id:#{user.ap_id}")
 978     Cachex.del(:user_cache, "nickname:#{user.nickname}")
 979     Cachex.del(:user_cache, "friends_ap_ids:#{user.ap_id}")
 980   end
 981
 982   @spec get_cached_by_ap_id(String.t()) :: User.t() | nil
 983   def get_cached_by_ap_id(ap_id) do
 984     key = "ap_id:#{ap_id}"
 985
 986     with {:ok, nil} <- Cachex.get(:user_cache, key),
 987          user when not is_nil(user) <- get_by_ap_id(ap_id),
 988          {:ok, true} <- Cachex.put(:user_cache, key, user) do
 989       user
 990     else
 991       {:ok, user} -> user
 992       nil -> nil
 993     end
 994   end
 995
 996   def get_cached_by_id(id) do
 997     key = "id:#{id}"
 998
 999     ap_id =
1000       Cachex.fetch!(:user_cache, key, fn _ ->
1001         user = get_by_id(id)
1002
1003         if user do
1004           Cachex.put(:user_cache, "ap_id:#{user.ap_id}", user)
1005           {:commit, user.ap_id}
1006         else
1007           {:ignore, ""}
1008         end
1009       end)
1010
1011     get_cached_by_ap_id(ap_id)
1012   end
1013
1014   def get_cached_by_nickname(nickname) do
1015     key = "nickname:#{nickname}"
1016
1017     Cachex.fetch!(:user_cache, key, fn ->
1018       case get_or_fetch_by_nickname(nickname) do
1019         {:ok, user} -> {:commit, user}
1020         {:error, _error} -> {:ignore, nil}
1021       end
1022     end)
1023   end
1024
1025   def get_cached_by_nickname_or_id(nickname_or_id, opts \\ []) do
1026     restrict_to_local = Config.get([:instance, :limit_to_local_content])
1027
1028     cond do
1029       is_integer(nickname_or_id) or FlakeId.flake_id?(nickname_or_id) ->
1030         get_cached_by_id(nickname_or_id) || get_cached_by_nickname(nickname_or_id)
1031
1032       restrict_to_local == false or not String.contains?(nickname_or_id, "@") ->
1033         get_cached_by_nickname(nickname_or_id)
1034
1035       restrict_to_local == :unauthenticated and match?(%User{}, opts[:for]) ->
1036         get_cached_by_nickname(nickname_or_id)
1037
1038       true ->
1039         nil
1040     end
1041   end
1042
1043   @spec get_by_nickname(String.t()) :: User.t() | nil
1044   def get_by_nickname(nickname) do
1045     Repo.get_by(User, nickname: nickname) ||
1046       if Regex.match?(~r(@#{Pleroma.Web.Endpoint.host()})i, nickname) do
1047         Repo.get_by(User, nickname: local_nickname(nickname))
1048       end
1049   end
1050
1051   def get_by_email(email), do: Repo.get_by(User, email: email)
1052
1053   def get_by_nickname_or_email(nickname_or_email) do
1054     get_by_nickname(nickname_or_email) || get_by_email(nickname_or_email)
1055   end
1056
1057   def fetch_by_nickname(nickname), do: ActivityPub.make_user_from_nickname(nickname)
1058
1059   def get_or_fetch_by_nickname(nickname) do
1060     with %User{} = user <- get_by_nickname(nickname) do
1061       {:ok, user}
1062     else
1063       _e ->
1064         with [_nick, _domain] <- String.split(nickname, "@"),
1065              {:ok, user} <- fetch_by_nickname(nickname) do
1066           {:ok, user}
1067         else
1068           _e -> {:error, "not found " <> nickname}
1069         end
1070     end
1071   end
1072
1073   @spec get_followers_query(User.t(), pos_integer() | nil) :: Ecto.Query.t()
1074   def get_followers_query(%User{} = user, nil) do
1075     User.Query.build(%{followers: user, deactivated: false})
1076   end
1077
1078   def get_followers_query(user, page) do
1079     user
1080     |> get_followers_query(nil)
1081     |> User.Query.paginate(page, 20)
1082   end
1083
1084   @spec get_followers_query(User.t()) :: Ecto.Query.t()
1085   def get_followers_query(user), do: get_followers_query(user, nil)
1086
1087   @spec get_followers(User.t(), pos_integer() | nil) :: {:ok, list(User.t())}
1088   def get_followers(user, page \\ nil) do
1089     user
1090     |> get_followers_query(page)
1091     |> Repo.all()
1092   end
1093
1094   @spec get_external_followers(User.t(), pos_integer() | nil) :: {:ok, list(User.t())}
1095   def get_external_followers(user, page \\ nil) do
1096     user
1097     |> get_followers_query(page)
1098     |> User.Query.build(%{external: true})
1099     |> Repo.all()
1100   end
1101
1102   def get_followers_ids(user, page \\ nil) do
1103     user
1104     |> get_followers_query(page)
1105     |> select([u], u.id)
1106     |> Repo.all()
1107   end
1108
1109   @spec get_friends_query(User.t(), pos_integer() | nil) :: Ecto.Query.t()
1110   def get_friends_query(%User{} = user, nil) do
1111     User.Query.build(%{friends: user, deactivated: false})
1112   end
1113
1114   def get_friends_query(user, page) do
1115     user
1116     |> get_friends_query(nil)
1117     |> User.Query.paginate(page, 20)
1118   end
1119
1120   @spec get_friends_query(User.t()) :: Ecto.Query.t()
1121   def get_friends_query(user), do: get_friends_query(user, nil)
1122
1123   def get_friends(user, page \\ nil) do
1124     user
1125     |> get_friends_query(page)
1126     |> Repo.all()
1127   end
1128
1129   def get_friends_ap_ids(user) do
1130     user
1131     |> get_friends_query(nil)
1132     |> select([u], u.ap_id)
1133     |> Repo.all()
1134   end
1135
1136   def get_friends_ids(user, page \\ nil) do
1137     user
1138     |> get_friends_query(page)
1139     |> select([u], u.id)
1140     |> Repo.all()
1141   end
1142
1143   defdelegate get_follow_requests(user), to: FollowingRelationship
1144
1145   def increase_note_count(%User{} = user) do
1146     User
1147     |> where(id: ^user.id)
1148     |> update([u], inc: [note_count: 1])
1149     |> select([u], u)
1150     |> Repo.update_all([])
1151     |> case do
1152       {1, [user]} -> set_cache(user)
1153       _ -> {:error, user}
1154     end
1155   end
1156
1157   def decrease_note_count(%User{} = user) do
1158     User
1159     |> where(id: ^user.id)
1160     |> update([u],
1161       set: [
1162         note_count: fragment("greatest(0, note_count - 1)")
1163       ]
1164     )
1165     |> select([u], u)
1166     |> Repo.update_all([])
1167     |> case do
1168       {1, [user]} -> set_cache(user)
1169       _ -> {:error, user}
1170     end
1171   end
1172
1173   def update_note_count(%User{} = user, note_count \\ nil) do
1174     note_count =
1175       note_count ||
1176         from(
1177           a in Object,
1178           where: fragment("?->>'actor' = ? and ?->>'type' = 'Note'", a.data, ^user.ap_id, a.data),
1179           select: count(a.id)
1180         )
1181         |> Repo.one()
1182
1183     user
1184     |> cast(%{note_count: note_count}, [:note_count])
1185     |> update_and_set_cache()
1186   end
1187
1188   @spec maybe_fetch_follow_information(User.t()) :: User.t()
1189   def maybe_fetch_follow_information(user) do
1190     with {:ok, user} <- fetch_follow_information(user) do
1191       user
1192     else
1193       e ->
1194         Logger.error("Follower/Following counter update for #{user.ap_id} failed.\n#{inspect(e)}")
1195
1196         user
1197     end
1198   end
1199
1200   def fetch_follow_information(user) do
1201     with {:ok, info} <- ActivityPub.fetch_follow_information_for_user(user) do
1202       user
1203       |> follow_information_changeset(info)
1204       |> update_and_set_cache()
1205     end
1206   end
1207
1208   defp follow_information_changeset(user, params) do
1209     user
1210     |> cast(params, [
1211       :hide_followers,
1212       :hide_follows,
1213       :follower_count,
1214       :following_count,
1215       :hide_followers_count,
1216       :hide_follows_count
1217     ])
1218   end
1219
1220   @spec update_follower_count(User.t()) :: {:ok, User.t()}
1221   def update_follower_count(%User{} = user) do
1222     if user.local or !Config.get([:instance, :external_user_synchronization]) do
1223       follower_count = FollowingRelationship.follower_count(user)
1224
1225       user
1226       |> follow_information_changeset(%{follower_count: follower_count})
1227       |> update_and_set_cache
1228     else
1229       {:ok, maybe_fetch_follow_information(user)}
1230     end
1231   end
1232
1233   @spec update_following_count(User.t()) :: {:ok, User.t()}
1234   def update_following_count(%User{local: false} = user) do
1235     if Config.get([:instance, :external_user_synchronization]) do
1236       {:ok, maybe_fetch_follow_information(user)}
1237     else
1238       {:ok, user}
1239     end
1240   end
1241
1242   def update_following_count(%User{local: true} = user) do
1243     following_count = FollowingRelationship.following_count(user)
1244
1245     user
1246     |> follow_information_changeset(%{following_count: following_count})
1247     |> update_and_set_cache()
1248   end
1249
1250   def set_unread_conversation_count(%User{local: true} = user) do
1251     unread_query = Participation.unread_conversation_count_for_user(user)
1252
1253     User
1254     |> join(:inner, [u], p in subquery(unread_query))
1255     |> update([u, p],
1256       set: [unread_conversation_count: p.count]
1257     )
1258     |> where([u], u.id == ^user.id)
1259     |> select([u], u)
1260     |> Repo.update_all([])
1261     |> case do
1262       {1, [user]} -> set_cache(user)
1263       _ -> {:error, user}
1264     end
1265   end
1266
1267   def set_unread_conversation_count(user), do: {:ok, user}
1268
1269   def increment_unread_conversation_count(conversation, %User{local: true} = user) do
1270     unread_query =
1271       Participation.unread_conversation_count_for_user(user)
1272       |> where([p], p.conversation_id == ^conversation.id)
1273
1274     User
1275     |> join(:inner, [u], p in subquery(unread_query))
1276     |> update([u, p],
1277       inc: [unread_conversation_count: 1]
1278     )
1279     |> where([u], u.id == ^user.id)
1280     |> where([u, p], p.count == 0)
1281     |> select([u], u)
1282     |> Repo.update_all([])
1283     |> case do
1284       {1, [user]} -> set_cache(user)
1285       _ -> {:error, user}
1286     end
1287   end
1288
1289   def increment_unread_conversation_count(_, user), do: {:ok, user}
1290
1291   @spec get_users_from_set([String.t()], keyword()) :: [User.t()]
1292   def get_users_from_set(ap_ids, opts \\ []) do
1293     local_only = Keyword.get(opts, :local_only, true)
1294     criteria = %{ap_id: ap_ids, deactivated: false}
1295     criteria = if local_only, do: Map.put(criteria, :local, true), else: criteria
1296
1297     User.Query.build(criteria)
1298     |> Repo.all()
1299   end
1300
1301   @spec get_recipients_from_activity(Activity.t()) :: [User.t()]
1302   def get_recipients_from_activity(%Activity{recipients: to, actor: actor}) do
1303     to = [actor | to]
1304
1305     query = User.Query.build(%{recipients_from_activity: to, local: true, deactivated: false})
1306
1307     query
1308     |> Repo.all()
1309   end
1310
1311   @spec mute(User.t(), User.t(), boolean()) ::
1312           {:ok, list(UserRelationship.t())} | {:error, String.t()}
1313   def mute(%User{} = muter, %User{} = mutee, notifications? \\ true) do
1314     add_to_mutes(muter, mutee, notifications?)
1315   end
1316
1317   def unmute(%User{} = muter, %User{} = mutee) do
1318     remove_from_mutes(muter, mutee)
1319   end
1320
1321   def subscribe(%User{} = subscriber, %User{} = target) do
1322     deny_follow_blocked = Config.get([:user, :deny_follow_blocked])
1323
1324     if blocks?(target, subscriber) and deny_follow_blocked do
1325       {:error, "Could not subscribe: #{target.nickname} is blocking you"}
1326     else
1327       # Note: the relationship is inverse: subscriber acts as relationship target
1328       UserRelationship.create_inverse_subscription(target, subscriber)
1329     end
1330   end
1331
1332   def subscribe(%User{} = subscriber, %{ap_id: ap_id}) do
1333     with %User{} = subscribee <- get_cached_by_ap_id(ap_id) do
1334       subscribe(subscriber, subscribee)
1335     end
1336   end
1337
1338   def unsubscribe(%User{} = unsubscriber, %User{} = target) do
1339     # Note: the relationship is inverse: subscriber acts as relationship target
1340     UserRelationship.delete_inverse_subscription(target, unsubscriber)
1341   end
1342
1343   def unsubscribe(%User{} = unsubscriber, %{ap_id: ap_id}) do
1344     with %User{} = user <- get_cached_by_ap_id(ap_id) do
1345       unsubscribe(unsubscriber, user)
1346     end
1347   end
1348
1349   def block(%User{} = blocker, %User{} = blocked) do
1350     # sever any follow relationships to prevent leaks per activitypub (Pleroma issue #213)
1351     blocker =
1352       if following?(blocker, blocked) do
1353         {:ok, blocker, _} = unfollow(blocker, blocked)
1354         blocker
1355       else
1356         blocker
1357       end
1358
1359     # clear any requested follows as well
1360     blocked =
1361       case CommonAPI.reject_follow_request(blocked, blocker) do
1362         {:ok, %User{} = updated_blocked} -> updated_blocked
1363         nil -> blocked
1364       end
1365
1366     unsubscribe(blocked, blocker)
1367
1368     unfollowing_blocked = Config.get([:activitypub, :unfollow_blocked], true)
1369     if unfollowing_blocked && following?(blocked, blocker), do: unfollow(blocked, blocker)
1370
1371     {:ok, blocker} = update_follower_count(blocker)
1372     {:ok, blocker, _} = Participation.mark_all_as_read(blocker, blocked)
1373     add_to_block(blocker, blocked)
1374   end
1375
1376   # helper to handle the block given only an actor's AP id
1377   def block(%User{} = blocker, %{ap_id: ap_id}) do
1378     block(blocker, get_cached_by_ap_id(ap_id))
1379   end
1380
1381   def unblock(%User{} = blocker, %User{} = blocked) do
1382     remove_from_block(blocker, blocked)
1383   end
1384
1385   # helper to handle the block given only an actor's AP id
1386   def unblock(%User{} = blocker, %{ap_id: ap_id}) do
1387     unblock(blocker, get_cached_by_ap_id(ap_id))
1388   end
1389
1390   def mutes?(nil, _), do: false
1391   def mutes?(%User{} = user, %User{} = target), do: mutes_user?(user, target)
1392
1393   def mutes_user?(%User{} = user, %User{} = target) do
1394     UserRelationship.mute_exists?(user, target)
1395   end
1396
1397   @spec muted_notifications?(User.t() | nil, User.t() | map()) :: boolean()
1398   def muted_notifications?(nil, _), do: false
1399
1400   def muted_notifications?(%User{} = user, %User{} = target),
1401     do: UserRelationship.notification_mute_exists?(user, target)
1402
1403   def blocks?(nil, _), do: false
1404
1405   def blocks?(%User{} = user, %User{} = target) do
1406     blocks_user?(user, target) ||
1407       (blocks_domain?(user, target) and not User.following?(user, target))
1408   end
1409
1410   def blocks_user?(%User{} = user, %User{} = target) do
1411     UserRelationship.block_exists?(user, target)
1412   end
1413
1414   def blocks_user?(_, _), do: false
1415
1416   def blocks_domain?(%User{} = user, %User{} = target) do
1417     domain_blocks = Pleroma.Web.ActivityPub.MRF.subdomains_regex(user.domain_blocks)
1418     %{host: host} = URI.parse(target.ap_id)
1419     Pleroma.Web.ActivityPub.MRF.subdomain_match?(domain_blocks, host)
1420   end
1421
1422   def blocks_domain?(_, _), do: false
1423
1424   def subscribed_to?(%User{} = user, %User{} = target) do
1425     # Note: the relationship is inverse: subscriber acts as relationship target
1426     UserRelationship.inverse_subscription_exists?(target, user)
1427   end
1428
1429   def subscribed_to?(%User{} = user, %{ap_id: ap_id}) do
1430     with %User{} = target <- get_cached_by_ap_id(ap_id) do
1431       subscribed_to?(user, target)
1432     end
1433   end
1434
1435   @doc """
1436   Returns map of outgoing (blocked, muted etc.) relationships' user AP IDs by relation type.
1437   E.g. `outgoing_relationships_ap_ids(user, [:block])` -> `%{block: ["https://some.site/users/userapid"]}`
1438   """
1439   @spec outgoing_relationships_ap_ids(User.t(), list(atom())) :: %{atom() => list(String.t())}
1440   def outgoing_relationships_ap_ids(_user, []), do: %{}
1441
1442   def outgoing_relationships_ap_ids(nil, _relationship_types), do: %{}
1443
1444   def outgoing_relationships_ap_ids(%User{} = user, relationship_types)
1445       when is_list(relationship_types) do
1446     db_result =
1447       user
1448       |> assoc(:outgoing_relationships)
1449       |> join(:inner, [user_rel], u in assoc(user_rel, :target))
1450       |> where([user_rel, u], user_rel.relationship_type in ^relationship_types)
1451       |> select([user_rel, u], [user_rel.relationship_type, fragment("array_agg(?)", u.ap_id)])
1452       |> group_by([user_rel, u], user_rel.relationship_type)
1453       |> Repo.all()
1454       |> Enum.into(%{}, fn [k, v] -> {k, v} end)
1455
1456     Enum.into(
1457       relationship_types,
1458       %{},
1459       fn rel_type -> {rel_type, db_result[rel_type] || []} end
1460     )
1461   end
1462
1463   def incoming_relationships_ungrouped_ap_ids(user, relationship_types, ap_ids \\ nil)
1464
1465   def incoming_relationships_ungrouped_ap_ids(_user, [], _ap_ids), do: []
1466
1467   def incoming_relationships_ungrouped_ap_ids(nil, _relationship_types, _ap_ids), do: []
1468
1469   def incoming_relationships_ungrouped_ap_ids(%User{} = user, relationship_types, ap_ids)
1470       when is_list(relationship_types) do
1471     user
1472     |> assoc(:incoming_relationships)
1473     |> join(:inner, [user_rel], u in assoc(user_rel, :source))
1474     |> where([user_rel, u], user_rel.relationship_type in ^relationship_types)
1475     |> maybe_filter_on_ap_id(ap_ids)
1476     |> select([user_rel, u], u.ap_id)
1477     |> distinct(true)
1478     |> Repo.all()
1479   end
1480
1481   defp maybe_filter_on_ap_id(query, ap_ids) when is_list(ap_ids) do
1482     where(query, [user_rel, u], u.ap_id in ^ap_ids)
1483   end
1484
1485   defp maybe_filter_on_ap_id(query, _ap_ids), do: query
1486
1487   def deactivate_async(user, status \\ true) do
1488     BackgroundWorker.enqueue("deactivate_user", %{"user_id" => user.id, "status" => status})
1489   end
1490
1491   def deactivate(user, status \\ true)
1492
1493   def deactivate(users, status) when is_list(users) do
1494     Repo.transaction(fn ->
1495       for user <- users, do: deactivate(user, status)
1496     end)
1497   end
1498
1499   def deactivate(%User{} = user, status) do
1500     with {:ok, user} <- set_activation_status(user, status) do
1501       user
1502       |> get_followers()
1503       |> Enum.filter(& &1.local)
1504       |> Enum.each(&set_cache(update_following_count(&1)))
1505
1506       # Only update local user counts, remote will be update during the next pull.
1507       user
1508       |> get_friends()
1509       |> Enum.filter(& &1.local)
1510       |> Enum.each(&do_unfollow(user, &1))
1511
1512       {:ok, user}
1513     end
1514   end
1515
1516   def approve(users) when is_list(users) do
1517     Repo.transaction(fn ->
1518       Enum.map(users, fn user ->
1519         with {:ok, user} <- approve(user), do: user
1520       end)
1521     end)
1522   end
1523
1524   def approve(%User{} = user) do
1525     change(user, approval_pending: false)
1526     |> update_and_set_cache()
1527   end
1528
1529   def update_notification_settings(%User{} = user, settings) do
1530     user
1531     |> cast(%{notification_settings: settings}, [])
1532     |> cast_embed(:notification_settings)
1533     |> validate_required([:notification_settings])
1534     |> update_and_set_cache()
1535   end
1536
1537   def delete(users) when is_list(users) do
1538     for user <- users, do: delete(user)
1539   end
1540
1541   def delete(%User{} = user) do
1542     BackgroundWorker.enqueue("delete_user", %{"user_id" => user.id})
1543   end
1544
1545   defp delete_and_invalidate_cache(%User{} = user) do
1546     invalidate_cache(user)
1547     Repo.delete(user)
1548   end
1549
1550   defp delete_or_deactivate(%User{local: false} = user), do: delete_and_invalidate_cache(user)
1551
1552   defp delete_or_deactivate(%User{local: true} = user) do
1553     status = account_status(user)
1554
1555     case status do
1556       :confirmation_pending -> delete_and_invalidate_cache(user)
1557       :approval_pending -> delete_and_invalidate_cache(user)
1558       _ ->
1559         user
1560         |> change(%{deactivated: true, email: nil})
1561         |> update_and_set_cache()
1562     end
1563   end
1564
1565   def perform(:force_password_reset, user), do: force_password_reset(user)
1566
1567   @spec perform(atom(), User.t()) :: {:ok, User.t()}
1568   def perform(:delete, %User{} = user) do
1569     # Remove all relationships
1570     user
1571     |> get_followers()
1572     |> Enum.each(fn follower ->
1573       ActivityPub.unfollow(follower, user)
1574       unfollow(follower, user)
1575     end)
1576
1577     user
1578     |> get_friends()
1579     |> Enum.each(fn followed ->
1580       ActivityPub.unfollow(user, followed)
1581       unfollow(user, followed)
1582     end)
1583
1584     delete_user_activities(user)
1585     delete_notifications_from_user_activities(user)
1586
1587     delete_outgoing_pending_follow_requests(user)
1588
1589     delete_or_deactivate(user)
1590   end
1591
1592   def perform(:deactivate_async, user, status), do: deactivate(user, status)
1593
1594   @spec perform(atom(), User.t(), list()) :: list() | {:error, any()}
1595   def perform(:blocks_import, %User{} = blocker, blocked_identifiers)
1596       when is_list(blocked_identifiers) do
1597     Enum.map(
1598       blocked_identifiers,
1599       fn blocked_identifier ->
1600         with {:ok, %User{} = blocked} <- get_or_fetch(blocked_identifier),
1601              {:ok, _block} <- CommonAPI.block(blocker, blocked) do
1602           blocked
1603         else
1604           err ->
1605             Logger.debug("blocks_import failed for #{blocked_identifier} with: #{inspect(err)}")
1606             err
1607         end
1608       end
1609     )
1610   end
1611
1612   def perform(:follow_import, %User{} = follower, followed_identifiers)
1613       when is_list(followed_identifiers) do
1614     Enum.map(
1615       followed_identifiers,
1616       fn followed_identifier ->
1617         with {:ok, %User{} = followed} <- get_or_fetch(followed_identifier),
1618              {:ok, follower} <- maybe_direct_follow(follower, followed),
1619              {:ok, _, _, _} <- CommonAPI.follow(follower, followed) do
1620           followed
1621         else
1622           err ->
1623             Logger.debug("follow_import failed for #{followed_identifier} with: #{inspect(err)}")
1624             err
1625         end
1626       end
1627     )
1628   end
1629
1630   @spec external_users_query() :: Ecto.Query.t()
1631   def external_users_query do
1632     User.Query.build(%{
1633       external: true,
1634       active: true,
1635       order_by: :id
1636     })
1637   end
1638
1639   @spec external_users(keyword()) :: [User.t()]
1640   def external_users(opts \\ []) do
1641     query =
1642       external_users_query()
1643       |> select([u], struct(u, [:id, :ap_id]))
1644
1645     query =
1646       if opts[:max_id],
1647         do: where(query, [u], u.id > ^opts[:max_id]),
1648         else: query
1649
1650     query =
1651       if opts[:limit],
1652         do: limit(query, ^opts[:limit]),
1653         else: query
1654
1655     Repo.all(query)
1656   end
1657
1658   def blocks_import(%User{} = blocker, blocked_identifiers) when is_list(blocked_identifiers) do
1659     BackgroundWorker.enqueue("blocks_import", %{
1660       "blocker_id" => blocker.id,
1661       "blocked_identifiers" => blocked_identifiers
1662     })
1663   end
1664
1665   def follow_import(%User{} = follower, followed_identifiers)
1666       when is_list(followed_identifiers) do
1667     BackgroundWorker.enqueue("follow_import", %{
1668       "follower_id" => follower.id,
1669       "followed_identifiers" => followed_identifiers
1670     })
1671   end
1672
1673   def delete_notifications_from_user_activities(%User{ap_id: ap_id}) do
1674     Notification
1675     |> join(:inner, [n], activity in assoc(n, :activity))
1676     |> where([n, a], fragment("? = ?", a.actor, ^ap_id))
1677     |> Repo.delete_all()
1678   end
1679
1680   def delete_user_activities(%User{ap_id: ap_id} = user) do
1681     ap_id
1682     |> Activity.Queries.by_actor()
1683     |> RepoStreamer.chunk_stream(50)
1684     |> Stream.each(fn activities ->
1685       Enum.each(activities, fn activity -> delete_activity(activity, user) end)
1686     end)
1687     |> Stream.run()
1688   end
1689
1690   defp delete_activity(%{data: %{"type" => "Create", "object" => object}} = activity, user) do
1691     with {_, %Object{}} <- {:find_object, Object.get_by_ap_id(object)},
1692          {:ok, delete_data, _} <- Builder.delete(user, object) do
1693       Pipeline.common_pipeline(delete_data, local: user.local)
1694     else
1695       {:find_object, nil} ->
1696         # We have the create activity, but not the object, it was probably pruned.
1697         # Insert a tombstone and try again
1698         with {:ok, tombstone_data, _} <- Builder.tombstone(user.ap_id, object),
1699              {:ok, _tombstone} <- Object.create(tombstone_data) do
1700           delete_activity(activity, user)
1701         end
1702
1703       e ->
1704         Logger.error("Could not delete #{object} created by #{activity.data["ap_id"]}")
1705         Logger.error("Error: #{inspect(e)}")
1706     end
1707   end
1708
1709   defp delete_activity(%{data: %{"type" => type}} = activity, user)
1710        when type in ["Like", "Announce"] do
1711     {:ok, undo, _} = Builder.undo(user, activity)
1712     Pipeline.common_pipeline(undo, local: user.local)
1713   end
1714
1715   defp delete_activity(_activity, _user), do: "Doing nothing"
1716
1717   defp delete_outgoing_pending_follow_requests(user) do
1718     user
1719     |> FollowingRelationship.outgoing_pending_follow_requests_query()
1720     |> Repo.delete_all()
1721   end
1722
1723   def html_filter_policy(%User{no_rich_text: true}) do
1724     Pleroma.HTML.Scrubber.TwitterText
1725   end
1726
1727   def html_filter_policy(_), do: Config.get([:markup, :scrub_policy])
1728
1729   def fetch_by_ap_id(ap_id), do: ActivityPub.make_user_from_ap_id(ap_id)
1730
1731   def get_or_fetch_by_ap_id(ap_id) do
1732     cached_user = get_cached_by_ap_id(ap_id)
1733
1734     maybe_fetched_user = needs_update?(cached_user) && fetch_by_ap_id(ap_id)
1735
1736     case {cached_user, maybe_fetched_user} do
1737       {_, {:ok, %User{} = user}} ->
1738         {:ok, user}
1739
1740       {%User{} = user, _} ->
1741         {:ok, user}
1742
1743       _ ->
1744         {:error, :not_found}
1745     end
1746   end
1747
1748   @doc """
1749   Creates an internal service actor by URI if missing.
1750   Optionally takes nickname for addressing.
1751   """
1752   @spec get_or_create_service_actor_by_ap_id(String.t(), String.t()) :: User.t() | nil
1753   def get_or_create_service_actor_by_ap_id(uri, nickname) do
1754     {_, user} =
1755       case get_cached_by_ap_id(uri) do
1756         nil ->
1757           with {:error, %{errors: errors}} <- create_service_actor(uri, nickname) do
1758             Logger.error("Cannot create service actor: #{uri}/.\n#{inspect(errors)}")
1759             {:error, nil}
1760           end
1761
1762         %User{invisible: false} = user ->
1763           set_invisible(user)
1764
1765         user ->
1766           {:ok, user}
1767       end
1768
1769     user
1770   end
1771
1772   @spec set_invisible(User.t()) :: {:ok, User.t()}
1773   defp set_invisible(user) do
1774     user
1775     |> change(%{invisible: true})
1776     |> update_and_set_cache()
1777   end
1778
1779   @spec create_service_actor(String.t(), String.t()) ::
1780           {:ok, User.t()} | {:error, Ecto.Changeset.t()}
1781   defp create_service_actor(uri, nickname) do
1782     %User{
1783       invisible: true,
1784       local: true,
1785       ap_id: uri,
1786       nickname: nickname,
1787       follower_address: uri <> "/followers"
1788     }
1789     |> change
1790     |> unique_constraint(:nickname)
1791     |> Repo.insert()
1792     |> set_cache()
1793   end
1794
1795   def public_key(%{public_key: public_key_pem}) when is_binary(public_key_pem) do
1796     key =
1797       public_key_pem
1798       |> :public_key.pem_decode()
1799       |> hd()
1800       |> :public_key.pem_entry_decode()
1801
1802     {:ok, key}
1803   end
1804
1805   def public_key(_), do: {:error, "key not found"}
1806
1807   def get_public_key_for_ap_id(ap_id) do
1808     with {:ok, %User{} = user} <- get_or_fetch_by_ap_id(ap_id),
1809          {:ok, public_key} <- public_key(user) do
1810       {:ok, public_key}
1811     else
1812       _ -> :error
1813     end
1814   end
1815
1816   def ap_enabled?(%User{local: true}), do: true
1817   def ap_enabled?(%User{ap_enabled: ap_enabled}), do: ap_enabled
1818   def ap_enabled?(_), do: false
1819
1820   @doc "Gets or fetch a user by uri or nickname."
1821   @spec get_or_fetch(String.t()) :: {:ok, User.t()} | {:error, String.t()}
1822   def get_or_fetch("http" <> _host = uri), do: get_or_fetch_by_ap_id(uri)
1823   def get_or_fetch(nickname), do: get_or_fetch_by_nickname(nickname)
1824
1825   # wait a period of time and return newest version of the User structs
1826   # this is because we have synchronous follow APIs and need to simulate them
1827   # with an async handshake
1828   def wait_and_refresh(_, %User{local: true} = a, %User{local: true} = b) do
1829     with %User{} = a <- get_cached_by_id(a.id),
1830          %User{} = b <- get_cached_by_id(b.id) do
1831       {:ok, a, b}
1832     else
1833       nil -> :error
1834     end
1835   end
1836
1837   def wait_and_refresh(timeout, %User{} = a, %User{} = b) do
1838     with :ok <- :timer.sleep(timeout),
1839          %User{} = a <- get_cached_by_id(a.id),
1840          %User{} = b <- get_cached_by_id(b.id) do
1841       {:ok, a, b}
1842     else
1843       nil -> :error
1844     end
1845   end
1846
1847   def parse_bio(bio) when is_binary(bio) and bio != "" do
1848     bio
1849     |> CommonUtils.format_input("text/plain", mentions_format: :full)
1850     |> elem(0)
1851   end
1852
1853   def parse_bio(_), do: ""
1854
1855   def parse_bio(bio, user) when is_binary(bio) and bio != "" do
1856     # TODO: get profile URLs other than user.ap_id
1857     profile_urls = [user.ap_id]
1858
1859     bio
1860     |> CommonUtils.format_input("text/plain",
1861       mentions_format: :full,
1862       rel: &RelMe.maybe_put_rel_me(&1, profile_urls)
1863     )
1864     |> elem(0)
1865   end
1866
1867   def parse_bio(_, _), do: ""
1868
1869   def tag(user_identifiers, tags) when is_list(user_identifiers) do
1870     Repo.transaction(fn ->
1871       for user_identifier <- user_identifiers, do: tag(user_identifier, tags)
1872     end)
1873   end
1874
1875   def tag(nickname, tags) when is_binary(nickname),
1876     do: tag(get_by_nickname(nickname), tags)
1877
1878   def tag(%User{} = user, tags),
1879     do: update_tags(user, Enum.uniq((user.tags || []) ++ normalize_tags(tags)))
1880
1881   def untag(user_identifiers, tags) when is_list(user_identifiers) do
1882     Repo.transaction(fn ->
1883       for user_identifier <- user_identifiers, do: untag(user_identifier, tags)
1884     end)
1885   end
1886
1887   def untag(nickname, tags) when is_binary(nickname),
1888     do: untag(get_by_nickname(nickname), tags)
1889
1890   def untag(%User{} = user, tags),
1891     do: update_tags(user, (user.tags || []) -- normalize_tags(tags))
1892
1893   defp update_tags(%User{} = user, new_tags) do
1894     {:ok, updated_user} =
1895       user
1896       |> change(%{tags: new_tags})
1897       |> update_and_set_cache()
1898
1899     updated_user
1900   end
1901
1902   defp normalize_tags(tags) do
1903     [tags]
1904     |> List.flatten()
1905     |> Enum.map(&String.downcase/1)
1906   end
1907
1908   defp local_nickname_regex do
1909     if Config.get([:instance, :extended_nickname_format]) do
1910       @extended_local_nickname_regex
1911     else
1912       @strict_local_nickname_regex
1913     end
1914   end
1915
1916   def local_nickname(nickname_or_mention) do
1917     nickname_or_mention
1918     |> full_nickname()
1919     |> String.split("@")
1920     |> hd()
1921   end
1922
1923   def full_nickname(nickname_or_mention),
1924     do: String.trim_leading(nickname_or_mention, "@")
1925
1926   def error_user(ap_id) do
1927     %User{
1928       name: ap_id,
1929       ap_id: ap_id,
1930       nickname: "erroruser@example.com",
1931       inserted_at: NaiveDateTime.utc_now()
1932     }
1933   end
1934
1935   @spec all_superusers() :: [User.t()]
1936   def all_superusers do
1937     User.Query.build(%{super_users: true, local: true, deactivated: false})
1938     |> Repo.all()
1939   end
1940
1941   def muting_reblogs?(%User{} = user, %User{} = target) do
1942     UserRelationship.reblog_mute_exists?(user, target)
1943   end
1944
1945   def showing_reblogs?(%User{} = user, %User{} = target) do
1946     not muting_reblogs?(user, target)
1947   end
1948
1949   @doc """
1950   The function returns a query to get users with no activity for given interval of days.
1951   Inactive users are those who didn't read any notification, or had any activity where
1952   the user is the activity's actor, during `inactivity_threshold` days.
1953   Deactivated users will not appear in this list.
1954
1955   ## Examples
1956
1957       iex> Pleroma.User.list_inactive_users()
1958       %Ecto.Query{}
1959   """
1960   @spec list_inactive_users_query(integer()) :: Ecto.Query.t()
1961   def list_inactive_users_query(inactivity_threshold \\ 7) do
1962     negative_inactivity_threshold = -inactivity_threshold
1963     now = NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
1964     # Subqueries are not supported in `where` clauses, join gets too complicated.
1965     has_read_notifications =
1966       from(n in Pleroma.Notification,
1967         where: n.seen == true,
1968         group_by: n.id,
1969         having: max(n.updated_at) > datetime_add(^now, ^negative_inactivity_threshold, "day"),
1970         select: n.user_id
1971       )
1972       |> Pleroma.Repo.all()
1973
1974     from(u in Pleroma.User,
1975       left_join: a in Pleroma.Activity,
1976       on: u.ap_id == a.actor,
1977       where: not is_nil(u.nickname),
1978       where: u.deactivated != ^true,
1979       where: u.id not in ^has_read_notifications,
1980       group_by: u.id,
1981       having:
1982         max(a.inserted_at) < datetime_add(^now, ^negative_inactivity_threshold, "day") or
1983           is_nil(max(a.inserted_at))
1984     )
1985   end
1986
1987   @doc """
1988   Enable or disable email notifications for user
1989
1990   ## Examples
1991
1992       iex> Pleroma.User.switch_email_notifications(Pleroma.User{email_notifications: %{"digest" => false}}, "digest", true)
1993       Pleroma.User{email_notifications: %{"digest" => true}}
1994
1995       iex> Pleroma.User.switch_email_notifications(Pleroma.User{email_notifications: %{"digest" => true}}, "digest", false)
1996       Pleroma.User{email_notifications: %{"digest" => false}}
1997   """
1998   @spec switch_email_notifications(t(), String.t(), boolean()) ::
1999           {:ok, t()} | {:error, Ecto.Changeset.t()}
2000   def switch_email_notifications(user, type, status) do
2001     User.update_email_notifications(user, %{type => status})
2002   end
2003
2004   @doc """
2005   Set `last_digest_emailed_at` value for the user to current time
2006   """
2007   @spec touch_last_digest_emailed_at(t()) :: t()
2008   def touch_last_digest_emailed_at(user) do
2009     now = NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
2010
2011     {:ok, updated_user} =
2012       user
2013       |> change(%{last_digest_emailed_at: now})
2014       |> update_and_set_cache()
2015
2016     updated_user
2017   end
2018
2019   @spec toggle_confirmation(User.t()) :: {:ok, User.t()} | {:error, Changeset.t()}
2020   def toggle_confirmation(%User{} = user) do
2021     user
2022     |> confirmation_changeset(need_confirmation: !user.confirmation_pending)
2023     |> update_and_set_cache()
2024   end
2025
2026   @spec toggle_confirmation([User.t()]) :: [{:ok, User.t()} | {:error, Changeset.t()}]
2027   def toggle_confirmation(users) do
2028     Enum.map(users, &toggle_confirmation/1)
2029   end
2030
2031   def get_mascot(%{mascot: %{} = mascot}) when not is_nil(mascot) do
2032     mascot
2033   end
2034
2035   def get_mascot(%{mascot: mascot}) when is_nil(mascot) do
2036     # use instance-default
2037     config = Config.get([:assets, :mascots])
2038     default_mascot = Config.get([:assets, :default_mascot])
2039     mascot = Keyword.get(config, default_mascot)
2040
2041     %{
2042       "id" => "default-mascot",
2043       "url" => mascot[:url],
2044       "preview_url" => mascot[:url],
2045       "pleroma" => %{
2046         "mime_type" => mascot[:mime_type]
2047       }
2048     }
2049   end
2050
2051   def ensure_keys_present(%{keys: keys} = user) when not is_nil(keys), do: {:ok, user}
2052
2053   def ensure_keys_present(%User{} = user) do
2054     with {:ok, pem} <- Keys.generate_rsa_pem() do
2055       user
2056       |> cast(%{keys: pem}, [:keys])
2057       |> validate_required([:keys])
2058       |> update_and_set_cache()
2059     end
2060   end
2061
2062   def get_ap_ids_by_nicknames(nicknames) do
2063     from(u in User,
2064       where: u.nickname in ^nicknames,
2065       select: u.ap_id
2066     )
2067     |> Repo.all()
2068   end
2069
2070   defdelegate search(query, opts \\ []), to: User.Search
2071
2072   defp put_password_hash(
2073          %Ecto.Changeset{valid?: true, changes: %{password: password}} = changeset
2074        ) do
2075     change(changeset, password_hash: Pbkdf2.hash_pwd_salt(password))
2076   end
2077
2078   defp put_password_hash(changeset), do: changeset
2079
2080   def is_internal_user?(%User{nickname: nil}), do: true
2081   def is_internal_user?(%User{local: true, nickname: "internal." <> _}), do: true
2082   def is_internal_user?(_), do: false
2083
2084   # A hack because user delete activities have a fake id for whatever reason
2085   # TODO: Get rid of this
2086   def get_delivered_users_by_object_id("pleroma:fake_object_id"), do: []
2087
2088   def get_delivered_users_by_object_id(object_id) do
2089     from(u in User,
2090       inner_join: delivery in assoc(u, :deliveries),
2091       where: delivery.object_id == ^object_id
2092     )
2093     |> Repo.all()
2094   end
2095
2096   def change_email(user, email) do
2097     user
2098     |> cast(%{email: email}, [:email])
2099     |> validate_required([:email])
2100     |> unique_constraint(:email)
2101     |> validate_format(:email, @email_regex)
2102     |> update_and_set_cache()
2103   end
2104
2105   # Internal function; public one is `deactivate/2`
2106   defp set_activation_status(user, deactivated) do
2107     user
2108     |> cast(%{deactivated: deactivated}, [:deactivated])
2109     |> update_and_set_cache()
2110   end
2111
2112   def update_banner(user, banner) do
2113     user
2114     |> cast(%{banner: banner}, [:banner])
2115     |> update_and_set_cache()
2116   end
2117
2118   def update_background(user, background) do
2119     user
2120     |> cast(%{background: background}, [:background])
2121     |> update_and_set_cache()
2122   end
2123
2124   def roles(%{is_moderator: is_moderator, is_admin: is_admin}) do
2125     %{
2126       admin: is_admin,
2127       moderator: is_moderator
2128     }
2129   end
2130
2131   def validate_fields(changeset, remote? \\ false) do
2132     limit_name = if remote?, do: :max_remote_account_fields, else: :max_account_fields
2133     limit = Config.get([:instance, limit_name], 0)
2134
2135     changeset
2136     |> validate_length(:fields, max: limit)
2137     |> validate_change(:fields, fn :fields, fields ->
2138       if Enum.all?(fields, &valid_field?/1) do
2139         []
2140       else
2141         [fields: "invalid"]
2142       end
2143     end)
2144   end
2145
2146   defp valid_field?(%{"name" => name, "value" => value}) do
2147     name_limit = Config.get([:instance, :account_field_name_length], 255)
2148     value_limit = Config.get([:instance, :account_field_value_length], 255)
2149
2150     is_binary(name) && is_binary(value) && String.length(name) <= name_limit &&
2151       String.length(value) <= value_limit
2152   end
2153
2154   defp valid_field?(_), do: false
2155
2156   defp truncate_field(%{"name" => name, "value" => value}) do
2157     {name, _chopped} =
2158       String.split_at(name, Config.get([:instance, :account_field_name_length], 255))
2159
2160     {value, _chopped} =
2161       String.split_at(value, Config.get([:instance, :account_field_value_length], 255))
2162
2163     %{"name" => name, "value" => value}
2164   end
2165
2166   def admin_api_update(user, params) do
2167     user
2168     |> cast(params, [
2169       :is_moderator,
2170       :is_admin,
2171       :show_role
2172     ])
2173     |> update_and_set_cache()
2174   end
2175
2176   @doc "Signs user out of all applications"
2177   def global_sign_out(user) do
2178     OAuth.Authorization.delete_user_authorizations(user)
2179     OAuth.Token.delete_user_tokens(user)
2180   end
2181
2182   def mascot_update(user, url) do
2183     user
2184     |> cast(%{mascot: url}, [:mascot])
2185     |> validate_required([:mascot])
2186     |> update_and_set_cache()
2187   end
2188
2189   def mastodon_settings_update(user, settings) do
2190     user
2191     |> cast(%{mastofe_settings: settings}, [:mastofe_settings])
2192     |> validate_required([:mastofe_settings])
2193     |> update_and_set_cache()
2194   end
2195
2196   @spec confirmation_changeset(User.t(), keyword()) :: Changeset.t()
2197   def confirmation_changeset(user, need_confirmation: need_confirmation?) do
2198     params =
2199       if need_confirmation? do
2200         %{
2201           confirmation_pending: true,
2202           confirmation_token: :crypto.strong_rand_bytes(32) |> Base.url_encode64()
2203         }
2204       else
2205         %{
2206           confirmation_pending: false,
2207           confirmation_token: nil
2208         }
2209       end
2210
2211     cast(user, params, [:confirmation_pending, :confirmation_token])
2212   end
2213
2214   @spec approval_changeset(User.t(), keyword()) :: Changeset.t()
2215   def approval_changeset(user, need_approval: need_approval?) do
2216     params = if need_approval?, do: %{approval_pending: true}, else: %{approval_pending: false}
2217     cast(user, params, [:approval_pending])
2218   end
2219
2220   def add_pinnned_activity(user, %Pleroma.Activity{id: id}) do
2221     if id not in user.pinned_activities do
2222       max_pinned_statuses = Config.get([:instance, :max_pinned_statuses], 0)
2223       params = %{pinned_activities: user.pinned_activities ++ [id]}
2224
2225       user
2226       |> cast(params, [:pinned_activities])
2227       |> validate_length(:pinned_activities,
2228         max: max_pinned_statuses,
2229         message: "You have already pinned the maximum number of statuses"
2230       )
2231     else
2232       change(user)
2233     end
2234     |> update_and_set_cache()
2235   end
2236
2237   def remove_pinnned_activity(user, %Pleroma.Activity{id: id}) do
2238     params = %{pinned_activities: List.delete(user.pinned_activities, id)}
2239
2240     user
2241     |> cast(params, [:pinned_activities])
2242     |> update_and_set_cache()
2243   end
2244
2245   def update_email_notifications(user, settings) do
2246     email_notifications =
2247       user.email_notifications
2248       |> Map.merge(settings)
2249       |> Map.take(["digest"])
2250
2251     params = %{email_notifications: email_notifications}
2252     fields = [:email_notifications]
2253
2254     user
2255     |> cast(params, fields)
2256     |> validate_required(fields)
2257     |> update_and_set_cache()
2258   end
2259
2260   defp set_domain_blocks(user, domain_blocks) do
2261     params = %{domain_blocks: domain_blocks}
2262
2263     user
2264     |> cast(params, [:domain_blocks])
2265     |> validate_required([:domain_blocks])
2266     |> update_and_set_cache()
2267   end
2268
2269   def block_domain(user, domain_blocked) do
2270     set_domain_blocks(user, Enum.uniq([domain_blocked | user.domain_blocks]))
2271   end
2272
2273   def unblock_domain(user, domain_blocked) do
2274     set_domain_blocks(user, List.delete(user.domain_blocks, domain_blocked))
2275   end
2276
2277   @spec add_to_block(User.t(), User.t()) ::
2278           {:ok, UserRelationship.t()} | {:error, Ecto.Changeset.t()}
2279   defp add_to_block(%User{} = user, %User{} = blocked) do
2280     UserRelationship.create_block(user, blocked)
2281   end
2282
2283   @spec add_to_block(User.t(), User.t()) ::
2284           {:ok, UserRelationship.t()} | {:ok, nil} | {:error, Ecto.Changeset.t()}
2285   defp remove_from_block(%User{} = user, %User{} = blocked) do
2286     UserRelationship.delete_block(user, blocked)
2287   end
2288
2289   defp add_to_mutes(%User{} = user, %User{} = muted_user, notifications?) do
2290     with {:ok, user_mute} <- UserRelationship.create_mute(user, muted_user),
2291          {:ok, user_notification_mute} <-
2292            (notifications? && UserRelationship.create_notification_mute(user, muted_user)) ||
2293              {:ok, nil} do
2294       {:ok, Enum.filter([user_mute, user_notification_mute], & &1)}
2295     end
2296   end
2297
2298   defp remove_from_mutes(user, %User{} = muted_user) do
2299     with {:ok, user_mute} <- UserRelationship.delete_mute(user, muted_user),
2300          {:ok, user_notification_mute} <-
2301            UserRelationship.delete_notification_mute(user, muted_user) do
2302       {:ok, [user_mute, user_notification_mute]}
2303     end
2304   end
2305
2306   def set_invisible(user, invisible) do
2307     params = %{invisible: invisible}
2308
2309     user
2310     |> cast(params, [:invisible])
2311     |> validate_required([:invisible])
2312     |> update_and_set_cache()
2313   end
2314
2315   def sanitize_html(%User{} = user) do
2316     sanitize_html(user, nil)
2317   end
2318
2319   # User data that mastodon isn't filtering (treated as plaintext):
2320   # - field name
2321   # - display name
2322   def sanitize_html(%User{} = user, filter) do
2323     fields =
2324       Enum.map(user.fields, fn %{"name" => name, "value" => value} ->
2325         %{
2326           "name" => name,
2327           "value" => HTML.filter_tags(value, Pleroma.HTML.Scrubber.LinksOnly)
2328         }
2329       end)
2330
2331     user
2332     |> Map.put(:bio, HTML.filter_tags(user.bio, filter))
2333     |> Map.put(:fields, fields)
2334   end
2335 end