bpmn-engine 0.1.0

BPMN 2.0 execution engine for Rust with JSON and XML format support
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

//! Task Elements
//!
//! Implementation of BPMN task elements with Activity/Capability traits.

use crate::activity::{Activity, ActivityError, ActivityResult};
use crate::capability::{Capability, CapabilityError, CapabilityResult, CapabilityProvider};
use crate::engine::ExecutionContext;
use crate::model::{ServiceTask, UserTask, ScriptTask, ManualTask};
use async_trait::async_trait;
use std::collections::HashMap;

/// Service Task Activity
///
/// Implements Activity trait for ServiceTask elements.
pub struct ServiceTaskActivity {
    task: ServiceTask,
}

impl ServiceTaskActivity {
    pub fn new(task: ServiceTask) -> Self {
        Self { task }
    }
}

#[async_trait]
impl Activity for ServiceTaskActivity {
    async fn execute(&self, context: &mut ExecutionContext) -> Result<ActivityResult, ActivityError> {
        // TODO: Implement service task execution
        // For now, just complete immediately
        Ok(ActivityResult::Completed { output_variables: None })
    }

    fn id(&self) -> &str {
        &self.task.base.id
    }

    fn name(&self) -> Option<&str> {
        self.task.base.name.as_deref()
    }
}

/// User Task Activity
///
/// Implements Activity trait for UserTask elements.
pub struct UserTaskActivity {
    task: UserTask,
}

impl UserTaskActivity {
    pub fn new(task: UserTask) -> Self {
        Self { task }
    }
}

#[async_trait]
impl Activity for UserTaskActivity {
    async fn execute(&self, context: &mut ExecutionContext) -> Result<ActivityResult, ActivityError> {
        // User tasks wait for user input
        Ok(ActivityResult::Waiting {
            reason: format!("User task '{}' waiting for user input", self.task.base.id),
        })
    }

    fn id(&self) -> &str {
        &self.task.base.id
    }

    fn name(&self) -> Option<&str> {
        self.task.base.name.as_deref()
    }
}

/// Script Task Activity
///
/// Implements Activity trait for ScriptTask elements.
pub struct ScriptTaskActivity {
    task: ScriptTask,
}

impl ScriptTaskActivity {
    pub fn new(task: ScriptTask) -> Self {
        Self { task }
    }
}

#[async_trait]
impl Activity for ScriptTaskActivity {
    async fn execute(&self, context: &mut ExecutionContext) -> Result<ActivityResult, ActivityError> {
        // TODO: Implement script execution
        // For now, just complete immediately
        Ok(ActivityResult::Completed { output_variables: None })
    }

    fn id(&self) -> &str {
        &self.task.base.id
    }

    fn name(&self) -> Option<&str> {
        self.task.base.name.as_deref()
    }
}

/// Manual Task Activity
///
/// Implements Activity trait for ManualTask elements.
pub struct ManualTaskActivity {
    task: ManualTask,
}

impl ManualTaskActivity {
    pub fn new(task: ManualTask) -> Self {
        Self { task }
    }
}

#[async_trait]
impl Activity for ManualTaskActivity {
    async fn execute(&self, context: &mut ExecutionContext) -> Result<ActivityResult, ActivityError> {
        // Manual tasks are completed immediately (they represent manual work outside the system)
        Ok(ActivityResult::Completed { output_variables: None })
    }

    fn id(&self) -> &str {
        &self.task.base.id
    }

    fn name(&self) -> Option<&str> {
        self.task.base.name.as_deref()
    }
}