A free and open source instant messaging and VoIP chat app built for friends, groups, and communities.
// SPDX-License-Identifier: AGPL-3.0-or-later
use crate::api::types::{FlashLevel, FlashMessage};
use crate::config::AdminConfig;
use axum::{
extract::Request,
http::{HeaderValue, header},
response::{IntoResponse, Redirect, Response},
};
use base64::Engine;
use serde::{Deserialize, Serialize};
const FLASH_COOKIE_NAME: &str = "flash";
#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct FlashData {
pub message: String,
pub flash_type: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub detail: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub field_error: Option<FieldError>,
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct FieldError {
pub field: String,
pub message: String,
}
impl FlashData {
pub fn success(message: impl Into<String>) -> Self {
Self {
message: message.into(),
flash_type: "success".to_owned(),
detail: None,
field_error: None,
}
}
pub fn error(message: impl Into<String>) -> Self {
Self {
message: message.into(),
flash_type: "error".to_owned(),
detail: None,
field_error: None,
}
}
pub fn info(message: impl Into<String>) -> Self {
Self {
message: message.into(),
flash_type: "info".to_owned(),
detail: None,
field_error: None,
}
}
pub fn with_field_error(mut self, field: &str, message: impl Into<String>) -> Self {
self.field_error = Some(FieldError {
field: field.to_owned(),
message: message.into(),
});
self
}
pub fn to_flash_message(&self) -> FlashMessage {
FlashMessage {
level: match self.flash_type.as_str() {
"success" => FlashLevel::Success,
"error" => FlashLevel::Error,
_ => FlashLevel::Info,
},
message: self.message.clone(),
}
}
}
pub fn serialize_flash(flash: &FlashData) -> String {
let json = serde_json::to_string(flash).unwrap_or_default();
base64::engine::general_purpose::URL_SAFE_NO_PAD.encode(json.as_bytes())
}
pub fn parse_flash(cookie: &str) -> Option<FlashData> {
let bytes = base64::engine::general_purpose::URL_SAFE_NO_PAD
.decode(cookie.trim())
.ok()?;
serde_json::from_slice(&bytes).ok()
}
pub fn extract_flash(request: &Request) -> Option<FlashData> {
let cookie_header = request.headers().get(header::COOKIE)?.to_str().ok()?;
for pair in cookie_header.split(';') {
let pair = pair.trim();
if let Some(value) = pair.strip_prefix("flash=") {
let trimmed = value.trim();
if !trimmed.is_empty() {
return parse_flash(trimmed);
}
}
}
None
}
fn delete_flash_cookie() -> String {
format!("{FLASH_COOKIE_NAME}=; Path=/; HttpOnly; SameSite=Lax; Max-Age=0")
}
pub fn clear_flash_cookie(response: &mut Response) {
if let Ok(v) = HeaderValue::from_str(&delete_flash_cookie()) {
response.headers_mut().append(header::SET_COOKIE, v);
}
}
pub fn redirect_with_flash(url: &str, flash: FlashData, secure: bool) -> Response {
let mut response = Redirect::to(url).into_response();
set_flash_cookie(&mut response, &flash, secure);
response
}
pub fn redirect_error(config: &AdminConfig, url: &str, message: impl Into<String>) -> Response {
redirect_with_flash(url, FlashData::error(message), config.secure_cookies())
}
pub fn set_flash_cookie(response: &mut Response, flash: &FlashData, secure: bool) {
let encoded = serialize_flash(flash);
let secure_flag = if secure { "; Secure" } else { "" };
let cookie_value = format!(
"{FLASH_COOKIE_NAME}={encoded}; Path=/; HttpOnly; SameSite=Lax; Max-Age=60{secure_flag}"
);
if let Ok(v) = HeaderValue::from_str(&cookie_value) {
response.headers_mut().append(header::SET_COOKIE, v);
}
}