projects / akkoma / blob
? search:


3c6fb4f9b614f46ed9f9a225527bc64ad9322e89
[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 "? @> ?",
617 a.data,
618 ^%{"object" => user.ap_id}
619 )
620 )
621 end
622
623 def update_follow_request_count(%User{} = user) do
624 subquery =
625 user
626 |> User.get_follow_requests_query()
627 |> select([a], %{count: count(a.id)})
628
629 User
630 |> where(id: ^user.id)
631 |> join(:inner, [u], s in subquery(subquery))
632 |> update([u, s],
633 set: [
634 info:
635 fragment(
636 "jsonb_set(?, '{follow_request_count}', ?::varchar::jsonb, true)",
637 u.info,
638 s.count
639 )
640 ]
641 )
642 |> Repo.update_all([], returning: true)
643 |> case do
644 {1, [user]} -> {:ok, user}
645 _ -> {:error, user}
646 end
647 end
648
649 def get_follow_requests(%User{} = user) do
650 q = get_follow_requests_query(user)
651 reqs = Repo.all(q)
652
653 users =
654 Enum.map(reqs, fn req -> req.actor end)
655 |> Enum.uniq()
656 |> Enum.map(fn ap_id -> get_by_ap_id(ap_id) end)
657 |> Enum.filter(fn u -> !is_nil(u) end)
658 |> Enum.filter(fn u -> !following?(u, user) end)
659
660 {:ok, users}
661 end
662
663 def increase_note_count(%User{} = user) do
664 info_cng = User.Info.add_to_note_count(user.info, 1)
665
666 cng =
667 change(user)
668 |> put_embed(:info, info_cng)
669
670 update_and_set_cache(cng)
671 end
672
673 def decrease_note_count(%User{} = user) do
674 info_cng = User.Info.add_to_note_count(user.info, -1)
675
676 cng =
677 change(user)
678 |> put_embed(:info, info_cng)
679
680 update_and_set_cache(cng)
681 end
682
683 def update_note_count(%User{} = user) do
684 note_count_query =
685 from(
686 a in Object,
687 where: fragment("?->>'actor' = ? and ?->>'type' = 'Note'", a.data, ^user.ap_id, a.data),
688 select: count(a.id)
689 )
690
691 note_count = Repo.one(note_count_query)
692
693 info_cng = User.Info.set_note_count(user.info, note_count)
694
695 cng =
696 change(user)
697 |> put_embed(:info, info_cng)
698
699 update_and_set_cache(cng)
700 end
701
702 def update_follower_count(%User{} = user) do
703 follower_count_query =
704 from(
705 u in User,
706 where: ^user.follower_address in u.following,
707 where: u.id != ^user.id,
708 select: count(u.id)
709 )
710
711 follower_count = Repo.one(follower_count_query)
712
713 info_cng =
714 user.info
715 |> User.Info.set_follower_count(follower_count)
716
717 cng =
718 change(user)
719 |> put_embed(:info, info_cng)
720
721 update_and_set_cache(cng)
722 end
723
724 def get_users_from_set_query(ap_ids, false) do
725 from(
726 u in User,
727 where: u.ap_id in ^ap_ids
728 )
729 end
730
731 def get_users_from_set_query(ap_ids, true) do
732 query = get_users_from_set_query(ap_ids, false)
733
734 from(
735 u in query,
736 where: u.local == true
737 )
738 end
739
740 def get_users_from_set(ap_ids, local_only \\ true) do
741 get_users_from_set_query(ap_ids, local_only)
742 |> Repo.all()
743 end
744
745 def get_recipients_from_activity(%Activity{recipients: to}) do
746 query =
747 from(
748 u in User,
749 where: u.ap_id in ^to,
750 or_where: fragment("? && ?", u.following, ^to)
751 )
752
753 query = from(u in query, where: u.local == true)
754
755 Repo.all(query)
756 end
757
758 def search(term, options \\ %{}) do
759 # Strip the beginning @ off if there is a query
760 term = String.trim_leading(term, "@")
761 query = options[:query] || User
762
763 if options[:resolve], do: get_or_fetch(term)
764
765 fts_results =
766 do_search(fts_search_subquery(term, query), options[:for_user], limit: options[:limit])
767
768 {:ok, trigram_results} =
769 Repo.transaction(fn ->
770 Ecto.Adapters.SQL.query(Repo, "select set_limit(0.25)", [])
771
772 do_search(trigram_search_subquery(term, query), options[:for_user], limit: options[:limit])
773 end)
774
775 Enum.uniq_by(fts_results ++ trigram_results, & &1.id)
776 end
777
778 def all(page, page_size) do
779 from(
780 u in User,
781 limit: ^page_size,
782 offset: ^((page - 1) * page_size),
783 order_by: u.id
784 )
785 |> Repo.all()
786 end
787
788 def count_all_except_one(user) do
789 query =
790 from(
791 u in User,
792 where: u.id != ^user.id
793 )
794
795 Repo.aggregate(query, :count, :id)
796 end
797
798 defp do_search(subquery, for_user, options) do
799 q =
800 from(
801 s in subquery(subquery),
802 order_by: [desc: s.search_rank],
803 limit: ^(options[:limit] || 20)
804 )
805
806 results =
807 q
808 |> Repo.all()
809 |> Enum.filter(&(&1.search_rank > 0))
810
811 boost_search_results(results, for_user)
812 end
813
814 defp fts_search_subquery(term, query) do
815 processed_query =
816 term
817 |> String.replace(~r/\W+/, " ")
818 |> String.trim()
819 |> String.split()
820 |> Enum.map(&(&1 <> ":*"))
821 |> Enum.join(" | ")
822
823 from(
824 u in query,
825 select_merge: %{
826 search_rank:
827 fragment(
828 """
829 ts_rank_cd(
830 setweight(to_tsvector('simple', regexp_replace(?, '\\W', ' ', 'g')), 'A') ||
831 setweight(to_tsvector('simple', regexp_replace(coalesce(?, ''), '\\W', ' ', 'g')), 'B'),
832 to_tsquery('simple', ?),
833 32
834 )
835 """,
836 u.nickname,
837 u.name,
838 ^processed_query
839 )
840 },
841 where:
842 fragment(
843 """
844 (setweight(to_tsvector('simple', regexp_replace(?, '\\W', ' ', 'g')), 'A') ||
845 setweight(to_tsvector('simple', regexp_replace(coalesce(?, ''), '\\W', ' ', 'g')), 'B')) @@ to_tsquery('simple', ?)
846 """,
847 u.nickname,
848 u.name,
849 ^processed_query
850 )
851 )
852 end
853
854 defp trigram_search_subquery(term, query) do
855 from(
856 u in query,
857 select_merge: %{
858 search_rank:
859 fragment(
860 "similarity(?, trim(? || ' ' || coalesce(?, '')))",
861 ^term,
862 u.nickname,
863 u.name
864 )
865 },
866 where: fragment("trim(? || ' ' || coalesce(?, '')) % ?", u.nickname, u.name, ^term)
867 )
868 end
869
870 defp boost_search_results(results, nil), do: results
871
872 defp boost_search_results(results, for_user) do
873 friends_ids = get_friends_ids(for_user)
874 followers_ids = get_followers_ids(for_user)
875
876 Enum.map(
877 results,
878 fn u ->
879 search_rank_coef =
880 cond do
881 u.id in friends_ids ->
882 1.2
883
884 u.id in followers_ids ->
885 1.1
886
887 true ->
888 1
889 end
890
891 Map.put(u, :search_rank, u.search_rank * search_rank_coef)
892 end
893 )
894 |> Enum.sort_by(&(-&1.search_rank))
895 end
896
897 def blocks_import(%User{} = blocker, blocked_identifiers) when is_list(blocked_identifiers) do
898 Enum.map(
899 blocked_identifiers,
900 fn blocked_identifier ->
901 with %User{} = blocked <- get_or_fetch(blocked_identifier),
902 {:ok, blocker} <- block(blocker, blocked),
903 {:ok, _} <- ActivityPub.block(blocker, blocked) do
904 blocked
905 else
906 err ->
907 Logger.debug("blocks_import failed for #{blocked_identifier} with: #{inspect(err)}")
908 err
909 end
910 end
911 )
912 end
913
914 def mute(muter, %User{ap_id: ap_id}) do
915 info_cng =
916 muter.info
917 |> User.Info.add_to_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 unmute(muter, %{ap_id: ap_id}) do
927 info_cng =
928 muter.info
929 |> User.Info.remove_from_mutes(ap_id)
930
931 cng =
932 change(muter)
933 |> put_embed(:info, info_cng)
934
935 update_and_set_cache(cng)
936 end
937
938 def block(blocker, %User{ap_id: ap_id} = blocked) do
939 # sever any follow relationships to prevent leaks per activitypub (Pleroma issue #213)
940 blocker =
941 if following?(blocker, blocked) do
942 {:ok, blocker, _} = unfollow(blocker, blocked)
943 blocker
944 else
945 blocker
946 end
947
948 if following?(blocked, blocker) do
949 unfollow(blocked, blocker)
950 end
951
952 info_cng =
953 blocker.info
954 |> User.Info.add_to_block(ap_id)
955
956 cng =
957 change(blocker)
958 |> put_embed(:info, info_cng)
959
960 update_and_set_cache(cng)
961 end
962
963 # helper to handle the block given only an actor's AP id
964 def block(blocker, %{ap_id: ap_id}) do
965 block(blocker, User.get_by_ap_id(ap_id))
966 end
967
968 def unblock(blocker, %{ap_id: ap_id}) do
969 info_cng =
970 blocker.info
971 |> User.Info.remove_from_block(ap_id)
972
973 cng =
974 change(blocker)
975 |> put_embed(:info, info_cng)
976
977 update_and_set_cache(cng)
978 end
979
980 def mutes?(user, %{ap_id: ap_id}), do: Enum.member?(user.info.mutes, ap_id)
981
982 def blocks?(user, %{ap_id: ap_id}) do
983 blocks = user.info.blocks
984 domain_blocks = user.info.domain_blocks
985 %{host: host} = URI.parse(ap_id)
986
987 Enum.member?(blocks, ap_id) ||
988 Enum.any?(domain_blocks, fn domain ->
989 host == domain
990 end)
991 end
992
993 def muted_users(user),
994 do: Repo.all(from(u in User, where: u.ap_id in ^user.info.mutes))
995
996 def blocked_users(user),
997 do: Repo.all(from(u in User, where: u.ap_id in ^user.info.blocks))
998
999 def block_domain(user, domain) do
1000 info_cng =
1001 user.info
1002 |> User.Info.add_to_domain_block(domain)
1003
1004 cng =
1005 change(user)
1006 |> put_embed(:info, info_cng)
1007
1008 update_and_set_cache(cng)
1009 end
1010
1011 def unblock_domain(user, domain) do
1012 info_cng =
1013 user.info
1014 |> User.Info.remove_from_domain_block(domain)
1015
1016 cng =
1017 change(user)
1018 |> put_embed(:info, info_cng)
1019
1020 update_and_set_cache(cng)
1021 end
1022
1023 def maybe_local_user_query(local) do
1024 if local, do: local_user_query(), else: User
1025 end
1026
1027 def local_user_query do
1028 from(
1029 u in User,
1030 where: u.local == true,
1031 where: not is_nil(u.nickname)
1032 )
1033 end
1034
1035 def active_local_user_query do
1036 from(
1037 u in local_user_query(),
1038 where: fragment("not (?->'deactivated' @> 'true')", u.info)
1039 )
1040 end
1041
1042 def moderator_user_query do
1043 from(
1044 u in User,
1045 where: u.local == true,
1046 where: fragment("?->'is_moderator' @> 'true'", u.info)
1047 )
1048 end
1049
1050 def deactivate(%User{} = user, status \\ true) do
1051 info_cng = User.Info.set_activation_status(user.info, status)
1052
1053 cng =
1054 change(user)
1055 |> put_embed(:info, info_cng)
1056
1057 update_and_set_cache(cng)
1058 end
1059
1060 def delete(%User{} = user) do
1061 {:ok, user} = User.deactivate(user)
1062
1063 # Remove all relationships
1064 {:ok, followers} = User.get_followers(user)
1065
1066 followers
1067 |> Enum.each(fn follower -> User.unfollow(follower, user) end)
1068
1069 {:ok, friends} = User.get_friends(user)
1070
1071 friends
1072 |> Enum.each(fn followed -> User.unfollow(user, followed) end)
1073
1074 query = from(a in Activity, where: a.actor == ^user.ap_id)
1075
1076 Repo.all(query)
1077 |> Enum.each(fn activity ->
1078 case activity.data["type"] do
1079 "Create" ->
1080 ActivityPub.delete(Object.normalize(activity.data["object"]))
1081
1082 # TODO: Do something with likes, follows, repeats.
1083 _ ->
1084 "Doing nothing"
1085 end
1086 end)
1087
1088 {:ok, user}
1089 end
1090
1091 def html_filter_policy(%User{info: %{no_rich_text: true}}) do
1092 Pleroma.HTML.Scrubber.TwitterText
1093 end
1094
1095 @default_scrubbers Pleroma.Config.get([:markup, :scrub_policy])
1096
1097 def html_filter_policy(_), do: @default_scrubbers
1098
1099 def get_or_fetch_by_ap_id(ap_id) do
1100 user = get_by_ap_id(ap_id)
1101
1102 if !is_nil(user) and !User.needs_update?(user) do
1103 user
1104 else
1105 ap_try = ActivityPub.make_user_from_ap_id(ap_id)
1106
1107 case ap_try do
1108 {:ok, user} ->
1109 user
1110
1111 _ ->
1112 case OStatus.make_user(ap_id) do
1113 {:ok, user} -> user
1114 _ -> {:error, "Could not fetch by AP id"}
1115 end
1116 end
1117 end
1118 end
1119
1120 def get_or_create_instance_user do
1121 relay_uri = "#{Pleroma.Web.Endpoint.url()}/relay"
1122
1123 if user = get_by_ap_id(relay_uri) do
1124 user
1125 else
1126 changes =
1127 %User{info: %User.Info{}}
1128 |> cast(%{}, [:ap_id, :nickname, :local])
1129 |> put_change(:ap_id, relay_uri)
1130 |> put_change(:nickname, nil)
1131 |> put_change(:local, true)
1132 |> put_change(:follower_address, relay_uri <> "/followers")
1133
1134 {:ok, user} = Repo.insert(changes)
1135 user
1136 end
1137 end
1138
1139 # AP style
1140 def public_key_from_info(%{
1141 source_data: %{"publicKey" => %{"publicKeyPem" => public_key_pem}}
1142 }) do
1143 key =
1144 public_key_pem
1145 |> :public_key.pem_decode()
1146 |> hd()
1147 |> :public_key.pem_entry_decode()
1148
1149 {:ok, key}
1150 end
1151
1152 # OStatus Magic Key
1153 def public_key_from_info(%{magic_key: magic_key}) do
1154 {:ok, Pleroma.Web.Salmon.decode_key(magic_key)}
1155 end
1156
1157 def get_public_key_for_ap_id(ap_id) do
1158 with %User{} = user <- get_or_fetch_by_ap_id(ap_id),
1159 {:ok, public_key} <- public_key_from_info(user.info) do
1160 {:ok, public_key}
1161 else
1162 _ -> :error
1163 end
1164 end
1165
1166 defp blank?(""), do: nil
1167 defp blank?(n), do: n
1168
1169 def insert_or_update_user(data) do
1170 data =
1171 data
1172 |> Map.put(:name, blank?(data[:name]) || data[:nickname])
1173
1174 cs = User.remote_user_creation(data)
1175
1176 Repo.insert(cs, on_conflict: :replace_all, conflict_target: :nickname)
1177 end
1178
1179 def ap_enabled?(%User{local: true}), do: true
1180 def ap_enabled?(%User{info: info}), do: info.ap_enabled
1181 def ap_enabled?(_), do: false
1182
1183 @doc "Gets or fetch a user by uri or nickname."
1184 @spec get_or_fetch(String.t()) :: User.t()
1185 def get_or_fetch("http" <> _host = uri), do: get_or_fetch_by_ap_id(uri)
1186 def get_or_fetch(nickname), do: get_or_fetch_by_nickname(nickname)
1187
1188 # wait a period of time and return newest version of the User structs
1189 # this is because we have synchronous follow APIs and need to simulate them
1190 # with an async handshake
1191 def wait_and_refresh(_, %User{local: true} = a, %User{local: true} = b) do
1192 with %User{} = a <- Repo.get(User, a.id),
1193 %User{} = b <- Repo.get(User, b.id) do
1194 {:ok, a, b}
1195 else
1196 _e ->
1197 :error
1198 end
1199 end
1200
1201 def wait_and_refresh(timeout, %User{} = a, %User{} = b) do
1202 with :ok <- :timer.sleep(timeout),
1203 %User{} = a <- Repo.get(User, a.id),
1204 %User{} = b <- Repo.get(User, b.id) do
1205 {:ok, a, b}
1206 else
1207 _e ->
1208 :error
1209 end
1210 end
1211
1212 def parse_bio(bio, user \\ %User{info: %{source_data: %{}}})
1213 def parse_bio(nil, _user), do: ""
1214 def parse_bio(bio, _user) when bio == "", do: bio
1215
1216 def parse_bio(bio, user) do
1217 emoji =
1218 (user.info.source_data["tag"] || [])
1219 |> Enum.filter(fn %{"type" => t} -> t == "Emoji" end)
1220 |> Enum.map(fn %{"icon" => %{"url" => url}, "name" => name} ->
1221 {String.trim(name, ":"), url}
1222 end)
1223
1224 bio
1225 |> CommonUtils.format_input("text/plain", mentions_format: :full)
1226 |> elem(0)
1227 |> Formatter.emojify(emoji)
1228 end
1229
1230 def tag(user_identifiers, tags) when is_list(user_identifiers) do
1231 Repo.transaction(fn ->
1232 for user_identifier <- user_identifiers, do: tag(user_identifier, tags)
1233 end)
1234 end
1235
1236 def tag(nickname, tags) when is_binary(nickname),
1237 do: tag(User.get_by_nickname(nickname), tags)
1238
1239 def tag(%User{} = user, tags),
1240 do: update_tags(user, Enum.uniq((user.tags || []) ++ normalize_tags(tags)))
1241
1242 def untag(user_identifiers, tags) when is_list(user_identifiers) do
1243 Repo.transaction(fn ->
1244 for user_identifier <- user_identifiers, do: untag(user_identifier, tags)
1245 end)
1246 end
1247
1248 def untag(nickname, tags) when is_binary(nickname),
1249 do: untag(User.get_by_nickname(nickname), tags)
1250
1251 def untag(%User{} = user, tags),
1252 do: update_tags(user, (user.tags || []) -- normalize_tags(tags))
1253
1254 defp update_tags(%User{} = user, new_tags) do
1255 {:ok, updated_user} =
1256 user
1257 |> change(%{tags: new_tags})
1258 |> update_and_set_cache()
1259
1260 updated_user
1261 end
1262
1263 def bookmark(%User{} = user, status_id) do
1264 bookmarks = Enum.uniq(user.bookmarks ++ [status_id])
1265 update_bookmarks(user, bookmarks)
1266 end
1267
1268 def unbookmark(%User{} = user, status_id) do
1269 bookmarks = Enum.uniq(user.bookmarks -- [status_id])
1270 update_bookmarks(user, bookmarks)
1271 end
1272
1273 def update_bookmarks(%User{} = user, bookmarks) do
1274 user
1275 |> change(%{bookmarks: bookmarks})
1276 |> update_and_set_cache
1277 end
1278
1279 defp normalize_tags(tags) do
1280 [tags]
1281 |> List.flatten()
1282 |> Enum.map(&String.downcase(&1))
1283 end
1284
1285 defp local_nickname_regex() do
1286 if Pleroma.Config.get([:instance, :extended_nickname_format]) do
1287 @extended_local_nickname_regex
1288 else
1289 @strict_local_nickname_regex
1290 end
1291 end
1292
1293 def local_nickname(nickname_or_mention) do
1294 nickname_or_mention
1295 |> full_nickname()
1296 |> String.split("@")
1297 |> hd()
1298 end
1299
1300 def full_nickname(nickname_or_mention),
1301 do: String.trim_leading(nickname_or_mention, "@")
1302
1303 def error_user(ap_id) do
1304 %User{
1305 name: ap_id,
1306 ap_id: ap_id,
1307 info: %User.Info{},
1308 nickname: "erroruser@example.com",
1309 inserted_at: NaiveDateTime.utc_now()
1310 }
1311 end
1312
1313 def all_superusers do
1314 from(
1315 u in User,
1316 where: u.local == true,
1317 where: fragment("?->'is_admin' @> 'true' OR ?->'is_moderator' @> 'true'", u.info, u.info)
1318 )
1319 |> Repo.all()
1320 end
1321 end
Fork of https://akkoma.dev/AkkomaGang/akkoma.git