ready-to-test

src/data.rs

@@ -1,35 +1,8 @@
-
 use reqwest::Client as HTTPClient;
-use serde::{Serialize, Deserialize};
 use serde_json::Value;
+use std::collections::HashMap;
 use std::error::Error;
 use std::env;
-use uuid::Uuid;
-use chrono::Utc;
-
-
-#[derive(Debug, Serialize, Deserialize)]
-#[serde(rename_all = "snake_case")]
-enum PayloadKind {
-    NewMessage,
-    NewFollower,
-    NewShout,
-    NewApproval,
-    NewComment,
-    NewRate,
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-struct Payload {
-    chat_id: Option<String>,
-    shout_id: Option<i32>,
-    author_id: Option<i32>,
-    topic_id: Option<i32>,
-    reaction_id: Option<i32>,
-    community_id: Option<i32>,
-    kind: PayloadKind,
-    body: String,
-}
 
 pub async fn get_auth_id(token: &str) -> Result<i32, Box<dyn Error>> {
     let api_base = env::var("API_BASE")?;
@@ -51,33 +24,69 @@ pub async fn get_auth_id(token: &str) -> Result<i32, Box<dyn Error>> {
     Ok(id)
 }
 
-pub async fn create_first_chat(author_id: i32, con: &mut redis::aio::Connection) -> Result<Vec<String>, Box<dyn Error>> {
-    let chat_id = Uuid::new_v4().to_string();
-    let members = vec![author_id.to_string(), "1".to_string()];
-    let timestamp = Utc::now().timestamp();
 
-    let chat = serde_json::json!({
-        "id": chat_id.clone(),
-        "admins": members.clone(),
-        "members": members.clone(),
-        "title": "",
-        "createdBy": author_id,
-        "createdAt": timestamp,
-        "updatedAt": timestamp,
-    });
-
-    let _: () = redis::pipe()
-        .atomic()
-        .cmd("SADD")
-        .arg(format!("chats_by_author/{}", author_id))
-        .arg(&chat_id)
-        .ignore()
-        .set(format!("chats/{}", chat_id), chat.to_string())
-        .ignore()
-        .set(format!("chats/{}/next_message_id", chat_id), "0")
-        .ignore()
-        .query_async(con)
+async fn get_shout_followers(shout_id: &str) -> Result<Vec<i32>, Box<dyn Error>> {
+    let api_base = env::var("API_BASE")?;
+    let gql = format!(r#"
+        query {{
+            shoutFollowers(shout: "{}") {{
+                follower {{
+                    id
+                }}
+            }}
+        }}
+    "#, shout_id);
+    let client = reqwest::Client::new();
+    let response = client
+        .post(&api_base)
+        .body(gql)
+        .send()
         .await?;
 
-    Ok(vec![chat_id])
+    let response_body: serde_json::Value = response.json().await?;
+
+    let ids: Vec<i32> = response_body["data"]["shoutFollowers"]
+        .as_array()
+        .ok_or("Failed to parse follower array")?
+        .iter()
+        .filter_map(|f| f["follower"]["id"].as_i64().map(|id| id as i32))
+        .collect();
+
+    Ok(ids)
+}
+
+
+pub async fn is_fitting(listener_id: i32, payload: HashMap<String, String>) -> Result<bool, &'static str> {
+    match payload.get("kind") {
+        Some(kind) => {
+            match kind.as_str() {
+                "new_follower" => {
+                    // payload is AuthorFollower
+                    Ok(payload.get("author").unwrap().to_string() == listener_id.to_string())
+                },
+                "new_reaction" => {
+                    // payload is Reaction
+                    let shout_id = payload.get("shout").unwrap();
+                    let recipients = get_shout_followers(shout_id).await.unwrap();
+
+                    Ok(recipients.contains(&listener_id))
+                },
+                "new_shout" => {
+                    // payload is Shout
+                    // TODO: check all community subscribers if no then
+                    // check all topics subscribers if no then
+                    // check all authors subscribers
+                    Ok(true)
+                },
+                "new_message" => {
+                    // payload is Chat
+                    let members_str = payload.get("members").unwrap();
+                    let members = serde_json::from_str::<Vec<String>>(members_str).unwrap();
+                    Ok(members.contains(&listener_id.to_string()))
+                },
+                _ => Err("Invalid kind"),
+            }
+        },
+        None => Err("No kind provided"),
+    }
 }