tensamin/iota
Watch
6
0
Fork
You've already forked iota
 0
Code Issues Pull requests 3 Projects Releases 1 Packages Wiki Activity Actions

[Fix] moved language to logging

Browse source
This commit is contained in:
Alex Emmet 2026-04-08 11:36:42 +02:00
commit b37ec732f7
7 changed files with 46 additions and 29 deletions
Download patch file Download diff file Expand all files Collapse all files

80
iota-util/src/langu/language_creator.rs
View file

@ -1,80 +0,0 @@
use crate::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(())
}

105
iota-util/src/langu/language_manager.rs
View file

@ -1,105 +0,0 @@
use crate::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(),
}
}
}

2
iota-util/src/langu/mod.rs
View file

@ -1,2 +0,0 @@
pub mod language_creator;
pub mod language_manager;

134
iota-util/src/update_util.rs
View file

@ -1,134 +0,0 @@
/* This file is used for the auto update function for the Iota.
* It connects to the git server from methanium and checks if
* the version has updated inside the cargo.toml file.
* It is made by Yolokit and pasted in by AlexEmmet */
use anyhow::{Context, Result, anyhow};
use semver::Version;
use serde::Deserialize;
use std::fs::File;
use std::io::copy;
use tempfile::NamedTempFile;
const CURRENT_VERSION: &str = env!("CARGO_PKG_VERSION");
const API_BASE: &str = "https://git.methanium.net/api/v1";
const OWNER: &str = "Tensamin";
const REPO: &str = "Iota";
#[derive(Debug, Deserialize)]
struct Release {
tag_name: String,
assets: Vec<Asset>,
}
#[derive(Debug, Deserialize)]
struct Asset {
name: String,
browser_download_url: String,
}
async fn latest_release() -> Result<Release> {
let url = format!("{API_BASE}/repos/{OWNER}/{REPO}/releases/latest");
let response = reqwest::get(&url)
.await
.context("failed to query latest release.")?;
if !response.status().is_success() {
return Err(anyhow!("release API returned {}", response.status()));
}
Ok(response
.json()
.await
.context("failed to parse release JSON")?)
}
async fn parse_tag_version(tag: &str) -> Result<Version> {
let normalized = tag.strip_prefix('v').unwrap_or(tag);
Ok(Version::parse(normalized)?)
}
async fn current_version() -> Result<Version> {
Ok(Version::parse(CURRENT_VERSION)?)
}
async fn asset_name_for_current_platform() -> String {
let os = std::env::consts::OS;
let arch = std::env::consts::ARCH;
match (os, arch) {
("linux", "x86_64") => "iota-linux-x86_64".to_string(),
("linux", "aarch64") => "iota-linux-aarch64".to_string(),
("windows", "x86_64") => "iota-windows-x86_64.exe".to_string(),
("macos", "x86_64") => "iota-macos-x86_64".to_string(),
("macos", "aarch64") => "iota-macos-aarch64".to_string(),
_ => panic!("unsupported platform: {os}/{arch}"),
}
}
async fn download_asset(url: &str) -> Result<NamedTempFile> {
let mut response = reqwest::get(url)
.await
.context("failed to download asset")?;
if !response.status().is_success() {
return Err(anyhow!("asset download returned {}", response.status()));
}
let tmp = NamedTempFile::new().context("failed to create temp file")?;
let mut out = File::create(tmp.path()).context("failed to open temp file")?;
let bytes = response
.bytes()
.await
.context("failed to read response bytes")?;
std::fs::write(tmp.path(), &bytes).context("failed to write file")?;
Ok(tmp)
}
async fn check_for_update() -> Result<Option<Release>> {
let current = current_version().await?;
let release = latest_release().await?;
let latest = parse_tag_version(&release.tag_name).await?;
if latest > current {
Ok(Some(release))
} else {
Ok(None)
}
}
async fn perform_update() -> Result<bool> {
let Some(release) = check_for_update().await? else {
return Ok(false);
};
let wanted_asset = asset_name_for_current_platform().await;
let asset = release
.assets
.iter()
.find(|a| a.name == wanted_asset)
.ok_or_else(|| anyhow!("no matching asset found: {}", wanted_asset))?;
log!("Downloading update: {}", asset.name);
let downloaded = download_asset(&asset.browser_download_url).await?;
self_replace::self_replace(downloaded.path())
.context("failed to replace current executable")?;
Ok(true)
}
pub async fn check_update() -> Result<bool> {
if perform_update().await? {
return Ok(true);
} else {
return Ok(false);
}
}