flawless_utils/
workflow.rs

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
use flawless::message::Message;
use reqwest::Client;
use serde::{Deserialize, Serialize};

use crate::Server;

#[derive(Debug, Deserialize)]
pub struct WorkflowRef {
    pub(crate) server: Option<Server>,
    id: String,
    response: Option<String>,
}

impl WorkflowRef {
    pub fn id(&self) -> &str {
        &self.id
    }

    pub fn response(&self) -> &Option<String> {
        &self.response
    }

    /// Send message to workflow.
    pub async fn send_msg<M: Message>(&self, msg: M) -> Result<(), String> {
        let type_ = M::TYPE.to_string();
        let data = serde_json::to_string(&msg).map_err(|_err| "Serialization failed".to_string())?;
        let msg = Msg { type_, data };

        let send_msg_url = format!("{}/api/workflow/send-msg/{}", self.server.as_ref().unwrap().url, self.id);
        let client = Client::new();
        let mut request = client.post(send_msg_url).json(&msg);

        if let Some(auth_token) = &self.server.as_ref().unwrap().auth_token {
            request = request.header("Authorization", &format!("Bearer {}", auth_token));
        }

        match request.send().await {
            Ok(response) => {
                let response = response.text().await.map_err(|_err| format!("Unable to read response"))?;
                let response: SendMsgResponse = serde_json::from_str(&response)
                    .map_err(|err| format!("Failed to parse flawless response as json. {err}"))?;
                match response {
                    SendMsgResponse::Ok => Ok(()),
                    SendMsgResponse::Error(err) => Err(err),
                }
            }
            Err(err) => {
                Err(format!("Failed to send request to `{}`. {err}", self.server.as_ref().unwrap().url))
            }
        }
    }
}

#[derive(Debug, Serialize, Deserialize)]
pub struct Msg {
    #[serde(rename = "type")]
    pub type_: String,
    pub data: String,
}

#[derive(Debug, Deserialize)]
enum SendMsgResponse {
    #[serde(rename = "ok")]
    Ok,
    #[serde(rename = "error")]
    Error(String),
}