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

   1 # Pleroma: A lightweight social networking server
   2 # Copyright © 2017-2019 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
  11   alias Comeonin.Pbkdf2
  12   alias Ecto.Multi
  13   alias Pleroma.Activity
  14   alias Pleroma.Keys
  15   alias Pleroma.Notification
  16   alias Pleroma.Object
  17   alias Pleroma.Registration
  18   alias Pleroma.Repo
  19   alias Pleroma.RepoStreamer
  20   alias Pleroma.User
  21   alias Pleroma.Web
  22   alias Pleroma.Web.ActivityPub.ActivityPub
  23   alias Pleroma.Web.ActivityPub.Utils
  24   alias Pleroma.Web.CommonAPI
  25   alias Pleroma.Web.CommonAPI.Utils, as: CommonUtils
  26   alias Pleroma.Web.OAuth
  27   alias Pleroma.Web.OStatus
  28   alias Pleroma.Web.RelMe
  29   alias Pleroma.Web.Websub
  30
  31   require Logger
  32
  33   @type t :: %__MODULE__{}
  34
  35   @primary_key {:id, Pleroma.FlakeId, autogenerate: true}
  36
  37   # credo:disable-for-next-line Credo.Check.Readability.MaxLineLength
  38   @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])?)*$/
  39
  40   @strict_local_nickname_regex ~r/^[a-zA-Z\d]+$/
  41   @extended_local_nickname_regex ~r/^[a-zA-Z\d_-]+$/
  42
  43   schema "users" do
  44     field(:bio, :string)
  45     field(:email, :string)
  46     field(:name, :string)
  47     field(:nickname, :string)
  48     field(:password_hash, :string)
  49     field(:password, :string, virtual: true)
  50     field(:password_confirmation, :string, virtual: true)
  51     field(:following, {:array, :string}, default: [])
  52     field(:ap_id, :string)
  53     field(:avatar, :map)
  54     field(:local, :boolean, default: true)
  55     field(:follower_address, :string)
  56     field(:following_address, :string)
  57     field(:search_rank, :float, virtual: true)
  58     field(:search_type, :integer, virtual: true)
  59     field(:tags, {:array, :string}, default: [])
  60     field(:last_refreshed_at, :naive_datetime_usec)
  61     field(:last_digest_emailed_at, :naive_datetime)
  62     has_many(:notifications, Notification)
  63     has_many(:registrations, Registration)
  64     embeds_one(:info, User.Info)
  65
  66     timestamps()
  67   end
  68
  69   def auth_active?(%User{info: %User.Info{confirmation_pending: true}}),
  70     do: !Pleroma.Config.get([:instance, :account_activation_required])
  71
  72   def auth_active?(%User{}), do: true
  73
  74   def visible_for?(user, for_user \\ nil)
  75
  76   def visible_for?(%User{id: user_id}, %User{id: for_id}) when user_id == for_id, do: true
  77
  78   def visible_for?(%User{} = user, for_user) do
  79     auth_active?(user) || superuser?(for_user)
  80   end
  81
  82   def visible_for?(_, _), do: false
  83
  84   def superuser?(%User{local: true, info: %User.Info{is_admin: true}}), do: true
  85   def superuser?(%User{local: true, info: %User.Info{is_moderator: true}}), do: true
  86   def superuser?(_), do: false
  87
  88   def avatar_url(user, options \\ []) do
  89     case user.avatar do
  90       %{"url" => [%{"href" => href} | _]} -> href
  91       _ -> !options[:no_default] && "#{Web.base_url()}/images/avi.png"
  92     end
  93   end
  94
  95   def banner_url(user, options \\ []) do
  96     case user.info.banner do
  97       %{"url" => [%{"href" => href} | _]} -> href
  98       _ -> !options[:no_default] && "#{Web.base_url()}/images/banner.png"
  99     end
 100   end
 101
 102   def profile_url(%User{info: %{source_data: %{"url" => url}}}), do: url
 103   def profile_url(%User{ap_id: ap_id}), do: ap_id
 104   def profile_url(_), do: nil
 105
 106   def ap_id(%User{nickname: nickname}) do
 107     "#{Web.base_url()}/users/#{nickname}"
 108   end
 109
 110   def ap_followers(%User{follower_address: fa}) when is_binary(fa), do: fa
 111   def ap_followers(%User{} = user), do: "#{ap_id(user)}/followers"
 112
 113   @spec ap_following(User.t()) :: Sring.t()
 114   def ap_following(%User{following_address: fa}) when is_binary(fa), do: fa
 115   def ap_following(%User{} = user), do: "#{ap_id(user)}/following"
 116
 117   def user_info(%User{} = user, args \\ %{}) do
 118     following_count =
 119       if args[:following_count],
 120         do: args[:following_count],
 121         else: user.info.following_count || following_count(user)
 122
 123     follower_count =
 124       if args[:follower_count], do: args[:follower_count], else: user.info.follower_count
 125
 126     %{
 127       note_count: user.info.note_count,
 128       locked: user.info.locked,
 129       confirmation_pending: user.info.confirmation_pending,
 130       default_scope: user.info.default_scope
 131     }
 132     |> Map.put(:following_count, following_count)
 133     |> Map.put(:follower_count, follower_count)
 134   end
 135
 136   def follow_state(%User{} = user, %User{} = target) do
 137     follow_activity = Utils.fetch_latest_follow(user, target)
 138
 139     if follow_activity,
 140       do: follow_activity.data["state"],
 141       # Ideally this would be nil, but then Cachex does not commit the value
 142       else: false
 143   end
 144
 145   def get_cached_follow_state(user, target) do
 146     key = "follow_state:#{user.ap_id}|#{target.ap_id}"
 147     Cachex.fetch!(:user_cache, key, fn _ -> {:commit, follow_state(user, target)} end)
 148   end
 149
 150   @spec set_follow_state_cache(String.t(), String.t(), String.t()) :: {:ok | :error, boolean()}
 151   def set_follow_state_cache(user_ap_id, target_ap_id, state) do
 152     Cachex.put(
 153       :user_cache,
 154       "follow_state:#{user_ap_id}|#{target_ap_id}",
 155       state
 156     )
 157   end
 158
 159   def set_info_cache(user, args) do
 160     Cachex.put(:user_cache, "user_info:#{user.id}", user_info(user, args))
 161   end
 162
 163   @spec restrict_deactivated(Ecto.Query.t()) :: Ecto.Query.t()
 164   def restrict_deactivated(query) do
 165     from(u in query,
 166       where: not fragment("? \\? 'deactivated' AND ?->'deactivated' @> 'true'", u.info, u.info)
 167     )
 168   end
 169
 170   def following_count(%User{following: []}), do: 0
 171
 172   def following_count(%User{} = user) do
 173     user
 174     |> get_friends_query()
 175     |> Repo.aggregate(:count, :id)
 176   end
 177
 178   defp truncate_if_exists(params, key, max_length) do
 179     if Map.has_key?(params, key) and is_binary(params[key]) do
 180       {value, _chopped} = String.split_at(params[key], max_length)
 181       Map.put(params, key, value)
 182     else
 183       params
 184     end
 185   end
 186
 187   def remote_user_creation(params) do
 188     bio_limit = Pleroma.Config.get([:instance, :user_bio_length], 5000)
 189     name_limit = Pleroma.Config.get([:instance, :user_name_length], 100)
 190
 191     params =
 192       params
 193       |> Map.put(:info, params[:info] || %{})
 194       |> truncate_if_exists(:name, name_limit)
 195       |> truncate_if_exists(:bio, bio_limit)
 196
 197     info_cng = User.Info.remote_user_creation(%User.Info{}, params[:info])
 198
 199     changes =
 200       %User{}
 201       |> cast(params, [:bio, :name, :ap_id, :nickname, :avatar])
 202       |> validate_required([:name, :ap_id])
 203       |> unique_constraint(:nickname)
 204       |> validate_format(:nickname, @email_regex)
 205       |> validate_length(:bio, max: bio_limit)
 206       |> validate_length(:name, max: name_limit)
 207       |> put_change(:local, false)
 208       |> put_embed(:info, info_cng)
 209
 210     if changes.valid? do
 211       case info_cng.changes[:source_data] do
 212         %{"followers" => followers, "following" => following} ->
 213           changes
 214           |> put_change(:follower_address, followers)
 215           |> put_change(:following_address, following)
 216
 217         _ ->
 218           followers = User.ap_followers(%User{nickname: changes.changes[:nickname]})
 219
 220           changes
 221           |> put_change(:follower_address, followers)
 222       end
 223     else
 224       changes
 225     end
 226   end
 227
 228   def update_changeset(struct, params \\ %{}) do
 229     bio_limit = Pleroma.Config.get([:instance, :user_bio_length], 5000)
 230     name_limit = Pleroma.Config.get([:instance, :user_name_length], 100)
 231
 232     struct
 233     |> cast(params, [:bio, :name, :avatar, :following])
 234     |> unique_constraint(:nickname)
 235     |> validate_format(:nickname, local_nickname_regex())
 236     |> validate_length(:bio, max: bio_limit)
 237     |> validate_length(:name, min: 1, max: name_limit)
 238   end
 239
 240   def upgrade_changeset(struct, params \\ %{}, remote? \\ false) do
 241     bio_limit = Pleroma.Config.get([:instance, :user_bio_length], 5000)
 242     name_limit = Pleroma.Config.get([:instance, :user_name_length], 100)
 243
 244     params = Map.put(params, :last_refreshed_at, NaiveDateTime.utc_now())
 245     info_cng = User.Info.user_upgrade(struct.info, params[:info], remote?)
 246
 247     struct
 248     |> cast(params, [
 249       :bio,
 250       :name,
 251       :follower_address,
 252       :following_address,
 253       :avatar,
 254       :last_refreshed_at
 255     ])
 256     |> unique_constraint(:nickname)
 257     |> validate_format(:nickname, local_nickname_regex())
 258     |> validate_length(:bio, max: bio_limit)
 259     |> validate_length(:name, max: name_limit)
 260     |> put_embed(:info, info_cng)
 261   end
 262
 263   def password_update_changeset(struct, params) do
 264     struct
 265     |> cast(params, [:password, :password_confirmation])
 266     |> validate_required([:password, :password_confirmation])
 267     |> validate_confirmation(:password)
 268     |> put_password_hash
 269   end
 270
 271   @spec reset_password(User.t(), map) :: {:ok, User.t()} | {:error, Ecto.Changeset.t()}
 272   def reset_password(%User{id: user_id} = user, data) do
 273     multi =
 274       Multi.new()
 275       |> Multi.update(:user, password_update_changeset(user, data))
 276       |> Multi.delete_all(:tokens, OAuth.Token.Query.get_by_user(user_id))
 277       |> Multi.delete_all(:auth, OAuth.Authorization.delete_by_user_query(user))
 278
 279     case Repo.transaction(multi) do
 280       {:ok, %{user: user} = _} -> set_cache(user)
 281       {:error, _, changeset, _} -> {:error, changeset}
 282     end
 283   end
 284
 285   def register_changeset(struct, params \\ %{}, opts \\ []) do
 286     bio_limit = Pleroma.Config.get([:instance, :user_bio_length], 5000)
 287     name_limit = Pleroma.Config.get([:instance, :user_name_length], 100)
 288
 289     need_confirmation? =
 290       if is_nil(opts[:need_confirmation]) do
 291         Pleroma.Config.get([:instance, :account_activation_required])
 292       else
 293         opts[:need_confirmation]
 294       end
 295
 296     info_change =
 297       User.Info.confirmation_changeset(%User.Info{}, need_confirmation: need_confirmation?)
 298
 299     changeset =
 300       struct
 301       |> cast(params, [:bio, :email, :name, :nickname, :password, :password_confirmation])
 302       |> validate_required([:name, :nickname, :password, :password_confirmation])
 303       |> validate_confirmation(:password)
 304       |> unique_constraint(:email)
 305       |> unique_constraint(:nickname)
 306       |> validate_exclusion(:nickname, Pleroma.Config.get([User, :restricted_nicknames]))
 307       |> validate_format(:nickname, local_nickname_regex())
 308       |> validate_format(:email, @email_regex)
 309       |> validate_length(:bio, max: bio_limit)
 310       |> validate_length(:name, min: 1, max: name_limit)
 311       |> put_change(:info, info_change)
 312
 313     changeset =
 314       if opts[:external] do
 315         changeset
 316       else
 317         validate_required(changeset, [:email])
 318       end
 319
 320     if changeset.valid? do
 321       ap_id = User.ap_id(%User{nickname: changeset.changes[:nickname]})
 322       followers = User.ap_followers(%User{nickname: changeset.changes[:nickname]})
 323
 324       changeset
 325       |> put_password_hash
 326       |> put_change(:ap_id, ap_id)
 327       |> unique_constraint(:ap_id)
 328       |> put_change(:following, [followers])
 329       |> put_change(:follower_address, followers)
 330     else
 331       changeset
 332     end
 333   end
 334
 335   defp autofollow_users(user) do
 336     candidates = Pleroma.Config.get([:instance, :autofollowed_nicknames])
 337
 338     autofollowed_users =
 339       User.Query.build(%{nickname: candidates, local: true, deactivated: false})
 340       |> Repo.all()
 341
 342     follow_all(user, autofollowed_users)
 343   end
 344
 345   @doc "Inserts provided changeset, performs post-registration actions (confirmation email sending etc.)"
 346   def register(%Ecto.Changeset{} = changeset) do
 347     with {:ok, user} <- Repo.insert(changeset),
 348          {:ok, user} <- post_register_action(user) do
 349       {:ok, user}
 350     end
 351   end
 352
 353   def post_register_action(%User{} = user) do
 354     with {:ok, user} <- autofollow_users(user),
 355          {:ok, user} <- set_cache(user),
 356          {:ok, _} <- User.WelcomeMessage.post_welcome_message_to_user(user),
 357          {:ok, _} <- try_send_confirmation_email(user) do
 358       {:ok, user}
 359     end
 360   end
 361
 362   def try_send_confirmation_email(%User{} = user) do
 363     if user.info.confirmation_pending &&
 364          Pleroma.Config.get([:instance, :account_activation_required]) do
 365       user
 366       |> Pleroma.Emails.UserEmail.account_confirmation_email()
 367       |> Pleroma.Emails.Mailer.deliver_async()
 368
 369       {:ok, :enqueued}
 370     else
 371       {:ok, :noop}
 372     end
 373   end
 374
 375   def needs_update?(%User{local: true}), do: false
 376
 377   def needs_update?(%User{local: false, last_refreshed_at: nil}), do: true
 378
 379   def needs_update?(%User{local: false} = user) do
 380     NaiveDateTime.diff(NaiveDateTime.utc_now(), user.last_refreshed_at) >= 86_400
 381   end
 382
 383   def needs_update?(_), do: true
 384
 385   @spec maybe_direct_follow(User.t(), User.t()) :: {:ok, User.t()} | {:error, String.t()}
 386   def maybe_direct_follow(%User{} = follower, %User{local: true, info: %{locked: true}}) do
 387     {:ok, follower}
 388   end
 389
 390   def maybe_direct_follow(%User{} = follower, %User{local: true} = followed) do
 391     follow(follower, followed)
 392   end
 393
 394   def maybe_direct_follow(%User{} = follower, %User{} = followed) do
 395     if not User.ap_enabled?(followed) do
 396       follow(follower, followed)
 397     else
 398       {:ok, follower}
 399     end
 400   end
 401
 402   @doc "A mass follow for local users. Respects blocks in both directions but does not create activities."
 403   @spec follow_all(User.t(), list(User.t())) :: {atom(), User.t()}
 404   def follow_all(follower, followeds) do
 405     followed_addresses =
 406       followeds
 407       |> Enum.reject(fn followed -> blocks?(follower, followed) || blocks?(followed, follower) end)
 408       |> Enum.map(fn %{follower_address: fa} -> fa end)
 409
 410     q =
 411       from(u in User,
 412         where: u.id == ^follower.id,
 413         update: [
 414           set: [
 415             following:
 416               fragment(
 417                 "array(select distinct unnest (array_cat(?, ?)))",
 418                 u.following,
 419                 ^followed_addresses
 420               )
 421           ]
 422         ],
 423         select: u
 424       )
 425
 426     {1, [follower]} = Repo.update_all(q, [])
 427
 428     Enum.each(followeds, fn followed ->
 429       update_follower_count(followed)
 430     end)
 431
 432     set_cache(follower)
 433   end
 434
 435   def follow(%User{} = follower, %User{info: info} = followed) do
 436     deny_follow_blocked = Pleroma.Config.get([:user, :deny_follow_blocked])
 437     ap_followers = followed.follower_address
 438
 439     cond do
 440       info.deactivated ->
 441         {:error, "Could not follow user: You are deactivated."}
 442
 443       deny_follow_blocked and blocks?(followed, follower) ->
 444         {:error, "Could not follow user: #{followed.nickname} blocked you."}
 445
 446       true ->
 447         if !followed.local && follower.local && !ap_enabled?(followed) do
 448           Websub.subscribe(follower, followed)
 449         end
 450
 451         q =
 452           from(u in User,
 453             where: u.id == ^follower.id,
 454             update: [push: [following: ^ap_followers]],
 455             select: u
 456           )
 457
 458         {1, [follower]} = Repo.update_all(q, [])
 459
 460         follower = maybe_update_following_count(follower)
 461
 462         {:ok, _} = update_follower_count(followed)
 463
 464         set_cache(follower)
 465     end
 466   end
 467
 468   def unfollow(%User{} = follower, %User{} = followed) do
 469     ap_followers = followed.follower_address
 470
 471     if following?(follower, followed) and follower.ap_id != followed.ap_id do
 472       q =
 473         from(u in User,
 474           where: u.id == ^follower.id,
 475           update: [pull: [following: ^ap_followers]],
 476           select: u
 477         )
 478
 479       {1, [follower]} = Repo.update_all(q, [])
 480
 481       follower = maybe_update_following_count(follower)
 482
 483       {:ok, followed} = update_follower_count(followed)
 484
 485       set_cache(follower)
 486
 487       {:ok, follower, Utils.fetch_latest_follow(follower, followed)}
 488     else
 489       {:error, "Not subscribed!"}
 490     end
 491   end
 492
 493   @spec following?(User.t(), User.t()) :: boolean
 494   def following?(%User{} = follower, %User{} = followed) do
 495     Enum.member?(follower.following, followed.follower_address)
 496   end
 497
 498   def locked?(%User{} = user) do
 499     user.info.locked || false
 500   end
 501
 502   def get_by_id(id) do
 503     Repo.get_by(User, id: id)
 504   end
 505
 506   def get_by_ap_id(ap_id) do
 507     Repo.get_by(User, ap_id: ap_id)
 508   end
 509
 510   def get_all_by_ap_id(ap_ids) do
 511     from(u in __MODULE__,
 512       where: u.ap_id in ^ap_ids
 513     )
 514     |> Repo.all()
 515   end
 516
 517   # This is mostly an SPC migration fix. This guesses the user nickname by taking the last part
 518   # of the ap_id and the domain and tries to get that user
 519   def get_by_guessed_nickname(ap_id) do
 520     domain = URI.parse(ap_id).host
 521     name = List.last(String.split(ap_id, "/"))
 522     nickname = "#{name}@#{domain}"
 523
 524     get_cached_by_nickname(nickname)
 525   end
 526
 527   def set_cache({:ok, user}), do: set_cache(user)
 528   def set_cache({:error, err}), do: {:error, err}
 529
 530   def set_cache(%User{} = user) do
 531     Cachex.put(:user_cache, "ap_id:#{user.ap_id}", user)
 532     Cachex.put(:user_cache, "nickname:#{user.nickname}", user)
 533     Cachex.put(:user_cache, "user_info:#{user.id}", user_info(user))
 534     {:ok, user}
 535   end
 536
 537   def update_and_set_cache(changeset) do
 538     with {:ok, user} <- Repo.update(changeset, stale_error_field: :id) do
 539       set_cache(user)
 540     else
 541       e -> e
 542     end
 543   end
 544
 545   def invalidate_cache(user) do
 546     Cachex.del(:user_cache, "ap_id:#{user.ap_id}")
 547     Cachex.del(:user_cache, "nickname:#{user.nickname}")
 548     Cachex.del(:user_cache, "user_info:#{user.id}")
 549   end
 550
 551   def get_cached_by_ap_id(ap_id) do
 552     key = "ap_id:#{ap_id}"
 553     Cachex.fetch!(:user_cache, key, fn _ -> get_by_ap_id(ap_id) end)
 554   end
 555
 556   def get_cached_by_id(id) do
 557     key = "id:#{id}"
 558
 559     ap_id =
 560       Cachex.fetch!(:user_cache, key, fn _ ->
 561         user = get_by_id(id)
 562
 563         if user do
 564           Cachex.put(:user_cache, "ap_id:#{user.ap_id}", user)
 565           {:commit, user.ap_id}
 566         else
 567           {:ignore, ""}
 568         end
 569       end)
 570
 571     get_cached_by_ap_id(ap_id)
 572   end
 573
 574   def get_cached_by_nickname(nickname) do
 575     key = "nickname:#{nickname}"
 576
 577     Cachex.fetch!(:user_cache, key, fn ->
 578       user_result = get_or_fetch_by_nickname(nickname)
 579
 580       case user_result do
 581         {:ok, user} -> {:commit, user}
 582         {:error, _error} -> {:ignore, nil}
 583       end
 584     end)
 585   end
 586
 587   def get_cached_by_nickname_or_id(nickname_or_id, opts \\ []) do
 588     restrict_to_local = Pleroma.Config.get([:instance, :limit_to_local_content])
 589
 590     cond do
 591       is_integer(nickname_or_id) or Pleroma.FlakeId.is_flake_id?(nickname_or_id) ->
 592         get_cached_by_id(nickname_or_id) || get_cached_by_nickname(nickname_or_id)
 593
 594       restrict_to_local == false ->
 595         get_cached_by_nickname(nickname_or_id)
 596
 597       restrict_to_local == :unauthenticated and match?(%User{}, opts[:for]) ->
 598         get_cached_by_nickname(nickname_or_id)
 599
 600       true ->
 601         nil
 602     end
 603   end
 604
 605   def get_by_nickname(nickname) do
 606     Repo.get_by(User, nickname: nickname) ||
 607       if Regex.match?(~r(@#{Pleroma.Web.Endpoint.host()})i, nickname) do
 608         Repo.get_by(User, nickname: local_nickname(nickname))
 609       end
 610   end
 611
 612   def get_by_email(email), do: Repo.get_by(User, email: email)
 613
 614   def get_by_nickname_or_email(nickname_or_email) do
 615     get_by_nickname(nickname_or_email) || get_by_email(nickname_or_email)
 616   end
 617
 618   def get_cached_user_info(user) do
 619     key = "user_info:#{user.id}"
 620     Cachex.fetch!(:user_cache, key, fn _ -> user_info(user) end)
 621   end
 622
 623   def fetch_by_nickname(nickname) do
 624     ap_try = ActivityPub.make_user_from_nickname(nickname)
 625
 626     case ap_try do
 627       {:ok, user} -> {:ok, user}
 628       _ -> OStatus.make_user(nickname)
 629     end
 630   end
 631
 632   def get_or_fetch_by_nickname(nickname) do
 633     with %User{} = user <- get_by_nickname(nickname) do
 634       {:ok, user}
 635     else
 636       _e ->
 637         with [_nick, _domain] <- String.split(nickname, "@"),
 638              {:ok, user} <- fetch_by_nickname(nickname) do
 639           if Pleroma.Config.get([:fetch_initial_posts, :enabled]) do
 640             fetch_initial_posts(user)
 641           end
 642
 643           {:ok, user}
 644         else
 645           _e -> {:error, "not found " <> nickname}
 646         end
 647     end
 648   end
 649
 650   @doc "Fetch some posts when the user has just been federated with"
 651   def fetch_initial_posts(user),
 652     do: PleromaJobQueue.enqueue(:background, __MODULE__, [:fetch_initial_posts, user])
 653
 654   @spec get_followers_query(User.t(), pos_integer() | nil) :: Ecto.Query.t()
 655   def get_followers_query(%User{} = user, nil) do
 656     User.Query.build(%{followers: user, deactivated: false})
 657   end
 658
 659   def get_followers_query(user, page) do
 660     from(u in get_followers_query(user, nil))
 661     |> User.Query.paginate(page, 20)
 662   end
 663
 664   @spec get_followers_query(User.t()) :: Ecto.Query.t()
 665   def get_followers_query(user), do: get_followers_query(user, nil)
 666
 667   @spec get_followers(User.t(), pos_integer()) :: {:ok, list(User.t())}
 668   def get_followers(user, page \\ nil) do
 669     q = get_followers_query(user, page)
 670
 671     {:ok, Repo.all(q)}
 672   end
 673
 674   @spec get_external_followers(User.t(), pos_integer()) :: {:ok, list(User.t())}
 675   def get_external_followers(user, page \\ nil) do
 676     q =
 677       user
 678       |> get_followers_query(page)
 679       |> User.Query.build(%{external: true})
 680
 681     {:ok, Repo.all(q)}
 682   end
 683
 684   def get_followers_ids(user, page \\ nil) do
 685     q = get_followers_query(user, page)
 686
 687     Repo.all(from(u in q, select: u.id))
 688   end
 689
 690   @spec get_friends_query(User.t(), pos_integer() | nil) :: Ecto.Query.t()
 691   def get_friends_query(%User{} = user, nil) do
 692     User.Query.build(%{friends: user, deactivated: false})
 693   end
 694
 695   def get_friends_query(user, page) do
 696     from(u in get_friends_query(user, nil))
 697     |> User.Query.paginate(page, 20)
 698   end
 699
 700   @spec get_friends_query(User.t()) :: Ecto.Query.t()
 701   def get_friends_query(user), do: get_friends_query(user, nil)
 702
 703   def get_friends(user, page \\ nil) do
 704     q = get_friends_query(user, page)
 705
 706     {:ok, Repo.all(q)}
 707   end
 708
 709   def get_friends_ids(user, page \\ nil) do
 710     q = get_friends_query(user, page)
 711
 712     Repo.all(from(u in q, select: u.id))
 713   end
 714
 715   @spec get_follow_requests(User.t()) :: {:ok, [User.t()]}
 716   def get_follow_requests(%User{} = user) do
 717     users =
 718       Activity.follow_requests_for_actor(user)
 719       |> join(:inner, [a], u in User, on: a.actor == u.ap_id)
 720       |> where([a, u], not fragment("? @> ?", u.following, ^[user.follower_address]))
 721       |> group_by([a, u], u.id)
 722       |> select([a, u], u)
 723       |> Repo.all()
 724
 725     {:ok, users}
 726   end
 727
 728   def increase_note_count(%User{} = user) do
 729     User
 730     |> where(id: ^user.id)
 731     |> update([u],
 732       set: [
 733         info:
 734           fragment(
 735             "jsonb_set(?, '{note_count}', ((?->>'note_count')::int + 1)::varchar::jsonb, true)",
 736             u.info,
 737             u.info
 738           )
 739       ]
 740     )
 741     |> select([u], u)
 742     |> Repo.update_all([])
 743     |> case do
 744       {1, [user]} -> set_cache(user)
 745       _ -> {:error, user}
 746     end
 747   end
 748
 749   def decrease_note_count(%User{} = user) do
 750     User
 751     |> where(id: ^user.id)
 752     |> update([u],
 753       set: [
 754         info:
 755           fragment(
 756             "jsonb_set(?, '{note_count}', (greatest(0, (?->>'note_count')::int - 1))::varchar::jsonb, true)",
 757             u.info,
 758             u.info
 759           )
 760       ]
 761     )
 762     |> select([u], u)
 763     |> Repo.update_all([])
 764     |> case do
 765       {1, [user]} -> set_cache(user)
 766       _ -> {:error, user}
 767     end
 768   end
 769
 770   def update_note_count(%User{} = user) do
 771     note_count_query =
 772       from(
 773         a in Object,
 774         where: fragment("?->>'actor' = ? and ?->>'type' = 'Note'", a.data, ^user.ap_id, a.data),
 775         select: count(a.id)
 776       )
 777
 778     note_count = Repo.one(note_count_query)
 779
 780     info_cng = User.Info.set_note_count(user.info, note_count)
 781
 782     user
 783     |> change()
 784     |> put_embed(:info, info_cng)
 785     |> update_and_set_cache()
 786   end
 787
 788   @spec maybe_fetch_follow_information(User.t()) :: User.t()
 789   def maybe_fetch_follow_information(user) do
 790     with {:ok, user} <- fetch_follow_information(user) do
 791       user
 792     else
 793       e ->
 794         Logger.error("Follower/Following counter update for #{user.ap_id} failed.\n#{inspect(e)}")
 795
 796         user
 797     end
 798   end
 799
 800   def fetch_follow_information(user) do
 801     with {:ok, info} <- ActivityPub.fetch_follow_information_for_user(user) do
 802       info_cng = User.Info.follow_information_update(user.info, info)
 803
 804       changeset =
 805         user
 806         |> change()
 807         |> put_embed(:info, info_cng)
 808
 809       update_and_set_cache(changeset)
 810     else
 811       {:error, _} = e -> e
 812       e -> {:error, e}
 813     end
 814   end
 815
 816   def update_follower_count(%User{} = user) do
 817     if user.local or !Pleroma.Config.get([:instance, :external_user_synchronization]) do
 818       follower_count_query =
 819         User.Query.build(%{followers: user, deactivated: false})
 820         |> select([u], %{count: count(u.id)})
 821
 822       User
 823       |> where(id: ^user.id)
 824       |> join(:inner, [u], s in subquery(follower_count_query))
 825       |> update([u, s],
 826         set: [
 827           info:
 828             fragment(
 829               "jsonb_set(?, '{follower_count}', ?::varchar::jsonb, true)",
 830               u.info,
 831               s.count
 832             )
 833         ]
 834       )
 835       |> select([u], u)
 836       |> Repo.update_all([])
 837       |> case do
 838         {1, [user]} -> set_cache(user)
 839         _ -> {:error, user}
 840       end
 841     else
 842       {:ok, maybe_fetch_follow_information(user)}
 843     end
 844   end
 845
 846   @spec maybe_update_following_count(User.t()) :: User.t()
 847   def maybe_update_following_count(%User{local: false} = user) do
 848     if Pleroma.Config.get([:instance, :external_user_synchronization]) do
 849       maybe_fetch_follow_information(user)
 850     else
 851       user
 852     end
 853   end
 854
 855   def maybe_update_following_count(user), do: user
 856
 857   def remove_duplicated_following(%User{following: following} = user) do
 858     uniq_following = Enum.uniq(following)
 859
 860     if length(following) == length(uniq_following) do
 861       {:ok, user}
 862     else
 863       user
 864       |> update_changeset(%{following: uniq_following})
 865       |> update_and_set_cache()
 866     end
 867   end
 868
 869   @spec get_users_from_set([String.t()], boolean()) :: [User.t()]
 870   def get_users_from_set(ap_ids, local_only \\ true) do
 871     criteria = %{ap_id: ap_ids, deactivated: false}
 872     criteria = if local_only, do: Map.put(criteria, :local, true), else: criteria
 873
 874     User.Query.build(criteria)
 875     |> Repo.all()
 876   end
 877
 878   @spec get_recipients_from_activity(Activity.t()) :: [User.t()]
 879   def get_recipients_from_activity(%Activity{recipients: to}) do
 880     User.Query.build(%{recipients_from_activity: to, local: true, deactivated: false})
 881     |> Repo.all()
 882   end
 883
 884   @spec mute(User.t(), User.t(), boolean()) :: {:ok, User.t()} | {:error, String.t()}
 885   def mute(muter, %User{ap_id: ap_id}, notifications? \\ true) do
 886     info = muter.info
 887
 888     info_cng =
 889       User.Info.add_to_mutes(info, ap_id)
 890       |> User.Info.add_to_muted_notifications(info, ap_id, notifications?)
 891
 892     cng =
 893       change(muter)
 894       |> put_embed(:info, info_cng)
 895
 896     update_and_set_cache(cng)
 897   end
 898
 899   def unmute(muter, %{ap_id: ap_id}) do
 900     info = muter.info
 901
 902     info_cng =
 903       User.Info.remove_from_mutes(info, ap_id)
 904       |> User.Info.remove_from_muted_notifications(info, ap_id)
 905
 906     cng =
 907       change(muter)
 908       |> put_embed(:info, info_cng)
 909
 910     update_and_set_cache(cng)
 911   end
 912
 913   def subscribe(subscriber, %{ap_id: ap_id}) do
 914     deny_follow_blocked = Pleroma.Config.get([:user, :deny_follow_blocked])
 915
 916     with %User{} = subscribed <- get_cached_by_ap_id(ap_id) do
 917       blocked = blocks?(subscribed, subscriber) and deny_follow_blocked
 918
 919       if blocked do
 920         {:error, "Could not subscribe: #{subscribed.nickname} is blocking you"}
 921       else
 922         info_cng =
 923           subscribed.info
 924           |> User.Info.add_to_subscribers(subscriber.ap_id)
 925
 926         change(subscribed)
 927         |> put_embed(:info, info_cng)
 928         |> update_and_set_cache()
 929       end
 930     end
 931   end
 932
 933   def unsubscribe(unsubscriber, %{ap_id: ap_id}) do
 934     with %User{} = user <- get_cached_by_ap_id(ap_id) do
 935       info_cng =
 936         user.info
 937         |> User.Info.remove_from_subscribers(unsubscriber.ap_id)
 938
 939       change(user)
 940       |> put_embed(:info, info_cng)
 941       |> update_and_set_cache()
 942     end
 943   end
 944
 945   def block(blocker, %User{ap_id: ap_id} = blocked) do
 946     # sever any follow relationships to prevent leaks per activitypub (Pleroma issue #213)
 947     blocker =
 948       if following?(blocker, blocked) do
 949         {:ok, blocker, _} = unfollow(blocker, blocked)
 950         blocker
 951       else
 952         blocker
 953       end
 954
 955     # clear any requested follows as well
 956     blocked =
 957       case CommonAPI.reject_follow_request(blocked, blocker) do
 958         {:ok, %User{} = updated_blocked} -> updated_blocked
 959         nil -> blocked
 960       end
 961
 962     blocker =
 963       if subscribed_to?(blocked, blocker) do
 964         {:ok, blocker} = unsubscribe(blocked, blocker)
 965         blocker
 966       else
 967         blocker
 968       end
 969
 970     if following?(blocked, blocker) do
 971       unfollow(blocked, blocker)
 972     end
 973
 974     {:ok, blocker} = update_follower_count(blocker)
 975
 976     info_cng =
 977       blocker.info
 978       |> User.Info.add_to_block(ap_id)
 979
 980     cng =
 981       change(blocker)
 982       |> put_embed(:info, info_cng)
 983
 984     update_and_set_cache(cng)
 985   end
 986
 987   # helper to handle the block given only an actor's AP id
 988   def block(blocker, %{ap_id: ap_id}) do
 989     block(blocker, get_cached_by_ap_id(ap_id))
 990   end
 991
 992   def unblock(blocker, %{ap_id: ap_id}) do
 993     info_cng =
 994       blocker.info
 995       |> User.Info.remove_from_block(ap_id)
 996
 997     cng =
 998       change(blocker)
 999       |> put_embed(:info, info_cng)
1000
1001     update_and_set_cache(cng)
1002   end
1003
1004   def mutes?(nil, _), do: false
1005   def mutes?(user, %{ap_id: ap_id}), do: Enum.member?(user.info.mutes, ap_id)
1006
1007   @spec muted_notifications?(User.t() | nil, User.t() | map()) :: boolean()
1008   def muted_notifications?(nil, _), do: false
1009
1010   def muted_notifications?(user, %{ap_id: ap_id}),
1011     do: Enum.member?(user.info.muted_notifications, ap_id)
1012
1013   def blocks?(%User{} = user, %User{} = target) do
1014     blocks_ap_id?(user, target) || blocks_domain?(user, target)
1015   end
1016
1017   def blocks?(nil, _), do: false
1018
1019   def blocks_ap_id?(%User{} = user, %User{} = target) do
1020     Enum.member?(user.info.blocks, target.ap_id)
1021   end
1022
1023   def blocks_ap_id?(_, _), do: false
1024
1025   def blocks_domain?(%User{} = user, %User{} = target) do
1026     domain_blocks = Pleroma.Web.ActivityPub.MRF.subdomains_regex(user.info.domain_blocks)
1027     %{host: host} = URI.parse(target.ap_id)
1028     Pleroma.Web.ActivityPub.MRF.subdomain_match?(domain_blocks, host)
1029   end
1030
1031   def blocks_domain?(_, _), do: false
1032
1033   def subscribed_to?(user, %{ap_id: ap_id}) do
1034     with %User{} = target <- get_cached_by_ap_id(ap_id) do
1035       Enum.member?(target.info.subscribers, user.ap_id)
1036     end
1037   end
1038
1039   @spec muted_users(User.t()) :: [User.t()]
1040   def muted_users(user) do
1041     User.Query.build(%{ap_id: user.info.mutes, deactivated: false})
1042     |> Repo.all()
1043   end
1044
1045   @spec blocked_users(User.t()) :: [User.t()]
1046   def blocked_users(user) do
1047     User.Query.build(%{ap_id: user.info.blocks, deactivated: false})
1048     |> Repo.all()
1049   end
1050
1051   @spec subscribers(User.t()) :: [User.t()]
1052   def subscribers(user) do
1053     User.Query.build(%{ap_id: user.info.subscribers, deactivated: false})
1054     |> Repo.all()
1055   end
1056
1057   def block_domain(user, domain) do
1058     info_cng =
1059       user.info
1060       |> User.Info.add_to_domain_block(domain)
1061
1062     cng =
1063       change(user)
1064       |> put_embed(:info, info_cng)
1065
1066     update_and_set_cache(cng)
1067   end
1068
1069   def unblock_domain(user, domain) do
1070     info_cng =
1071       user.info
1072       |> User.Info.remove_from_domain_block(domain)
1073
1074     cng =
1075       change(user)
1076       |> put_embed(:info, info_cng)
1077
1078     update_and_set_cache(cng)
1079   end
1080
1081   def deactivate_async(user, status \\ true) do
1082     PleromaJobQueue.enqueue(:background, __MODULE__, [:deactivate_async, user, status])
1083   end
1084
1085   def deactivate(%User{} = user, status \\ true) do
1086     info_cng = User.Info.set_activation_status(user.info, status)
1087
1088     with {:ok, friends} <- User.get_friends(user),
1089          {:ok, followers} <- User.get_followers(user),
1090          {:ok, user} <-
1091            user
1092            |> change()
1093            |> put_embed(:info, info_cng)
1094            |> update_and_set_cache() do
1095       Enum.each(followers, &invalidate_cache(&1))
1096       Enum.each(friends, &update_follower_count(&1))
1097
1098       {:ok, user}
1099     end
1100   end
1101
1102   def update_notification_settings(%User{} = user, settings \\ %{}) do
1103     info_changeset = User.Info.update_notification_settings(user.info, settings)
1104
1105     change(user)
1106     |> put_embed(:info, info_changeset)
1107     |> update_and_set_cache()
1108   end
1109
1110   @spec delete(User.t()) :: :ok
1111   def delete(%User{} = user),
1112     do: PleromaJobQueue.enqueue(:background, __MODULE__, [:delete, user])
1113
1114   @spec perform(atom(), User.t()) :: {:ok, User.t()}
1115   def perform(:delete, %User{} = user) do
1116     {:ok, _user} = ActivityPub.delete(user)
1117
1118     # Remove all relationships
1119     {:ok, followers} = User.get_followers(user)
1120
1121     Enum.each(followers, fn follower ->
1122       ActivityPub.unfollow(follower, user)
1123       User.unfollow(follower, user)
1124     end)
1125
1126     {:ok, friends} = User.get_friends(user)
1127
1128     Enum.each(friends, fn followed ->
1129       ActivityPub.unfollow(user, followed)
1130       User.unfollow(user, followed)
1131     end)
1132
1133     delete_user_activities(user)
1134     invalidate_cache(user)
1135     Repo.delete(user)
1136   end
1137
1138   @spec perform(atom(), User.t()) :: {:ok, User.t()}
1139   def perform(:fetch_initial_posts, %User{} = user) do
1140     pages = Pleroma.Config.get!([:fetch_initial_posts, :pages])
1141
1142     Enum.each(
1143       # Insert all the posts in reverse order, so they're in the right order on the timeline
1144       Enum.reverse(Utils.fetch_ordered_collection(user.info.source_data["outbox"], pages)),
1145       &Pleroma.Web.Federator.incoming_ap_doc/1
1146     )
1147
1148     {:ok, user}
1149   end
1150
1151   def perform(:deactivate_async, user, status), do: deactivate(user, status)
1152
1153   @spec perform(atom(), User.t(), list()) :: list() | {:error, any()}
1154   def perform(:blocks_import, %User{} = blocker, blocked_identifiers)
1155       when is_list(blocked_identifiers) do
1156     Enum.map(
1157       blocked_identifiers,
1158       fn blocked_identifier ->
1159         with {:ok, %User{} = blocked} <- get_or_fetch(blocked_identifier),
1160              {:ok, blocker} <- block(blocker, blocked),
1161              {:ok, _} <- ActivityPub.block(blocker, blocked) do
1162           blocked
1163         else
1164           err ->
1165             Logger.debug("blocks_import failed for #{blocked_identifier} with: #{inspect(err)}")
1166             err
1167         end
1168       end
1169     )
1170   end
1171
1172   @spec perform(atom(), User.t(), list()) :: list() | {:error, any()}
1173   def perform(:follow_import, %User{} = follower, followed_identifiers)
1174       when is_list(followed_identifiers) do
1175     Enum.map(
1176       followed_identifiers,
1177       fn followed_identifier ->
1178         with {:ok, %User{} = followed} <- get_or_fetch(followed_identifier),
1179              {:ok, follower} <- maybe_direct_follow(follower, followed),
1180              {:ok, _} <- ActivityPub.follow(follower, followed) do
1181           followed
1182         else
1183           err ->
1184             Logger.debug("follow_import failed for #{followed_identifier} with: #{inspect(err)}")
1185             err
1186         end
1187       end
1188     )
1189   end
1190
1191   @spec external_users_query() :: Ecto.Query.t()
1192   def external_users_query do
1193     User.Query.build(%{
1194       external: true,
1195       active: true,
1196       order_by: :id
1197     })
1198   end
1199
1200   @spec external_users(keyword()) :: [User.t()]
1201   def external_users(opts \\ []) do
1202     query =
1203       external_users_query()
1204       |> select([u], struct(u, [:id, :ap_id, :info]))
1205
1206     query =
1207       if opts[:max_id],
1208         do: where(query, [u], u.id > ^opts[:max_id]),
1209         else: query
1210
1211     query =
1212       if opts[:limit],
1213         do: limit(query, ^opts[:limit]),
1214         else: query
1215
1216     Repo.all(query)
1217   end
1218
1219   def blocks_import(%User{} = blocker, blocked_identifiers) when is_list(blocked_identifiers),
1220     do:
1221       PleromaJobQueue.enqueue(:background, __MODULE__, [
1222         :blocks_import,
1223         blocker,
1224         blocked_identifiers
1225       ])
1226
1227   def follow_import(%User{} = follower, followed_identifiers) when is_list(followed_identifiers),
1228     do:
1229       PleromaJobQueue.enqueue(:background, __MODULE__, [
1230         :follow_import,
1231         follower,
1232         followed_identifiers
1233       ])
1234
1235   def delete_user_activities(%User{ap_id: ap_id} = user) do
1236     ap_id
1237     |> Activity.Queries.by_actor()
1238     |> RepoStreamer.chunk_stream(50)
1239     |> Stream.each(fn activities ->
1240       Enum.each(activities, &delete_activity(&1))
1241     end)
1242     |> Stream.run()
1243
1244     {:ok, user}
1245   end
1246
1247   defp delete_activity(%{data: %{"type" => "Create"}} = activity) do
1248     activity
1249     |> Object.normalize()
1250     |> ActivityPub.delete()
1251   end
1252
1253   defp delete_activity(%{data: %{"type" => "Like"}} = activity) do
1254     user = get_cached_by_ap_id(activity.actor)
1255     object = Object.normalize(activity)
1256
1257     ActivityPub.unlike(user, object)
1258   end
1259
1260   defp delete_activity(%{data: %{"type" => "Announce"}} = activity) do
1261     user = get_cached_by_ap_id(activity.actor)
1262     object = Object.normalize(activity)
1263
1264     ActivityPub.unannounce(user, object)
1265   end
1266
1267   defp delete_activity(_activity), do: "Doing nothing"
1268
1269   def html_filter_policy(%User{info: %{no_rich_text: true}}) do
1270     Pleroma.HTML.Scrubber.TwitterText
1271   end
1272
1273   def html_filter_policy(_), do: Pleroma.Config.get([:markup, :scrub_policy])
1274
1275   def fetch_by_ap_id(ap_id) do
1276     ap_try = ActivityPub.make_user_from_ap_id(ap_id)
1277
1278     case ap_try do
1279       {:ok, user} ->
1280         {:ok, user}
1281
1282       _ ->
1283         case OStatus.make_user(ap_id) do
1284           {:ok, user} -> {:ok, user}
1285           _ -> {:error, "Could not fetch by AP id"}
1286         end
1287     end
1288   end
1289
1290   def get_or_fetch_by_ap_id(ap_id) do
1291     user = get_cached_by_ap_id(ap_id)
1292
1293     if !is_nil(user) and !User.needs_update?(user) do
1294       {:ok, user}
1295     else
1296       # Whether to fetch initial posts for the user (if it's a new user & the fetching is enabled)
1297       should_fetch_initial = is_nil(user) and Pleroma.Config.get([:fetch_initial_posts, :enabled])
1298
1299       resp = fetch_by_ap_id(ap_id)
1300
1301       if should_fetch_initial do
1302         with {:ok, %User{} = user} <- resp do
1303           fetch_initial_posts(user)
1304         end
1305       end
1306
1307       resp
1308     end
1309   end
1310
1311   @doc "Creates an internal service actor by URI if missing.  Optionally takes nickname for addressing."
1312   def get_or_create_service_actor_by_ap_id(uri, nickname \\ nil) do
1313     if user = get_cached_by_ap_id(uri) do
1314       user
1315     else
1316       changes =
1317         %User{info: %User.Info{}}
1318         |> cast(%{}, [:ap_id, :nickname, :local])
1319         |> put_change(:ap_id, uri)
1320         |> put_change(:nickname, nickname)
1321         |> put_change(:local, true)
1322         |> put_change(:follower_address, uri <> "/followers")
1323
1324       {:ok, user} = Repo.insert(changes)
1325       user
1326     end
1327   end
1328
1329   # AP style
1330   def public_key_from_info(%{
1331         source_data: %{"publicKey" => %{"publicKeyPem" => public_key_pem}}
1332       }) do
1333     key =
1334       public_key_pem
1335       |> :public_key.pem_decode()
1336       |> hd()
1337       |> :public_key.pem_entry_decode()
1338
1339     {:ok, key}
1340   end
1341
1342   # OStatus Magic Key
1343   def public_key_from_info(%{magic_key: magic_key}) when not is_nil(magic_key) do
1344     {:ok, Pleroma.Web.Salmon.decode_key(magic_key)}
1345   end
1346
1347   def public_key_from_info(_), do: {:error, "not found key"}
1348
1349   def get_public_key_for_ap_id(ap_id) do
1350     with {:ok, %User{} = user} <- get_or_fetch_by_ap_id(ap_id),
1351          {:ok, public_key} <- public_key_from_info(user.info) do
1352       {:ok, public_key}
1353     else
1354       _ -> :error
1355     end
1356   end
1357
1358   defp blank?(""), do: nil
1359   defp blank?(n), do: n
1360
1361   def insert_or_update_user(data) do
1362     data
1363     |> Map.put(:name, blank?(data[:name]) || data[:nickname])
1364     |> remote_user_creation()
1365     |> Repo.insert(on_conflict: :replace_all_except_primary_key, conflict_target: :nickname)
1366     |> set_cache()
1367   end
1368
1369   def ap_enabled?(%User{local: true}), do: true
1370   def ap_enabled?(%User{info: info}), do: info.ap_enabled
1371   def ap_enabled?(_), do: false
1372
1373   @doc "Gets or fetch a user by uri or nickname."
1374   @spec get_or_fetch(String.t()) :: {:ok, User.t()} | {:error, String.t()}
1375   def get_or_fetch("http" <> _host = uri), do: get_or_fetch_by_ap_id(uri)
1376   def get_or_fetch(nickname), do: get_or_fetch_by_nickname(nickname)
1377
1378   # wait a period of time and return newest version of the User structs
1379   # this is because we have synchronous follow APIs and need to simulate them
1380   # with an async handshake
1381   def wait_and_refresh(_, %User{local: true} = a, %User{local: true} = b) do
1382     with %User{} = a <- User.get_cached_by_id(a.id),
1383          %User{} = b <- User.get_cached_by_id(b.id) do
1384       {:ok, a, b}
1385     else
1386       _e ->
1387         :error
1388     end
1389   end
1390
1391   def wait_and_refresh(timeout, %User{} = a, %User{} = b) do
1392     with :ok <- :timer.sleep(timeout),
1393          %User{} = a <- User.get_cached_by_id(a.id),
1394          %User{} = b <- User.get_cached_by_id(b.id) do
1395       {:ok, a, b}
1396     else
1397       _e ->
1398         :error
1399     end
1400   end
1401
1402   def parse_bio(bio) when is_binary(bio) and bio != "" do
1403     bio
1404     |> CommonUtils.format_input("text/plain", mentions_format: :full)
1405     |> elem(0)
1406   end
1407
1408   def parse_bio(_), do: ""
1409
1410   def parse_bio(bio, user) when is_binary(bio) and bio != "" do
1411     # TODO: get profile URLs other than user.ap_id
1412     profile_urls = [user.ap_id]
1413
1414     bio
1415     |> CommonUtils.format_input("text/plain",
1416       mentions_format: :full,
1417       rel: &RelMe.maybe_put_rel_me(&1, profile_urls)
1418     )
1419     |> elem(0)
1420   end
1421
1422   def parse_bio(_, _), do: ""
1423
1424   def tag(user_identifiers, tags) when is_list(user_identifiers) do
1425     Repo.transaction(fn ->
1426       for user_identifier <- user_identifiers, do: tag(user_identifier, tags)
1427     end)
1428   end
1429
1430   def tag(nickname, tags) when is_binary(nickname),
1431     do: tag(get_by_nickname(nickname), tags)
1432
1433   def tag(%User{} = user, tags),
1434     do: update_tags(user, Enum.uniq((user.tags || []) ++ normalize_tags(tags)))
1435
1436   def untag(user_identifiers, tags) when is_list(user_identifiers) do
1437     Repo.transaction(fn ->
1438       for user_identifier <- user_identifiers, do: untag(user_identifier, tags)
1439     end)
1440   end
1441
1442   def untag(nickname, tags) when is_binary(nickname),
1443     do: untag(get_by_nickname(nickname), tags)
1444
1445   def untag(%User{} = user, tags),
1446     do: update_tags(user, (user.tags || []) -- normalize_tags(tags))
1447
1448   defp update_tags(%User{} = user, new_tags) do
1449     {:ok, updated_user} =
1450       user
1451       |> change(%{tags: new_tags})
1452       |> update_and_set_cache()
1453
1454     updated_user
1455   end
1456
1457   defp normalize_tags(tags) do
1458     [tags]
1459     |> List.flatten()
1460     |> Enum.map(&String.downcase(&1))
1461   end
1462
1463   defp local_nickname_regex do
1464     if Pleroma.Config.get([:instance, :extended_nickname_format]) do
1465       @extended_local_nickname_regex
1466     else
1467       @strict_local_nickname_regex
1468     end
1469   end
1470
1471   def local_nickname(nickname_or_mention) do
1472     nickname_or_mention
1473     |> full_nickname()
1474     |> String.split("@")
1475     |> hd()
1476   end
1477
1478   def full_nickname(nickname_or_mention),
1479     do: String.trim_leading(nickname_or_mention, "@")
1480
1481   def error_user(ap_id) do
1482     %User{
1483       name: ap_id,
1484       ap_id: ap_id,
1485       info: %User.Info{},
1486       nickname: "erroruser@example.com",
1487       inserted_at: NaiveDateTime.utc_now()
1488     }
1489   end
1490
1491   @spec all_superusers() :: [User.t()]
1492   def all_superusers do
1493     User.Query.build(%{super_users: true, local: true, deactivated: false})
1494     |> Repo.all()
1495   end
1496
1497   def showing_reblogs?(%User{} = user, %User{} = target) do
1498     target.ap_id not in user.info.muted_reblogs
1499   end
1500
1501   @doc """
1502   The function returns a query to get users with no activity for given interval of days.
1503   Inactive users are those who didn't read any notification, or had any activity where
1504   the user is the activity's actor, during `inactivity_threshold` days.
1505   Deactivated users will not appear in this list.
1506
1507   ## Examples
1508
1509       iex> Pleroma.User.list_inactive_users()
1510       %Ecto.Query{}
1511   """
1512   @spec list_inactive_users_query(integer()) :: Ecto.Query.t()
1513   def list_inactive_users_query(inactivity_threshold \\ 7) do
1514     negative_inactivity_threshold = -inactivity_threshold
1515     now = NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
1516     # Subqueries are not supported in `where` clauses, join gets too complicated.
1517     has_read_notifications =
1518       from(n in Pleroma.Notification,
1519         where: n.seen == true,
1520         group_by: n.id,
1521         having: max(n.updated_at) > datetime_add(^now, ^negative_inactivity_threshold, "day"),
1522         select: n.user_id
1523       )
1524       |> Pleroma.Repo.all()
1525
1526     from(u in Pleroma.User,
1527       left_join: a in Pleroma.Activity,
1528       on: u.ap_id == a.actor,
1529       where: not is_nil(u.nickname),
1530       where: fragment("not (?->'deactivated' @> 'true')", u.info),
1531       where: u.id not in ^has_read_notifications,
1532       group_by: u.id,
1533       having:
1534         max(a.inserted_at) < datetime_add(^now, ^negative_inactivity_threshold, "day") or
1535           is_nil(max(a.inserted_at))
1536     )
1537   end
1538
1539   @doc """
1540   Enable or disable email notifications for user
1541
1542   ## Examples
1543
1544       iex> Pleroma.User.switch_email_notifications(Pleroma.User{info: %{email_notifications: %{"digest" => false}}}, "digest", true)
1545       Pleroma.User{info: %{email_notifications: %{"digest" => true}}}
1546
1547       iex> Pleroma.User.switch_email_notifications(Pleroma.User{info: %{email_notifications: %{"digest" => true}}}, "digest", false)
1548       Pleroma.User{info: %{email_notifications: %{"digest" => false}}}
1549   """
1550   @spec switch_email_notifications(t(), String.t(), boolean()) ::
1551           {:ok, t()} | {:error, Ecto.Changeset.t()}
1552   def switch_email_notifications(user, type, status) do
1553     info = Pleroma.User.Info.update_email_notifications(user.info, %{type => status})
1554
1555     change(user)
1556     |> put_embed(:info, info)
1557     |> update_and_set_cache()
1558   end
1559
1560   @doc """
1561   Set `last_digest_emailed_at` value for the user to current time
1562   """
1563   @spec touch_last_digest_emailed_at(t()) :: t()
1564   def touch_last_digest_emailed_at(user) do
1565     now = NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
1566
1567     {:ok, updated_user} =
1568       user
1569       |> change(%{last_digest_emailed_at: now})
1570       |> update_and_set_cache()
1571
1572     updated_user
1573   end
1574
1575   @spec toggle_confirmation(User.t()) :: {:ok, User.t()} | {:error, Changeset.t()}
1576   def toggle_confirmation(%User{} = user) do
1577     need_confirmation? = !user.info.confirmation_pending
1578
1579     info_changeset =
1580       User.Info.confirmation_changeset(user.info, need_confirmation: need_confirmation?)
1581
1582     user
1583     |> change()
1584     |> put_embed(:info, info_changeset)
1585     |> update_and_set_cache()
1586   end
1587
1588   def get_mascot(%{info: %{mascot: %{} = mascot}}) when not is_nil(mascot) do
1589     mascot
1590   end
1591
1592   def get_mascot(%{info: %{mascot: mascot}}) when is_nil(mascot) do
1593     # use instance-default
1594     config = Pleroma.Config.get([:assets, :mascots])
1595     default_mascot = Pleroma.Config.get([:assets, :default_mascot])
1596     mascot = Keyword.get(config, default_mascot)
1597
1598     %{
1599       "id" => "default-mascot",
1600       "url" => mascot[:url],
1601       "preview_url" => mascot[:url],
1602       "pleroma" => %{
1603         "mime_type" => mascot[:mime_type]
1604       }
1605     }
1606   end
1607
1608   def ensure_keys_present(%User{info: info} = user) do
1609     if info.keys do
1610       {:ok, user}
1611     else
1612       {:ok, pem} = Keys.generate_rsa_pem()
1613
1614       user
1615       |> Ecto.Changeset.change()
1616       |> Ecto.Changeset.put_embed(:info, User.Info.set_keys(info, pem))
1617       |> update_and_set_cache()
1618     end
1619   end
1620
1621   def get_ap_ids_by_nicknames(nicknames) do
1622     from(u in User,
1623       where: u.nickname in ^nicknames,
1624       select: u.ap_id
1625     )
1626     |> Repo.all()
1627   end
1628
1629   defdelegate search(query, opts \\ []), to: User.Search
1630
1631   defp put_password_hash(
1632          %Ecto.Changeset{valid?: true, changes: %{password: password}} = changeset
1633        ) do
1634     change(changeset, password_hash: Pbkdf2.hashpwsalt(password))
1635   end
1636
1637   defp put_password_hash(changeset), do: changeset
1638
1639   def is_internal_user?(%User{nickname: nil}), do: true
1640   def is_internal_user?(%User{local: true, nickname: "internal." <> _}), do: true
1641   def is_internal_user?(_), do: false
1642
1643   def change_email(user, email) do
1644     user
1645     |> cast(%{email: email}, [:email])
1646     |> validate_required([:email])
1647     |> unique_constraint(:email)
1648     |> validate_format(:email, @email_regex)
1649     |> update_and_set_cache()
1650   end
1651 end