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 ->
1557         delete_and_invalidate_cache(user)
1558
1559       :approval_pending ->
1560         delete_and_invalidate_cache(user)
1561
1562       _ ->
1563         user
1564         |> change(%{deactivated: true, email: nil})
1565         |> update_and_set_cache()
1566     end
1567   end
1568
1569   def perform(:force_password_reset, user), do: force_password_reset(user)
1570
1571   @spec perform(atom(), User.t()) :: {:ok, User.t()}
1572   def perform(:delete, %User{} = user) do
1573     # Remove all relationships
1574     user
1575     |> get_followers()
1576     |> Enum.each(fn follower ->
1577       ActivityPub.unfollow(follower, user)
1578       unfollow(follower, user)
1579     end)
1580
1581     user
1582     |> get_friends()
1583     |> Enum.each(fn followed ->
1584       ActivityPub.unfollow(user, followed)
1585       unfollow(user, followed)
1586     end)
1587
1588     delete_user_activities(user)
1589     delete_notifications_from_user_activities(user)
1590
1591     delete_outgoing_pending_follow_requests(user)
1592
1593     delete_or_deactivate(user)
1594   end
1595
1596   def perform(:deactivate_async, user, status), do: deactivate(user, status)
1597
1598   @spec perform(atom(), User.t(), list()) :: list() | {:error, any()}
1599   def perform(:blocks_import, %User{} = blocker, blocked_identifiers)
1600       when is_list(blocked_identifiers) do
1601     Enum.map(
1602       blocked_identifiers,
1603       fn blocked_identifier ->
1604         with {:ok, %User{} = blocked} <- get_or_fetch(blocked_identifier),
1605              {:ok, _block} <- CommonAPI.block(blocker, blocked) do
1606           blocked
1607         else
1608           err ->
1609             Logger.debug("blocks_import failed for #{blocked_identifier} with: #{inspect(err)}")
1610             err
1611         end
1612       end
1613     )
1614   end
1615
1616   def perform(:follow_import, %User{} = follower, followed_identifiers)
1617       when is_list(followed_identifiers) do
1618     Enum.map(
1619       followed_identifiers,
1620       fn followed_identifier ->
1621         with {:ok, %User{} = followed} <- get_or_fetch(followed_identifier),
1622              {:ok, follower} <- maybe_direct_follow(follower, followed),
1623              {:ok, _, _, _} <- CommonAPI.follow(follower, followed) do
1624           followed
1625         else
1626           err ->
1627             Logger.debug("follow_import failed for #{followed_identifier} with: #{inspect(err)}")
1628             err
1629         end
1630       end
1631     )
1632   end
1633
1634   @spec external_users_query() :: Ecto.Query.t()
1635   def external_users_query do
1636     User.Query.build(%{
1637       external: true,
1638       active: true,
1639       order_by: :id
1640     })
1641   end
1642
1643   @spec external_users(keyword()) :: [User.t()]
1644   def external_users(opts \\ []) do
1645     query =
1646       external_users_query()
1647       |> select([u], struct(u, [:id, :ap_id]))
1648
1649     query =
1650       if opts[:max_id],
1651         do: where(query, [u], u.id > ^opts[:max_id]),
1652         else: query
1653
1654     query =
1655       if opts[:limit],
1656         do: limit(query, ^opts[:limit]),
1657         else: query
1658
1659     Repo.all(query)
1660   end
1661
1662   def blocks_import(%User{} = blocker, blocked_identifiers) when is_list(blocked_identifiers) do
1663     BackgroundWorker.enqueue("blocks_import", %{
1664       "blocker_id" => blocker.id,
1665       "blocked_identifiers" => blocked_identifiers
1666     })
1667   end
1668
1669   def follow_import(%User{} = follower, followed_identifiers)
1670       when is_list(followed_identifiers) do
1671     BackgroundWorker.enqueue("follow_import", %{
1672       "follower_id" => follower.id,
1673       "followed_identifiers" => followed_identifiers
1674     })
1675   end
1676
1677   def delete_notifications_from_user_activities(%User{ap_id: ap_id}) do
1678     Notification
1679     |> join(:inner, [n], activity in assoc(n, :activity))
1680     |> where([n, a], fragment("? = ?", a.actor, ^ap_id))
1681     |> Repo.delete_all()
1682   end
1683
1684   def delete_user_activities(%User{ap_id: ap_id} = user) do
1685     ap_id
1686     |> Activity.Queries.by_actor()
1687     |> RepoStreamer.chunk_stream(50)
1688     |> Stream.each(fn activities ->
1689       Enum.each(activities, fn activity -> delete_activity(activity, user) end)
1690     end)
1691     |> Stream.run()
1692   end
1693
1694   defp delete_activity(%{data: %{"type" => "Create", "object" => object}} = activity, user) do
1695     with {_, %Object{}} <- {:find_object, Object.get_by_ap_id(object)},
1696          {:ok, delete_data, _} <- Builder.delete(user, object) do
1697       Pipeline.common_pipeline(delete_data, local: user.local)
1698     else
1699       {:find_object, nil} ->
1700         # We have the create activity, but not the object, it was probably pruned.
1701         # Insert a tombstone and try again
1702         with {:ok, tombstone_data, _} <- Builder.tombstone(user.ap_id, object),
1703              {:ok, _tombstone} <- Object.create(tombstone_data) do
1704           delete_activity(activity, user)
1705         end
1706
1707       e ->
1708         Logger.error("Could not delete #{object} created by #{activity.data["ap_id"]}")
1709         Logger.error("Error: #{inspect(e)}")
1710     end
1711   end
1712
1713   defp delete_activity(%{data: %{"type" => type}} = activity, user)
1714        when type in ["Like", "Announce"] do
1715     {:ok, undo, _} = Builder.undo(user, activity)
1716     Pipeline.common_pipeline(undo, local: user.local)
1717   end
1718
1719   defp delete_activity(_activity, _user), do: "Doing nothing"
1720
1721   defp delete_outgoing_pending_follow_requests(user) do
1722     user
1723     |> FollowingRelationship.outgoing_pending_follow_requests_query()
1724     |> Repo.delete_all()
1725   end
1726
1727   def html_filter_policy(%User{no_rich_text: true}) do
1728     Pleroma.HTML.Scrubber.TwitterText
1729   end
1730
1731   def html_filter_policy(_), do: Config.get([:markup, :scrub_policy])
1732
1733   def fetch_by_ap_id(ap_id), do: ActivityPub.make_user_from_ap_id(ap_id)
1734
1735   def get_or_fetch_by_ap_id(ap_id) do
1736     cached_user = get_cached_by_ap_id(ap_id)
1737
1738     maybe_fetched_user = needs_update?(cached_user) && fetch_by_ap_id(ap_id)
1739
1740     case {cached_user, maybe_fetched_user} do
1741       {_, {:ok, %User{} = user}} ->
1742         {:ok, user}
1743
1744       {%User{} = user, _} ->
1745         {:ok, user}
1746
1747       _ ->
1748         {:error, :not_found}
1749     end
1750   end
1751
1752   @doc """
1753   Creates an internal service actor by URI if missing.
1754   Optionally takes nickname for addressing.
1755   """
1756   @spec get_or_create_service_actor_by_ap_id(String.t(), String.t()) :: User.t() | nil
1757   def get_or_create_service_actor_by_ap_id(uri, nickname) do
1758     {_, user} =
1759       case get_cached_by_ap_id(uri) do
1760         nil ->
1761           with {:error, %{errors: errors}} <- create_service_actor(uri, nickname) do
1762             Logger.error("Cannot create service actor: #{uri}/.\n#{inspect(errors)}")
1763             {:error, nil}
1764           end
1765
1766         %User{invisible: false} = user ->
1767           set_invisible(user)
1768
1769         user ->
1770           {:ok, user}
1771       end
1772
1773     user
1774   end
1775
1776   @spec set_invisible(User.t()) :: {:ok, User.t()}
1777   defp set_invisible(user) do
1778     user
1779     |> change(%{invisible: true})
1780     |> update_and_set_cache()
1781   end
1782
1783   @spec create_service_actor(String.t(), String.t()) ::
1784           {:ok, User.t()} | {:error, Ecto.Changeset.t()}
1785   defp create_service_actor(uri, nickname) do
1786     %User{
1787       invisible: true,
1788       local: true,
1789       ap_id: uri,
1790       nickname: nickname,
1791       follower_address: uri <> "/followers"
1792     }
1793     |> change
1794     |> unique_constraint(:nickname)
1795     |> Repo.insert()
1796     |> set_cache()
1797   end
1798
1799   def public_key(%{public_key: public_key_pem}) when is_binary(public_key_pem) do
1800     key =
1801       public_key_pem
1802       |> :public_key.pem_decode()
1803       |> hd()
1804       |> :public_key.pem_entry_decode()
1805
1806     {:ok, key}
1807   end
1808
1809   def public_key(_), do: {:error, "key not found"}
1810
1811   def get_public_key_for_ap_id(ap_id) do
1812     with {:ok, %User{} = user} <- get_or_fetch_by_ap_id(ap_id),
1813          {:ok, public_key} <- public_key(user) do
1814       {:ok, public_key}
1815     else
1816       _ -> :error
1817     end
1818   end
1819
1820   def ap_enabled?(%User{local: true}), do: true
1821   def ap_enabled?(%User{ap_enabled: ap_enabled}), do: ap_enabled
1822   def ap_enabled?(_), do: false
1823
1824   @doc "Gets or fetch a user by uri or nickname."
1825   @spec get_or_fetch(String.t()) :: {:ok, User.t()} | {:error, String.t()}
1826   def get_or_fetch("http" <> _host = uri), do: get_or_fetch_by_ap_id(uri)
1827   def get_or_fetch(nickname), do: get_or_fetch_by_nickname(nickname)
1828
1829   # wait a period of time and return newest version of the User structs
1830   # this is because we have synchronous follow APIs and need to simulate them
1831   # with an async handshake
1832   def wait_and_refresh(_, %User{local: true} = a, %User{local: true} = b) do
1833     with %User{} = a <- get_cached_by_id(a.id),
1834          %User{} = b <- get_cached_by_id(b.id) do
1835       {:ok, a, b}
1836     else
1837       nil -> :error
1838     end
1839   end
1840
1841   def wait_and_refresh(timeout, %User{} = a, %User{} = b) do
1842     with :ok <- :timer.sleep(timeout),
1843          %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 parse_bio(bio) when is_binary(bio) and bio != "" do
1852     bio
1853     |> CommonUtils.format_input("text/plain", mentions_format: :full)
1854     |> elem(0)
1855   end
1856
1857   def parse_bio(_), do: ""
1858
1859   def parse_bio(bio, user) when is_binary(bio) and bio != "" do
1860     # TODO: get profile URLs other than user.ap_id
1861     profile_urls = [user.ap_id]
1862
1863     bio
1864     |> CommonUtils.format_input("text/plain",
1865       mentions_format: :full,
1866       rel: &RelMe.maybe_put_rel_me(&1, profile_urls)
1867     )
1868     |> elem(0)
1869   end
1870
1871   def parse_bio(_, _), do: ""
1872
1873   def tag(user_identifiers, tags) when is_list(user_identifiers) do
1874     Repo.transaction(fn ->
1875       for user_identifier <- user_identifiers, do: tag(user_identifier, tags)
1876     end)
1877   end
1878
1879   def tag(nickname, tags) when is_binary(nickname),
1880     do: tag(get_by_nickname(nickname), tags)
1881
1882   def tag(%User{} = user, tags),
1883     do: update_tags(user, Enum.uniq((user.tags || []) ++ normalize_tags(tags)))
1884
1885   def untag(user_identifiers, tags) when is_list(user_identifiers) do
1886     Repo.transaction(fn ->
1887       for user_identifier <- user_identifiers, do: untag(user_identifier, tags)
1888     end)
1889   end
1890
1891   def untag(nickname, tags) when is_binary(nickname),
1892     do: untag(get_by_nickname(nickname), tags)
1893
1894   def untag(%User{} = user, tags),
1895     do: update_tags(user, (user.tags || []) -- normalize_tags(tags))
1896
1897   defp update_tags(%User{} = user, new_tags) do
1898     {:ok, updated_user} =
1899       user
1900       |> change(%{tags: new_tags})
1901       |> update_and_set_cache()
1902
1903     updated_user
1904   end
1905
1906   defp normalize_tags(tags) do
1907     [tags]
1908     |> List.flatten()
1909     |> Enum.map(&String.downcase/1)
1910   end
1911
1912   defp local_nickname_regex do
1913     if Config.get([:instance, :extended_nickname_format]) do
1914       @extended_local_nickname_regex
1915     else
1916       @strict_local_nickname_regex
1917     end
1918   end
1919
1920   def local_nickname(nickname_or_mention) do
1921     nickname_or_mention
1922     |> full_nickname()
1923     |> String.split("@")
1924     |> hd()
1925   end
1926
1927   def full_nickname(nickname_or_mention),
1928     do: String.trim_leading(nickname_or_mention, "@")
1929
1930   def error_user(ap_id) do
1931     %User{
1932       name: ap_id,
1933       ap_id: ap_id,
1934       nickname: "erroruser@example.com",
1935       inserted_at: NaiveDateTime.utc_now()
1936     }
1937   end
1938
1939   @spec all_superusers() :: [User.t()]
1940   def all_superusers do
1941     User.Query.build(%{super_users: true, local: true, deactivated: false})
1942     |> Repo.all()
1943   end
1944
1945   def muting_reblogs?(%User{} = user, %User{} = target) do
1946     UserRelationship.reblog_mute_exists?(user, target)
1947   end
1948
1949   def showing_reblogs?(%User{} = user, %User{} = target) do
1950     not muting_reblogs?(user, target)
1951   end
1952
1953   @doc """
1954   The function returns a query to get users with no activity for given interval of days.
1955   Inactive users are those who didn't read any notification, or had any activity where
1956   the user is the activity's actor, during `inactivity_threshold` days.
1957   Deactivated users will not appear in this list.
1958
1959   ## Examples
1960
1961       iex> Pleroma.User.list_inactive_users()
1962       %Ecto.Query{}
1963   """
1964   @spec list_inactive_users_query(integer()) :: Ecto.Query.t()
1965   def list_inactive_users_query(inactivity_threshold \\ 7) do
1966     negative_inactivity_threshold = -inactivity_threshold
1967     now = NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
1968     # Subqueries are not supported in `where` clauses, join gets too complicated.
1969     has_read_notifications =
1970       from(n in Pleroma.Notification,
1971         where: n.seen == true,
1972         group_by: n.id,
1973         having: max(n.updated_at) > datetime_add(^now, ^negative_inactivity_threshold, "day"),
1974         select: n.user_id
1975       )
1976       |> Pleroma.Repo.all()
1977
1978     from(u in Pleroma.User,
1979       left_join: a in Pleroma.Activity,
1980       on: u.ap_id == a.actor,
1981       where: not is_nil(u.nickname),
1982       where: u.deactivated != ^true,
1983       where: u.id not in ^has_read_notifications,
1984       group_by: u.id,
1985       having:
1986         max(a.inserted_at) < datetime_add(^now, ^negative_inactivity_threshold, "day") or
1987           is_nil(max(a.inserted_at))
1988     )
1989   end
1990
1991   @doc """
1992   Enable or disable email notifications for user
1993
1994   ## Examples
1995
1996       iex> Pleroma.User.switch_email_notifications(Pleroma.User{email_notifications: %{"digest" => false}}, "digest", true)
1997       Pleroma.User{email_notifications: %{"digest" => true}}
1998
1999       iex> Pleroma.User.switch_email_notifications(Pleroma.User{email_notifications: %{"digest" => true}}, "digest", false)
2000       Pleroma.User{email_notifications: %{"digest" => false}}
2001   """
2002   @spec switch_email_notifications(t(), String.t(), boolean()) ::
2003           {:ok, t()} | {:error, Ecto.Changeset.t()}
2004   def switch_email_notifications(user, type, status) do
2005     User.update_email_notifications(user, %{type => status})
2006   end
2007
2008   @doc """
2009   Set `last_digest_emailed_at` value for the user to current time
2010   """
2011   @spec touch_last_digest_emailed_at(t()) :: t()
2012   def touch_last_digest_emailed_at(user) do
2013     now = NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
2014
2015     {:ok, updated_user} =
2016       user
2017       |> change(%{last_digest_emailed_at: now})
2018       |> update_and_set_cache()
2019
2020     updated_user
2021   end
2022
2023   @spec toggle_confirmation(User.t()) :: {:ok, User.t()} | {:error, Changeset.t()}
2024   def toggle_confirmation(%User{} = user) do
2025     user
2026     |> confirmation_changeset(need_confirmation: !user.confirmation_pending)
2027     |> update_and_set_cache()
2028   end
2029
2030   @spec toggle_confirmation([User.t()]) :: [{:ok, User.t()} | {:error, Changeset.t()}]
2031   def toggle_confirmation(users) do
2032     Enum.map(users, &toggle_confirmation/1)
2033   end
2034
2035   def get_mascot(%{mascot: %{} = mascot}) when not is_nil(mascot) do
2036     mascot
2037   end
2038
2039   def get_mascot(%{mascot: mascot}) when is_nil(mascot) do
2040     # use instance-default
2041     config = Config.get([:assets, :mascots])
2042     default_mascot = Config.get([:assets, :default_mascot])
2043     mascot = Keyword.get(config, default_mascot)
2044
2045     %{
2046       "id" => "default-mascot",
2047       "url" => mascot[:url],
2048       "preview_url" => mascot[:url],
2049       "pleroma" => %{
2050         "mime_type" => mascot[:mime_type]
2051       }
2052     }
2053   end
2054
2055   def ensure_keys_present(%{keys: keys} = user) when not is_nil(keys), do: {:ok, user}
2056
2057   def ensure_keys_present(%User{} = user) do
2058     with {:ok, pem} <- Keys.generate_rsa_pem() do
2059       user
2060       |> cast(%{keys: pem}, [:keys])
2061       |> validate_required([:keys])
2062       |> update_and_set_cache()
2063     end
2064   end
2065
2066   def get_ap_ids_by_nicknames(nicknames) do
2067     from(u in User,
2068       where: u.nickname in ^nicknames,
2069       select: u.ap_id
2070     )
2071     |> Repo.all()
2072   end
2073
2074   defdelegate search(query, opts \\ []), to: User.Search
2075
2076   defp put_password_hash(
2077          %Ecto.Changeset{valid?: true, changes: %{password: password}} = changeset
2078        ) do
2079     change(changeset, password_hash: Pbkdf2.hash_pwd_salt(password))
2080   end
2081
2082   defp put_password_hash(changeset), do: changeset
2083
2084   def is_internal_user?(%User{nickname: nil}), do: true
2085   def is_internal_user?(%User{local: true, nickname: "internal." <> _}), do: true
2086   def is_internal_user?(_), do: false
2087
2088   # A hack because user delete activities have a fake id for whatever reason
2089   # TODO: Get rid of this
2090   def get_delivered_users_by_object_id("pleroma:fake_object_id"), do: []
2091
2092   def get_delivered_users_by_object_id(object_id) do
2093     from(u in User,
2094       inner_join: delivery in assoc(u, :deliveries),
2095       where: delivery.object_id == ^object_id
2096     )
2097     |> Repo.all()
2098   end
2099
2100   def change_email(user, email) do
2101     user
2102     |> cast(%{email: email}, [:email])
2103     |> validate_required([:email])
2104     |> unique_constraint(:email)
2105     |> validate_format(:email, @email_regex)
2106     |> update_and_set_cache()
2107   end
2108
2109   # Internal function; public one is `deactivate/2`
2110   defp set_activation_status(user, deactivated) do
2111     user
2112     |> cast(%{deactivated: deactivated}, [:deactivated])
2113     |> update_and_set_cache()
2114   end
2115
2116   def update_banner(user, banner) do
2117     user
2118     |> cast(%{banner: banner}, [:banner])
2119     |> update_and_set_cache()
2120   end
2121
2122   def update_background(user, background) do
2123     user
2124     |> cast(%{background: background}, [:background])
2125     |> update_and_set_cache()
2126   end
2127
2128   def roles(%{is_moderator: is_moderator, is_admin: is_admin}) do
2129     %{
2130       admin: is_admin,
2131       moderator: is_moderator
2132     }
2133   end
2134
2135   def validate_fields(changeset, remote? \\ false) do
2136     limit_name = if remote?, do: :max_remote_account_fields, else: :max_account_fields
2137     limit = Config.get([:instance, limit_name], 0)
2138
2139     changeset
2140     |> validate_length(:fields, max: limit)
2141     |> validate_change(:fields, fn :fields, fields ->
2142       if Enum.all?(fields, &valid_field?/1) do
2143         []
2144       else
2145         [fields: "invalid"]
2146       end
2147     end)
2148   end
2149
2150   defp valid_field?(%{"name" => name, "value" => value}) do
2151     name_limit = Config.get([:instance, :account_field_name_length], 255)
2152     value_limit = Config.get([:instance, :account_field_value_length], 255)
2153
2154     is_binary(name) && is_binary(value) && String.length(name) <= name_limit &&
2155       String.length(value) <= value_limit
2156   end
2157
2158   defp valid_field?(_), do: false
2159
2160   defp truncate_field(%{"name" => name, "value" => value}) do
2161     {name, _chopped} =
2162       String.split_at(name, Config.get([:instance, :account_field_name_length], 255))
2163
2164     {value, _chopped} =
2165       String.split_at(value, Config.get([:instance, :account_field_value_length], 255))
2166
2167     %{"name" => name, "value" => value}
2168   end
2169
2170   def admin_api_update(user, params) do
2171     user
2172     |> cast(params, [
2173       :is_moderator,
2174       :is_admin,
2175       :show_role
2176     ])
2177     |> update_and_set_cache()
2178   end
2179
2180   @doc "Signs user out of all applications"
2181   def global_sign_out(user) do
2182     OAuth.Authorization.delete_user_authorizations(user)
2183     OAuth.Token.delete_user_tokens(user)
2184   end
2185
2186   def mascot_update(user, url) do
2187     user
2188     |> cast(%{mascot: url}, [:mascot])
2189     |> validate_required([:mascot])
2190     |> update_and_set_cache()
2191   end
2192
2193   def mastodon_settings_update(user, settings) do
2194     user
2195     |> cast(%{mastofe_settings: settings}, [:mastofe_settings])
2196     |> validate_required([:mastofe_settings])
2197     |> update_and_set_cache()
2198   end
2199
2200   @spec confirmation_changeset(User.t(), keyword()) :: Changeset.t()
2201   def confirmation_changeset(user, need_confirmation: need_confirmation?) do
2202     params =
2203       if need_confirmation? do
2204         %{
2205           confirmation_pending: true,
2206           confirmation_token: :crypto.strong_rand_bytes(32) |> Base.url_encode64()
2207         }
2208       else
2209         %{
2210           confirmation_pending: false,
2211           confirmation_token: nil
2212         }
2213       end
2214
2215     cast(user, params, [:confirmation_pending, :confirmation_token])
2216   end
2217
2218   @spec approval_changeset(User.t(), keyword()) :: Changeset.t()
2219   def approval_changeset(user, need_approval: need_approval?) do
2220     params = if need_approval?, do: %{approval_pending: true}, else: %{approval_pending: false}
2221     cast(user, params, [:approval_pending])
2222   end
2223
2224   def add_pinnned_activity(user, %Pleroma.Activity{id: id}) do
2225     if id not in user.pinned_activities do
2226       max_pinned_statuses = Config.get([:instance, :max_pinned_statuses], 0)
2227       params = %{pinned_activities: user.pinned_activities ++ [id]}
2228
2229       user
2230       |> cast(params, [:pinned_activities])
2231       |> validate_length(:pinned_activities,
2232         max: max_pinned_statuses,
2233         message: "You have already pinned the maximum number of statuses"
2234       )
2235     else
2236       change(user)
2237     end
2238     |> update_and_set_cache()
2239   end
2240
2241   def remove_pinnned_activity(user, %Pleroma.Activity{id: id}) do
2242     params = %{pinned_activities: List.delete(user.pinned_activities, id)}
2243
2244     user
2245     |> cast(params, [:pinned_activities])
2246     |> update_and_set_cache()
2247   end
2248
2249   def update_email_notifications(user, settings) do
2250     email_notifications =
2251       user.email_notifications
2252       |> Map.merge(settings)
2253       |> Map.take(["digest"])
2254
2255     params = %{email_notifications: email_notifications}
2256     fields = [:email_notifications]
2257
2258     user
2259     |> cast(params, fields)
2260     |> validate_required(fields)
2261     |> update_and_set_cache()
2262   end
2263
2264   defp set_domain_blocks(user, domain_blocks) do
2265     params = %{domain_blocks: domain_blocks}
2266
2267     user
2268     |> cast(params, [:domain_blocks])
2269     |> validate_required([:domain_blocks])
2270     |> update_and_set_cache()
2271   end
2272
2273   def block_domain(user, domain_blocked) do
2274     set_domain_blocks(user, Enum.uniq([domain_blocked | user.domain_blocks]))
2275   end
2276
2277   def unblock_domain(user, domain_blocked) do
2278     set_domain_blocks(user, List.delete(user.domain_blocks, domain_blocked))
2279   end
2280
2281   @spec add_to_block(User.t(), User.t()) ::
2282           {:ok, UserRelationship.t()} | {:error, Ecto.Changeset.t()}
2283   defp add_to_block(%User{} = user, %User{} = blocked) do
2284     UserRelationship.create_block(user, blocked)
2285   end
2286
2287   @spec add_to_block(User.t(), User.t()) ::
2288           {:ok, UserRelationship.t()} | {:ok, nil} | {:error, Ecto.Changeset.t()}
2289   defp remove_from_block(%User{} = user, %User{} = blocked) do
2290     UserRelationship.delete_block(user, blocked)
2291   end
2292
2293   defp add_to_mutes(%User{} = user, %User{} = muted_user, notifications?) do
2294     with {:ok, user_mute} <- UserRelationship.create_mute(user, muted_user),
2295          {:ok, user_notification_mute} <-
2296            (notifications? && UserRelationship.create_notification_mute(user, muted_user)) ||
2297              {:ok, nil} do
2298       {:ok, Enum.filter([user_mute, user_notification_mute], & &1)}
2299     end
2300   end
2301
2302   defp remove_from_mutes(user, %User{} = muted_user) do
2303     with {:ok, user_mute} <- UserRelationship.delete_mute(user, muted_user),
2304          {:ok, user_notification_mute} <-
2305            UserRelationship.delete_notification_mute(user, muted_user) do
2306       {:ok, [user_mute, user_notification_mute]}
2307     end
2308   end
2309
2310   def set_invisible(user, invisible) do
2311     params = %{invisible: invisible}
2312
2313     user
2314     |> cast(params, [:invisible])
2315     |> validate_required([:invisible])
2316     |> update_and_set_cache()
2317   end
2318
2319   def sanitize_html(%User{} = user) do
2320     sanitize_html(user, nil)
2321   end
2322
2323   # User data that mastodon isn't filtering (treated as plaintext):
2324   # - field name
2325   # - display name
2326   def sanitize_html(%User{} = user, filter) do
2327     fields =
2328       Enum.map(user.fields, fn %{"name" => name, "value" => value} ->
2329         %{
2330           "name" => name,
2331           "value" => HTML.filter_tags(value, Pleroma.HTML.Scrubber.LinksOnly)
2332         }
2333       end)
2334
2335     user
2336     |> Map.put(:bio, HTML.filter_tags(user.bio, filter))
2337     |> Map.put(:fields, fields)
2338   end
2339 end