projects / akkoma / blob
? search:


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