603fc3b4459ebf0d1f30bb18cc68a11bec460ce4
[akkoma] / lib / pleroma / user.ex
1 # Pleroma: A lightweight social networking server
2 # Copyright © 2017-2020 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 import Ecto, only: [assoc: 2]
11
12 alias Ecto.Multi
13 alias Pleroma.Activity
14 alias Pleroma.Config
15 alias Pleroma.Conversation.Participation
16 alias Pleroma.Delivery
17 alias Pleroma.EctoType.ActivityPub.ObjectValidators
18 alias Pleroma.Emoji
19 alias Pleroma.FollowingRelationship
20 alias Pleroma.Formatter
21 alias Pleroma.HTML
22 alias Pleroma.Keys
23 alias Pleroma.MFA
24 alias Pleroma.Notification
25 alias Pleroma.Object
26 alias Pleroma.Registration
27 alias Pleroma.Repo
28 alias Pleroma.RepoStreamer
29 alias Pleroma.User
30 alias Pleroma.UserRelationship
31 alias Pleroma.Web
32 alias Pleroma.Web.ActivityPub.ActivityPub
33 alias Pleroma.Web.ActivityPub.Builder
34 alias Pleroma.Web.ActivityPub.Pipeline
35 alias Pleroma.Web.ActivityPub.Utils
36 alias Pleroma.Web.CommonAPI
37 alias Pleroma.Web.CommonAPI.Utils, as: CommonUtils
38 alias Pleroma.Web.OAuth
39 alias Pleroma.Web.RelMe
40 alias Pleroma.Workers.BackgroundWorker
41
42 require Logger
43
44 @type t :: %__MODULE__{}
45 @type account_status ::
46 :active
47 | :deactivated
48 | :password_reset_pending
49 | :confirmation_pending
50 | :approval_pending
51 @primary_key {:id, FlakeId.Ecto.CompatType, autogenerate: true}
52
53 # credo:disable-for-next-line Credo.Check.Readability.MaxLineLength
54 @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])?)*$/
55
56 @strict_local_nickname_regex ~r/^[a-zA-Z\d]+$/
57 @extended_local_nickname_regex ~r/^[a-zA-Z\d_-]+$/
58
59 # AP ID user relationships (blocks, mutes etc.)
60 # Format: [rel_type: [outgoing_rel: :outgoing_rel_target, incoming_rel: :incoming_rel_source]]
61 @user_relationships_config [
62 block: [
63 blocker_blocks: :blocked_users,
64 blockee_blocks: :blocker_users
65 ],
66 mute: [
67 muter_mutes: :muted_users,
68 mutee_mutes: :muter_users
69 ],
70 reblog_mute: [
71 reblog_muter_mutes: :reblog_muted_users,
72 reblog_mutee_mutes: :reblog_muter_users
73 ],
74 notification_mute: [
75 notification_muter_mutes: :notification_muted_users,
76 notification_mutee_mutes: :notification_muter_users
77 ],
78 # Note: `inverse_subscription` relationship is inverse: subscriber acts as relationship target
79 inverse_subscription: [
80 subscribee_subscriptions: :subscriber_users,
81 subscriber_subscriptions: :subscribee_users
82 ]
83 ]
84
85 schema "users" do
86 field(:bio, :string, default: "")
87 field(:raw_bio, :string)
88 field(:email, :string)
89 field(:name, :string)
90 field(:nickname, :string)
91 field(:password_hash, :string)
92 field(:password, :string, virtual: true)
93 field(:password_confirmation, :string, virtual: true)
94 field(:keys, :string)
95 field(:public_key, :string)
96 field(:ap_id, :string)
97 field(:avatar, :map, default: %{})
98 field(:local, :boolean, default: true)
99 field(:follower_address, :string)
100 field(:following_address, :string)
101 field(:search_rank, :float, virtual: true)
102 field(:search_type, :integer, virtual: true)
103 field(:tags, {:array, :string}, default: [])
104 field(:last_refreshed_at, :naive_datetime_usec)
105 field(:last_digest_emailed_at, :naive_datetime)
106 field(:banner, :map, default: %{})
107 field(:background, :map, default: %{})
108 field(:note_count, :integer, default: 0)
109 field(:follower_count, :integer, default: 0)
110 field(:following_count, :integer, default: 0)
111 field(:locked, :boolean, default: false)
112 field(:confirmation_pending, :boolean, default: false)
113 field(:password_reset_pending, :boolean, default: false)
114 field(:approval_pending, :boolean, default: false)
115 field(:registration_reason, :string, default: nil)
116 field(:confirmation_token, :string, default: nil)
117 field(:default_scope, :string, default: "public")
118 field(:domain_blocks, {:array, :string}, default: [])
119 field(:deactivated, :boolean, default: false)
120 field(:no_rich_text, :boolean, default: false)
121 field(:ap_enabled, :boolean, default: false)
122 field(:is_moderator, :boolean, default: false)
123 field(:is_admin, :boolean, default: false)
124 field(:show_role, :boolean, default: true)
125 field(:mastofe_settings, :map, default: nil)
126 field(:uri, ObjectValidators.Uri, default: nil)
127 field(:hide_followers_count, :boolean, default: false)
128 field(:hide_follows_count, :boolean, default: false)
129 field(:hide_followers, :boolean, default: false)
130 field(:hide_follows, :boolean, default: false)
131 field(:hide_favorites, :boolean, default: true)
132 field(:unread_conversation_count, :integer, default: 0)
133 field(:pinned_activities, {:array, :string}, default: [])
134 field(:email_notifications, :map, default: %{"digest" => false})
135 field(:mascot, :map, default: nil)
136 field(:emoji, :map, default: %{})
137 field(:pleroma_settings_store, :map, default: %{})
138 field(:fields, {:array, :map}, default: [])
139 field(:raw_fields, {:array, :map}, default: [])
140 field(:discoverable, :boolean, default: false)
141 field(:invisible, :boolean, default: false)
142 field(:allow_following_move, :boolean, default: true)
143 field(:skip_thread_containment, :boolean, default: false)
144 field(:actor_type, :string, default: "Person")
145 field(:also_known_as, {:array, :string}, default: [])
146 field(:inbox, :string)
147 field(:shared_inbox, :string)
148 field(:accepts_chat_messages, :boolean, default: nil)
149
150 embeds_one(
151 :notification_settings,
152 Pleroma.User.NotificationSetting,
153 on_replace: :update
154 )
155
156 has_many(:notifications, Notification)
157 has_many(:registrations, Registration)
158 has_many(:deliveries, Delivery)
159
160 has_many(:outgoing_relationships, UserRelationship, foreign_key: :source_id)
161 has_many(:incoming_relationships, UserRelationship, foreign_key: :target_id)
162
163 for {relationship_type,
164 [
165 {outgoing_relation, outgoing_relation_target},
166 {incoming_relation, incoming_relation_source}
167 ]} <- @user_relationships_config do
168 # Definitions of `has_many` relations: :blocker_blocks, :muter_mutes, :reblog_muter_mutes,
169 # :notification_muter_mutes, :subscribee_subscriptions
170 has_many(outgoing_relation, UserRelationship,
171 foreign_key: :source_id,
172 where: [relationship_type: relationship_type]
173 )
174
175 # Definitions of `has_many` relations: :blockee_blocks, :mutee_mutes, :reblog_mutee_mutes,
176 # :notification_mutee_mutes, :subscriber_subscriptions
177 has_many(incoming_relation, UserRelationship,
178 foreign_key: :target_id,
179 where: [relationship_type: relationship_type]
180 )
181
182 # Definitions of `has_many` relations: :blocked_users, :muted_users, :reblog_muted_users,
183 # :notification_muted_users, :subscriber_users
184 has_many(outgoing_relation_target, through: [outgoing_relation, :target])
185
186 # Definitions of `has_many` relations: :blocker_users, :muter_users, :reblog_muter_users,
187 # :notification_muter_users, :subscribee_users
188 has_many(incoming_relation_source, through: [incoming_relation, :source])
189 end
190
191 # `:blocks` is deprecated (replaced with `blocked_users` relation)
192 field(:blocks, {:array, :string}, default: [])
193 # `:mutes` is deprecated (replaced with `muted_users` relation)
194 field(:mutes, {:array, :string}, default: [])
195 # `:muted_reblogs` is deprecated (replaced with `reblog_muted_users` relation)
196 field(:muted_reblogs, {:array, :string}, default: [])
197 # `:muted_notifications` is deprecated (replaced with `notification_muted_users` relation)
198 field(:muted_notifications, {:array, :string}, default: [])
199 # `:subscribers` is deprecated (replaced with `subscriber_users` relation)
200 field(:subscribers, {:array, :string}, default: [])
201
202 embeds_one(
203 :multi_factor_authentication_settings,
204 MFA.Settings,
205 on_replace: :delete
206 )
207
208 timestamps()
209 end
210
211 for {_relationship_type, [{_outgoing_relation, outgoing_relation_target}, _]} <-
212 @user_relationships_config do
213 # `def blocked_users_relation/2`, `def muted_users_relation/2`,
214 # `def reblog_muted_users_relation/2`, `def notification_muted_users/2`,
215 # `def subscriber_users/2`
216 def unquote(:"#{outgoing_relation_target}_relation")(user, restrict_deactivated? \\ false) do
217 target_users_query = assoc(user, unquote(outgoing_relation_target))
218
219 if restrict_deactivated? do
220 restrict_deactivated(target_users_query)
221 else
222 target_users_query
223 end
224 end
225
226 # `def blocked_users/2`, `def muted_users/2`, `def reblog_muted_users/2`,
227 # `def notification_muted_users/2`, `def subscriber_users/2`
228 def unquote(outgoing_relation_target)(user, restrict_deactivated? \\ false) do
229 __MODULE__
230 |> apply(unquote(:"#{outgoing_relation_target}_relation"), [
231 user,
232 restrict_deactivated?
233 ])
234 |> Repo.all()
235 end
236
237 # `def blocked_users_ap_ids/2`, `def muted_users_ap_ids/2`, `def reblog_muted_users_ap_ids/2`,
238 # `def notification_muted_users_ap_ids/2`, `def subscriber_users_ap_ids/2`
239 def unquote(:"#{outgoing_relation_target}_ap_ids")(user, restrict_deactivated? \\ false) do
240 __MODULE__
241 |> apply(unquote(:"#{outgoing_relation_target}_relation"), [
242 user,
243 restrict_deactivated?
244 ])
245 |> select([u], u.ap_id)
246 |> Repo.all()
247 end
248 end
249
250 defdelegate following_count(user), to: FollowingRelationship
251 defdelegate following(user), to: FollowingRelationship
252 defdelegate following?(follower, followed), to: FollowingRelationship
253 defdelegate following_ap_ids(user), to: FollowingRelationship
254 defdelegate get_follow_requests(user), to: FollowingRelationship
255 defdelegate search(query, opts \\ []), to: User.Search
256
257 @doc """
258 Dumps Flake Id to SQL-compatible format (16-byte UUID).
259 E.g. "9pQtDGXuq4p3VlcJEm" -> <<0, 0, 1, 110, 179, 218, 42, 92, 213, 41, 44, 227, 95, 213, 0, 0>>
260 """
261 def binary_id(source_id) when is_binary(source_id) do
262 with {:ok, dumped_id} <- FlakeId.Ecto.CompatType.dump(source_id) do
263 dumped_id
264 else
265 _ -> source_id
266 end
267 end
268
269 def binary_id(source_ids) when is_list(source_ids) do
270 Enum.map(source_ids, &binary_id/1)
271 end
272
273 def binary_id(%User{} = user), do: binary_id(user.id)
274
275 @doc "Returns status account"
276 @spec account_status(User.t()) :: account_status()
277 def account_status(%User{deactivated: true}), do: :deactivated
278 def account_status(%User{password_reset_pending: true}), do: :password_reset_pending
279 def account_status(%User{approval_pending: true}), do: :approval_pending
280
281 def account_status(%User{confirmation_pending: true}) do
282 if Config.get([:instance, :account_activation_required]) do
283 :confirmation_pending
284 else
285 :active
286 end
287 end
288
289 def account_status(%User{}), do: :active
290
291 @spec visible_for(User.t(), User.t() | nil) ::
292 :visible
293 | :invisible
294 | :restricted_unauthenticated
295 | :deactivated
296 | :confirmation_pending
297 def visible_for(user, for_user \\ nil)
298
299 def visible_for(%User{invisible: true}, _), do: :invisible
300
301 def visible_for(%User{id: user_id}, %User{id: user_id}), do: :visible
302
303 def visible_for(%User{} = user, nil) do
304 if restrict_unauthenticated?(user) do
305 :restrict_unauthenticated
306 else
307 visible_account_status(user)
308 end
309 end
310
311 def visible_for(%User{} = user, for_user) do
312 if superuser?(for_user) do
313 :visible
314 else
315 visible_account_status(user)
316 end
317 end
318
319 def visible_for(_, _), do: :invisible
320
321 defp restrict_unauthenticated?(%User{local: true}) do
322 Config.restrict_unauthenticated_access?(:profiles, :local)
323 end
324
325 defp restrict_unauthenticated?(%User{local: _}) do
326 Config.restrict_unauthenticated_access?(:profiles, :remote)
327 end
328
329 defp visible_account_status(user) do
330 status = account_status(user)
331
332 if status in [:active, :password_reset_pending] do
333 :visible
334 else
335 status
336 end
337 end
338
339 @spec superuser?(User.t()) :: boolean()
340 def superuser?(%User{local: true, is_admin: true}), do: true
341 def superuser?(%User{local: true, is_moderator: true}), do: true
342 def superuser?(_), do: false
343
344 @spec invisible?(User.t()) :: boolean()
345 def invisible?(%User{invisible: true}), do: true
346 def invisible?(_), do: false
347
348 def avatar_url(user, options \\ []) do
349 case user.avatar do
350 %{"url" => [%{"href" => href} | _]} ->
351 href
352
353 _ ->
354 unless options[:no_default] do
355 Config.get([:assets, :default_user_avatar], "#{Web.base_url()}/images/avi.png")
356 end
357 end
358 end
359
360 def banner_url(user, options \\ []) do
361 case user.banner do
362 %{"url" => [%{"href" => href} | _]} -> href
363 _ -> !options[:no_default] && "#{Web.base_url()}/images/banner.png"
364 end
365 end
366
367 # Should probably be renamed or removed
368 def ap_id(%User{nickname: nickname}), do: "#{Web.base_url()}/users/#{nickname}"
369
370 def ap_followers(%User{follower_address: fa}) when is_binary(fa), do: fa
371 def ap_followers(%User{} = user), do: "#{ap_id(user)}/followers"
372
373 @spec ap_following(User.t()) :: String.t()
374 def ap_following(%User{following_address: fa}) when is_binary(fa), do: fa
375 def ap_following(%User{} = user), do: "#{ap_id(user)}/following"
376
377 @spec restrict_deactivated(Ecto.Query.t()) :: Ecto.Query.t()
378 def restrict_deactivated(query) do
379 from(u in query, where: u.deactivated != ^true)
380 end
381
382 defp truncate_fields_param(params) do
383 if Map.has_key?(params, :fields) do
384 Map.put(params, :fields, Enum.map(params[:fields], &truncate_field/1))
385 else
386 params
387 end
388 end
389
390 defp truncate_if_exists(params, key, max_length) do
391 if Map.has_key?(params, key) and is_binary(params[key]) do
392 {value, _chopped} = String.split_at(params[key], max_length)
393 Map.put(params, key, value)
394 else
395 params
396 end
397 end
398
399 defp fix_follower_address(%{follower_address: _, following_address: _} = params), do: params
400
401 defp fix_follower_address(%{nickname: nickname} = params),
402 do: Map.put(params, :follower_address, ap_followers(%User{nickname: nickname}))
403
404 defp fix_follower_address(params), do: params
405
406 def remote_user_changeset(struct \\ %User{local: false}, params) do
407 bio_limit = Config.get([:instance, :user_bio_length], 5000)
408 name_limit = Config.get([:instance, :user_name_length], 100)
409
410 name =
411 case params[:name] do
412 name when is_binary(name) and byte_size(name) > 0 -> name
413 _ -> params[:nickname]
414 end
415
416 params =
417 params
418 |> Map.put(:name, name)
419 |> Map.put_new(:last_refreshed_at, NaiveDateTime.utc_now())
420 |> truncate_if_exists(:name, name_limit)
421 |> truncate_if_exists(:bio, bio_limit)
422 |> truncate_fields_param()
423 |> fix_follower_address()
424
425 struct
426 |> cast(
427 params,
428 [
429 :bio,
430 :name,
431 :emoji,
432 :ap_id,
433 :inbox,
434 :shared_inbox,
435 :nickname,
436 :public_key,
437 :avatar,
438 :ap_enabled,
439 :banner,
440 :locked,
441 :last_refreshed_at,
442 :uri,
443 :follower_address,
444 :following_address,
445 :hide_followers,
446 :hide_follows,
447 :hide_followers_count,
448 :hide_follows_count,
449 :follower_count,
450 :fields,
451 :following_count,
452 :discoverable,
453 :invisible,
454 :actor_type,
455 :also_known_as,
456 :accepts_chat_messages
457 ]
458 )
459 |> validate_required([:name, :ap_id])
460 |> unique_constraint(:nickname)
461 |> validate_format(:nickname, @email_regex)
462 |> validate_length(:bio, max: bio_limit)
463 |> validate_length(:name, max: name_limit)
464 |> validate_fields(true)
465 end
466
467 def update_changeset(struct, params \\ %{}) do
468 bio_limit = Config.get([:instance, :user_bio_length], 5000)
469 name_limit = Config.get([:instance, :user_name_length], 100)
470
471 struct
472 |> cast(
473 params,
474 [
475 :bio,
476 :raw_bio,
477 :name,
478 :emoji,
479 :avatar,
480 :public_key,
481 :inbox,
482 :shared_inbox,
483 :locked,
484 :no_rich_text,
485 :default_scope,
486 :banner,
487 :hide_follows,
488 :hide_followers,
489 :hide_followers_count,
490 :hide_follows_count,
491 :hide_favorites,
492 :allow_following_move,
493 :background,
494 :show_role,
495 :skip_thread_containment,
496 :fields,
497 :raw_fields,
498 :pleroma_settings_store,
499 :discoverable,
500 :actor_type,
501 :also_known_as,
502 :accepts_chat_messages
503 ]
504 )
505 |> unique_constraint(:nickname)
506 |> validate_format(:nickname, local_nickname_regex())
507 |> validate_length(:bio, max: bio_limit)
508 |> validate_length(:name, min: 1, max: name_limit)
509 |> validate_inclusion(:actor_type, ["Person", "Service"])
510 |> put_fields()
511 |> put_emoji()
512 |> put_change_if_present(:bio, &{:ok, parse_bio(&1, struct)})
513 |> put_change_if_present(:avatar, &put_upload(&1, :avatar))
514 |> put_change_if_present(:banner, &put_upload(&1, :banner))
515 |> put_change_if_present(:background, &put_upload(&1, :background))
516 |> put_change_if_present(
517 :pleroma_settings_store,
518 &{:ok, Map.merge(struct.pleroma_settings_store, &1)}
519 )
520 |> validate_fields(false)
521 end
522
523 defp put_fields(changeset) do
524 if raw_fields = get_change(changeset, :raw_fields) do
525 raw_fields =
526 raw_fields
527 |> Enum.filter(fn %{"name" => n} -> n != "" end)
528
529 fields =
530 raw_fields
531 |> Enum.map(fn f -> Map.update!(f, "value", &parse_fields(&1)) end)
532
533 changeset
534 |> put_change(:raw_fields, raw_fields)
535 |> put_change(:fields, fields)
536 else
537 changeset
538 end
539 end
540
541 defp parse_fields(value) do
542 value
543 |> Formatter.linkify(mentions_format: :full)
544 |> elem(0)
545 end
546
547 defp put_emoji(changeset) do
548 emojified_fields = [:bio, :name, :raw_fields]
549
550 if Enum.any?(changeset.changes, fn {k, _} -> k in emojified_fields end) do
551 bio = Emoji.Formatter.get_emoji_map(get_field(changeset, :bio))
552 name = Emoji.Formatter.get_emoji_map(get_field(changeset, :name))
553
554 emoji = Map.merge(bio, name)
555
556 emoji =
557 changeset
558 |> get_field(:raw_fields)
559 |> Enum.reduce(emoji, fn x, acc ->
560 Map.merge(acc, Emoji.Formatter.get_emoji_map(x["name"] <> x["value"]))
561 end)
562
563 put_change(changeset, :emoji, emoji)
564 else
565 changeset
566 end
567 end
568
569 defp put_change_if_present(changeset, map_field, value_function) do
570 with {:ok, value} <- fetch_change(changeset, map_field),
571 {:ok, new_value} <- value_function.(value) do
572 put_change(changeset, map_field, new_value)
573 else
574 _ -> changeset
575 end
576 end
577
578 defp put_upload(value, type) do
579 with %Plug.Upload{} <- value,
580 {:ok, object} <- ActivityPub.upload(value, type: type) do
581 {:ok, object.data}
582 end
583 end
584
585 def update_as_admin_changeset(struct, params) do
586 struct
587 |> update_changeset(params)
588 |> cast(params, [:email])
589 |> delete_change(:also_known_as)
590 |> unique_constraint(:email)
591 |> validate_format(:email, @email_regex)
592 |> validate_inclusion(:actor_type, ["Person", "Service"])
593 end
594
595 @spec update_as_admin(User.t(), map()) :: {:ok, User.t()} | {:error, Changeset.t()}
596 def update_as_admin(user, params) do
597 params = Map.put(params, "password_confirmation", params["password"])
598 changeset = update_as_admin_changeset(user, params)
599
600 if params["password"] do
601 reset_password(user, changeset, params)
602 else
603 User.update_and_set_cache(changeset)
604 end
605 end
606
607 def password_update_changeset(struct, params) do
608 struct
609 |> cast(params, [:password, :password_confirmation])
610 |> validate_required([:password, :password_confirmation])
611 |> validate_confirmation(:password)
612 |> put_password_hash()
613 |> put_change(:password_reset_pending, false)
614 end
615
616 @spec reset_password(User.t(), map()) :: {:ok, User.t()} | {:error, Changeset.t()}
617 def reset_password(%User{} = user, params) do
618 reset_password(user, user, params)
619 end
620
621 def reset_password(%User{id: user_id} = user, struct, params) do
622 multi =
623 Multi.new()
624 |> Multi.update(:user, password_update_changeset(struct, params))
625 |> Multi.delete_all(:tokens, OAuth.Token.Query.get_by_user(user_id))
626 |> Multi.delete_all(:auth, OAuth.Authorization.delete_by_user_query(user))
627
628 case Repo.transaction(multi) do
629 {:ok, %{user: user} = _} -> set_cache(user)
630 {:error, _, changeset, _} -> {:error, changeset}
631 end
632 end
633
634 def update_password_reset_pending(user, value) do
635 user
636 |> change()
637 |> put_change(:password_reset_pending, value)
638 |> update_and_set_cache()
639 end
640
641 def force_password_reset_async(user) do
642 BackgroundWorker.enqueue("force_password_reset", %{"user_id" => user.id})
643 end
644
645 @spec force_password_reset(User.t()) :: {:ok, User.t()} | {:error, Ecto.Changeset.t()}
646 def force_password_reset(user), do: update_password_reset_pending(user, true)
647
648 # Used to auto-register LDAP accounts which won't have a password hash stored locally
649 def register_changeset_ldap(struct, params = %{password: password})
650 when is_nil(password) do
651 params = Map.put_new(params, :accepts_chat_messages, true)
652
653 params =
654 if Map.has_key?(params, :email) do
655 Map.put_new(params, :email, params[:email])
656 else
657 params
658 end
659
660 struct
661 |> cast(params, [
662 :name,
663 :nickname,
664 :email,
665 :accepts_chat_messages
666 ])
667 |> validate_required([:name, :nickname])
668 |> unique_constraint(:nickname)
669 |> validate_exclusion(:nickname, Config.get([User, :restricted_nicknames]))
670 |> validate_format(:nickname, local_nickname_regex())
671 |> put_ap_id()
672 |> unique_constraint(:ap_id)
673 |> put_following_and_follower_address()
674 end
675
676 def register_changeset(struct, params \\ %{}, opts \\ []) do
677 bio_limit = Config.get([:instance, :user_bio_length], 5000)
678 name_limit = Config.get([:instance, :user_name_length], 100)
679 reason_limit = Config.get([:instance, :registration_reason_length], 500)
680 params = Map.put_new(params, :accepts_chat_messages, true)
681
682 need_confirmation? =
683 if is_nil(opts[:need_confirmation]) do
684 Config.get([:instance, :account_activation_required])
685 else
686 opts[:need_confirmation]
687 end
688
689 need_approval? =
690 if is_nil(opts[:need_approval]) do
691 Config.get([:instance, :account_approval_required])
692 else
693 opts[:need_approval]
694 end
695
696 struct
697 |> confirmation_changeset(need_confirmation: need_confirmation?)
698 |> approval_changeset(need_approval: need_approval?)
699 |> cast(params, [
700 :bio,
701 :raw_bio,
702 :email,
703 :name,
704 :nickname,
705 :password,
706 :password_confirmation,
707 :emoji,
708 :accepts_chat_messages,
709 :registration_reason
710 ])
711 |> validate_required([:name, :nickname, :password, :password_confirmation])
712 |> validate_confirmation(:password)
713 |> unique_constraint(:email)
714 |> validate_format(:email, @email_regex)
715 |> validate_change(:email, fn :email, email ->
716 valid? =
717 Config.get([User, :email_blacklist])
718 |> Enum.all?(fn blacklisted_domain ->
719 !String.ends_with?(email, ["@" <> blacklisted_domain, "." <> blacklisted_domain])
720 end)
721
722 if valid?, do: [], else: [email: "Invalid email"]
723 end)
724 |> unique_constraint(:nickname)
725 |> validate_exclusion(:nickname, Config.get([User, :restricted_nicknames]))
726 |> validate_format(:nickname, local_nickname_regex())
727 |> validate_length(:bio, max: bio_limit)
728 |> validate_length(:name, min: 1, max: name_limit)
729 |> validate_length(:registration_reason, max: reason_limit)
730 |> maybe_validate_required_email(opts[:external])
731 |> put_password_hash
732 |> put_ap_id()
733 |> unique_constraint(:ap_id)
734 |> put_following_and_follower_address()
735 end
736
737 def maybe_validate_required_email(changeset, true), do: changeset
738
739 def maybe_validate_required_email(changeset, _) do
740 if Config.get([:instance, :account_activation_required]) do
741 validate_required(changeset, [:email])
742 else
743 changeset
744 end
745 end
746
747 defp put_ap_id(changeset) do
748 ap_id = ap_id(%User{nickname: get_field(changeset, :nickname)})
749 put_change(changeset, :ap_id, ap_id)
750 end
751
752 defp put_following_and_follower_address(changeset) do
753 followers = ap_followers(%User{nickname: get_field(changeset, :nickname)})
754
755 changeset
756 |> put_change(:follower_address, followers)
757 end
758
759 defp autofollow_users(user) do
760 candidates = Config.get([:instance, :autofollowed_nicknames])
761
762 autofollowed_users =
763 User.Query.build(%{nickname: candidates, local: true, deactivated: false})
764 |> Repo.all()
765
766 follow_all(user, autofollowed_users)
767 end
768
769 @doc "Inserts provided changeset, performs post-registration actions (confirmation email sending etc.)"
770 def register(%Ecto.Changeset{} = changeset) do
771 with {:ok, user} <- Repo.insert(changeset) do
772 post_register_action(user)
773 end
774 end
775
776 def post_register_action(%User{} = user) do
777 with {:ok, user} <- autofollow_users(user),
778 {:ok, user} <- set_cache(user),
779 {:ok, _} <- send_welcome_email(user),
780 {:ok, _} <- send_welcome_message(user),
781 {:ok, _} <- send_welcome_chat_message(user),
782 {:ok, _} <- try_send_confirmation_email(user) do
783 {:ok, user}
784 end
785 end
786
787 def send_welcome_message(user) do
788 if User.WelcomeMessage.enabled?() do
789 User.WelcomeMessage.post_message(user)
790 {:ok, :enqueued}
791 else
792 {:ok, :noop}
793 end
794 end
795
796 def send_welcome_chat_message(user) do
797 if User.WelcomeChatMessage.enabled?() do
798 User.WelcomeChatMessage.post_message(user)
799 {:ok, :enqueued}
800 else
801 {:ok, :noop}
802 end
803 end
804
805 def send_welcome_email(%User{email: email} = user) when is_binary(email) do
806 if User.WelcomeEmail.enabled?() do
807 User.WelcomeEmail.send_email(user)
808 {:ok, :enqueued}
809 else
810 {:ok, :noop}
811 end
812 end
813
814 def send_welcome_email(_), do: {:ok, :noop}
815
816 @spec try_send_confirmation_email(User.t()) :: {:ok, :enqueued | :noop}
817 def try_send_confirmation_email(%User{confirmation_pending: true} = user) do
818 if Config.get([:instance, :account_activation_required]) do
819 send_confirmation_email(user)
820 {:ok, :enqueued}
821 else
822 {:ok, :noop}
823 end
824 end
825
826 def try_send_confirmation_email(_), do: {:ok, :noop}
827
828 @spec send_confirmation_email(Uset.t()) :: User.t()
829 def send_confirmation_email(%User{} = user) do
830 user
831 |> Pleroma.Emails.UserEmail.account_confirmation_email()
832 |> Pleroma.Emails.Mailer.deliver_async()
833
834 user
835 end
836
837 def needs_update?(%User{local: true}), do: false
838
839 def needs_update?(%User{local: false, last_refreshed_at: nil}), do: true
840
841 def needs_update?(%User{local: false} = user) do
842 NaiveDateTime.diff(NaiveDateTime.utc_now(), user.last_refreshed_at) >= 86_400
843 end
844
845 def needs_update?(_), do: true
846
847 @spec maybe_direct_follow(User.t(), User.t()) :: {:ok, User.t()} | {:error, String.t()}
848
849 # "Locked" (self-locked) users demand explicit authorization of follow requests
850 def maybe_direct_follow(%User{} = follower, %User{local: true, locked: true} = followed) do
851 follow(follower, followed, :follow_pending)
852 end
853
854 def maybe_direct_follow(%User{} = follower, %User{local: true} = followed) do
855 follow(follower, followed)
856 end
857
858 def maybe_direct_follow(%User{} = follower, %User{} = followed) do
859 if not ap_enabled?(followed) do
860 follow(follower, followed)
861 else
862 {:ok, follower}
863 end
864 end
865
866 @doc "A mass follow for local users. Respects blocks in both directions but does not create activities."
867 @spec follow_all(User.t(), list(User.t())) :: {atom(), User.t()}
868 def follow_all(follower, followeds) do
869 followeds
870 |> Enum.reject(fn followed -> blocks?(follower, followed) || blocks?(followed, follower) end)
871 |> Enum.each(&follow(follower, &1, :follow_accept))
872
873 set_cache(follower)
874 end
875
876 def follow(%User{} = follower, %User{} = followed, state \\ :follow_accept) do
877 deny_follow_blocked = Config.get([:user, :deny_follow_blocked])
878
879 cond do
880 followed.deactivated ->
881 {:error, "Could not follow user: #{followed.nickname} is deactivated."}
882
883 deny_follow_blocked and blocks?(followed, follower) ->
884 {:error, "Could not follow user: #{followed.nickname} blocked you."}
885
886 true ->
887 FollowingRelationship.follow(follower, followed, state)
888
889 {:ok, _} = update_follower_count(followed)
890
891 follower
892 |> update_following_count()
893 end
894 end
895
896 def unfollow(%User{ap_id: ap_id}, %User{ap_id: ap_id}) do
897 {:error, "Not subscribed!"}
898 end
899
900 @spec unfollow(User.t(), User.t()) :: {:ok, User.t(), Activity.t()} | {:error, String.t()}
901 def unfollow(%User{} = follower, %User{} = followed) do
902 case do_unfollow(follower, followed) do
903 {:ok, follower, followed} ->
904 {:ok, follower, Utils.fetch_latest_follow(follower, followed)}
905
906 error ->
907 error
908 end
909 end
910
911 @spec do_unfollow(User.t(), User.t()) :: {:ok, User.t(), User.t()} | {:error, String.t()}
912 defp do_unfollow(%User{} = follower, %User{} = followed) do
913 case get_follow_state(follower, followed) do
914 state when state in [:follow_pending, :follow_accept] ->
915 FollowingRelationship.unfollow(follower, followed)
916 {:ok, followed} = update_follower_count(followed)
917
918 {:ok, follower} =
919 follower
920 |> update_following_count()
921
922 {:ok, follower, followed}
923
924 nil ->
925 {:error, "Not subscribed!"}
926 end
927 end
928
929 @doc "Returns follow state as Pleroma.FollowingRelationship.State value"
930 def get_follow_state(%User{} = follower, %User{} = following) do
931 following_relationship = FollowingRelationship.get(follower, following)
932 get_follow_state(follower, following, following_relationship)
933 end
934
935 def get_follow_state(
936 %User{} = follower,
937 %User{} = following,
938 following_relationship
939 ) do
940 case {following_relationship, following.local} do
941 {nil, false} ->
942 case Utils.fetch_latest_follow(follower, following) do
943 %Activity{data: %{"state" => state}} when state in ["pending", "accept"] ->
944 FollowingRelationship.state_to_enum(state)
945
946 _ ->
947 nil
948 end
949
950 {%{state: state}, _} ->
951 state
952
953 {nil, _} ->
954 nil
955 end
956 end
957
958 def locked?(%User{} = user) do
959 user.locked || false
960 end
961
962 def get_by_id(id) do
963 Repo.get_by(User, id: id)
964 end
965
966 def get_by_ap_id(ap_id) do
967 Repo.get_by(User, ap_id: ap_id)
968 end
969
970 def get_all_by_ap_id(ap_ids) do
971 from(u in __MODULE__,
972 where: u.ap_id in ^ap_ids
973 )
974 |> Repo.all()
975 end
976
977 def get_all_by_ids(ids) do
978 from(u in __MODULE__, where: u.id in ^ids)
979 |> Repo.all()
980 end
981
982 # This is mostly an SPC migration fix. This guesses the user nickname by taking the last part
983 # of the ap_id and the domain and tries to get that user
984 def get_by_guessed_nickname(ap_id) do
985 domain = URI.parse(ap_id).host
986 name = List.last(String.split(ap_id, "/"))
987 nickname = "#{name}@#{domain}"
988
989 get_cached_by_nickname(nickname)
990 end
991
992 def set_cache({:ok, user}), do: set_cache(user)
993 def set_cache({:error, err}), do: {:error, err}
994
995 def set_cache(%User{} = user) do
996 Cachex.put(:user_cache, "ap_id:#{user.ap_id}", user)
997 Cachex.put(:user_cache, "nickname:#{user.nickname}", user)
998 Cachex.put(:user_cache, "friends_ap_ids:#{user.nickname}", get_user_friends_ap_ids(user))
999 {:ok, user}
1000 end
1001
1002 def update_and_set_cache(struct, params) do
1003 struct
1004 |> update_changeset(params)
1005 |> update_and_set_cache()
1006 end
1007
1008 def update_and_set_cache(changeset) do
1009 with {:ok, user} <- Repo.update(changeset, stale_error_field: :id) do
1010 set_cache(user)
1011 end
1012 end
1013
1014 def get_user_friends_ap_ids(user) do
1015 from(u in User.get_friends_query(user), select: u.ap_id)
1016 |> Repo.all()
1017 end
1018
1019 @spec get_cached_user_friends_ap_ids(User.t()) :: [String.t()]
1020 def get_cached_user_friends_ap_ids(user) do
1021 Cachex.fetch!(:user_cache, "friends_ap_ids:#{user.ap_id}", fn _ ->
1022 get_user_friends_ap_ids(user)
1023 end)
1024 end
1025
1026 def invalidate_cache(user) do
1027 Cachex.del(:user_cache, "ap_id:#{user.ap_id}")
1028 Cachex.del(:user_cache, "nickname:#{user.nickname}")
1029 Cachex.del(:user_cache, "friends_ap_ids:#{user.ap_id}")
1030 end
1031
1032 @spec get_cached_by_ap_id(String.t()) :: User.t() | nil
1033 def get_cached_by_ap_id(ap_id) do
1034 key = "ap_id:#{ap_id}"
1035
1036 with {:ok, nil} <- Cachex.get(:user_cache, key),
1037 user when not is_nil(user) <- get_by_ap_id(ap_id),
1038 {:ok, true} <- Cachex.put(:user_cache, key, user) do
1039 user
1040 else
1041 {:ok, user} -> user
1042 nil -> nil
1043 end
1044 end
1045
1046 def get_cached_by_id(id) do
1047 key = "id:#{id}"
1048
1049 ap_id =
1050 Cachex.fetch!(:user_cache, key, fn _ ->
1051 user = get_by_id(id)
1052
1053 if user do
1054 Cachex.put(:user_cache, "ap_id:#{user.ap_id}", user)
1055 {:commit, user.ap_id}
1056 else
1057 {:ignore, ""}
1058 end
1059 end)
1060
1061 get_cached_by_ap_id(ap_id)
1062 end
1063
1064 def get_cached_by_nickname(nickname) do
1065 key = "nickname:#{nickname}"
1066
1067 Cachex.fetch!(:user_cache, key, fn ->
1068 case get_or_fetch_by_nickname(nickname) do
1069 {:ok, user} -> {:commit, user}
1070 {:error, _error} -> {:ignore, nil}
1071 end
1072 end)
1073 end
1074
1075 def get_cached_by_nickname_or_id(nickname_or_id, opts \\ []) do
1076 restrict_to_local = Config.get([:instance, :limit_to_local_content])
1077
1078 cond do
1079 is_integer(nickname_or_id) or FlakeId.flake_id?(nickname_or_id) ->
1080 get_cached_by_id(nickname_or_id) || get_cached_by_nickname(nickname_or_id)
1081
1082 restrict_to_local == false or not String.contains?(nickname_or_id, "@") ->
1083 get_cached_by_nickname(nickname_or_id)
1084
1085 restrict_to_local == :unauthenticated and match?(%User{}, opts[:for]) ->
1086 get_cached_by_nickname(nickname_or_id)
1087
1088 true ->
1089 nil
1090 end
1091 end
1092
1093 @spec get_by_nickname(String.t()) :: User.t() | nil
1094 def get_by_nickname(nickname) do
1095 Repo.get_by(User, nickname: nickname) ||
1096 if Regex.match?(~r(@#{Pleroma.Web.Endpoint.host()})i, nickname) do
1097 Repo.get_by(User, nickname: local_nickname(nickname))
1098 end
1099 end
1100
1101 def get_by_email(email), do: Repo.get_by(User, email: email)
1102
1103 def get_by_nickname_or_email(nickname_or_email) do
1104 get_by_nickname(nickname_or_email) || get_by_email(nickname_or_email)
1105 end
1106
1107 def fetch_by_nickname(nickname), do: ActivityPub.make_user_from_nickname(nickname)
1108
1109 def get_or_fetch_by_nickname(nickname) do
1110 with %User{} = user <- get_by_nickname(nickname) do
1111 {:ok, user}
1112 else
1113 _e ->
1114 with [_nick, _domain] <- String.split(nickname, "@"),
1115 {:ok, user} <- fetch_by_nickname(nickname) do
1116 {:ok, user}
1117 else
1118 _e -> {:error, "not found " <> nickname}
1119 end
1120 end
1121 end
1122
1123 @spec get_followers_query(User.t(), pos_integer() | nil) :: Ecto.Query.t()
1124 def get_followers_query(%User{} = user, nil) do
1125 User.Query.build(%{followers: user, deactivated: false})
1126 end
1127
1128 def get_followers_query(%User{} = user, page) do
1129 user
1130 |> get_followers_query(nil)
1131 |> User.Query.paginate(page, 20)
1132 end
1133
1134 @spec get_followers_query(User.t()) :: Ecto.Query.t()
1135 def get_followers_query(%User{} = user), do: get_followers_query(user, nil)
1136
1137 @spec get_followers(User.t(), pos_integer() | nil) :: {:ok, list(User.t())}
1138 def get_followers(%User{} = user, page \\ nil) do
1139 user
1140 |> get_followers_query(page)
1141 |> Repo.all()
1142 end
1143
1144 @spec get_external_followers(User.t(), pos_integer() | nil) :: {:ok, list(User.t())}
1145 def get_external_followers(%User{} = user, page \\ nil) do
1146 user
1147 |> get_followers_query(page)
1148 |> User.Query.build(%{external: true})
1149 |> Repo.all()
1150 end
1151
1152 def get_followers_ids(%User{} = user, page \\ nil) do
1153 user
1154 |> get_followers_query(page)
1155 |> select([u], u.id)
1156 |> Repo.all()
1157 end
1158
1159 @spec get_friends_query(User.t(), pos_integer() | nil) :: Ecto.Query.t()
1160 def get_friends_query(%User{} = user, nil) do
1161 User.Query.build(%{friends: user, deactivated: false})
1162 end
1163
1164 def get_friends_query(%User{} = user, page) do
1165 user
1166 |> get_friends_query(nil)
1167 |> User.Query.paginate(page, 20)
1168 end
1169
1170 @spec get_friends_query(User.t()) :: Ecto.Query.t()
1171 def get_friends_query(%User{} = user), do: get_friends_query(user, nil)
1172
1173 def get_friends(%User{} = user, page \\ nil) do
1174 user
1175 |> get_friends_query(page)
1176 |> Repo.all()
1177 end
1178
1179 def get_friends_ap_ids(%User{} = user) do
1180 user
1181 |> get_friends_query(nil)
1182 |> select([u], u.ap_id)
1183 |> Repo.all()
1184 end
1185
1186 def get_friends_ids(%User{} = user, page \\ nil) do
1187 user
1188 |> get_friends_query(page)
1189 |> select([u], u.id)
1190 |> Repo.all()
1191 end
1192
1193 def increase_note_count(%User{} = user) do
1194 User
1195 |> where(id: ^user.id)
1196 |> update([u], inc: [note_count: 1])
1197 |> select([u], u)
1198 |> Repo.update_all([])
1199 |> case do
1200 {1, [user]} -> set_cache(user)
1201 _ -> {:error, user}
1202 end
1203 end
1204
1205 def decrease_note_count(%User{} = user) do
1206 User
1207 |> where(id: ^user.id)
1208 |> update([u],
1209 set: [
1210 note_count: fragment("greatest(0, note_count - 1)")
1211 ]
1212 )
1213 |> select([u], u)
1214 |> Repo.update_all([])
1215 |> case do
1216 {1, [user]} -> set_cache(user)
1217 _ -> {:error, user}
1218 end
1219 end
1220
1221 def update_note_count(%User{} = user, note_count \\ nil) do
1222 note_count =
1223 note_count ||
1224 from(
1225 a in Object,
1226 where: fragment("?->>'actor' = ? and ?->>'type' = 'Note'", a.data, ^user.ap_id, a.data),
1227 select: count(a.id)
1228 )
1229 |> Repo.one()
1230
1231 user
1232 |> cast(%{note_count: note_count}, [:note_count])
1233 |> update_and_set_cache()
1234 end
1235
1236 @spec maybe_fetch_follow_information(User.t()) :: User.t()
1237 def maybe_fetch_follow_information(user) do
1238 with {:ok, user} <- fetch_follow_information(user) do
1239 user
1240 else
1241 e ->
1242 Logger.error("Follower/Following counter update for #{user.ap_id} failed.\n#{inspect(e)}")
1243
1244 user
1245 end
1246 end
1247
1248 def fetch_follow_information(user) do
1249 with {:ok, info} <- ActivityPub.fetch_follow_information_for_user(user) do
1250 user
1251 |> follow_information_changeset(info)
1252 |> update_and_set_cache()
1253 end
1254 end
1255
1256 defp follow_information_changeset(user, params) do
1257 user
1258 |> cast(params, [
1259 :hide_followers,
1260 :hide_follows,
1261 :follower_count,
1262 :following_count,
1263 :hide_followers_count,
1264 :hide_follows_count
1265 ])
1266 end
1267
1268 @spec update_follower_count(User.t()) :: {:ok, User.t()}
1269 def update_follower_count(%User{} = user) do
1270 if user.local or !Config.get([:instance, :external_user_synchronization]) do
1271 follower_count = FollowingRelationship.follower_count(user)
1272
1273 user
1274 |> follow_information_changeset(%{follower_count: follower_count})
1275 |> update_and_set_cache
1276 else
1277 {:ok, maybe_fetch_follow_information(user)}
1278 end
1279 end
1280
1281 @spec update_following_count(User.t()) :: {:ok, User.t()}
1282 def update_following_count(%User{local: false} = user) do
1283 if Config.get([:instance, :external_user_synchronization]) do
1284 {:ok, maybe_fetch_follow_information(user)}
1285 else
1286 {:ok, user}
1287 end
1288 end
1289
1290 def update_following_count(%User{local: true} = user) do
1291 following_count = FollowingRelationship.following_count(user)
1292
1293 user
1294 |> follow_information_changeset(%{following_count: following_count})
1295 |> update_and_set_cache()
1296 end
1297
1298 def set_unread_conversation_count(%User{local: true} = user) do
1299 unread_query = Participation.unread_conversation_count_for_user(user)
1300
1301 User
1302 |> join(:inner, [u], p in subquery(unread_query))
1303 |> update([u, p],
1304 set: [unread_conversation_count: p.count]
1305 )
1306 |> where([u], u.id == ^user.id)
1307 |> select([u], u)
1308 |> Repo.update_all([])
1309 |> case do
1310 {1, [user]} -> set_cache(user)
1311 _ -> {:error, user}
1312 end
1313 end
1314
1315 def set_unread_conversation_count(user), do: {:ok, user}
1316
1317 def increment_unread_conversation_count(conversation, %User{local: true} = user) do
1318 unread_query =
1319 Participation.unread_conversation_count_for_user(user)
1320 |> where([p], p.conversation_id == ^conversation.id)
1321
1322 User
1323 |> join(:inner, [u], p in subquery(unread_query))
1324 |> update([u, p],
1325 inc: [unread_conversation_count: 1]
1326 )
1327 |> where([u], u.id == ^user.id)
1328 |> where([u, p], p.count == 0)
1329 |> select([u], u)
1330 |> Repo.update_all([])
1331 |> case do
1332 {1, [user]} -> set_cache(user)
1333 _ -> {:error, user}
1334 end
1335 end
1336
1337 def increment_unread_conversation_count(_, user), do: {:ok, user}
1338
1339 @spec get_users_from_set([String.t()], keyword()) :: [User.t()]
1340 def get_users_from_set(ap_ids, opts \\ []) do
1341 local_only = Keyword.get(opts, :local_only, true)
1342 criteria = %{ap_id: ap_ids, deactivated: false}
1343 criteria = if local_only, do: Map.put(criteria, :local, true), else: criteria
1344
1345 User.Query.build(criteria)
1346 |> Repo.all()
1347 end
1348
1349 @spec get_recipients_from_activity(Activity.t()) :: [User.t()]
1350 def get_recipients_from_activity(%Activity{recipients: to, actor: actor}) do
1351 to = [actor | to]
1352
1353 query = User.Query.build(%{recipients_from_activity: to, local: true, deactivated: false})
1354
1355 query
1356 |> Repo.all()
1357 end
1358
1359 @spec mute(User.t(), User.t(), boolean()) ::
1360 {:ok, list(UserRelationship.t())} | {:error, String.t()}
1361 def mute(%User{} = muter, %User{} = mutee, notifications? \\ true) do
1362 add_to_mutes(muter, mutee, notifications?)
1363 end
1364
1365 def unmute(%User{} = muter, %User{} = mutee) do
1366 remove_from_mutes(muter, mutee)
1367 end
1368
1369 def subscribe(%User{} = subscriber, %User{} = target) do
1370 deny_follow_blocked = Config.get([:user, :deny_follow_blocked])
1371
1372 if blocks?(target, subscriber) and deny_follow_blocked do
1373 {:error, "Could not subscribe: #{target.nickname} is blocking you"}
1374 else
1375 # Note: the relationship is inverse: subscriber acts as relationship target
1376 UserRelationship.create_inverse_subscription(target, subscriber)
1377 end
1378 end
1379
1380 def subscribe(%User{} = subscriber, %{ap_id: ap_id}) do
1381 with %User{} = subscribee <- get_cached_by_ap_id(ap_id) do
1382 subscribe(subscriber, subscribee)
1383 end
1384 end
1385
1386 def unsubscribe(%User{} = unsubscriber, %User{} = target) do
1387 # Note: the relationship is inverse: subscriber acts as relationship target
1388 UserRelationship.delete_inverse_subscription(target, unsubscriber)
1389 end
1390
1391 def unsubscribe(%User{} = unsubscriber, %{ap_id: ap_id}) do
1392 with %User{} = user <- get_cached_by_ap_id(ap_id) do
1393 unsubscribe(unsubscriber, user)
1394 end
1395 end
1396
1397 def block(%User{} = blocker, %User{} = blocked) do
1398 # sever any follow relationships to prevent leaks per activitypub (Pleroma issue #213)
1399 blocker =
1400 if following?(blocker, blocked) do
1401 {:ok, blocker, _} = unfollow(blocker, blocked)
1402 blocker
1403 else
1404 blocker
1405 end
1406
1407 # clear any requested follows as well
1408 blocked =
1409 case CommonAPI.reject_follow_request(blocked, blocker) do
1410 {:ok, %User{} = updated_blocked} -> updated_blocked
1411 nil -> blocked
1412 end
1413
1414 unsubscribe(blocked, blocker)
1415
1416 unfollowing_blocked = Config.get([:activitypub, :unfollow_blocked], true)
1417 if unfollowing_blocked && following?(blocked, blocker), do: unfollow(blocked, blocker)
1418
1419 {:ok, blocker} = update_follower_count(blocker)
1420 {:ok, blocker, _} = Participation.mark_all_as_read(blocker, blocked)
1421 add_to_block(blocker, blocked)
1422 end
1423
1424 # helper to handle the block given only an actor's AP id
1425 def block(%User{} = blocker, %{ap_id: ap_id}) do
1426 block(blocker, get_cached_by_ap_id(ap_id))
1427 end
1428
1429 def unblock(%User{} = blocker, %User{} = blocked) do
1430 remove_from_block(blocker, blocked)
1431 end
1432
1433 # helper to handle the block given only an actor's AP id
1434 def unblock(%User{} = blocker, %{ap_id: ap_id}) do
1435 unblock(blocker, get_cached_by_ap_id(ap_id))
1436 end
1437
1438 def mutes?(nil, _), do: false
1439 def mutes?(%User{} = user, %User{} = target), do: mutes_user?(user, target)
1440
1441 def mutes_user?(%User{} = user, %User{} = target) do
1442 UserRelationship.mute_exists?(user, target)
1443 end
1444
1445 @spec muted_notifications?(User.t() | nil, User.t() | map()) :: boolean()
1446 def muted_notifications?(nil, _), do: false
1447
1448 def muted_notifications?(%User{} = user, %User{} = target),
1449 do: UserRelationship.notification_mute_exists?(user, target)
1450
1451 def blocks?(nil, _), do: false
1452
1453 def blocks?(%User{} = user, %User{} = target) do
1454 blocks_user?(user, target) ||
1455 (blocks_domain?(user, target) and not User.following?(user, target))
1456 end
1457
1458 def blocks_user?(%User{} = user, %User{} = target) do
1459 UserRelationship.block_exists?(user, target)
1460 end
1461
1462 def blocks_user?(_, _), do: false
1463
1464 def blocks_domain?(%User{} = user, %User{} = target) do
1465 domain_blocks = Pleroma.Web.ActivityPub.MRF.subdomains_regex(user.domain_blocks)
1466 %{host: host} = URI.parse(target.ap_id)
1467 Pleroma.Web.ActivityPub.MRF.subdomain_match?(domain_blocks, host)
1468 end
1469
1470 def blocks_domain?(_, _), do: false
1471
1472 def subscribed_to?(%User{} = user, %User{} = target) do
1473 # Note: the relationship is inverse: subscriber acts as relationship target
1474 UserRelationship.inverse_subscription_exists?(target, user)
1475 end
1476
1477 def subscribed_to?(%User{} = user, %{ap_id: ap_id}) do
1478 with %User{} = target <- get_cached_by_ap_id(ap_id) do
1479 subscribed_to?(user, target)
1480 end
1481 end
1482
1483 @doc """
1484 Returns map of outgoing (blocked, muted etc.) relationships' user AP IDs by relation type.
1485 E.g. `outgoing_relationships_ap_ids(user, [:block])` -> `%{block: ["https://some.site/users/userapid"]}`
1486 """
1487 @spec outgoing_relationships_ap_ids(User.t(), list(atom())) :: %{atom() => list(String.t())}
1488 def outgoing_relationships_ap_ids(_user, []), do: %{}
1489
1490 def outgoing_relationships_ap_ids(nil, _relationship_types), do: %{}
1491
1492 def outgoing_relationships_ap_ids(%User{} = user, relationship_types)
1493 when is_list(relationship_types) do
1494 db_result =
1495 user
1496 |> assoc(:outgoing_relationships)
1497 |> join(:inner, [user_rel], u in assoc(user_rel, :target))
1498 |> where([user_rel, u], user_rel.relationship_type in ^relationship_types)
1499 |> select([user_rel, u], [user_rel.relationship_type, fragment("array_agg(?)", u.ap_id)])
1500 |> group_by([user_rel, u], user_rel.relationship_type)
1501 |> Repo.all()
1502 |> Enum.into(%{}, fn [k, v] -> {k, v} end)
1503
1504 Enum.into(
1505 relationship_types,
1506 %{},
1507 fn rel_type -> {rel_type, db_result[rel_type] || []} end
1508 )
1509 end
1510
1511 def incoming_relationships_ungrouped_ap_ids(user, relationship_types, ap_ids \\ nil)
1512
1513 def incoming_relationships_ungrouped_ap_ids(_user, [], _ap_ids), do: []
1514
1515 def incoming_relationships_ungrouped_ap_ids(nil, _relationship_types, _ap_ids), do: []
1516
1517 def incoming_relationships_ungrouped_ap_ids(%User{} = user, relationship_types, ap_ids)
1518 when is_list(relationship_types) do
1519 user
1520 |> assoc(:incoming_relationships)
1521 |> join(:inner, [user_rel], u in assoc(user_rel, :source))
1522 |> where([user_rel, u], user_rel.relationship_type in ^relationship_types)
1523 |> maybe_filter_on_ap_id(ap_ids)
1524 |> select([user_rel, u], u.ap_id)
1525 |> distinct(true)
1526 |> Repo.all()
1527 end
1528
1529 defp maybe_filter_on_ap_id(query, ap_ids) when is_list(ap_ids) do
1530 where(query, [user_rel, u], u.ap_id in ^ap_ids)
1531 end
1532
1533 defp maybe_filter_on_ap_id(query, _ap_ids), do: query
1534
1535 def deactivate_async(user, status \\ true) do
1536 BackgroundWorker.enqueue("deactivate_user", %{"user_id" => user.id, "status" => status})
1537 end
1538
1539 def deactivate(user, status \\ true)
1540
1541 def deactivate(users, status) when is_list(users) do
1542 Repo.transaction(fn ->
1543 for user <- users, do: deactivate(user, status)
1544 end)
1545 end
1546
1547 def deactivate(%User{} = user, status) do
1548 with {:ok, user} <- set_activation_status(user, status) do
1549 user
1550 |> get_followers()
1551 |> Enum.filter(& &1.local)
1552 |> Enum.each(&set_cache(update_following_count(&1)))
1553
1554 # Only update local user counts, remote will be update during the next pull.
1555 user
1556 |> get_friends()
1557 |> Enum.filter(& &1.local)
1558 |> Enum.each(&do_unfollow(user, &1))
1559
1560 {:ok, user}
1561 end
1562 end
1563
1564 def approve(users) when is_list(users) do
1565 Repo.transaction(fn ->
1566 Enum.map(users, fn user ->
1567 with {:ok, user} <- approve(user), do: user
1568 end)
1569 end)
1570 end
1571
1572 def approve(%User{} = user) do
1573 change(user, approval_pending: false)
1574 |> update_and_set_cache()
1575 end
1576
1577 def update_notification_settings(%User{} = user, settings) do
1578 user
1579 |> cast(%{notification_settings: settings}, [])
1580 |> cast_embed(:notification_settings)
1581 |> validate_required([:notification_settings])
1582 |> update_and_set_cache()
1583 end
1584
1585 @spec purge_user_changeset(User.t()) :: Changeset.t()
1586 def purge_user_changeset(user) do
1587 # "Right to be forgotten"
1588 # https://gdpr.eu/right-to-be-forgotten/
1589 change(user, %{
1590 bio: "",
1591 raw_bio: nil,
1592 email: nil,
1593 name: nil,
1594 password_hash: nil,
1595 keys: nil,
1596 public_key: nil,
1597 avatar: %{},
1598 tags: [],
1599 last_refreshed_at: nil,
1600 last_digest_emailed_at: nil,
1601 banner: %{},
1602 background: %{},
1603 note_count: 0,
1604 follower_count: 0,
1605 following_count: 0,
1606 locked: false,
1607 confirmation_pending: false,
1608 password_reset_pending: false,
1609 approval_pending: false,
1610 registration_reason: nil,
1611 confirmation_token: nil,
1612 domain_blocks: [],
1613 deactivated: true,
1614 ap_enabled: false,
1615 is_moderator: false,
1616 is_admin: false,
1617 mastofe_settings: nil,
1618 mascot: nil,
1619 emoji: %{},
1620 pleroma_settings_store: %{},
1621 fields: [],
1622 raw_fields: [],
1623 discoverable: false,
1624 also_known_as: []
1625 })
1626 end
1627
1628 def delete(users) when is_list(users) do
1629 for user <- users, do: delete(user)
1630 end
1631
1632 def delete(%User{} = user) do
1633 BackgroundWorker.enqueue("delete_user", %{"user_id" => user.id})
1634 end
1635
1636 defp delete_and_invalidate_cache(%User{} = user) do
1637 invalidate_cache(user)
1638 Repo.delete(user)
1639 end
1640
1641 defp delete_or_deactivate(%User{local: false} = user), do: delete_and_invalidate_cache(user)
1642
1643 defp delete_or_deactivate(%User{local: true} = user) do
1644 status = account_status(user)
1645
1646 case status do
1647 :confirmation_pending ->
1648 delete_and_invalidate_cache(user)
1649
1650 :approval_pending ->
1651 delete_and_invalidate_cache(user)
1652
1653 _ ->
1654 user
1655 |> purge_user_changeset()
1656 |> update_and_set_cache()
1657 end
1658 end
1659
1660 def perform(:force_password_reset, user), do: force_password_reset(user)
1661
1662 @spec perform(atom(), User.t()) :: {:ok, User.t()}
1663 def perform(:delete, %User{} = user) do
1664 # Remove all relationships
1665 user
1666 |> get_followers()
1667 |> Enum.each(fn follower ->
1668 ActivityPub.unfollow(follower, user)
1669 unfollow(follower, user)
1670 end)
1671
1672 user
1673 |> get_friends()
1674 |> Enum.each(fn followed ->
1675 ActivityPub.unfollow(user, followed)
1676 unfollow(user, followed)
1677 end)
1678
1679 delete_user_activities(user)
1680 delete_notifications_from_user_activities(user)
1681
1682 delete_outgoing_pending_follow_requests(user)
1683
1684 delete_or_deactivate(user)
1685 end
1686
1687 def perform(:deactivate_async, user, status), do: deactivate(user, status)
1688
1689 @spec perform(atom(), User.t(), list()) :: list() | {:error, any()}
1690 def perform(:blocks_import, %User{} = blocker, blocked_identifiers)
1691 when is_list(blocked_identifiers) do
1692 Enum.map(
1693 blocked_identifiers,
1694 fn blocked_identifier ->
1695 with {:ok, %User{} = blocked} <- get_or_fetch(blocked_identifier),
1696 {:ok, _block} <- CommonAPI.block(blocker, blocked) do
1697 blocked
1698 else
1699 err ->
1700 Logger.debug("blocks_import failed for #{blocked_identifier} with: #{inspect(err)}")
1701 err
1702 end
1703 end
1704 )
1705 end
1706
1707 def perform(:follow_import, %User{} = follower, followed_identifiers)
1708 when is_list(followed_identifiers) do
1709 Enum.map(
1710 followed_identifiers,
1711 fn followed_identifier ->
1712 with {:ok, %User{} = followed} <- get_or_fetch(followed_identifier),
1713 {:ok, follower} <- maybe_direct_follow(follower, followed),
1714 {:ok, _, _, _} <- CommonAPI.follow(follower, followed) do
1715 followed
1716 else
1717 err ->
1718 Logger.debug("follow_import failed for #{followed_identifier} with: #{inspect(err)}")
1719 err
1720 end
1721 end
1722 )
1723 end
1724
1725 @spec external_users_query() :: Ecto.Query.t()
1726 def external_users_query do
1727 User.Query.build(%{
1728 external: true,
1729 active: true,
1730 order_by: :id
1731 })
1732 end
1733
1734 @spec external_users(keyword()) :: [User.t()]
1735 def external_users(opts \\ []) do
1736 query =
1737 external_users_query()
1738 |> select([u], struct(u, [:id, :ap_id]))
1739
1740 query =
1741 if opts[:max_id],
1742 do: where(query, [u], u.id > ^opts[:max_id]),
1743 else: query
1744
1745 query =
1746 if opts[:limit],
1747 do: limit(query, ^opts[:limit]),
1748 else: query
1749
1750 Repo.all(query)
1751 end
1752
1753 def blocks_import(%User{} = blocker, blocked_identifiers) when is_list(blocked_identifiers) do
1754 BackgroundWorker.enqueue("blocks_import", %{
1755 "blocker_id" => blocker.id,
1756 "blocked_identifiers" => blocked_identifiers
1757 })
1758 end
1759
1760 def follow_import(%User{} = follower, followed_identifiers)
1761 when is_list(followed_identifiers) do
1762 BackgroundWorker.enqueue("follow_import", %{
1763 "follower_id" => follower.id,
1764 "followed_identifiers" => followed_identifiers
1765 })
1766 end
1767
1768 def delete_notifications_from_user_activities(%User{ap_id: ap_id}) do
1769 Notification
1770 |> join(:inner, [n], activity in assoc(n, :activity))
1771 |> where([n, a], fragment("? = ?", a.actor, ^ap_id))
1772 |> Repo.delete_all()
1773 end
1774
1775 def delete_user_activities(%User{ap_id: ap_id} = user) do
1776 ap_id
1777 |> Activity.Queries.by_actor()
1778 |> RepoStreamer.chunk_stream(50)
1779 |> Stream.each(fn activities ->
1780 Enum.each(activities, fn activity -> delete_activity(activity, user) end)
1781 end)
1782 |> Stream.run()
1783 end
1784
1785 defp delete_activity(%{data: %{"type" => "Create", "object" => object}} = activity, user) do
1786 with {_, %Object{}} <- {:find_object, Object.get_by_ap_id(object)},
1787 {:ok, delete_data, _} <- Builder.delete(user, object) do
1788 Pipeline.common_pipeline(delete_data, local: user.local)
1789 else
1790 {:find_object, nil} ->
1791 # We have the create activity, but not the object, it was probably pruned.
1792 # Insert a tombstone and try again
1793 with {:ok, tombstone_data, _} <- Builder.tombstone(user.ap_id, object),
1794 {:ok, _tombstone} <- Object.create(tombstone_data) do
1795 delete_activity(activity, user)
1796 end
1797
1798 e ->
1799 Logger.error("Could not delete #{object} created by #{activity.data["ap_id"]}")
1800 Logger.error("Error: #{inspect(e)}")
1801 end
1802 end
1803
1804 defp delete_activity(%{data: %{"type" => type}} = activity, user)
1805 when type in ["Like", "Announce"] do
1806 {:ok, undo, _} = Builder.undo(user, activity)
1807 Pipeline.common_pipeline(undo, local: user.local)
1808 end
1809
1810 defp delete_activity(_activity, _user), do: "Doing nothing"
1811
1812 defp delete_outgoing_pending_follow_requests(user) do
1813 user
1814 |> FollowingRelationship.outgoing_pending_follow_requests_query()
1815 |> Repo.delete_all()
1816 end
1817
1818 def html_filter_policy(%User{no_rich_text: true}) do
1819 Pleroma.HTML.Scrubber.TwitterText
1820 end
1821
1822 def html_filter_policy(_), do: Config.get([:markup, :scrub_policy])
1823
1824 def fetch_by_ap_id(ap_id), do: ActivityPub.make_user_from_ap_id(ap_id)
1825
1826 def get_or_fetch_by_ap_id(ap_id) do
1827 cached_user = get_cached_by_ap_id(ap_id)
1828
1829 maybe_fetched_user = needs_update?(cached_user) && fetch_by_ap_id(ap_id)
1830
1831 case {cached_user, maybe_fetched_user} do
1832 {_, {:ok, %User{} = user}} ->
1833 {:ok, user}
1834
1835 {%User{} = user, _} ->
1836 {:ok, user}
1837
1838 _ ->
1839 {:error, :not_found}
1840 end
1841 end
1842
1843 @doc """
1844 Creates an internal service actor by URI if missing.
1845 Optionally takes nickname for addressing.
1846 """
1847 @spec get_or_create_service_actor_by_ap_id(String.t(), String.t()) :: User.t() | nil
1848 def get_or_create_service_actor_by_ap_id(uri, nickname) do
1849 {_, user} =
1850 case get_cached_by_ap_id(uri) do
1851 nil ->
1852 with {:error, %{errors: errors}} <- create_service_actor(uri, nickname) do
1853 Logger.error("Cannot create service actor: #{uri}/.\n#{inspect(errors)}")
1854 {:error, nil}
1855 end
1856
1857 %User{invisible: false} = user ->
1858 set_invisible(user)
1859
1860 user ->
1861 {:ok, user}
1862 end
1863
1864 user
1865 end
1866
1867 @spec set_invisible(User.t()) :: {:ok, User.t()}
1868 defp set_invisible(user) do
1869 user
1870 |> change(%{invisible: true})
1871 |> update_and_set_cache()
1872 end
1873
1874 @spec create_service_actor(String.t(), String.t()) ::
1875 {:ok, User.t()} | {:error, Ecto.Changeset.t()}
1876 defp create_service_actor(uri, nickname) do
1877 %User{
1878 invisible: true,
1879 local: true,
1880 ap_id: uri,
1881 nickname: nickname,
1882 follower_address: uri <> "/followers"
1883 }
1884 |> change
1885 |> unique_constraint(:nickname)
1886 |> Repo.insert()
1887 |> set_cache()
1888 end
1889
1890 def public_key(%{public_key: public_key_pem}) when is_binary(public_key_pem) do
1891 key =
1892 public_key_pem
1893 |> :public_key.pem_decode()
1894 |> hd()
1895 |> :public_key.pem_entry_decode()
1896
1897 {:ok, key}
1898 end
1899
1900 def public_key(_), do: {:error, "key not found"}
1901
1902 def get_public_key_for_ap_id(ap_id) do
1903 with {:ok, %User{} = user} <- get_or_fetch_by_ap_id(ap_id),
1904 {:ok, public_key} <- public_key(user) do
1905 {:ok, public_key}
1906 else
1907 _ -> :error
1908 end
1909 end
1910
1911 def ap_enabled?(%User{local: true}), do: true
1912 def ap_enabled?(%User{ap_enabled: ap_enabled}), do: ap_enabled
1913 def ap_enabled?(_), do: false
1914
1915 @doc "Gets or fetch a user by uri or nickname."
1916 @spec get_or_fetch(String.t()) :: {:ok, User.t()} | {:error, String.t()}
1917 def get_or_fetch("http" <> _host = uri), do: get_or_fetch_by_ap_id(uri)
1918 def get_or_fetch(nickname), do: get_or_fetch_by_nickname(nickname)
1919
1920 # wait a period of time and return newest version of the User structs
1921 # this is because we have synchronous follow APIs and need to simulate them
1922 # with an async handshake
1923 def wait_and_refresh(_, %User{local: true} = a, %User{local: true} = b) do
1924 with %User{} = a <- get_cached_by_id(a.id),
1925 %User{} = b <- get_cached_by_id(b.id) do
1926 {:ok, a, b}
1927 else
1928 nil -> :error
1929 end
1930 end
1931
1932 def wait_and_refresh(timeout, %User{} = a, %User{} = b) do
1933 with :ok <- :timer.sleep(timeout),
1934 %User{} = a <- get_cached_by_id(a.id),
1935 %User{} = b <- get_cached_by_id(b.id) do
1936 {:ok, a, b}
1937 else
1938 nil -> :error
1939 end
1940 end
1941
1942 def parse_bio(bio) when is_binary(bio) and bio != "" do
1943 bio
1944 |> CommonUtils.format_input("text/plain", mentions_format: :full)
1945 |> elem(0)
1946 end
1947
1948 def parse_bio(_), do: ""
1949
1950 def parse_bio(bio, user) when is_binary(bio) and bio != "" do
1951 # TODO: get profile URLs other than user.ap_id
1952 profile_urls = [user.ap_id]
1953
1954 bio
1955 |> CommonUtils.format_input("text/plain",
1956 mentions_format: :full,
1957 rel: &RelMe.maybe_put_rel_me(&1, profile_urls)
1958 )
1959 |> elem(0)
1960 end
1961
1962 def parse_bio(_, _), do: ""
1963
1964 def tag(user_identifiers, tags) when is_list(user_identifiers) do
1965 Repo.transaction(fn ->
1966 for user_identifier <- user_identifiers, do: tag(user_identifier, tags)
1967 end)
1968 end
1969
1970 def tag(nickname, tags) when is_binary(nickname),
1971 do: tag(get_by_nickname(nickname), tags)
1972
1973 def tag(%User{} = user, tags),
1974 do: update_tags(user, Enum.uniq((user.tags || []) ++ normalize_tags(tags)))
1975
1976 def untag(user_identifiers, tags) when is_list(user_identifiers) do
1977 Repo.transaction(fn ->
1978 for user_identifier <- user_identifiers, do: untag(user_identifier, tags)
1979 end)
1980 end
1981
1982 def untag(nickname, tags) when is_binary(nickname),
1983 do: untag(get_by_nickname(nickname), tags)
1984
1985 def untag(%User{} = user, tags),
1986 do: update_tags(user, (user.tags || []) -- normalize_tags(tags))
1987
1988 defp update_tags(%User{} = user, new_tags) do
1989 {:ok, updated_user} =
1990 user
1991 |> change(%{tags: new_tags})
1992 |> update_and_set_cache()
1993
1994 updated_user
1995 end
1996
1997 defp normalize_tags(tags) do
1998 [tags]
1999 |> List.flatten()
2000 |> Enum.map(&String.downcase/1)
2001 end
2002
2003 defp local_nickname_regex do
2004 if Config.get([:instance, :extended_nickname_format]) do
2005 @extended_local_nickname_regex
2006 else
2007 @strict_local_nickname_regex
2008 end
2009 end
2010
2011 def local_nickname(nickname_or_mention) do
2012 nickname_or_mention
2013 |> full_nickname()
2014 |> String.split("@")
2015 |> hd()
2016 end
2017
2018 def full_nickname(nickname_or_mention),
2019 do: String.trim_leading(nickname_or_mention, "@")
2020
2021 def error_user(ap_id) do
2022 %User{
2023 name: ap_id,
2024 ap_id: ap_id,
2025 nickname: "erroruser@example.com",
2026 inserted_at: NaiveDateTime.utc_now()
2027 }
2028 end
2029
2030 @spec all_superusers() :: [User.t()]
2031 def all_superusers do
2032 User.Query.build(%{super_users: true, local: true, deactivated: false})
2033 |> Repo.all()
2034 end
2035
2036 def muting_reblogs?(%User{} = user, %User{} = target) do
2037 UserRelationship.reblog_mute_exists?(user, target)
2038 end
2039
2040 def showing_reblogs?(%User{} = user, %User{} = target) do
2041 not muting_reblogs?(user, target)
2042 end
2043
2044 @doc """
2045 The function returns a query to get users with no activity for given interval of days.
2046 Inactive users are those who didn't read any notification, or had any activity where
2047 the user is the activity's actor, during `inactivity_threshold` days.
2048 Deactivated users will not appear in this list.
2049
2050 ## Examples
2051
2052 iex> Pleroma.User.list_inactive_users()
2053 %Ecto.Query{}
2054 """
2055 @spec list_inactive_users_query(integer()) :: Ecto.Query.t()
2056 def list_inactive_users_query(inactivity_threshold \\ 7) do
2057 negative_inactivity_threshold = -inactivity_threshold
2058 now = NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
2059 # Subqueries are not supported in `where` clauses, join gets too complicated.
2060 has_read_notifications =
2061 from(n in Pleroma.Notification,
2062 where: n.seen == true,
2063 group_by: n.id,
2064 having: max(n.updated_at) > datetime_add(^now, ^negative_inactivity_threshold, "day"),
2065 select: n.user_id
2066 )
2067 |> Pleroma.Repo.all()
2068
2069 from(u in Pleroma.User,
2070 left_join: a in Pleroma.Activity,
2071 on: u.ap_id == a.actor,
2072 where: not is_nil(u.nickname),
2073 where: u.deactivated != ^true,
2074 where: u.id not in ^has_read_notifications,
2075 group_by: u.id,
2076 having:
2077 max(a.inserted_at) < datetime_add(^now, ^negative_inactivity_threshold, "day") or
2078 is_nil(max(a.inserted_at))
2079 )
2080 end
2081
2082 @doc """
2083 Enable or disable email notifications for user
2084
2085 ## Examples
2086
2087 iex> Pleroma.User.switch_email_notifications(Pleroma.User{email_notifications: %{"digest" => false}}, "digest", true)
2088 Pleroma.User{email_notifications: %{"digest" => true}}
2089
2090 iex> Pleroma.User.switch_email_notifications(Pleroma.User{email_notifications: %{"digest" => true}}, "digest", false)
2091 Pleroma.User{email_notifications: %{"digest" => false}}
2092 """
2093 @spec switch_email_notifications(t(), String.t(), boolean()) ::
2094 {:ok, t()} | {:error, Ecto.Changeset.t()}
2095 def switch_email_notifications(user, type, status) do
2096 User.update_email_notifications(user, %{type => status})
2097 end
2098
2099 @doc """
2100 Set `last_digest_emailed_at` value for the user to current time
2101 """
2102 @spec touch_last_digest_emailed_at(t()) :: t()
2103 def touch_last_digest_emailed_at(user) do
2104 now = NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
2105
2106 {:ok, updated_user} =
2107 user
2108 |> change(%{last_digest_emailed_at: now})
2109 |> update_and_set_cache()
2110
2111 updated_user
2112 end
2113
2114 @spec toggle_confirmation(User.t()) :: {:ok, User.t()} | {:error, Changeset.t()}
2115 def toggle_confirmation(%User{} = user) do
2116 user
2117 |> confirmation_changeset(need_confirmation: !user.confirmation_pending)
2118 |> update_and_set_cache()
2119 end
2120
2121 @spec toggle_confirmation([User.t()]) :: [{:ok, User.t()} | {:error, Changeset.t()}]
2122 def toggle_confirmation(users) do
2123 Enum.map(users, &toggle_confirmation/1)
2124 end
2125
2126 @spec need_confirmation(User.t(), boolean()) :: {:ok, User.t()} | {:error, Changeset.t()}
2127 def need_confirmation(%User{} = user, bool) do
2128 user
2129 |> confirmation_changeset(need_confirmation: bool)
2130 |> update_and_set_cache()
2131 end
2132
2133 def get_mascot(%{mascot: %{} = mascot}) when not is_nil(mascot) do
2134 mascot
2135 end
2136
2137 def get_mascot(%{mascot: mascot}) when is_nil(mascot) do
2138 # use instance-default
2139 config = Config.get([:assets, :mascots])
2140 default_mascot = Config.get([:assets, :default_mascot])
2141 mascot = Keyword.get(config, default_mascot)
2142
2143 %{
2144 "id" => "default-mascot",
2145 "url" => mascot[:url],
2146 "preview_url" => mascot[:url],
2147 "pleroma" => %{
2148 "mime_type" => mascot[:mime_type]
2149 }
2150 }
2151 end
2152
2153 def ensure_keys_present(%{keys: keys} = user) when not is_nil(keys), do: {:ok, user}
2154
2155 def ensure_keys_present(%User{} = user) do
2156 with {:ok, pem} <- Keys.generate_rsa_pem() do
2157 user
2158 |> cast(%{keys: pem}, [:keys])
2159 |> validate_required([:keys])
2160 |> update_and_set_cache()
2161 end
2162 end
2163
2164 def get_ap_ids_by_nicknames(nicknames) do
2165 from(u in User,
2166 where: u.nickname in ^nicknames,
2167 select: u.ap_id
2168 )
2169 |> Repo.all()
2170 end
2171
2172 defp put_password_hash(
2173 %Ecto.Changeset{valid?: true, changes: %{password: password}} = changeset
2174 ) do
2175 change(changeset, password_hash: Pbkdf2.hash_pwd_salt(password))
2176 end
2177
2178 defp put_password_hash(changeset), do: changeset
2179
2180 def is_internal_user?(%User{nickname: nil}), do: true
2181 def is_internal_user?(%User{local: true, nickname: "internal." <> _}), do: true
2182 def is_internal_user?(_), do: false
2183
2184 # A hack because user delete activities have a fake id for whatever reason
2185 # TODO: Get rid of this
2186 def get_delivered_users_by_object_id("pleroma:fake_object_id"), do: []
2187
2188 def get_delivered_users_by_object_id(object_id) do
2189 from(u in User,
2190 inner_join: delivery in assoc(u, :deliveries),
2191 where: delivery.object_id == ^object_id
2192 )
2193 |> Repo.all()
2194 end
2195
2196 def change_email(user, email) do
2197 user
2198 |> cast(%{email: email}, [:email])
2199 |> validate_required([:email])
2200 |> unique_constraint(:email)
2201 |> validate_format(:email, @email_regex)
2202 |> update_and_set_cache()
2203 end
2204
2205 # Internal function; public one is `deactivate/2`
2206 defp set_activation_status(user, deactivated) do
2207 user
2208 |> cast(%{deactivated: deactivated}, [:deactivated])
2209 |> update_and_set_cache()
2210 end
2211
2212 def update_banner(user, banner) do
2213 user
2214 |> cast(%{banner: banner}, [:banner])
2215 |> update_and_set_cache()
2216 end
2217
2218 def update_background(user, background) do
2219 user
2220 |> cast(%{background: background}, [:background])
2221 |> update_and_set_cache()
2222 end
2223
2224 def roles(%{is_moderator: is_moderator, is_admin: is_admin}) do
2225 %{
2226 admin: is_admin,
2227 moderator: is_moderator
2228 }
2229 end
2230
2231 def validate_fields(changeset, remote? \\ false) do
2232 limit_name = if remote?, do: :max_remote_account_fields, else: :max_account_fields
2233 limit = Config.get([:instance, limit_name], 0)
2234
2235 changeset
2236 |> validate_length(:fields, max: limit)
2237 |> validate_change(:fields, fn :fields, fields ->
2238 if Enum.all?(fields, &valid_field?/1) do
2239 []
2240 else
2241 [fields: "invalid"]
2242 end
2243 end)
2244 end
2245
2246 defp valid_field?(%{"name" => name, "value" => value}) do
2247 name_limit = Config.get([:instance, :account_field_name_length], 255)
2248 value_limit = Config.get([:instance, :account_field_value_length], 255)
2249
2250 is_binary(name) && is_binary(value) && String.length(name) <= name_limit &&
2251 String.length(value) <= value_limit
2252 end
2253
2254 defp valid_field?(_), do: false
2255
2256 defp truncate_field(%{"name" => name, "value" => value}) do
2257 {name, _chopped} =
2258 String.split_at(name, Config.get([:instance, :account_field_name_length], 255))
2259
2260 {value, _chopped} =
2261 String.split_at(value, Config.get([:instance, :account_field_value_length], 255))
2262
2263 %{"name" => name, "value" => value}
2264 end
2265
2266 def admin_api_update(user, params) do
2267 user
2268 |> cast(params, [
2269 :is_moderator,
2270 :is_admin,
2271 :show_role
2272 ])
2273 |> update_and_set_cache()
2274 end
2275
2276 @doc "Signs user out of all applications"
2277 def global_sign_out(user) do
2278 OAuth.Authorization.delete_user_authorizations(user)
2279 OAuth.Token.delete_user_tokens(user)
2280 end
2281
2282 def mascot_update(user, url) do
2283 user
2284 |> cast(%{mascot: url}, [:mascot])
2285 |> validate_required([:mascot])
2286 |> update_and_set_cache()
2287 end
2288
2289 def mastodon_settings_update(user, settings) do
2290 user
2291 |> cast(%{mastofe_settings: settings}, [:mastofe_settings])
2292 |> validate_required([:mastofe_settings])
2293 |> update_and_set_cache()
2294 end
2295
2296 @spec confirmation_changeset(User.t(), keyword()) :: Changeset.t()
2297 def confirmation_changeset(user, need_confirmation: need_confirmation?) do
2298 params =
2299 if need_confirmation? do
2300 %{
2301 confirmation_pending: true,
2302 confirmation_token: :crypto.strong_rand_bytes(32) |> Base.url_encode64()
2303 }
2304 else
2305 %{
2306 confirmation_pending: false,
2307 confirmation_token: nil
2308 }
2309 end
2310
2311 cast(user, params, [:confirmation_pending, :confirmation_token])
2312 end
2313
2314 @spec approval_changeset(User.t(), keyword()) :: Changeset.t()
2315 def approval_changeset(user, need_approval: need_approval?) do
2316 params = if need_approval?, do: %{approval_pending: true}, else: %{approval_pending: false}
2317 cast(user, params, [:approval_pending])
2318 end
2319
2320 def add_pinnned_activity(user, %Pleroma.Activity{id: id}) do
2321 if id not in user.pinned_activities do
2322 max_pinned_statuses = Config.get([:instance, :max_pinned_statuses], 0)
2323 params = %{pinned_activities: user.pinned_activities ++ [id]}
2324
2325 user
2326 |> cast(params, [:pinned_activities])
2327 |> validate_length(:pinned_activities,
2328 max: max_pinned_statuses,
2329 message: "You have already pinned the maximum number of statuses"
2330 )
2331 else
2332 change(user)
2333 end
2334 |> update_and_set_cache()
2335 end
2336
2337 def remove_pinnned_activity(user, %Pleroma.Activity{id: id}) do
2338 params = %{pinned_activities: List.delete(user.pinned_activities, id)}
2339
2340 user
2341 |> cast(params, [:pinned_activities])
2342 |> update_and_set_cache()
2343 end
2344
2345 def update_email_notifications(user, settings) do
2346 email_notifications =
2347 user.email_notifications
2348 |> Map.merge(settings)
2349 |> Map.take(["digest"])
2350
2351 params = %{email_notifications: email_notifications}
2352 fields = [:email_notifications]
2353
2354 user
2355 |> cast(params, fields)
2356 |> validate_required(fields)
2357 |> update_and_set_cache()
2358 end
2359
2360 defp set_domain_blocks(user, domain_blocks) do
2361 params = %{domain_blocks: domain_blocks}
2362
2363 user
2364 |> cast(params, [:domain_blocks])
2365 |> validate_required([:domain_blocks])
2366 |> update_and_set_cache()
2367 end
2368
2369 def block_domain(user, domain_blocked) do
2370 set_domain_blocks(user, Enum.uniq([domain_blocked | user.domain_blocks]))
2371 end
2372
2373 def unblock_domain(user, domain_blocked) do
2374 set_domain_blocks(user, List.delete(user.domain_blocks, domain_blocked))
2375 end
2376
2377 @spec add_to_block(User.t(), User.t()) ::
2378 {:ok, UserRelationship.t()} | {:error, Ecto.Changeset.t()}
2379 defp add_to_block(%User{} = user, %User{} = blocked) do
2380 UserRelationship.create_block(user, blocked)
2381 end
2382
2383 @spec add_to_block(User.t(), User.t()) ::
2384 {:ok, UserRelationship.t()} | {:ok, nil} | {:error, Ecto.Changeset.t()}
2385 defp remove_from_block(%User{} = user, %User{} = blocked) do
2386 UserRelationship.delete_block(user, blocked)
2387 end
2388
2389 defp add_to_mutes(%User{} = user, %User{} = muted_user, notifications?) do
2390 with {:ok, user_mute} <- UserRelationship.create_mute(user, muted_user),
2391 {:ok, user_notification_mute} <-
2392 (notifications? && UserRelationship.create_notification_mute(user, muted_user)) ||
2393 {:ok, nil} do
2394 {:ok, Enum.filter([user_mute, user_notification_mute], & &1)}
2395 end
2396 end
2397
2398 defp remove_from_mutes(user, %User{} = muted_user) do
2399 with {:ok, user_mute} <- UserRelationship.delete_mute(user, muted_user),
2400 {:ok, user_notification_mute} <-
2401 UserRelationship.delete_notification_mute(user, muted_user) do
2402 {:ok, [user_mute, user_notification_mute]}
2403 end
2404 end
2405
2406 def set_invisible(user, invisible) do
2407 params = %{invisible: invisible}
2408
2409 user
2410 |> cast(params, [:invisible])
2411 |> validate_required([:invisible])
2412 |> update_and_set_cache()
2413 end
2414
2415 def sanitize_html(%User{} = user) do
2416 sanitize_html(user, nil)
2417 end
2418
2419 # User data that mastodon isn't filtering (treated as plaintext):
2420 # - field name
2421 # - display name
2422 def sanitize_html(%User{} = user, filter) do
2423 fields =
2424 Enum.map(user.fields, fn %{"name" => name, "value" => value} ->
2425 %{
2426 "name" => name,
2427 "value" => HTML.filter_tags(value, Pleroma.HTML.Scrubber.LinksOnly)
2428 }
2429 end)
2430
2431 user
2432 |> Map.put(:bio, HTML.filter_tags(user.bio, filter))
2433 |> Map.put(:fields, fields)
2434 end
2435 end