Opening hours completed. Leptos upgraded to 0.5.2.

src/backend/data.rs

@@ -1,9 +1,14 @@
 //use chrono::{NaiveDate, NaiveTime, Weekday};
 //use rust_decimal::Decimal;
 #![allow(unused_variables)]
+
+use chrono::{NaiveTime, Weekday};
+use lazy_static::lazy_static;
+use regex::Regex;
 use serde::{Deserialize, Serialize};
 //use uuid::Uuid;
-use validator::Validate;
+use validator::{Validate, ValidationError};
+use crate::error::AppError;
 
 #[derive(Serialize, Deserialize, Clone, Debug)]
 pub enum ApiResponse<T> {
@@ -114,6 +119,176 @@ impl PwdChange {
     }
 }
 
+#[derive(Clone, Serialize, Deserialize, Debug, PartialEq, Eq, Default)]
+#[cfg_attr(feature = "ssr", derive(sqlx::FromRow))]
+pub struct OpeningHour {
+    id: i32,
+    pub day: i32,
+    pub from: NaiveTime,
+    pub to: NaiveTime,
+    pub discount: Option<i32>
+}
+
+impl OpeningHour {
+    pub fn id(&self) -> i32 {
+        self.id
+    }
+}
+
+#[derive(Serialize, Deserialize, Clone, Debug)]
+pub struct DayHours(pub Vec<DayHour>);
+
+impl DayHours {
+
+    pub fn try_new(hours: &str) -> Result<Self, AppError> {
+        if hours.is_empty() {
+            return Ok(Self(Vec::new()))
+        }
+
+        let times = hours.split(",")
+            .map(|h| h.trim())
+            .map(|h| DayHour::try_from(h))
+            .collect::<Vec<_>>();
+
+        if times.contains(&Err(AppError::HourParseError)) {
+            return Err(AppError::HourParseError)
+        }
+
+        Ok(Self(times.into_iter().map(|h| h.unwrap()).collect()))
+    }
+
+    pub fn hours(&self) -> &Vec<DayHour> {
+        &self.0
+    }
+}
+
+impl ToString for DayHours {
+    fn to_string(&self) -> String {
+        if self.0.is_empty() {
+            return "".to_string()
+        }
+
+        self.0.iter().map(|h| {
+            let discount = if let Some(d) = h.discount() {
+                format!(" ({})", d).to_string()
+            } else { "".to_string() };
+            format!("{} - {}{}", h.from().format("%H:%M"), h.to().format("%H:%M"), discount).to_string()})
+            .collect::<Vec<String>>()
+            .join(", ")
+    }
+}
+
+#[derive(Eq, PartialEq, Serialize, Deserialize, Clone, Debug)]
+pub struct DayHour {
+    from: NaiveTime,
+    to: NaiveTime,
+    discount: Option<i32>
+}
+
+impl DayHour {
+    pub fn new(from: NaiveTime, to: NaiveTime, discount: Option<i32>) -> Self {
+        Self { from, to, discount }
+    }
+
+    pub fn from(&self) -> NaiveTime {
+        self.from
+    }
+    pub fn to(&self) -> NaiveTime {
+        self.to
+    }
+    pub fn discount(&self) -> Option<i32> {
+        self.discount
+    }
+}
+
+impl TryFrom<String> for DayHour {
+    type Error = AppError;
+
+    fn try_from(value: String) -> Result<Self, Self::Error> {
+        value.as_str().try_into()
+    }
+}
+
+impl TryFrom<&str> for DayHour {
+    type Error = AppError;
+
+    fn try_from(value: &str) -> Result<Self, Self::Error> {
+        if value.is_empty() {
+            return Err(AppError::HourParseError)
+        }
+
+        let times = value.split("-")
+            .map(|t| t.trim()).collect::<Vec<_>>();
+
+        if times.len() != 2 {
+            return Err(AppError::HourParseError)
+        }
+
+        let from = NaiveTime::parse_from_str(times.get(0).unwrap(), "%H:%M");
+        let to = NaiveTime::parse_from_str(times.get(1).unwrap(), "%H:%M");
+
+        if from.is_err() || to.is_err() {
+            return Err(AppError::HourParseError)
+        }
+
+        Ok(DayHour {
+            from: from.unwrap(),
+            to: to.unwrap(),
+            discount: None
+        })
+    }
+}
+
+fn validate_hours(value: &WeekHours) -> Result<(), ValidationError> {
+    if value.hours().is_empty() {
+        return Ok(())
+    }
+    if let Ok(h) = DayHours::try_new(value.hours()) {
+        for hr in h.hours() {
+            if hr.from() >= hr.to() { return Err(ValidationError::new("TO_BEFORE_FROM")) }
+        }
+        Ok(())
+    } else {
+        Ok(())
+    }
+}
+
+lazy_static! {
+    static ref RE_HOURS: Regex = Regex::new(r"^$|(^\d{2}:\d{2} ?- ?\d{2}:\d{2} ?(\(\d+\))?,? ?)+").unwrap();
+}
+
+#[derive(Clone, Serialize, Deserialize, Debug, Validate)]
+#[validate(schema(function = "validate_hours", message = "Time 'to' must be after time 'from'"))]
+pub struct WeekHours {
+    day: Weekday,
+    #[validate(regex(path = "RE_HOURS", message = "Hours must be in HH:MM - HH:MM format"))]
+    hours: String
+}
+
+impl Default for WeekHours {
+    fn default() -> Self {
+        Self {
+            day: Weekday::Mon,
+            hours: String::default()
+        }
+    }
+}
+
+impl WeekHours {
+    pub fn new(day: Weekday, hours: Vec<DayHour>) -> Self {
+        Self {
+            day,
+            hours: DayHours(hours).to_string()
+        }
+    }
+    pub fn day(&self) -> Weekday {
+        self.day
+    }
+    pub fn hours(&self) -> &str {
+        &self.hours
+    }
+}
+
 /*pub struct Property {
     id: u16,
     name: String,
@@ -135,14 +310,6 @@ pub struct Message {
     text: String,
 }
 
-pub struct OpeningHour {
-    id: u16,
-    day: Weekday,
-    from: NaiveTime,
-    to: NaiveTime,
-    discount: u8
-}
-
 pub struct Customer {
     id: u128,
     full_name: String,