use serde::{Deserialize, Serialize};
pub use crate::stp::LoginParams;
pub use crate::session::TokenInfo;
pub type SessionData = crate::session::TokenSession;
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CheckLoginRequest {
pub token: String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CheckPermissionRequest {
pub token: String,
pub permission: String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CheckRoleRequest {
pub token: String,
pub role: String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CheckApiKeyRequest {
pub api_key: String,
pub namespace: String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct KickoutRequest {
pub login_id: String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct LoginRequest {
pub login_id: String,
pub params: LoginParams,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct LogoutRequest {
pub token: String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SwitchToRequest {
pub token: String,
pub target_login_id: String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RenewToEquivalentRequest {
pub token: String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ApiResponse<T> {
#[serde(skip_serializing_if = "Option::is_none")]
pub data: Option<T>,
#[serde(skip_serializing_if = "Option::is_none")]
pub error_code: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub message: Option<String>,
}
impl<T> ApiResponse<T> {
pub fn ok(data: T) -> Self {
Self {
data: Some(data),
error_code: None,
message: None,
}
}
pub fn err(error_code: impl Into<String>, message: impl Into<String>) -> Self {
Self {
data: None,
error_code: Some(error_code.into()),
message: Some(message.into()),
}
}
pub fn into_result(self) -> Result<T, (String, String)> {
match self.data {
Some(v) => Ok(v),
None => Err((
self.error_code.unwrap_or_else(|| "UNKNOWN".to_string()),
self.message.unwrap_or_else(|| "Unknown error".to_string()),
)),
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn api_response_ok_wraps_data() {
let resp: ApiResponse<i32> = ApiResponse::ok(42);
assert_eq!(resp.data, Some(42));
assert!(resp.error_code.is_none());
assert!(resp.message.is_none());
}
#[test]
fn api_response_err_wraps_error_info() {
let resp: ApiResponse<String> = ApiResponse::err("DENIED", "拒绝访问");
assert!(resp.data.is_none());
assert_eq!(resp.error_code.as_deref(), Some("DENIED"));
assert_eq!(resp.message.as_deref(), Some("拒绝访问"));
}
#[test]
fn into_result_ok_extracts_data() {
let resp: ApiResponse<i32> = ApiResponse::ok(7);
assert_eq!(resp.into_result().unwrap(), 7);
}
#[test]
fn into_result_err_with_explicit_fields() {
let resp: ApiResponse<i32> = ApiResponse::err("NOT_FOUND", "资源不存在");
let (code, msg) = resp.into_result().unwrap_err();
assert_eq!(code, "NOT_FOUND");
assert_eq!(msg, "资源不存在");
}
#[test]
fn into_result_err_with_none_fields_uses_defaults() {
let resp: ApiResponse<i32> = ApiResponse {
data: None,
error_code: None,
message: None,
};
let (code, msg) = resp.into_result().unwrap_err();
assert_eq!(code, "UNKNOWN");
assert_eq!(msg, "Unknown error");
}
}