bpm-engine-core 0.2.0

Core types and traits for the BPM engine (process, token, node)
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

// Placeholder; full content in step 2 (payloads + event_from_outbox need serde_json).
pub mod payloads {
    use std::collections::HashMap;

    #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
    pub struct ProcessStarted {
        pub process_id: String,
        pub instance_id: String,
        #[serde(default)]
        pub initial_variables: Option<HashMap<String, String>>,
    }

    #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
    pub struct TokenArrived {
        pub instance_id: String,
        pub token_id: String,
        pub node_id: String,
    }

    #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
    pub struct TokenCompleted {
        pub instance_id: String,
        pub token_id: String,
    }

    #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
    pub struct UserTaskCreated {
        pub instance_id: String,
        pub node_id: String,
    }

    #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
    pub struct UserTaskCompleted {
        pub task_id: String,
        pub instance_id: String,
        pub node_id: String,
        pub variables: HashMap<String, String>,
    }

    #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
    pub struct TimerFired {
        pub timer_id: String,
        pub token_id: String,
    }

    #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
    pub struct TimerScheduled {
        pub timer_id: String,
        pub instance_id: String,
        pub token_id: String,
        pub node_id: String,
        pub fire_at: u64,
    }

    #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
    pub struct TokenFailed {
        pub instance_id: String,
        pub token_id: String,
        pub node_id: String,
        pub reason: String,
    }

    #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
    pub struct SagaStarted {
        pub instance_id: String,
        pub token_id: String,
        pub node_id: String,
    }

    #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
    pub struct SagaCompleted {
        pub instance_id: String,
        pub token_id: String,
        pub node_id: String,
    }

    #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
    pub struct ProcessCompleted {
        pub instance_id: String,
    }
}

#[derive(Debug, Clone)]
pub enum EngineEvent {
    ProcessStarted(payloads::ProcessStarted),
    TokenArrived(payloads::TokenArrived),
    TokenCompleted(payloads::TokenCompleted),
    UserTaskCreated(payloads::UserTaskCreated),
    UserTaskCompleted(payloads::UserTaskCompleted),
    TimerFired(payloads::TimerFired),
    TimerScheduled(payloads::TimerScheduled),
    TokenFailed(payloads::TokenFailed),
    SagaStarted(payloads::SagaStarted),
    SagaCompleted(payloads::SagaCompleted),
    ProcessCompleted(payloads::ProcessCompleted),
}

pub fn event_from_outbox(event_type: &str, payload: &str) -> Option<EngineEvent> {
    let ev = match event_type {
        "ProcessStarted" => EngineEvent::ProcessStarted(serde_json::from_str(payload).ok()?),
        "TokenArrived" => EngineEvent::TokenArrived(serde_json::from_str(payload).ok()?),
        "TokenCompleted" => EngineEvent::TokenCompleted(serde_json::from_str(payload).ok()?),
        "UserTaskCreated" => EngineEvent::UserTaskCreated(serde_json::from_str(payload).ok()?),
        "UserTaskCompleted" => EngineEvent::UserTaskCompleted(serde_json::from_str(payload).ok()?),
        "TimerFired" => EngineEvent::TimerFired(serde_json::from_str(payload).ok()?),
        "TimerScheduled" => EngineEvent::TimerScheduled(serde_json::from_str(payload).ok()?),
        "TokenFailed" => EngineEvent::TokenFailed(serde_json::from_str(payload).ok()?),
        "SagaStarted" => EngineEvent::SagaStarted(serde_json::from_str(payload).ok()?),
        "SagaCompleted" => EngineEvent::SagaCompleted(serde_json::from_str(payload).ok()?),
        "ProcessCompleted" => EngineEvent::ProcessCompleted(serde_json::from_str(payload).ok()?),
        _ => return None,
    };
    Some(ev)
}