git.squeep.com Git - akkoma/blob - lib/pleroma/user.ex

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