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 Pleroma.Activity
  13   alias Pleroma.Formatter
  14   alias Pleroma.Notification
  15   alias Pleroma.Object
  16   alias Pleroma.Registration
  17   alias Pleroma.Repo
  18   alias Pleroma.User
  19   alias Pleroma.Web
  20   alias Pleroma.Web.ActivityPub.ActivityPub
  21   alias Pleroma.Web.ActivityPub.Utils
  22   alias Pleroma.Web.CommonAPI.Utils, as: CommonUtils
  23   alias Pleroma.Web.OAuth
  24   alias Pleroma.Web.OStatus
  25   alias Pleroma.Web.RelMe
  26   alias Pleroma.Web.Websub
  27
  28   require Logger
  29
  30   @type t :: %__MODULE__{}
  31
  32   @primary_key {:id, Pleroma.FlakeId, autogenerate: true}
  33
  34   # credo:disable-for-next-line Credo.Check.Readability.MaxLineLength
  35   @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])?)*$/
  36
  37   @strict_local_nickname_regex ~r/^[a-zA-Z\d]+$/
  38   @extended_local_nickname_regex ~r/^[a-zA-Z\d_-]+$/
  39
  40   schema "users" do
  41     field(:bio, :string)
  42     field(:email, :string)
  43     field(:name, :string)
  44     field(:nickname, :string)
  45     field(:password_hash, :string)
  46     field(:password, :string, virtual: true)
  47     field(:password_confirmation, :string, virtual: true)
  48     field(:following, {:array, :string}, default: [])
  49     field(:ap_id, :string)
  50     field(:avatar, :map)
  51     field(:local, :boolean, default: true)
  52     field(:follower_address, :string)
  53     field(:search_rank, :float, virtual: true)
  54     field(:search_type, :integer, virtual: true)
  55     field(:tags, {:array, :string}, default: [])
  56     field(:bookmarks, {:array, :string}, default: [])
  57     field(:last_refreshed_at, :naive_datetime_usec)
  58     has_many(:notifications, Notification)
  59     has_many(:registrations, Registration)
  60     embeds_one(:info, Pleroma.User.Info)
  61
  62     timestamps()
  63   end
  64
  65   def auth_active?(%User{info: %User.Info{confirmation_pending: true}}),
  66     do: !Pleroma.Config.get([:instance, :account_activation_required])
  67
  68   def auth_active?(%User{}), do: true
  69
  70   def visible_for?(user, for_user \\ nil)
  71
  72   def visible_for?(%User{id: user_id}, %User{id: for_id}) when user_id == for_id, do: true
  73
  74   def visible_for?(%User{} = user, for_user) do
  75     auth_active?(user) || superuser?(for_user)
  76   end
  77
  78   def visible_for?(_, _), do: false
  79
  80   def superuser?(%User{local: true, info: %User.Info{is_admin: true}}), do: true
  81   def superuser?(%User{local: true, info: %User.Info{is_moderator: true}}), do: true
  82   def superuser?(_), do: false
  83
  84   def avatar_url(user, options \\ []) do
  85     case user.avatar do
  86       %{"url" => [%{"href" => href} | _]} -> href
  87       _ -> !options[:no_default] && "#{Web.base_url()}/images/avi.png"
  88     end
  89   end
  90
  91   def banner_url(user, options \\ []) do
  92     case user.info.banner do
  93       %{"url" => [%{"href" => href} | _]} -> href
  94       _ -> !options[:no_default] && "#{Web.base_url()}/images/banner.png"
  95     end
  96   end
  97
  98   def profile_url(%User{info: %{source_data: %{"url" => url}}}), do: url
  99   def profile_url(%User{ap_id: ap_id}), do: ap_id
 100   def profile_url(_), do: nil
 101
 102   def ap_id(%User{nickname: nickname}) do
 103     "#{Web.base_url()}/users/#{nickname}"
 104   end
 105
 106   def ap_followers(%User{follower_address: fa}) when is_binary(fa), do: fa
 107   def ap_followers(%User{} = user), do: "#{ap_id(user)}/followers"
 108
 109   def user_info(%User{} = user) do
 110     oneself = if user.local, do: 1, else: 0
 111
 112     %{
 113       following_count: length(user.following) - oneself,
 114       note_count: user.info.note_count,
 115       follower_count: user.info.follower_count,
 116       locked: user.info.locked,
 117       confirmation_pending: user.info.confirmation_pending,
 118       default_scope: user.info.default_scope
 119     }
 120   end
 121
 122   def remote_user_creation(params) do
 123     params =
 124       params
 125       |> Map.put(:info, params[:info] || %{})
 126
 127     info_cng = User.Info.remote_user_creation(%User.Info{}, params[:info])
 128
 129     changes =
 130       %User{}
 131       |> cast(params, [:bio, :name, :ap_id, :nickname, :avatar])
 132       |> validate_required([:name, :ap_id])
 133       |> unique_constraint(:nickname)
 134       |> validate_format(:nickname, @email_regex)
 135       |> validate_length(:bio, max: 5000)
 136       |> validate_length(:name, max: 100)
 137       |> put_change(:local, false)
 138       |> put_embed(:info, info_cng)
 139
 140     if changes.valid? do
 141       case info_cng.changes[:source_data] do
 142         %{"followers" => followers} ->
 143           changes
 144           |> put_change(:follower_address, followers)
 145
 146         _ ->
 147           followers = User.ap_followers(%User{nickname: changes.changes[:nickname]})
 148
 149           changes
 150           |> put_change(:follower_address, followers)
 151       end
 152     else
 153       changes
 154     end
 155   end
 156
 157   def update_changeset(struct, params \\ %{}) do
 158     struct
 159     |> cast(params, [:bio, :name, :avatar])
 160     |> unique_constraint(:nickname)
 161     |> validate_format(:nickname, local_nickname_regex())
 162     |> validate_length(:bio, max: 5000)
 163     |> validate_length(:name, min: 1, max: 100)
 164   end
 165
 166   def upgrade_changeset(struct, params \\ %{}) do
 167     params =
 168       params
 169       |> Map.put(:last_refreshed_at, NaiveDateTime.utc_now())
 170
 171     info_cng =
 172       struct.info
 173       |> User.Info.user_upgrade(params[:info])
 174
 175     struct
 176     |> cast(params, [:bio, :name, :follower_address, :avatar, :last_refreshed_at])
 177     |> unique_constraint(:nickname)
 178     |> validate_format(:nickname, local_nickname_regex())
 179     |> validate_length(:bio, max: 5000)
 180     |> validate_length(:name, max: 100)
 181     |> put_embed(:info, info_cng)
 182   end
 183
 184   def password_update_changeset(struct, params) do
 185     changeset =
 186       struct
 187       |> cast(params, [:password, :password_confirmation])
 188       |> validate_required([:password, :password_confirmation])
 189       |> validate_confirmation(:password)
 190
 191     OAuth.Token.delete_user_tokens(struct)
 192     OAuth.Authorization.delete_user_authorizations(struct)
 193
 194     if changeset.valid? do
 195       hashed = Pbkdf2.hashpwsalt(changeset.changes[:password])
 196
 197       changeset
 198       |> put_change(:password_hash, hashed)
 199     else
 200       changeset
 201     end
 202   end
 203
 204   def reset_password(user, data) do
 205     update_and_set_cache(password_update_changeset(user, data))
 206   end
 207
 208   def register_changeset(struct, params \\ %{}, opts \\ []) do
 209     confirmation_status =
 210       if opts[:confirmed] || !Pleroma.Config.get([:instance, :account_activation_required]) do
 211         :confirmed
 212       else
 213         :unconfirmed
 214       end
 215
 216     info_change = User.Info.confirmation_changeset(%User.Info{}, confirmation_status)
 217
 218     changeset =
 219       struct
 220       |> cast(params, [:bio, :email, :name, :nickname, :password, :password_confirmation])
 221       |> validate_required([:name, :nickname, :password, :password_confirmation])
 222       |> validate_confirmation(:password)
 223       |> unique_constraint(:email)
 224       |> unique_constraint(:nickname)
 225       |> validate_exclusion(:nickname, Pleroma.Config.get([Pleroma.User, :restricted_nicknames]))
 226       |> validate_format(:nickname, local_nickname_regex())
 227       |> validate_format(:email, @email_regex)
 228       |> validate_length(:bio, max: 1000)
 229       |> validate_length(:name, min: 1, max: 100)
 230       |> put_change(:info, info_change)
 231
 232     changeset =
 233       if opts[:external] do
 234         changeset
 235       else
 236         validate_required(changeset, [:email])
 237       end
 238
 239     if changeset.valid? do
 240       hashed = Pbkdf2.hashpwsalt(changeset.changes[:password])
 241       ap_id = User.ap_id(%User{nickname: changeset.changes[:nickname]})
 242       followers = User.ap_followers(%User{nickname: changeset.changes[:nickname]})
 243
 244       changeset
 245       |> put_change(:password_hash, hashed)
 246       |> put_change(:ap_id, ap_id)
 247       |> unique_constraint(:ap_id)
 248       |> put_change(:following, [followers])
 249       |> put_change(:follower_address, followers)
 250     else
 251       changeset
 252     end
 253   end
 254
 255   defp autofollow_users(user) do
 256     candidates = Pleroma.Config.get([:instance, :autofollowed_nicknames])
 257
 258     autofollowed_users =
 259       from(u in User,
 260         where: u.local == true,
 261         where: u.nickname in ^candidates
 262       )
 263       |> Repo.all()
 264
 265     follow_all(user, autofollowed_users)
 266   end
 267
 268   @doc "Inserts provided changeset, performs post-registration actions (confirmation email sending etc.)"
 269   def register(%Ecto.Changeset{} = changeset) do
 270     with {:ok, user} <- Repo.insert(changeset),
 271          {:ok, user} <- autofollow_users(user),
 272          {:ok, _} <- Pleroma.User.WelcomeMessage.post_welcome_message_to_user(user),
 273          {:ok, _} <- try_send_confirmation_email(user) do
 274       {:ok, user}
 275     end
 276   end
 277
 278   def try_send_confirmation_email(%User{} = user) do
 279     if user.info.confirmation_pending &&
 280          Pleroma.Config.get([:instance, :account_activation_required]) do
 281       user
 282       |> Pleroma.UserEmail.account_confirmation_email()
 283       |> Pleroma.Mailer.deliver_async()
 284     else
 285       {:ok, :noop}
 286     end
 287   end
 288
 289   def needs_update?(%User{local: true}), do: false
 290
 291   def needs_update?(%User{local: false, last_refreshed_at: nil}), do: true
 292
 293   def needs_update?(%User{local: false} = user) do
 294     NaiveDateTime.diff(NaiveDateTime.utc_now(), user.last_refreshed_at) >= 86_400
 295   end
 296
 297   def needs_update?(_), do: true
 298
 299   def maybe_direct_follow(%User{} = follower, %User{local: true, info: %{locked: true}}) do
 300     {:ok, follower}
 301   end
 302
 303   def maybe_direct_follow(%User{} = follower, %User{local: true} = followed) do
 304     follow(follower, followed)
 305   end
 306
 307   def maybe_direct_follow(%User{} = follower, %User{} = followed) do
 308     if not User.ap_enabled?(followed) do
 309       follow(follower, followed)
 310     else
 311       {:ok, follower}
 312     end
 313   end
 314
 315   def maybe_follow(%User{} = follower, %User{info: _info} = followed) do
 316     if not following?(follower, followed) do
 317       follow(follower, followed)
 318     else
 319       {:ok, follower}
 320     end
 321   end
 322
 323   @doc "A mass follow for local users. Respects blocks in both directions but does not create activities."
 324   @spec follow_all(User.t(), list(User.t())) :: {atom(), User.t()}
 325   def follow_all(follower, followeds) do
 326     followed_addresses =
 327       followeds
 328       |> Enum.reject(fn followed -> blocks?(follower, followed) || blocks?(followed, follower) end)
 329       |> Enum.map(fn %{follower_address: fa} -> fa end)
 330
 331     q =
 332       from(u in User,
 333         where: u.id == ^follower.id,
 334         update: [
 335           set: [
 336             following:
 337               fragment(
 338                 "array(select distinct unnest (array_cat(?, ?)))",
 339                 u.following,
 340                 ^followed_addresses
 341               )
 342           ]
 343         ],
 344         select: u
 345       )
 346
 347     {1, [follower]} = Repo.update_all(q, [])
 348
 349     Enum.each(followeds, fn followed ->
 350       update_follower_count(followed)
 351     end)
 352
 353     set_cache(follower)
 354   end
 355
 356   def follow(%User{} = follower, %User{info: info} = followed) do
 357     user_config = Application.get_env(:pleroma, :user)
 358     deny_follow_blocked = Keyword.get(user_config, :deny_follow_blocked)
 359
 360     ap_followers = followed.follower_address
 361
 362     cond do
 363       following?(follower, followed) or info.deactivated ->
 364         {:error, "Could not follow user: #{followed.nickname} is already on your list."}
 365
 366       deny_follow_blocked and blocks?(followed, follower) ->
 367         {:error, "Could not follow user: #{followed.nickname} blocked you."}
 368
 369       true ->
 370         if !followed.local && follower.local && !ap_enabled?(followed) do
 371           Websub.subscribe(follower, followed)
 372         end
 373
 374         q =
 375           from(u in User,
 376             where: u.id == ^follower.id,
 377             update: [push: [following: ^ap_followers]],
 378             select: u
 379           )
 380
 381         {1, [follower]} = Repo.update_all(q, [])
 382
 383         {:ok, _} = update_follower_count(followed)
 384
 385         set_cache(follower)
 386     end
 387   end
 388
 389   def unfollow(%User{} = follower, %User{} = followed) do
 390     ap_followers = followed.follower_address
 391
 392     if following?(follower, followed) and follower.ap_id != followed.ap_id do
 393       q =
 394         from(u in User,
 395           where: u.id == ^follower.id,
 396           update: [pull: [following: ^ap_followers]],
 397           select: u
 398         )
 399
 400       {1, [follower]} = Repo.update_all(q, [])
 401
 402       {:ok, followed} = update_follower_count(followed)
 403
 404       set_cache(follower)
 405
 406       {:ok, follower, Utils.fetch_latest_follow(follower, followed)}
 407     else
 408       {:error, "Not subscribed!"}
 409     end
 410   end
 411
 412   @spec following?(User.t(), User.t()) :: boolean
 413   def following?(%User{} = follower, %User{} = followed) do
 414     Enum.member?(follower.following, followed.follower_address)
 415   end
 416
 417   def follow_import(%User{} = follower, followed_identifiers)
 418       when is_list(followed_identifiers) do
 419     Enum.map(
 420       followed_identifiers,
 421       fn followed_identifier ->
 422         with %User{} = followed <- get_or_fetch(followed_identifier),
 423              {:ok, follower} <- maybe_direct_follow(follower, followed),
 424              {:ok, _} <- ActivityPub.follow(follower, followed) do
 425           followed
 426         else
 427           err ->
 428             Logger.debug("follow_import failed for #{followed_identifier} with: #{inspect(err)}")
 429             err
 430         end
 431       end
 432     )
 433   end
 434
 435   def locked?(%User{} = user) do
 436     user.info.locked || false
 437   end
 438
 439   def get_by_id(id) do
 440     Repo.get_by(User, id: id)
 441   end
 442
 443   def get_by_ap_id(ap_id) do
 444     Repo.get_by(User, ap_id: ap_id)
 445   end
 446
 447   # This is mostly an SPC migration fix. This guesses the user nickname by taking the last part
 448   # of the ap_id and the domain and tries to get that user
 449   def get_by_guessed_nickname(ap_id) do
 450     domain = URI.parse(ap_id).host
 451     name = List.last(String.split(ap_id, "/"))
 452     nickname = "#{name}@#{domain}"
 453
 454     get_by_nickname(nickname)
 455   end
 456
 457   def set_cache(user) do
 458     Cachex.put(:user_cache, "ap_id:#{user.ap_id}", user)
 459     Cachex.put(:user_cache, "nickname:#{user.nickname}", user)
 460     Cachex.put(:user_cache, "user_info:#{user.id}", user_info(user))
 461     {:ok, user}
 462   end
 463
 464   def update_and_set_cache(changeset) do
 465     with {:ok, user} <- Repo.update(changeset) do
 466       set_cache(user)
 467     else
 468       e -> e
 469     end
 470   end
 471
 472   def invalidate_cache(user) do
 473     Cachex.del(:user_cache, "ap_id:#{user.ap_id}")
 474     Cachex.del(:user_cache, "nickname:#{user.nickname}")
 475     Cachex.del(:user_cache, "user_info:#{user.id}")
 476   end
 477
 478   def get_cached_by_ap_id(ap_id) do
 479     key = "ap_id:#{ap_id}"
 480     Cachex.fetch!(:user_cache, key, fn _ -> get_by_ap_id(ap_id) end)
 481   end
 482
 483   def get_cached_by_id(id) do
 484     key = "id:#{id}"
 485
 486     ap_id =
 487       Cachex.fetch!(:user_cache, key, fn _ ->
 488         user = get_by_id(id)
 489
 490         if user do
 491           Cachex.put(:user_cache, "ap_id:#{user.ap_id}", user)
 492           {:commit, user.ap_id}
 493         else
 494           {:ignore, ""}
 495         end
 496       end)
 497
 498     get_cached_by_ap_id(ap_id)
 499   end
 500
 501   def get_cached_by_nickname(nickname) do
 502     key = "nickname:#{nickname}"
 503     Cachex.fetch!(:user_cache, key, fn _ -> get_or_fetch_by_nickname(nickname) end)
 504   end
 505
 506   def get_cached_by_nickname_or_id(nickname_or_id) do
 507     get_cached_by_id(nickname_or_id) || get_cached_by_nickname(nickname_or_id)
 508   end
 509
 510   def get_by_nickname(nickname) do
 511     Repo.get_by(User, nickname: nickname) ||
 512       if Regex.match?(~r(@#{Pleroma.Web.Endpoint.host()})i, nickname) do
 513         Repo.get_by(User, nickname: local_nickname(nickname))
 514       end
 515   end
 516
 517   def get_by_email(email), do: Repo.get_by(User, email: email)
 518
 519   def get_by_nickname_or_email(nickname_or_email) do
 520     get_by_nickname(nickname_or_email) || get_by_email(nickname_or_email)
 521   end
 522
 523   def get_cached_user_info(user) do
 524     key = "user_info:#{user.id}"
 525     Cachex.fetch!(:user_cache, key, fn _ -> user_info(user) end)
 526   end
 527
 528   def fetch_by_nickname(nickname) do
 529     ap_try = ActivityPub.make_user_from_nickname(nickname)
 530
 531     case ap_try do
 532       {:ok, user} -> {:ok, user}
 533       _ -> OStatus.make_user(nickname)
 534     end
 535   end
 536
 537   def get_or_fetch_by_nickname(nickname) do
 538     with %User{} = user <- get_by_nickname(nickname) do
 539       user
 540     else
 541       _e ->
 542         with [_nick, _domain] <- String.split(nickname, "@"),
 543              {:ok, user} <- fetch_by_nickname(nickname) do
 544           if Pleroma.Config.get([:fetch_initial_posts, :enabled]) do
 545             {:ok, _} = Task.start(__MODULE__, :fetch_initial_posts, [user])
 546           end
 547
 548           user
 549         else
 550           _e -> nil
 551         end
 552     end
 553   end
 554
 555   @doc "Fetch some posts when the user has just been federated with"
 556   def fetch_initial_posts(user) do
 557     pages = Pleroma.Config.get!([:fetch_initial_posts, :pages])
 558
 559     Enum.each(
 560       # Insert all the posts in reverse order, so they're in the right order on the timeline
 561       Enum.reverse(Utils.fetch_ordered_collection(user.info.source_data["outbox"], pages)),
 562       &Pleroma.Web.Federator.incoming_ap_doc/1
 563     )
 564   end
 565
 566   def get_followers_query(%User{id: id, follower_address: follower_address}, nil) do
 567     from(
 568       u in User,
 569       where: fragment("? <@ ?", ^[follower_address], u.following),
 570       where: u.id != ^id
 571     )
 572   end
 573
 574   def get_followers_query(user, page) do
 575     from(u in get_followers_query(user, nil))
 576     |> paginate(page, 20)
 577   end
 578
 579   def get_followers_query(user), do: get_followers_query(user, nil)
 580
 581   def get_followers(user, page \\ nil) do
 582     q = get_followers_query(user, page)
 583
 584     {:ok, Repo.all(q)}
 585   end
 586
 587   def get_followers_ids(user, page \\ nil) do
 588     q = get_followers_query(user, page)
 589
 590     Repo.all(from(u in q, select: u.id))
 591   end
 592
 593   def get_friends_query(%User{id: id, following: following}, nil) do
 594     from(
 595       u in User,
 596       where: u.follower_address in ^following,
 597       where: u.id != ^id
 598     )
 599   end
 600
 601   def get_friends_query(user, page) do
 602     from(u in get_friends_query(user, nil))
 603     |> paginate(page, 20)
 604   end
 605
 606   def get_friends_query(user), do: get_friends_query(user, nil)
 607
 608   def get_friends(user, page \\ nil) do
 609     q = get_friends_query(user, page)
 610
 611     {:ok, Repo.all(q)}
 612   end
 613
 614   def get_friends_ids(user, page \\ nil) do
 615     q = get_friends_query(user, page)
 616
 617     Repo.all(from(u in q, select: u.id))
 618   end
 619
 620   def get_follow_requests_query(%User{} = user) do
 621     from(
 622       a in Activity,
 623       where:
 624         fragment(
 625           "? ->> 'type' = 'Follow'",
 626           a.data
 627         ),
 628       where:
 629         fragment(
 630           "? ->> 'state' = 'pending'",
 631           a.data
 632         ),
 633       where:
 634         fragment(
 635           "coalesce((?)->'object'->>'id', (?)->>'object') = ?",
 636           a.data,
 637           a.data,
 638           ^user.ap_id
 639         )
 640     )
 641   end
 642
 643   def get_follow_requests(%User{} = user) do
 644     users =
 645       user
 646       |> User.get_follow_requests_query()
 647       |> join(:inner, [a], u in User, on: a.actor == u.ap_id)
 648       |> where([a, u], not fragment("? @> ?", u.following, ^[user.follower_address]))
 649       |> group_by([a, u], u.id)
 650       |> select([a, u], u)
 651       |> Repo.all()
 652
 653     {:ok, users}
 654   end
 655
 656   def increase_note_count(%User{} = user) do
 657     User
 658     |> where(id: ^user.id)
 659     |> update([u],
 660       set: [
 661         info:
 662           fragment(
 663             "jsonb_set(?, '{note_count}', ((?->>'note_count')::int + 1)::varchar::jsonb, true)",
 664             u.info,
 665             u.info
 666           )
 667       ]
 668     )
 669     |> select([u], u)
 670     |> Repo.update_all([])
 671     |> case do
 672       {1, [user]} -> set_cache(user)
 673       _ -> {:error, user}
 674     end
 675   end
 676
 677   def decrease_note_count(%User{} = user) do
 678     User
 679     |> where(id: ^user.id)
 680     |> update([u],
 681       set: [
 682         info:
 683           fragment(
 684             "jsonb_set(?, '{note_count}', (greatest(0, (?->>'note_count')::int - 1))::varchar::jsonb, true)",
 685             u.info,
 686             u.info
 687           )
 688       ]
 689     )
 690     |> select([u], u)
 691     |> Repo.update_all([])
 692     |> case do
 693       {1, [user]} -> set_cache(user)
 694       _ -> {:error, user}
 695     end
 696   end
 697
 698   def update_note_count(%User{} = user) do
 699     note_count_query =
 700       from(
 701         a in Object,
 702         where: fragment("?->>'actor' = ? and ?->>'type' = 'Note'", a.data, ^user.ap_id, a.data),
 703         select: count(a.id)
 704       )
 705
 706     note_count = Repo.one(note_count_query)
 707
 708     info_cng = User.Info.set_note_count(user.info, note_count)
 709
 710     cng =
 711       change(user)
 712       |> put_embed(:info, info_cng)
 713
 714     update_and_set_cache(cng)
 715   end
 716
 717   def update_follower_count(%User{} = user) do
 718     follower_count_query =
 719       User
 720       |> where([u], ^user.follower_address in u.following)
 721       |> where([u], u.id != ^user.id)
 722       |> select([u], %{count: count(u.id)})
 723
 724     User
 725     |> where(id: ^user.id)
 726     |> join(:inner, [u], s in subquery(follower_count_query))
 727     |> update([u, s],
 728       set: [
 729         info:
 730           fragment(
 731             "jsonb_set(?, '{follower_count}', ?::varchar::jsonb, true)",
 732             u.info,
 733             s.count
 734           )
 735       ]
 736     )
 737     |> select([u], u)
 738     |> Repo.update_all([])
 739     |> case do
 740       {1, [user]} -> set_cache(user)
 741       _ -> {:error, user}
 742     end
 743   end
 744
 745   def get_users_from_set_query(ap_ids, false) do
 746     from(
 747       u in User,
 748       where: u.ap_id in ^ap_ids
 749     )
 750   end
 751
 752   def get_users_from_set_query(ap_ids, true) do
 753     query = get_users_from_set_query(ap_ids, false)
 754
 755     from(
 756       u in query,
 757       where: u.local == true
 758     )
 759   end
 760
 761   def get_users_from_set(ap_ids, local_only \\ true) do
 762     get_users_from_set_query(ap_ids, local_only)
 763     |> Repo.all()
 764   end
 765
 766   def get_recipients_from_activity(%Activity{recipients: to}) do
 767     query =
 768       from(
 769         u in User,
 770         where: u.ap_id in ^to,
 771         or_where: fragment("? && ?", u.following, ^to)
 772       )
 773
 774     query = from(u in query, where: u.local == true)
 775
 776     Repo.all(query)
 777   end
 778
 779   def search(query, resolve \\ false, for_user \\ nil) do
 780     # Strip the beginning @ off if there is a query
 781     query = String.trim_leading(query, "@")
 782
 783     if resolve, do: get_or_fetch(query)
 784
 785     {:ok, results} =
 786       Repo.transaction(fn ->
 787         Ecto.Adapters.SQL.query(Repo, "select set_limit(0.25)", [])
 788         Repo.all(search_query(query, for_user))
 789       end)
 790
 791     results
 792   end
 793
 794   def search_query(query, for_user) do
 795     fts_subquery = fts_search_subquery(query)
 796     trigram_subquery = trigram_search_subquery(query)
 797     union_query = from(s in trigram_subquery, union_all: ^fts_subquery)
 798     distinct_query = from(s in subquery(union_query), order_by: s.search_type, distinct: s.id)
 799
 800     from(s in subquery(boost_search_rank_query(distinct_query, for_user)),
 801       order_by: [desc: s.search_rank],
 802       limit: 20
 803     )
 804   end
 805
 806   defp boost_search_rank_query(query, nil), do: query
 807
 808   defp boost_search_rank_query(query, for_user) do
 809     friends_ids = get_friends_ids(for_user)
 810     followers_ids = get_followers_ids(for_user)
 811
 812     from(u in subquery(query),
 813       select_merge: %{
 814         search_rank:
 815           fragment(
 816             """
 817              CASE WHEN (?) THEN (?) * 1.3
 818              WHEN (?) THEN (?) * 1.2
 819              WHEN (?) THEN (?) * 1.1
 820              ELSE (?) END
 821             """,
 822             u.id in ^friends_ids and u.id in ^followers_ids,
 823             u.search_rank,
 824             u.id in ^friends_ids,
 825             u.search_rank,
 826             u.id in ^followers_ids,
 827             u.search_rank,
 828             u.search_rank
 829           )
 830       }
 831     )
 832   end
 833
 834   defp fts_search_subquery(term, query \\ User) do
 835     processed_query =
 836       term
 837       |> String.replace(~r/\W+/, " ")
 838       |> String.trim()
 839       |> String.split()
 840       |> Enum.map(&(&1 <> ":*"))
 841       |> Enum.join(" | ")
 842
 843     from(
 844       u in query,
 845       select_merge: %{
 846         search_type: ^0,
 847         search_rank:
 848           fragment(
 849             """
 850             ts_rank_cd(
 851               setweight(to_tsvector('simple', regexp_replace(?, '\\W', ' ', 'g')), 'A') ||
 852               setweight(to_tsvector('simple', regexp_replace(coalesce(?, ''), '\\W', ' ', 'g')), 'B'),
 853               to_tsquery('simple', ?),
 854               32
 855             )
 856             """,
 857             u.nickname,
 858             u.name,
 859             ^processed_query
 860           )
 861       },
 862       where:
 863         fragment(
 864           """
 865             (setweight(to_tsvector('simple', regexp_replace(?, '\\W', ' ', 'g')), 'A') ||
 866             setweight(to_tsvector('simple', regexp_replace(coalesce(?, ''), '\\W', ' ', 'g')), 'B')) @@ to_tsquery('simple', ?)
 867           """,
 868           u.nickname,
 869           u.name,
 870           ^processed_query
 871         )
 872     )
 873   end
 874
 875   defp trigram_search_subquery(term) do
 876     from(
 877       u in User,
 878       select_merge: %{
 879         # ^1 gives 'Postgrex expected a binary, got 1' for some weird reason
 880         search_type: fragment("?", 1),
 881         search_rank:
 882           fragment(
 883             "similarity(?, trim(? || ' ' || coalesce(?, '')))",
 884             ^term,
 885             u.nickname,
 886             u.name
 887           )
 888       },
 889       where: fragment("trim(? || ' ' || coalesce(?, '')) % ?", u.nickname, u.name, ^term)
 890     )
 891   end
 892
 893   def blocks_import(%User{} = blocker, blocked_identifiers) when is_list(blocked_identifiers) do
 894     Enum.map(
 895       blocked_identifiers,
 896       fn blocked_identifier ->
 897         with %User{} = blocked <- get_or_fetch(blocked_identifier),
 898              {:ok, blocker} <- block(blocker, blocked),
 899              {:ok, _} <- ActivityPub.block(blocker, blocked) do
 900           blocked
 901         else
 902           err ->
 903             Logger.debug("blocks_import failed for #{blocked_identifier} with: #{inspect(err)}")
 904             err
 905         end
 906       end
 907     )
 908   end
 909
 910   def mute(muter, %User{ap_id: ap_id}) do
 911     info_cng =
 912       muter.info
 913       |> User.Info.add_to_mutes(ap_id)
 914
 915     cng =
 916       change(muter)
 917       |> put_embed(:info, info_cng)
 918
 919     update_and_set_cache(cng)
 920   end
 921
 922   def unmute(muter, %{ap_id: ap_id}) do
 923     info_cng =
 924       muter.info
 925       |> User.Info.remove_from_mutes(ap_id)
 926
 927     cng =
 928       change(muter)
 929       |> put_embed(:info, info_cng)
 930
 931     update_and_set_cache(cng)
 932   end
 933
 934   def block(blocker, %User{ap_id: ap_id} = blocked) do
 935     # sever any follow relationships to prevent leaks per activitypub (Pleroma issue #213)
 936     blocker =
 937       if following?(blocker, blocked) do
 938         {:ok, blocker, _} = unfollow(blocker, blocked)
 939         blocker
 940       else
 941         blocker
 942       end
 943
 944     if following?(blocked, blocker) do
 945       unfollow(blocked, blocker)
 946     end
 947
 948     {:ok, blocker} = update_follower_count(blocker)
 949
 950     info_cng =
 951       blocker.info
 952       |> User.Info.add_to_block(ap_id)
 953
 954     cng =
 955       change(blocker)
 956       |> put_embed(:info, info_cng)
 957
 958     update_and_set_cache(cng)
 959   end
 960
 961   # helper to handle the block given only an actor's AP id
 962   def block(blocker, %{ap_id: ap_id}) do
 963     block(blocker, User.get_by_ap_id(ap_id))
 964   end
 965
 966   def unblock(blocker, %{ap_id: ap_id}) do
 967     info_cng =
 968       blocker.info
 969       |> User.Info.remove_from_block(ap_id)
 970
 971     cng =
 972       change(blocker)
 973       |> put_embed(:info, info_cng)
 974
 975     update_and_set_cache(cng)
 976   end
 977
 978   def mutes?(nil, _), do: false
 979   def mutes?(user, %{ap_id: ap_id}), do: Enum.member?(user.info.mutes, ap_id)
 980
 981   def blocks?(user, %{ap_id: ap_id}) do
 982     blocks = user.info.blocks
 983     domain_blocks = user.info.domain_blocks
 984     %{host: host} = URI.parse(ap_id)
 985
 986     Enum.member?(blocks, ap_id) ||
 987       Enum.any?(domain_blocks, fn domain ->
 988         host == domain
 989       end)
 990   end
 991
 992   def muted_users(user),
 993     do: Repo.all(from(u in User, where: u.ap_id in ^user.info.mutes))
 994
 995   def blocked_users(user),
 996     do: Repo.all(from(u in User, where: u.ap_id in ^user.info.blocks))
 997
 998   def block_domain(user, domain) do
 999     info_cng =
1000       user.info
1001       |> User.Info.add_to_domain_block(domain)
1002
1003     cng =
1004       change(user)
1005       |> put_embed(:info, info_cng)
1006
1007     update_and_set_cache(cng)
1008   end
1009
1010   def unblock_domain(user, domain) do
1011     info_cng =
1012       user.info
1013       |> User.Info.remove_from_domain_block(domain)
1014
1015     cng =
1016       change(user)
1017       |> put_embed(:info, info_cng)
1018
1019     update_and_set_cache(cng)
1020   end
1021
1022   def maybe_local_user_query(query, local) do
1023     if local, do: local_user_query(query), else: query
1024   end
1025
1026   def local_user_query(query \\ User) do
1027     from(
1028       u in query,
1029       where: u.local == true,
1030       where: not is_nil(u.nickname)
1031     )
1032   end
1033
1034   def maybe_external_user_query(query, external) do
1035     if external, do: external_user_query(query), else: query
1036   end
1037
1038   def external_user_query(query \\ User) do
1039     from(
1040       u in query,
1041       where: u.local == false,
1042       where: not is_nil(u.nickname)
1043     )
1044   end
1045
1046   def maybe_active_user_query(query, active) do
1047     if active, do: active_user_query(query), else: query
1048   end
1049
1050   def active_user_query(query \\ User) do
1051     from(
1052       u in query,
1053       where: fragment("not (?->'deactivated' @> 'true')", u.info),
1054       where: not is_nil(u.nickname)
1055     )
1056   end
1057
1058   def maybe_deactivated_user_query(query, deactivated) do
1059     if deactivated, do: deactivated_user_query(query), else: query
1060   end
1061
1062   def deactivated_user_query(query \\ User) do
1063     from(
1064       u in query,
1065       where: fragment("(?->'deactivated' @> 'true')", u.info),
1066       where: not is_nil(u.nickname)
1067     )
1068   end
1069
1070   def active_local_user_query do
1071     from(
1072       u in local_user_query(),
1073       where: fragment("not (?->'deactivated' @> 'true')", u.info)
1074     )
1075   end
1076
1077   def moderator_user_query do
1078     from(
1079       u in User,
1080       where: u.local == true,
1081       where: fragment("?->'is_moderator' @> 'true'", u.info)
1082     )
1083   end
1084
1085   def deactivate(%User{} = user, status \\ true) do
1086     info_cng = User.Info.set_activation_status(user.info, status)
1087
1088     cng =
1089       change(user)
1090       |> put_embed(:info, info_cng)
1091
1092     update_and_set_cache(cng)
1093   end
1094
1095   def update_notification_settings(%User{} = user, settings \\ %{}) do
1096     info_changeset = User.Info.update_notification_settings(user.info, settings)
1097
1098     change(user)
1099     |> put_embed(:info, info_changeset)
1100     |> update_and_set_cache()
1101   end
1102
1103   def delete(%User{} = user) do
1104     {:ok, user} = User.deactivate(user)
1105
1106     # Remove all relationships
1107     {:ok, followers} = User.get_followers(user)
1108
1109     Enum.each(followers, fn follower -> User.unfollow(follower, user) end)
1110
1111     {:ok, friends} = User.get_friends(user)
1112
1113     Enum.each(friends, fn followed -> User.unfollow(user, followed) end)
1114
1115     delete_user_activities(user)
1116   end
1117
1118   def delete_user_activities(%User{ap_id: ap_id} = user) do
1119     Activity
1120     |> where(actor: ^ap_id)
1121     |> Activity.with_preloaded_object()
1122     |> Repo.all()
1123     |> Enum.each(fn
1124       %{data: %{"type" => "Create"}} = activity ->
1125         activity |> Object.normalize() |> ActivityPub.delete()
1126
1127       # TODO: Do something with likes, follows, repeats.
1128       _ ->
1129         "Doing nothing"
1130     end)
1131
1132     {:ok, user}
1133   end
1134
1135   def html_filter_policy(%User{info: %{no_rich_text: true}}) do
1136     Pleroma.HTML.Scrubber.TwitterText
1137   end
1138
1139   @default_scrubbers Pleroma.Config.get([:markup, :scrub_policy])
1140
1141   def html_filter_policy(_), do: @default_scrubbers
1142
1143   def fetch_by_ap_id(ap_id) do
1144     ap_try = ActivityPub.make_user_from_ap_id(ap_id)
1145
1146     case ap_try do
1147       {:ok, user} ->
1148         user
1149
1150       _ ->
1151         case OStatus.make_user(ap_id) do
1152           {:ok, user} -> user
1153           _ -> {:error, "Could not fetch by AP id"}
1154         end
1155     end
1156   end
1157
1158   def get_or_fetch_by_ap_id(ap_id) do
1159     user = get_by_ap_id(ap_id)
1160
1161     if !is_nil(user) and !User.needs_update?(user) do
1162       user
1163     else
1164       # Whether to fetch initial posts for the user (if it's a new user & the fetching is enabled)
1165       should_fetch_initial = is_nil(user) and Pleroma.Config.get([:fetch_initial_posts, :enabled])
1166
1167       user = fetch_by_ap_id(ap_id)
1168
1169       if should_fetch_initial do
1170         with %User{} = user do
1171           {:ok, _} = Task.start(__MODULE__, :fetch_initial_posts, [user])
1172         end
1173       end
1174
1175       user
1176     end
1177   end
1178
1179   def get_or_create_instance_user do
1180     relay_uri = "#{Pleroma.Web.Endpoint.url()}/relay"
1181
1182     if user = get_by_ap_id(relay_uri) do
1183       user
1184     else
1185       changes =
1186         %User{info: %User.Info{}}
1187         |> cast(%{}, [:ap_id, :nickname, :local])
1188         |> put_change(:ap_id, relay_uri)
1189         |> put_change(:nickname, nil)
1190         |> put_change(:local, true)
1191         |> put_change(:follower_address, relay_uri <> "/followers")
1192
1193       {:ok, user} = Repo.insert(changes)
1194       user
1195     end
1196   end
1197
1198   # AP style
1199   def public_key_from_info(%{
1200         source_data: %{"publicKey" => %{"publicKeyPem" => public_key_pem}}
1201       }) do
1202     key =
1203       public_key_pem
1204       |> :public_key.pem_decode()
1205       |> hd()
1206       |> :public_key.pem_entry_decode()
1207
1208     {:ok, key}
1209   end
1210
1211   # OStatus Magic Key
1212   def public_key_from_info(%{magic_key: magic_key}) do
1213     {:ok, Pleroma.Web.Salmon.decode_key(magic_key)}
1214   end
1215
1216   def get_public_key_for_ap_id(ap_id) do
1217     with %User{} = user <- get_or_fetch_by_ap_id(ap_id),
1218          {:ok, public_key} <- public_key_from_info(user.info) do
1219       {:ok, public_key}
1220     else
1221       _ -> :error
1222     end
1223   end
1224
1225   defp blank?(""), do: nil
1226   defp blank?(n), do: n
1227
1228   def insert_or_update_user(data) do
1229     data =
1230       data
1231       |> Map.put(:name, blank?(data[:name]) || data[:nickname])
1232
1233     cs = User.remote_user_creation(data)
1234
1235     Repo.insert(cs, on_conflict: :replace_all, conflict_target: :nickname)
1236   end
1237
1238   def ap_enabled?(%User{local: true}), do: true
1239   def ap_enabled?(%User{info: info}), do: info.ap_enabled
1240   def ap_enabled?(_), do: false
1241
1242   @doc "Gets or fetch a user by uri or nickname."
1243   @spec get_or_fetch(String.t()) :: User.t()
1244   def get_or_fetch("http" <> _host = uri), do: get_or_fetch_by_ap_id(uri)
1245   def get_or_fetch(nickname), do: get_or_fetch_by_nickname(nickname)
1246
1247   # wait a period of time and return newest version of the User structs
1248   # this is because we have synchronous follow APIs and need to simulate them
1249   # with an async handshake
1250   def wait_and_refresh(_, %User{local: true} = a, %User{local: true} = b) do
1251     with %User{} = a <- User.get_by_id(a.id),
1252          %User{} = b <- User.get_by_id(b.id) do
1253       {:ok, a, b}
1254     else
1255       _e ->
1256         :error
1257     end
1258   end
1259
1260   def wait_and_refresh(timeout, %User{} = a, %User{} = b) do
1261     with :ok <- :timer.sleep(timeout),
1262          %User{} = a <- User.get_by_id(a.id),
1263          %User{} = b <- User.get_by_id(b.id) do
1264       {:ok, a, b}
1265     else
1266       _e ->
1267         :error
1268     end
1269   end
1270
1271   def parse_bio(bio, user \\ %User{info: %{source_data: %{}}})
1272   def parse_bio(nil, _user), do: ""
1273   def parse_bio(bio, _user) when bio == "", do: bio
1274
1275   def parse_bio(bio, user) do
1276     emoji =
1277       (user.info.source_data["tag"] || [])
1278       |> Enum.filter(fn %{"type" => t} -> t == "Emoji" end)
1279       |> Enum.map(fn %{"icon" => %{"url" => url}, "name" => name} ->
1280         {String.trim(name, ":"), url}
1281       end)
1282
1283     # TODO: get profile URLs other than user.ap_id
1284     profile_urls = [user.ap_id]
1285
1286     bio
1287     |> CommonUtils.format_input("text/plain",
1288       mentions_format: :full,
1289       rel: &RelMe.maybe_put_rel_me(&1, profile_urls)
1290     )
1291     |> elem(0)
1292     |> Formatter.emojify(emoji)
1293   end
1294
1295   def tag(user_identifiers, tags) when is_list(user_identifiers) do
1296     Repo.transaction(fn ->
1297       for user_identifier <- user_identifiers, do: tag(user_identifier, tags)
1298     end)
1299   end
1300
1301   def tag(nickname, tags) when is_binary(nickname),
1302     do: tag(User.get_by_nickname(nickname), tags)
1303
1304   def tag(%User{} = user, tags),
1305     do: update_tags(user, Enum.uniq((user.tags || []) ++ normalize_tags(tags)))
1306
1307   def untag(user_identifiers, tags) when is_list(user_identifiers) do
1308     Repo.transaction(fn ->
1309       for user_identifier <- user_identifiers, do: untag(user_identifier, tags)
1310     end)
1311   end
1312
1313   def untag(nickname, tags) when is_binary(nickname),
1314     do: untag(User.get_by_nickname(nickname), tags)
1315
1316   def untag(%User{} = user, tags),
1317     do: update_tags(user, (user.tags || []) -- normalize_tags(tags))
1318
1319   defp update_tags(%User{} = user, new_tags) do
1320     {:ok, updated_user} =
1321       user
1322       |> change(%{tags: new_tags})
1323       |> update_and_set_cache()
1324
1325     updated_user
1326   end
1327
1328   def bookmark(%User{} = user, status_id) do
1329     bookmarks = Enum.uniq(user.bookmarks ++ [status_id])
1330     update_bookmarks(user, bookmarks)
1331   end
1332
1333   def unbookmark(%User{} = user, status_id) do
1334     bookmarks = Enum.uniq(user.bookmarks -- [status_id])
1335     update_bookmarks(user, bookmarks)
1336   end
1337
1338   def update_bookmarks(%User{} = user, bookmarks) do
1339     user
1340     |> change(%{bookmarks: bookmarks})
1341     |> update_and_set_cache
1342   end
1343
1344   defp normalize_tags(tags) do
1345     [tags]
1346     |> List.flatten()
1347     |> Enum.map(&String.downcase(&1))
1348   end
1349
1350   defp local_nickname_regex do
1351     if Pleroma.Config.get([:instance, :extended_nickname_format]) do
1352       @extended_local_nickname_regex
1353     else
1354       @strict_local_nickname_regex
1355     end
1356   end
1357
1358   def local_nickname(nickname_or_mention) do
1359     nickname_or_mention
1360     |> full_nickname()
1361     |> String.split("@")
1362     |> hd()
1363   end
1364
1365   def full_nickname(nickname_or_mention),
1366     do: String.trim_leading(nickname_or_mention, "@")
1367
1368   def error_user(ap_id) do
1369     %User{
1370       name: ap_id,
1371       ap_id: ap_id,
1372       info: %User.Info{},
1373       nickname: "erroruser@example.com",
1374       inserted_at: NaiveDateTime.utc_now()
1375     }
1376   end
1377
1378   def all_superusers do
1379     from(
1380       u in User,
1381       where: u.local == true,
1382       where: fragment("?->'is_admin' @> 'true' OR ?->'is_moderator' @> 'true'", u.info, u.info)
1383     )
1384     |> Repo.all()
1385   end
1386
1387   defp paginate(query, page, page_size) do
1388     from(u in query,
1389       limit: ^page_size,
1390       offset: ^((page - 1) * page_size)
1391     )
1392   end
1393
1394   def showing_reblogs?(%User{} = user, %User{} = target) do
1395     target.ap_id not in user.info.muted_reblogs
1396   end
1397 end