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