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