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