flawless-utils 1.0.0-beta.2

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),
}