projects / akkoma / blob
? search:


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