projects / akkoma / blob
? search:


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