use crate::error::BaseError;
use crate::table::{TableConfig, TableQuery};
use crate::token::TokenManager;
use serde::de::DeserializeOwned;
use std::any::Any;
use std::collections::HashMap;
use std::sync::{Arc, RwLock};
use super::Request;
#[derive(Debug, Clone)]
pub struct User {
pub id: i64,
pub username: String,
pub nickname: String,
pub email: String,
pub roles: Vec<String>,
pub permissions: Vec<String>,
}
impl User {
pub fn new(id: i64, username: impl Into<String>) -> Self {
Self {
id,
username: username.into(),
nickname: String::new(),
email: String::new(),
roles: Vec::new(),
permissions: Vec::new(),
}
}
pub fn has_permission(&self, permission: &str) -> bool {
self.permissions.contains(&permission.to_string())
}
pub fn has_role(&self, role: &str) -> bool {
self.roles.contains(&role.to_string())
}
pub fn has_any_role(&self, roles: &[String]) -> bool {
roles.iter().any(|r| self.has_role(r))
}
}
#[derive(Debug)]
pub struct GlobalTools {
token_manager: Arc<TokenManager>,
tools: Arc<RwLock<HashMap<String, Arc<dyn Any + Send + Sync>>>>,
}
impl GlobalTools {
pub fn new(token_manager: TokenManager) -> Self {
Self {
token_manager: Arc::new(token_manager),
tools: Arc::new(RwLock::new(HashMap::new())),
}
}
pub fn register_tool<T: Any + Send + Sync>(&self, name: &str, tool: Arc<T>) {
let mut tools = self.tools.write().unwrap();
tools.insert(name.to_string(), tool);
}
pub fn get_tool<T: Any + Send + Sync>(&self, name: &str) -> Option<Arc<T>> {
let tools = self.tools.read().unwrap();
tools
.get(name)
.and_then(|tool| tool.clone().downcast::<T>().ok())
}
pub fn token_manager(&self) -> &TokenManager {
&self.token_manager
}
}
#[derive(Debug)]
pub struct ActionContext {
pub request: Request,
pub user: Option<User>,
pub tools: Arc<GlobalTools>,
pub table_config: Option<Arc<TableConfig>>,
}
impl ActionContext {
pub fn new(request: Request, tools: Arc<GlobalTools>) -> Self {
Self {
request,
user: None,
tools,
table_config: None,
}
}
pub fn with_user(mut self, user: User) -> Self {
self.user = Some(user);
self
}
pub fn with_table_config(mut self, config: Arc<TableConfig>) -> Self {
self.table_config = Some(config);
self
}
pub fn param<T: DeserializeOwned>(&self, key: &str) -> Result<T, BaseError> {
let value = self
.request
.body
.get(key)
.ok_or_else(|| BaseError::ParamMissing(key.to_string()))?;
serde_json::from_value(value.clone()).map_err(|_| {
BaseError::ParamInvalid(key.to_string(), "无法将参数转换为目标类型".to_string())
})
}
pub fn param_optional<T: DeserializeOwned>(&self, key: &str) -> Option<T> {
self.request
.body
.get(key)
.and_then(|v| serde_json::from_value(v.clone()).ok())
}
pub fn table_query(&self) -> Result<TableQuery, BaseError> {
let config = self
.table_config
.as_ref()
.ok_or(BaseError::TableConfigNotSet)?;
let user_roles = self
.user
.as_ref()
.map(|u| u.roles.clone())
.unwrap_or_default();
Ok(TableQuery::new(config.clone(), user_roles, None))
}
pub fn user_roles(&self) -> Vec<String> {
self.user
.as_ref()
.map(|u| u.roles.clone())
.unwrap_or_default()
}
}