acts 0.17.2

a fast, lightweight, extensiable workflow engine
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

mod act_executor;
mod event_executor;
mod message_executor;
mod model_executor;
mod package_executor;
mod process_executor;
mod task_executor;

use serde::Serialize;
use serde_json::json;

use crate::{scheduler::Runtime, store::query::*};
use std::sync::Arc;

#[derive(Default, Debug)]
pub struct ExecutorQuery {
    pub query_by: Vec<(String, serde_json::Value)>,
    pub order_by: Vec<(String, bool)>,

    pub offset: usize,
    pub count: usize,
}

#[derive(Clone)]
pub struct Executor {
    msg: message_executor::MessageExecutor,
    act: act_executor::ActExecutor,
    model: model_executor::ModelExecutor,
    proc: process_executor::ProcessExecutor,
    task: task_executor::TaskExecutor,
    pack: package_executor::PackageExecutor,
    evt: event_executor::EventExecutor,
}

impl ExecutorQuery {
    pub fn new() -> Self {
        Self::default()
    }

    pub fn with_offset(mut self, offset: usize) -> Self {
        self.offset = offset;
        self
    }

    pub fn with_count(mut self, count: usize) -> Self {
        self.count = count;
        self
    }

    pub fn with_order(mut self, order: &str, rev: bool) -> Self {
        self.order_by.push((order.to_string(), rev));
        self
    }

    pub fn with_query<T: Serialize>(mut self, key: &str, value: T) -> Self {
        self.query_by.push((key.to_string(), json!(value)));
        self
    }

    pub fn into_cond(&self) -> Cond {
        let mut cond = Cond::and();
        for (k, v) in self.query_by.iter() {
            let mut key: &str = k;
            if k == "type" {
                key = "kind";
            }
            cond = cond.push(Expr::eq(key, v))
        }
        cond
    }

    pub fn into_query(&self) -> Query {
        let mut query = Query::new().set_offset(self.offset).set_limit(self.count);
        if !self.query_by.is_empty() {
            query = query.push(self.into_cond())
        }
        query.set_order(&self.order_by)
    }
}

impl Executor {
    pub(crate) fn new(rt: &Arc<Runtime>) -> Self {
        Self {
            msg: message_executor::MessageExecutor::new(rt),
            act: act_executor::ActExecutor::new(rt),
            model: model_executor::ModelExecutor::new(rt),
            proc: process_executor::ProcessExecutor::new(rt),
            task: task_executor::TaskExecutor::new(rt),
            pack: package_executor::PackageExecutor::new(rt),
            evt: event_executor::EventExecutor::new(rt),
        }
    }

    /// executor for related message functions
    pub fn msg(&self) -> &message_executor::MessageExecutor {
        &self.msg
    }

    /// executor for related act operations
    /// such as 'complete', 'back', 'cancel' ..
    pub fn act(&self) -> &act_executor::ActExecutor {
        &self.act
    }

    /// executor for related model functions
    pub fn model(&self) -> &model_executor::ModelExecutor {
        &self.model
    }

    /// executor for related process functions
    pub fn proc(&self) -> &process_executor::ProcessExecutor {
        &self.proc
    }

    /// executor for related task functions
    pub fn task(&self) -> &task_executor::TaskExecutor {
        &self.task
    }

    /// executor for related package functions
    pub fn pack(&self) -> &package_executor::PackageExecutor {
        &self.pack
    }

    /// executor for related event functions
    pub fn evt(&self) -> &event_executor::EventExecutor {
        &self.evt
    }
}