0.13.0 - Setup Wizard

Author: ShayBox

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "vrc-log"
-version = "0.12.2"
+version = "0.13.0"
 authors = ["Shayne Hartford <[email protected]>"]
 edition = "2021"
 description = "VRChat Local Avatar ID Logger"
@@ -21,8 +21,10 @@ chrono = "0.4"
 colored = "3"
 crossbeam = "0.8"
 crossterm = { version = "0.29", optional = true }
+derive-config = { version = "2", features = ["dirs", "toml"] }
 discord-presence = { version = "1", optional = true }
 futures = "0.3"
+inquire = "0.7"
 lazy-regex = "3"
 notify = "8"
 parking_lot = "0.12"

Cargo.toml

@@ -38,12 +38,7 @@ impl Discord {
 }
 
 #[once(option = true, sync_writes = true)]
-pub fn get_user_id() -> Option<String> {
-    if let Ok(user_id) = std::env::var("DISCORD") {
-        /* TODO: Validate User ID (Snowflake) - Regex? */
-        return Some(user_id);
-    }
-
+pub fn get_user() -> Option<PartialUser> {
     let discord = Discord::start();
     std::thread::sleep(Duration::from_secs(5));
     discord.client.shutdown().ok()?;
@@ -55,20 +50,18 @@ pub fn get_user_id() -> Option<String> {
                     info!("[Discord] Authenticated as {username}");
                 }
 
-                return Some(user_id.clone());
+                return Some(user.clone());
             }
 
             warn!("Vesktop & arRPC doesn't support fetching user info");
             warn!("You can supply the 'DISCORD' env variable manually");
-            warn!("The User ID will default to the developer: ShayBox");
         }
     } else {
         warn!("Error: Discord RPC Connection Failed\n");
         warn!("This may be due to one of the following reasons:");
         warn!("1. Discord is not running on your system.");
         warn!("2. VRC-LOG was restarted too quickly.\n");
-        warn!("The User ID will default to the developer: ShayBox");
     }
 
-    Some(String::from(DEVELOPER_ID))
+    None
 }

src/discord.rs

@@ -2,7 +2,6 @@
 extern crate tracing;
 
 use std::{
-    collections::VecDeque,
     env::Args,
     fs::File,
     io::{BufRead, BufReader, Error},
@@ -21,11 +20,15 @@ use notify::{Config, Event, PollWatcher, RecursiveMode, Watcher};
 use parking_lot::RwLock;
 use terminal_link::Link;
 
-use crate::provider::{prelude::*, Provider, Type};
+use crate::{
+    provider::{prelude::*, Provider, ProviderKind},
+    settings::Settings,
+};
 
 #[cfg(feature = "discord")]
 pub mod discord;
 pub mod provider;
+pub mod settings;
 pub mod vrchat;
 
 pub const CARGO_PKG_VERSION: &str = env!("CARGO_PKG_VERSION");
@@ -111,37 +114,30 @@ pub fn launch_game(args: Args) -> Result<()> {
 
 /// # Errors
 /// Will return `Err` if `Sqlite::new` or `Provider::send_avatar_id` errors
-pub async fn process_avatars((_tx, rx): (Sender<PathBuf>, Receiver<PathBuf>)) -> Result<()> {
+pub async fn process_avatars(
+    settings: Settings,
+    (_tx, rx): (Sender<PathBuf>, Receiver<PathBuf>),
+) -> Result<()> {
     #[cfg(feature = "cache")]
     let cache = Cache::new().await?;
-
-    #[cfg(feature = "avtrdb")]
-    let avtrdb = AvtrDB::default();
-
-    #[cfg(feature = "vrcdb")]
-    let vrcdb = VrcDB::default();
-
-    #[cfg(feature = "vrcds")]
-    let vrcds = VrcDS::default();
-
-    #[cfg(feature = "vrcwb")]
-    let vrcwb = VrcWB::default();
-
-    #[cfg(feature = "paw")]
-    let paw = Paw::default();
-
-    let providers = VecDeque::from([
-        #[cfg(feature = "avtrdb")]
-        Type::AVTRDB(&avtrdb),
-        #[cfg(feature = "vrcdb")]
-        Type::VRCDB(&vrcdb),
-        #[cfg(feature = "vrcds")]
-        Type::VRCDS(&vrcds),
-        #[cfg(feature = "vrcwb")]
-        Type::VRCWB(&vrcwb),
-        #[cfg(feature = "paw")]
-        Type::PAW(&paw),
-    ]);
+    let providers = settings
+        .providers
+        .iter()
+        .filter_map(|provider| match provider {
+            #[cfg(feature = "cache")]
+            ProviderKind::CACHE => None,
+            #[cfg(feature = "avtrdb")]
+            ProviderKind::AVTRDB => provider!(AvtrDB::new(&settings)),
+            #[cfg(feature = "paw")]
+            ProviderKind::PAW => provider!(Paw::new(&settings)),
+            #[cfg(feature = "vrcdb")]
+            ProviderKind::VRCDB => provider!(VrcDB::new(&settings)),
+            #[cfg(feature = "vrcds")]
+            ProviderKind::VRCDS => provider!(VrcDS::new(&settings)),
+            #[cfg(feature = "vrcwb")]
+            ProviderKind::VRCWB => provider!(VrcWB::new(&settings)),
+        })
+        .collect::<Vec<_>>();
 
     while let Ok(path) = rx.recv() {
         for avatar_id in parse_avatar_ids(&path) {
@@ -162,18 +158,19 @@ pub async fn process_avatars((_tx, rx): (Sender<PathBuf>, Receiver<PathBuf>)) ->
             let results = futures::future::join_all(futures).await;
 
             for (provider, result) in providers.iter().zip(results) {
+                let kind = provider.kind();
                 match result {
                     Ok(unique) => {
                         if unique {
-                            info!("^ Successfully Submitted to {provider}");
+                            info!("^ Successfully Submitted to {kind}");
                         }
                     }
                     Err(error) => {
                         #[cfg(feature = "cache")]
                         {
                             send_to_cache = false;
                         }
-                        error!("^ Failed to submit to {provider}: {error}");
+                        error!("^ Failed to submit to {kind}: {error}");
                     }
                 }
             }

src/lib.rs

@@ -1,22 +1,23 @@
 #[macro_use]
 extern crate tracing;
 
-use std::sync::OnceLock;
+use std::{io::ErrorKind, sync::OnceLock};
 
 use anyhow::Result;
 use chrono::{Local, Offset};
 #[cfg(feature = "title")]
 use crossterm::{execute, terminal::SetTitle};
+use derive_config::{ConfigError, DeriveTomlConfig};
 use notify::PollWatcher;
 use terminal_link::Link;
 use time::{macros::format_description, UtcOffset};
 use tracing::level_filters::LevelFilter;
 use tracing_subscriber::{fmt::time::OffsetTime, EnvFilter};
 use vrc_log::{
+    settings::Settings,
     vrchat::{VRCHAT_AMP_PATH, VRCHAT_LOW_PATH},
     CARGO_PKG_HOMEPAGE,
 };
-
 /* Watchers will stop working if they get dropped. */
 static WATCHERS: OnceLock<Vec<PollWatcher>> = OnceLock::new();
 
@@ -46,12 +47,24 @@ async fn main() -> Result<()> {
     }
 
     let args = std::env::args();
+    let settings = Settings::load().unwrap_or_else(|error| match error {
+        ConfigError::Io(error) if error.kind() == ErrorKind::NotFound => {
+            info!("Welcome to VRC-LOG! Please follow the setup wizard");
+            Settings::try_wizard().expect("Failed to setup wizard")
+        }
+        error => {
+            error!("There was an error loading the settings: {error}");
+            Settings::try_wizard().expect("Failed to setup wizard")
+        }
+    });
+
     let (tx, rx) = crossbeam::channel::unbounded();
     let _ = WATCHERS.set(vec![
         vrc_log::watch(tx.clone(), VRCHAT_AMP_PATH.as_path())?,
         vrc_log::watch(tx.clone(), VRCHAT_LOW_PATH.as_path())?,
     ]);
 
+    settings.save()?;
     vrc_log::launch_game(args)?;
-    vrc_log::process_avatars((tx, rx)).await
+    vrc_log::process_avatars(settings, (tx, rx)).await
 }

src/main.rs

@@ -4,120 +4,103 @@ use anyhow::{bail, Result};
 use async_trait::async_trait;
 use reqwest::{Client, StatusCode, Url};
 use serde::{Deserialize, Serialize};
+use serde_json::{json, Value};
 
 use crate::{
-    provider::{Provider, Type},
+    provider::{Provider, ProviderKind},
+    settings::Settings,
     USER_AGENT,
 };
 
 const URL: &str = "https://api.avtrdb.com/v2/";
 
-pub struct AvtrDB {
-    attribution: Option<String>,
-    client:      Client,
-    url:         Url,
+pub struct AvtrDB<'a> {
+    settings: &'a Settings,
+    client:   Client,
 }
 
-impl AvtrDB {
+impl<'a> AvtrDB<'a> {
     #[must_use]
-    pub fn new(attribution: Option<String>, url: Url) -> Self {
+    pub fn new(settings: &'a Settings) -> Self {
         Self {
-            attribution,
-            url,
-            ..Default::default()
+            settings,
+            client: Client::default(),
         }
     }
 }
 
-impl Default for AvtrDB {
-    fn default() -> Self {
-        // Only alphanumeric strings up to 30 characters or nothing are allowed.
-        // if these conditions are not met, the given avatars will not be ingested.
-        let attribution = std::env::var("AVTRDB_ATTRIBUTION")
-            .ok()
-            .or_else(crate::discord::get_user_id);
-
-        Self {
-            attribution,
-            url: Url::parse(URL).expect("Failed to parse URL"),
-            client: Client::builder()
-                .timeout(Duration::from_secs(10))
-                .user_agent(USER_AGENT)
-                .build()
-                .unwrap(),
-        }
-    }
-}
-
-#[derive(Debug, Serialize)]
-struct AvtrDBRequest {
-    avatar_ids:  Vec<String>,
-    attribution: Option<String>,
-}
-
 #[derive(Debug, Deserialize)]
-struct AvtrDBResponse {
+struct IngestResponse {
     valid_avatar_ids: u64,
 }
 
 #[derive(Debug, Deserialize)]
-struct AvtrDBSearchResponse {
-    avatars: Vec<serde_json::Value>,
+struct SearchResponse {
+    avatars: Vec<Value>,
 }
 
 #[async_trait]
-impl Provider for AvtrDB {
+impl Provider for AvtrDB<'_> {
+    fn kind(&self) -> ProviderKind {
+        ProviderKind::AVTRDB
+    }
+
     async fn check_avatar_id(&self, avatar_id: &str) -> Result<bool> {
-        let name = Type::AVTRDB(self);
-        let mut url = self.url.join("avatar/search")?;
+        let kind = self.kind();
+        let mut url = Url::parse(URL)?.join("avatar/search")?;
         url.set_query(Some(format!("query={avatar_id}").as_str()));
 
-        let response = self.client.get(url).send().await?;
+        let response = self
+            .client
+            .get(url)
+            .header("User-Agent", USER_AGENT)
+            .send()
+            .await?;
+
         let status = response.status();
         let text = response.text().await?;
-        debug!("[{name}] {status} | {text}");
+        debug!("[{kind}] {status} | {text}");
 
         if status != StatusCode::OK {
-            bail!("[{name}] Failed to check avatar: {status} | {text}");
+            bail!("[{kind}] Failed to check avatar: {status} | {text}");
         }
 
-        let data = serde_json::from_str::<AvtrDBSearchResponse>(&text)?;
+        let data = serde_json::from_str::<SearchResponse>(&text)?;
 
         Ok(data.avatars.len() == 1)
     }
 
-    // The API supports batching, but this interface does not
-    // FIXME: adapt ProviderTrait to support batching
     async fn send_avatar_id(&self, avatar_id: &str) -> Result<bool> {
-        let name = Type::AVTRDB(self);
-        let request = AvtrDBRequest {
-            avatar_ids:  vec![avatar_id.to_string()],
-            attribution: self.attribution.clone(),
-        };
+        let kind = self.kind();
+        let json = json!({
+            "avatar_ids":  vec![avatar_id.to_string()],
+            "attribution": self.settings.attribution.get_user_id(),
+        });
 
-        debug!("[{name}] Sending {:#?}", serde_json::to_string(&request)?);
+        debug!("[{kind}] Sending {json:#?}");
 
         let response = self
             .client
-            .post(self.url.join("avatar/ingest")?)
-            .json(&request)
+            .post(Url::parse(URL)?.join("avatar/ingest")?)
+            .header("User-Agent", USER_AGENT)
+            .json(&json)
             .timeout(Duration::from_secs(3))
             .send()
             .await?;
 
         let status = response.status();
         let text = response.text().await?;
-        let data = serde_json::from_str::<AvtrDBResponse>(&text)?;
-        debug!("[{name}] {status} | {text}");
+        let data = serde_json::from_str::<IngestResponse>(&text)?;
+        debug!("[{kind}] {status} | {text}");
 
         let unique = match status {
             StatusCode::OK => data.valid_avatar_ids == 1,
             StatusCode::TOO_MANY_REQUESTS => {
-                warn!("[{name}] 429 Rate Limit, trying again in 10 seconds");
+                warn!("[{kind}] 429 Rate Limit, trying again in 10 seconds");
                 tokio::time::sleep(Duration::from_secs(10)).await;
                 Box::pin(self.send_avatar_id(avatar_id)).await?
             }
-            _ => bail!("[{name}] Unknown Error: {status} | {text}"),
+            _ => bail!("[{kind}] Unknown Error: {status} | {text}"),
         };
 
         Ok(unique)