Skip to content

A free and open source instant messaging and VoIP chat app built for friends, groups, and communities.

TypeScript fluxerfluxerapp
3.5 KB
Raw Blame
// SPDX-License-Identifier: AGPL-3.0-or-later

use crate::{
    api::{client::AdminApiClient, codes::GIFT_DURATION_TYPES},
    middleware::{
        auth::AuthContext,
        csrf::CsrfToken,
        flash::{self, FlashData},
    },
    state::AppState,
    templates::{
        self,
        pages::gift_codes::{GiftCodesPremium, MAX_GIFT_CODES},
    },
};
use axum::{
    Form, Router,
    extract::{FromRequest, Query, Request, State},
    response::{Html, IntoResponse, Response},
    routing::get,
};
use serde::Deserialize;

#[derive(Deserialize)]
struct GiftCodesQuery {
    codes: Option<String>,
}

#[derive(Deserialize)]
struct GiftCodesForm {
    #[serde(default)]
    _csrf: Option<String>,
    #[serde(default)]
    count: Option<u32>,
    #[serde(default)]
    duration_type: Option<String>,
    #[serde(default)]
    duration_quantity: Option<u32>,
}

pub fn router() -> Router<AppState> {
    Router::new().route("/gift-codes", get(gift_codes_page).post(gift_codes_post))
}

async fn gift_codes_page(
    State(state): State<AppState>,
    auth: axum::Extension<AuthContext>,
    csrf: axum::Extension<CsrfToken>,
    Query(query): Query<GiftCodesQuery>,
) -> Response {
    let config = state.config();
    let client = AdminApiClient::new(state.http_client(), config, &auth.0.session);
    let premium = GiftCodesPremium::from_branding(
        config.self_hosted,
        state.premium_branding(&client).await.as_ref(),
    );

    let generated_codes: Option<Vec<String>> = query
        .codes
        .as_ref()
        .map(|c| c.split(',').map(|s| s.to_string()).collect());

    let markup = templates::pages::gift_codes::gift_codes_page(
        config,
        &auth.0,
        &csrf.0.0,
        &premium,
        generated_codes.as_deref(),
    );
    Html(markup.into_string()).into_response()
}

async fn gift_codes_post(
    State(state): State<AppState>,
    auth: axum::Extension<AuthContext>,
    request: Request,
) -> Response {
    let config = state.config();
    let base = &config.base_path;
    let form: GiftCodesForm = match Form::from_request(request, &state).await {
        Ok(Form(f)) => f,
        Err(error) => {
            tracing::warn!(%error, "failed to parse gift codes form");
            return flash::redirect_error(
                config,
                &format!("{base}/gift-codes"),
                "Invalid form data",
            );
        }
    };
    let count = form.count.unwrap_or(1).clamp(1, MAX_GIFT_CODES);
    let duration_type = form
        .duration_type
        .as_deref()
        .filter(|value| GIFT_DURATION_TYPES.contains(value))
        .unwrap_or("months");
    let duration_quantity = form.duration_quantity.unwrap_or(1).max(1);
    let client = AdminApiClient::new(state.http_client(), config, &auth.0.session);
    match client
        .generate_gift_codes(count, duration_type, duration_quantity)
        .await
    {
        Ok(result) => {
            let codes = result.codes.join(",");
            flash::redirect_with_flash(
                &format!("{base}/gift-codes?codes={codes}"),
                FlashData::success(format!("{} gift code(s) generated", result.codes.len())),
                config.secure_cookies(),
            )
        }
        Err(error) => {
            tracing::warn!(%error, "admin API request failed: generate gift codes");
            flash::redirect_error(
                config,
                &format!("{base}/gift-codes"),
                "Failed to generate gift codes",
            )
        }
    }
}