159 lines
3.9 KiB
Rust
159 lines
3.9 KiB
Rust
use crate::db::models::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 ToSql<Binary, Sqlite> for Periods
|
|
//where
|
|
// Vec<u8>: ToSql<Binary, Sqlite>,
|
|
//{
|
|
// fn to_sql<'b>(&'b self, out: &mut Output<'b, '_, Sqlite>) -> serialize::Result {
|
|
// let periods_u8: Vec<u8> = self
|
|
// .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();
|
|
//
|
|
// out.set_value(periods_u8);
|
|
//
|
|
// Ok(IsNull::No)
|
|
// }
|
|
//}
|
|
//
|
|
//impl<DB> FromSql<Binary, DB> for Periods
|
|
//where
|
|
// DB: diesel::backend::Backend,
|
|
// Vec<u8>: FromSql<Binary, DB>,
|
|
//{
|
|
// fn from_sql(bytes: DB::RawValue<'_>) -> deserialize::Result<Self> {
|
|
// let blob: Vec<u8> = Vec::from_sql(bytes).unwrap();
|
|
//
|
|
// let mut vec = Vec::new();
|
|
// for i in (3..blob.len()).step_by(4) {
|
|
// let start_val_h: u32 = blob[i - 3] as u32;
|
|
// let start_val_m: u32 = blob[i - 2] as u32;
|
|
// let end_val_h: u32 = blob[i - 1] as u32;
|
|
// let end_val_m: u32 = blob[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(),
|
|
// });
|
|
// }
|
|
// Ok(Periods(vec))
|
|
// }
|
|
//}
|
|
|
|
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)
|
|
}
|
|
}
|