hey-sdk 0.30.0

Rust client for the HEY API, generated from a Smithy model of the API
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

//! The two identity preferences HEY lets a client write.

use std::str::FromStr;

use chrono::Weekday;

use crate::error::Error;
use crate::generated::types::{
    FirstWeekDayParams, UpdateFirstWeekDayRequestContent, UpdateTimeFormatRequestContent,
};

pub use crate::generated::services::identity::*;

/// The clock HEY renders times on.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum TimeFormat {
    TwelveHour,
    TwentyFourHour,
}

impl TimeFormat {
    pub fn as_str(&self) -> &'static str {
        match self {
            TimeFormat::TwelveHour => "twelve_hour",
            TimeFormat::TwentyFourHour => "twenty_four_hour",
        }
    }
}

impl<'a> Identity<'a> {
    /// Sets which day the identity's calendar weeks start on, and answers the day HEY
    /// stored. The write reaches every HEY client — web, mobile and this SDK read the same
    /// identity preference.
    pub async fn set_first_week_day(&self, day: Weekday) -> Result<Weekday, Error> {
        let body = UpdateFirstWeekDayRequestContent {
            identity_preference: FirstWeekDayParams {
                first_week_day: day_name(day).to_string(),
            },
        };
        let stored = self.update_first_week_day(&body).await?;
        weekday_at(stored.first_week_day)
    }

    /// Sets whether HEY renders times on a 12-hour or a 24-hour clock, and answers the
    /// format HEY stored.
    pub async fn set_time_format(&self, format: TimeFormat) -> Result<TimeFormat, Error> {
        let body = UpdateTimeFormatRequestContent {
            twenty_four_hour_time_format: format == TimeFormat::TwentyFourHour,
        };
        self.update_time_format(&body).await?.time_format.parse()
    }
}

/// HEY takes the day as its lowercased English name.
fn day_name(day: Weekday) -> &'static str {
    match day {
        Weekday::Mon => "monday",
        Weekday::Tue => "tuesday",
        Weekday::Wed => "wednesday",
        Weekday::Thu => "thursday",
        Weekday::Fri => "friday",
        Weekday::Sat => "saturday",
        Weekday::Sun => "sunday",
    }
}

/// HEY answers the stored day as an index the way it serves the identity: 0 is Sunday.
fn weekday_at(index: i32) -> Result<Weekday, Error> {
    match index {
        0 => Ok(Weekday::Sun),
        1 => Ok(Weekday::Mon),
        2 => Ok(Weekday::Tue),
        3 => Ok(Weekday::Wed),
        4 => Ok(Weekday::Thu),
        5 => Ok(Weekday::Fri),
        6 => Ok(Weekday::Sat),
        _ => Err(Error::api(
            0,
            format!("first week day {index} is not a day of the week"),
        )),
    }
}

impl FromStr for TimeFormat {
    type Err = Error;

    fn from_str(source: &str) -> Result<TimeFormat, Error> {
        match source {
            "twelve_hour" => Ok(TimeFormat::TwelveHour),
            "twenty_four_hour" => Ok(TimeFormat::TwentyFourHour),
            _ => Err(Error::usage(format!(
                "time format {source:?} is neither \"twelve_hour\" nor \"twenty_four_hour\""
            ))),
        }
    }
}