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