better tracking

Qrimpuff · Oct 20, 2024 · 5ea8ec3 · 5ea8ec3
1 parent 9866a8f
commit 5ea8ec3
Show file tree

Hide file tree

Showing 8 changed files with 297 additions and 28 deletions.
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -23,3 +23,4 @@ printpdf = { git = "https://github.com/Qrimpuff/printpdf", branch = "reuse_image
 ] }
 image = { version = "0.25.2", features = ["png", "webp"] }
 futures = "0.3.31"
+wasm-bindgen = { version = "0.2.95", features = ["serde"] }
diff --git a/assets/untrack.html b/assets/untrack.html
@@ -3,8 +3,8 @@
 <body></body>
 <script>
     let disabled = localStorage.getItem("umami.disabled");
-    if (disabled == "1") {
-        localStorage.setItem("umami.disabled", "0");
+    if (disabled) {
+        localStorage.removeItem("umami.disabled");
     } else {
         localStorage.setItem("umami.disabled", "1");
     }

diff --git a/assets/utils.js b/assets/utils.js
@@ -0,0 +1,6 @@
+
+export function track_event(event, data) {
+    if (window.umami && window.umami.track) {
+        window.umami.track(event, data);
+    }
+}
diff --git a/src/main.rs b/src/main.rs
@@ -6,10 +6,12 @@ use dioxus::prelude::*;
 use dioxus_logger::tracing::{info, Level};
 use gloo::{
     file::{Blob, BlobContents},
-    utils::document,
+    utils::{document, format::JsValueSerdeExt},
 };
+use serde::Serialize;
 use sources::*;
-use web_sys::{wasm_bindgen::JsCast, Url};
+use wasm_bindgen::prelude::*;
+use web_sys::Url;
 
 fn main() {
     // Init logger
@@ -186,6 +188,15 @@ pub fn UnknownImport(
     mut common_deck: Signal<Option<CommonDeck>>,
     map: Signal<CardsInfoMap>,
 ) -> Element {
+    #[derive(Serialize)]
+    struct EventData {
+        format: &'static str,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        file_format: Option<&'static str>,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        error: Option<String>,
+    }
+
     let mut deck_error = use_signal(String::new);
     let mut deck_success = use_signal(String::new);
     let mut file_name = use_signal(String::new);
@@ -208,6 +219,14 @@ pub fn UnknownImport(
                         *common_deck.write() =
                             Some(holodelta::Deck::to_common_deck(deck, &map.read()));
                         *deck_success.write() = "Deck file format: holoDelta".into();
+                        track_convert_event(
+                            EventType::Import,
+                            EventData {
+                                format: "Unknown",
+                                file_format: Some("holoDelta"),
+                                error: None,
+                            },
+                        );
                         return;
                     }
 
@@ -218,6 +237,14 @@ pub fn UnknownImport(
                         *common_deck.write() =
                             Some(holoduel::Deck::to_common_deck(deck, &map.read()));
                         *deck_success.write() = "Deck file format: HoloDuel".into();
+                        track_convert_event(
+                            EventType::Import,
+                            EventData {
+                                format: "Unknown",
+                                file_format: Some("HoloDuel"),
+                                error: None,
+                            },
+                        );
                         return;
                     }
 
@@ -229,10 +256,26 @@ pub fn UnknownImport(
                             Some(tabletop_sim::Deck::to_common_deck(deck, &map.read()));
                         *deck_success.write() =
                             "Deck file format: Tabletop Simulator (by Noodlebrain)".into();
+                        track_convert_event(
+                            EventType::Import,
+                            EventData {
+                                format: "Unknown",
+                                file_format: Some("Tabletop Sim"),
+                                error: None,
+                            },
+                        );
                         return;
                     }
 
                     *deck_error.write() = "Cannot parse deck file".into();
+                    track_convert_event(
+                        EventType::Import,
+                        EventData {
+                            format: "Unknown",
+                            file_format: None,
+                            error: Some("Cannot parse deck file".into()),
+                        },
+                    );
                 }
             }
         }
@@ -282,7 +325,7 @@ fn DeckPreview() -> Element {
     let map = CARDS_INFO.read();
 
     let Some(deck) = deck.as_ref() else {
-        return rsx! {  };
+        return rsx! {};
     };
 
     let oshi = rsx! {
@@ -405,3 +448,27 @@ pub fn done_loading() {
         loading.remove();
     }
 }
+
+#[wasm_bindgen(module = "/assets/utils.js")]
+extern "C" {
+    fn track_event(event: &str, data: JsValue);
+}
+
+pub enum EventType {
+    Import,
+    Export,
+}
+
+pub fn track_convert_event<T>(event: EventType, data: T)
+where
+    T: serde::ser::Serialize,
+{
+    let event = match event {
+        EventType::Import => "import",
+        EventType::Export => "export",
+    };
+
+    let data = JsValue::from_serde(&data).unwrap();
+
+    track_event(event, data);
+}
diff --git a/src/sources/deck_log.rs b/src/sources/deck_log.rs
@@ -6,6 +6,8 @@ use dioxus_logger::tracing::info;
 use reqwest::{Client, ClientBuilder};
 use serde::{Deserialize, Serialize};
 
+use crate::{track_convert_event, EventType};
+
 use super::{
     CardsInfoMap, CommonCards, CommonCardsConversion, CommonDeck, CommonDeckConversion,
     MergeCommonCards,
@@ -102,7 +104,7 @@ impl Deck {
         Ok(serde_json::from_str(&content).map_err(|_| content)?)
     }
 
-    pub async fn publish(&self, game_title_id: u32) -> Result<String, Box<dyn Error>> {
+    pub async fn publish(&mut self, game_title_id: u32) -> Result<String, Box<dyn Error>> {
         let mut req = PublishDeckRequest(self.clone());
         req.0.game_title_id = game_title_id;
 
@@ -118,13 +120,10 @@ impl Deck {
 
         let res: ViewDeckResult = serde_json::from_str(&content).map_err(|_| content)?;
 
-        let deck = Deck {
-            game_title_id,
-            deck_id: res.deck_id,
-            ..Deck::default()
-        };
+        self.game_title_id = game_title_id;
+        self.deck_id = res.deck_id;
 
-        Ok(deck.view_url())
+        Ok(self.view_url())
     }
 }
 
@@ -193,6 +192,17 @@ fn http_client() -> &'static Client {
 
 #[component]
 pub fn Import(mut common_deck: Signal<Option<CommonDeck>>, map: Signal<CardsInfoMap>) -> Element {
+    #[derive(Serialize)]
+    struct EventData {
+        format: &'static str,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        game_title_id: Option<u32>,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        deck_id: Option<String>,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        error: Option<String>,
+    }
+
     let mut deck_error = use_signal(String::new);
     let mut import_url_code = use_signal(String::new);
     let mut is_url = use_signal(|| false);
@@ -244,9 +254,29 @@ pub fn Import(mut common_deck: Signal<Option<CommonDeck>>, map: Signal<CardsInfo
         match deck {
             Ok(deck) => {
                 *deck_log_url.write() = deck.view_url();
+                track_convert_event(
+                    EventType::Import,
+                    EventData {
+                        format: "Deck Log",
+                        game_title_id: Some(deck.game_title_id),
+                        deck_id: Some(deck.deck_id.clone()),
+                        error: None,
+                    },
+                );
                 *common_deck.write() = Some(Deck::to_common_deck(deck, &map.read()));
             }
-            Err(e) => *deck_error.write() = e.to_string(),
+            Err(e) => {
+                *deck_error.write() = e.to_string();
+                track_convert_event(
+                    EventType::Import,
+                    EventData {
+                        format: "Deck Log",
+                        game_title_id: None,
+                        deck_id: None,
+                        error: Some(e.to_string()),
+                    },
+                );
+            }
         }
 
         *loading.write() = false;
@@ -297,6 +327,16 @@ static PUBLISH_CACHE: GlobalSignal<HashMap<(u32, u64), String>> = Signal::global
 
 #[component]
 pub fn Export(mut common_deck: Signal<Option<CommonDeck>>, map: Signal<CardsInfoMap>) -> Element {
+    #[derive(Serialize)]
+    struct EventData {
+        format: &'static str,
+        game_title_id: u32,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        deck_id: Option<String>,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        error: Option<String>,
+    }
+
     let mut deck_error = use_signal(String::new);
     let mut game_title_id = use_signal(|| 9); // default to Deck Log JP
     let mut deck_log_url = use_signal(String::new);
@@ -327,15 +367,35 @@ pub fn Export(mut common_deck: Signal<Option<CommonDeck>>, map: Signal<CardsInfo
             return;
         }
 
-        let deck = Deck::from_common_deck(common_deck.clone(), &map.read());
+        let mut deck = Deck::from_common_deck(common_deck.clone(), &map.read());
         match deck.publish(*game_title_id.read()).await {
             Ok(url) => {
                 *deck_log_url.write() = url.clone();
                 PUBLISH_CACHE
                     .write()
                     .insert((*game_title_id.read(), common_deck.calculate_hash()), url);
+                track_convert_event(
+                    EventType::Export,
+                    EventData {
+                        format: "Deck Log",
+                        game_title_id: *game_title_id.read(),
+                        deck_id: Some(deck.deck_id.clone()),
+                        error: None,
+                    },
+                );
+            }
+            Err(e) => {
+                *deck_error.write() = e.to_string();
+                track_convert_event(
+                    EventType::Export,
+                    EventData {
+                        format: "Deck Log",
+                        game_title_id: *game_title_id.read(),
+                        deck_id: None,
+                        error: Some(e.to_string()),
+                    },
+                );
             }
-            Err(e) => *deck_error.write() = e.to_string(),
         }
 
         *loading.write() = false;