backbone-bucket 0.2.1

//! FileShare trigger handlers
//!
//! Auto-generated by backbone-cli. Do not edit manually.

use std::sync::Arc;
use async_trait::async_trait;
use backbone_core::trigger::{
    ActionExecutor, TriggerContext, TriggerContextMut, TriggerEvent, TriggerHandler, TriggerRegistry,
};

use crate::domain::entity::FileShare;

pub type FileShareTriggerEvent      = TriggerEvent;
pub type FileShareTriggerContext    = TriggerContext<FileShare>;
pub type FileShareTriggerContextMut = TriggerContextMut<FileShare>;
pub type FileShareActionExecutor    = ActionExecutor;
pub type FileShareTriggerRegistry   = TriggerRegistry<FileShare>;
pub type FileShareTriggerHandlerObj =
    dyn TriggerHandler<TriggerContext<FileShare>, TriggerEvent>;

// Lifecycle trigger handlers

/// BeforeCreate handler
pub struct FileShareBeforeCreateHandler1 {
    /// Event publisher for emitting domain events
    pub event_publisher: Option<Arc<crate::domain::event::FileShareEventPublisher>>,
    /// Action executor for side effects
    pub action_executor: Option<Arc<FileShareActionExecutor>>,
}

impl FileShareBeforeCreateHandler1 {
    pub fn new() -> Self {
        Self {
            event_publisher: None,
            action_executor: None,
        }
    }

    pub fn with_event_publisher(mut self, publisher: Arc<crate::domain::event::FileShareEventPublisher>) -> Self {
        self.event_publisher = Some(publisher);
        self
    }

    pub fn with_action_executor(mut self, executor: Arc<FileShareActionExecutor>) -> Self {
        self.action_executor = Some(executor);
        self
    }
}

#[async_trait]
impl TriggerHandler<FileShareTriggerContext, FileShareTriggerEvent> for FileShareBeforeCreateHandler1 {
    fn events(&self) -> Vec<FileShareTriggerEvent> {
        vec![TriggerEvent::BeforeCreate]
    }

    async fn handle(&self, ctx: &FileShareTriggerContext) -> anyhow::Result<()> {
        let _ = &ctx; // Mark as used to avoid unused warning
        // Unknown action type 'if': token == null || token == '' { set: token = generate_secure_token
        // Unknown action type 'if': share_type == 'password' && $input.password != null { set: password_hash = hash_password
        Ok(())
    }
}

/// AfterCreate handler
pub struct FileShareAfterCreateHandler2 {
    /// Event publisher for emitting domain events
    pub event_publisher: Option<Arc<crate::domain::event::FileShareEventPublisher>>,
    /// Action executor for side effects
    pub action_executor: Option<Arc<FileShareActionExecutor>>,
}

impl FileShareAfterCreateHandler2 {
    pub fn new() -> Self {
        Self {
            event_publisher: None,
            action_executor: None,
        }
    }

    pub fn with_event_publisher(mut self, publisher: Arc<crate::domain::event::FileShareEventPublisher>) -> Self {
        self.event_publisher = Some(publisher);
        self
    }

    pub fn with_action_executor(mut self, executor: Arc<FileShareActionExecutor>) -> Self {
        self.action_executor = Some(executor);
        self
    }
}

#[async_trait]
impl TriggerHandler<FileShareTriggerContext, FileShareTriggerEvent> for FileShareAfterCreateHandler2 {
    fn events(&self) -> Vec<FileShareTriggerEvent> {
        vec![TriggerEvent::AfterCreate]
    }

    async fn handle(&self, ctx: &FileShareTriggerContext) -> anyhow::Result<()> {
        let _ = &ctx; // Mark as used to avoid unused warning
        tracing::info!("Trigger executed for entity: {:?}", ctx.entity.id);
        // Unknown action type 'if': share_type == 'user' && shared_with != null && shared_with.length > 0 { notify
        Ok(())
    }
}

/// AfterCreate handler
pub struct FileShareAfterCreateHandler3 {
    /// Event publisher for emitting domain events
    pub event_publisher: Option<Arc<crate::domain::event::FileShareEventPublisher>>,
    /// Action executor for side effects
    pub action_executor: Option<Arc<FileShareActionExecutor>>,
}

impl FileShareAfterCreateHandler3 {
    pub fn new() -> Self {
        Self {
            event_publisher: None,
            action_executor: None,
        }
    }

    pub fn with_event_publisher(mut self, publisher: Arc<crate::domain::event::FileShareEventPublisher>) -> Self {
        self.event_publisher = Some(publisher);
        self
    }

    pub fn with_action_executor(mut self, executor: Arc<FileShareActionExecutor>) -> Self {
        self.action_executor = Some(executor);
        self
    }
}

#[async_trait]
impl TriggerHandler<FileShareTriggerContext, FileShareTriggerEvent> for FileShareAfterCreateHandler3 {
    fn events(&self) -> Vec<FileShareTriggerEvent> {
        vec![TriggerEvent::AfterCreate]
    }

    async fn handle(&self, ctx: &FileShareTriggerContext) -> anyhow::Result<()> {
        let _ = &ctx; // Mark as used to avoid unused warning
        // Unknown action type 'create': fileaccesslog
        // Emit shareaccessedevent event
        if let Some(_publisher) = &self.event_publisher {
            // Custom event: shareaccessedevent
            // <<< CUSTOM EMIT: shareaccessedevent >>>
        }
        Ok(())
    }
}

/// AfterCreate handler
pub struct FileShareAfterCreateHandler4 {
    /// Event publisher for emitting domain events
    pub event_publisher: Option<Arc<crate::domain::event::FileShareEventPublisher>>,
    /// Action executor for side effects
    pub action_executor: Option<Arc<FileShareActionExecutor>>,
}

impl FileShareAfterCreateHandler4 {
    pub fn new() -> Self {
        Self {
            event_publisher: None,
            action_executor: None,
        }
    }

    pub fn with_event_publisher(mut self, publisher: Arc<crate::domain::event::FileShareEventPublisher>) -> Self {
        self.event_publisher = Some(publisher);
        self
    }

    pub fn with_action_executor(mut self, executor: Arc<FileShareActionExecutor>) -> Self {
        self.action_executor = Some(executor);
        self
    }
}

#[async_trait]
impl TriggerHandler<FileShareTriggerContext, FileShareTriggerEvent> for FileShareAfterCreateHandler4 {
    fn events(&self) -> Vec<FileShareTriggerEvent> {
        vec![TriggerEvent::AfterCreate]
    }

    async fn handle(&self, ctx: &FileShareTriggerContext) -> anyhow::Result<()> {
        let _ = &ctx; // Mark as used to avoid unused warning
        tracing::info!("Trigger executed for entity: {:?}", ctx.entity.id);
        // Emit sharestatuschangedevent event
        if let Some(_publisher) = &self.event_publisher {
            // Custom event: sharestatuschangedevent
            // <<< CUSTOM EMIT: sharestatuschangedevent >>>
        }
        Ok(())
    }
}

/// AfterDelete handler
pub struct FileShareAfterDeleteHandler5 {
    /// Event publisher for emitting domain events
    pub event_publisher: Option<Arc<crate::domain::event::FileShareEventPublisher>>,
    /// Action executor for side effects
    pub action_executor: Option<Arc<FileShareActionExecutor>>,
}

impl FileShareAfterDeleteHandler5 {
    pub fn new() -> Self {
        Self {
            event_publisher: None,
            action_executor: None,
        }
    }

    pub fn with_event_publisher(mut self, publisher: Arc<crate::domain::event::FileShareEventPublisher>) -> Self {
        self.event_publisher = Some(publisher);
        self
    }

    pub fn with_action_executor(mut self, executor: Arc<FileShareActionExecutor>) -> Self {
        self.action_executor = Some(executor);
        self
    }
}

#[async_trait]
impl TriggerHandler<FileShareTriggerContext, FileShareTriggerEvent> for FileShareAfterDeleteHandler5 {
    fn events(&self) -> Vec<FileShareTriggerEvent> {
        vec![TriggerEvent::AfterDelete]
    }

    async fn handle(&self, ctx: &FileShareTriggerContext) -> anyhow::Result<()> {
        let _ = &ctx; // Mark as used to avoid unused warning
        // Emit sharedeletedevent event
        if let Some(publisher) = &self.event_publisher {
            publisher.publish_deleted(ctx.entity.id().to_string(), ctx.user_id.clone()).await?;
        }
        tracing::info!("Trigger executed for entity: {:?}", ctx.entity.id);
        Ok(())
    }
}

// State machine trigger handlers

/// Handler for entering active state
pub struct FileShareOnEnterActiveHandler {
    pub event_publisher: Option<Arc<crate::domain::event::FileShareEventPublisher>>,
}

impl FileShareOnEnterActiveHandler {
    pub fn new() -> Self {
        Self {
            event_publisher: None,
        }
    }
}

#[async_trait]
impl TriggerHandler<FileShareTriggerContext, FileShareTriggerEvent> for FileShareOnEnterActiveHandler {
    fn events(&self) -> Vec<FileShareTriggerEvent> {
        vec![TriggerEvent::OnEnterState("active".to_string())]
    }

    async fn handle(&self, ctx: &FileShareTriggerContext) -> anyhow::Result<()> {
        let _ = &ctx; // Mark as used to avoid unused warning
        // Emit sharecreatedevent event
        if let Some(publisher) = &self.event_publisher {
            publisher.publish_created(ctx.entity.clone(), ctx.user_id.clone()).await?;
        }
        Ok(())
    }
}

/// Handler for entering inactive state
pub struct FileShareOnEnterInactiveHandler {}

impl FileShareOnEnterInactiveHandler {
    pub fn new() -> Self { Self {} }
}

#[async_trait]
impl TriggerHandler<FileShareTriggerContext, FileShareTriggerEvent> for FileShareOnEnterInactiveHandler {
    fn events(&self) -> Vec<FileShareTriggerEvent> {
        vec![TriggerEvent::OnEnterState("inactive".to_string())]
    }

    async fn handle(&self, ctx: &FileShareTriggerContext) -> anyhow::Result<()> {
        let _ = &ctx; // Mark as used to avoid unused warning
        tracing::info!("Trigger executed for entity: {:?}", ctx.entity.id);
        Ok(())
    }
}

/// Handler for entering expired state
pub struct FileShareOnEnterExpiredHandler {}

impl FileShareOnEnterExpiredHandler {
    pub fn new() -> Self { Self {} }
}

#[async_trait]
impl TriggerHandler<FileShareTriggerContext, FileShareTriggerEvent> for FileShareOnEnterExpiredHandler {
    fn events(&self) -> Vec<FileShareTriggerEvent> {
        vec![TriggerEvent::OnEnterState("expired".to_string())]
    }

    async fn handle(&self, ctx: &FileShareTriggerContext) -> anyhow::Result<()> {
        let _ = &ctx; // Mark as used to avoid unused warning
        tracing::info!("Trigger executed for entity: {:?}", ctx.entity.id);
        Ok(())
    }
}

/// Handler for entering exhausted state
pub struct FileShareOnEnterExhaustedHandler {
    pub event_publisher: Option<Arc<crate::domain::event::FileShareEventPublisher>>,
}

impl FileShareOnEnterExhaustedHandler {
    pub fn new() -> Self {
        Self {
            event_publisher: None,
        }
    }
}

#[async_trait]
impl TriggerHandler<FileShareTriggerContext, FileShareTriggerEvent> for FileShareOnEnterExhaustedHandler {
    fn events(&self) -> Vec<FileShareTriggerEvent> {
        vec![TriggerEvent::OnEnterState("exhausted".to_string())]
    }

    async fn handle(&self, ctx: &FileShareTriggerContext) -> anyhow::Result<()> {
        let _ = &ctx; // Mark as used to avoid unused warning
        // Emit sharedownloadlimitreachedevent event
        if let Some(_publisher) = &self.event_publisher {
            // Custom event: sharedownloadlimitreachedevent
            // <<< CUSTOM EMIT: sharedownloadlimitreachedevent >>>
        }
        tracing::info!("Trigger executed for entity: {:?}", ctx.entity.id);
        Ok(())
    }
}

/// Handler for entering revoked state
pub struct FileShareOnEnterRevokedHandler {
    pub event_publisher: Option<Arc<crate::domain::event::FileShareEventPublisher>>,
}

impl FileShareOnEnterRevokedHandler {
    pub fn new() -> Self {
        Self {
            event_publisher: None,
        }
    }
}

#[async_trait]
impl TriggerHandler<FileShareTriggerContext, FileShareTriggerEvent> for FileShareOnEnterRevokedHandler {
    fn events(&self) -> Vec<FileShareTriggerEvent> {
        vec![TriggerEvent::OnEnterState("revoked".to_string())]
    }

    async fn handle(&self, ctx: &FileShareTriggerContext) -> anyhow::Result<()> {
        let _ = &ctx; // Mark as used to avoid unused warning
        // Set revoked_at to current timestamp
        // <<< CUSTOM SET: revoked_at = now >>>
        // ctx.entity.revoked_at = Some(chrono::Utc::now();
        // Note: Add closing parenthesis if using Some()
        // Emit sharerevokedevent event
        if let Some(_publisher) = &self.event_publisher {
            // Custom event: sharerevokedevent
            // <<< CUSTOM EMIT: sharerevokedevent >>>
        }
        tracing::info!("Trigger executed for entity: {:?}", ctx.entity.id);
        Ok(())
    }
}

/// Create a default registry pre-populated with all handlers for FileShare.
pub fn file_share_trigger_registry() -> FileShareTriggerRegistry {
    TriggerRegistry::build(|r| {
        r.register(Arc::new(FileShareBeforeCreateHandler1::new()));
        r.register(Arc::new(FileShareAfterCreateHandler2::new()));
        r.register(Arc::new(FileShareAfterCreateHandler3::new()));
        r.register(Arc::new(FileShareAfterCreateHandler4::new()));
        r.register(Arc::new(FileShareAfterDeleteHandler5::new()));
        r.register(Arc::new(FileShareOnEnterActiveHandler::new()));
        r.register(Arc::new(FileShareOnEnterInactiveHandler::new()));
        r.register(Arc::new(FileShareOnEnterExpiredHandler::new()));
        r.register(Arc::new(FileShareOnEnterExhaustedHandler::new()));
        r.register(Arc::new(FileShareOnEnterRevokedHandler::new()));
    })
}