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(:tags, {:array, :string}, default: [])
  54     field(:bookmarks, {:array, :string}, default: [])
  55     field(:last_refreshed_at, :naive_datetime)
  56     has_many(:notifications, Notification)
  57     embeds_one(:info, Pleroma.User.Info)
  58
  59     timestamps()
  60   end
  61
  62   def auth_active?(%User{local: false}), do: true
  63
  64   def auth_active?(%User{info: %User.Info{confirmation_pending: false}}), do: true
  65
  66   def auth_active?(%User{info: %User.Info{confirmation_pending: true}}),
  67     do: !Pleroma.Config.get([:instance, :account_activation_required])
  68
  69   def auth_active?(_), do: false
  70
  71   def visible_for?(user, for_user \\ nil)
  72
  73   def visible_for?(%User{id: user_id}, %User{id: for_id}) when user_id == for_id, do: true
  74
  75   def visible_for?(%User{} = user, for_user) do
  76     auth_active?(user) || superuser?(for_user)
  77   end
  78
  79   def visible_for?(_, _), do: false
  80
  81   def superuser?(%User{local: true, info: %User.Info{is_admin: true}}), do: true
  82   def superuser?(%User{local: true, info: %User.Info{is_moderator: true}}), do: true
  83   def superuser?(_), do: false
  84
  85   def avatar_url(user) do
  86     case user.avatar do
  87       %{"url" => [%{"href" => href} | _]} -> href
  88       _ -> "#{Web.base_url()}/images/avi.png"
  89     end
  90   end
  91
  92   def banner_url(user) do
  93     case user.info.banner do
  94       %{"url" => [%{"href" => href} | _]} -> href
  95       _ -> "#{Web.base_url()}/images/banner.png"
  96     end
  97   end
  98
  99   def profile_url(%User{info: %{source_data: %{"url" => url}}}), do: url
 100   def profile_url(%User{ap_id: ap_id}), do: ap_id
 101   def profile_url(_), do: nil
 102
 103   def ap_id(%User{nickname: nickname}) do
 104     "#{Web.base_url()}/users/#{nickname}"
 105   end
 106
 107   def ap_followers(%User{follower_address: fa}) when is_binary(fa), do: fa
 108   def ap_followers(%User{} = user), do: "#{ap_id(user)}/followers"
 109
 110   def user_info(%User{} = user) do
 111     oneself = if user.local, do: 1, else: 0
 112
 113     %{
 114       following_count: length(user.following) - oneself,
 115       note_count: user.info.note_count,
 116       follower_count: user.info.follower_count,
 117       locked: user.info.locked,
 118       confirmation_pending: user.info.confirmation_pending,
 119       default_scope: user.info.default_scope
 120     }
 121   end
 122
 123   def remote_user_creation(params) do
 124     params =
 125       params
 126       |> Map.put(:info, params[:info] || %{})
 127
 128     info_cng = User.Info.remote_user_creation(%User.Info{}, params[:info])
 129
 130     changes =
 131       %User{}
 132       |> cast(params, [:bio, :name, :ap_id, :nickname, :avatar])
 133       |> validate_required([:name, :ap_id])
 134       |> unique_constraint(:nickname)
 135       |> validate_format(:nickname, @email_regex)
 136       |> validate_length(:bio, max: 5000)
 137       |> validate_length(:name, max: 100)
 138       |> put_change(:local, false)
 139       |> put_embed(:info, info_cng)
 140
 141     if changes.valid? do
 142       case info_cng.changes[:source_data] do
 143         %{"followers" => followers} ->
 144           changes
 145           |> put_change(:follower_address, followers)
 146
 147         _ ->
 148           followers = User.ap_followers(%User{nickname: changes.changes[:nickname]})
 149
 150           changes
 151           |> put_change(:follower_address, followers)
 152       end
 153     else
 154       changes
 155     end
 156   end
 157
 158   def update_changeset(struct, params \\ %{}) do
 159     struct
 160     |> cast(params, [:bio, :name, :avatar])
 161     |> unique_constraint(:nickname)
 162     |> validate_format(:nickname, local_nickname_regex())
 163     |> validate_length(:bio, max: 5000)
 164     |> validate_length(:name, min: 1, max: 100)
 165   end
 166
 167   def upgrade_changeset(struct, params \\ %{}) do
 168     params =
 169       params
 170       |> Map.put(:last_refreshed_at, NaiveDateTime.utc_now())
 171
 172     info_cng =
 173       struct.info
 174       |> User.Info.user_upgrade(params[:info])
 175
 176     struct
 177     |> cast(params, [:bio, :name, :follower_address, :avatar, :last_refreshed_at])
 178     |> unique_constraint(:nickname)
 179     |> validate_format(:nickname, local_nickname_regex())
 180     |> validate_length(:bio, max: 5000)
 181     |> validate_length(:name, max: 100)
 182     |> put_embed(:info, info_cng)
 183   end
 184
 185   def password_update_changeset(struct, params) do
 186     changeset =
 187       struct
 188       |> cast(params, [:password, :password_confirmation])
 189       |> validate_required([:password, :password_confirmation])
 190       |> validate_confirmation(:password)
 191
 192     OAuth.Token.delete_user_tokens(struct)
 193     OAuth.Authorization.delete_user_authorizations(struct)
 194
 195     if changeset.valid? do
 196       hashed = Pbkdf2.hashpwsalt(changeset.changes[:password])
 197
 198       changeset
 199       |> put_change(:password_hash, hashed)
 200     else
 201       changeset
 202     end
 203   end
 204
 205   def reset_password(user, data) do
 206     update_and_set_cache(password_update_changeset(user, data))
 207   end
 208
 209   def register_changeset(struct, params \\ %{}, opts \\ []) do
 210     confirmation_status =
 211       if opts[:confirmed] || !Pleroma.Config.get([:instance, :account_activation_required]) do
 212         :confirmed
 213       else
 214         :unconfirmed
 215       end
 216
 217     info_change = User.Info.confirmation_changeset(%User.Info{}, confirmation_status)
 218
 219     changeset =
 220       struct
 221       |> cast(params, [:bio, :email, :name, :nickname, :password, :password_confirmation])
 222       |> validate_required([:email, :name, :nickname, :password, :password_confirmation])
 223       |> validate_confirmation(:password)
 224       |> unique_constraint(:email)
 225       |> unique_constraint(:nickname)
 226       |> validate_exclusion(:nickname, Pleroma.Config.get([Pleroma.User, :restricted_nicknames]))
 227       |> validate_format(:nickname, local_nickname_regex())
 228       |> validate_format(:email, @email_regex)
 229       |> validate_length(:bio, max: 1000)
 230       |> validate_length(:name, min: 1, max: 100)
 231       |> put_change(:info, info_change)
 232
 233     if changeset.valid? do
 234       hashed = Pbkdf2.hashpwsalt(changeset.changes[:password])
 235       ap_id = User.ap_id(%User{nickname: changeset.changes[:nickname]})
 236       followers = User.ap_followers(%User{nickname: changeset.changes[:nickname]})
 237
 238       changeset
 239       |> put_change(:password_hash, hashed)
 240       |> put_change(:ap_id, ap_id)
 241       |> unique_constraint(:ap_id)
 242       |> put_change(:following, [followers])
 243       |> put_change(:follower_address, followers)
 244     else
 245       changeset
 246     end
 247   end
 248
 249   defp autofollow_users(user) do
 250     candidates = Pleroma.Config.get([:instance, :autofollowed_nicknames])
 251
 252     autofollowed_users =
 253       from(u in User,
 254         where: u.local == true,
 255         where: u.nickname in ^candidates
 256       )
 257       |> Repo.all()
 258
 259     follow_all(user, autofollowed_users)
 260   end
 261
 262   @doc "Inserts provided changeset, performs post-registration actions (confirmation email sending etc.)"
 263   def register(%Ecto.Changeset{} = changeset) do
 264     with {:ok, user} <- Repo.insert(changeset),
 265          {:ok, user} <- autofollow_users(user),
 266          {:ok, _} <- Pleroma.User.WelcomeMessage.post_welcome_message_to_user(user),
 267          {:ok, _} <- try_send_confirmation_email(user) do
 268       {:ok, user}
 269     end
 270   end
 271
 272   def try_send_confirmation_email(%User{} = user) do
 273     if user.info.confirmation_pending &&
 274          Pleroma.Config.get([:instance, :account_activation_required]) do
 275       user
 276       |> Pleroma.UserEmail.account_confirmation_email()
 277       |> Pleroma.Mailer.deliver_async()
 278     else
 279       {:ok, :noop}
 280     end
 281   end
 282
 283   def needs_update?(%User{local: true}), do: false
 284
 285   def needs_update?(%User{local: false, last_refreshed_at: nil}), do: true
 286
 287   def needs_update?(%User{local: false} = user) do
 288     NaiveDateTime.diff(NaiveDateTime.utc_now(), user.last_refreshed_at) >= 86_400
 289   end
 290
 291   def needs_update?(_), do: true
 292
 293   def maybe_direct_follow(%User{} = follower, %User{local: true, info: %{locked: true}}) do
 294     {:ok, follower}
 295   end
 296
 297   def maybe_direct_follow(%User{} = follower, %User{local: true} = followed) do
 298     follow(follower, followed)
 299   end
 300
 301   def maybe_direct_follow(%User{} = follower, %User{} = followed) do
 302     if not User.ap_enabled?(followed) do
 303       follow(follower, followed)
 304     else
 305       {:ok, follower}
 306     end
 307   end
 308
 309   def maybe_follow(%User{} = follower, %User{info: _info} = followed) do
 310     if not following?(follower, followed) do
 311       follow(follower, followed)
 312     else
 313       {:ok, follower}
 314     end
 315   end
 316
 317   @doc "A mass follow for local users. Respects blocks in both directions but does not create activities."
 318   @spec follow_all(User.t(), list(User.t())) :: {atom(), User.t()}
 319   def follow_all(follower, followeds) do
 320     followed_addresses =
 321       followeds
 322       |> Enum.reject(fn followed -> blocks?(follower, followed) || blocks?(followed, follower) end)
 323       |> Enum.map(fn %{follower_address: fa} -> fa end)
 324
 325     q =
 326       from(u in User,
 327         where: u.id == ^follower.id,
 328         update: [
 329           set: [
 330             following:
 331               fragment(
 332                 "array(select distinct unnest (array_cat(?, ?)))",
 333                 u.following,
 334                 ^followed_addresses
 335               )
 336           ]
 337         ]
 338       )
 339
 340     {1, [follower]} = Repo.update_all(q, [], returning: true)
 341
 342     Enum.each(followeds, fn followed ->
 343       update_follower_count(followed)
 344     end)
 345
 346     set_cache(follower)
 347   end
 348
 349   def follow(%User{} = follower, %User{info: info} = followed) do
 350     user_config = Application.get_env(:pleroma, :user)
 351     deny_follow_blocked = Keyword.get(user_config, :deny_follow_blocked)
 352
 353     ap_followers = followed.follower_address
 354
 355     cond do
 356       following?(follower, followed) or info.deactivated ->
 357         {:error, "Could not follow user: #{followed.nickname} is already on your list."}
 358
 359       deny_follow_blocked and blocks?(followed, follower) ->
 360         {:error, "Could not follow user: #{followed.nickname} blocked you."}
 361
 362       true ->
 363         if !followed.local && follower.local && !ap_enabled?(followed) do
 364           Websub.subscribe(follower, followed)
 365         end
 366
 367         q =
 368           from(u in User,
 369             where: u.id == ^follower.id,
 370             update: [push: [following: ^ap_followers]]
 371           )
 372
 373         {1, [follower]} = Repo.update_all(q, [], returning: true)
 374
 375         {:ok, _} = update_follower_count(followed)
 376
 377         set_cache(follower)
 378     end
 379   end
 380
 381   def unfollow(%User{} = follower, %User{} = followed) do
 382     ap_followers = followed.follower_address
 383
 384     if following?(follower, followed) and follower.ap_id != followed.ap_id do
 385       q =
 386         from(u in User,
 387           where: u.id == ^follower.id,
 388           update: [pull: [following: ^ap_followers]]
 389         )
 390
 391       {1, [follower]} = Repo.update_all(q, [], returning: true)
 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, 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     |> Repo.update_all([], returning: true)
 662     |> case do
 663       {1, [user]} -> set_cache(user)
 664       _ -> {:error, user}
 665     end
 666   end
 667
 668   def decrease_note_count(%User{} = user) do
 669     User
 670     |> where(id: ^user.id)
 671     |> update([u],
 672       set: [
 673         info:
 674           fragment(
 675             "jsonb_set(?, '{note_count}', (greatest(0, (?->>'note_count')::int - 1))::varchar::jsonb, true)",
 676             u.info,
 677             u.info
 678           )
 679       ]
 680     )
 681     |> Repo.update_all([], returning: true)
 682     |> case do
 683       {1, [user]} -> set_cache(user)
 684       _ -> {:error, user}
 685     end
 686   end
 687
 688   def update_note_count(%User{} = user) do
 689     note_count_query =
 690       from(
 691         a in Object,
 692         where: fragment("?->>'actor' = ? and ?->>'type' = 'Note'", a.data, ^user.ap_id, a.data),
 693         select: count(a.id)
 694       )
 695
 696     note_count = Repo.one(note_count_query)
 697
 698     info_cng = User.Info.set_note_count(user.info, note_count)
 699
 700     cng =
 701       change(user)
 702       |> put_embed(:info, info_cng)
 703
 704     update_and_set_cache(cng)
 705   end
 706
 707   def update_follower_count(%User{} = user) do
 708     follower_count_query =
 709       User
 710       |> where([u], ^user.follower_address in u.following)
 711       |> where([u], u.id != ^user.id)
 712       |> select([u], %{count: count(u.id)})
 713
 714     User
 715     |> where(id: ^user.id)
 716     |> join(:inner, [u], s in subquery(follower_count_query))
 717     |> update([u, s],
 718       set: [
 719         info:
 720           fragment(
 721             "jsonb_set(?, '{follower_count}', ?::varchar::jsonb, true)",
 722             u.info,
 723             s.count
 724           )
 725       ]
 726     )
 727     |> Repo.update_all([], returning: true)
 728     |> case do
 729       {1, [user]} -> set_cache(user)
 730       _ -> {:error, user}
 731     end
 732   end
 733
 734   def get_users_from_set_query(ap_ids, false) do
 735     from(
 736       u in User,
 737       where: u.ap_id in ^ap_ids
 738     )
 739   end
 740
 741   def get_users_from_set_query(ap_ids, true) do
 742     query = get_users_from_set_query(ap_ids, false)
 743
 744     from(
 745       u in query,
 746       where: u.local == true
 747     )
 748   end
 749
 750   def get_users_from_set(ap_ids, local_only \\ true) do
 751     get_users_from_set_query(ap_ids, local_only)
 752     |> Repo.all()
 753   end
 754
 755   def get_recipients_from_activity(%Activity{recipients: to}) do
 756     query =
 757       from(
 758         u in User,
 759         where: u.ap_id in ^to,
 760         or_where: fragment("? && ?", u.following, ^to)
 761       )
 762
 763     query = from(u in query, where: u.local == true)
 764
 765     Repo.all(query)
 766   end
 767
 768   @spec search_for_admin(%{
 769           local: boolean(),
 770           page: number(),
 771           page_size: number()
 772         }) :: {:ok, [Pleroma.User.t()], number()}
 773   def search_for_admin(%{query: nil, local: local, page: page, page_size: page_size}) do
 774     query =
 775       from(u in User, order_by: u.nickname)
 776       |> maybe_local_user_query(local)
 777
 778     paginated_query =
 779       query
 780       |> paginate(page, page_size)
 781
 782     count =
 783       query
 784       |> Repo.aggregate(:count, :id)
 785
 786     {:ok, Repo.all(paginated_query), count}
 787   end
 788
 789   @spec search_for_admin(%{
 790           query: binary(),
 791           local: boolean(),
 792           page: number(),
 793           page_size: number()
 794         }) :: {:ok, [Pleroma.User.t()], number()}
 795   def search_for_admin(%{
 796         query: term,
 797         local: local,
 798         page: page,
 799         page_size: page_size
 800       }) do
 801     maybe_local_query = User |> maybe_local_user_query(local)
 802
 803     search_query = from(u in maybe_local_query, where: ilike(u.nickname, ^"%#{term}%"))
 804     count = search_query |> Repo.aggregate(:count, :id)
 805
 806     results =
 807       search_query
 808       |> paginate(page, page_size)
 809       |> Repo.all()
 810
 811     {:ok, results, count}
 812   end
 813
 814   def search(query, resolve \\ false, for_user \\ nil) do
 815     # Strip the beginning @ off if there is a query
 816     query = String.trim_leading(query, "@")
 817
 818     if resolve, do: get_or_fetch(query)
 819
 820     fts_results = do_search(fts_search_subquery(query), for_user)
 821
 822     {:ok, trigram_results} =
 823       Repo.transaction(fn ->
 824         Ecto.Adapters.SQL.query(Repo, "select set_limit(0.25)", [])
 825         do_search(trigram_search_subquery(query), for_user)
 826       end)
 827
 828     Enum.uniq_by(fts_results ++ trigram_results, & &1.id)
 829   end
 830
 831   defp do_search(subquery, for_user, options \\ []) do
 832     q =
 833       from(
 834         s in subquery(subquery),
 835         order_by: [desc: s.search_rank],
 836         limit: ^(options[:limit] || 20)
 837       )
 838
 839     results =
 840       q
 841       |> Repo.all()
 842       |> Enum.filter(&(&1.search_rank > 0))
 843
 844     boost_search_results(results, for_user)
 845   end
 846
 847   defp fts_search_subquery(term, query \\ User) do
 848     processed_query =
 849       term
 850       |> String.replace(~r/\W+/, " ")
 851       |> String.trim()
 852       |> String.split()
 853       |> Enum.map(&(&1 <> ":*"))
 854       |> Enum.join(" | ")
 855
 856     from(
 857       u in query,
 858       select_merge: %{
 859         search_rank:
 860           fragment(
 861             """
 862             ts_rank_cd(
 863               setweight(to_tsvector('simple', regexp_replace(?, '\\W', ' ', 'g')), 'A') ||
 864               setweight(to_tsvector('simple', regexp_replace(coalesce(?, ''), '\\W', ' ', 'g')), 'B'),
 865               to_tsquery('simple', ?),
 866               32
 867             )
 868             """,
 869             u.nickname,
 870             u.name,
 871             ^processed_query
 872           )
 873       },
 874       where:
 875         fragment(
 876           """
 877             (setweight(to_tsvector('simple', regexp_replace(?, '\\W', ' ', 'g')), 'A') ||
 878             setweight(to_tsvector('simple', regexp_replace(coalesce(?, ''), '\\W', ' ', 'g')), 'B')) @@ to_tsquery('simple', ?)
 879           """,
 880           u.nickname,
 881           u.name,
 882           ^processed_query
 883         )
 884     )
 885   end
 886
 887   defp trigram_search_subquery(term) do
 888     from(
 889       u in User,
 890       select_merge: %{
 891         search_rank:
 892           fragment(
 893             "similarity(?, trim(? || ' ' || coalesce(?, '')))",
 894             ^term,
 895             u.nickname,
 896             u.name
 897           )
 898       },
 899       where: fragment("trim(? || ' ' || coalesce(?, '')) % ?", u.nickname, u.name, ^term)
 900     )
 901   end
 902
 903   defp boost_search_results(results, nil), do: results
 904
 905   defp boost_search_results(results, for_user) do
 906     friends_ids = get_friends_ids(for_user)
 907     followers_ids = get_followers_ids(for_user)
 908
 909     Enum.map(
 910       results,
 911       fn u ->
 912         search_rank_coef =
 913           cond do
 914             u.id in friends_ids ->
 915               1.2
 916
 917             u.id in followers_ids ->
 918               1.1
 919
 920             true ->
 921               1
 922           end
 923
 924         Map.put(u, :search_rank, u.search_rank * search_rank_coef)
 925       end
 926     )
 927     |> Enum.sort_by(&(-&1.search_rank))
 928   end
 929
 930   def blocks_import(%User{} = blocker, blocked_identifiers) when is_list(blocked_identifiers) do
 931     Enum.map(
 932       blocked_identifiers,
 933       fn blocked_identifier ->
 934         with %User{} = blocked <- get_or_fetch(blocked_identifier),
 935              {:ok, blocker} <- block(blocker, blocked),
 936              {:ok, _} <- ActivityPub.block(blocker, blocked) do
 937           blocked
 938         else
 939           err ->
 940             Logger.debug("blocks_import failed for #{blocked_identifier} with: #{inspect(err)}")
 941             err
 942         end
 943       end
 944     )
 945   end
 946
 947   def mute(muter, %User{ap_id: ap_id}) do
 948     info_cng =
 949       muter.info
 950       |> User.Info.add_to_mutes(ap_id)
 951
 952     cng =
 953       change(muter)
 954       |> put_embed(:info, info_cng)
 955
 956     update_and_set_cache(cng)
 957   end
 958
 959   def unmute(muter, %{ap_id: ap_id}) do
 960     info_cng =
 961       muter.info
 962       |> User.Info.remove_from_mutes(ap_id)
 963
 964     cng =
 965       change(muter)
 966       |> put_embed(:info, info_cng)
 967
 968     update_and_set_cache(cng)
 969   end
 970
 971   def block(blocker, %User{ap_id: ap_id} = blocked) do
 972     # sever any follow relationships to prevent leaks per activitypub (Pleroma issue #213)
 973     blocker =
 974       if following?(blocker, blocked) do
 975         {:ok, blocker, _} = unfollow(blocker, blocked)
 976         blocker
 977       else
 978         blocker
 979       end
 980
 981     if following?(blocked, blocker) do
 982       unfollow(blocked, blocker)
 983     end
 984
 985     info_cng =
 986       blocker.info
 987       |> User.Info.add_to_block(ap_id)
 988
 989     cng =
 990       change(blocker)
 991       |> put_embed(:info, info_cng)
 992
 993     update_and_set_cache(cng)
 994   end
 995
 996   # helper to handle the block given only an actor's AP id
 997   def block(blocker, %{ap_id: ap_id}) do
 998     block(blocker, User.get_by_ap_id(ap_id))
 999   end
1000
1001   def unblock(blocker, %{ap_id: ap_id}) do
1002     info_cng =
1003       blocker.info
1004       |> User.Info.remove_from_block(ap_id)
1005
1006     cng =
1007       change(blocker)
1008       |> put_embed(:info, info_cng)
1009
1010     update_and_set_cache(cng)
1011   end
1012
1013   def mutes?(nil, _), do: false
1014   def mutes?(user, %{ap_id: ap_id}), do: Enum.member?(user.info.mutes, ap_id)
1015
1016   def blocks?(user, %{ap_id: ap_id}) do
1017     blocks = user.info.blocks
1018     domain_blocks = user.info.domain_blocks
1019     %{host: host} = URI.parse(ap_id)
1020
1021     Enum.member?(blocks, ap_id) ||
1022       Enum.any?(domain_blocks, fn domain ->
1023         host == domain
1024       end)
1025   end
1026
1027   def muted_users(user),
1028     do: Repo.all(from(u in User, where: u.ap_id in ^user.info.mutes))
1029
1030   def blocked_users(user),
1031     do: Repo.all(from(u in User, where: u.ap_id in ^user.info.blocks))
1032
1033   def block_domain(user, domain) do
1034     info_cng =
1035       user.info
1036       |> User.Info.add_to_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 unblock_domain(user, domain) do
1046     info_cng =
1047       user.info
1048       |> User.Info.remove_from_domain_block(domain)
1049
1050     cng =
1051       change(user)
1052       |> put_embed(:info, info_cng)
1053
1054     update_and_set_cache(cng)
1055   end
1056
1057   def maybe_local_user_query(query, local) do
1058     if local, do: local_user_query(query), else: query
1059   end
1060
1061   def local_user_query(query \\ User) do
1062     from(
1063       u in query,
1064       where: u.local == true,
1065       where: not is_nil(u.nickname)
1066     )
1067   end
1068
1069   def active_local_user_query do
1070     from(
1071       u in local_user_query(),
1072       where: fragment("not (?->'deactivated' @> 'true')", u.info)
1073     )
1074   end
1075
1076   def moderator_user_query do
1077     from(
1078       u in User,
1079       where: u.local == true,
1080       where: fragment("?->'is_moderator' @> 'true'", u.info)
1081     )
1082   end
1083
1084   def deactivate(%User{} = user, status \\ true) do
1085     info_cng = User.Info.set_activation_status(user.info, status)
1086
1087     cng =
1088       change(user)
1089       |> put_embed(:info, info_cng)
1090
1091     update_and_set_cache(cng)
1092   end
1093
1094   def delete(%User{} = user) do
1095     {:ok, user} = User.deactivate(user)
1096
1097     # Remove all relationships
1098     {:ok, followers} = User.get_followers(user)
1099
1100     followers
1101     |> Enum.each(fn follower -> User.unfollow(follower, user) end)
1102
1103     {:ok, friends} = User.get_friends(user)
1104
1105     friends
1106     |> Enum.each(fn followed -> User.unfollow(user, followed) end)
1107
1108     query = from(a in Activity, where: a.actor == ^user.ap_id)
1109
1110     Repo.all(query)
1111     |> Enum.each(fn activity ->
1112       case activity.data["type"] do
1113         "Create" ->
1114           ActivityPub.delete(Object.normalize(activity.data["object"]))
1115
1116         # TODO: Do something with likes, follows, repeats.
1117         _ ->
1118           "Doing nothing"
1119       end
1120     end)
1121
1122     {:ok, user}
1123   end
1124
1125   def html_filter_policy(%User{info: %{no_rich_text: true}}) do
1126     Pleroma.HTML.Scrubber.TwitterText
1127   end
1128
1129   @default_scrubbers Pleroma.Config.get([:markup, :scrub_policy])
1130
1131   def html_filter_policy(_), do: @default_scrubbers
1132
1133   def fetch_by_ap_id(ap_id) do
1134     ap_try = ActivityPub.make_user_from_ap_id(ap_id)
1135
1136     case ap_try do
1137       {:ok, user} ->
1138         user
1139
1140       _ ->
1141         case OStatus.make_user(ap_id) do
1142           {:ok, user} -> user
1143           _ -> {:error, "Could not fetch by AP id"}
1144         end
1145     end
1146   end
1147
1148   def get_or_fetch_by_ap_id(ap_id) do
1149     user = get_by_ap_id(ap_id)
1150
1151     if !is_nil(user) and !User.needs_update?(user) do
1152       user
1153     else
1154       # Whether to fetch initial posts for the user (if it's a new user & the fetching is enabled)
1155       should_fetch_initial = is_nil(user) and Pleroma.Config.get([:fetch_initial_posts, :enabled])
1156
1157       user = fetch_by_ap_id(ap_id)
1158
1159       if should_fetch_initial do
1160         with %User{} = user do
1161           {:ok, _} = Task.start(__MODULE__, :fetch_initial_posts, [user])
1162         end
1163       end
1164
1165       user
1166     end
1167   end
1168
1169   def get_or_create_instance_user do
1170     relay_uri = "#{Pleroma.Web.Endpoint.url()}/relay"
1171
1172     if user = get_by_ap_id(relay_uri) do
1173       user
1174     else
1175       changes =
1176         %User{info: %User.Info{}}
1177         |> cast(%{}, [:ap_id, :nickname, :local])
1178         |> put_change(:ap_id, relay_uri)
1179         |> put_change(:nickname, nil)
1180         |> put_change(:local, true)
1181         |> put_change(:follower_address, relay_uri <> "/followers")
1182
1183       {:ok, user} = Repo.insert(changes)
1184       user
1185     end
1186   end
1187
1188   # AP style
1189   def public_key_from_info(%{
1190         source_data: %{"publicKey" => %{"publicKeyPem" => public_key_pem}}
1191       }) do
1192     key =
1193       public_key_pem
1194       |> :public_key.pem_decode()
1195       |> hd()
1196       |> :public_key.pem_entry_decode()
1197
1198     {:ok, key}
1199   end
1200
1201   # OStatus Magic Key
1202   def public_key_from_info(%{magic_key: magic_key}) do
1203     {:ok, Pleroma.Web.Salmon.decode_key(magic_key)}
1204   end
1205
1206   def get_public_key_for_ap_id(ap_id) do
1207     with %User{} = user <- get_or_fetch_by_ap_id(ap_id),
1208          {:ok, public_key} <- public_key_from_info(user.info) do
1209       {:ok, public_key}
1210     else
1211       _ -> :error
1212     end
1213   end
1214
1215   defp blank?(""), do: nil
1216   defp blank?(n), do: n
1217
1218   def insert_or_update_user(data) do
1219     data =
1220       data
1221       |> Map.put(:name, blank?(data[:name]) || data[:nickname])
1222
1223     cs = User.remote_user_creation(data)
1224
1225     Repo.insert(cs, on_conflict: :replace_all, conflict_target: :nickname)
1226   end
1227
1228   def ap_enabled?(%User{local: true}), do: true
1229   def ap_enabled?(%User{info: info}), do: info.ap_enabled
1230   def ap_enabled?(_), do: false
1231
1232   @doc "Gets or fetch a user by uri or nickname."
1233   @spec get_or_fetch(String.t()) :: User.t()
1234   def get_or_fetch("http" <> _host = uri), do: get_or_fetch_by_ap_id(uri)
1235   def get_or_fetch(nickname), do: get_or_fetch_by_nickname(nickname)
1236
1237   # wait a period of time and return newest version of the User structs
1238   # this is because we have synchronous follow APIs and need to simulate them
1239   # with an async handshake
1240   def wait_and_refresh(_, %User{local: true} = a, %User{local: true} = b) do
1241     with %User{} = a <- Repo.get(User, a.id),
1242          %User{} = b <- Repo.get(User, b.id) do
1243       {:ok, a, b}
1244     else
1245       _e ->
1246         :error
1247     end
1248   end
1249
1250   def wait_and_refresh(timeout, %User{} = a, %User{} = b) do
1251     with :ok <- :timer.sleep(timeout),
1252          %User{} = a <- Repo.get(User, a.id),
1253          %User{} = b <- Repo.get(User, b.id) do
1254       {:ok, a, b}
1255     else
1256       _e ->
1257         :error
1258     end
1259   end
1260
1261   def parse_bio(bio, user \\ %User{info: %{source_data: %{}}})
1262   def parse_bio(nil, _user), do: ""
1263   def parse_bio(bio, _user) when bio == "", do: bio
1264
1265   def parse_bio(bio, user) do
1266     emoji =
1267       (user.info.source_data["tag"] || [])
1268       |> Enum.filter(fn %{"type" => t} -> t == "Emoji" end)
1269       |> Enum.map(fn %{"icon" => %{"url" => url}, "name" => name} ->
1270         {String.trim(name, ":"), url}
1271       end)
1272
1273     # TODO: get profile URLs other than user.ap_id
1274     profile_urls = [user.ap_id]
1275
1276     bio
1277     |> CommonUtils.format_input("text/plain",
1278       mentions_format: :full,
1279       rel: &RelMe.maybe_put_rel_me(&1, profile_urls)
1280     )
1281     |> elem(0)
1282     |> Formatter.emojify(emoji)
1283   end
1284
1285   def tag(user_identifiers, tags) when is_list(user_identifiers) do
1286     Repo.transaction(fn ->
1287       for user_identifier <- user_identifiers, do: tag(user_identifier, tags)
1288     end)
1289   end
1290
1291   def tag(nickname, tags) when is_binary(nickname),
1292     do: tag(User.get_by_nickname(nickname), tags)
1293
1294   def tag(%User{} = user, tags),
1295     do: update_tags(user, Enum.uniq((user.tags || []) ++ normalize_tags(tags)))
1296
1297   def untag(user_identifiers, tags) when is_list(user_identifiers) do
1298     Repo.transaction(fn ->
1299       for user_identifier <- user_identifiers, do: untag(user_identifier, tags)
1300     end)
1301   end
1302
1303   def untag(nickname, tags) when is_binary(nickname),
1304     do: untag(User.get_by_nickname(nickname), tags)
1305
1306   def untag(%User{} = user, tags),
1307     do: update_tags(user, (user.tags || []) -- normalize_tags(tags))
1308
1309   defp update_tags(%User{} = user, new_tags) do
1310     {:ok, updated_user} =
1311       user
1312       |> change(%{tags: new_tags})
1313       |> update_and_set_cache()
1314
1315     updated_user
1316   end
1317
1318   def bookmark(%User{} = user, status_id) do
1319     bookmarks = Enum.uniq(user.bookmarks ++ [status_id])
1320     update_bookmarks(user, bookmarks)
1321   end
1322
1323   def unbookmark(%User{} = user, status_id) do
1324     bookmarks = Enum.uniq(user.bookmarks -- [status_id])
1325     update_bookmarks(user, bookmarks)
1326   end
1327
1328   def update_bookmarks(%User{} = user, bookmarks) do
1329     user
1330     |> change(%{bookmarks: bookmarks})
1331     |> update_and_set_cache
1332   end
1333
1334   defp normalize_tags(tags) do
1335     [tags]
1336     |> List.flatten()
1337     |> Enum.map(&String.downcase(&1))
1338   end
1339
1340   defp local_nickname_regex do
1341     if Pleroma.Config.get([:instance, :extended_nickname_format]) do
1342       @extended_local_nickname_regex
1343     else
1344       @strict_local_nickname_regex
1345     end
1346   end
1347
1348   def local_nickname(nickname_or_mention) do
1349     nickname_or_mention
1350     |> full_nickname()
1351     |> String.split("@")
1352     |> hd()
1353   end
1354
1355   def full_nickname(nickname_or_mention),
1356     do: String.trim_leading(nickname_or_mention, "@")
1357
1358   def error_user(ap_id) do
1359     %User{
1360       name: ap_id,
1361       ap_id: ap_id,
1362       info: %User.Info{},
1363       nickname: "erroruser@example.com",
1364       inserted_at: NaiveDateTime.utc_now()
1365     }
1366   end
1367
1368   def all_superusers do
1369     from(
1370       u in User,
1371       where: u.local == true,
1372       where: fragment("?->'is_admin' @> 'true' OR ?->'is_moderator' @> 'true'", u.info, u.info)
1373     )
1374     |> Repo.all()
1375   end
1376
1377   defp paginate(query, page, page_size) do
1378     from(u in query,
1379       limit: ^page_size,
1380       offset: ^((page - 1) * page_size)
1381     )
1382   end
1383
1384   def showing_reblogs?(%User{} = user, %User{} = target) do
1385     target.ap_id not in user.info.muted_reblogs
1386   end
1387 end