(rust) sqlx tests for armasuisse

rust/src/main.rs

@@ -1,70 +1,102 @@
 #![allow(dead_code, unused)]
 
-use std::{
-    io::{stdin, stdout, Error, Result, Write},
-    sync::{
-        atomic::{AtomicBool, Ordering}, Arc
-    },
+mod log_handler;
+mod log_structures;
+
+use chrono::{
+    DateTime, Local,
+};
+use clap::{Args, Parser, Subcommand};
+use sqlx::{
+    database, migrate::MigrateDatabase, query, query_as, sqlite::{
+        SqlitePool,
+        SqlitePoolOptions,
+    }, Row, Sqlite
 };
 
-fn main() -> Result<()> {
-    let running = Arc::new(AtomicBool::new(true));
-    let signal_running = running.clone();
-    let mut input: String = String::new();
-    let mut length: usize;
-    let mut tokens: Vec<&str>;
+use log_handler::Logger;
 
-    ctrlc::set_handler(move || {
-        signal_running.swap(false, Ordering::SeqCst);
-    });
+const DATABASE_URL: &str = "./test.db";
+const NAME_LOG_TABLE: &str = "logs";
+const NAME_TEST_TABLE: &str = "tests";
 
-    while running.load(Ordering::SeqCst) {
-        print!("> ");
-        _ = stdout().flush();
-        length = match stdin().read_line(&mut input) {
-            Ok(value) => value,
-            Err(error) => {
-                println!("\nError: {:#?}\n", error);
-                continue;
+#[derive(Parser, Debug)]
+#[clap(author, version, about, long_about=None)]
+struct Arguments {
+    /// subcommand
+    #[command(subcommand)]
+    pub action: Action,
+}
+
+#[allow(non_camel_case_types)]
+#[derive(Debug, Clone, Subcommand)]
+pub enum Action {
+    /// perform action on logs
+    #[command(subcommand)]
+    log(SubAction),
+
+    // /// perform action on tests
+    // test(SubAction),
+}
+
+#[allow(non_camel_case_types)]
+#[derive(Debug, Clone, Subcommand)]
+pub enum SubAction {
+    add(AddArgs),
+    get(GetArgs),
+    remove(RemoveArgs),
+    show(ShowArgs),
+}
+
+#[derive(Debug, Clone, Args)]
+pub struct AddArgs {
+    test: String,
+    message: String,
+}
+
+#[derive(Debug, Clone, Args)]
+pub struct GetArgs {
+    id: usize,
+}
+
+#[derive(Debug, Clone, Args)]
+pub struct RemoveArgs {
+    range_start: usize,
+    range_stop: usize,
+}
+
+#[derive(Debug, Clone, Args)]
+pub struct ShowArgs {
+    range_start: Option<usize>,
+    range_stop: Option<usize>,
+}
+
+#[tokio::main]
+async fn main() -> anyhow::Result<()> {
+    let args = Arguments::try_parse()?;
+    let logger = Logger::setup().await.unwrap();
+    let read_logger = logger.clone();
+
+    match args.action {
+        Action::log(subaction) => {
+            match subaction {
+                SubAction::add(subargs) => {
+                    logger.add_log(&subargs.test, &subargs.message).await.unwrap();
+                }
+                SubAction::get(subargs) => {
+                    let record = logger.query_for_log(&format!("DELETE FROM logs WHERE log_id = {} RETURNING log_id, log_time, test_name, log_message;", subargs.id)).await.unwrap();
+                    println!("record: {:#?}", record);
+                }
+                SubAction::remove(subargs) => {
+                    // remove_log(&db, subargs.range_start, subargs.range_stop).await?;
+                }
+                SubAction::show(subargs) => {
+                    let records = read_logger.query_for_log(&format!("SELECT * FROM logs;")).await.unwrap();
+                    println!("records: {:#?}", records);
+                }
             }
-        };
-
-        if 0 == length {
-            continue;
         }
-
-        input = input.trim_matches('\n').to_owned();
-        tokens = input.splitn(2,[' ']).collect();
-        if tokens.len() != 2 {
-            continue;
-        }
-
-        let cmd = tokens.remove(0);
-        let data = tokens.remove(0);
-
-        if cmd == "raw" {
-            println!("{:02x?}", data.as_bytes());
-        } else if cmd == "str" {
-            println!("{}", data);
-        }
-
-        input.clear();
     }
 
     Ok(())
 }
-
-// NOTE: not required, but might be fun to implement at some point
-// fn tokenise(input: &str, separator: Vec<&str>) -> Vec<String> {
-//     let separator = separator.join("");
-//     let mut tokens: Vec<String> = Vec::new();
-//     let mut quoted = false;
-//
-//     for char in input.chars() {
-//         input.len
-//         if separator.contains(char) {
-//         }
-//     }
-//
-//     tokens
-// }