[FIX] Migrated to Tensamin Transport Protocol

src/util/file_util.rs

@@ -0,0 +1,179 @@
+use std::fs::{self, File};
+use std::io::{self, BufReader, Read};
+use std::path::{Path, PathBuf};
+
+use crate::log;
+use crate::util::logger::PrintType;
+
+#[allow(dead_code)]
+pub fn delete_directory(path: &str) -> bool {
+    let dir = Path::new(&get_directory()).join(path);
+    delete_dir_recursive(&dir)
+}
+
+#[allow(dead_code)]
+fn delete_dir_recursive(directory: &Path) -> bool {
+    if !directory.exists() {
+        return false;
+    }
+    if let Err(e) = fs::remove_dir_all(directory) {
+        log!(
+            0,
+            PrintType::General,
+            "[IMPORTANT] Couldn't delete directory {}: {}",
+            directory.display(),
+            e,
+        );
+        return false;
+    }
+    true
+}
+
+#[allow(dead_code)]
+pub fn delete_user_directory(user_id: i64) {
+    let user_dir = Path::new(&get_directory())
+        .join("users")
+        .join(user_id.to_string());
+    let _ = delete_dir_recursive(&user_dir);
+}
+
+pub fn load_file_buf(path: &str, name: &str) -> io::Result<BufReader<File>> {
+    let dir = Path::new(&get_directory()).join(path);
+    let file_path = dir.join(name);
+
+    // Ensure the directory exists, create if necessary
+    if !dir.exists() {
+        if let Err(_) = fs::create_dir_all(&dir) {
+            return Err(io::Error::new(
+                io::ErrorKind::NotFound,
+                "Directory creation failed",
+            ));
+        }
+    }
+
+    // Create the file if it doesn't exist
+    if !file_path.exists() {
+        return Err(io::Error::new(
+            io::ErrorKind::NotFound,
+            "File creation failed",
+        ));
+    }
+
+    // Open the file and return a BufReader for efficient reading
+    let file = File::open(&file_path)?;
+    Ok(BufReader::new(file))
+}
+pub fn has_file(path: &str, name: &str) -> bool {
+    let dir = Path::new(&get_directory()).join(path);
+    let file_path = dir.join(name);
+
+    if !dir.exists() {
+        return false;
+    }
+
+    if !file_path.exists() {
+        return false;
+    }
+
+    true
+}
+pub fn has_dir(path: &str) -> bool {
+    let dir = Path::new(&get_directory()).join(path);
+
+    if !dir.exists() {
+        return false;
+    }
+
+    true
+}
+
+pub fn load_file(path: &str, name: &str) -> String {
+    let dir = Path::new(&get_directory()).join(path);
+    let file_path = dir.join(name);
+
+    if !dir.exists() {
+        if let Err(e) = fs::create_dir_all(&dir) {
+            log!(
+                0,
+                PrintType::General,
+                "[IMPORTANT] Couldn't create directories: {}",
+                e
+            );
+            return String::new();
+        }
+        return String::new();
+    }
+
+    if !file_path.exists() {
+        if let Err(e) = File::create(&file_path) {
+            log!(
+                0,
+                PrintType::General,
+                "[IMPORTANT] Couldn't create file: {}",
+                e
+            );
+        }
+        return String::new();
+    }
+
+    let mut content = String::new();
+    if let Ok(mut f) = File::open(&file_path) {
+        let _ = f.read_to_string(&mut content);
+    }
+    content
+}
+
+pub fn load_file_vec(path: &str, name: &str) -> Result<Vec<u8>, std::io::Error> {
+    let dir = Path::new(&get_directory()).join(path);
+    let file_path = dir.join(name);
+
+    std::fs::read(file_path)
+}
+
+pub fn save_file(path: &str, name: &str, value: &str) {
+    let dir = Path::new(&get_directory()).join(path);
+    let file_path = dir.join(name);
+
+    if !dir.exists() {
+        if let Err(e) = fs::create_dir_all(&dir) {
+            log!(
+                0,
+                PrintType::General,
+                "[IMPORTANT] Couldn't create directories: {}",
+                e
+            );
+            return;
+        }
+    }
+
+    if let Err(e) = fs::write(&file_path, value) {
+        log!(
+            0,
+            PrintType::General,
+            "[IMPORTANT] Couldn't write file {}: {}",
+            file_path.display(),
+            e
+        );
+    }
+}
+
+pub fn get_children(path: &str) -> Vec<String> {
+    let dir = Path::new(&get_directory()).join(path);
+    let mut children = Vec::new();
+    if let Ok(entries) = fs::read_dir(&dir) {
+        for entry in entries {
+            if let Ok(entry) = entry {
+                children.push(entry.file_name().to_string_lossy().to_string());
+            }
+        }
+    }
+    children
+}
+
+pub fn get_directory() -> String {
+    let exe = std::env::current_exe().unwrap_or_else(|_| PathBuf::from("."));
+    exe.parent()
+        .unwrap_or(Path::new("."))
+        .to_string_lossy()
+        .to_string()
+}

src/util/logger.rs

@@ -1,4 +1,5 @@
 use std::{
+    collections::HashMap,
     fs::{self, OpenOptions},
     io::Write,
     path::Path,
@@ -8,9 +9,7 @@ use std::{
 };
 
 use ansi_term::Color;
-use json::JsonValue;
-
-use crate::data::communication::CommunicationValue;
+use epsilon_core::{CommunicationValue, DataTypes, DataValue};
 
 static LOGGER: OnceLock<mpsc::Sender<LogMessage>> = OnceLock::new();
 
@@ -151,7 +150,7 @@ pub fn log_cv_internal(
     let formatted = format_cv(cv);
 
     log_internal(
-        cv.get_sender(),
+        cv.get_sender() as i64,
         print_type.unwrap_or(PrintType::General),
         prefix,
         false,
@@ -176,24 +175,80 @@ pub fn format_cv(cv: &CommunicationValue) -> String {
     let comm_type = cv.get_type().to_string();
     parts.push(format!("{}", comm_type));
 
-    let mut data_parts = Vec::new();
-    if let JsonValue::Object(data) = &cv.clone().to_json()["data"] {
-        for (key, value) in data.iter() {
-            let val_string = match value {
-                JsonValue::String(s) => s.clone(),
-                _ => value.dump(),
-            };
+    let data: &HashMap<DataTypes, DataValue> = cv.get_data_container();
 
-            data_parts.push(format!("{} {}", key, val_string));
-        }
-    }
+    let formated_data =
+        format_data_container(data.iter().map(|(k, v)| (k.clone(), v.clone())).collect());
 
-    if !data_parts.is_empty() {
-        parts.push(format!("{}", data_parts.join(", ")));
-    }
+    parts.push(format!("{}", formated_data));
 
     parts.join(": ")
 }
+
+fn format_data_container(data: Vec<(DataTypes, DataValue)>) -> String {
+    let parts: Vec<String> = data
+        .into_iter()
+        .map(|(key, value)| {
+            let key_str = key.to_string();
+
+            match value {
+                DataValue::Str(s) => format!("{}=\"{}\"", key_str, s),
+
+                DataValue::Container(inner) => {
+                    let inner_formatted = format_data_container(inner);
+                    format!("{}={{ {} }}", key_str, inner_formatted)
+                }
+
+                DataValue::Array(arr) => {
+                    let arr_formatted = format_array(arr);
+                    format!("{}=[{}]", key_str, arr_formatted)
+                }
+
+                DataValue::Bool(b) => format!("{}={}", key_str, b),
+
+                DataValue::BoolTrue => format!("{}=true", key_str),
+                DataValue::BoolFalse => format!("{}=false", key_str),
+
+                DataValue::Number(num) => format!("{}={}", key_str, num),
+
+                _ => "".to_string(),
+            }
+        })
+        .collect();
+
+    parts.join(", ")
+}
+
+fn format_array(arr: Vec<DataValue>) -> String {
+    let parts: Vec<String> = arr
+        .into_iter()
+        .map(|value| match value {
+            DataValue::Str(s) => format!("\"{}\"", s),
+
+            DataValue::Container(inner) => {
+                let inner_formatted = format_data_container(inner);
+                format!("{{ {} }}", inner_formatted)
+            }
+
+            DataValue::Array(inner_arr) => {
+                let formatted = format_array(inner_arr);
+                format!("[{}]", formatted)
+            }
+
+            DataValue::Bool(b) => b.to_string(),
+
+            DataValue::BoolTrue => "true".to_string(),
+            DataValue::BoolFalse => "false".to_string(),
+
+            DataValue::Number(num) => num.to_string(),
+
+            _ => String::new(),
+        })
+        .collect();
+
+    parts.join(", ")
+}
+
 #[macro_export]
 macro_rules! log_cv {
     ($kind:expr, $cv:expr) => {

src/util/mod.rs

@@ -1,3 +1,4 @@
 pub mod crypto_helper;
 pub mod crypto_util;
+pub mod file_util;
 pub mod logger;