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     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, User.get_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   def blocks?(user, %{ap_id: ap_id}) do
 980     blocks = user.info.blocks
 981     domain_blocks = user.info.domain_blocks
 982     %{host: host} = URI.parse(ap_id)
 983
 984     Enum.member?(blocks, ap_id) ||
 985       Enum.any?(domain_blocks, fn domain ->
 986         host == domain
 987       end)
 988   end
 989
 990   def muted_users(user),
 991     do: Repo.all(from(u in User, where: u.ap_id in ^user.info.mutes))
 992
 993   def blocked_users(user),
 994     do: Repo.all(from(u in User, where: u.ap_id in ^user.info.blocks))
 995
 996   def block_domain(user, domain) do
 997     info_cng =
 998       user.info
 999       |> User.Info.add_to_domain_block(domain)
1000
1001     cng =
1002       change(user)
1003       |> put_embed(:info, info_cng)
1004
1005     update_and_set_cache(cng)
1006   end
1007
1008   def unblock_domain(user, domain) do
1009     info_cng =
1010       user.info
1011       |> User.Info.remove_from_domain_block(domain)
1012
1013     cng =
1014       change(user)
1015       |> put_embed(:info, info_cng)
1016
1017     update_and_set_cache(cng)
1018   end
1019
1020   def maybe_local_user_query(query, local) do
1021     if local, do: local_user_query(query), else: query
1022   end
1023
1024   def local_user_query(query \\ User) do
1025     from(
1026       u in query,
1027       where: u.local == true,
1028       where: not is_nil(u.nickname)
1029     )
1030   end
1031
1032   def maybe_external_user_query(query, external) do
1033     if external, do: external_user_query(query), else: query
1034   end
1035
1036   def external_user_query(query \\ User) do
1037     from(
1038       u in query,
1039       where: u.local == false,
1040       where: not is_nil(u.nickname)
1041     )
1042   end
1043
1044   def maybe_active_user_query(query, active) do
1045     if active, do: active_user_query(query), else: query
1046   end
1047
1048   def active_user_query(query \\ User) do
1049     from(
1050       u in query,
1051       where: fragment("not (?->'deactivated' @> 'true')", u.info),
1052       where: not is_nil(u.nickname)
1053     )
1054   end
1055
1056   def maybe_deactivated_user_query(query, deactivated) do
1057     if deactivated, do: deactivated_user_query(query), else: query
1058   end
1059
1060   def deactivated_user_query(query \\ User) do
1061     from(
1062       u in query,
1063       where: fragment("(?->'deactivated' @> 'true')", u.info),
1064       where: not is_nil(u.nickname)
1065     )
1066   end
1067
1068   def active_local_user_query do
1069     from(
1070       u in local_user_query(),
1071       where: fragment("not (?->'deactivated' @> 'true')", u.info)
1072     )
1073   end
1074
1075   def moderator_user_query do
1076     from(
1077       u in User,
1078       where: u.local == true,
1079       where: fragment("?->'is_moderator' @> 'true'", u.info)
1080     )
1081   end
1082
1083   def deactivate(%User{} = user, status \\ true) do
1084     info_cng = User.Info.set_activation_status(user.info, status)
1085
1086     cng =
1087       change(user)
1088       |> put_embed(:info, info_cng)
1089
1090     update_and_set_cache(cng)
1091   end
1092
1093   def delete(%User{} = user) do
1094     {:ok, user} = User.deactivate(user)
1095
1096     # Remove all relationships
1097     {:ok, followers} = User.get_followers(user)
1098
1099     followers
1100     |> Enum.each(fn follower -> User.unfollow(follower, user) end)
1101
1102     {:ok, friends} = User.get_friends(user)
1103
1104     friends
1105     |> Enum.each(fn followed -> User.unfollow(user, followed) end)
1106
1107     query =
1108       from(a in Activity, where: a.actor == ^user.ap_id)
1109       |> Activity.with_preloaded_object()
1110
1111     Repo.all(query)
1112     |> Enum.each(fn activity ->
1113       case activity.data["type"] do
1114         "Create" ->
1115           ActivityPub.delete(Object.normalize(activity))
1116
1117         # TODO: Do something with likes, follows, repeats.
1118         _ ->
1119           "Doing nothing"
1120       end
1121     end)
1122
1123     {:ok, user}
1124   end
1125
1126   def html_filter_policy(%User{info: %{no_rich_text: true}}) do
1127     Pleroma.HTML.Scrubber.TwitterText
1128   end
1129
1130   @default_scrubbers Pleroma.Config.get([:markup, :scrub_policy])
1131
1132   def html_filter_policy(_), do: @default_scrubbers
1133
1134   def fetch_by_ap_id(ap_id) do
1135     ap_try = ActivityPub.make_user_from_ap_id(ap_id)
1136
1137     case ap_try do
1138       {:ok, user} ->
1139         user
1140
1141       _ ->
1142         case OStatus.make_user(ap_id) do
1143           {:ok, user} -> user
1144           _ -> {:error, "Could not fetch by AP id"}
1145         end
1146     end
1147   end
1148
1149   def get_or_fetch_by_ap_id(ap_id) do
1150     user = get_by_ap_id(ap_id)
1151
1152     if !is_nil(user) and !User.needs_update?(user) do
1153       user
1154     else
1155       # Whether to fetch initial posts for the user (if it's a new user & the fetching is enabled)
1156       should_fetch_initial = is_nil(user) and Pleroma.Config.get([:fetch_initial_posts, :enabled])
1157
1158       user = fetch_by_ap_id(ap_id)
1159
1160       if should_fetch_initial do
1161         with %User{} = user do
1162           {:ok, _} = Task.start(__MODULE__, :fetch_initial_posts, [user])
1163         end
1164       end
1165
1166       user
1167     end
1168   end
1169
1170   def get_or_create_instance_user do
1171     relay_uri = "#{Pleroma.Web.Endpoint.url()}/relay"
1172
1173     if user = get_by_ap_id(relay_uri) do
1174       user
1175     else
1176       changes =
1177         %User{info: %User.Info{}}
1178         |> cast(%{}, [:ap_id, :nickname, :local])
1179         |> put_change(:ap_id, relay_uri)
1180         |> put_change(:nickname, nil)
1181         |> put_change(:local, true)
1182         |> put_change(:follower_address, relay_uri <> "/followers")
1183
1184       {:ok, user} = Repo.insert(changes)
1185       user
1186     end
1187   end
1188
1189   # AP style
1190   def public_key_from_info(%{
1191         source_data: %{"publicKey" => %{"publicKeyPem" => public_key_pem}}
1192       }) do
1193     key =
1194       public_key_pem
1195       |> :public_key.pem_decode()
1196       |> hd()
1197       |> :public_key.pem_entry_decode()
1198
1199     {:ok, key}
1200   end
1201
1202   # OStatus Magic Key
1203   def public_key_from_info(%{magic_key: magic_key}) do
1204     {:ok, Pleroma.Web.Salmon.decode_key(magic_key)}
1205   end
1206
1207   def get_public_key_for_ap_id(ap_id) do
1208     with %User{} = user <- get_or_fetch_by_ap_id(ap_id),
1209          {:ok, public_key} <- public_key_from_info(user.info) do
1210       {:ok, public_key}
1211     else
1212       _ -> :error
1213     end
1214   end
1215
1216   defp blank?(""), do: nil
1217   defp blank?(n), do: n
1218
1219   def insert_or_update_user(data) do
1220     data =
1221       data
1222       |> Map.put(:name, blank?(data[:name]) || data[:nickname])
1223
1224     cs = User.remote_user_creation(data)
1225
1226     Repo.insert(cs, on_conflict: :replace_all, conflict_target: :nickname)
1227   end
1228
1229   def ap_enabled?(%User{local: true}), do: true
1230   def ap_enabled?(%User{info: info}), do: info.ap_enabled
1231   def ap_enabled?(_), do: false
1232
1233   @doc "Gets or fetch a user by uri or nickname."
1234   @spec get_or_fetch(String.t()) :: User.t()
1235   def get_or_fetch("http" <> _host = uri), do: get_or_fetch_by_ap_id(uri)
1236   def get_or_fetch(nickname), do: get_or_fetch_by_nickname(nickname)
1237
1238   # wait a period of time and return newest version of the User structs
1239   # this is because we have synchronous follow APIs and need to simulate them
1240   # with an async handshake
1241   def wait_and_refresh(_, %User{local: true} = a, %User{local: true} = b) do
1242     with %User{} = a <- Repo.get(User, a.id),
1243          %User{} = b <- Repo.get(User, b.id) do
1244       {:ok, a, b}
1245     else
1246       _e ->
1247         :error
1248     end
1249   end
1250
1251   def wait_and_refresh(timeout, %User{} = a, %User{} = b) do
1252     with :ok <- :timer.sleep(timeout),
1253          %User{} = a <- Repo.get(User, a.id),
1254          %User{} = b <- Repo.get(User, b.id) do
1255       {:ok, a, b}
1256     else
1257       _e ->
1258         :error
1259     end
1260   end
1261
1262   def parse_bio(bio, user \\ %User{info: %{source_data: %{}}})
1263   def parse_bio(nil, _user), do: ""
1264   def parse_bio(bio, _user) when bio == "", do: bio
1265
1266   def parse_bio(bio, user) do
1267     emoji =
1268       (user.info.source_data["tag"] || [])
1269       |> Enum.filter(fn %{"type" => t} -> t == "Emoji" end)
1270       |> Enum.map(fn %{"icon" => %{"url" => url}, "name" => name} ->
1271         {String.trim(name, ":"), url}
1272       end)
1273
1274     # TODO: get profile URLs other than user.ap_id
1275     profile_urls = [user.ap_id]
1276
1277     bio
1278     |> CommonUtils.format_input("text/plain",
1279       mentions_format: :full,
1280       rel: &RelMe.maybe_put_rel_me(&1, profile_urls)
1281     )
1282     |> elem(0)
1283     |> Formatter.emojify(emoji)
1284   end
1285
1286   def tag(user_identifiers, tags) when is_list(user_identifiers) do
1287     Repo.transaction(fn ->
1288       for user_identifier <- user_identifiers, do: tag(user_identifier, tags)
1289     end)
1290   end
1291
1292   def tag(nickname, tags) when is_binary(nickname),
1293     do: tag(User.get_by_nickname(nickname), tags)
1294
1295   def tag(%User{} = user, tags),
1296     do: update_tags(user, Enum.uniq((user.tags || []) ++ normalize_tags(tags)))
1297
1298   def untag(user_identifiers, tags) when is_list(user_identifiers) do
1299     Repo.transaction(fn ->
1300       for user_identifier <- user_identifiers, do: untag(user_identifier, tags)
1301     end)
1302   end
1303
1304   def untag(nickname, tags) when is_binary(nickname),
1305     do: untag(User.get_by_nickname(nickname), tags)
1306
1307   def untag(%User{} = user, tags),
1308     do: update_tags(user, (user.tags || []) -- normalize_tags(tags))
1309
1310   defp update_tags(%User{} = user, new_tags) do
1311     {:ok, updated_user} =
1312       user
1313       |> change(%{tags: new_tags})
1314       |> update_and_set_cache()
1315
1316     updated_user
1317   end
1318
1319   def bookmark(%User{} = user, status_id) do
1320     bookmarks = Enum.uniq(user.bookmarks ++ [status_id])
1321     update_bookmarks(user, bookmarks)
1322   end
1323
1324   def unbookmark(%User{} = user, status_id) do
1325     bookmarks = Enum.uniq(user.bookmarks -- [status_id])
1326     update_bookmarks(user, bookmarks)
1327   end
1328
1329   def update_bookmarks(%User{} = user, bookmarks) do
1330     user
1331     |> change(%{bookmarks: bookmarks})
1332     |> update_and_set_cache
1333   end
1334
1335   defp normalize_tags(tags) do
1336     [tags]
1337     |> List.flatten()
1338     |> Enum.map(&String.downcase(&1))
1339   end
1340
1341   defp local_nickname_regex do
1342     if Pleroma.Config.get([:instance, :extended_nickname_format]) do
1343       @extended_local_nickname_regex
1344     else
1345       @strict_local_nickname_regex
1346     end
1347   end
1348
1349   def local_nickname(nickname_or_mention) do
1350     nickname_or_mention
1351     |> full_nickname()
1352     |> String.split("@")
1353     |> hd()
1354   end
1355
1356   def full_nickname(nickname_or_mention),
1357     do: String.trim_leading(nickname_or_mention, "@")
1358
1359   def error_user(ap_id) do
1360     %User{
1361       name: ap_id,
1362       ap_id: ap_id,
1363       info: %User.Info{},
1364       nickname: "erroruser@example.com",
1365       inserted_at: NaiveDateTime.utc_now()
1366     }
1367   end
1368
1369   def all_superusers do
1370     from(
1371       u in User,
1372       where: u.local == true,
1373       where: fragment("?->'is_admin' @> 'true' OR ?->'is_moderator' @> 'true'", u.info, u.info)
1374     )
1375     |> Repo.all()
1376   end
1377
1378   defp paginate(query, page, page_size) do
1379     from(u in query,
1380       limit: ^page_size,
1381       offset: ^((page - 1) * page_size)
1382     )
1383   end
1384
1385   def showing_reblogs?(%User{} = user, %User{} = target) do
1386     target.ap_id not in user.info.muted_reblogs
1387   end
1388 end