Sync

src/communities/interactables/category.rs

@@ -0,0 +1,121 @@
+use crate::communities::{community::Community, interactables::interactable::Interactable};
+use async_trait::async_trait;
+use json::JsonValue;
+use std::any::Any;
+use std::sync::Arc;
+use ttp_core::CommunicationValue;
+use uuid::Uuid;
+
+pub struct Category {
+    id: Uuid,
+    name: String,
+    path: String,
+    community: Arc<Community>,
+    children: Vec<Arc<Box<dyn Interactable>>>,
+}
+impl Category {
+    pub fn new() -> Category {
+        Category {
+            id: Uuid::new_v4(),
+            name: String::new(),
+            path: String::new(),
+            community: Arc::new(Community::new()),
+            children: Vec::new(),
+        }
+    }
+    pub fn get_child(&self, path: String, name: String) -> Option<Arc<Box<dyn Interactable>>> {
+        if path.is_empty() {
+            self.children
+                .iter()
+                .find(|child| child.get_name() == &name)
+                .cloned()
+        } else {
+            let sub_module = path.split("/").next().unwrap();
+            let next = self
+                .children
+                .iter()
+                .find(|child| child.get_name() == sub_module)
+                .unwrap();
+            if next.get_codec() == "category" {
+                let next_cat = next.as_any().downcast_ref::<Category>().unwrap();
+                next_cat.get_child(path, name)
+            } else {
+                Some(next.clone())
+            }
+        }
+    }
+    pub fn get_children(&self) -> Vec<Arc<Box<dyn Interactable>>> {
+        self.children.iter().map(|child| child.clone()).collect()
+    }
+}
+
+#[async_trait]
+impl Interactable for Category {
+    fn get_id(&self) -> &Uuid {
+        &self.id
+    }
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+    fn as_any_mut(&mut self) -> &mut dyn Any {
+        self
+    }
+    fn get_codec(&self) -> String {
+        "category".to_string()
+    }
+    fn set_name(&mut self, name: String) {
+        self.name = name;
+    }
+    fn set_path(&mut self, path: String) {
+        self.path = path;
+    }
+    fn get_community(&self) -> &Arc<Community> {
+        &self.community
+    }
+    fn set_community(&mut self, community: Arc<Community>) {
+        self.community = community;
+    }
+    fn get_name(&self) -> &String {
+        &self.name
+    }
+    fn get_path(&self) -> &String {
+        &self.path
+    }
+    fn get_total_path(&self) -> String {
+        String::new() + &self.path + "/" + &self.name
+    }
+    fn get_data(&self) -> JsonValue {
+        let mut v = JsonValue::new_object();
+        for child in &self.children {
+            let mut subject = JsonValue::new_object();
+            subject["codec"] = JsonValue::String(child.get_codec());
+            subject["data"] = child.get_data();
+            v[child.get_name()] = subject;
+        }
+        v
+    }
+    async fn run_function(&self, _cv: CommunicationValue) -> CommunicationValue {
+        CommunicationValue::new(CommunicationType::error)
+    }
+    fn to_json(&self) -> JsonValue {
+        let mut v = JsonValue::new_object();
+        v["children"] = JsonValue::new_array();
+        for child in &self.children {
+            let _ = v["children"].push(child.to_json());
+        }
+        v
+    }
+    fn load(
+        &mut self,
+        community: Arc<Community>,
+        id: Uuid,
+        path: String,
+        name: String,
+        _json: &JsonValue,
+    ) {
+        self.community = community;
+        self.id = id;
+        self.name = name;
+        self.path = path;
+    }
+}

src/communities/interactables/interactable.rs

@@ -0,0 +1,35 @@
+use crate::communities::community::Community;
+use async_trait::async_trait;
+use json::JsonValue;
+use std::any::Any;
+use std::sync::Arc;
+use ttp_core::CommunicationValue;
+use uuid::Uuid;
+
+pub type InteractableFactory = fn() -> Box<dyn Interactable>;
+
+#[async_trait]
+pub trait Interactable: Send + Sync + Any {
+    fn as_any(&self) -> &dyn Any;
+    fn as_any_mut(&mut self) -> &mut dyn Any;
+    fn get_codec(&self) -> String;
+    fn get_name(&self) -> &String;
+    fn get_path(&self) -> &String;
+    fn get_total_path(&self) -> String;
+    fn set_name(&mut self, name: String);
+    fn set_path(&mut self, path: String);
+    fn get_community(&self) -> &Arc<Community>;
+    fn set_community(&mut self, community: Arc<Community>);
+    async fn run_function(&self, cv: CommunicationValue) -> CommunicationValue;
+    fn get_data(&self) -> JsonValue;
+    fn get_id(&self) -> &Uuid;
+    fn to_json(&self) -> JsonValue;
+    fn load(
+        &mut self,
+        community: Arc<Community>,
+        id: Uuid,
+        path: String,
+        name: String,
+        json: &JsonValue,
+    );
+}

src/communities/interactables/registry.rs

@@ -0,0 +1,75 @@
+use crate::communities::community::Community;
+use crate::communities::interactables::category::Category;
+use crate::communities::interactables::interactable::{Interactable, InteractableFactory};
+use crate::communities::interactables::text_chat::TextChat;
+use crate::communities::interactables::voice_chat::VoiceChat;
+use crate::util::file_util;
+use json::JsonValue;
+use once_cell::sync::Lazy;
+use std::collections::HashMap;
+use std::sync::Arc;
+use tokio::sync::Mutex;
+use uuid::Uuid;
+
+pub static INTERACTABLE_REGISTRY: Lazy<Arc<Mutex<HashMap<String, InteractableFactory>>>> =
+    Lazy::new(|| Arc::new(Mutex::new(HashMap::new())));
+pub async fn load_interactables() {
+    INTERACTABLE_REGISTRY
+        .lock()
+        .await
+        .insert(TextChat::new().get_codec(), || {
+            Box::new(TextChat::new()) as Box<dyn Interactable>
+        });
+    INTERACTABLE_REGISTRY
+        .lock()
+        .await
+        .insert(VoiceChat::new().get_codec(), || {
+            Box::new(VoiceChat::new()) as Box<dyn Interactable>
+        });
+    INTERACTABLE_REGISTRY
+        .lock()
+        .await
+        .insert(Category::new().get_codec(), || {
+            Box::new(Category::new()) as Box<dyn Interactable>
+        });
+}
+pub async fn register_interactable(name: String, interactable: InteractableFactory) {
+    INTERACTABLE_REGISTRY
+        .lock()
+        .await
+        .insert(name.to_string(), interactable)
+        .unwrap();
+}
+pub async fn get_interactable(name: &str) -> Box<dyn Interactable> {
+    INTERACTABLE_REGISTRY.lock().await.get(name).unwrap()()
+}
+pub async fn save(interactable: &Arc<Box<dyn Interactable>>) {
+    let mut json_object: JsonValue = interactable.to_json().clone();
+    json_object["codec"] = JsonValue::String(interactable.get_codec());
+    json_object["id"] = JsonValue::String(interactable.get_id().to_string());
+    file_util::save_file(
+        &format!(
+            "communities/{}/interactables/{}",
+            interactable.get_community().get_name(),
+            interactable.get_path()
+        ),
+        &format!("{}.json", interactable.get_name()),
+        &json_object.to_string(),
+    );
+}
+pub async fn load(
+    c: Arc<Community>,
+    path: String,
+    name: String,
+) -> Box<dyn Interactable + 'static> {
+    let s = file_util::load_file(
+        &format!("communities/{}/interactables/{}", c.get_name(), path),
+        &format!("{}.json", name),
+    );
+    let json_object: JsonValue = json::parse(&s).unwrap();
+    let codec: String = json_object["codec"].as_str().unwrap().to_string();
+    let id: String = json_object["id"].as_str().unwrap().to_string();
+    let mut interactable = get_interactable(&codec).await;
+    interactable.load(c, Uuid::parse_str(&id).unwrap(), path, name, &json_object);
+    interactable
+}

src/communities/interactables/text_chat.rs

@@ -0,0 +1,261 @@
+use crate::{
+    communities::{
+        community::Community, community_connection::CommunityConnection,
+        interactables::interactable::Interactable,
+    },
+    log,
+    util::file_util::{get_children, load_file, save_file},
+};
+use async_trait::async_trait;
+use json::{JsonValue, array, object};
+use std::fs;
+use std::sync::Arc;
+use std::{any::Any, collections::HashMap};
+use ttp_core::{CommunicationType, CommunicationValue, DataTypes};
+use uuid::Uuid;
+pub struct TextChat {
+    id: Uuid,
+    name: String,
+    path: String,
+    community: Arc<Community>,
+}
+impl TextChat {
+    pub fn new() -> TextChat {
+        TextChat {
+            id: Uuid::new_v4(),
+            name: String::new(),
+            path: String::new(),
+            community: Arc::new(Community::new()),
+        }
+    }
+    pub fn add_message(&self, send_time: u128, sender: i64, message: &str) {
+        let user_dir = &format!(
+            "communities/{}/interactables/{}/{}",
+            self.get_community().get_name(),
+            self.get_path(),
+            self.get_name()
+        );
+
+        if let Err(e) = fs::create_dir_all(user_dir) {
+            log!("Failed to create chat directory: {}", e);
+            return;
+        }
+
+        let mut chunk_index = 0;
+        let mut message_chunk = array![];
+
+        // find latest chunk not full (max 800 msgs)
+        loop {
+            let file_name = format!("msgs_{}.json", chunk_index);
+            let file_content = load_file(&user_dir, &file_name);
+
+            if !file_content.is_empty() {
+                if let Ok(current_chunk) = json::parse(&file_content) {
+                    if current_chunk.is_array() && current_chunk.len() < 800 {
+                        message_chunk = current_chunk;
+                        break;
+                    }
+                } else {
+                    log!("Failed to parse existing JSON file: {}", file_name);
+                }
+            } else {
+                break;
+            }
+
+            chunk_index += 1;
+            if chunk_index > 1000 {
+                log!("Too many message chunks. Aborting add.");
+                return;
+            }
+        }
+
+        let json_obj = object! {
+            "timestamp" => send_time as i64,
+            "content" => message,
+            "sender" => sender.to_string(),
+        };
+
+        if let Err(e) = message_chunk.push(json_obj) {
+            log!("Failed to push new message into JSON array: {}", e);
+            return;
+        }
+
+        let file_name = format!("msgs_{}.json", chunk_index);
+        log!("Saving message to {}/{}", user_dir, file_name);
+        save_file(&user_dir, &file_name, &message_chunk.dump());
+    }
+    pub fn get_messages(&self, loaded_messages: i64, amount: i64) -> JsonValue {
+        let mut messages = array![];
+
+        let mut latest_chunk_index: i32 = -1;
+        let files = get_children(&format!(
+            "communities/{}/interactables/{}/{}",
+            self.get_community().get_name(),
+            self.get_path(),
+            self.get_name()
+        ));
+
+        for entry in files {
+            if let Some(num) = {
+                entry
+                    .strip_prefix("msgs_")
+                    .and_then(|s| s.strip_suffix(".json"))
+            } {
+                if let Ok(index) = num.parse::<i32>() {
+                    if index > latest_chunk_index {
+                        latest_chunk_index = index;
+                    }
+                }
+            }
+        }
+
+        if latest_chunk_index == -1 {
+            return messages;
+        }
+
+        let mut to_skip = loaded_messages;
+        let mut needed = amount;
+
+        for chunk_index in (0..=latest_chunk_index).rev() {
+            if needed == 0 {
+                break;
+            }
+            let file_name = format!("msgs_{}.json", chunk_index);
+            let file_content = load_file(
+                &format!(
+                    "communities/{}/interactables/{}/{}",
+                    self.get_community().get_name(),
+                    self.get_path(),
+                    self.get_name()
+                ),
+                &file_name,
+            );
+            if file_content.is_empty() {
+                continue;
+            }
+            if let Ok(chunk) = json::parse(&file_content) {
+                for i in (0..chunk.len()).rev() {
+                    if needed == 0 {
+                        break;
+                    }
+                    if to_skip > 0 {
+                        to_skip -= 1;
+                        continue;
+                    }
+                    messages.push(chunk[i].clone()).unwrap();
+                    needed -= 1;
+                }
+            }
+        }
+
+        messages
+    }
+}
+#[async_trait]
+impl Interactable for TextChat {
+    fn get_id(&self) -> &Uuid {
+        &self.id
+    }
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+    fn as_any_mut(&mut self) -> &mut dyn Any {
+        self
+    }
+    fn get_codec(&self) -> String {
+        "text".to_string()
+    }
+    fn set_name(&mut self, name: String) {
+        self.name = name;
+    }
+    fn set_path(&mut self, path: String) {
+        self.path = path;
+    }
+    fn get_community(&self) -> &Arc<Community> {
+        &self.community
+    }
+    fn set_community(&mut self, community: Arc<Community>) {
+        self.community = community;
+    }
+    fn get_name(&self) -> &String {
+        &self.name
+    }
+    fn get_path(&self) -> &String {
+        &self.path
+    }
+    fn get_total_path(&self) -> String {
+        String::new() + &self.path + "/" + &self.name
+    }
+    fn get_data(&self) -> JsonValue {
+        JsonValue::new_object()
+    }
+    async fn run_function(&self, cv: CommunicationValue) -> CommunicationValue {
+        let payload = cv.get_data(DataTypes::payload).as_container().unwrap();
+        if cv.get_data(DataTypes::function).as_str().unwrap() == "get_messages" {
+            let amount = payload.get(DataTypes::amount).as_i64().unwrap();
+            let loaded_messages = payload["loaded_messages"].as_i64().unwrap();
+            let messages = self.get_messages(loaded_messages, amount).clone();
+            let mut payload = JsonValue::new_object();
+            payload["messages"] = messages;
+            return CommunicationValue::new(CommunicationType::function)
+                .with_id(cv.get_id())
+                .add_data_str(DataTypes::name, self.name.clone())
+                .add_data_str(DataTypes::path, self.path.clone())
+                .add_data_str(DataTypes::result, "message_chunk".to_string())
+                .add_data(DataTypes::payload, payload);
+        }
+        if cv.get_data(DataTypes::function).unwrap().as_str().unwrap() == "send_message" {
+            let message = payload["message"].as_str().unwrap();
+            let milliseconds_timestamp: u128 = std::time::SystemTime::now()
+                .duration_since(std::time::UNIX_EPOCH)
+                .unwrap()
+                .as_millis();
+            self.add_message(milliseconds_timestamp, cv.get_sender(), message);
+
+            let mut distribution_payload = JsonValue::new_object();
+            distribution_payload["message"] = JsonValue::String(message.to_string());
+            distribution_payload["sender_id"] = JsonValue::String(cv.get_sender().to_string());
+            distribution_payload["send_time"] =
+                JsonValue::String(milliseconds_timestamp.to_string());
+            let distribution = CommunicationValue::new(CommunicationType::update)
+                .with_id(cv.get_id())
+                .add_data_str(DataTypes::name, self.name.clone())
+                .add_data_str(DataTypes::path, self.path.clone())
+                .add_data_str(DataTypes::result, "message_live".to_string())
+                .add_data(DataTypes::payload, distribution_payload);
+
+            let connections: HashMap<i64, Vec<Arc<CommunityConnection>>> =
+                self.get_community().get_connections().await.clone();
+
+            for con in connections.values() {
+                for c in con {
+                    let cd: &Arc<CommunityConnection> = c;
+                    cd.send_message(&distribution).await;
+                }
+            }
+            return CommunicationValue::new(CommunicationType::function)
+                .with_id(cv.get_id())
+                .add_data_str(DataTypes::name, self.name.clone())
+                .add_data_str(DataTypes::path, self.path.clone())
+                .add_data_str(DataTypes::result, "message_received".to_string())
+                .add_data(DataTypes::payload, JsonValue::new_object());
+        }
+        CommunicationValue::new(CommunicationType::error).with_id(cv.get_id())
+    }
+    fn to_json(&self) -> JsonValue {
+        JsonValue::new_object()
+    }
+    fn load(
+        &mut self,
+        community: Arc<Community>,
+        id: Uuid,
+        path: String,
+        name: String,
+        _json: &JsonValue,
+    ) {
+        self.community = community;
+        self.id = id;
+        self.name = name;
+        self.path = path;
+    }
+}

src/communities/interactables/voice_chat.rs

@@ -0,0 +1,187 @@
+use crate::communities::{community::Community, interactables::interactable::Interactable};
+use async_trait::async_trait;
+use json::JsonValue;
+use std::sync::Arc;
+use std::{any::Any, sync::RwLock};
+use uuid::Uuid;
+pub enum CallUserState {
+    Active,
+    Muted,
+    Deafed,
+}
+impl CallUserState {
+    pub fn parse(state: &str) -> CallUserState {
+        match state {
+            "active" => CallUserState::Active,
+            "muted" => CallUserState::Muted,
+            "deafed" => CallUserState::Deafed,
+            _ => CallUserState::Active,
+        }
+    }
+    pub fn to_string(&self) -> String {
+        match self {
+            CallUserState::Active => "active".to_string(),
+            CallUserState::Muted => "muted".to_string(),
+            CallUserState::Deafed => "deafed".to_string(),
+        }
+    }
+}
+
+pub struct CallUser {
+    pub user_id: Uuid,
+    pub user_state: CallUserState,
+    pub streaming: bool,
+}
+
+pub struct VoiceChat {
+    id: Uuid,
+    name: String,
+    path: String,
+    community: Arc<Community>,
+    users: RwLock<Vec<CallUser>>,
+}
+impl VoiceChat {
+    pub fn new() -> VoiceChat {
+        VoiceChat {
+            id: Uuid::new_v4(),
+            name: String::new(),
+            path: String::new(),
+            community: Arc::new(Community::new()),
+            users: RwLock::new(Vec::new()),
+        }
+    }
+    pub fn update_user_state(
+        self: Arc<Self>,
+        user_id: Uuid,
+        state: CallUserState,
+        streaming: bool,
+    ) {
+        if let Some(user) = self
+            .users
+            .write()
+            .unwrap()
+            .iter_mut()
+            .find(|u| u.user_id == user_id)
+        {
+            user.user_state = state;
+            user.streaming = streaming;
+        }
+    }
+}
+#[async_trait]
+impl Interactable for VoiceChat {
+    fn get_id(&self) -> &Uuid {
+        &self.id
+    }
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+    fn as_any_mut(&mut self) -> &mut dyn Any {
+        self
+    }
+    fn get_codec(&self) -> String {
+        "voice".to_string()
+    }
+    fn set_name(&mut self, name: String) {
+        self.name = name;
+    }
+    fn set_path(&mut self, path: String) {
+        self.path = path;
+    }
+    fn get_community(&self) -> &Arc<Community> {
+        &self.community
+    }
+    fn set_community(&mut self, community: Arc<Community>) {
+        self.community = community;
+    }
+    fn get_name(&self) -> &String {
+        &self.name
+    }
+    fn get_path(&self) -> &String {
+        &self.path
+    }
+    fn get_total_path(&self) -> String {
+        String::new() + &self.path + "/" + &self.name
+    }
+    fn get_data(&self) -> JsonValue {
+        let mut data = JsonValue::new_object();
+        let mut active_users = JsonValue::new_object();
+        for user in self.users.read().unwrap().iter() {
+            let mut user_data = JsonValue::new_object();
+            let _ = user_data.insert("state", JsonValue::String(user.user_state.to_string()));
+            let _ = user_data.insert("streaming", JsonValue::Boolean(user.streaming));
+            let _ = active_users.insert(&user.user_id.to_string(), user_data);
+        }
+        let _ = data.insert("active_users", active_users);
+        data
+    }
+    async fn run_function(&self, cv: CommunicationValue) -> CommunicationValue {
+        let payload = cv.get_data(DataTypes::payload).unwrap();
+        let function = cv.get_data(DataTypes::function).unwrap().as_str().unwrap();
+
+        if function == "get_call" {
+            let sender_id = payload["sender_id"].as_str().unwrap();
+            let message_id = payload["message"].as_str().unwrap();
+            let send_time = payload["send_time"].as_str().unwrap();
+
+            let mut response_payload = JsonValue::new_object();
+            response_payload["sender_id"] = JsonValue::String(sender_id.to_string());
+            response_payload["message"] = JsonValue::String(message_id.to_string());
+            response_payload["send_time"] = JsonValue::String(send_time.to_string());
+
+            return CommunicationValue::new(CommunicationType::function)
+                .with_id(cv.get_id())
+                .add_data_str(DataTypes::name, self.name.clone())
+                .add_data_str(DataTypes::path, self.path.clone())
+                .add_data_str(DataTypes::result, "getting_call".to_string())
+                .add_data(DataTypes::payload, response_payload);
+        }
+
+        if function == "update_user_state" {
+            let user_id = payload["user_id"].as_str().unwrap();
+            let state = payload["state"].as_str().unwrap();
+            let streaming = payload["streaming"].as_bool().unwrap();
+
+            if let Some(user) = self
+                .users
+                .write()
+                .unwrap()
+                .iter_mut()
+                .find(|u| u.user_id == Uuid::parse_str(user_id).unwrap())
+            {
+                user.user_state = CallUserState::parse(state);
+                user.streaming = streaming;
+            }
+            let mut response_payload = JsonValue::new_object();
+            response_payload["user_id"] = JsonValue::String(user_id.to_string());
+            response_payload["state"] = JsonValue::String(state.to_string());
+            response_payload["streaming"] = JsonValue::Boolean(streaming);
+
+            return CommunicationValue::new(CommunicationType::update)
+                .with_id(cv.get_id())
+                .add_data_str(DataTypes::name, self.name.clone())
+                .add_data_str(DataTypes::path, self.path.clone())
+                .add_data_str(DataTypes::result, "user_changed".to_string())
+                .add_data(DataTypes::payload, response_payload);
+        }
+        CommunicationValue::new(CommunicationType::error).with_id(cv.get_id())
+    }
+
+    fn to_json(&self) -> JsonValue {
+        let v = JsonValue::new_object();
+        v
+    }
+    fn load(
+        &mut self,
+        community: Arc<Community>,
+        id: Uuid,
+        path: String,
+        name: String,
+        _json: &JsonValue,
+    ) {
+        self.community = community;
+        self.id = id;
+        self.name = name;
+        self.path = path;
+    }
+}