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