use std::fmt::Write as _;
use axum::{
Json,
extract::{Path, Query, State},
http::StatusCode,
response::{IntoResponse, Response},
};
// rand 0.10 把 trait 重切了:原本的 RngCore 改名為 Rng(fill_bytes 在這裡),
// 而原本 Rng 上的高階方法搬到 RngExt(見 upload.rs)。
use rand::Rng;
use serde::{Deserialize, Serialize};
use serde_json::json;
use sqlx::FromRow;
use crate::handlers::posts::Pagination;
use crate::state::AppState;
use crate::util::parse_int;
/// `newsletter_subscribers` 一列(`SELECT *`)。欄位序 = 表宣告序,對齊舊 `row_to_json`。
#[derive(Debug, Serialize, FromRow, specta::Type, utoipa::ToSchema)]
pub struct SubscriberRow {
#[specta(type = specta_typescript::Number)]
pub id: i64,
pub email: String,
pub name: Option<String>,
pub status: Option<String>,
pub subscribed_at: Option<String>,
pub unsubscribed_at: Option<String>,
pub unsubscribe_token: Option<String>,
}
#[derive(Debug, Serialize, specta::Type, utoipa::ToSchema)]
pub struct SubscribersResponse {
pub message: String,
pub subscribers: Vec<SubscriberRow>,
pub pagination: Pagination,
}
/// `GET /api/newsletter/by-token/:token` 的回應(顯式 3 欄)。
#[derive(Debug, Serialize, FromRow, specta::Type, utoipa::ToSchema)]
pub struct SubscriberByToken {
pub email: String,
pub name: Option<String>,
pub status: Option<String>,
}
/// `crypto.randomBytes(16).toString('hex')` 等價:32 hex 字元。
fn gen_unsub_token() -> String {
let mut b = [0u8; 16];
// rand 0.9 起 thread_rng() 改名 rng()(舊名在 0.10 已移除)
rand::rng().fill_bytes(&mut b);
b.iter().fold(String::new(), |mut acc, x| {
let _ = write!(acc, "{x:02x}");
acc
})
}
#[derive(Debug, Deserialize, utoipa::ToSchema)]
pub struct SubscribeBody {
email: Option<String>,
name: Option<String>,
}
/// `POST /api/newsletter/subscribe` —— 公開訂閱;重複 email 且非 active → 重新啟用。
#[utoipa::path(post, path = "/api/newsletter/subscribe", tag = "newsletter",
responses((status = 200, description = "訂閱電子報(動態 JSON)")))]
pub async fn subscribe(
State(state): State<AppState>,
crate::error::JsonBody(b): crate::error::JsonBody<SubscribeBody>,
) -> Response {
let email = b.email.unwrap_or_default();
if email.is_empty() {
return (StatusCode::BAD_REQUEST, Json(json!({ "error": "Email is required" }))).into_response();
}
// Express regex: /^[^\s@]+@[^\s@]+\.[^\s@]+$/
static EMAIL_RE: std::sync::LazyLock<regex::Regex> =
std::sync::LazyLock::new(|| regex::Regex::new(r"^[^\s@]+@[^\s@]+\.[^\s@]+$").expect("字面 regex"));
let re = &*EMAIL_RE;
if !re.is_match(&email) {
return (StatusCode::BAD_REQUEST, Json(json!({ "error": "Invalid email format" }))).into_response();
}
let token = gen_unsub_token();
let name = b.name.filter(|s| !s.is_empty());
match sqlx::query(
"INSERT INTO newsletter_subscribers (email, name, status, unsubscribe_token) VALUES (?, ?, 'active', ?)",
)
.bind(&email)
.bind(&name)
.bind(&token)
.execute(&state.pool)
.await
{
Ok(r) => (
StatusCode::CREATED,
Json(json!({ "message": "Successfully subscribed to newsletter", "id": r.last_insert_rowid() })),
)
.into_response(),
Err(e) => {
let msg = e.to_string();
if msg.contains("UNIQUE constraint failed: newsletter_subscribers.email") {
// 已訂閱:非 active → 重新啟用並補 token
match sqlx::query(
"UPDATE newsletter_subscribers SET status = 'active', unsubscribed_at = NULL, \
unsubscribe_token = COALESCE(unsubscribe_token, ?) WHERE email = ? AND status != 'active'",
)
.bind(&token)
.bind(&email)
.execute(&state.pool)
.await
{
Err(e2) => (StatusCode::BAD_REQUEST, Json(json!({ "error": e2.to_string() }))).into_response(),
Ok(r) if r.rows_affected() > 0 => {
Json(json!({ "message": "Re-subscribed to newsletter" })).into_response()
}
Ok(_) => (
StatusCode::BAD_REQUEST,
Json(json!({ "error": "This email is already subscribed" })),
)
.into_response(),
}
} else {
(StatusCode::BAD_REQUEST, Json(json!({ "error": msg }))).into_response()
}
}
}
}
#[derive(Debug, Deserialize, utoipa::ToSchema)]
pub struct UnsubscribeBody {
email: Option<String>,
token: Option<String>,
}
/// `POST /api/newsletter/unsubscribe` —— email 或 token 擇一(token 優先)。
#[utoipa::path(post, path = "/api/newsletter/unsubscribe", tag = "newsletter",
responses((status = 200, description = "退訂電子報(動態 JSON)")))]
pub async fn unsubscribe(
State(state): State<AppState>,
crate::error::JsonBody(b): crate::error::JsonBody<UnsubscribeBody>,
) -> Response {
let email = b.email.filter(|s| !s.is_empty());
let token = b.token.filter(|s| !s.is_empty());
// token 優先於 email(對齊 Express `token || email`);兩者皆無 → 400
let (sql, param) = match (token, email) {
(Some(t), _) => (
"UPDATE newsletter_subscribers SET status = ?, unsubscribed_at = datetime('now') WHERE unsubscribe_token = ?",
t,
),
(None, Some(e)) => (
"UPDATE newsletter_subscribers SET status = ?, unsubscribed_at = datetime('now') WHERE email = ?",
e,
),
(None, None) => {
return (StatusCode::BAD_REQUEST, Json(json!({ "error": "Email or token is required" })))
.into_response();
}
};
match sqlx::query(sql).bind("unsubscribed").bind(¶m).execute(&state.pool).await {
Err(e) => crate::error::internal_error(StatusCode::BAD_REQUEST, e),
Ok(r) if r.rows_affected() == 0 => {
(StatusCode::NOT_FOUND, Json(json!({ "message": "Subscriber not found" }))).into_response()
}
Ok(_) => Json(json!({ "message": "Successfully unsubscribed from newsletter" })).into_response(),
}
}
/// `GET /api/newsletter/by-token/:token` —— 退訂確認頁用(裸 row:email/name/status)。
#[utoipa::path(get, path = "/api/newsletter/by-token/{token}", tag = "newsletter",
params(("token" = String, Path)),
responses((status = 200, body = SubscriberByToken)))]
pub async fn by_token(State(state): State<AppState>, Path(token): Path<String>) -> Response {
match sqlx::query_as::<_, SubscriberByToken>(
"SELECT email, name, status FROM newsletter_subscribers WHERE unsubscribe_token = ?",
)
.bind(&token)
.fetch_optional(&state.pool)
.await
{
Err(e) => crate::error::internal_error(StatusCode::INTERNAL_SERVER_ERROR, e),
Ok(None) => (StatusCode::NOT_FOUND, Json(json!({ "error": "invalid token" }))).into_response(),
Ok(Some(sub)) => Json(sub).into_response(),
}
}
#[derive(Debug, Deserialize)]
pub struct SubscribersQuery {
page: Option<String>,
limit: Option<String>,
status: Option<String>,
}
/// `GET /api/newsletter/subscribers`(requireAdmin)—— 分頁列表(SELECT * 動態 row)。
#[utoipa::path(get, path = "/api/newsletter/subscribers", tag = "newsletter", security(("bearer" = [])),
responses((status = 200, body = SubscribersResponse), (status = 401, description = "未授權")))]
pub async fn subscribers(
State(state): State<AppState>,
_auth: crate::auth::AdminAuth,
Query(q): Query<SubscribersQuery>,
) -> Response {
let page = parse_int(q.page.as_deref(), 1);
let limit = parse_int(q.limit.as_deref(), 50);
let offset = (page - 1) * limit;
let status = q.status.as_deref().unwrap_or("active");
let subscribers = match sqlx::query_as::<_, SubscriberRow>(
"SELECT * FROM newsletter_subscribers WHERE status = ? ORDER BY subscribed_at DESC LIMIT ? OFFSET ?",
)
.bind(status)
.bind(limit)
.bind(offset)
.fetch_all(&state.pool)
.await
{
Ok(r) => r,
Err(e) => return crate::error::internal_error(StatusCode::INTERNAL_SERVER_ERROR, e),
};
let total = match sqlx::query_scalar::<_, i64>(
"SELECT COUNT(*) as total FROM newsletter_subscribers WHERE status = ?",
)
.bind(status)
.fetch_one(&state.pool)
.await
{
Ok(t) => t,
Err(e) => return crate::error::internal_error(StatusCode::INTERNAL_SERVER_ERROR, e),
};
let total_pages = if limit > 0 { (total + limit - 1) / limit } else { 0 };
Json(SubscribersResponse {
message: "success".into(),
subscribers,
pagination: Pagination { page, limit, total, total_pages },
})
.into_response()
}