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