fix: check for db connection first

swordfish-common/src/database/katana.rs

@@ -1,8 +1,8 @@
-use mongodb::Collection;
-
 use crate::database;
 use crate::structs::Card;
+use mongodb::Collection;
 use std::sync::OnceLock;
+use std::time::{SystemTime, UNIX_EPOCH};
 
 static KATANA: OnceLock<Collection<Card>> = OnceLock::new();
 
@@ -25,11 +25,54 @@ pub fn init() {
 
 pub async fn query_card(name: &str, series: &str) -> Option<Card> {
     // todo!("Query card from database");
-    KATANA.get().unwrap().find_one(
+    KATANA
-        mongodb::bson::doc! {
+        .get()
-            "name": name,
+        .unwrap()
-            "series": series
+        .find_one(
-        },
+            mongodb::bson::doc! {
-        None,
+                "name": name,
-    ).await.unwrap()
+                "series": series
+            },
+            None,
+        )
+        .await
+        .unwrap()
+}
+
+pub async fn write_card(mut card: Card) {
+    // todo!("Write card to database");
+    let old_card = KATANA
+        .get()
+        .unwrap()
+        .find_one(
+            mongodb::bson::doc! {
+                "name": card.name.clone(),
+                "series": card.series.clone()
+            },
+            None,
+        )
+        .await
+        .unwrap();
+    let start = SystemTime::now();
+    let current_time_ts = start
+        .duration_since(UNIX_EPOCH)
+        .expect("Time went backwards");
+    card.last_update_ts = current_time_ts.as_secs() as i64;
+    if old_card.is_some() {
+        KATANA
+            .get()
+            .unwrap()
+            .replace_one(
+                mongodb::bson::doc! {
+                    "name": card.name.clone(),
+                    "series": card.series.clone()
+                },
+                card,
+                None,
+            )
+            .await
+            .unwrap();
+    } else {
+        KATANA.get().unwrap().insert_one(card, None).await.unwrap();
+    }
 }

swordfish-common/src/database/mod.rs

@@ -35,10 +35,10 @@ pub async fn init() {
     }
     let client = Client::with_options(options).unwrap();
     let db = client.database("swordfish");
-    db.run_command(doc! { "ping": 1 }, None).await.expect("Failed to connect to MongoDB");
+    db.run_command(doc! { "ping": 1 }, None)
+        .await
+        .expect("Failed to connect to MongoDB");
     MONGO_DATABASE.set(db).unwrap();
-    MONGO_CLIENT
+    MONGO_CLIENT.set(client).unwrap();
-        .set(client)
-        .unwrap();
     katana::init();
 }

swordfish-common/src/structs.rs

@@ -6,4 +6,5 @@ pub struct Card {
     pub name: String,
     pub series: String,
     pub print: i32,
+    pub last_update_ts: i64,
 }

swordfish/src/katana.rs

@@ -6,8 +6,8 @@ use regex::Regex;
 use serenity::model::channel::Message;
 use std::io::Cursor;
 use std::sync::LazyLock;
-use swordfish_common::structs::Card;
 use swordfish_common::database::katana as db;
+use swordfish_common::structs::Card;
 use swordfish_common::tesseract::{libtesseract, subprocess};
 use swordfish_common::{trace, warn};
 use tokio::task;
@@ -209,21 +209,22 @@ pub async fn analyze_card_libtesseract(card: image::DynamicImage, count: u32) ->
     trace!("Name: {}", name);
     let series = series_thread.await.unwrap();
     trace!("Series: {}", series);
-    let mut wishlist: Option<i32> = None;
     // TODO: Read the print number
-    // Read the wishlist number
+    let mut card = Card {
-    match db::query_card(name.as_str(), series.as_str()).await {
+        wishlist: None,
-        Some(card) => {
-            wishlist = card.wishlist;
-        }
-        None => {}
-    }
-    return Card {
-        wishlist,
         name,
         series,
         print: 0,
+        last_update_ts: 0,
     };
+    // Read the wishlist number
+    match db::query_card(&card.name.as_str(), &card.series.as_str()).await {
+        Some(c) => {
+            card = c;
+        }
+        None => {}
+    }
+    card
 }
 
 pub async fn analyze_card_subprocess(card: image::DynamicImage, count: u32) -> Card {
@@ -257,21 +258,22 @@ pub async fn analyze_card_subprocess(card: image::DynamicImage, count: u32) -> C
     trace!("Name: {}", name);
     let series = series_thread.await.unwrap();
     trace!("Series: {}", series);
-    let mut wishlist: Option<i32> = None;
     // TODO: Read the print number
-    // Read the wishlist number
+    let mut card = Card {
-    match db::query_card(name.as_str(), series.as_str()).await {
+        wishlist: None,
-        Some(card) => {
-            wishlist = card.wishlist;
-        }
-        None => {}
-    }
-    return Card {
-        wishlist,
         name,
         series,
         print: 0,
+        last_update_ts: 0,
     };
+    // Read the wishlist number
+    match db::query_card(&card.name.as_str(), &card.series.as_str()).await {
+        Some(c) => {
+            card = c;
+        }
+        None => {}
+    }
+    card
 }
 
 async fn execute_analyze_drop(image: DynamicImage, count: u32) -> Card {

swordfish/src/main.rs

@@ -200,13 +200,19 @@ async fn kdropanalyze(ctx: &Context, msg: &Message) -> CommandResult {
                             out_str.push(' ');
                         }
                         out_str
-                    },
+                    }
                     None => "None ".to_string(),
                 };
+                let last_update_ts_str = match card.last_update_ts {
+                    0 => "`Never`".to_string(),
+                    ts => {
+                        format!("<t:{}:R>", ts.to_string())
+                    }
+                };
                 reply_str.push_str(
                     format!(
-                        ":heart: `{}` • `{}` • **{}** • {}\n",
+                        ":heart: `{}` • `{}` • **{}** • {} • {}\n",
-                        wishlist_str, card.print, card.name, card.series
+                        wishlist_str, card.print, card.name, card.series, last_update_ts_str
                     )
                     .as_str(),
                 )