vrc-log 0.15.3

VRChat Local Avatar ID Logger
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107

use std::collections::HashMap;

use anyhow::Result;
use derive_config::DeriveTomlConfig;
use inquire::{
    list_option::ListOption,
    validator::{ErrorMessage, Validation},
    Confirm,
    MultiSelect,
    Select,
};
use serde::{Deserialize, Serialize};
use strum::{Display, IntoEnumIterator};

use crate::{discord, discord::DEVELOPER_ID, provider::ProviderKind};

#[derive(Display, Deserialize, Serialize, Default)]
pub enum Attribution {
    #[strum(to_string = "Anonymously (VRC-LOG Dev)")]
    #[default]
    Anonymous,
    #[strum(to_string = "Discord RPC ({0})")]
    DiscordRPC(String),
    #[strum(to_string = "Discord ID (Manual Input)")]
    DiscordID(String),
}

impl Attribution {
    #[must_use]
    pub fn get_user_id(&self) -> String {
        match self {
            Self::Anonymous => DEVELOPER_ID.to_string(),
            Self::DiscordID(id) => id.clone(),
            Self::DiscordRPC(id) => discord::get_user()
                .and_then(|u| u.id)
                .unwrap_or_else(|| id.clone()),
        }
    }
}

#[derive(DeriveTomlConfig, Deserialize, Serialize, Default)]
pub struct Settings {
    pub attribution:     Attribution,
    pub clear_amplitude: bool,
    pub print_scanned:   bool,
    pub providers:       HashMap<ProviderKind, bool>,
}

impl Settings {
    /// # Setup Wizard
    ///
    /// # Errors
    ///
    /// Will return `Err` if prompts fail.
    ///
    /// # Panics
    ///
    /// Will panic if Discord user ID doesn't exist.
    pub fn try_wizard() -> Result<Self> {
        let mut attributions = vec![
            Attribution::Anonymous,
            Attribution::DiscordID(String::new()),
        ];
        if let Some(user) = discord::get_user() {
            attributions.insert(1, Attribution::DiscordRPC(user.id.unwrap()));
        }
        let attribution = Select::new("How do you want to be credited?", attributions).prompt()?;
        let providers = {
            let providers = ProviderKind::iter().collect::<Vec<_>>();
            let enabled = MultiSelect::new("Select which providers to use:", providers.clone())
                .with_default(&[0])
                .with_validator(|list: &[ListOption<&ProviderKind>]| {
                    if list.is_empty() {
                        let message = String::from("You must select at least one.");
                        Ok(Validation::Invalid(ErrorMessage::Custom(message)))
                    } else {
                        Ok(Validation::Valid)
                    }
                })
                .prompt()?;

            providers
                .iter()
                .map(|provider| (*provider, enabled.contains(provider)))
                .collect()
        };

        let clear_amplitude = Confirm::new(
            "Clear amplitude file after reading? (Helps with privacy by removing tracked data)",
        )
        .with_default(true)
        .prompt()?;

        let print_scanned = Confirm::new(
            "Print all scanned avatar ids instead of just the uniquely discovered ones",
        )
        .with_default(false)
        .prompt()?;

        Ok(Self {
            attribution,
            clear_amplitude,
            print_scanned,
            providers,
        })
    }
}