projects / akkoma / blob
? search:


a6e2c8b9745613f35676d49dd89e8f5d76856994
[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 block(blocker, %User{ap_id: ap_id} = blocked) do
927 # sever any follow relationships to prevent leaks per activitypub (Pleroma issue #213)
928 blocker =
929 if following?(blocker, blocked) do
930 {:ok, blocker, _} = unfollow(blocker, blocked)
931 blocker
932 else
933 blocker
934 end
935
936 if following?(blocked, blocker) do
937 unfollow(blocked, blocker)
938 end
939
940 {:ok, blocker} = update_follower_count(blocker)
941
942 info_cng =
943 blocker.info
944 |> User.Info.add_to_block(ap_id)
945
946 cng =
947 change(blocker)
948 |> put_embed(:info, info_cng)
949
950 update_and_set_cache(cng)
951 end
952
953 # helper to handle the block given only an actor's AP id
954 def block(blocker, %{ap_id: ap_id}) do
955 block(blocker, User.get_by_ap_id(ap_id))
956 end
957
958 def unblock(blocker, %{ap_id: ap_id}) do
959 info_cng =
960 blocker.info
961 |> User.Info.remove_from_block(ap_id)
962
963 cng =
964 change(blocker)
965 |> put_embed(:info, info_cng)
966
967 update_and_set_cache(cng)
968 end
969
970 def mutes?(nil, _), do: false
971 def mutes?(user, %{ap_id: ap_id}), do: Enum.member?(user.info.mutes, ap_id)
972
973 def blocks?(user, %{ap_id: ap_id}) do
974 blocks = user.info.blocks
975 domain_blocks = user.info.domain_blocks
976 %{host: host} = URI.parse(ap_id)
977
978 Enum.member?(blocks, ap_id) ||
979 Enum.any?(domain_blocks, fn domain ->
980 host == domain
981 end)
982 end
983
984 def muted_users(user),
985 do: Repo.all(from(u in User, where: u.ap_id in ^user.info.mutes))
986
987 def blocked_users(user),
988 do: Repo.all(from(u in User, where: u.ap_id in ^user.info.blocks))
989
990 def block_domain(user, domain) do
991 info_cng =
992 user.info
993 |> User.Info.add_to_domain_block(domain)
994
995 cng =
996 change(user)
997 |> put_embed(:info, info_cng)
998
999 update_and_set_cache(cng)
1000 end
1001
1002 def unblock_domain(user, domain) do
1003 info_cng =
1004 user.info
1005 |> User.Info.remove_from_domain_block(domain)
1006
1007 cng =
1008 change(user)
1009 |> put_embed(:info, info_cng)
1010
1011 update_and_set_cache(cng)
1012 end
1013
1014 def maybe_local_user_query(query, local) do
1015 if local, do: local_user_query(query), else: query
1016 end
1017
1018 def local_user_query(query \\ User) do
1019 from(
1020 u in query,
1021 where: u.local == true,
1022 where: not is_nil(u.nickname)
1023 )
1024 end
1025
1026 def maybe_external_user_query(query, external) do
1027 if external, do: external_user_query(query), else: query
1028 end
1029
1030 def external_user_query(query \\ User) do
1031 from(
1032 u in query,
1033 where: u.local == false,
1034 where: not is_nil(u.nickname)
1035 )
1036 end
1037
1038 def maybe_active_user_query(query, active) do
1039 if active, do: active_user_query(query), else: query
1040 end
1041
1042 def active_user_query(query \\ User) do
1043 from(
1044 u in query,
1045 where: fragment("not (?->'deactivated' @> 'true')", u.info),
1046 where: not is_nil(u.nickname)
1047 )
1048 end
1049
1050 def maybe_deactivated_user_query(query, deactivated) do
1051 if deactivated, do: deactivated_user_query(query), else: query
1052 end
1053
1054 def deactivated_user_query(query \\ User) do
1055 from(
1056 u in query,
1057 where: fragment("(?->'deactivated' @> 'true')", u.info),
1058 where: not is_nil(u.nickname)
1059 )
1060 end
1061
1062 def active_local_user_query do
1063 from(
1064 u in local_user_query(),
1065 where: fragment("not (?->'deactivated' @> 'true')", u.info)
1066 )
1067 end
1068
1069 def moderator_user_query do
1070 from(
1071 u in User,
1072 where: u.local == true,
1073 where: fragment("?->'is_moderator' @> 'true'", u.info)
1074 )
1075 end
1076
1077 def deactivate(%User{} = user, status \\ true) do
1078 info_cng = User.Info.set_activation_status(user.info, status)
1079
1080 cng =
1081 change(user)
1082 |> put_embed(:info, info_cng)
1083
1084 update_and_set_cache(cng)
1085 end
1086
1087 def delete(%User{} = user) do
1088 {:ok, user} = User.deactivate(user)
1089
1090 # Remove all relationships
1091 {:ok, followers} = User.get_followers(user)
1092
1093 Enum.each(followers, fn follower -> User.unfollow(follower, user) end)
1094
1095 {:ok, friends} = User.get_friends(user)
1096
1097 Enum.each(friends, fn followed -> User.unfollow(user, followed) end)
1098
1099 delete_user_activities(user)
1100 end
1101
1102 def delete_user_activities(%User{ap_id: ap_id} = user) do
1103 Activity
1104 |> where(actor: ^ap_id)
1105 |> Activity.with_preloaded_object()
1106 |> Repo.all()
1107 |> Enum.each(fn
1108 %{data: %{"type" => "Create"}} = activity ->
1109 activity |> Object.normalize() |> ActivityPub.delete()
1110
1111 # TODO: Do something with likes, follows, repeats.
1112 _ ->
1113 "Doing nothing"
1114 end)
1115
1116 {:ok, user}
1117 end
1118
1119 def html_filter_policy(%User{info: %{no_rich_text: true}}) do
1120 Pleroma.HTML.Scrubber.TwitterText
1121 end
1122
1123 @default_scrubbers Pleroma.Config.get([:markup, :scrub_policy])
1124
1125 def html_filter_policy(_), do: @default_scrubbers
1126
1127 def fetch_by_ap_id(ap_id) do
1128 ap_try = ActivityPub.make_user_from_ap_id(ap_id)
1129
1130 case ap_try do
1131 {:ok, user} ->
1132 user
1133
1134 _ ->
1135 case OStatus.make_user(ap_id) do
1136 {:ok, user} -> user
1137 _ -> {:error, "Could not fetch by AP id"}
1138 end
1139 end
1140 end
1141
1142 def get_or_fetch_by_ap_id(ap_id) do
1143 user = get_by_ap_id(ap_id)
1144
1145 if !is_nil(user) and !User.needs_update?(user) do
1146 user
1147 else
1148 # Whether to fetch initial posts for the user (if it's a new user & the fetching is enabled)
1149 should_fetch_initial = is_nil(user) and Pleroma.Config.get([:fetch_initial_posts, :enabled])
1150
1151 user = fetch_by_ap_id(ap_id)
1152
1153 if should_fetch_initial do
1154 with %User{} = user do
1155 {:ok, _} = Task.start(__MODULE__, :fetch_initial_posts, [user])
1156 end
1157 end
1158
1159 user
1160 end
1161 end
1162
1163 def get_or_create_instance_user do
1164 relay_uri = "#{Pleroma.Web.Endpoint.url()}/relay"
1165
1166 if user = get_by_ap_id(relay_uri) do
1167 user
1168 else
1169 changes =
1170 %User{info: %User.Info{}}
1171 |> cast(%{}, [:ap_id, :nickname, :local])
1172 |> put_change(:ap_id, relay_uri)
1173 |> put_change(:nickname, nil)
1174 |> put_change(:local, true)
1175 |> put_change(:follower_address, relay_uri <> "/followers")
1176
1177 {:ok, user} = Repo.insert(changes)
1178 user
1179 end
1180 end
1181
1182 # AP style
1183 def public_key_from_info(%{
1184 source_data: %{"publicKey" => %{"publicKeyPem" => public_key_pem}}
1185 }) do
1186 key =
1187 public_key_pem
1188 |> :public_key.pem_decode()
1189 |> hd()
1190 |> :public_key.pem_entry_decode()
1191
1192 {:ok, key}
1193 end
1194
1195 # OStatus Magic Key
1196 def public_key_from_info(%{magic_key: magic_key}) do
1197 {:ok, Pleroma.Web.Salmon.decode_key(magic_key)}
1198 end
1199
1200 def get_public_key_for_ap_id(ap_id) do
1201 with %User{} = user <- get_or_fetch_by_ap_id(ap_id),
1202 {:ok, public_key} <- public_key_from_info(user.info) do
1203 {:ok, public_key}
1204 else
1205 _ -> :error
1206 end
1207 end
1208
1209 defp blank?(""), do: nil
1210 defp blank?(n), do: n
1211
1212 def insert_or_update_user(data) do
1213 data =
1214 data
1215 |> Map.put(:name, blank?(data[:name]) || data[:nickname])
1216
1217 cs = User.remote_user_creation(data)
1218
1219 Repo.insert(cs, on_conflict: :replace_all, conflict_target: :nickname)
1220 end
1221
1222 def ap_enabled?(%User{local: true}), do: true
1223 def ap_enabled?(%User{info: info}), do: info.ap_enabled
1224 def ap_enabled?(_), do: false
1225
1226 @doc "Gets or fetch a user by uri or nickname."
1227 @spec get_or_fetch(String.t()) :: User.t()
1228 def get_or_fetch("http" <> _host = uri), do: get_or_fetch_by_ap_id(uri)
1229 def get_or_fetch(nickname), do: get_or_fetch_by_nickname(nickname)
1230
1231 # wait a period of time and return newest version of the User structs
1232 # this is because we have synchronous follow APIs and need to simulate them
1233 # with an async handshake
1234 def wait_and_refresh(_, %User{local: true} = a, %User{local: true} = b) do
1235 with %User{} = a <- User.get_by_id(a.id),
1236 %User{} = b <- User.get_by_id(b.id) do
1237 {:ok, a, b}
1238 else
1239 _e ->
1240 :error
1241 end
1242 end
1243
1244 def wait_and_refresh(timeout, %User{} = a, %User{} = b) do
1245 with :ok <- :timer.sleep(timeout),
1246 %User{} = a <- User.get_by_id(a.id),
1247 %User{} = b <- User.get_by_id(b.id) do
1248 {:ok, a, b}
1249 else
1250 _e ->
1251 :error
1252 end
1253 end
1254
1255 def parse_bio(bio, user \\ %User{info: %{source_data: %{}}})
1256 def parse_bio(nil, _user), do: ""
1257 def parse_bio(bio, _user) when bio == "", do: bio
1258
1259 def parse_bio(bio, user) do
1260 emoji =
1261 (user.info.source_data["tag"] || [])
1262 |> Enum.filter(fn %{"type" => t} -> t == "Emoji" end)
1263 |> Enum.map(fn %{"icon" => %{"url" => url}, "name" => name} ->
1264 {String.trim(name, ":"), url}
1265 end)
1266
1267 # TODO: get profile URLs other than user.ap_id
1268 profile_urls = [user.ap_id]
1269
1270 bio
1271 |> CommonUtils.format_input("text/plain",
1272 mentions_format: :full,
1273 rel: &RelMe.maybe_put_rel_me(&1, profile_urls)
1274 )
1275 |> elem(0)
1276 |> Formatter.emojify(emoji)
1277 end
1278
1279 def tag(user_identifiers, tags) when is_list(user_identifiers) do
1280 Repo.transaction(fn ->
1281 for user_identifier <- user_identifiers, do: tag(user_identifier, tags)
1282 end)
1283 end
1284
1285 def tag(nickname, tags) when is_binary(nickname),
1286 do: tag(User.get_by_nickname(nickname), tags)
1287
1288 def tag(%User{} = user, tags),
1289 do: update_tags(user, Enum.uniq((user.tags || []) ++ normalize_tags(tags)))
1290
1291 def untag(user_identifiers, tags) when is_list(user_identifiers) do
1292 Repo.transaction(fn ->
1293 for user_identifier <- user_identifiers, do: untag(user_identifier, tags)
1294 end)
1295 end
1296
1297 def untag(nickname, tags) when is_binary(nickname),
1298 do: untag(User.get_by_nickname(nickname), tags)
1299
1300 def untag(%User{} = user, tags),
1301 do: update_tags(user, (user.tags || []) -- normalize_tags(tags))
1302
1303 defp update_tags(%User{} = user, new_tags) do
1304 {:ok, updated_user} =
1305 user
1306 |> change(%{tags: new_tags})
1307 |> update_and_set_cache()
1308
1309 updated_user
1310 end
1311
1312 def bookmark(%User{} = user, status_id) do
1313 bookmarks = Enum.uniq(user.bookmarks ++ [status_id])
1314 update_bookmarks(user, bookmarks)
1315 end
1316
1317 def unbookmark(%User{} = user, status_id) do
1318 bookmarks = Enum.uniq(user.bookmarks -- [status_id])
1319 update_bookmarks(user, bookmarks)
1320 end
1321
1322 def update_bookmarks(%User{} = user, bookmarks) do
1323 user
1324 |> change(%{bookmarks: bookmarks})
1325 |> update_and_set_cache
1326 end
1327
1328 defp normalize_tags(tags) do
1329 [tags]
1330 |> List.flatten()
1331 |> Enum.map(&String.downcase(&1))
1332 end
1333
1334 defp local_nickname_regex do
1335 if Pleroma.Config.get([:instance, :extended_nickname_format]) do
1336 @extended_local_nickname_regex
1337 else
1338 @strict_local_nickname_regex
1339 end
1340 end
1341
1342 def local_nickname(nickname_or_mention) do
1343 nickname_or_mention
1344 |> full_nickname()
1345 |> String.split("@")
1346 |> hd()
1347 end
1348
1349 def full_nickname(nickname_or_mention),
1350 do: String.trim_leading(nickname_or_mention, "@")
1351
1352 def error_user(ap_id) do
1353 %User{
1354 name: ap_id,
1355 ap_id: ap_id,
1356 info: %User.Info{},
1357 nickname: "erroruser@example.com",
1358 inserted_at: NaiveDateTime.utc_now()
1359 }
1360 end
1361
1362 def all_superusers do
1363 from(
1364 u in User,
1365 where: u.local == true,
1366 where: fragment("?->'is_admin' @> 'true' OR ?->'is_moderator' @> 'true'", u.info, u.info)
1367 )
1368 |> Repo.all()
1369 end
1370
1371 defp paginate(query, page, page_size) do
1372 from(u in query,
1373 limit: ^page_size,
1374 offset: ^((page - 1) * page_size)
1375 )
1376 end
1377
1378 def showing_reblogs?(%User{} = user, %User{} = target) do
1379 target.ap_id not in user.info.muted_reblogs
1380 end
1381 end
Fork of https://akkoma.dev/AkkomaGang/akkoma.git