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