pub mod decision;
use async_trait::async_trait;
use std::sync::Arc;
use unicode_normalization::UnicodeNormalization;
use crate::error::{GarrisonError, GarrisonResult};
use crate::stp::GarrisonInterface;
pub use decision::{AuthRequest, Decision, DecisionReason};
#[cfg(feature = "core-advanced")]
pub mod registry;
#[cfg(feature = "core-advanced")]
pub use registry::{PermissionRegistration, PermissionRegistry, PermissionSpec};
#[cfg(feature = "authorize-api")]
pub mod authorize;
#[cfg(feature = "authorize-api")]
pub use authorize::Authorizer;
#[cfg(feature = "core-advanced")]
pub mod decision_combinator;
#[cfg(feature = "core-advanced")]
pub use decision_combinator::DecisionCombinator;
#[async_trait]
pub trait PermissionChecker: Send + Sync {
async fn has_permission(&self, login_id: &str, permission: &str) -> GarrisonResult<bool>;
async fn has_role(&self, login_id: &str, role: &str) -> GarrisonResult<bool>;
async fn has_permission_in_tenant(
&self,
_tenant_id: i64,
login_id: &str,
permission: &str,
) -> GarrisonResult<bool> {
self.has_permission(login_id, permission).await
}
async fn authorize(&self, request: &AuthRequest) -> GarrisonResult<Decision> {
#[cfg(feature = "core-advanced")]
let trace_id = Some(uuid::Uuid::now_v7().to_string());
#[cfg(not(feature = "core-advanced"))]
let trace_id: Option<String> = None;
let allowed = if request.tenant_id != 0 {
self.has_permission_in_tenant(request.tenant_id, &request.login_id, &request.action)
.await?
} else {
self.has_permission(&request.login_id, &request.action)
.await?
};
let decision = if allowed {
Decision {
allowed: true,
reason: DecisionReason::ExplicitAllow,
errors: Vec::new(),
checked_permissions: Vec::new(),
matched_roles: Vec::new(),
trace_id,
}
} else {
Decision {
allowed: false,
reason: DecisionReason::NoMatchingPermission,
errors: Vec::new(),
checked_permissions: Vec::new(),
matched_roles: Vec::new(),
trace_id,
}
};
Ok(decision)
}
async fn check_permission(&self, login_id: &str, permission: &str) -> GarrisonResult<()> {
let request = AuthRequest::new(login_id, permission);
let decision = self.authorize(&request).await?;
if decision.allowed {
Ok(())
} else {
Err(GarrisonError::NotPermission(format!(
"core-account-no-permission::{}::{}",
login_id, permission
)))
}
}
async fn check_role(&self, login_id: &str, role: &str) -> GarrisonResult<()> {
if self.has_role(login_id, role).await? {
Ok(())
} else {
Err(GarrisonError::NotRole(format!(
"core-account-no-role::{}::{}",
login_id, role
)))
}
}
async fn has_any_permission(&self, login_id: &str, perms: &[&str]) -> bool;
async fn has_all_permissions(&self, login_id: &str, perms: &[&str]) -> bool;
}
pub struct PermissionCheckerDefault {
interface: Arc<dyn GarrisonInterface>,
}
pub mod default;
#[cfg(test)]
mod mock;
#[cfg(test)]
mod tests;