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