backbone_bucket/application/triggers/
processing_job_triggers.rs

1//! ProcessingJob trigger handlers
2//!
3//! Auto-generated by backbone-cli. Do not edit manually.
4
5use std::sync::Arc;
6use async_trait::async_trait;
7use backbone_core::trigger::{
8    ActionExecutor, TriggerContext, TriggerContextMut, TriggerEvent, TriggerHandler, TriggerRegistry,
9};
10
11use crate::domain::entity::ProcessingJob;
12
13pub type ProcessingJobTriggerEvent      = TriggerEvent;
14pub type ProcessingJobTriggerContext    = TriggerContext<ProcessingJob>;
15pub type ProcessingJobTriggerContextMut = TriggerContextMut<ProcessingJob>;
16pub type ProcessingJobActionExecutor    = ActionExecutor;
17pub type ProcessingJobTriggerRegistry   = TriggerRegistry<ProcessingJob>;
18pub type ProcessingJobTriggerHandlerObj =
19    dyn TriggerHandler<TriggerContext<ProcessingJob>, TriggerEvent>;
20
21// Lifecycle trigger handlers
22
23/// AfterCreate handler
24pub struct ProcessingJobAfterCreateHandler1 {
25    /// Event publisher for emitting domain events
26    pub event_publisher: Option<Arc<crate::domain::event::ProcessingJobEventPublisher>>,
27    /// Action executor for side effects
28    pub action_executor: Option<Arc<ProcessingJobActionExecutor>>,
29}
30
31impl ProcessingJobAfterCreateHandler1 {
32    pub fn new() -> Self {
33        Self {
34            event_publisher: None,
35            action_executor: None,
36        }
37    }
38
39    pub fn with_event_publisher(mut self, publisher: Arc<crate::domain::event::ProcessingJobEventPublisher>) -> Self {
40        self.event_publisher = Some(publisher);
41        self
42    }
43
44    pub fn with_action_executor(mut self, executor: Arc<ProcessingJobActionExecutor>) -> Self {
45        self.action_executor = Some(executor);
46        self
47    }
48}
49
50#[async_trait]
51impl TriggerHandler<ProcessingJobTriggerContext, ProcessingJobTriggerEvent> for ProcessingJobAfterCreateHandler1 {
52    fn events(&self) -> Vec<ProcessingJobTriggerEvent> {
53        vec![TriggerEvent::AfterCreate]
54    }
55
56    async fn handle(&self, ctx: &ProcessingJobTriggerContext) -> anyhow::Result<()> {
57        let _ = &ctx; // Mark as used to avoid unused warning
58        tracing::info!("Trigger executed for entity: {:?}", ctx.entity.id);
59        // Emit processingjobcreatedevent event
60        if let Some(publisher) = &self.event_publisher {
61            publisher.publish_created(ctx.entity.clone(), ctx.user_id.clone()).await?;
62        }
63        Ok(())
64    }
65}
66
67/// AfterCreate handler
68pub struct ProcessingJobAfterCreateHandler2 {
69    /// Event publisher for emitting domain events
70    pub event_publisher: Option<Arc<crate::domain::event::ProcessingJobEventPublisher>>,
71    /// Action executor for side effects
72    pub action_executor: Option<Arc<ProcessingJobActionExecutor>>,
73}
74
75impl ProcessingJobAfterCreateHandler2 {
76    pub fn new() -> Self {
77        Self {
78            event_publisher: None,
79            action_executor: None,
80        }
81    }
82
83    pub fn with_event_publisher(mut self, publisher: Arc<crate::domain::event::ProcessingJobEventPublisher>) -> Self {
84        self.event_publisher = Some(publisher);
85        self
86    }
87
88    pub fn with_action_executor(mut self, executor: Arc<ProcessingJobActionExecutor>) -> Self {
89        self.action_executor = Some(executor);
90        self
91    }
92}
93
94#[async_trait]
95impl TriggerHandler<ProcessingJobTriggerContext, ProcessingJobTriggerEvent> for ProcessingJobAfterCreateHandler2 {
96    fn events(&self) -> Vec<ProcessingJobTriggerEvent> {
97        vec![TriggerEvent::AfterCreate]
98    }
99
100    async fn handle(&self, ctx: &ProcessingJobTriggerContext) -> anyhow::Result<()> {
101        let _ = &ctx; // Mark as used to avoid unused warning
102        tracing::info!("Trigger executed for entity: {:?}", ctx.entity.id);
103        Ok(())
104    }
105}
106
107/// AfterCreate handler
108pub struct ProcessingJobAfterCreateHandler3 {
109    /// Event publisher for emitting domain events
110    pub event_publisher: Option<Arc<crate::domain::event::ProcessingJobEventPublisher>>,
111    /// Action executor for side effects
112    pub action_executor: Option<Arc<ProcessingJobActionExecutor>>,
113}
114
115impl ProcessingJobAfterCreateHandler3 {
116    pub fn new() -> Self {
117        Self {
118            event_publisher: None,
119            action_executor: None,
120        }
121    }
122
123    pub fn with_event_publisher(mut self, publisher: Arc<crate::domain::event::ProcessingJobEventPublisher>) -> Self {
124        self.event_publisher = Some(publisher);
125        self
126    }
127
128    pub fn with_action_executor(mut self, executor: Arc<ProcessingJobActionExecutor>) -> Self {
129        self.action_executor = Some(executor);
130        self
131    }
132}
133
134#[async_trait]
135impl TriggerHandler<ProcessingJobTriggerContext, ProcessingJobTriggerEvent> for ProcessingJobAfterCreateHandler3 {
136    fn events(&self) -> Vec<ProcessingJobTriggerEvent> {
137        vec![TriggerEvent::AfterCreate]
138    }
139
140    async fn handle(&self, ctx: &ProcessingJobTriggerContext) -> anyhow::Result<()> {
141        let _ = &ctx; // Mark as used to avoid unused warning
142        // Unknown action type 'dispatch': processingjob where status == 'pending' and
143        Ok(())
144    }
145}
146
147/// AfterCreate handler
148pub struct ProcessingJobAfterCreateHandler4 {
149    /// Event publisher for emitting domain events
150    pub event_publisher: Option<Arc<crate::domain::event::ProcessingJobEventPublisher>>,
151    /// Action executor for side effects
152    pub action_executor: Option<Arc<ProcessingJobActionExecutor>>,
153}
154
155impl ProcessingJobAfterCreateHandler4 {
156    pub fn new() -> Self {
157        Self {
158            event_publisher: None,
159            action_executor: None,
160        }
161    }
162
163    pub fn with_event_publisher(mut self, publisher: Arc<crate::domain::event::ProcessingJobEventPublisher>) -> Self {
164        self.event_publisher = Some(publisher);
165        self
166    }
167
168    pub fn with_action_executor(mut self, executor: Arc<ProcessingJobActionExecutor>) -> Self {
169        self.action_executor = Some(executor);
170        self
171    }
172}
173
174#[async_trait]
175impl TriggerHandler<ProcessingJobTriggerContext, ProcessingJobTriggerEvent> for ProcessingJobAfterCreateHandler4 {
176    fn events(&self) -> Vec<ProcessingJobTriggerEvent> {
177        vec![TriggerEvent::AfterCreate]
178    }
179
180    async fn handle(&self, ctx: &ProcessingJobTriggerContext) -> anyhow::Result<()> {
181        let _ = &ctx; // Mark as used to avoid unused warning
182        // Unknown action type 'update': processingjob
183        // Unknown action type 'update': processingjob
184        Ok(())
185    }
186}
187
188/// AfterCreate handler
189pub struct ProcessingJobAfterCreateHandler5 {
190    /// Event publisher for emitting domain events
191    pub event_publisher: Option<Arc<crate::domain::event::ProcessingJobEventPublisher>>,
192    /// Action executor for side effects
193    pub action_executor: Option<Arc<ProcessingJobActionExecutor>>,
194}
195
196impl ProcessingJobAfterCreateHandler5 {
197    pub fn new() -> Self {
198        Self {
199            event_publisher: None,
200            action_executor: None,
201        }
202    }
203
204    pub fn with_event_publisher(mut self, publisher: Arc<crate::domain::event::ProcessingJobEventPublisher>) -> Self {
205        self.event_publisher = Some(publisher);
206        self
207    }
208
209    pub fn with_action_executor(mut self, executor: Arc<ProcessingJobActionExecutor>) -> Self {
210        self.action_executor = Some(executor);
211        self
212    }
213}
214
215#[async_trait]
216impl TriggerHandler<ProcessingJobTriggerContext, ProcessingJobTriggerEvent> for ProcessingJobAfterCreateHandler5 {
217    fn events(&self) -> Vec<ProcessingJobTriggerEvent> {
218        vec![TriggerEvent::AfterCreate]
219    }
220
221    async fn handle(&self, ctx: &ProcessingJobTriggerContext) -> anyhow::Result<()> {
222        let _ = &ctx; // Mark as used to avoid unused warning
223        // Unknown action type 'update': storedfile
224        Ok(())
225    }
226}
227
228// State machine trigger handlers
229
230/// Handler for entering pending state
231pub struct ProcessingJobOnEnterPendingHandler {}
232
233impl ProcessingJobOnEnterPendingHandler {
234    pub fn new() -> Self { Self {} }
235}
236
237#[async_trait]
238impl TriggerHandler<ProcessingJobTriggerContext, ProcessingJobTriggerEvent> for ProcessingJobOnEnterPendingHandler {
239    fn events(&self) -> Vec<ProcessingJobTriggerEvent> {
240        vec![TriggerEvent::OnEnterState("pending".to_string())]
241    }
242
243    async fn handle(&self, ctx: &ProcessingJobTriggerContext) -> anyhow::Result<()> {
244        let _ = &ctx; // Mark as used to avoid unused warning
245        tracing::info!("Trigger executed for entity: {:?}", ctx.entity.id);
246        Ok(())
247    }
248}
249
250/// Handler for entering running state
251pub struct ProcessingJobOnEnterRunningHandler {
252    pub event_publisher: Option<Arc<crate::domain::event::ProcessingJobEventPublisher>>,
253}
254
255impl ProcessingJobOnEnterRunningHandler {
256    pub fn new() -> Self {
257        Self {
258            event_publisher: None,
259        }
260    }
261}
262
263#[async_trait]
264impl TriggerHandler<ProcessingJobTriggerContext, ProcessingJobTriggerEvent> for ProcessingJobOnEnterRunningHandler {
265    fn events(&self) -> Vec<ProcessingJobTriggerEvent> {
266        vec![TriggerEvent::OnEnterState("running".to_string())]
267    }
268
269    async fn handle(&self, ctx: &ProcessingJobTriggerContext) -> anyhow::Result<()> {
270        let _ = &ctx; // Mark as used to avoid unused warning
271        // Set started_at to current timestamp
272        // ctx.entity.started_at = Some(chrono::Utc::now();
273        // Note: Add closing parenthesis if using Some()
274        // Emit jobstartedevent event
275        if let Some(_publisher) = &self.event_publisher {
276            // Custom event: jobstartedevent
277        }
278        Ok(())
279    }
280}
281
282/// Handler for entering completed state
283pub struct ProcessingJobOnEnterCompletedHandler {
284    pub event_publisher: Option<Arc<crate::domain::event::ProcessingJobEventPublisher>>,
285}
286
287impl ProcessingJobOnEnterCompletedHandler {
288    pub fn new() -> Self {
289        Self {
290            event_publisher: None,
291        }
292    }
293}
294
295#[async_trait]
296impl TriggerHandler<ProcessingJobTriggerContext, ProcessingJobTriggerEvent> for ProcessingJobOnEnterCompletedHandler {
297    fn events(&self) -> Vec<ProcessingJobTriggerEvent> {
298        vec![TriggerEvent::OnEnterState("completed".to_string())]
299    }
300
301    async fn handle(&self, ctx: &ProcessingJobTriggerContext) -> anyhow::Result<()> {
302        let _ = &ctx; // Mark as used to avoid unused warning
303        // Set completed_at to current timestamp
304        // ctx.entity.completed_at = Some(chrono::Utc::now();
305        // Note: Add closing parenthesis if using Some()
306        // Emit jobcompletedevent event
307        if let Some(_publisher) = &self.event_publisher {
308            // Custom event: jobcompletedevent
309        }
310        tracing::info!("Trigger executed for entity: {:?}", ctx.entity.id);
311        Ok(())
312    }
313}
314
315/// Handler for entering failed state
316pub struct ProcessingJobOnEnterFailedHandler {
317    pub event_publisher: Option<Arc<crate::domain::event::ProcessingJobEventPublisher>>,
318}
319
320impl ProcessingJobOnEnterFailedHandler {
321    pub fn new() -> Self {
322        Self {
323            event_publisher: None,
324        }
325    }
326}
327
328#[async_trait]
329impl TriggerHandler<ProcessingJobTriggerContext, ProcessingJobTriggerEvent> for ProcessingJobOnEnterFailedHandler {
330    fn events(&self) -> Vec<ProcessingJobTriggerEvent> {
331        vec![TriggerEvent::OnEnterState("failed".to_string())]
332    }
333
334    async fn handle(&self, ctx: &ProcessingJobTriggerContext) -> anyhow::Result<()> {
335        let _ = &ctx; // Mark as used to avoid unused warning
336        // Set completed_at to current timestamp
337        // ctx.entity.completed_at = Some(chrono::Utc::now();
338        // Note: Add closing parenthesis if using Some()
339        // Emit jobfailedevent event
340        if let Some(_publisher) = &self.event_publisher {
341            // Custom event: jobfailedevent
342        }
343        tracing::info!("Trigger executed for entity: {:?}", ctx.entity.id);
344        Ok(())
345    }
346}
347
348/// Handler for entering cancelled state
349pub struct ProcessingJobOnEnterCancelledHandler {
350    pub event_publisher: Option<Arc<crate::domain::event::ProcessingJobEventPublisher>>,
351}
352
353impl ProcessingJobOnEnterCancelledHandler {
354    pub fn new() -> Self {
355        Self {
356            event_publisher: None,
357        }
358    }
359}
360
361#[async_trait]
362impl TriggerHandler<ProcessingJobTriggerContext, ProcessingJobTriggerEvent> for ProcessingJobOnEnterCancelledHandler {
363    fn events(&self) -> Vec<ProcessingJobTriggerEvent> {
364        vec![TriggerEvent::OnEnterState("cancelled".to_string())]
365    }
366
367    async fn handle(&self, ctx: &ProcessingJobTriggerContext) -> anyhow::Result<()> {
368        let _ = &ctx; // Mark as used to avoid unused warning
369        // Set completed_at to current timestamp
370        // ctx.entity.completed_at = Some(chrono::Utc::now();
371        // Note: Add closing parenthesis if using Some()
372        // Emit jobcancelledevent event
373        if let Some(_publisher) = &self.event_publisher {
374            // Custom event: jobcancelledevent
375        }
376        tracing::info!("Trigger executed for entity: {:?}", ctx.entity.id);
377        Ok(())
378    }
379}
380
381/// Create a default registry pre-populated with all handlers for ProcessingJob.
382pub fn processing_job_trigger_registry() -> ProcessingJobTriggerRegistry {
383    TriggerRegistry::build(|r| {
384        r.register(Arc::new(ProcessingJobAfterCreateHandler1::new()));
385        r.register(Arc::new(ProcessingJobAfterCreateHandler2::new()));
386        r.register(Arc::new(ProcessingJobAfterCreateHandler3::new()));
387        r.register(Arc::new(ProcessingJobAfterCreateHandler4::new()));
388        r.register(Arc::new(ProcessingJobAfterCreateHandler5::new()));
389        r.register(Arc::new(ProcessingJobOnEnterPendingHandler::new()));
390        r.register(Arc::new(ProcessingJobOnEnterRunningHandler::new()));
391        r.register(Arc::new(ProcessingJobOnEnterCompletedHandler::new()));
392        r.register(Arc::new(ProcessingJobOnEnterFailedHandler::new()));
393        r.register(Arc::new(ProcessingJobOnEnterCancelledHandler::new()));
394    })
395}
396
backbone_bucket/application/triggers/processing_job_triggers.rs

backbone_bucket/application/triggers/
processing_job_triggers.rs
