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