acts-next 0.14.2

a fast, tiny, 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

use std::collections::HashMap;

use acts_next::{Executor, Message, MessageState, Result, Vars};
use serde_json::json;

type Action = fn(&Vars) -> Vars;
pub struct Client {
    actions: HashMap<String, Box<Action>>,
}

impl Client {
    pub fn new() -> Self {
        let actions: HashMap<_, _> = [
            ("init".to_string(), Box::new(Self::init as Action)),
            ("action1".to_string(), Box::new(Self::action1)),
            ("action2".to_string(), Box::new(Self::action2)),
            ("action3".to_string(), Box::new(Self::action3)),
            ("action4".to_string(), Box::new(Self::action4)),
        ]
        .into();

        Self { actions }
    }

    pub fn process(&self, executor: &Executor, message: &Message) -> Result<()> {
        if message.is_source("act") && message.is_state(MessageState::Created) {
            match self.actions.get(&message.key) {
                Some(action) => {
                    let outputs = action(&message.inputs);
                    executor
                        .act()
                        .complete(&message.pid, &message.tid, &outputs)?;
                    println!("action state: key={}", &message.key);
                    println!("inputs:{:?}", &message.inputs);
                    println!("outputs:{:?}", &outputs);
                    println!();
                }
                None => eprintln!("cannot find action '{}'", message.key),
            }
        }

        Ok(())
    }

    pub fn init(_inputs: &Vars) -> Vars {
        let mut vars = Vars::new();
        vars.insert("uid".to_string(), json!("u1"));

        // set the condition var
        vars.insert("v".to_string(), json!(10));
        vars
    }
    pub fn action1(_inputs: &Vars) -> Vars {
        let mut vars = Vars::new();
        vars.insert("uid".to_string(), json!("u2"));

        // change the result var
        vars.insert("v".to_string(), json!(100));

        vars
    }
    pub fn action2(inputs: &Vars) -> Vars {
        let result = inputs.get_value("v").unwrap().as_i64().unwrap();

        let mut vars = Vars::new();
        vars.insert("uid".to_string(), json!("u3"));

        // change the result var again
        vars.insert("v".to_string(), json!(result * 2));

        vars
    }
    pub fn action3(_inputs: &Vars) -> Vars {
        let mut vars = Vars::new();
        vars.insert("uid".to_string(), json!("u4"));

        vars
    }

    pub fn action4(inputs: &Vars) -> Vars {
        println!("result:{:?}", inputs.get_value("v"));

        let mut vars = Vars::new();
        vars.insert("uid".to_string(), json!("u5"));

        vars
    }
}