A free and open source instant messaging and VoIP chat app built for friends, groups, and communities.
feat(admin): add account settings and inactive account deletion
Hampus147fcf686eab
diff --git a/fluxer_admin/src/routes/system_actions/accounts.rs b/fluxer_admin/src/routes/system_actions/accounts.rsnew file mode 100644index 000000000..964fa748b--- /dev/null+++ b/fluxer_admin/src/routes/system_actions/accounts.rs@@ -0,0 +1,119 @@+// SPDX-License-Identifier: AGPL-3.0-or-later++use super::{parse_choice, parse_form_number};+use crate::{+ api::types::{+ AccountsConfigUpdateRequest, AuthConfigUpdateRequest, CLEANUP_INACTIVE_DAYS_RANGE,+ DobMissingCleanupUpdateRequest, INACTIVITY_WARNING_LEAD_DAYS_RANGE,+ INSTANT_ACCOUNTS_ESCALATION_RANGE, InactivityDeletionUpdateRequest,+ InstanceConfigUpdateRequest, InstantAccountsConfigUpdateRequest,+ UnclaimedAccountCleanupUpdateRequest,+ },+ utils::forms::MultiValueForm,+};+use std::num::NonZeroU64;++fn parse_form_days(+ form: &MultiValueForm,+ key: &str,+ label: &str,+ range: &std::ops::RangeInclusive<u32>,+) -> Result<Option<NonZeroU64>, String> {+ Ok(+ parse_form_number(form, key, label, *range.start(), *range.end())?+ .and_then(|days| NonZeroU64::new(u64::from(days))),+ )+}++pub(super) fn build_accounts_update(+ form: &MultiValueForm,+) -> Result<InstanceConfigUpdateRequest, String> {+ let unclaimed = UnclaimedAccountCleanupUpdateRequest {+ mode: parse_choice(+ form,+ "accounts_unclaimed_cleanup_mode",+ "Accounts with no way back in",+ )?,+ inactive_days: parse_form_days(+ form,+ "accounts_unclaimed_cleanup_inactive_days",+ "Days without use",+ &CLEANUP_INACTIVE_DAYS_RANGE,+ )?,+ on_last_session_end: parse_choice(+ form,+ "accounts_unclaimed_cleanup_on_last_session_end",+ "After the last sign-out",+ )?,+ };+ let dob_missing = DobMissingCleanupUpdateRequest {+ mode: parse_choice(+ form,+ "accounts_dob_missing_cleanup_mode",+ "Accounts that never gave a date of birth",+ )?,+ inactive_days: parse_form_days(+ form,+ "accounts_dob_missing_cleanup_inactive_days",+ "Days without use",+ &CLEANUP_INACTIVE_DAYS_RANGE,+ )?,+ };+ let inactivity = InactivityDeletionUpdateRequest {+ mode: parse_choice(+ form,+ "accounts_inactivity_deletion_mode",+ "Inactive accounts",+ )?,+ inactive_days: parse_form_days(+ form,+ "accounts_inactivity_deletion_inactive_days",+ "Days without use",+ &CLEANUP_INACTIVE_DAYS_RANGE,+ )?,+ warning_lead_days: parse_form_days(+ form,+ "accounts_inactivity_deletion_warning_lead_days",+ "Days between warning and deletion",+ &INACTIVITY_WARNING_LEAD_DAYS_RANGE,+ )?,+ };+ Ok(InstanceConfigUpdateRequest {+ auth: Some(AuthConfigUpdateRequest {+ identifier_first: parse_choice(form, "auth_identifier_first", "Start sign-in")?,+ instant_accounts: Some(InstantAccountsConfigUpdateRequest {+ enabled: Some(form.bool_value("auth_instant_accounts_enabled")),+ pow_escalation_per_hour: parse_form_number(+ form,+ "auth_instant_accounts_pow_escalation_per_hour",+ "Accounts per hour",+ *INSTANT_ACCOUNTS_ESCALATION_RANGE.start(),+ *INSTANT_ACCOUNTS_ESCALATION_RANGE.end(),+ )?,+ }),+ }),+ accounts: Some(AccountsConfigUpdateRequest {+ date_of_birth: parse_choice(form, "accounts_date_of_birth", "Date of birth")?,+ interaction_tier: parse_choice(form, "accounts_interaction_tier", "Account limits")?,+ verification_basis: parse_choice(+ form,+ "accounts_verification_basis",+ "What finishes setting up an account",+ )?,+ guild_join_gate: parse_choice(form, "accounts_guild_join_gate", "Joining a community")?,+ unclaimed_account_cleanup: (unclaimed.mode.is_some()+ || unclaimed.inactive_days.is_some()+ || unclaimed.on_last_session_end.is_some())+ .then_some(unclaimed),+ dob_missing_cleanup: (dob_missing.mode.is_some()+ || dob_missing.inactive_days.is_some())+ .then_some(dob_missing),+ inactivity_deletion: (inactivity.mode.is_some()+ || inactivity.inactive_days.is_some()+ || inactivity.warning_lead_days.is_some())+ .then_some(inactivity),+ ..Default::default()+ }),+ ..Default::default()+ })+}diff --git a/fluxer_admin/src/templates/pages/instance_config/accounts.rs b/fluxer_admin/src/templates/pages/instance_config/accounts.rsnew file mode 100644index 000000000..05cfa7f7a--- /dev/null+++ b/fluxer_admin/src/templates/pages/instance_config/accounts.rs@@ -0,0 +1,435 @@+// SPDX-License-Identifier: AGPL-3.0-or-later++use super::{+ CLEANUP_MODE_CHOICES, DATE_OF_BIRTH_CHOICES, GUILD_JOIN_GATE_CHOICES, IDENTIFIER_FIRST_CHOICES,+ INTERACTION_TIER_CHOICES, LAST_SESSION_CLEANUP_CHOICES, VERIFICATION_BASIS_CHOICES,+ choice_select,+};+use crate::templates::pages::instance_config::ConfigForm;+use crate::{+ api::types::{+ AccountIdentityConfigResponse, AccountIdentityLockReason, AccountIdentityMode,+ AccountIdentitySettings, AccountsConfigResponse, AuthConfigResponse,+ CLEANUP_INACTIVE_DAYS_RANGE, CaptchaProvider, CleanupMode, DateOfBirthPolicy,+ EmailDeliveryState, GuildJoinGate, INACTIVITY_WARNING_LEAD_DAYS_RANGE,+ INSTANT_ACCOUNTS_ESCALATION_RANGE, InstantAccountAvailability, InteractionTierMode,+ SCHEDULED_DELETION_GRACE_HOURS, TagStyle, VerificationBasis,+ },+ templates::components::{+ badge::{BadgeVariant, badge},+ form::{Checkbox, NumberField, form_actions, submit_button},+ section_card::section_card_with_description,+ },+};+use maud::{Markup, html};++pub(super) fn account_identity_section(account_identity: &AccountIdentityConfigResponse) -> Markup {+ let description = match account_identity.mode {+ AccountIdentityMode::Username => {+ "Members sign in with a username and password. The instance never collects an email \+ address. A member who forgets their password uses their recovery kit or a reset link \+ from an admin."+ }+ AccountIdentityMode::Email => "Members sign in with an email address and password.",+ };+ section_card_with_description(+ "Sign-in Method",+ "How members identify themselves when they sign in.",+ html! {+ div class="space-y-3" {+ div class="flex flex-wrap items-center gap-2" {+ h3 class="text-sm font-semibold text-neutral-900" {+ (account_identity.mode.label())+ }+ @if account_identity.locked {+ (badge("Fixed", BadgeVariant::Default))+ } @else {+ (badge("Not fixed yet", BadgeVariant::Warning))+ }+ }+ p class="text-sm text-neutral-600" { (description) }+ @if let Some(reason) = account_identity.lock_reason {+ p class="text-sm text-neutral-600" {+ (match reason {+ AccountIdentityLockReason::SetupConfigured => "It is fixed because setup is finished.",+ AccountIdentityLockReason::ExistingInstance => {+ "It is fixed because this instance was in use before username sign-in existed, so it \+ stays on email."+ }+ AccountIdentityLockReason::AdminExists => {+ "It is fixed because an administrator account already exists."+ }+ AccountIdentityLockReason::AccountsExist => "It is fixed because accounts already exist.",+ })+ }+ }+ @if !account_identity.mode.is_username() {+ div class="flex flex-wrap items-center gap-2" {+ h3 class="text-sm font-semibold text-neutral-900" {+ (account_identity.tag_style.label())+ }+ }+ p class="text-sm text-neutral-600" {+ @match account_identity.tag_style {+ TagStyle::None => {+ "Each name belongs to one person and is shown without a tag."+ }+ TagStyle::Random => {+ "Names have a random tag, like alex#4821, so several people can share a name."+ }+ }+ }+ }+ p class="text-xs text-neutral-500" {+ @if account_identity.mode.is_username() {+ "The sign-in method is chosen during setup. It cannot be changed once setup is complete or the first account exists."+ } @else {+ "The sign-in method and the username tags are chosen during setup. They cannot be changed once setup is complete or the first account exists."+ }+ }+ }+ },+ )+}++#[derive(Clone, Copy, Debug, Eq, PartialEq)]+struct TierWording {+ missing: &'static str,+ step: &'static str,+}++const LOCAL_CREDENTIAL_WORDING: TierWording = TierWording {+ missing: "without a password or passkey",+ step: "set a password",+};++const CONFIRMED_EMAIL_WORDING: TierWording = TierWording {+ missing: "without a confirmed email",+ step: "add an email",+};++fn tier_wording(+ mode: AccountIdentityMode,+ basis: VerificationBasis,+ delivery_state: EmailDeliveryState,+) -> TierWording {+ let local_credential = mode.is_username()+ || match basis {+ VerificationBasis::Auto => delivery_state != EmailDeliveryState::On,+ VerificationBasis::ConfirmedEmail => false,+ VerificationBasis::LocalCredential => true,+ };+ if local_credential {+ LOCAL_CREDENTIAL_WORDING+ } else {+ CONFIRMED_EMAIL_WORDING+ }+}++fn way_back_in_wording(+ mode: AccountIdentityMode,+ delivery_state: EmailDeliveryState,+) -> &'static str {+ if mode.is_username() {+ "a password, a passkey or a recovery kit"+ } else if delivery_state == EmailDeliveryState::On {+ "a passkey or an email address"+ } else {+ "a passkey, or a password together with an email address"+ }+}++fn instant_account_inactive_reason(+ availability: InstantAccountAvailability,+) -> Option<&'static str> {+ match availability {+ InstantAccountAvailability::Available | InstantAccountAvailability::Disabled => None,+ InstantAccountAvailability::CaptchaOff => Some("Inactive: the proof-of-work check is off"),+ InstantAccountAvailability::RegistrationClosed => Some("Inactive: registration is closed"),+ InstantAccountAvailability::ApprovalRequired => {+ Some("Inactive: new accounts need approval")+ }+ }+}++fn guild_join_gate_inactive_reason(+ accounts: &AccountsConfigResponse,+ guild_visits_enabled: bool,+) -> Option<&'static str> {+ if accounts.guild_join_gate == GuildJoinGate::Off {+ None+ } else if accounts.interaction_tier == InteractionTierMode::Legacy {+ Some("Inactive: the older limits are on")+ } else if !guild_visits_enabled {+ Some("Inactive: community previews are off")+ } else {+ None+ }+}++fn days_field(+ name: &str,+ label: &str,+ value: u64,+ range: &std::ops::RangeInclusive<u32>,+) -> Markup {+ NumberField {+ name,+ label,+ value: &value.to_string(),+ min: Some(*range.start()),+ max: Some(*range.end()),+ step: "1",+ helper: None,+ placeholder: None,+ }+ .render()+}++pub(super) struct AccountsSectionInput<'a> {+ pub(super) auth: &'a AuthConfigResponse,+ pub(super) accounts: &'a AccountsConfigResponse,+ pub(super) identity: AccountIdentitySettings,+ pub(super) delivery_state: EmailDeliveryState,+ pub(super) captcha_provider: CaptchaProvider,+ pub(super) guild_visits_enabled: bool,+}++pub(super) fn accounts_section(+ base: &str,+ config_form: ConfigForm<'_>,+ input: &AccountsSectionInput,+) -> Markup {+ let AccountsSectionInput {+ auth,+ accounts,+ identity,+ delivery_state,+ captcha_provider,+ guild_visits_enabled,+ } = *input;+ let wording = tier_wording(identity.mode, accounts.verification_basis, delivery_state);+ let captcha_on = captcha_provider != CaptchaProvider::None;+ let name_source = if identity.tag_style.is_none() {+ "Their username is made from it"+ } else {+ "Their username and tag are made from it"+ };+ let instant_inactive = auth+ .instant_accounts+ .enabled+ .then(|| instant_account_inactive_reason(auth.instant_account_availability))+ .flatten();+ let join_gate_inactive = guild_join_gate_inactive_reason(accounts, guild_visits_enabled);+ let interaction_tier_label = format!("Accounts {}", wording.missing);+ let unclaimed = &accounts.unclaimed_account_cleanup;+ let dob_missing = &accounts.dob_missing_cleanup;+ let inactivity = &accounts.inactivity_deletion;+ section_card_with_description(+ "Sign-in & new accounts",+ &format!(+ "How people sign in, whether they can start with just a display name, and what an \+ account {} can do.",+ wording.missing+ ),+ html! {+ form method="post" action={(base) "/instance-config?action=update_accounts"} {+ (config_form.fields())+ div class="space-y-6" {+ @if !identity.mode.is_username() {+ (choice_select(+ "auth_identifier_first",+ "Start sign-in with the email address",+ IDENTIFIER_FIRST_CHOICES,+ &auth.identifier_first,+ ))+ p class="text-xs text-neutral-500" {+ "Clients ask for an email first, then offer a password, a passkey or a \+ code sent by email. Email codes need working email delivery."+ }+ }+ div class="flex flex-wrap items-center gap-2" {+ (Checkbox {+ name: "auth_instant_accounts_enabled",+ value: "true",+ label: "Let people start with just a display name",+ checked: auth.instant_accounts.enabled,+ enabled: captcha_on || auth.instant_accounts.enabled,+ }.render())+ @if let Some(reason) = instant_inactive {+ (badge(reason, BadgeVariant::Warning))+ }+ }+ p class="text-xs text-neutral-500" {+ @if captcha_on {+ (format!(+ "New people type the name others see and start right away. {name_source}, \+ and they {} later to keep the account. This works while registration \+ is open, or through a registration link that does not need approval.",+ wording.step+ ))+ } @else {+ "Turn on the proof-of-work check first. Instant accounts need it."+ }+ }+ (NumberField {+ name: "auth_instant_accounts_pow_escalation_per_hour",+ label: "Accounts per hour before the check gets harder",+ value: &auth.instant_accounts.pow_escalation_per_hour.to_string(),+ min: Some(*INSTANT_ACCOUNTS_ESCALATION_RANGE.start()),+ max: Some(*INSTANT_ACCOUNTS_ESCALATION_RANGE.end()),+ step: "1",+ helper: Some("Every this many instant accounts in the current hour doubles the check's cost for the next one."),+ placeholder: None,+ }.render())+ (choice_select(+ "accounts_date_of_birth",+ "Date of birth",+ DATE_OF_BIRTH_CHOICES,+ &accounts.date_of_birth,+ ))+ p class="text-xs text-neutral-500" {+ "With \u{201c}Don't ask\u{201d}, new accounts do not store a date of birth and \+ are treated as adults."+ }+ @if !identity.mode.is_username() {+ (choice_select(+ "accounts_verification_basis",+ "What finishes setting up an account",+ VERIFICATION_BASIS_CHOICES,+ &accounts.verification_basis,+ ))+ p class="text-xs text-neutral-500" {+ "Turning email delivery on, or choosing \u{201c}A confirmed email\u{201d}, \+ makes accounts that have a password but an unconfirmed email count as \+ not set up until they confirm it."+ }+ }+ (choice_select(+ "accounts_interaction_tier",+ &interaction_tier_label,+ INTERACTION_TIER_CHOICES,+ &accounts.interaction_tier,+ ))+ div class="flex flex-col gap-2" {+ (choice_select(+ "accounts_guild_join_gate",+ &format!("Joining a community {}", wording.missing),+ GUILD_JOIN_GATE_CHOICES,+ &accounts.guild_join_gate,+ ))+ @if let Some(reason) = join_gate_inactive {+ div { (badge(reason, BadgeVariant::Warning)) }+ }+ }+ p class="text-xs text-neutral-500" {+ (format!(+ "Applies only while \u{201c}{interaction_tier_label}\u{201d} is set to \+ \u{201c}Only allow what does not reach other people\u{201d} and community \+ previews are on for that person."+ ))+ }+ div class="space-y-4 border-t border-neutral-200 pt-6" {+ h3 class="text-sm font-semibold text-neutral-900" { "Accounts with no way back in" }+ div class="grid grid-cols-1 gap-4 sm:grid-cols-3" {+ (choice_select(+ "accounts_unclaimed_cleanup_mode",+ "Delete",+ CLEANUP_MODE_CHOICES,+ &unclaimed.mode,+ ))+ (days_field(+ "accounts_unclaimed_cleanup_inactive_days",+ "Days without use",+ unclaimed.inactive_days.get(),+ &CLEANUP_INACTIVE_DAYS_RANGE,+ ))+ (choice_select(+ "accounts_unclaimed_cleanup_on_last_session_end",+ "After the last sign-out",+ LAST_SESSION_CLEANUP_CHOICES,+ &unclaimed.on_last_session_end,+ ))+ }+ p class="text-xs text-neutral-500" {+ (format!(+ "An account has no way back in when it has none of {}. Accounts that \+ sign in through SSO always have one. Such an account is deleted after \+ {} days without use. Deletion after the last sign-out happens \+ {SCHEDULED_DELETION_GRACE_HOURS} hours after it signs out of its \+ last session.",+ way_back_in_wording(identity.mode, delivery_state),+ unclaimed.inactive_days,+ ))+ }+ }+ div class="space-y-4 border-t border-neutral-200 pt-6" {+ div class="flex flex-wrap items-center gap-2" {+ h3 class="text-sm font-semibold text-neutral-900" { "Accounts that never gave a date of birth" }+ @if dob_missing.mode != CleanupMode::Off && accounts.date_of_birth == DateOfBirthPolicy::Off {+ (badge("Inactive: the date of birth is not asked for", BadgeVariant::Warning))+ }+ }+ div class="grid grid-cols-1 gap-4 sm:grid-cols-2" {+ (choice_select(+ "accounts_dob_missing_cleanup_mode",+ "Delete",+ CLEANUP_MODE_CHOICES,+ &dob_missing.mode,+ ))+ (days_field(+ "accounts_dob_missing_cleanup_inactive_days",+ "Days without use",+ dob_missing.inactive_days.get(),+ &CLEANUP_INACTIVE_DAYS_RANGE,+ ))+ }+ p class="text-xs text-neutral-500" {+ (format!(+ "Covers accounts created without a date of birth that never entered \+ one, after {} days without use. Applies only while the date of birth \+ setting is not \u{201c}Don't ask\u{201d}.",+ dob_missing.inactive_days,+ ))+ }+ }+ div class="space-y-4 border-t border-neutral-200 pt-6" {+ h3 class="text-sm font-semibold text-neutral-900" { "Inactive accounts" }+ div class="grid grid-cols-1 gap-4 sm:grid-cols-3" {+ (choice_select(+ "accounts_inactivity_deletion_mode",+ "Delete",+ CLEANUP_MODE_CHOICES,+ &inactivity.mode,+ ))+ (days_field(+ "accounts_inactivity_deletion_inactive_days",+ "Days without use",+ inactivity.inactive_days.get(),+ &CLEANUP_INACTIVE_DAYS_RANGE,+ ))+ (days_field(+ "accounts_inactivity_deletion_warning_lead_days",+ "Days between warning and deletion",+ inactivity.warning_lead_days.get(),+ &INACTIVITY_WARNING_LEAD_DAYS_RANGE,+ ))+ }+ p class="text-xs text-neutral-500" {+ (format!(+ "Sends a warning email after {} days without use and deletes the \+ account {} days later unless someone signs in. Nothing is deleted \+ without a warning email, so accounts without an email address are kept.",+ inactivity.inactive_days,+ inactivity.warning_lead_days,+ ))+ }+ }+ (form_actions(html! {+ (submit_button("Save"))+ }))+ }+ }+ },+ )+}