processcube_engine_client 0.3.0

5Minds ProcessCube® Engine client written in Rust
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
131
132
133
134
135
136
137
138
139
140
141
142

use serde::{Deserialize, Serialize};

#[derive(Serialize, Deserialize, Debug)]
#[serde(rename_all = "camelCase")]
pub struct ProcessModel {
    #[serde(rename = "processModelId")]
    pub id: String,
    #[serde(rename = "processModelName")]
    pub name: Option<String>,
    pub process_definition_id: String,
    pub version: Option<String>,
    pub custom_properties: serde_json::Value,
    pub is_executable: bool,
    pub lane_set: LaneSet,
    pub start_events: Vec<StartEvent>,
    pub end_events: Vec<EndEvent>,
    pub flow_nodes: Vec<FlowNode>,
}

#[derive(Serialize, Deserialize, Debug)]
#[serde(rename_all = "camelCase")]
pub struct ProcessModelList {
    pub process_models: Vec<ProcessModel>,
    pub total_count: u32,
}

#[derive(Serialize, Deserialize, Debug)]
#[serde(rename_all = "camelCase")]
pub struct ProcessStartRequest {
    pub start_event_id: String,
    pub correlation_id: String,
    pub initial_token: serde_json::Value,
    pub return_on: String,
    pub end_event_id: String,
}

#[derive(Serialize, Deserialize, Debug)]
#[serde(rename_all = "camelCase")]
pub struct ProcessStartResponse {
    pub process_instance_id: String,
    pub correlation_id: String,
    pub end_event_id: String,
    pub token_payload: serde_json::Value,
}

impl Default for ProcessStartResponse {
    fn default() -> Self {
        ProcessStartResponse {
            process_instance_id: String::new(),
            correlation_id: String::new(),
            end_event_id: String::new(),
            token_payload: serde_json::Value::Null,
        }
    }
}

#[derive(Serialize, Deserialize, Debug)]
#[serde(rename_all = "camelCase")]
pub struct LaneSet {
    lanes: Vec<Lane>,
}

#[derive(Serialize, Deserialize, Debug)]
#[serde(rename_all = "camelCase")]
pub struct Lane {
    id: String,
    extension_elements: Option<ExtensionElements>,
    flow_node_references: Option<Vec<String>>,
    name: Option<String>,
    child_lane_set: Option<Vec<String>>,
    documentation: Option<Vec<String>>,
}

#[derive(Serialize, Deserialize, Debug)]
#[serde(rename_all = "camelCase")]
pub struct ExtensionElements {
    camunda_execution_listener: Option<CamundaExecutionListener>,
    camunda_extension_properties: Vec<CamundaExtensionProperties>,
}

#[derive(Serialize, Deserialize, Debug)]
#[serde(rename_all = "camelCase")]
pub struct CamundaExecutionListener {
    class: String,
    event: String,
}

#[derive(Serialize, Deserialize, Debug)]
#[serde(rename_all = "camelCase")]
pub struct CamundaExtensionProperties {
    name: String,
    value: String,
}

#[derive(Serialize, Deserialize, Debug)]
#[serde(rename_all = "camelCase")]
pub struct StartEvent {
    id: String,
    name: String,
    process_model_id: String,
    process_model_name: String,
    custom_properties: serde_json::Value,
    flow_node_type: String,
    timer_type: Option<String>,
    timer_value: Option<String>,
    message_name: Option<String>,
    message_id: Option<String>,
    signal_name: Option<String>,
    signal_id: Option<String>,
    documentation: Option<Vec<String>>,
}

#[derive(Serialize, Deserialize, Debug)]
#[serde(rename_all = "camelCase")]
pub struct EndEvent {
    id: String,
    name: String,
    process_model_id: String,
    process_model_name: String,
    custom_properties: serde_json::Value,
    flow_node_type: String,
    error_name: Option<String>,
    error_code: Option<String>,
    error_message: Option<String>,
    message_name: Option<String>,
    message_id: Option<String>,
    signal_name: Option<String>,
    signal_id: Option<String>,
    documentation: Option<Vec<String>>,
}

#[derive(Serialize, Deserialize, Debug)]
#[serde(rename_all = "camelCase")]
pub struct FlowNode {
    id: String,
    name: String,
    custom_properties: serde_json::Value,
    flow_node_type: String,
    process_model_id: String,
    process_model_name: String,
    documentation: Option<Vec<String>>,
}