field(:is_moderator, :boolean, default: false)
field(:is_admin, :boolean, default: false)
field(:show_role, :boolean, default: true)
+ field(:mastofe_settings, :map, default: nil)
field(:uri, ObjectValidators.Uri, default: nil)
field(:hide_followers_count, :boolean, default: false)
field(:hide_follows_count, :boolean, default: false)
field(:also_known_as, {:array, ObjectValidators.ObjectID}, default: [])
field(:inbox, :string)
field(:shared_inbox, :string)
- field(:accepts_chat_messages, :boolean, default: nil)
field(:last_active_at, :naive_datetime)
field(:disclose_client, :boolean, default: true)
field(:pinned_objects, :map, default: %{})
field(:is_suggested, :boolean, default: false)
field(:last_status_at, :naive_datetime)
+ field(:language, :string)
embeds_one(
:notification_settings,
has_many(incoming_relation_source, through: [incoming_relation, :source])
end
- # `:blocks` is deprecated (replaced with `blocked_users` relation)
- field(:blocks, {:array, :string}, default: [])
- # `:mutes` is deprecated (replaced with `muted_users` relation)
- field(:mutes, {:array, :string}, default: [])
- # `:muted_reblogs` is deprecated (replaced with `reblog_muted_users` relation)
- field(:muted_reblogs, {:array, :string}, default: [])
- # `:muted_notifications` is deprecated (replaced with `notification_muted_users` relation)
- field(:muted_notifications, {:array, :string}, default: [])
- # `:subscribers` is deprecated (replaced with `subscriber_users` relation)
- field(:subscribers, {:array, :string}, default: [])
-
embeds_one(
:multi_factor_authentication_settings,
MFA.Settings,
:invisible,
:actor_type,
:also_known_as,
- :accepts_chat_messages,
:pinned_objects
]
)
:pleroma_settings_store,
:is_discoverable,
:actor_type,
- :accepts_chat_messages,
:disclose_client
]
)
@spec force_password_reset(User.t()) :: {:ok, User.t()} | {:error, Ecto.Changeset.t()}
def force_password_reset(user), do: update_password_reset_pending(user, true)
- # Used to auto-register LDAP accounts which won't have a password hash stored locally
- def register_changeset_ldap(struct, params = %{password: password})
- when is_nil(password) do
- params = Map.put_new(params, :accepts_chat_messages, true)
-
- params =
- if Map.has_key?(params, :email) do
- Map.put_new(params, :email, params[:email])
- else
- params
- end
-
- struct
- |> cast(params, [
- :name,
- :nickname,
- :email,
- :accepts_chat_messages
- ])
- |> validate_required([:name, :nickname])
- |> unique_constraint(:nickname)
- |> validate_exclusion(:nickname, Config.get([User, :restricted_nicknames]))
- |> validate_format(:nickname, local_nickname_regex())
- |> put_ap_id()
- |> unique_constraint(:ap_id)
- |> put_following_and_follower_and_featured_address()
- end
-
def register_changeset(struct, params \\ %{}, opts \\ []) do
bio_limit = Config.get([:instance, :user_bio_length], 5000)
name_limit = Config.get([:instance, :user_name_length], 100)
reason_limit = Config.get([:instance, :registration_reason_length], 500)
- params = Map.put_new(params, :accepts_chat_messages, true)
confirmed? =
if is_nil(opts[:confirmed]) do
:password,
:password_confirmation,
:emoji,
- :accepts_chat_messages,
- :registration_reason
+ :registration_reason,
+ :language
])
|> validate_required([:name, :nickname, :password, :password_confirmation])
|> validate_confirmation(:password)
{:ok, user} <- set_cache(user),
{:ok, _} <- maybe_send_registration_email(user),
{:ok, _} <- maybe_send_welcome_email(user),
- {:ok, _} <- maybe_send_welcome_message(user),
- {:ok, _} <- maybe_send_welcome_chat_message(user) do
+ {:ok, _} <- maybe_send_welcome_message(user) do
{:ok, user}
end
end
end
end
- defp maybe_send_welcome_chat_message(user) do
- if User.WelcomeChatMessage.enabled?() do
- User.WelcomeChatMessage.post_message(user)
- {:ok, :enqueued}
- else
- {:ok, :noop}
- end
- end
-
defp maybe_send_welcome_email(%User{email: email} = user) when is_binary(email) do
if User.WelcomeEmail.enabled?() do
User.WelcomeEmail.send_email(user)
|> update_and_set_cache()
end
- def update_and_set_cache(changeset) do
+ def update_and_set_cache(%{data: %Pleroma.User{} = user} = changeset) do
+ was_superuser_before_update = User.superuser?(user)
+
with {:ok, user} <- Repo.update(changeset, stale_error_field: :id) do
set_cache(user)
end
+ |> maybe_remove_report_notifications(was_superuser_before_update)
+ end
+
+ defp maybe_remove_report_notifications({:ok, %Pleroma.User{} = user} = result, true) do
+ if not User.superuser?(user),
+ do: user |> Notification.destroy_multiple_from_types(["pleroma:report"])
+
+ result
+ end
+
+ defp maybe_remove_report_notifications(result, _) do
+ result
end
def get_user_friends_ap_ids(user) do
ap_enabled: false,
is_moderator: false,
is_admin: false,
+ mastofe_settings: nil,
mascot: nil,
emoji: %{},
pleroma_settings_store: %{},
|> update_and_set_cache()
end
+ def alias_users(user) do
+ user.also_known_as
+ |> Enum.map(&User.get_cached_by_ap_id/1)
+ |> Enum.filter(fn user -> user != nil end)
+ end
+
+ def add_alias(user, new_alias_user) do
+ current_aliases = user.also_known_as || []
+ new_alias_ap_id = new_alias_user.ap_id
+
+ if new_alias_ap_id in current_aliases do
+ {:ok, user}
+ else
+ user
+ |> cast(%{also_known_as: current_aliases ++ [new_alias_ap_id]}, [:also_known_as])
+ |> update_and_set_cache()
+ end
+ end
+
+ def delete_alias(user, alias_user) do
+ current_aliases = user.also_known_as || []
+ alias_ap_id = alias_user.ap_id
+
+ if alias_ap_id in current_aliases do
+ user
+ |> cast(%{also_known_as: current_aliases -- [alias_ap_id]}, [:also_known_as])
+ |> update_and_set_cache()
+ else
+ {:error, :no_such_alias}
+ end
+ end
+
# Internal function; public one is `deactivate/2`
defp set_activation_status(user, status) do
user
|> update_and_set_cache()
end
+ def mastodon_settings_update(user, settings) do
+ user
+ |> cast(%{mastofe_settings: settings}, [:mastofe_settings])
+ |> validate_required([:mastofe_settings])
+ |> update_and_set_cache()
+ end
+
@spec confirmation_changeset(User.t(), keyword()) :: Changeset.t()
def confirmation_changeset(user, set_confirmation: confirmed?) do
params =
projects / akkoma / blobdiff