main
use std::str::FromStr;
use sea_orm::{ConnectionTrait, EntityTrait};
/// A locale with a shipped server-side catalogue.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum UiLocale {
ZhCn,
En,
}
impl UiLocale {
/// BCP-47 tag, as written into `lang=""` and into the mail headers.
pub fn tag(self) -> &'static str {
match self {
Self::ZhCn => "zh-CN",
Self::En => "en",
}
}
/// Parse one tag, tolerating POSIX spellings (`zh_CN`) and script/region
/// variants (`zh-Hans-CN`, `en-US`).
///
/// `zh-Hant`/`zh-TW`/`zh-HK`/`zh-MO` deliberately return `None`: serving
/// Simplified copy to a Traditional reader is worse than falling back.
pub fn parse(raw: &str) -> Option<Self> {
let tag = raw.trim().to_ascii_lowercase().replace('_', "-");
if tag.is_empty() {
return None;
}
if tag == "zh" || tag.starts_with("zh-") {
let rest = &tag[2..];
if rest.contains("hant") || ["-tw", "-hk", "-mo"].iter().any(|s| rest.contains(s)) {
return None;
}
return Some(Self::ZhCn);
}
if tag == "en" || tag.starts_with("en-") {
return Some(Self::En);
}
None
}
/// Locale tag for HTTP headers that want an underscore-free form.
pub fn header(self) -> &'static str {
self.tag()
}
}
impl FromStr for UiLocale {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
Self::parse(s).ok_or(())
}
}
/// Pick a locale from an `Accept-Language` header value.
///
/// Honours q-values (including `q=0` as an explicit refusal) and walks the
/// client's preference order, so `zh-CN,zh;q=0.9,en;q=0.8` resolves to zh-CN
/// while `en-GB,en;q=0.9` resolves to en.
pub fn negotiate_accept_language(header: Option<&str>, fallback: UiLocale) -> UiLocale {
let Some(header) = header else {
return fallback;
};
let mut candidates: Vec<(f32, usize, UiLocale)> = Vec::new();
for (index, entry) in header.split(',').enumerate() {
let entry = entry.trim();
if entry.is_empty() {
continue;
}
let (tag, q) = match entry.split_once(';') {
Some((tag, params)) => {
let q = params
.trim()
.strip_prefix("q=")
.and_then(|value| value.trim().parse::<f32>().ok())
.unwrap_or(1.0);
(tag.trim(), q)
}
None => (entry, 1.0),
};
if q <= 0.0 {
continue;
}
if let Some(locale) = UiLocale::parse(tag) {
candidates.push((q, index, locale));
}
}
// Stable by (descending q, ascending header position); header order wins ties.
candidates.sort_by(|a, b| b.0.total_cmp(&a.0).then(a.1.cmp(&b.1)));
candidates
.first()
.map(|(_, _, locale)| *locale)
.unwrap_or(fallback)
}
/// Resolve the language for a specific message recipient.
///
/// Preference order is fixed and intentional: an account-level choice always
/// beats the ambient request, because one request can produce several mails to
/// recipients who read different languages.
pub fn resolve_locale(
user_language: Option<&str>,
user_locale: Option<&str>,
accept_language: Option<&str>,
fallback: UiLocale,
) -> UiLocale {
UiLocale::parse(user_language.filter(|v| !v.trim().is_empty()).unwrap_or(""))
.or_else(|| UiLocale::parse(user_locale.filter(|v| !v.trim().is_empty()).unwrap_or("")))
.unwrap_or_else(|| negotiate_accept_language(accept_language, fallback))
}
/// Batch-read a single user's rendered-locale preference straight from the DB.
///
/// Returns `fallback` when the user has no usable preference, so callers can
/// pass the result directly to a template.
pub async fn resolve_user_locale<C: ConnectionTrait>(
db: &C,
uid: i64,
fallback: UiLocale,
) -> UiLocale {
use models::users::user;
let row = user::Entity::find_by_id(uid).one(db).await.ok().flatten();
match row {
Some(row) => resolve_locale(
row.language.as_deref(),
row.locale.as_deref(),
None,
fallback,
),
None => fallback,
}
}
/// Batch variant: one query for many recipients, keyed by user id.
///
/// Callers that fan a single event out to a whole room or issue watcher list
/// must not issue one query per recipient.
pub async fn resolve_user_locales<C: ConnectionTrait>(
db: &C,
uids: &[i64],
fallback: UiLocale,
) -> std::collections::HashMap<i64, UiLocale> {
use models::users::user;
use sea_orm::{ColumnTrait, QueryFilter};
let mut out = std::collections::HashMap::new();
if uids.is_empty() {
return out;
}
let rows = user::Entity::find()
.filter(user::Column::Uid.is_in(uids.to_vec()))
.all(db)
.await
.unwrap_or_default();
for row in rows {
let locale = resolve_locale(
row.language.as_deref(),
row.locale.as_deref(),
None,
fallback,
);
out.insert(row.uid, locale);
}
out
}