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

//! Test Builders
//!
//! Builder pattern implementations for creating test data.

use bpmn_engine::model::ProcessDefinition;
use std::collections::HashMap;

/// Builder for ProcessDefinition
pub struct ProcessDefinitionBuilder {
    id: String,
    name: Option<String>,
    elements: Vec<serde_json::Value>,
    variables: HashMap<String, serde_json::Value>,
}

impl ProcessDefinitionBuilder {
    pub fn new(id: impl Into<String>) -> Self {
        Self {
            id: id.into(),
            name: None,
            elements: Vec::new(),
            variables: HashMap::new(),
        }
    }

    pub fn with_name(mut self, name: impl Into<String>) -> Self {
        self.name = Some(name.into());
        self
    }

    pub fn add_start_event(mut self, id: impl Into<String>, name: Option<&str>) -> Self {
        let mut event = serde_json::json!({
            "type": "startEvent",
            "id": id.into()
        });
        if let Some(n) = name {
            event["name"] = serde_json::Value::String(n.to_string());
        }
        self.elements.push(event);
        self
    }

    pub fn add_end_event(mut self, id: impl Into<String>, name: Option<&str>) -> Self {
        let mut event = serde_json::json!({
            "type": "endEvent",
            "id": id.into()
        });
        if let Some(n) = name {
            event["name"] = serde_json::Value::String(n.to_string());
        }
        self.elements.push(event);
        self
    }

    pub fn add_service_task(mut self, id: impl Into<String>, name: Option<&str>) -> Self {
        let mut task = serde_json::json!({
            "type": "serviceTask",
            "id": id.into()
        });
        if let Some(n) = name {
            task["name"] = serde_json::Value::String(n.to_string());
        }
        self.elements.push(task);
        self
    }

    pub fn add_sequence_flow(
        mut self,
        id: impl Into<String>,
        source_ref: impl Into<String>,
        target_ref: impl Into<String>,
    ) -> Self {
        let flow = serde_json::json!({
            "type": "sequenceFlow",
            "id": id.into(),
            "sourceRef": source_ref.into(),
            "targetRef": target_ref.into()
        });
        self.elements.push(flow);
        self
    }

    pub fn add_variable(mut self, name: impl Into<String>, value: serde_json::Value) -> Self {
        self.variables.insert(name.into(), value);
        self
    }

    pub fn build(self) -> Result<ProcessDefinition, serde_json::Error> {
        let mut process_json = serde_json::json!({
            "id": self.id,
            "isExecutable": true,
            "elements": self.elements,
            "variables": {}
        });

        if let Some(name) = self.name {
            process_json["name"] = serde_json::Value::String(name);
        }

        let json_str = serde_json::to_string(&process_json)?;
        ProcessDefinition::from_json(&json_str)
    }
}

impl Default for ProcessDefinitionBuilder {
    fn default() -> Self {
        Self::new("test_process")
    }
}