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