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

use busylib::types::timestamp::Timestamp;
use busylib::types::timezone_name::TimezoneName;
use clap::Subcommand;

use crate::cli::Context;
use crate::error::Result;
use crate::reporter::{OkEvent, TimeNowEvent, TimeTimezoneEvent, TimeTzlistEvent};

#[derive(Debug, Subcommand)]
pub enum TimeCommand {
    /// Show the device clock
    Now,

    /// Set the device clock
    SetTimestamp {
        /// ISO 8601 timestamp with time zone
        #[arg(value_name = "TIMESTAMP")]
        timestamp: Timestamp,
    },

    /// Show the time zone
    Timezone,

    /// Set the time zone
    SetTimezone {
        /// Time zone name
        #[arg(value_name = "NAME")]
        name: TimezoneName,
    },

    /// List the supported time zones
    Tzlist,
}

impl TimeCommand {
    pub async fn run(self, context: &Context) -> Result<()> {
        match self {
            TimeCommand::Now => now(context).await,
            TimeCommand::SetTimestamp { timestamp } => set_timestamp(context, timestamp).await,
            TimeCommand::Timezone => timezone(context).await,
            TimeCommand::SetTimezone { name } => set_timezone(context, name).await,
            TimeCommand::Tzlist => tzlist(context).await,
        }
    }
}

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

    context.reporter.report(TimeNowEvent::new(now))?;

    Ok(())
}

async fn set_timestamp(context: &Context, timestamp: Timestamp) -> Result<()> {
    context.client.time().set_timestamp(timestamp).await?;

    context
        .reporter
        .report(OkEvent::new("time set-timestamp"))?;

    Ok(())
}

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

    context.reporter.report(TimeTimezoneEvent::new(timezone))?;

    Ok(())
}

async fn set_timezone(context: &Context, name: TimezoneName) -> Result<()> {
    context.client.time().set_timezone(name).await?;

    context.reporter.report(OkEvent::new("time set-timezone"))?;

    Ok(())
}

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

    context.reporter.report(TimeTzlistEvent::new(list))?;

    Ok(())
}