busybar 0.0.9

BUSY Bar CLI
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
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162

use busylib::model::settings::HttpAccess;
use busylib::types::access_key::AccessKey;
use busylib::types::brightness::Brightness;
use busylib::types::device_name::DeviceName;
use busylib::types::volume::Volume;
use clap::Subcommand;

use crate::cli::Context;
use crate::error::{CliError, Result};
use crate::reporter::{
    OkEvent, SettingsAccessEvent, SettingsBrightnessEvent, SettingsNameEvent, SettingsVolumeEvent,
};
use crate::types::access_mode_arg::AccessModeArg;

#[derive(Debug, Subcommand)]
pub enum SettingsCommand {
    /// Show the HTTP API access configuration
    Access,

    /// Set how the HTTP API may be reached over Wi-Fi
    SetAccess {
        /// Access mode
        #[arg(value_enum, value_name = "MODE")]
        mode: AccessModeArg,

        /// Access key of 4 to 10 digits, required for the key mode
        #[arg(long, short = 'k', value_name = "KEY", required_if_eq("mode", "key"))]
        key: Option<AccessKey>,
    },

    /// Show the device name
    Name,

    /// Set the device name
    SetName {
        /// New device name
        #[arg(value_name = "NAME")]
        name: DeviceName,
    },

    /// Show the audio volume
    Volume,

    /// Set the audio volume
    SetVolume {
        /// Volume between 0 and 100
        #[arg(value_name = "PERCENT")]
        volume: Volume,

        /// Do not play the volume change sound
        #[arg(long)]
        silent: bool,
    },

    /// Show the display brightness
    Brightness,

    /// Set the display brightness
    SetBrightness {
        /// Percentage between 0 and 100, or auto
        #[arg(value_name = "VALUE")]
        value: Brightness,
    },
}

impl SettingsCommand {
    pub async fn run(self, context: &Context) -> Result<()> {
        match self {
            SettingsCommand::Access => access(context).await,
            SettingsCommand::SetAccess { mode, key } => set_access(context, mode, key).await,
            SettingsCommand::Name => name(context).await,
            SettingsCommand::SetName { name } => set_name(context, name).await,
            SettingsCommand::Volume => volume(context).await,
            SettingsCommand::SetVolume { volume, silent } => {
                set_volume(context, volume, silent).await
            }
            SettingsCommand::Brightness => brightness(context).await,
            SettingsCommand::SetBrightness { value } => set_brightness(context, value).await,
        }
    }
}

async fn access(context: &Context) -> Result<()> {
    let access = context.client.settings().access().await?;

    context.reporter.report(SettingsAccessEvent::new(access))?;

    Ok(())
}

async fn set_access(context: &Context, mode: AccessModeArg, key: Option<AccessKey>) -> Result<()> {
    let access = match (mode, key) {
        (AccessModeArg::Disabled, _) => HttpAccess::Disabled,
        (AccessModeArg::Enabled, _) => HttpAccess::Enabled,
        (AccessModeArg::Key, Some(key)) => HttpAccess::Key(key),
        (AccessModeArg::Key, None) => {
            return Err(CliError::Usage("--key is required for the key mode"));
        }
    };

    context.client.settings().set_access(&access).await?;

    context
        .reporter
        .report(OkEvent::new("settings set-access"))?;

    Ok(())
}

async fn name(context: &Context) -> Result<()> {
    let name = context.client.settings().name().await?;

    context.reporter.report(SettingsNameEvent::new(name))?;

    Ok(())
}

async fn set_name(context: &Context, name: DeviceName) -> Result<()> {
    context.client.settings().set_name(name).await?;

    context.reporter.report(OkEvent::new("settings set-name"))?;

    Ok(())
}

async fn volume(context: &Context) -> Result<()> {
    let volume = context.client.settings().volume().await?;

    context.reporter.report(SettingsVolumeEvent::new(volume))?;

    Ok(())
}

async fn set_volume(context: &Context, volume: Volume, silent: bool) -> Result<()> {
    context.client.settings().set_volume(volume, silent).await?;

    context
        .reporter
        .report(OkEvent::new("settings set-volume"))?;

    Ok(())
}

async fn brightness(context: &Context) -> Result<()> {
    let brightness = context.client.settings().brightness().await?;

    context
        .reporter
        .report(SettingsBrightnessEvent::new(brightness))?;

    Ok(())
}

async fn set_brightness(context: &Context, value: Brightness) -> Result<()> {
    context.client.settings().set_brightness(value).await?;

    context
        .reporter
        .report(OkEvent::new("settings set-brightness"))?;

    Ok(())
}