backbone-bucket 0.4.6

//! UploadSession 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::UploadSession;

pub type UploadSessionTriggerEvent      = TriggerEvent;
pub type UploadSessionTriggerContext    = TriggerContext<UploadSession>;
pub type UploadSessionTriggerContextMut = TriggerContextMut<UploadSession>;
pub type UploadSessionActionExecutor    = ActionExecutor;
pub type UploadSessionTriggerRegistry   = TriggerRegistry<UploadSession>;
pub type UploadSessionTriggerHandlerObj =
    dyn TriggerHandler<TriggerContext<UploadSession>, TriggerEvent>;

// Lifecycle trigger handlers

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

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

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

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

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

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

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

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

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

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

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

    async fn handle(&self, ctx: &UploadSessionTriggerContext) -> anyhow::Result<()> {
        let _ = &ctx; // Mark as used to avoid unused warning
        // Emit uploadpartreceivedevent event
        if let Some(_publisher) = &self.event_publisher {
            // Custom event: uploadpartreceivedevent
        }
        Ok(())
    }
}

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

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

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

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

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

    async fn handle(&self, ctx: &UploadSessionTriggerContext) -> anyhow::Result<()> {
        let _ = &ctx; // Mark as used to avoid unused warning
        // Unknown action type 'update': uploadsession
        Ok(())
    }
}

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

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

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

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

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

    async fn handle(&self, ctx: &UploadSessionTriggerContext) -> anyhow::Result<()> {
        let _ = &ctx; // Mark as used to avoid unused warning
        // Unknown action type 'queue': cleanupuploadparts
        Ok(())
    }
}

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

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

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

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

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

    async fn handle(&self, ctx: &UploadSessionTriggerContext) -> anyhow::Result<()> {
        let _ = &ctx; // Mark as used to avoid unused warning
        // Send notification
        if let Some(executor) = &self.action_executor {
            executor.notify(ctx, "default").await?;
        }
        Ok(())
    }
}

// State machine trigger handlers

/// Handler for entering initiated state
pub struct UploadSessionOnEnterInitiatedHandler {}

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

#[async_trait]
impl TriggerHandler<UploadSessionTriggerContext, UploadSessionTriggerEvent> for UploadSessionOnEnterInitiatedHandler {
    fn events(&self) -> Vec<UploadSessionTriggerEvent> {
        vec![TriggerEvent::OnEnterState("initiated".to_string())]
    }

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

/// Handler for entering uploading state
pub struct UploadSessionOnEnterUploadingHandler {
    pub event_publisher: Option<Arc<crate::domain::event::UploadSessionEventPublisher>>,
}

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

#[async_trait]
impl TriggerHandler<UploadSessionTriggerContext, UploadSessionTriggerEvent> for UploadSessionOnEnterUploadingHandler {
    fn events(&self) -> Vec<UploadSessionTriggerEvent> {
        vec![TriggerEvent::OnEnterState("uploading".to_string())]
    }

    async fn handle(&self, ctx: &UploadSessionTriggerContext) -> anyhow::Result<()> {
        let _ = &ctx; // Mark as used to avoid unused warning
        // Emit uploadstartedevent event
        if let Some(_publisher) = &self.event_publisher {
            // Custom event: uploadstartedevent
        }
        Ok(())
    }
}

/// Handler for entering completing state
pub struct UploadSessionOnEnterCompletingHandler {
    pub event_publisher: Option<Arc<crate::domain::event::UploadSessionEventPublisher>>,
}

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

#[async_trait]
impl TriggerHandler<UploadSessionTriggerContext, UploadSessionTriggerEvent> for UploadSessionOnEnterCompletingHandler {
    fn events(&self) -> Vec<UploadSessionTriggerEvent> {
        vec![TriggerEvent::OnEnterState("completing".to_string())]
    }

    async fn handle(&self, ctx: &UploadSessionTriggerContext) -> anyhow::Result<()> {
        let _ = &ctx; // Mark as used to avoid unused warning
        // Emit uploadfinalizingevent event
        if let Some(_publisher) = &self.event_publisher {
            // Custom event: uploadfinalizingevent
        }
        Ok(())
    }
}

/// Handler for entering completed state
pub struct UploadSessionOnEnterCompletedHandler {
    pub event_publisher: Option<Arc<crate::domain::event::UploadSessionEventPublisher>>,
}

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

#[async_trait]
impl TriggerHandler<UploadSessionTriggerContext, UploadSessionTriggerEvent> for UploadSessionOnEnterCompletedHandler {
    fn events(&self) -> Vec<UploadSessionTriggerEvent> {
        vec![TriggerEvent::OnEnterState("completed".to_string())]
    }

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

/// Handler for entering failed state
pub struct UploadSessionOnEnterFailedHandler {
    pub event_publisher: Option<Arc<crate::domain::event::UploadSessionEventPublisher>>,
}

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

#[async_trait]
impl TriggerHandler<UploadSessionTriggerContext, UploadSessionTriggerEvent> for UploadSessionOnEnterFailedHandler {
    fn events(&self) -> Vec<UploadSessionTriggerEvent> {
        vec![TriggerEvent::OnEnterState("failed".to_string())]
    }

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

/// Handler for entering expired state
pub struct UploadSessionOnEnterExpiredHandler {
    pub event_publisher: Option<Arc<crate::domain::event::UploadSessionEventPublisher>>,
}

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

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

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

/// Create a default registry pre-populated with all handlers for UploadSession.
pub fn upload_session_trigger_registry() -> UploadSessionTriggerRegistry {
    TriggerRegistry::build(|r| {
        r.register(Arc::new(UploadSessionAfterCreateHandler1::new()));
        r.register(Arc::new(UploadSessionAfterCreateHandler2::new()));
        r.register(Arc::new(UploadSessionAfterCreateHandler3::new()));
        r.register(Arc::new(UploadSessionAfterCreateHandler4::new()));
        r.register(Arc::new(UploadSessionAfterCreateHandler5::new()));
        r.register(Arc::new(UploadSessionOnEnterInitiatedHandler::new()));
        r.register(Arc::new(UploadSessionOnEnterUploadingHandler::new()));
        r.register(Arc::new(UploadSessionOnEnterCompletingHandler::new()));
        r.register(Arc::new(UploadSessionOnEnterCompletedHandler::new()));
        r.register(Arc::new(UploadSessionOnEnterFailedHandler::new()));
        r.register(Arc::new(UploadSessionOnEnterExpiredHandler::new()));
    })
}