use std::sync::Arc;
use crate::account::disable::{DefaultDisableRepository, DisableRepository};
use crate::config::GarrisonConfig;
use crate::core::auth::AuthLogic;
use crate::core::permission::PermissionChecker;
use crate::error::GarrisonResult;
#[cfg(feature = "listener")]
use crate::listener::GarrisonListenerManager;
use crate::plugin::GarrisonPluginManager;
use crate::session::GarrisonSession;
use crate::stp::GarrisonLogicDefault;
use crate::strategy::GarrisonPermissionStrategy;
pub struct GarrisonLogicFactoryContext {
pub plugin_manager: Option<Arc<GarrisonPluginManager>>,
#[cfg(feature = "listener")]
pub listener_manager: Option<Arc<GarrisonListenerManager>>,
pub auth_logic: Option<Arc<dyn AuthLogic>>,
pub permission_checker: Option<Arc<dyn PermissionChecker>>,
pub disable_repository: Option<Arc<dyn DisableRepository>>,
#[cfg(feature = "three-tier-cache")]
pub user_cache_service: Option<Arc<crate::cache::UserCacheService>>,
}
pub type GarrisonLogicFactoryFn = fn(
session: Arc<GarrisonSession>,
config: Arc<GarrisonConfig>,
firewall: Arc<dyn GarrisonPermissionStrategy>,
ctx: &GarrisonLogicFactoryContext,
) -> GarrisonResult<Arc<GarrisonLogicDefault>>;
pub struct GarrisonLogicFactoryEntry {
pub name: &'static str,
pub factory: GarrisonLogicFactoryFn,
}
inventory::collect!(GarrisonLogicFactoryEntry);
pub fn garrison_logic_factory_default(
session: Arc<GarrisonSession>,
config: Arc<GarrisonConfig>,
firewall: Arc<dyn GarrisonPermissionStrategy>,
ctx: &GarrisonLogicFactoryContext,
) -> GarrisonResult<Arc<GarrisonLogicDefault>> {
let disable_repository: Arc<dyn DisableRepository> = ctx
.disable_repository
.clone()
.unwrap_or_else(|| Arc::new(DefaultDisableRepository::new(session.dao().clone())));
let mut builder = GarrisonLogicDefault::new(session, config, firewall, disable_repository);
if let Some(pm) = ctx.plugin_manager.clone() {
builder = builder.with_plugin_manager(pm);
}
#[cfg(feature = "listener")]
if let Some(lm) = ctx.listener_manager.clone() {
builder = builder.with_listener_manager(lm);
}
if let Some(auth) = ctx.auth_logic.clone() {
builder = builder.with_auth_logic(auth);
}
if let Some(pc) = ctx.permission_checker.clone() {
builder = builder.with_permission_checker(pc);
}
#[cfg(feature = "three-tier-cache")]
if let Some(ucs) = ctx.user_cache_service.clone() {
builder = builder.with_user_cache_service(ucs);
}
Ok(Arc::new(builder))
}
inventory::submit! {
GarrisonLogicFactoryEntry {
name: "default",
factory: garrison_logic_factory_default,
}
}