litterrobot3 0.1.2

A client wrapper over the litter robot API. Control your robot from rust :)
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
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

use serde::Deserialize;
use serde::de;
use serde_json::Value;

#[derive(Clone, Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Robot {
    pub litter_robot_id: String,
    pub litter_robot_serial: String,
    pub litter_robot_nickname: String,
    pub device_type: String,
    #[serde(deserialize_with = "deserialize_u64")]
    pub cycle_count: u64,
    #[serde(deserialize_with = "deserialize_u64")]
    pub total_cycle_count: u64,
    #[serde(deserialize_with = "deserialize_u64")]
    pub cycle_capacity: u64,
    #[serde(deserialize_with = "deserialize_u64")]
    pub new_cycle_capacity: u64,
    #[serde(deserialize_with = "deserialize_bool")]
    #[serde(rename = "isDFITriggered")]
    pub is_dfi_triggered: bool,
    #[serde(deserialize_with = "deserialize_bool")]
    pub is_df1_triggered: bool,
    #[serde(deserialize_with = "deserialize_bool")]
    pub is_df2_triggered: bool,
    #[serde(deserialize_with = "deserialize_bool")]
    pub is_dfs_triggered: bool,
    #[serde(deserialize_with = "deserialize_bool")]
    pub is_manual_reset: bool,
    #[serde(deserialize_with = "deserialize_bool")]
    pub saved_is_manual_reset: bool,
    #[serde(deserialize_with = "deserialize_bool")]
    #[serde(rename = "previousDFITriggered")]
    pub previous_dfi_triggered: bool,
    #[serde(deserialize_with = "deserialize_u64")]
    #[serde(rename = "DFICycleCount")]
    pub dfi_cycle_count: u64,
    #[serde(deserialize_with = "deserialize_u64")]
    pub saved_cycle_count: u64,
    pub clean_cycle_wait_time_minutes: String,
    pub cycles_after_drawer_full: u64,
    #[serde(deserialize_with = "deserialize_bool")]
    pub night_light_active: bool,
    #[serde(deserialize_with = "deserialize_bool")]
    pub panel_lock_active: bool,
    #[serde(deserialize_with = "deserialize_bool")]
    pub sleep_mode_active: bool,
    pub sleep_mode_time: u64,
    pub power_status: String,
    pub unit_status: UnitStatus,
    #[serde(deserialize_with = "deserialize_u64")]
    pub sleep_mode_end_time: u64,
    #[serde(deserialize_with = "deserialize_u64")]
    pub sleep_mode_start_time: u64,
    pub last_seen: String,
    pub setup_date: String,
    pub is_onboarded: bool,
    pub did_notify_offline: bool,
    pub auto_offline_disabled: bool,
    pub scoops_saved_count: u64,
}

impl std::fmt::Display for Robot {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}: {}", self.litter_robot_nickname, self.unit_status)
    }
}

#[derive(Clone, Copy, Debug, Deserialize, PartialEq)]
pub enum UnitStatus {
    RDY,
    CCP,
    CCC,
    CSF,
    DF1,
    DF2,
    CST,
    CSI,
    BR,
    P,
    OFF,
    SDF,
    DFS,
}

impl std::fmt::Display for UnitStatus {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let s = match *self {
            Self::RDY => "Unit is ready",
            Self::CCP => "Clean cycle in progress",
            Self::CCC => "Clean cycle complete",
            Self::CSF => "Cat sensor fault",
            Self::DF1 => "Drawer full - 2 cycles remaining",
            Self::DF2 => "Drawer full - 1 cycle remaining",
            Self::CST => "Cat sensor timing",
            Self::CSI => "Cat sensor interrupted",
            Self::BR => "Bonnet removed",
            Self::P => "Unit is paused",
            Self::OFF => "Unit is powered off",
            Self::SDF => "Drawer full on startup and will not cycle",
            Self::DFS => "Drawer full and will not cycle",
        };

        write!(f, "{}", s)
    }
}

fn deserialize_bool<'de, D>(deserializer: D) -> Result<bool, D::Error>
where
    D: de::Deserializer<'de>,
{
    Ok(match de::Deserialize::deserialize(deserializer)? {
        Value::Bool(b) => b,
        Value::String(s) => match s.as_str() {
            "0" | "false" => false,
            "1" | "true" => true,
            _ => return Err(de::Error::custom("Failed to parse bool")),
        }
        _ => return Err(de::Error::custom("Failed to parse bool")),
    })
}


fn deserialize_u64<'de, D>(deserializer: D) -> Result<u64, D::Error>
where
    D: de::Deserializer<'de>,
{
    Ok(match de::Deserialize::deserialize(deserializer)? {
        Value::Number(n) => n.as_u64().unwrap(),
        Value::String(s) => s.parse::<u64>().unwrap(),
        _ => return Err(de::Error::custom("Failed to parse u64")),
    })
}