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
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
pub mod data;
pub use csml_interpreter::data::{
csml_result::CsmlResult, error_info::ErrorInfo, warnings::Warnings, Client,
};
use serde_json::json;
mod db_connectors;
mod error_messages;
mod encrypt;
mod init;
mod interpreter_actions;
mod send;
mod utils;
use data::*;
use db_connectors::{conversations::*, init_db, messages::*, state::*, DbConversation};
use init::*;
use interpreter_actions::interpret_step;
use utils::*;
use csml_interpreter::{
data::{csml_bot::CsmlBot, csml_flow::CsmlFlow, ContextJson, Hold, Memory},
load_components,
};
use md5::{Digest, Md5};
use std::{collections::HashMap, env, time::SystemTime};
pub fn start_conversation(
request: CsmlRequest,
mut bot: CsmlBot,
) -> Result<serde_json::Map<String, serde_json::Value>, EngineError> {
let now = SystemTime::now();
let formatted_event = format_event(json!(request))?;
bot.native_components = match load_components() {
Ok(components) => Some(components),
Err(err) => return Err(EngineError::Interpreter(err.format_error())),
};
let mut data = init_conversation_info(
get_default_flow(&bot)?.name.to_owned(),
&formatted_event,
&request,
&bot,
)?;
let msgs = vec![request.payload.to_owned()];
add_messages_bulk(&mut data, msgs, 0, "RECEIVE")?;
let flow = get_flow_by_id(&data.context.flow, &bot.flows)?;
check_for_hold(&mut data, flow)?;
let res = interpret_step(&mut data, formatted_event.to_owned(), &bot);
if let Ok(var) = env::var(DEBUG) {
if var == "true" {
let el = now.elapsed()?;
println!("Total time Manager - {}.{}", el.as_secs(), el.as_millis());
}
}
res
}
pub fn get_open_conversation(client: &Client) -> Result<Option<DbConversation>, EngineError> {
let mut db = init_db()?;
get_latest_open(client, &mut db)
}
pub fn get_steps_from_flow(bot: CsmlBot) -> HashMap<String, Vec<String>> {
csml_interpreter::get_steps_from_flow(bot)
}
pub fn validate_bot(bot: CsmlBot) -> CsmlResult {
csml_interpreter::validate_bot(bot)
}
pub fn user_close_all_conversations(client: Client) -> Result<(), EngineError> {
let mut db = init_db()?;
delete_state_key(&client, "hold", "position", &mut db)?;
close_all_conversations(&client, &mut db)
}
fn check_for_hold(data: &mut ConversationInfo, flow: &CsmlFlow) -> Result<(), EngineError> {
match get_state_key(&data.client, "hold", "position", &mut data.db) {
Ok(Some(string)) => {
let hold = serde_json::to_value(string)?;
let mut hash = Md5::new();
hash.update(flow.content.as_bytes());
let new_hash = format!("{:x}", hash.finalize());
if new_hash != hold["hash"] {
data.context.step = "start".to_owned();
delete_state_key(&data.client, "hold", "position", &mut data.db)?;
data.context.hold = None;
return Ok(());
}
data.context.hold = Some(Hold {
index: hold["index"]
.as_u64()
.ok_or(EngineError::Interpreter("hold index bad format".to_owned()))?
as usize,
step_vars: hold["step_vars"].clone(),
});
delete_state_key(&data.client, "hold", "position", &mut data.db)?;
}
Ok(None) => (),
Err(_) => (),
};
Ok(())
}