Add basic model for messages + parsing

1 files changed, 0 insertions, 146 deletions

diff --git a/src/mattermost.rs b/src/mattermost.rs
deleted file mode 100644
index c8759c3..0000000
--- a/src/mattermost.rs
+++ /dev/null
@@ -1,146 +0,0 @@
-use anyhow::anyhow;
-use async_tungstenite::{tokio::connect_async, tungstenite::Message};
-use futures_util::{SinkExt, StreamExt};
-use serde_json::json;
-use tracing::{debug, warn};
-pub struct AuthData {
-    pub(crate) login: String,
-    pub(crate) password: String,
-}
-pub struct Client {
-    pub(crate) auth: AuthData,
-    pub(crate) url: String,
-    bearer_token: Option<String>,
-    client: reqwest::Client,
-}
-
-#[async_trait::async_trait]
-pub trait Handler {
-    async fn handle(
-        &self,
-        message: serde_json::Value,
-        client: &Client,
-    ) -> Result<(), anyhow::Error>;
-}
-
-impl Client {
-    pub(crate) fn new(auth: AuthData, url: &str) -> Self {
-        Self {
-            auth,
-            url: url.to_owned(),
-            bearer_token: None,
-            client: reqwest::Client::new(),
-        }
-    }
-    pub(crate) async fn update_bearer_token(&mut self) -> Result<(), anyhow::Error> {
-        debug!("Fetching bearer token from api");
-        let response = self
-            .client
-            .post(format!("{}/api/v4/users/login", self.url))
-            .json(&json!({
-                "login_id":self.auth.login,
-                "password":self.auth.password,
-            }))
-            .send()
-            .await?;
-        let token = response
-            .headers()
-            .get("token")
-            .ok_or(anyhow!("Haven't received bearer token in headers"))?
-            .to_str()?;
-        self.bearer_token = Some(token.to_owned());
-        debug!("Successfully updated bearer token");
-        Ok(())
-    }
-    pub(crate) async fn handle_websocket_stream<T: Handler>(
-        &mut self,
-        handler: T,
-    ) -> Result<(), anyhow::Error> {
-        let url = format!("{}/api/v4/websocket", self.url.replacen("http", "ws", 1));
-        let (mut ws_stream, _) = connect_async(url).await?;
-        let token = self
-            .bearer_token
-            .clone()
-            .ok_or(anyhow!("Missing bearer token"))?;
-        ws_stream
-            .send(Message::Text(
-                json!({"seq":1,"action":"authentication_challenge","data":{"token":token}})
-                    .to_string(),
-            ))
-            .await?;
-        while let Some(message) = ws_stream.next().await {
-            match message {
-                Ok(message) => match message {
-                    Message::Text(text) => {
-                        let json: Result<serde_json::Value, _> = serde_json::from_str(&text);
-                        match json {
-                            Ok(json) => {
-                                // debug!("Got json: {json}");
-                                if let Err(err) = handler.handle(json, &self).await {
-                                    warn!("Handler returned error: {err}");
-                                };
-                            }
-                            Err(err) => warn!("Error while deserializing: {err}"),
-                        }
-                    }
-                    Message::Close(_) => break,
-                    _ => {
-                        debug!("Message: {message:?}");
-                    }
-                },
-                Err(err) => warn!("Error {err} while reading message"),
-            }
-        }
-        Ok(())
-    }
-    pub(crate) async fn reply_to(
-        &self,
-        post: &serde_json::Value,
-        reply: String,
-    ) -> Result<(), anyhow::Error> {
-        let token = self
-            .bearer_token
-            .clone()
-            .ok_or(anyhow!("Missing bearer token"))?;
-        let object = post
-            .as_object()
-            .ok_or(anyhow!("Response from mattermost should be object"))?;
-        let id = object
-            .get("id")
-            .ok_or(anyhow!("missing id"))?
-            .as_str()
-            .ok_or(anyhow!("id should be a string"))?;
-        let root_id = object
-            .get("root_id")
-            .ok_or(anyhow!("missing root_id"))?
-            .as_str()
-            .ok_or(anyhow!("root_id should be a string"))?;
-        let post_id = if root_id == "" { id } else { root_id };
-        let channel_id = object
-            .get("channel_id")
-            .ok_or(anyhow!("missing channel_id"))?
-            .as_str()
-            .ok_or(anyhow!("channel_id should be a string"))?;
-
-        debug!("Sending response");
-        let response = self
-            .client
-            .post(format!("{}/api/v4/posts", self.url))
-            .json(&json!({
-                "channel_id":channel_id,
-                "root_id":post_id,
-                "message":&reply,
-            }))
-            .header("Authorization", format!("Bearer {token}"))
-            .send()
-            .await?;
-        let status = response.status();
-        let resp = response.text().await;
-        if !status.is_success() {
-            warn!("{:?}", resp);
-            return Err(anyhow!("Error {}", status));
-        }
-        debug!("Sent response");
-        Ok(())
-    }
-}