Initial commit

Author: HardCodeDev777

Cargo.toml

@@ -0,0 +1,17 @@
+[package]
+name = "Github-Game-Status"
+version = "1.0.0"
+edition = "2024"
+build = "build.rs"
+authors = ["HardCodeDev"]
+license = "MIT"
+repository = "https://github.com/HardCodeDev777/Github-Game-Status"
+
+[dependencies]
+slint = "1.12.1"
+serde = { version = "1.0.104", features = ["derive"] }
+serde_json = "1.0.140"
+sysinfo = "0.36.0"
+
+[build-dependencies]
+slint-build = "1.12.1"

build.rs

@@ -0,0 +1,3 @@
+fn main() {
+    slint_build::compile("ui/mainwindow.slint").unwrap();
+}

src/app_data.rs

@@ -0,0 +1,32 @@
+use serde::{Serialize, Deserialize};
+
+pub const SETUP_FILE_NAME: &str = "setupdata.json";
+pub const PROCESSES_DATA_FILE_NAME: &str = "processesdata.json";
+pub const DEFAULT_STATUS_BATCH_FILE_NAME: &str = "default_status_logic.bat";
+pub const STATUS_LOGIC_BATCH_FILE_NAME: &str = "status_logic.bat";
+
+#[derive(Serialize, Deserialize)]
+pub struct SetupData {
+    pub cli_path: String,
+    pub default_status_text: String,
+    pub default_status_emoji: String
+}
+
+impl SetupData{
+    pub fn new(cli_path: String, default_status_text: String, default_status_emoji: String) -> Self{
+        Self {cli_path, default_status_text, default_status_emoji}
+    }
+}
+
+#[derive(Serialize, Deserialize, Clone)]
+pub struct ProcessData{
+    pub game_file_name: String,
+    pub status_text: String,
+    pub status_emoji: String
+}
+
+impl ProcessData{
+    pub fn new(game_file_name: String, status_text: String, status_emoji: String) -> Self{
+        Self {game_file_name, status_text, status_emoji}
+    }
+}

src/core_logic.rs

@@ -0,0 +1,160 @@
+use std::fs::{File, remove_file};
+use std::io::Write;
+use std::error::Error;
+use std::process::Command;
+use std::{thread, time};
+use std::sync::{Arc, atomic};
+use slint::{SharedString, ToSharedString};
+use sysinfo::System;
+use crate::{app_data::{SetupData, ProcessData, PROCESSES_DATA_FILE_NAME, SETUP_FILE_NAME, STATUS_LOGIC_BATCH_FILE_NAME, DEFAULT_STATUS_BATCH_FILE_NAME}, json_utils::{write_setup_data_to_json, read_setup_data_from_json}};
+
+// Create new SetupData and saves it as JSON
+pub fn set_setup(path_to_cli: SharedString, default_status_text: SharedString, 
+    default_status_emoji: SharedString) -> Result<(), Box<dyn Error>> {
+    // Creates a new SetupData instance from the provided parameters
+    let setup_data = SetupData::new(path_to_cli.to_string(), 
+    default_status_text.to_string(), default_status_emoji.to_string());
+
+    // Write it to JSON
+    write_setup_data_to_json(SETUP_FILE_NAME, setup_data).expect("Error saving setup in Json in core logic!");
+
+    Ok(())
+}
+
+// Delete all data files
+pub fn delete_all_data() -> Result<(), Box<dyn Error>> {
+    // Remove batch files
+    remove_file(STATUS_LOGIC_BATCH_FILE_NAME)?;
+    remove_file(DEFAULT_STATUS_BATCH_FILE_NAME)?;
+
+    // Remove JSON data files
+    remove_file(SETUP_FILE_NAME)?;
+    remove_file(PROCESSES_DATA_FILE_NAME)?;
+
+    Ok(())
+}
+
+// Create a batch file that updates the user status
+pub fn make_process_batch(status_text: SharedString, status_emoji: SharedString) -> Result<(), Box<dyn Error>> {
+
+    // Create the batch file itself
+    let mut file = File::create(STATUS_LOGIC_BATCH_FILE_NAME)?;
+
+    // Read SetupData from JSON
+    let readed_setup_data = read_setup_data_from_json(SETUP_FILE_NAME).expect("Error reading setup data from Json in core logic!");
+
+    // Get GitHub CLI path from setup data
+    let cli_path = readed_setup_data.cli_path;
+
+    // Batch file command content
+    let bat_message = String::from(format!(
+        "@echo off \n cd {} \n gh user-status set --emoji \"{}\" \"{}\"", 
+        cli_path, status_emoji, status_text));
+
+    // Write commands to the batch file
+    file.write_all(bat_message.as_bytes())?;
+
+    // Run the batch file using cmd
+    let status = Command::new("cmd").args(["/C", STATUS_LOGIC_BATCH_FILE_NAME]).status()?;
+
+    // Check if the batch file executed successfully
+    if status.success() {
+        println!("Process batch ran successfully in core logic");
+    } else {
+        println!("Process batch failed to run correctly in core logic");
+    }
+
+    // Delete the batch file after execution
+    remove_file(STATUS_LOGIC_BATCH_FILE_NAME)?;
+
+    Ok(())
+}
+
+// Set the default user status if no matching process is found (via batch file)
+pub fn set_default_status_batch() -> Result<(), Box<dyn Error>> {
+    // Create the batch file
+    let mut file = File::create(DEFAULT_STATUS_BATCH_FILE_NAME)?;
+
+    // Read SetupData from JSON
+    let readed_setup_data = read_setup_data_from_json(SETUP_FILE_NAME).expect("Error reading setup data from Json in core logic!");
+
+    // Get required data
+    let cli_path = readed_setup_data.cli_path;
+    let default_status_text = readed_setup_data.default_status_text;
+    let default_status_emoji = readed_setup_data.default_status_emoji;
+
+    // Batch file command content
+    let bat_message = String::from(format!(
+        "@echo off \n cd {} \n gh user-status set --emoji \"{}\" \"{}\"", 
+        cli_path, default_status_emoji, default_status_text));
+
+    // Write commands to the batch file
+    file.write_all(bat_message.as_bytes())?;
+
+    // Run the batch file using cmd
+    let status = Command::new("cmd").args(["/C", DEFAULT_STATUS_BATCH_FILE_NAME]).status()?;
+
+    // Check if the batch file executed successfully
+    if status.success() {
+        println!("Default batch ran successfully in core logic");
+    } else {
+        println!("Default batch failed to run correctly in core logic");
+    }
+
+    // Delete the batch file after execution
+    remove_file(DEFAULT_STATUS_BATCH_FILE_NAME)?;
+
+    Ok(())
+}
+
+// Monitor running processes
+#[allow(unused_assignments)]
+pub fn monitor_processes(running: Arc<atomic::AtomicBool>, readed_data: Vec<ProcessData>) -> Result<(), Box<dyn Error>> {  
+    // Clone the shared running flag(Rust moment)
+    let running_clone = running.clone();
+    let running = running_clone.clone();
+
+    // Clone game process data
+    let readed_data_clone = readed_data.clone();
+
+    // Start a new thread
+    thread::spawn(move || {
+        // Initialize system information
+        let mut sys = System::new_all();
+
+        // Runs while the flag is set to true
+        while running.load(atomic::Ordering::Relaxed) {
+            // Refreshes system information
+            sys.refresh_all();
+
+            // Check if at least one monitored process is running
+            let matching_process_data = readed_data_clone.iter().find(|data| {
+                sys.processes().values().any(|p| {
+                    p.exe()
+                        .and_then(|path| path.file_name())
+                        .and_then(|name| name.to_str())
+                        .map(|name| name.to_lowercase() == data.game_file_name.to_lowercase())
+                        .unwrap_or(false)
+                })
+            });
+
+            // React based on whether a matching process is found
+            match matching_process_data {
+                Some(process_data) => {
+                    // Update status according to the running process
+                    make_process_batch(process_data.status_text.to_shared_string(), 
+                    process_data.status_emoji.to_shared_string())
+                    .expect("Error creating batch file in core logic!");
+                },
+                None => {
+                    // Set default status if no matching process is found
+                    set_default_status_batch().expect("Error setting default status in core logic!");
+                },
+            }
+
+            // Wait for 10 seconds before the next check
+            thread::sleep(time::Duration::from_secs(10));
+        }
+    });
+    Ok(())
+}

src/json_utils.rs

@@ -0,0 +1,118 @@
+use std::fs::{File, OpenOptions, remove_file};
+use std::io::{Read, Write};
+use std::path::Path;
+use std::error::Error;
+use serde_json::{to_string_pretty, from_str};
+use slint::SharedString;
+use crate::app_data::{SetupData, ProcessData};
+
+// Core function for writing to a JSON file
+fn write_to_json_core(path: &str, data: String) -> Result<(), Box<dyn Error>> {
+    let mut file: File;
+
+    // If the file exists
+    if Path::new(path).exists() {
+        // Open without overwriting
+        file = OpenOptions::new().write(true).open(path)?;
+    } else {
+        // Create a new file
+        file = File::create(path)?;
+    }
+    // Write all data to it
+    file.write_all(data.as_bytes())?;
+
+    Ok(())
+}
+
+// Write SetupData to JSON
+pub fn write_setup_data_to_json(path: &str, setup_data: SetupData) -> Result<(), Box<dyn Error>> {
+    // Serialize SetupData
+    let serialized_data = to_string_pretty(&setup_data).unwrap();
+    
+    // If the file already exists
+    if Path::new(path).exists() {
+        // Delete it first
+        remove_file(path)?;
+    }
+
+    // Write to JSON
+    write_to_json_core(path, serialized_data).expect("Error saving to JSON in core logic!");
+
+    Ok(())
+}
+
+// Write ProcessData to JSON
+#[allow(unused_assignments)]
+pub fn write_process_data_to_json(path: &str, game_file_name: SharedString, status_text: SharedString, 
+    status_emoji: SharedString) -> Result<(), Box<dyn Error>> {
+    // Variable to store the final JSON string
+    let mut serialized_data = String::new();
+
+    // Create new ProcessData from received parameters
+    let new_process_data = ProcessData::new(game_file_name.to_string(), status_text.to_string(), 
+    status_emoji.to_string());
+
+    // Clone it
+    let new_process_data_clone = new_process_data.clone();
+
+    // If the file exists
+    if Path::new(path).exists() {
+        // Read Vec<ProcessData> from it
+        let mut read_vec = read_processes_data_from_json(path)
+            .expect("Error reading game file names from JSON in core logic!");
+
+        // Push new ProcessData
+        read_vec.push(new_process_data);
+
+        // Serialize the vector
+        serialized_data = to_string_pretty(&read_vec).unwrap();
+    } else {
+        // Create a new vector of ProcessData
+        let mut vec_of_game_process_data = Vec::<ProcessData>::new();
+
+        // Add the newly created ProcessData
+        vec_of_game_process_data.push(new_process_data_clone);
+
+        // Serialize the vector
+        serialized_data = to_string_pretty(&vec_of_game_process_data).unwrap();
+    }
+
+    // Write to JSON
+    write_to_json_core(path, serialized_data).expect("Error saving to JSON in core logic!");
+
+    Ok(())
+}
+
+// Reads SetupData from JSON
+pub fn read_setup_data_from_json(path: &str) -> Result<SetupData, Box<dyn Error>> {
+    // Open the file at the given path
+    let mut file = File::open(path)?;
+
+    // String to store JSON data
+    let mut path_to_cli = String::new();
+
+    // Read JSON into the string
+    file.read_to_string(&mut path_to_cli)?;
+
+    // Deserialize into SetupData
+    let result: SetupData = from_str(&path_to_cli).unwrap();
+
+    Ok(result)
+}
+
+// Read ProcessData from JSON
+pub fn read_processes_data_from_json(path: &str) -> Result<Vec<ProcessData>, Box<dyn Error>> {
+    // Open the file at the given path
+    let mut file = File::open(path)?;
+
+    // String to store JSON data
+    let mut process_data_read = String::new();
+
+    // Read JSON into the string
+    file.read_to_string(&mut process_data_read)?;
+
+    // Deserialize into Vec<ProcessData>
+    let result: Vec<ProcessData> = from_str(&process_data_read).unwrap();
+
+    Ok(result)
+}

src/main.rs

@@ -0,0 +1,13 @@
+mod ui_logic;
+mod core_logic;
+mod json_utils;
+mod app_data;
+
+use std::error::Error;
+use ui_logic::make_app;
+
+fn main() -> Result<(), Box<dyn Error>> {
+    // Run the app
+    make_app().expect("Error in app work... How is this even happened?");
+    Ok(())
+}