backbone-bucket 0.4.4

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

pub type ConversionJobTriggerEvent      = TriggerEvent;
pub type ConversionJobTriggerContext    = TriggerContext<ConversionJob>;
pub type ConversionJobTriggerContextMut = TriggerContextMut<ConversionJob>;
pub type ConversionJobActionExecutor    = ActionExecutor;
pub type ConversionJobTriggerRegistry   = TriggerRegistry<ConversionJob>;
pub type ConversionJobTriggerHandlerObj =
    dyn TriggerHandler<TriggerContext<ConversionJob>, TriggerEvent>;

// Lifecycle trigger handlers

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    async fn handle(&self, ctx: &ConversionJobTriggerContext) -> anyhow::Result<()> {
        let _ = &ctx; // Mark as used to avoid unused warning
        // Unknown action type 'dispatch': conversionjob where status == 'pending' and
        Ok(())
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

// State machine trigger handlers

/// Handler for entering pending state
pub struct ConversionJobOnEnterPendingHandler {}

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

#[async_trait]
impl TriggerHandler<ConversionJobTriggerContext, ConversionJobTriggerEvent> for ConversionJobOnEnterPendingHandler {
    fn events(&self) -> Vec<ConversionJobTriggerEvent> {
        vec![TriggerEvent::OnEnterState("pending".to_string())]
    }

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

/// Handler for entering processing state
pub struct ConversionJobOnEnterProcessingHandler {
    pub event_publisher: Option<Arc<crate::domain::event::ConversionJobEventPublisher>>,
}

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

#[async_trait]
impl TriggerHandler<ConversionJobTriggerContext, ConversionJobTriggerEvent> for ConversionJobOnEnterProcessingHandler {
    fn events(&self) -> Vec<ConversionJobTriggerEvent> {
        vec![TriggerEvent::OnEnterState("processing".to_string())]
    }

    async fn handle(&self, ctx: &ConversionJobTriggerContext) -> anyhow::Result<()> {
        let _ = &ctx; // Mark as used to avoid unused warning
        // Set started_at to current timestamp
        // ctx.entity.started_at = Some(chrono::Utc::now();
        // Note: Add closing parenthesis if using Some()
        // Emit conversionstartedevent event
        if let Some(_publisher) = &self.event_publisher {
            // Custom event: conversionstartedevent
        }
        Ok(())
    }
}

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

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

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

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

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

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

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

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

/// Handler for entering cancelled state
pub struct ConversionJobOnEnterCancelledHandler {
    pub event_publisher: Option<Arc<crate::domain::event::ConversionJobEventPublisher>>,
}

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

#[async_trait]
impl TriggerHandler<ConversionJobTriggerContext, ConversionJobTriggerEvent> for ConversionJobOnEnterCancelledHandler {
    fn events(&self) -> Vec<ConversionJobTriggerEvent> {
        vec![TriggerEvent::OnEnterState("cancelled".to_string())]
    }

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

/// Create a default registry pre-populated with all handlers for ConversionJob.
pub fn conversion_job_trigger_registry() -> ConversionJobTriggerRegistry {
    TriggerRegistry::build(|r| {
        r.register(Arc::new(ConversionJobAfterCreateHandler1::new()));
        r.register(Arc::new(ConversionJobAfterCreateHandler2::new()));
        r.register(Arc::new(ConversionJobAfterCreateHandler3::new()));
        r.register(Arc::new(ConversionJobAfterCreateHandler4::new()));
        r.register(Arc::new(ConversionJobAfterCreateHandler5::new()));
        r.register(Arc::new(ConversionJobOnEnterPendingHandler::new()));
        r.register(Arc::new(ConversionJobOnEnterProcessingHandler::new()));
        r.register(Arc::new(ConversionJobOnEnterCompletedHandler::new()));
        r.register(Arc::new(ConversionJobOnEnterFailedHandler::new()));
        r.register(Arc::new(ConversionJobOnEnterCancelledHandler::new()));
    })
}