Refactor models names

This commit is contained in:
Tobias Reisinger 2023-11-27 12:49:40 +01:00
parent 76b14ce75b
commit be7f31906c
Signed by: serguzim
GPG key ID: 13AD60C237A28DFE
24 changed files with 461 additions and 340 deletions

View file

@ -0,0 +1,68 @@
use serde::{Serialize, Serializer};
use sqlx::database::HasArguments;
use sqlx::encode::IsNull;
use sqlx::error::BoxDynError;
use sqlx::sqlite::{SqliteTypeInfo, SqliteValueRef};
use sqlx::{Decode, Encode, Sqlite, Type};
use uuid::Uuid;
#[derive(Clone, Debug)]
pub struct ControllerUid(Uuid);
impl Default for ControllerUid {
fn default() -> Self {
Self(Uuid::new_v4())
}
}
impl Serialize for ControllerUid {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
String::from(self).serialize(serializer)
}
}
impl From<&ControllerUid> for String {
fn from(uid: &ControllerUid) -> String {
uid.0.as_hyphenated().to_string()
}
}
impl Type<Sqlite> for ControllerUid {
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 ControllerUid {
//noinspection DuplicatedCode
fn encode_by_ref(&self, buf: &mut <Sqlite as HasArguments<'q>>::ArgumentBuffer) -> IsNull {
let uuid_val = self.0.as_bytes().to_vec();
<&Vec<u8> as Encode<Sqlite>>::encode(&uuid_val, buf)
}
}
impl<'r> Decode<'r, Sqlite> for ControllerUid {
//noinspection DuplicatedCode
fn decode(value: SqliteValueRef<'r>) -> Result<Self, BoxDynError> {
Ok(Self::from(<&[u8] as Decode<Sqlite>>::decode(value)?))
}
}
impl From<&[u8]> for ControllerUid {
fn from(value: &[u8]) -> Self {
Self(Uuid::from_slice(value).unwrap())
}
}
impl From<Vec<u8>> for ControllerUid {
fn from(value: Vec<u8>) -> Self {
Self::from(value.as_slice())
}
}

View file

@ -0,0 +1,5 @@
mod controller_uid;
mod schedule_uid;
pub use controller_uid::ControllerUid;
pub use schedule_uid::ScheduleUid;

View file

@ -0,0 +1,147 @@
use std::convert::TryFrom;
use std::fmt::{Debug, Formatter};
use std::str::FromStr;
use serde::{Serialize, Serializer};
use sqlx::database::HasArguments;
use sqlx::encode::IsNull;
use sqlx::error::BoxDynError;
use sqlx::sqlite::{SqliteTypeInfo, SqliteValueRef};
use sqlx::{Decode, Encode, Sqlite, Type};
use uuid::Uuid;
#[derive(Clone)]
pub enum ScheduleUid {
Off,
On,
Any(Uuid),
}
impl ScheduleUid {
const OFF_STR: &'static str = "off";
const ON_STR: &'static str = "on";
const OFF_U8: u8 = 0;
const ON_U8: u8 = 1;
const OFF_U128: u128 = 0;
const ON_U128: u128 = 1;
}
impl Default for ScheduleUid {
fn default() -> Self {
Self::Any(Uuid::new_v4())
}
}
impl Debug for ScheduleUid {
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
match self {
Self::Off => Self::OFF_STR.fmt(f),
Self::On => Self::ON_STR.fmt(f),
Self::Any(value) => value.fmt(f),
}
}
}
impl Type<Sqlite> for ScheduleUid {
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 ScheduleUid {
//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 ScheduleUid {
//noinspection DuplicatedCode
fn decode(value: SqliteValueRef<'r>) -> Result<Self, BoxDynError> {
Ok(Self::from(<&[u8] as Decode<Sqlite>>::decode(value)?))
}
}
impl Serialize for ScheduleUid {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
String::from(self).serialize(serializer)
}
}
impl From<Uuid> for ScheduleUid {
fn from(uid: Uuid) -> Self {
match uid.as_u128() {
Self::OFF_U128 => Self::Off,
Self::ON_U128 => Self::On,
_ => Self::Any(uid),
}
}
}
impl TryFrom<&str> for ScheduleUid {
type Error = uuid::Error;
fn try_from(value: &str) -> Result<Self, Self::Error> {
match value {
Self::OFF_STR => Ok(Self::Off),
Self::ON_STR => Ok(Self::On),
any => match Uuid::from_str(any) {
Ok(uuid) => Ok(Self::Any(uuid)),
Err(err) => Err(err),
},
}
}
}
impl From<&ScheduleUid> for Uuid {
fn from(uid: &ScheduleUid) -> Uuid {
match uid {
ScheduleUid::Off => Uuid::from_u128(ScheduleUid::OFF_U128),
ScheduleUid::On => Uuid::from_u128(ScheduleUid::ON_U128),
ScheduleUid::Any(value) => *value,
}
}
}
impl From<&ScheduleUid> for String {
fn from(uid: &ScheduleUid) -> String {
match uid {
ScheduleUid::Off => String::from(ScheduleUid::OFF_STR),
ScheduleUid::On => String::from(ScheduleUid::ON_STR),
ScheduleUid::Any(value) => value.as_hyphenated().to_string(),
}
}
}
impl From<&ScheduleUid> for Vec<u8> {
fn from(uid: &ScheduleUid) -> Vec<u8> {
match uid {
ScheduleUid::Off => vec![ScheduleUid::OFF_U8],
ScheduleUid::On => vec![ScheduleUid::ON_U8],
ScheduleUid::Any(value) => value.as_bytes().to_vec(),
}
}
}
impl From<&[u8]> for ScheduleUid {
fn from(value: &[u8]) -> Self {
match value {
[Self::OFF_U8] => Self::Off,
[Self::ON_U8] => Self::On,
value_bytes => Self::Any(Uuid::from_slice(value_bytes).unwrap()),
}
}
}
impl From<Vec<u8>> for ScheduleUid {
fn from(value: Vec<u8>) -> Self {
Self::from(value.as_slice())
}
}