[Fix] moved language to logging

iota-logger/Cargo.toml

@@ -4,7 +4,11 @@ version = "0.1.0"
 edition = "2024"
 
 [dependencies]
-ratatui = "0.30.0"
-ttp-core = { git = "https://git.methanium.net/Tensamin/TTP.git", package = "ttp-core" }
 iota-state = { path = "../iota-state" }
 iota-util = { path = "../iota-util" }
+
+ttp-core = { git = "https://git.methanium.net/Tensamin/TTP.git", package = "ttp-core" }
+
+ratatui = "0.30.0"
+json = "0.12.4"
+once_cell = "1.21.4"

iota-logger/src/language_creator.rs

@@ -0,0 +1,81 @@
+use iota_util::file_util::save_file;
+
+use json::{self, JsonError, JsonValue};
+
+pub fn create_languages() -> Result<(), JsonError> {
+    let mut frontend_messages = JsonValue::new_object();
+    let mut omikron_messages = JsonValue::new_object();
+    let mut button_texts = JsonValue::new_object();
+    let mut general_texts = JsonValue::new_object();
+    let mut debug_messages = JsonValue::new_object();
+
+    frontend_messages.insert("error", "An error occurred")?;
+    // FRONTEND
+    frontend_messages.insert("get_chats", "User {} is loading conversations")?;
+    frontend_messages.insert("message_get", "User {} is loading messages")?;
+    frontend_messages.insert("get_communities", "User {} is loading communities")?;
+    frontend_messages.insert("client_connected", "Client {} connected")?;
+    frontend_messages.insert("add_conversation", "User {} added {}")?;
+    frontend_messages.insert("message_send", "User {} sent a message")?;
+
+    // OMIKRON
+    omikron_messages.insert(
+        "identification_response",
+        "IOTA identified on Omikron, {} users!",
+    )?;
+    omikron_messages.insert(
+        "send_message_failed",
+        "Failed to send message to Omikron: {}",
+    )?;
+    omikron_messages.insert("connection_failed", "Failed to connect to Omikron: {}")?;
+
+    // BUTTONS
+    button_texts.insert("exit", "Exit")?;
+
+    // GENERAL
+    general_texts.insert("iota_id", "IOTA ID: {}-####-####-####-############")?;
+    general_texts.insert("user_id", "USER ID: {}")?;
+    general_texts.insert("user_ids", "USER IDS: {}")?;
+    general_texts.insert("user_load_failed", "Failed to load user data")?;
+    general_texts.insert("setup_completed", "Launched")?;
+    general_texts.insert(
+        "community_active",
+        "Communities active on ws://{}:{}/community/...",
+    )?;
+    general_texts.insert(
+        "community_start_error",
+        "Failed to start community socket on port {}!",
+    )?;
+    general_texts.insert(
+        "community_start_error_admin",
+        "Failed to start community socket on port {}! Run with admin privileges",
+    )?;
+    // DEBUG
+    debug_messages.insert("", "")?;
+    save_file(
+        "languages/en_INT",
+        "frontend.json",
+        &frontend_messages.to_string(),
+    );
+    save_file(
+        "languages/en_INT",
+        "omikron.json",
+        &omikron_messages.to_string(),
+    );
+    save_file(
+        "languages/en_INT",
+        "buttons.json",
+        &button_texts.to_string(),
+    );
+    save_file(
+        "languages/en_INT",
+        "debug.json",
+        &debug_messages.to_string(),
+    );
+    save_file(
+        "languages/en_INT",
+        "general.json",
+        &general_texts.to_string(),
+    );
+    Ok(())
+}

iota-logger/src/language_manager.rs

@@ -0,0 +1,105 @@
+use iota_util::file_util::{self};
+use json::parse;
+use once_cell::sync::Lazy;
+use std::collections::HashMap;
+use std::sync::Mutex;
+
+#[derive(Clone)]
+pub struct LanguagePack {
+    language: HashMap<String, String>,
+}
+
+pub static LANGUAGE_PACK: Lazy<Mutex<LanguagePack>> =
+    Lazy::new(|| Mutex::new(LanguagePack::new("en_INT")));
+
+#[allow(dead_code)]
+pub fn get_language() -> LanguagePack {
+    LANGUAGE_PACK.lock().unwrap().clone()
+}
+
+#[allow(dead_code)]
+pub fn get_languages() -> Vec<String> {
+    file_util::get_children("languages")
+}
+
+#[allow(dead_code)]
+pub fn set_language(language: &str) {
+    LANGUAGE_PACK.lock().unwrap().language.clear();
+    LANGUAGE_PACK.lock().unwrap().load_language(language);
+}
+
+pub fn from_key(key: &str) -> String {
+    LANGUAGE_PACK
+        .lock()
+        .unwrap()
+        .get_translation(key)
+        .to_string()
+}
+
+pub fn format(key: &str, args: &[&str]) -> String {
+    let message = from_key(key);
+    let mut formatted = String::new();
+    let parts = message.split("{}");
+    for (i, part) in parts.enumerate() {
+        formatted.push_str(part);
+        if i < args.len() {
+            formatted.push_str(args[i]);
+        }
+    }
+    formatted
+}
+
+impl LanguagePack {
+    pub fn new(language: &str) -> Self {
+        let mut pack = LanguagePack {
+            language: HashMap::new(),
+        };
+        pack.load_language(language);
+        pack
+    }
+
+    pub fn load_language(&mut self, language: &str) {
+        let path = format!("languages/{}/", language);
+
+        let frontend_messages = file_util::load_file(&path, "frontend.json");
+        let frontend_messages = parse(&frontend_messages).unwrap();
+        for (key, value) in frontend_messages.entries() {
+            self.language
+                .insert(key.to_string(), value.as_str().unwrap().to_string());
+        }
+
+        let omikron_messages = file_util::load_file(&path, "omikron.json");
+        let omikron_messages = parse(&omikron_messages).unwrap();
+        for (key, value) in omikron_messages.entries() {
+            self.language
+                .insert(key.to_string(), value.as_str().unwrap().to_string());
+        }
+
+        let button_texts = file_util::load_file(&path, "buttons.json");
+        let button_texts = parse(&button_texts).unwrap();
+        for (key, value) in button_texts.entries() {
+            self.language
+                .insert(key.to_string(), value.as_str().unwrap().to_string());
+        }
+
+        let debug_messages = file_util::load_file(&path, "debug.json");
+        let debug_messages = parse(&debug_messages).unwrap();
+        for (key, value) in debug_messages.entries() {
+            self.language
+                .insert(key.to_string(), value.as_str().unwrap().to_string());
+        }
+
+        let general_messages = file_util::load_file(&path, "general.json");
+        let general_messages = parse(&general_messages).unwrap();
+        for (key, value) in general_messages.entries() {
+            self.language
+                .insert(key.to_string(), value.as_str().unwrap().to_string());
+        }
+    }
+    pub fn get_translation(&self, key: &str) -> String {
+        match self.language.get(key) {
+            Some(v) if !v.is_empty() => v.clone(),
+            _ => key.to_uppercase(),
+        }
+    }
+}

iota-logger/src/lib.rs

@@ -12,7 +12,8 @@ use ratatui::style::Color;
 use ttp_core::{CommunicationValue, DataTypes, DataValue};
 
 use iota_state::{APP_STATE, UNIQUE, UiLogEntry};
-use iota_util::langu::language_manager;
+mod language_creator;
+mod language_manager;
 
 static LOGGER: OnceLock<mpsc::Sender<LogMessage>> = OnceLock::new();
 
@@ -128,22 +129,6 @@ fn fixed_box(content: &str, width: usize) -> String {
     }
 }
 
-fn colorize(kind: PrintType, is_error: bool) -> Color {
-    if is_error {
-        return Color::Red;
-    }
-
-    match kind {
-        PrintType::Call => Color::Magenta,
-        PrintType::Client => Color::Green,
-        PrintType::Iota => Color::Yellow,
-        PrintType::Omikron => Color::Blue,
-        PrintType::Omega => Color::Cyan,
-        PrintType::General => Color::LightCyan,
-        PrintType::Command => Color::LightGreen,
-    }
-}
-
 pub fn log_internal_translated(
     kind: PrintType,
     prefix: String,