busybar 0.0.8

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

use busylib::model::smart_home::SmartHomeSwitchState;
use clap::Subcommand;

use crate::cli::Context;
use crate::error::Result;
use crate::reporter::{
    OkEvent, SmartHomePairingEvent, SmartHomeStartPairingEvent, SmartHomeSwitchEvent,
};
use crate::values::{SwitchStartupArg, SwitchStateArg};

#[derive(Debug, Subcommand)]
pub enum SmartHomeCommand {
    /// Show the smart home pairing status
    Pairing,

    /// Start pairing with a smart home
    StartPairing,

    /// Erase every smart home link
    ErasePairings,

    /// Show the state of the emulated switch
    Switch,

    /// Set the state of the emulated switch
    SetSwitch {
        /// Switch state
        #[arg(value_enum, value_name = "STATE")]
        state: SwitchStateArg,

        /// State of the switch after a restart
        #[arg(long, value_enum, value_name = "STATE")]
        startup: Option<SwitchStartupArg>,
    },
}

impl SmartHomeCommand {
    pub async fn run(self, context: &Context) -> Result<()> {
        match self {
            SmartHomeCommand::Pairing => pairing(context).await,
            SmartHomeCommand::StartPairing => start_pairing(context).await,
            SmartHomeCommand::ErasePairings => erase_pairings(context).await,
            SmartHomeCommand::Switch => switch(context).await,
            SmartHomeCommand::SetSwitch { state, startup } => {
                set_switch(context, state, startup).await
            }
        }
    }
}

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

    context
        .reporter
        .report(SmartHomePairingEvent::new(pairing))?;

    Ok(())
}

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

    context
        .reporter
        .report(SmartHomeStartPairingEvent::new(payload))?;

    Ok(())
}

async fn erase_pairings(context: &Context) -> Result<()> {
    context.client.smart_home().erase_pairings().await?;

    context
        .reporter
        .report(OkEvent::new("smart-home erase-pairings"))?;

    Ok(())
}

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

    context.reporter.report(SmartHomeSwitchEvent::new(switch))?;

    Ok(())
}

async fn set_switch(
    context: &Context,
    state: SwitchStateArg,
    startup: Option<SwitchStartupArg>,
) -> Result<()> {
    let mut switch = if bool::from(state) {
        SmartHomeSwitchState::on()
    } else {
        SmartHomeSwitchState::off()
    };

    if let Some(startup) = startup {
        switch = switch.startup(startup.into());
    }

    context.client.smart_home().set_switch(&switch).await?;

    context
        .reporter
        .report(OkEvent::new("smart-home set-switch"))?;

    Ok(())
}