Refactor project into workspaces

emgauwa-lib/src/db/model_utils.rs

@@ -0,0 +1,111 @@
+use crate::db::schedules::Periods;
+use chrono::{NaiveTime, Timelike};
+use serde::{Deserialize, Serialize};
+use sqlx::database::HasArguments;
+use sqlx::encode::IsNull;
+use sqlx::error::BoxDynError;
+use sqlx::sqlite::{SqliteTypeInfo, SqliteValueRef};
+use sqlx::{Decode, Encode, Sqlite, Type};
+
+#[derive(Debug, Serialize, Deserialize, PartialEq, Clone)]
+pub struct Period {
+	#[serde(with = "period_format")]
+	pub start: NaiveTime,
+	#[serde(with = "period_format")]
+	pub end: NaiveTime,
+}
+
+mod period_format {
+	use chrono::NaiveTime;
+	use serde::{self, Deserialize, Deserializer, Serializer};
+
+	const FORMAT: &str = "%H:%M";
+
+	pub fn serialize<S>(time: &NaiveTime, serializer: S) -> Result<S::Ok, S::Error>
+	where
+		S: Serializer,
+	{
+		let s = format!("{}", time.format(FORMAT));
+		serializer.serialize_str(&s)
+	}
+
+	pub fn deserialize<'de, D>(deserializer: D) -> Result<NaiveTime, D::Error>
+	where
+		D: Deserializer<'de>,
+	{
+		let s = String::deserialize(deserializer)?;
+		NaiveTime::parse_from_str(&s, FORMAT).map_err(serde::de::Error::custom)
+	}
+}
+
+impl Period {
+	pub fn new(start: NaiveTime, end: NaiveTime) -> Self {
+		Period { start, end }
+	}
+
+	pub fn new_on() -> Self {
+		Period {
+			start: NaiveTime::from_hms_opt(0, 0, 0).unwrap(),
+			end: NaiveTime::from_hms_opt(0, 0, 0).unwrap(),
+		}
+	}
+}
+
+impl Type<Sqlite> for Periods {
+	fn type_info() -> SqliteTypeInfo {
+		<&[u8] as Type<Sqlite>>::type_info()
+	}
+
+	fn compatible(ty: &SqliteTypeInfo) -> bool {
+		<&[u8] as Type<Sqlite>>::compatible(ty)
+	}
+}
+
+impl<'q> Encode<'q, Sqlite> for Periods {
+	//noinspection DuplicatedCode
+	fn encode_by_ref(&self, buf: &mut <Sqlite as HasArguments<'q>>::ArgumentBuffer) -> IsNull {
+		<&Vec<u8> as Encode<Sqlite>>::encode(&Vec::from(self), buf)
+	}
+}
+
+impl<'r> Decode<'r, Sqlite> for Periods {
+	fn decode(value: SqliteValueRef<'r>) -> Result<Self, BoxDynError> {
+		let blob = <&[u8] as Decode<Sqlite>>::decode(value)?;
+		Ok(Periods::from(Vec::from(blob)))
+	}
+}
+
+impl From<&Periods> for Vec<u8> {
+	fn from(periods: &Periods) -> Vec<u8> {
+		periods
+			.0
+			.iter()
+			.flat_map(|period| {
+				let vec = vec![
+					period.start.hour() as u8,
+					period.start.minute() as u8,
+					period.end.hour() as u8,
+					period.end.minute() as u8,
+				];
+				vec
+			})
+			.collect()
+	}
+}
+
+impl From<Vec<u8>> for Periods {
+	fn from(value: Vec<u8>) -> Self {
+		let mut vec = Vec::new();
+		for i in (3..value.len()).step_by(4) {
+			let start_val_h: u32 = value[i - 3] as u32;
+			let start_val_m: u32 = value[i - 2] as u32;
+			let end_val_h: u32 = value[i - 1] as u32;
+			let end_val_m: u32 = value[i] as u32;
+			vec.push(Period {
+				start: NaiveTime::from_hms_opt(start_val_h, start_val_m, 0).unwrap(),
+				end: NaiveTime::from_hms_opt(end_val_h, end_val_m, 0).unwrap(),
+			});
+		}
+		Periods(vec)
+	}
+}