Merge remote-tracking branch 'remotes/origin/develop' into chore/elixir-1.11
[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(:is_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(:is_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 :is_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 :is_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 :is_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 :is_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{} = user) do
776 with {:ok, user} <- autofollow_users(user),
777 {:ok, user} <- set_cache(user),
778 {:ok, _} <- send_welcome_email(user),
779 {:ok, _} <- send_welcome_message(user),
780 {:ok, _} <- send_welcome_chat_message(user),
781 {:ok, _} <- try_send_confirmation_email(user) do
782 {:ok, user}
783 end
784 end
785
786 def send_welcome_message(user) do
787 if User.WelcomeMessage.enabled?() do
788 User.WelcomeMessage.post_message(user)
789 {:ok, :enqueued}
790 else
791 {:ok, :noop}
792 end
793 end
794
795 def send_welcome_chat_message(user) do
796 if User.WelcomeChatMessage.enabled?() do
797 User.WelcomeChatMessage.post_message(user)
798 {:ok, :enqueued}
799 else
800 {:ok, :noop}
801 end
802 end
803
804 def send_welcome_email(%User{email: email} = user) when is_binary(email) do
805 if User.WelcomeEmail.enabled?() do
806 User.WelcomeEmail.send_email(user)
807 {:ok, :enqueued}
808 else
809 {:ok, :noop}
810 end
811 end
812
813 def send_welcome_email(_), do: {:ok, :noop}
814
815 @spec try_send_confirmation_email(User.t()) :: {:ok, :enqueued | :noop}
816 def try_send_confirmation_email(%User{confirmation_pending: true, email: email} = user)
817 when is_binary(email) 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, is_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} = update_following_count(follower)
919
920 {:ok, follower, followed}
921
922 nil ->
923 {:error, "Not subscribed!"}
924 end
925 end
926
927 @doc "Returns follow state as Pleroma.FollowingRelationship.State value"
928 def get_follow_state(%User{} = follower, %User{} = following) do
929 following_relationship = FollowingRelationship.get(follower, following)
930 get_follow_state(follower, following, following_relationship)
931 end
932
933 def get_follow_state(
934 %User{} = follower,
935 %User{} = following,
936 following_relationship
937 ) do
938 case {following_relationship, following.local} do
939 {nil, false} ->
940 case Utils.fetch_latest_follow(follower, following) do
941 %Activity{data: %{"state" => state}} when state in ["pending", "accept"] ->
942 FollowingRelationship.state_to_enum(state)
943
944 _ ->
945 nil
946 end
947
948 {%{state: state}, _} ->
949 state
950
951 {nil, _} ->
952 nil
953 end
954 end
955
956 def locked?(%User{} = user) do
957 user.is_locked || false
958 end
959
960 def get_by_id(id) do
961 Repo.get_by(User, id: id)
962 end
963
964 def get_by_ap_id(ap_id) do
965 Repo.get_by(User, ap_id: ap_id)
966 end
967
968 def get_all_by_ap_id(ap_ids) do
969 from(u in __MODULE__,
970 where: u.ap_id in ^ap_ids
971 )
972 |> Repo.all()
973 end
974
975 def get_all_by_ids(ids) do
976 from(u in __MODULE__, where: u.id in ^ids)
977 |> Repo.all()
978 end
979
980 # This is mostly an SPC migration fix. This guesses the user nickname by taking the last part
981 # of the ap_id and the domain and tries to get that user
982 def get_by_guessed_nickname(ap_id) do
983 domain = URI.parse(ap_id).host
984 name = List.last(String.split(ap_id, "/"))
985 nickname = "#{name}@#{domain}"
986
987 get_cached_by_nickname(nickname)
988 end
989
990 def set_cache({:ok, user}), do: set_cache(user)
991 def set_cache({:error, err}), do: {:error, err}
992
993 def set_cache(%User{} = user) do
994 Cachex.put(:user_cache, "ap_id:#{user.ap_id}", user)
995 Cachex.put(:user_cache, "nickname:#{user.nickname}", user)
996 Cachex.put(:user_cache, "friends_ap_ids:#{user.nickname}", get_user_friends_ap_ids(user))
997 {:ok, user}
998 end
999
1000 def update_and_set_cache(struct, params) do
1001 struct
1002 |> update_changeset(params)
1003 |> update_and_set_cache()
1004 end
1005
1006 def update_and_set_cache(changeset) do
1007 with {:ok, user} <- Repo.update(changeset, stale_error_field: :id) do
1008 set_cache(user)
1009 end
1010 end
1011
1012 def get_user_friends_ap_ids(user) do
1013 from(u in User.get_friends_query(user), select: u.ap_id)
1014 |> Repo.all()
1015 end
1016
1017 @spec get_cached_user_friends_ap_ids(User.t()) :: [String.t()]
1018 def get_cached_user_friends_ap_ids(user) do
1019 Cachex.fetch!(:user_cache, "friends_ap_ids:#{user.ap_id}", fn _ ->
1020 get_user_friends_ap_ids(user)
1021 end)
1022 end
1023
1024 def invalidate_cache(user) do
1025 Cachex.del(:user_cache, "ap_id:#{user.ap_id}")
1026 Cachex.del(:user_cache, "nickname:#{user.nickname}")
1027 Cachex.del(:user_cache, "friends_ap_ids:#{user.ap_id}")
1028 end
1029
1030 @spec get_cached_by_ap_id(String.t()) :: User.t() | nil
1031 def get_cached_by_ap_id(ap_id) do
1032 key = "ap_id:#{ap_id}"
1033
1034 with {:ok, nil} <- Cachex.get(:user_cache, key),
1035 user when not is_nil(user) <- get_by_ap_id(ap_id),
1036 {:ok, true} <- Cachex.put(:user_cache, key, user) do
1037 user
1038 else
1039 {:ok, user} -> user
1040 nil -> nil
1041 end
1042 end
1043
1044 def get_cached_by_id(id) do
1045 key = "id:#{id}"
1046
1047 ap_id =
1048 Cachex.fetch!(:user_cache, key, fn _ ->
1049 user = get_by_id(id)
1050
1051 if user do
1052 Cachex.put(:user_cache, "ap_id:#{user.ap_id}", user)
1053 {:commit, user.ap_id}
1054 else
1055 {:ignore, ""}
1056 end
1057 end)
1058
1059 get_cached_by_ap_id(ap_id)
1060 end
1061
1062 def get_cached_by_nickname(nickname) do
1063 key = "nickname:#{nickname}"
1064
1065 Cachex.fetch!(:user_cache, key, fn ->
1066 case get_or_fetch_by_nickname(nickname) do
1067 {:ok, user} -> {:commit, user}
1068 {:error, _error} -> {:ignore, nil}
1069 end
1070 end)
1071 end
1072
1073 def get_cached_by_nickname_or_id(nickname_or_id, opts \\ []) do
1074 restrict_to_local = Config.get([:instance, :limit_to_local_content])
1075
1076 cond do
1077 is_integer(nickname_or_id) or FlakeId.flake_id?(nickname_or_id) ->
1078 get_cached_by_id(nickname_or_id) || get_cached_by_nickname(nickname_or_id)
1079
1080 restrict_to_local == false or not String.contains?(nickname_or_id, "@") ->
1081 get_cached_by_nickname(nickname_or_id)
1082
1083 restrict_to_local == :unauthenticated and match?(%User{}, opts[:for]) ->
1084 get_cached_by_nickname(nickname_or_id)
1085
1086 true ->
1087 nil
1088 end
1089 end
1090
1091 @spec get_by_nickname(String.t()) :: User.t() | nil
1092 def get_by_nickname(nickname) do
1093 Repo.get_by(User, nickname: nickname) ||
1094 if Regex.match?(~r(@#{Pleroma.Web.Endpoint.host()})i, nickname) do
1095 Repo.get_by(User, nickname: local_nickname(nickname))
1096 end
1097 end
1098
1099 def get_by_email(email), do: Repo.get_by(User, email: email)
1100
1101 def get_by_nickname_or_email(nickname_or_email) do
1102 get_by_nickname(nickname_or_email) || get_by_email(nickname_or_email)
1103 end
1104
1105 def fetch_by_nickname(nickname), do: ActivityPub.make_user_from_nickname(nickname)
1106
1107 def get_or_fetch_by_nickname(nickname) do
1108 with %User{} = user <- get_by_nickname(nickname) do
1109 {:ok, user}
1110 else
1111 _e ->
1112 with [_nick, _domain] <- String.split(nickname, "@"),
1113 {:ok, user} <- fetch_by_nickname(nickname) do
1114 {:ok, user}
1115 else
1116 _e -> {:error, "not found " <> nickname}
1117 end
1118 end
1119 end
1120
1121 @spec get_followers_query(User.t(), pos_integer() | nil) :: Ecto.Query.t()
1122 def get_followers_query(%User{} = user, nil) do
1123 User.Query.build(%{followers: user, deactivated: false})
1124 end
1125
1126 def get_followers_query(%User{} = user, page) do
1127 user
1128 |> get_followers_query(nil)
1129 |> User.Query.paginate(page, 20)
1130 end
1131
1132 @spec get_followers_query(User.t()) :: Ecto.Query.t()
1133 def get_followers_query(%User{} = user), do: get_followers_query(user, nil)
1134
1135 @spec get_followers(User.t(), pos_integer() | nil) :: {:ok, list(User.t())}
1136 def get_followers(%User{} = user, page \\ nil) do
1137 user
1138 |> get_followers_query(page)
1139 |> Repo.all()
1140 end
1141
1142 @spec get_external_followers(User.t(), pos_integer() | nil) :: {:ok, list(User.t())}
1143 def get_external_followers(%User{} = user, page \\ nil) do
1144 user
1145 |> get_followers_query(page)
1146 |> User.Query.build(%{external: true})
1147 |> Repo.all()
1148 end
1149
1150 def get_followers_ids(%User{} = user, page \\ nil) do
1151 user
1152 |> get_followers_query(page)
1153 |> select([u], u.id)
1154 |> Repo.all()
1155 end
1156
1157 @spec get_friends_query(User.t(), pos_integer() | nil) :: Ecto.Query.t()
1158 def get_friends_query(%User{} = user, nil) do
1159 User.Query.build(%{friends: user, deactivated: false})
1160 end
1161
1162 def get_friends_query(%User{} = user, page) do
1163 user
1164 |> get_friends_query(nil)
1165 |> User.Query.paginate(page, 20)
1166 end
1167
1168 @spec get_friends_query(User.t()) :: Ecto.Query.t()
1169 def get_friends_query(%User{} = user), do: get_friends_query(user, nil)
1170
1171 def get_friends(%User{} = user, page \\ nil) do
1172 user
1173 |> get_friends_query(page)
1174 |> Repo.all()
1175 end
1176
1177 def get_friends_ap_ids(%User{} = user) do
1178 user
1179 |> get_friends_query(nil)
1180 |> select([u], u.ap_id)
1181 |> Repo.all()
1182 end
1183
1184 def get_friends_ids(%User{} = user, page \\ nil) do
1185 user
1186 |> get_friends_query(page)
1187 |> select([u], u.id)
1188 |> Repo.all()
1189 end
1190
1191 def increase_note_count(%User{} = user) do
1192 User
1193 |> where(id: ^user.id)
1194 |> update([u], inc: [note_count: 1])
1195 |> select([u], u)
1196 |> Repo.update_all([])
1197 |> case do
1198 {1, [user]} -> set_cache(user)
1199 _ -> {:error, user}
1200 end
1201 end
1202
1203 def decrease_note_count(%User{} = user) do
1204 User
1205 |> where(id: ^user.id)
1206 |> update([u],
1207 set: [
1208 note_count: fragment("greatest(0, note_count - 1)")
1209 ]
1210 )
1211 |> select([u], u)
1212 |> Repo.update_all([])
1213 |> case do
1214 {1, [user]} -> set_cache(user)
1215 _ -> {:error, user}
1216 end
1217 end
1218
1219 def update_note_count(%User{} = user, note_count \\ nil) do
1220 note_count =
1221 note_count ||
1222 from(
1223 a in Object,
1224 where: fragment("?->>'actor' = ? and ?->>'type' = 'Note'", a.data, ^user.ap_id, a.data),
1225 select: count(a.id)
1226 )
1227 |> Repo.one()
1228
1229 user
1230 |> cast(%{note_count: note_count}, [:note_count])
1231 |> update_and_set_cache()
1232 end
1233
1234 @spec maybe_fetch_follow_information(User.t()) :: User.t()
1235 def maybe_fetch_follow_information(user) do
1236 with {:ok, user} <- fetch_follow_information(user) do
1237 user
1238 else
1239 e ->
1240 Logger.error("Follower/Following counter update for #{user.ap_id} failed.\n#{inspect(e)}")
1241
1242 user
1243 end
1244 end
1245
1246 def fetch_follow_information(user) do
1247 with {:ok, info} <- ActivityPub.fetch_follow_information_for_user(user) do
1248 user
1249 |> follow_information_changeset(info)
1250 |> update_and_set_cache()
1251 end
1252 end
1253
1254 defp follow_information_changeset(user, params) do
1255 user
1256 |> cast(params, [
1257 :hide_followers,
1258 :hide_follows,
1259 :follower_count,
1260 :following_count,
1261 :hide_followers_count,
1262 :hide_follows_count
1263 ])
1264 end
1265
1266 @spec update_follower_count(User.t()) :: {:ok, User.t()}
1267 def update_follower_count(%User{} = user) do
1268 if user.local or !Config.get([:instance, :external_user_synchronization]) do
1269 follower_count = FollowingRelationship.follower_count(user)
1270
1271 user
1272 |> follow_information_changeset(%{follower_count: follower_count})
1273 |> update_and_set_cache
1274 else
1275 {:ok, maybe_fetch_follow_information(user)}
1276 end
1277 end
1278
1279 @spec update_following_count(User.t()) :: {:ok, User.t()}
1280 def update_following_count(%User{local: false} = user) do
1281 if Config.get([:instance, :external_user_synchronization]) do
1282 {:ok, maybe_fetch_follow_information(user)}
1283 else
1284 {:ok, user}
1285 end
1286 end
1287
1288 def update_following_count(%User{local: true} = user) do
1289 following_count = FollowingRelationship.following_count(user)
1290
1291 user
1292 |> follow_information_changeset(%{following_count: following_count})
1293 |> update_and_set_cache()
1294 end
1295
1296 def set_unread_conversation_count(%User{local: true} = user) do
1297 unread_query = Participation.unread_conversation_count_for_user(user)
1298
1299 User
1300 |> join(:inner, [u], p in subquery(unread_query))
1301 |> update([u, p],
1302 set: [unread_conversation_count: p.count]
1303 )
1304 |> where([u], u.id == ^user.id)
1305 |> select([u], u)
1306 |> Repo.update_all([])
1307 |> case do
1308 {1, [user]} -> set_cache(user)
1309 _ -> {:error, user}
1310 end
1311 end
1312
1313 def set_unread_conversation_count(user), do: {:ok, user}
1314
1315 def increment_unread_conversation_count(conversation, %User{local: true} = user) do
1316 unread_query =
1317 Participation.unread_conversation_count_for_user(user)
1318 |> where([p], p.conversation_id == ^conversation.id)
1319
1320 User
1321 |> join(:inner, [u], p in subquery(unread_query))
1322 |> update([u, p],
1323 inc: [unread_conversation_count: 1]
1324 )
1325 |> where([u], u.id == ^user.id)
1326 |> where([u, p], p.count == 0)
1327 |> select([u], u)
1328 |> Repo.update_all([])
1329 |> case do
1330 {1, [user]} -> set_cache(user)
1331 _ -> {:error, user}
1332 end
1333 end
1334
1335 def increment_unread_conversation_count(_, user), do: {:ok, user}
1336
1337 @spec get_users_from_set([String.t()], keyword()) :: [User.t()]
1338 def get_users_from_set(ap_ids, opts \\ []) do
1339 local_only = Keyword.get(opts, :local_only, true)
1340 criteria = %{ap_id: ap_ids, deactivated: false}
1341 criteria = if local_only, do: Map.put(criteria, :local, true), else: criteria
1342
1343 User.Query.build(criteria)
1344 |> Repo.all()
1345 end
1346
1347 @spec get_recipients_from_activity(Activity.t()) :: [User.t()]
1348 def get_recipients_from_activity(%Activity{recipients: to, actor: actor}) do
1349 to = [actor | to]
1350
1351 query = User.Query.build(%{recipients_from_activity: to, local: true, deactivated: false})
1352
1353 query
1354 |> Repo.all()
1355 end
1356
1357 @spec mute(User.t(), User.t(), boolean()) ::
1358 {:ok, list(UserRelationship.t())} | {:error, String.t()}
1359 def mute(%User{} = muter, %User{} = mutee, notifications? \\ true) do
1360 add_to_mutes(muter, mutee, notifications?)
1361 end
1362
1363 def unmute(%User{} = muter, %User{} = mutee) do
1364 remove_from_mutes(muter, mutee)
1365 end
1366
1367 def subscribe(%User{} = subscriber, %User{} = target) do
1368 deny_follow_blocked = Config.get([:user, :deny_follow_blocked])
1369
1370 if blocks?(target, subscriber) and deny_follow_blocked do
1371 {:error, "Could not subscribe: #{target.nickname} is blocking you"}
1372 else
1373 # Note: the relationship is inverse: subscriber acts as relationship target
1374 UserRelationship.create_inverse_subscription(target, subscriber)
1375 end
1376 end
1377
1378 def subscribe(%User{} = subscriber, %{ap_id: ap_id}) do
1379 with %User{} = subscribee <- get_cached_by_ap_id(ap_id) do
1380 subscribe(subscriber, subscribee)
1381 end
1382 end
1383
1384 def unsubscribe(%User{} = unsubscriber, %User{} = target) do
1385 # Note: the relationship is inverse: subscriber acts as relationship target
1386 UserRelationship.delete_inverse_subscription(target, unsubscriber)
1387 end
1388
1389 def unsubscribe(%User{} = unsubscriber, %{ap_id: ap_id}) do
1390 with %User{} = user <- get_cached_by_ap_id(ap_id) do
1391 unsubscribe(unsubscriber, user)
1392 end
1393 end
1394
1395 def block(%User{} = blocker, %User{} = blocked) do
1396 # sever any follow relationships to prevent leaks per activitypub (Pleroma issue #213)
1397 blocker =
1398 if following?(blocker, blocked) do
1399 {:ok, blocker, _} = unfollow(blocker, blocked)
1400 blocker
1401 else
1402 blocker
1403 end
1404
1405 # clear any requested follows as well
1406 blocked =
1407 case CommonAPI.reject_follow_request(blocked, blocker) do
1408 {:ok, %User{} = updated_blocked} -> updated_blocked
1409 nil -> blocked
1410 end
1411
1412 unsubscribe(blocked, blocker)
1413
1414 unfollowing_blocked = Config.get([:activitypub, :unfollow_blocked], true)
1415 if unfollowing_blocked && following?(blocked, blocker), do: unfollow(blocked, blocker)
1416
1417 {:ok, blocker} = update_follower_count(blocker)
1418 {:ok, blocker, _} = Participation.mark_all_as_read(blocker, blocked)
1419 add_to_block(blocker, blocked)
1420 end
1421
1422 # helper to handle the block given only an actor's AP id
1423 def block(%User{} = blocker, %{ap_id: ap_id}) do
1424 block(blocker, get_cached_by_ap_id(ap_id))
1425 end
1426
1427 def unblock(%User{} = blocker, %User{} = blocked) do
1428 remove_from_block(blocker, blocked)
1429 end
1430
1431 # helper to handle the block given only an actor's AP id
1432 def unblock(%User{} = blocker, %{ap_id: ap_id}) do
1433 unblock(blocker, get_cached_by_ap_id(ap_id))
1434 end
1435
1436 def mutes?(nil, _), do: false
1437 def mutes?(%User{} = user, %User{} = target), do: mutes_user?(user, target)
1438
1439 def mutes_user?(%User{} = user, %User{} = target) do
1440 UserRelationship.mute_exists?(user, target)
1441 end
1442
1443 @spec muted_notifications?(User.t() | nil, User.t() | map()) :: boolean()
1444 def muted_notifications?(nil, _), do: false
1445
1446 def muted_notifications?(%User{} = user, %User{} = target),
1447 do: UserRelationship.notification_mute_exists?(user, target)
1448
1449 def blocks?(nil, _), do: false
1450
1451 def blocks?(%User{} = user, %User{} = target) do
1452 blocks_user?(user, target) ||
1453 (blocks_domain?(user, target) and not User.following?(user, target))
1454 end
1455
1456 def blocks_user?(%User{} = user, %User{} = target) do
1457 UserRelationship.block_exists?(user, target)
1458 end
1459
1460 def blocks_user?(_, _), do: false
1461
1462 def blocks_domain?(%User{} = user, %User{} = target) do
1463 domain_blocks = Pleroma.Web.ActivityPub.MRF.subdomains_regex(user.domain_blocks)
1464 %{host: host} = URI.parse(target.ap_id)
1465 Pleroma.Web.ActivityPub.MRF.subdomain_match?(domain_blocks, host)
1466 end
1467
1468 def blocks_domain?(_, _), do: false
1469
1470 def subscribed_to?(%User{} = user, %User{} = target) do
1471 # Note: the relationship is inverse: subscriber acts as relationship target
1472 UserRelationship.inverse_subscription_exists?(target, user)
1473 end
1474
1475 def subscribed_to?(%User{} = user, %{ap_id: ap_id}) do
1476 with %User{} = target <- get_cached_by_ap_id(ap_id) do
1477 subscribed_to?(user, target)
1478 end
1479 end
1480
1481 @doc """
1482 Returns map of outgoing (blocked, muted etc.) relationships' user AP IDs by relation type.
1483 E.g. `outgoing_relationships_ap_ids(user, [:block])` -> `%{block: ["https://some.site/users/userapid"]}`
1484 """
1485 @spec outgoing_relationships_ap_ids(User.t(), list(atom())) :: %{atom() => list(String.t())}
1486 def outgoing_relationships_ap_ids(_user, []), do: %{}
1487
1488 def outgoing_relationships_ap_ids(nil, _relationship_types), do: %{}
1489
1490 def outgoing_relationships_ap_ids(%User{} = user, relationship_types)
1491 when is_list(relationship_types) do
1492 db_result =
1493 user
1494 |> assoc(:outgoing_relationships)
1495 |> join(:inner, [user_rel], u in assoc(user_rel, :target))
1496 |> where([user_rel, u], user_rel.relationship_type in ^relationship_types)
1497 |> select([user_rel, u], [user_rel.relationship_type, fragment("array_agg(?)", u.ap_id)])
1498 |> group_by([user_rel, u], user_rel.relationship_type)
1499 |> Repo.all()
1500 |> Enum.into(%{}, fn [k, v] -> {k, v} end)
1501
1502 Enum.into(
1503 relationship_types,
1504 %{},
1505 fn rel_type -> {rel_type, db_result[rel_type] || []} end
1506 )
1507 end
1508
1509 def incoming_relationships_ungrouped_ap_ids(user, relationship_types, ap_ids \\ nil)
1510
1511 def incoming_relationships_ungrouped_ap_ids(_user, [], _ap_ids), do: []
1512
1513 def incoming_relationships_ungrouped_ap_ids(nil, _relationship_types, _ap_ids), do: []
1514
1515 def incoming_relationships_ungrouped_ap_ids(%User{} = user, relationship_types, ap_ids)
1516 when is_list(relationship_types) do
1517 user
1518 |> assoc(:incoming_relationships)
1519 |> join(:inner, [user_rel], u in assoc(user_rel, :source))
1520 |> where([user_rel, u], user_rel.relationship_type in ^relationship_types)
1521 |> maybe_filter_on_ap_id(ap_ids)
1522 |> select([user_rel, u], u.ap_id)
1523 |> distinct(true)
1524 |> Repo.all()
1525 end
1526
1527 defp maybe_filter_on_ap_id(query, ap_ids) when is_list(ap_ids) do
1528 where(query, [user_rel, u], u.ap_id in ^ap_ids)
1529 end
1530
1531 defp maybe_filter_on_ap_id(query, _ap_ids), do: query
1532
1533 def deactivate_async(user, status \\ true) do
1534 BackgroundWorker.enqueue("deactivate_user", %{"user_id" => user.id, "status" => status})
1535 end
1536
1537 def deactivate(user, status \\ true)
1538
1539 def deactivate(users, status) when is_list(users) do
1540 Repo.transaction(fn ->
1541 for user <- users, do: deactivate(user, status)
1542 end)
1543 end
1544
1545 def deactivate(%User{} = user, status) do
1546 with {:ok, user} <- set_activation_status(user, status) do
1547 user
1548 |> get_followers()
1549 |> Enum.filter(& &1.local)
1550 |> Enum.each(&set_cache(update_following_count(&1)))
1551
1552 # Only update local user counts, remote will be update during the next pull.
1553 user
1554 |> get_friends()
1555 |> Enum.filter(& &1.local)
1556 |> Enum.each(&do_unfollow(user, &1))
1557
1558 {:ok, user}
1559 end
1560 end
1561
1562 def approve(users) when is_list(users) do
1563 Repo.transaction(fn ->
1564 Enum.map(users, fn user ->
1565 with {:ok, user} <- approve(user), do: user
1566 end)
1567 end)
1568 end
1569
1570 def approve(%User{} = user) do
1571 change(user, approval_pending: false)
1572 |> update_and_set_cache()
1573 end
1574
1575 def update_notification_settings(%User{} = user, settings) do
1576 user
1577 |> cast(%{notification_settings: settings}, [])
1578 |> cast_embed(:notification_settings)
1579 |> validate_required([:notification_settings])
1580 |> update_and_set_cache()
1581 end
1582
1583 @spec purge_user_changeset(User.t()) :: Changeset.t()
1584 def purge_user_changeset(user) do
1585 # "Right to be forgotten"
1586 # https://gdpr.eu/right-to-be-forgotten/
1587 change(user, %{
1588 bio: "",
1589 raw_bio: nil,
1590 email: nil,
1591 name: nil,
1592 password_hash: nil,
1593 keys: nil,
1594 public_key: nil,
1595 avatar: %{},
1596 tags: [],
1597 last_refreshed_at: nil,
1598 last_digest_emailed_at: nil,
1599 banner: %{},
1600 background: %{},
1601 note_count: 0,
1602 follower_count: 0,
1603 following_count: 0,
1604 is_locked: false,
1605 confirmation_pending: false,
1606 password_reset_pending: false,
1607 approval_pending: false,
1608 registration_reason: nil,
1609 confirmation_token: nil,
1610 domain_blocks: [],
1611 deactivated: true,
1612 ap_enabled: false,
1613 is_moderator: false,
1614 is_admin: false,
1615 mastofe_settings: nil,
1616 mascot: nil,
1617 emoji: %{},
1618 pleroma_settings_store: %{},
1619 fields: [],
1620 raw_fields: [],
1621 is_discoverable: false,
1622 also_known_as: []
1623 })
1624 end
1625
1626 def delete(users) when is_list(users) do
1627 for user <- users, do: delete(user)
1628 end
1629
1630 def delete(%User{} = user) do
1631 BackgroundWorker.enqueue("delete_user", %{"user_id" => user.id})
1632 end
1633
1634 defp delete_and_invalidate_cache(%User{} = user) do
1635 invalidate_cache(user)
1636 Repo.delete(user)
1637 end
1638
1639 defp delete_or_deactivate(%User{local: false} = user), do: delete_and_invalidate_cache(user)
1640
1641 defp delete_or_deactivate(%User{local: true} = user) do
1642 status = account_status(user)
1643
1644 case status do
1645 :confirmation_pending ->
1646 delete_and_invalidate_cache(user)
1647
1648 :approval_pending ->
1649 delete_and_invalidate_cache(user)
1650
1651 _ ->
1652 user
1653 |> purge_user_changeset()
1654 |> update_and_set_cache()
1655 end
1656 end
1657
1658 def perform(:force_password_reset, user), do: force_password_reset(user)
1659
1660 @spec perform(atom(), User.t()) :: {:ok, User.t()}
1661 def perform(:delete, %User{} = user) do
1662 # Remove all relationships
1663 user
1664 |> get_followers()
1665 |> Enum.each(fn follower ->
1666 ActivityPub.unfollow(follower, user)
1667 unfollow(follower, user)
1668 end)
1669
1670 user
1671 |> get_friends()
1672 |> Enum.each(fn followed ->
1673 ActivityPub.unfollow(user, followed)
1674 unfollow(user, followed)
1675 end)
1676
1677 delete_user_activities(user)
1678 delete_notifications_from_user_activities(user)
1679
1680 delete_outgoing_pending_follow_requests(user)
1681
1682 delete_or_deactivate(user)
1683 end
1684
1685 def perform(:deactivate_async, user, status), do: deactivate(user, status)
1686
1687 @spec external_users_query() :: Ecto.Query.t()
1688 def external_users_query do
1689 User.Query.build(%{
1690 external: true,
1691 active: true,
1692 order_by: :id
1693 })
1694 end
1695
1696 @spec external_users(keyword()) :: [User.t()]
1697 def external_users(opts \\ []) do
1698 query =
1699 external_users_query()
1700 |> select([u], struct(u, [:id, :ap_id]))
1701
1702 query =
1703 if opts[:max_id],
1704 do: where(query, [u], u.id > ^opts[:max_id]),
1705 else: query
1706
1707 query =
1708 if opts[:limit],
1709 do: limit(query, ^opts[:limit]),
1710 else: query
1711
1712 Repo.all(query)
1713 end
1714
1715 def delete_notifications_from_user_activities(%User{ap_id: ap_id}) do
1716 Notification
1717 |> join(:inner, [n], activity in assoc(n, :activity))
1718 |> where([n, a], fragment("? = ?", a.actor, ^ap_id))
1719 |> Repo.delete_all()
1720 end
1721
1722 def delete_user_activities(%User{ap_id: ap_id} = user) do
1723 ap_id
1724 |> Activity.Queries.by_actor()
1725 |> Repo.chunk_stream(50, :batches)
1726 |> Stream.each(fn activities ->
1727 Enum.each(activities, fn activity -> delete_activity(activity, user) end)
1728 end)
1729 |> Stream.run()
1730 end
1731
1732 defp delete_activity(%{data: %{"type" => "Create", "object" => object}} = activity, user) do
1733 with {_, %Object{}} <- {:find_object, Object.get_by_ap_id(object)},
1734 {:ok, delete_data, _} <- Builder.delete(user, object) do
1735 Pipeline.common_pipeline(delete_data, local: user.local)
1736 else
1737 {:find_object, nil} ->
1738 # We have the create activity, but not the object, it was probably pruned.
1739 # Insert a tombstone and try again
1740 with {:ok, tombstone_data, _} <- Builder.tombstone(user.ap_id, object),
1741 {:ok, _tombstone} <- Object.create(tombstone_data) do
1742 delete_activity(activity, user)
1743 end
1744
1745 e ->
1746 Logger.error("Could not delete #{object} created by #{activity.data["ap_id"]}")
1747 Logger.error("Error: #{inspect(e)}")
1748 end
1749 end
1750
1751 defp delete_activity(%{data: %{"type" => type}} = activity, user)
1752 when type in ["Like", "Announce"] do
1753 {:ok, undo, _} = Builder.undo(user, activity)
1754 Pipeline.common_pipeline(undo, local: user.local)
1755 end
1756
1757 defp delete_activity(_activity, _user), do: "Doing nothing"
1758
1759 defp delete_outgoing_pending_follow_requests(user) do
1760 user
1761 |> FollowingRelationship.outgoing_pending_follow_requests_query()
1762 |> Repo.delete_all()
1763 end
1764
1765 def html_filter_policy(%User{no_rich_text: true}) do
1766 Pleroma.HTML.Scrubber.TwitterText
1767 end
1768
1769 def html_filter_policy(_), do: Config.get([:markup, :scrub_policy])
1770
1771 def fetch_by_ap_id(ap_id, opts \\ []), do: ActivityPub.make_user_from_ap_id(ap_id, opts)
1772
1773 def get_or_fetch_by_ap_id(ap_id, opts \\ []) do
1774 cached_user = get_cached_by_ap_id(ap_id)
1775
1776 maybe_fetched_user = needs_update?(cached_user) && fetch_by_ap_id(ap_id, opts)
1777
1778 case {cached_user, maybe_fetched_user} do
1779 {_, {:ok, %User{} = user}} ->
1780 {:ok, user}
1781
1782 {%User{} = user, _} ->
1783 {:ok, user}
1784
1785 _ ->
1786 {:error, :not_found}
1787 end
1788 end
1789
1790 @doc """
1791 Creates an internal service actor by URI if missing.
1792 Optionally takes nickname for addressing.
1793 """
1794 @spec get_or_create_service_actor_by_ap_id(String.t(), String.t()) :: User.t() | nil
1795 def get_or_create_service_actor_by_ap_id(uri, nickname) do
1796 {_, user} =
1797 case get_cached_by_ap_id(uri) do
1798 nil ->
1799 with {:error, %{errors: errors}} <- create_service_actor(uri, nickname) do
1800 Logger.error("Cannot create service actor: #{uri}/.\n#{inspect(errors)}")
1801 {:error, nil}
1802 end
1803
1804 %User{invisible: false} = user ->
1805 set_invisible(user)
1806
1807 user ->
1808 {:ok, user}
1809 end
1810
1811 user
1812 end
1813
1814 @spec set_invisible(User.t()) :: {:ok, User.t()}
1815 defp set_invisible(user) do
1816 user
1817 |> change(%{invisible: true})
1818 |> update_and_set_cache()
1819 end
1820
1821 @spec create_service_actor(String.t(), String.t()) ::
1822 {:ok, User.t()} | {:error, Ecto.Changeset.t()}
1823 defp create_service_actor(uri, nickname) do
1824 %User{
1825 invisible: true,
1826 local: true,
1827 ap_id: uri,
1828 nickname: nickname,
1829 follower_address: uri <> "/followers"
1830 }
1831 |> change
1832 |> unique_constraint(:nickname)
1833 |> Repo.insert()
1834 |> set_cache()
1835 end
1836
1837 def public_key(%{public_key: public_key_pem}) when is_binary(public_key_pem) do
1838 key =
1839 public_key_pem
1840 |> :public_key.pem_decode()
1841 |> hd()
1842 |> :public_key.pem_entry_decode()
1843
1844 {:ok, key}
1845 end
1846
1847 def public_key(_), do: {:error, "key not found"}
1848
1849 def get_public_key_for_ap_id(ap_id, opts \\ []) do
1850 with {:ok, %User{} = user} <- get_or_fetch_by_ap_id(ap_id, opts),
1851 {:ok, public_key} <- public_key(user) do
1852 {:ok, public_key}
1853 else
1854 _ -> :error
1855 end
1856 end
1857
1858 def ap_enabled?(%User{local: true}), do: true
1859 def ap_enabled?(%User{ap_enabled: ap_enabled}), do: ap_enabled
1860 def ap_enabled?(_), do: false
1861
1862 @doc "Gets or fetch a user by uri or nickname."
1863 @spec get_or_fetch(String.t()) :: {:ok, User.t()} | {:error, String.t()}
1864 def get_or_fetch("http" <> _host = uri), do: get_or_fetch_by_ap_id(uri)
1865 def get_or_fetch(nickname), do: get_or_fetch_by_nickname(nickname)
1866
1867 # wait a period of time and return newest version of the User structs
1868 # this is because we have synchronous follow APIs and need to simulate them
1869 # with an async handshake
1870 def wait_and_refresh(_, %User{local: true} = a, %User{local: true} = b) do
1871 with %User{} = a <- get_cached_by_id(a.id),
1872 %User{} = b <- get_cached_by_id(b.id) do
1873 {:ok, a, b}
1874 else
1875 nil -> :error
1876 end
1877 end
1878
1879 def wait_and_refresh(timeout, %User{} = a, %User{} = b) do
1880 with :ok <- :timer.sleep(timeout),
1881 %User{} = a <- get_cached_by_id(a.id),
1882 %User{} = b <- get_cached_by_id(b.id) do
1883 {:ok, a, b}
1884 else
1885 nil -> :error
1886 end
1887 end
1888
1889 def parse_bio(bio) when is_binary(bio) and bio != "" do
1890 bio
1891 |> CommonUtils.format_input("text/plain", mentions_format: :full)
1892 |> elem(0)
1893 end
1894
1895 def parse_bio(_), do: ""
1896
1897 def parse_bio(bio, user) when is_binary(bio) and bio != "" do
1898 # TODO: get profile URLs other than user.ap_id
1899 profile_urls = [user.ap_id]
1900
1901 bio
1902 |> CommonUtils.format_input("text/plain",
1903 mentions_format: :full,
1904 rel: &RelMe.maybe_put_rel_me(&1, profile_urls)
1905 )
1906 |> elem(0)
1907 end
1908
1909 def parse_bio(_, _), do: ""
1910
1911 def tag(user_identifiers, tags) when is_list(user_identifiers) do
1912 Repo.transaction(fn ->
1913 for user_identifier <- user_identifiers, do: tag(user_identifier, tags)
1914 end)
1915 end
1916
1917 def tag(nickname, tags) when is_binary(nickname),
1918 do: tag(get_by_nickname(nickname), tags)
1919
1920 def tag(%User{} = user, tags),
1921 do: update_tags(user, Enum.uniq((user.tags || []) ++ normalize_tags(tags)))
1922
1923 def untag(user_identifiers, tags) when is_list(user_identifiers) do
1924 Repo.transaction(fn ->
1925 for user_identifier <- user_identifiers, do: untag(user_identifier, tags)
1926 end)
1927 end
1928
1929 def untag(nickname, tags) when is_binary(nickname),
1930 do: untag(get_by_nickname(nickname), tags)
1931
1932 def untag(%User{} = user, tags),
1933 do: update_tags(user, (user.tags || []) -- normalize_tags(tags))
1934
1935 defp update_tags(%User{} = user, new_tags) do
1936 {:ok, updated_user} =
1937 user
1938 |> change(%{tags: new_tags})
1939 |> update_and_set_cache()
1940
1941 updated_user
1942 end
1943
1944 defp normalize_tags(tags) do
1945 [tags]
1946 |> List.flatten()
1947 |> Enum.map(&String.downcase/1)
1948 end
1949
1950 defp local_nickname_regex do
1951 if Config.get([:instance, :extended_nickname_format]) do
1952 @extended_local_nickname_regex
1953 else
1954 @strict_local_nickname_regex
1955 end
1956 end
1957
1958 def local_nickname(nickname_or_mention) do
1959 nickname_or_mention
1960 |> full_nickname()
1961 |> String.split("@")
1962 |> hd()
1963 end
1964
1965 def full_nickname(nickname_or_mention),
1966 do: String.trim_leading(nickname_or_mention, "@")
1967
1968 def error_user(ap_id) do
1969 %User{
1970 name: ap_id,
1971 ap_id: ap_id,
1972 nickname: "erroruser@example.com",
1973 inserted_at: NaiveDateTime.utc_now()
1974 }
1975 end
1976
1977 @spec all_superusers() :: [User.t()]
1978 def all_superusers do
1979 User.Query.build(%{super_users: true, local: true, deactivated: false})
1980 |> Repo.all()
1981 end
1982
1983 def muting_reblogs?(%User{} = user, %User{} = target) do
1984 UserRelationship.reblog_mute_exists?(user, target)
1985 end
1986
1987 def showing_reblogs?(%User{} = user, %User{} = target) do
1988 not muting_reblogs?(user, target)
1989 end
1990
1991 @doc """
1992 The function returns a query to get users with no activity for given interval of days.
1993 Inactive users are those who didn't read any notification, or had any activity where
1994 the user is the activity's actor, during `inactivity_threshold` days.
1995 Deactivated users will not appear in this list.
1996
1997 ## Examples
1998
1999 iex> Pleroma.User.list_inactive_users()
2000 %Ecto.Query{}
2001 """
2002 @spec list_inactive_users_query(integer()) :: Ecto.Query.t()
2003 def list_inactive_users_query(inactivity_threshold \\ 7) do
2004 negative_inactivity_threshold = -inactivity_threshold
2005 now = NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
2006 # Subqueries are not supported in `where` clauses, join gets too complicated.
2007 has_read_notifications =
2008 from(n in Pleroma.Notification,
2009 where: n.seen == true,
2010 group_by: n.id,
2011 having: max(n.updated_at) > datetime_add(^now, ^negative_inactivity_threshold, "day"),
2012 select: n.user_id
2013 )
2014 |> Pleroma.Repo.all()
2015
2016 from(u in Pleroma.User,
2017 left_join: a in Pleroma.Activity,
2018 on: u.ap_id == a.actor,
2019 where: not is_nil(u.nickname),
2020 where: u.deactivated != ^true,
2021 where: u.id not in ^has_read_notifications,
2022 group_by: u.id,
2023 having:
2024 max(a.inserted_at) < datetime_add(^now, ^negative_inactivity_threshold, "day") or
2025 is_nil(max(a.inserted_at))
2026 )
2027 end
2028
2029 @doc """
2030 Enable or disable email notifications for user
2031
2032 ## Examples
2033
2034 iex> Pleroma.User.switch_email_notifications(Pleroma.User{email_notifications: %{"digest" => false}}, "digest", true)
2035 Pleroma.User{email_notifications: %{"digest" => true}}
2036
2037 iex> Pleroma.User.switch_email_notifications(Pleroma.User{email_notifications: %{"digest" => true}}, "digest", false)
2038 Pleroma.User{email_notifications: %{"digest" => false}}
2039 """
2040 @spec switch_email_notifications(t(), String.t(), boolean()) ::
2041 {:ok, t()} | {:error, Ecto.Changeset.t()}
2042 def switch_email_notifications(user, type, status) do
2043 User.update_email_notifications(user, %{type => status})
2044 end
2045
2046 @doc """
2047 Set `last_digest_emailed_at` value for the user to current time
2048 """
2049 @spec touch_last_digest_emailed_at(t()) :: t()
2050 def touch_last_digest_emailed_at(user) do
2051 now = NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
2052
2053 {:ok, updated_user} =
2054 user
2055 |> change(%{last_digest_emailed_at: now})
2056 |> update_and_set_cache()
2057
2058 updated_user
2059 end
2060
2061 @spec toggle_confirmation(User.t()) :: {:ok, User.t()} | {:error, Changeset.t()}
2062 def toggle_confirmation(%User{} = user) do
2063 user
2064 |> confirmation_changeset(need_confirmation: !user.confirmation_pending)
2065 |> update_and_set_cache()
2066 end
2067
2068 @spec toggle_confirmation([User.t()]) :: [{:ok, User.t()} | {:error, Changeset.t()}]
2069 def toggle_confirmation(users) do
2070 Enum.map(users, &toggle_confirmation/1)
2071 end
2072
2073 @spec need_confirmation(User.t(), boolean()) :: {:ok, User.t()} | {:error, Changeset.t()}
2074 def need_confirmation(%User{} = user, bool) do
2075 user
2076 |> confirmation_changeset(need_confirmation: bool)
2077 |> update_and_set_cache()
2078 end
2079
2080 def get_mascot(%{mascot: %{} = mascot}) when not is_nil(mascot) do
2081 mascot
2082 end
2083
2084 def get_mascot(%{mascot: mascot}) when is_nil(mascot) do
2085 # use instance-default
2086 config = Config.get([:assets, :mascots])
2087 default_mascot = Config.get([:assets, :default_mascot])
2088 mascot = Keyword.get(config, default_mascot)
2089
2090 %{
2091 "id" => "default-mascot",
2092 "url" => mascot[:url],
2093 "preview_url" => mascot[:url],
2094 "pleroma" => %{
2095 "mime_type" => mascot[:mime_type]
2096 }
2097 }
2098 end
2099
2100 def ensure_keys_present(%{keys: keys} = user) when not is_nil(keys), do: {:ok, user}
2101
2102 def ensure_keys_present(%User{} = user) do
2103 with {:ok, pem} <- Keys.generate_rsa_pem() do
2104 user
2105 |> cast(%{keys: pem}, [:keys])
2106 |> validate_required([:keys])
2107 |> update_and_set_cache()
2108 end
2109 end
2110
2111 def get_ap_ids_by_nicknames(nicknames) do
2112 from(u in User,
2113 where: u.nickname in ^nicknames,
2114 select: u.ap_id
2115 )
2116 |> Repo.all()
2117 end
2118
2119 defp put_password_hash(
2120 %Ecto.Changeset{valid?: true, changes: %{password: password}} = changeset
2121 ) do
2122 change(changeset, password_hash: Pbkdf2.hash_pwd_salt(password))
2123 end
2124
2125 defp put_password_hash(changeset), do: changeset
2126
2127 def is_internal_user?(%User{nickname: nil}), do: true
2128 def is_internal_user?(%User{local: true, nickname: "internal." <> _}), do: true
2129 def is_internal_user?(_), do: false
2130
2131 # A hack because user delete activities have a fake id for whatever reason
2132 # TODO: Get rid of this
2133 def get_delivered_users_by_object_id("pleroma:fake_object_id"), do: []
2134
2135 def get_delivered_users_by_object_id(object_id) do
2136 from(u in User,
2137 inner_join: delivery in assoc(u, :deliveries),
2138 where: delivery.object_id == ^object_id
2139 )
2140 |> Repo.all()
2141 end
2142
2143 def change_email(user, email) do
2144 user
2145 |> cast(%{email: email}, [:email])
2146 |> validate_required([:email])
2147 |> unique_constraint(:email)
2148 |> validate_format(:email, @email_regex)
2149 |> update_and_set_cache()
2150 end
2151
2152 # Internal function; public one is `deactivate/2`
2153 defp set_activation_status(user, deactivated) do
2154 user
2155 |> cast(%{deactivated: deactivated}, [:deactivated])
2156 |> update_and_set_cache()
2157 end
2158
2159 def update_banner(user, banner) do
2160 user
2161 |> cast(%{banner: banner}, [:banner])
2162 |> update_and_set_cache()
2163 end
2164
2165 def update_background(user, background) do
2166 user
2167 |> cast(%{background: background}, [:background])
2168 |> update_and_set_cache()
2169 end
2170
2171 def roles(%{is_moderator: is_moderator, is_admin: is_admin}) do
2172 %{
2173 admin: is_admin,
2174 moderator: is_moderator
2175 }
2176 end
2177
2178 def validate_fields(changeset, remote? \\ false) do
2179 limit_name = if remote?, do: :max_remote_account_fields, else: :max_account_fields
2180 limit = Config.get([:instance, limit_name], 0)
2181
2182 changeset
2183 |> validate_length(:fields, max: limit)
2184 |> validate_change(:fields, fn :fields, fields ->
2185 if Enum.all?(fields, &valid_field?/1) do
2186 []
2187 else
2188 [fields: "invalid"]
2189 end
2190 end)
2191 end
2192
2193 defp valid_field?(%{"name" => name, "value" => value}) do
2194 name_limit = Config.get([:instance, :account_field_name_length], 255)
2195 value_limit = Config.get([:instance, :account_field_value_length], 255)
2196
2197 is_binary(name) && is_binary(value) && String.length(name) <= name_limit &&
2198 String.length(value) <= value_limit
2199 end
2200
2201 defp valid_field?(_), do: false
2202
2203 defp truncate_field(%{"name" => name, "value" => value}) do
2204 {name, _chopped} =
2205 String.split_at(name, Config.get([:instance, :account_field_name_length], 255))
2206
2207 {value, _chopped} =
2208 String.split_at(value, Config.get([:instance, :account_field_value_length], 255))
2209
2210 %{"name" => name, "value" => value}
2211 end
2212
2213 def admin_api_update(user, params) do
2214 user
2215 |> cast(params, [
2216 :is_moderator,
2217 :is_admin,
2218 :show_role
2219 ])
2220 |> update_and_set_cache()
2221 end
2222
2223 @doc "Signs user out of all applications"
2224 def global_sign_out(user) do
2225 OAuth.Authorization.delete_user_authorizations(user)
2226 OAuth.Token.delete_user_tokens(user)
2227 end
2228
2229 def mascot_update(user, url) do
2230 user
2231 |> cast(%{mascot: url}, [:mascot])
2232 |> validate_required([:mascot])
2233 |> update_and_set_cache()
2234 end
2235
2236 def mastodon_settings_update(user, settings) do
2237 user
2238 |> cast(%{mastofe_settings: settings}, [:mastofe_settings])
2239 |> validate_required([:mastofe_settings])
2240 |> update_and_set_cache()
2241 end
2242
2243 @spec confirmation_changeset(User.t(), keyword()) :: Changeset.t()
2244 def confirmation_changeset(user, need_confirmation: need_confirmation?) do
2245 params =
2246 if need_confirmation? do
2247 %{
2248 confirmation_pending: true,
2249 confirmation_token: :crypto.strong_rand_bytes(32) |> Base.url_encode64()
2250 }
2251 else
2252 %{
2253 confirmation_pending: false,
2254 confirmation_token: nil
2255 }
2256 end
2257
2258 cast(user, params, [:confirmation_pending, :confirmation_token])
2259 end
2260
2261 @spec approval_changeset(User.t(), keyword()) :: Changeset.t()
2262 def approval_changeset(user, need_approval: need_approval?) do
2263 params = if need_approval?, do: %{approval_pending: true}, else: %{approval_pending: false}
2264 cast(user, params, [:approval_pending])
2265 end
2266
2267 def add_pinnned_activity(user, %Pleroma.Activity{id: id}) do
2268 if id not in user.pinned_activities do
2269 max_pinned_statuses = Config.get([:instance, :max_pinned_statuses], 0)
2270 params = %{pinned_activities: user.pinned_activities ++ [id]}
2271
2272 # if pinned activity was scheduled for deletion, we remove job
2273 if expiration = Pleroma.Workers.PurgeExpiredActivity.get_expiration(id) do
2274 Oban.cancel_job(expiration.id)
2275 end
2276
2277 user
2278 |> cast(params, [:pinned_activities])
2279 |> validate_length(:pinned_activities,
2280 max: max_pinned_statuses,
2281 message: "You have already pinned the maximum number of statuses"
2282 )
2283 else
2284 change(user)
2285 end
2286 |> update_and_set_cache()
2287 end
2288
2289 def remove_pinnned_activity(user, %Pleroma.Activity{id: id, data: data}) do
2290 params = %{pinned_activities: List.delete(user.pinned_activities, id)}
2291
2292 # if pinned activity was scheduled for deletion, we reschedule it for deletion
2293 if data["expires_at"] do
2294 # MRF.ActivityExpirationPolicy used UTC timestamps for expires_at in original implementation
2295 {:ok, expires_at} =
2296 data["expires_at"] |> Pleroma.EctoType.ActivityPub.ObjectValidators.DateTime.cast()
2297
2298 Pleroma.Workers.PurgeExpiredActivity.enqueue(%{
2299 activity_id: id,
2300 expires_at: expires_at
2301 })
2302 end
2303
2304 user
2305 |> cast(params, [:pinned_activities])
2306 |> update_and_set_cache()
2307 end
2308
2309 def update_email_notifications(user, settings) do
2310 email_notifications =
2311 user.email_notifications
2312 |> Map.merge(settings)
2313 |> Map.take(["digest"])
2314
2315 params = %{email_notifications: email_notifications}
2316 fields = [:email_notifications]
2317
2318 user
2319 |> cast(params, fields)
2320 |> validate_required(fields)
2321 |> update_and_set_cache()
2322 end
2323
2324 defp set_domain_blocks(user, domain_blocks) do
2325 params = %{domain_blocks: domain_blocks}
2326
2327 user
2328 |> cast(params, [:domain_blocks])
2329 |> validate_required([:domain_blocks])
2330 |> update_and_set_cache()
2331 end
2332
2333 def block_domain(user, domain_blocked) do
2334 set_domain_blocks(user, Enum.uniq([domain_blocked | user.domain_blocks]))
2335 end
2336
2337 def unblock_domain(user, domain_blocked) do
2338 set_domain_blocks(user, List.delete(user.domain_blocks, domain_blocked))
2339 end
2340
2341 @spec add_to_block(User.t(), User.t()) ::
2342 {:ok, UserRelationship.t()} | {:error, Ecto.Changeset.t()}
2343 defp add_to_block(%User{} = user, %User{} = blocked) do
2344 UserRelationship.create_block(user, blocked)
2345 end
2346
2347 @spec add_to_block(User.t(), User.t()) ::
2348 {:ok, UserRelationship.t()} | {:ok, nil} | {:error, Ecto.Changeset.t()}
2349 defp remove_from_block(%User{} = user, %User{} = blocked) do
2350 UserRelationship.delete_block(user, blocked)
2351 end
2352
2353 defp add_to_mutes(%User{} = user, %User{} = muted_user, notifications?) do
2354 with {:ok, user_mute} <- UserRelationship.create_mute(user, muted_user),
2355 {:ok, user_notification_mute} <-
2356 (notifications? && UserRelationship.create_notification_mute(user, muted_user)) ||
2357 {:ok, nil} do
2358 {:ok, Enum.filter([user_mute, user_notification_mute], & &1)}
2359 end
2360 end
2361
2362 defp remove_from_mutes(user, %User{} = muted_user) do
2363 with {:ok, user_mute} <- UserRelationship.delete_mute(user, muted_user),
2364 {:ok, user_notification_mute} <-
2365 UserRelationship.delete_notification_mute(user, muted_user) do
2366 {:ok, [user_mute, user_notification_mute]}
2367 end
2368 end
2369
2370 def set_invisible(user, invisible) do
2371 params = %{invisible: invisible}
2372
2373 user
2374 |> cast(params, [:invisible])
2375 |> validate_required([:invisible])
2376 |> update_and_set_cache()
2377 end
2378
2379 def sanitize_html(%User{} = user) do
2380 sanitize_html(user, nil)
2381 end
2382
2383 # User data that mastodon isn't filtering (treated as plaintext):
2384 # - field name
2385 # - display name
2386 def sanitize_html(%User{} = user, filter) do
2387 fields =
2388 Enum.map(user.fields, fn %{"name" => name, "value" => value} ->
2389 %{
2390 "name" => name,
2391 "value" => HTML.filter_tags(value, Pleroma.HTML.Scrubber.LinksOnly)
2392 }
2393 end)
2394
2395 user
2396 |> Map.put(:bio, HTML.filter_tags(user.bio, filter))
2397 |> Map.put(:fields, fields)
2398 end
2399 end