feat: add WCREQ parsing

Author: Ofenhed

intouch2/src/object.rs

@@ -26,14 +26,11 @@ impl ToStatic for StatusChange<'_> {
     }
 }
 
-impl<const N: usize> ToStatic for Cow<'_, [u8; N]> {
-    type Static = Cow<'static, [u8; N]>;
+impl ToStatic for WatercareInfo {
+    type Static = WatercareInfo;
 
     fn to_static(&self) -> Self::Static {
-        match *self {
-            Cow::Owned(x) => Cow::Owned(x),
-            Cow::Borrowed(x) => Cow::Owned(*x),
-        }
+        self.clone()
     }
 }
 
@@ -78,10 +75,43 @@ pub struct ReminderInfo {
     pub valid: bool,
 }
 
+#[derive(Debug, Clone, PartialEq, Eq)]
+#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
+pub struct WatercareInfo {
+    pub mode: u8,
+    pub r#type: WatercareType,
+    pub index: u8,
+    pub start_day: Weekday,
+    pub end_day: Weekday,
+    pub start_time: Time,
+    pub end_time: Time,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, strum::FromRepr)]
+#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
+#[repr(u8)]
+pub enum Weekday {
+    Sunday = 0,
+    Monday = 1,
+    Tuesday = 2,
+    Wednesday = 3,
+    Thursday = 4,
+    Friday = 5,
+    Saturday = 6,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
+pub struct Time {
+    pub hour: u8,
+    pub minute: u8,
+}
+
 #[derive(Clone, Copy, Debug, PartialEq, Eq, strum::FromRepr)]
 #[cfg_attr(feature = "serialize", derive(serde::Serialize))]
 #[repr(u8)]
 pub enum WatercareType {
+    Invalid = 0,
     Economy = 1,
     FilterCycle = 2,
 }
@@ -100,6 +130,14 @@ impl<'a> ActualType for &'a [ReminderInfo] {
     type Type = Cow<'a, [ReminderInfo]>;
 }
 
+impl<'a> ActualType for &'a [WatercareInfo] {
+    type Type = Cow<'a, [WatercareInfo]>;
+}
+
+impl ActualType for WatercareInfo {
+    type Type = WatercareInfo;
+}
+
 macro_rules! actually_self {
     ($ty:ty $(,$($rest:tt)*)?) => {
         impl ActualType for $ty {
@@ -115,7 +153,7 @@ macro_rules! actually_self {
     };
     () => {};
 }
-actually_self!(u8, u16, WatercareType);
+actually_self!(u8, u16, WatercareType, Weekday);
 
 pub mod package_data {
     use super::*;
@@ -205,14 +243,7 @@ pub mod package_data {
         ModifyWatercare {
             b"MDFWC": Tag,
             seq: u8,
-            mode: u8,
-            r#type: WatercareType,
-            rule_index: u8,
-            unknown: &[u8; 2],
-            start_hour: u8,
-            start_minute: u8,
-            end_hour: u8,
-            end_minutes: u8,
+            info: WatercareInfo,
         },
         DeleteWatercare {
             b"DELWC": Tag,
@@ -230,14 +261,7 @@ pub mod package_data {
         AddWatercare {
             b"ADDWC": Tag,
             seq: u8,
-            mode: u8,
-            r#type: WatercareType,
-            index: u8,
-            unknown: &[u8; 2],
-            start_hour: u8,
-            start_minute: u8,
-            end_hour: u8,
-            end_minutes: u8,
+            info: WatercareInfo,
         },
         WatercareAdded {
             b"WCADD": Tag,
@@ -269,7 +293,13 @@ pub mod package_data {
         RemindersSet {
             b"RMSET": Tag,
         },
-        WatercareRequest(b"WCREQ": Tailing),
+        WatercareRequest{
+            b"WCREQ": Tag,
+            index: u8,
+            next_index: u8,
+            schedule: &[WatercareInfo],
+        },
+        MalformedWatercareRequest(b"WCREQ": Tailing),
         ChannelCurrent {
             b"CHCUR": Tag,
             channel: u8,

intouch2/src/parser.rs

@@ -241,6 +241,88 @@ impl<'a> DatasContent<'a> for ReminderInfo {
     }
 }
 
+impl<'a> DatasContent<'a> for WatercareInfo {
+    fn parse(input: &'a [u8]) -> nom::IResult<&'a [u8], Self> {
+        let (input, mode) = u8::parse(input)?;
+        let (new_input, r#type) = u8::parse(input)?;
+        let (input, r#type) = (
+            new_input,
+            WatercareType::from_repr(r#type).ok_or_else(|| {
+                nom::Err::Failure(nom::error::make_error(
+                    new_input,
+                    nom::error::ErrorKind::OneOf,
+                ))
+            })?,
+        );
+
+        let (input, index) = u8::parse(input)?;
+        let (new_input, start_day) = u8::parse(input)?;
+        let (input, start_day) = (
+            new_input,
+            Weekday::from_repr(start_day).ok_or_else(|| {
+                nom::Err::Failure(nom::error::make_error(
+                    new_input,
+                    nom::error::ErrorKind::OneOf,
+                ))
+            })?,
+        );
+        let (new_input, end_day) = u8::parse(input)?;
+        let (input, end_day) = (
+            new_input,
+            Weekday::from_repr(end_day).ok_or_else(|| {
+                nom::Err::Failure(nom::error::make_error(
+                    new_input,
+                    nom::error::ErrorKind::OneOf,
+                ))
+            })?,
+        );
+
+        let (input, start_time) = Time::parse(input)?;
+        let (input, end_time) = Time::parse(input)?;
+        Ok((
+            input,
+            Self {
+                mode,
+                r#type,
+                index,
+                start_day,
+                end_day,
+                start_time,
+                end_time,
+            },
+        ))
+    }
+
+    fn compose(&self) -> Cow<'a, [u8]> {
+        Cow::Owned(
+            [
+                &[
+                    self.mode as u8,
+                    self.r#type as u8,
+                    self.index,
+                    self.start_day as u8,
+                    self.end_day as u8,
+                ][..],
+                &self.start_time.compose(),
+                &self.end_time.compose(),
+            ][..]
+                .concat(),
+        )
+    }
+}
+
+impl<'a> DatasContent<'a> for Time {
+    fn parse(input: &'a [u8]) -> nom::IResult<&'a [u8], Self> {
+        let (input, hour) = u8::parse(input)?;
+        let (input, minute) = u8::parse(input)?;
+        Ok((input, Self { hour, minute }))
+    }
+
+    fn compose(&self) -> Cow<'a, [u8]> {
+        Cow::Owned(vec![self.hour, self.minute])
+    }
+}
+
 impl<'a, T: DatasContent<'a> + Clone> DatasContent<'a> for Cow<'a, [T]>
 where
     [T]: ToOwned,

intouch2/src/tests.rs

@@ -110,6 +110,21 @@ fn parse_reminders() {
     assert_eq!(parse_fail, None);
 }
 
+#[test]
+fn parse_watercare() {
+    let valid_payload = [
+        0, 1, 0, 1, 0, 0, 6, 0, 0, 0, 0, 0, 2, 1, 0, 6, 6, 30, 6, 40, 0, 2, 2, 0, 6, 22, 0, 22, 10,
+        1, 2, 0, 0, 6, 18, 0, 18, 10,
+    ];
+    let mut raw_data = b"WCREQ".to_vec();
+    raw_data.append(&mut valid_payload.to_vec());
+    let parse_fail = match NetworkPackageData::parse(&raw_data) {
+        Ok(([], NetworkPackageData::WatercareRequest(_))) => None,
+        x => Some(x),
+    };
+    assert_eq!(parse_fail, None);
+}
+
 #[test]
 fn id_packets() {
     let packets = vec![

intouch2/src/to_static.rs

@@ -6,19 +6,11 @@ pub trait ToStatic {
     fn to_static(&self) -> Self::Static;
 }
 
-impl<O, S, T> ToStatic for Cow<'_, [T]>
-where
-    S: Clone + 'static,
-    O: ToStatic<Static = S>,
-    [T]: ToOwned<Owned = Vec<O>>,
-{
-    type Static = Cow<'static, [S]>;
+impl<'a, T: ToOwned + ToStatic + ?Sized> ToStatic for Cow<'a, T> {
+    type Static = T::Static;
 
     fn to_static(&self) -> Self::Static {
-        match self {
-            Cow::Owned(o) => o.to_static(),
-            Cow::Borrowed(b) => (**b).to_owned().to_static(),
-        }
+        T::to_static(self.as_ref())
     }
 }