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