emgauwa/core
2
0
Fork 0
Code Issues Pull requests Projects Releases1 Packages Wiki Activity Actions

Refactor models names

Browse source
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

40
emgauwa-lib/src/db/controllers.rs
View file

@ -5,11 +5,11 @@ use sqlx::pool::PoolConnection;
use sqlx::Sqlite;
use crate::db::errors::DatabaseError;
use crate::db::Tag;
use crate::db::types::ControllerUid;
use crate::db::DbTag;
use crate::types::ControllerUid;
#[derive(Debug, Serialize, Clone)]
pub struct Controller {
pub struct DbController {
pub id: i64,
pub uid: ControllerUid,
pub name: String,
@ -17,11 +17,11 @@ pub struct Controller {
pub active: bool,
}
impl Controller {
impl DbController {
pub async fn get_all(
conn: &mut PoolConnection<Sqlite>,
) -> Result<Vec<Controller>, DatabaseError> {
Ok(sqlx::query_as!(Controller, "SELECT * FROM controllers")
) -> Result<Vec<DbController>, DatabaseError> {
Ok(sqlx::query_as!(DbController, "SELECT * FROM controllers")
.fetch_all(conn.deref_mut())
.await?)
}
@ -29,12 +29,8 @@ impl Controller {
pub async fn get(
conn: &mut PoolConnection<Sqlite>,
id: i64,
) -> Result<Controller, DatabaseError> {
sqlx::query_as!(
Controller,
"SELECT * FROM controllers WHERE id = ?",
id
)
) -> Result<DbController, DatabaseError> {
sqlx::query_as!(DbController, "SELECT * FROM controllers WHERE id = ?", id)
.fetch_optional(conn.deref_mut())
.await
.map(|s| s.ok_or(DatabaseError::NotFound))?
@ -43,9 +39,9 @@ impl Controller {
pub async fn get_by_uid(
conn: &mut PoolConnection<Sqlite>,
filter_uid: &ControllerUid,
) -> Result<Controller, DatabaseError> {
) -> Result<DbController, DatabaseError> {
sqlx::query_as!(
Controller,
DbController,
"SELECT * FROM controllers WHERE uid = ?",
filter_uid
)
@ -56,9 +52,9 @@ impl Controller {
pub async fn get_by_tag(
conn: &mut PoolConnection<Sqlite>,
tag: &Tag,
) -> Result<Vec<Controller>, DatabaseError> {
Ok(sqlx::query_as!(Controller, "SELECT schedule.* FROM controllers AS schedule INNER JOIN junction_tag ON junction_tag.schedule_id = schedule.id WHERE junction_tag.tag_id = ?", tag.id)
tag: &DbTag,
) -> Result<Vec<DbController>, DatabaseError> {
Ok(sqlx::query_as!(DbController, "SELECT schedule.* FROM controllers AS schedule INNER JOIN junction_tag ON junction_tag.schedule_id = schedule.id WHERE junction_tag.tag_id = ?", tag.id)
.fetch_all(conn.deref_mut())
.await?)
}
@ -81,10 +77,10 @@ impl Controller {
new_uid: &ControllerUid,
new_name: &str,
new_relay_count: i64,
new_active: bool
) -> Result<Controller, DatabaseError> {
new_active: bool,
) -> Result<DbController, DatabaseError> {
sqlx::query_as!(
Controller,
DbController,
"INSERT INTO controllers (uid, name, relay_count, active) VALUES (?, ?, ?, ?) RETURNING *",
new_uid,
new_name,
@ -101,8 +97,8 @@ impl Controller {
conn: &mut PoolConnection<Sqlite>,
new_name: &str,
new_relay_count: i64,
new_active: bool
) -> Result<Controller, DatabaseError> {
new_active: bool,
) -> Result<DbController, DatabaseError> {
sqlx::query!(
"UPDATE controllers SET name = ?, relay_count = ?, active = ? WHERE id = ?",
new_name,

25
emgauwa-lib/src/db/mod.rs
View file

@ -6,20 +6,19 @@ use std::str::FromStr;
use crate::db::errors::DatabaseError;
use crate::db::model_utils::Period;
use crate::db::types::ScheduleUid;
use crate::types::ScheduleUid;
mod controllers;
pub mod errors;
mod model_utils;
mod relays;
mod schedules;
mod tag;
pub mod types;
mod controllers;
mod relays;
pub use controllers::Controller;
pub use relays::Relay;
pub use schedules::{Periods, Schedule};
pub use tag::Tag;
pub use controllers::DbController;
pub use relays::DbRelay;
pub use schedules::{DbPeriods, DbSchedule};
pub use tag::DbTag;
static MIGRATOR: Migrator = sqlx::migrate!("../migrations"); // defaults to "./migrations"
@ -32,16 +31,16 @@ async fn init_schedule(
pool: &Pool<Sqlite>,
uid: &ScheduleUid,
name: &str,
periods: Periods,
periods: DbPeriods,
) -> Result<(), DatabaseError> {
trace!("Initializing schedule {:?}", name);
match Schedule::get_by_uid(&mut pool.acquire().await.unwrap(), uid).await {
match DbSchedule::get_by_uid(&mut pool.acquire().await.unwrap(), uid).await {
Ok(_) => Ok(()),
Err(err) => match err {
DatabaseError::NotFound => {
trace!("Schedule {:?} not found, inserting", name);
sqlx::query_as!(
Schedule,
DbSchedule,
"INSERT INTO schedules (uid, name, periods) VALUES (?, ?, ?) RETURNING *",
uid,
name,
@ -71,7 +70,7 @@ pub async fn init(db: &str) -> Pool<Sqlite> {
run_migrations(&pool).await;
init_schedule(&pool, &ScheduleUid::Off, "Off", Periods(vec![]))
init_schedule(&pool, &ScheduleUid::Off, "Off", DbPeriods(vec![]))
.await
.expect("Error initializing schedule Off");
@ -79,7 +78,7 @@ pub async fn init(db: &str) -> Pool<Sqlite> {
&pool,
&ScheduleUid::On,
"On",
Periods(vec![Period::new_on()]),
DbPeriods(vec![Period::new_on()]),
)
.await
.expect("Error initializing schedule On");

18
emgauwa-lib/src/db/model_utils.rs
View file

@ -1,4 +1,4 @@
use crate::db::Periods;
use crate::db::DbPeriods;
use chrono::{NaiveTime, Timelike};
use serde::{Deserialize, Serialize};
use sqlx::database::HasArguments;
@ -51,7 +51,7 @@ impl Period {
}
}
impl Type<Sqlite> for Periods {
impl Type<Sqlite> for DbPeriods {
fn type_info() -> SqliteTypeInfo {
<&[u8] as Type<Sqlite>>::type_info()
}
@ -61,22 +61,22 @@ impl Type<Sqlite> for Periods {
}
}
impl<'q> Encode<'q, Sqlite> for Periods {
impl<'q> Encode<'q, Sqlite> for DbPeriods {
//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 {
impl<'r> Decode<'r, Sqlite> for DbPeriods {
fn decode(value: SqliteValueRef<'r>) -> Result<Self, BoxDynError> {
let blob = <&[u8] as Decode<Sqlite>>::decode(value)?;
Ok(Periods::from(Vec::from(blob)))
Ok(DbPeriods::from(Vec::from(blob)))
}
}
impl From<&Periods> for Vec<u8> {
fn from(periods: &Periods) -> Vec<u8> {
impl From<&DbPeriods> for Vec<u8> {
fn from(periods: &DbPeriods) -> Vec<u8> {
periods
.0
.iter()
@ -93,7 +93,7 @@ impl From<&Periods> for Vec<u8> {
}
}
impl From<Vec<u8>> for Periods {
impl From<Vec<u8>> for DbPeriods {
fn from(value: Vec<u8>) -> Self {
let mut vec = Vec::new();
for i in (3..value.len()).step_by(4) {
@ -106,6 +106,6 @@ impl From<Vec<u8>> for Periods {
end: NaiveTime::from_hms_opt(end_val_h, end_val_m, 0).unwrap(),
});
}
Periods(vec)
DbPeriods(vec)
}
}

81
emgauwa-lib/src/db/relays.rs
View file

@ -1,16 +1,15 @@
use serde_derive::Serialize;
use std::ops::DerefMut;
use crate::db::DbController;
use sqlx::pool::PoolConnection;
use sqlx::Sqlite;
use crate::db::Controller;
use crate::db::errors::DatabaseError;
use crate::db::Tag;
use crate::db::DbTag;
#[derive(Debug, Serialize, Clone)]
#[derive(sqlx::FromRow)]
pub struct Relay {
#[derive(Debug, Serialize, Clone, sqlx::FromRow)]
pub struct DbRelay {
#[serde(skip)]
pub id: i64,
pub name: String,
@ -19,34 +18,41 @@ pub struct Relay {
pub controller_id: i64,
}
impl Relay {
pub async fn get_all(
conn: &mut PoolConnection<Sqlite>,
) -> Result<Vec<Relay>, DatabaseError> {
Ok(sqlx::query_as!(Relay, "SELECT * FROM relays")
impl DbRelay {
pub async fn get_all(conn: &mut PoolConnection<Sqlite>) -> Result<Vec<DbRelay>, DatabaseError> {
Ok(sqlx::query_as!(DbRelay, "SELECT * FROM relays")
.fetch_all(conn.deref_mut())
.await?)
}
pub async fn get(
conn: &mut PoolConnection<Sqlite>,
id: i64,
) -> Result<Relay, DatabaseError> {
sqlx::query_as!(
Relay,
"SELECT * FROM relays WHERE id = ?",
id
)
pub async fn get(conn: &mut PoolConnection<Sqlite>, id: i64) -> Result<DbRelay, DatabaseError> {
sqlx::query_as!(DbRelay, "SELECT * FROM relays WHERE id = ?", id)
.fetch_optional(conn.deref_mut())
.await
.map(|s| s.ok_or(DatabaseError::NotFound))?
}
pub async fn get_by_controller_and_num(
conn: &mut PoolConnection<Sqlite>,
controller: &DbController,
number: i64,
) -> Result<DbRelay, DatabaseError> {
sqlx::query_as!(
DbRelay,
"SELECT * FROM relays WHERE controller_id = ? AND number = ?",
controller.id,
number
)
.fetch_optional(conn.deref_mut())
.await
.map(|s| s.ok_or(DatabaseError::NotFound))?
}
pub async fn get_by_tag(
conn: &mut PoolConnection<Sqlite>,
tag: &Tag,
) -> Result<Vec<Relay>, DatabaseError> {
Ok(sqlx::query_as!(Relay, "SELECT schedule.* FROM relays AS schedule INNER JOIN junction_tag ON junction_tag.schedule_id = schedule.id WHERE junction_tag.tag_id = ?", tag.id)
tag: &DbTag,
) -> Result<Vec<DbRelay>, DatabaseError> {
Ok(sqlx::query_as!(DbRelay, "SELECT schedule.* FROM relays AS schedule INNER JOIN junction_tag ON junction_tag.schedule_id = schedule.id WHERE junction_tag.tag_id = ?", tag.id)
.fetch_all(conn.deref_mut())
.await?)
}
@ -55,10 +61,10 @@ impl Relay {
conn: &mut PoolConnection<Sqlite>,
new_name: &str,
new_number: i64,
new_controller: &Controller,
) -> Result<Relay, DatabaseError> {
new_controller: &DbController,
) -> Result<DbRelay, DatabaseError> {
sqlx::query_as!(
Relay,
DbRelay,
"INSERT INTO relays (name, number, controller_id) VALUES (?, ?, ?) RETURNING *",
new_name,
new_number,
@ -69,10 +75,7 @@ impl Relay {
.ok_or(DatabaseError::InsertGetError)
}
pub async fn delete(
&self,
conn: &mut PoolConnection<Sqlite>,
) -> Result<(), DatabaseError> {
pub async fn delete(&self, conn: &mut PoolConnection<Sqlite>) -> Result<(), DatabaseError> {
sqlx::query!("DELETE FROM relays WHERE id = ?", self.id)
.execute(conn.deref_mut())
.await
@ -87,8 +90,8 @@ impl Relay {
conn: &mut PoolConnection<Sqlite>,
new_name: &str,
new_number: i64,
new_controller: &Controller,
) -> Result<Relay, DatabaseError> {
new_controller: &DbController,
) -> Result<DbRelay, DatabaseError> {
sqlx::query!(
"UPDATE relays SET name = ?, number = ?, controller_id = ? WHERE id = ?",
new_name,
@ -99,14 +102,20 @@ impl Relay {
.execute(conn.deref_mut())
.await?;
Relay::get(conn, self.id).await
DbRelay::get(conn, self.id).await
}
pub async fn get_controller(&self, conn: &mut PoolConnection<Sqlite>) -> Result<Controller, DatabaseError> {
Controller::get(conn, self.controller_id).await
pub async fn get_controller(
&self,
conn: &mut PoolConnection<Sqlite>,
) -> Result<DbController, DatabaseError> {
DbController::get(conn, self.controller_id).await
}
pub async fn get_tags(&self, conn: &mut PoolConnection<Sqlite>) -> Result<Vec<String>, DatabaseError> {
pub async fn get_tags(
&self,
conn: &mut PoolConnection<Sqlite>,
) -> Result<Vec<String>, DatabaseError> {
Ok(sqlx::query_scalar!("SELECT tag FROM tags INNER JOIN junction_tag ON junction_tag.tag_id = tags.id WHERE junction_tag.relay_id = ?", self.id)
.fetch_all(conn.deref_mut())
.await?)
@ -122,7 +131,7 @@ impl Relay {
.await?;
for new_tag in new_tags {
let tag: Tag = Tag::get_by_tag_or_create(conn, new_tag).await?;
let tag: DbTag = DbTag::get_by_tag_or_create(conn, new_tag).await?;
tag.link_relay(conn, self).await?;
}
Ok(())

48
emgauwa-lib/src/db/schedules.rs
View file

@ -7,27 +7,27 @@ use sqlx::Sqlite;
use crate::db::errors::DatabaseError;
use crate::db::model_utils::Period;
use crate::db::Tag;
use crate::db::types::ScheduleUid;
use crate::db::DbTag;
use crate::types::ScheduleUid;
#[derive(Debug, Serialize, Clone)]
pub struct Schedule {
pub struct DbSchedule {
#[serde(skip)]
pub id: i64,
#[serde(rename(serialize = "id"))]
pub uid: ScheduleUid,
pub name: String,
pub periods: Periods,
pub periods: DbPeriods,
}
#[derive(Debug, Serialize, Deserialize, PartialEq, Clone)]
pub struct Periods(pub Vec<Period>);
pub struct DbPeriods(pub Vec<Period>);
impl Schedule {
impl DbSchedule {
pub async fn get_all(
conn: &mut PoolConnection<Sqlite>,
) -> Result<Vec<Schedule>, DatabaseError> {
Ok(sqlx::query_as!(Schedule, "SELECT * FROM schedules")
) -> Result<Vec<DbSchedule>, DatabaseError> {
Ok(sqlx::query_as!(DbSchedule, "SELECT * FROM schedules")
.fetch_all(conn.deref_mut())
.await?)
}
@ -35,12 +35,8 @@ impl Schedule {
pub async fn get(
conn: &mut PoolConnection<Sqlite>,
id: i64,
) -> Result<Schedule, DatabaseError> {
sqlx::query_as!(
Schedule,
"SELECT * FROM schedules WHERE id = ?",
id
)
) -> Result<DbSchedule, DatabaseError> {
sqlx::query_as!(DbSchedule, "SELECT * FROM schedules WHERE id = ?", id)
.fetch_optional(conn.deref_mut())
.await
.map(|s| s.ok_or(DatabaseError::NotFound))?
@ -49,9 +45,9 @@ impl Schedule {
pub async fn get_by_uid(
conn: &mut PoolConnection<Sqlite>,
filter_uid: &ScheduleUid,
) -> Result<Schedule, DatabaseError> {
) -> Result<DbSchedule, DatabaseError> {
sqlx::query_as!(
Schedule,
DbSchedule,
"SELECT * FROM schedules WHERE uid = ?",
filter_uid
)
@ -62,9 +58,9 @@ impl Schedule {
pub async fn get_by_tag(
conn: &mut PoolConnection<Sqlite>,
tag: &Tag,
) -> Result<Vec<Schedule>, DatabaseError> {
Ok(sqlx::query_as!(Schedule, "SELECT schedule.* FROM schedules AS schedule INNER JOIN junction_tag ON junction_tag.schedule_id = schedule.id WHERE junction_tag.tag_id = ?", tag.id)
tag: &DbTag,
) -> Result<Vec<DbSchedule>, DatabaseError> {
Ok(sqlx::query_as!(DbSchedule, "SELECT schedule.* FROM schedules AS schedule INNER JOIN junction_tag ON junction_tag.schedule_id = schedule.id WHERE junction_tag.tag_id = ?", tag.id)
.fetch_all(conn.deref_mut())
.await?)
}
@ -91,11 +87,11 @@ impl Schedule {
pub async fn create(
conn: &mut PoolConnection<Sqlite>,
new_name: &str,
new_periods: &Periods,
) -> Result<Schedule, DatabaseError> {
new_periods: &DbPeriods,
) -> Result<DbSchedule, DatabaseError> {
let uid = ScheduleUid::default();
sqlx::query_as!(
Schedule,
DbSchedule,
"INSERT INTO schedules (uid, name, periods) VALUES (?, ?, ?) RETURNING *",
uid,
new_name,
@ -110,8 +106,8 @@ impl Schedule {
&self,
conn: &mut PoolConnection<Sqlite>,
new_name: &str,
new_periods: &Periods,
) -> Result<Schedule, DatabaseError> {
new_periods: &DbPeriods,
) -> Result<DbSchedule, DatabaseError> {
// overwrite periods on protected schedules
let new_periods = match self.uid {
ScheduleUid::Off | ScheduleUid::On => self.periods.borrow(),
@ -127,7 +123,7 @@ impl Schedule {
.execute(conn.deref_mut())
.await?;
Schedule::get(conn, self.id).await
DbSchedule::get(conn, self.id).await
}
pub async fn get_tags(
@ -149,7 +145,7 @@ impl Schedule {
.await?;
for new_tag in new_tags {
let tag: Tag = Tag::get_by_tag_or_create(conn, new_tag).await?;
let tag: DbTag = DbTag::get_by_tag_or_create(conn, new_tag).await?;
tag.link_schedule(conn, self).await?;
}
Ok(())

41
emgauwa-lib/src/db/tag.rs
View file

@ -5,28 +5,28 @@ use sqlx::pool::PoolConnection;
use sqlx::Sqlite;
use crate::db::errors::DatabaseError;
use crate::db::{Relay, Schedule};
use crate::db::{DbRelay, DbSchedule};
#[derive(Debug, Serialize, Clone)]
pub struct Tag {
pub struct DbTag {
pub id: i64,
pub tag: String,
}
pub struct JunctionTag {
pub struct DbJunctionTag {
pub id: i64,
pub tag_id: i64,
pub relay_id: Option<i64>,
pub schedule_id: Option<i64>,
}
impl Tag {
impl DbTag {
pub async fn create(
conn: &mut PoolConnection<Sqlite>,
new_tag: &str,
) -> Result<Tag, DatabaseError> {
) -> Result<DbTag, DatabaseError> {
sqlx::query_as!(
Tag,
DbTag,
"INSERT INTO tags (tag) VALUES (?) RETURNING *",
new_tag
)
@ -35,11 +35,8 @@ impl Tag {
.ok_or(DatabaseError::InsertGetError)
}
pub async fn get(
conn: &mut PoolConnection<Sqlite>,
id: i64,
) -> Result<Tag, DatabaseError> {
sqlx::query_as!(Tag, "SELECT * FROM tags WHERE id = ?", id)
pub async fn get(conn: &mut PoolConnection<Sqlite>, id: i64) -> Result<DbTag, DatabaseError> {
sqlx::query_as!(DbTag, "SELECT * FROM tags WHERE id = ?", id)
.fetch_optional(conn.deref_mut())
.await
.map(|t| t.ok_or(DatabaseError::NotFound))?
@ -48,10 +45,10 @@ impl Tag {
pub async fn get_by_tag_or_create(
conn: &mut PoolConnection<Sqlite>,
target_tag: &str,
) -> Result<Tag, DatabaseError> {
match Tag::get_by_tag(conn, target_tag).await {
) -> Result<DbTag, DatabaseError> {
match DbTag::get_by_tag(conn, target_tag).await {
Ok(tag) => Ok(tag),
Err(DatabaseError::NotFound) => Tag::create(conn, target_tag).await,
Err(DatabaseError::NotFound) => DbTag::create(conn, target_tag).await,
Err(e) => Err(e),
}
}
@ -59,8 +56,8 @@ impl Tag {
pub async fn get_by_tag(
conn: &mut PoolConnection<Sqlite>,
target_tag: &str,
) -> Result<Tag, DatabaseError> {
sqlx::query_as!(Tag, "SELECT * FROM tags WHERE tag = ?", target_tag)
) -> Result<DbTag, DatabaseError> {
sqlx::query_as!(DbTag, "SELECT * FROM tags WHERE tag = ?", target_tag)
.fetch_optional(conn.deref_mut())
.await
.map(|t| t.ok_or(DatabaseError::NotFound))?
@ -69,10 +66,10 @@ impl Tag {
pub async fn link_relay(
&self,
conn: &mut PoolConnection<Sqlite>,
target_relay: &Relay,
) -> Result<JunctionTag, DatabaseError> {
target_relay: &DbRelay,
) -> Result<DbJunctionTag, DatabaseError> {
sqlx::query_as!(
JunctionTag,
DbJunctionTag,
"INSERT INTO junction_tag (tag_id, relay_id) VALUES (?, ?) RETURNING *",
self.id,
target_relay.id
@ -85,10 +82,10 @@ impl Tag {
pub async fn link_schedule(
&self,
conn: &mut PoolConnection<Sqlite>,
target_schedule: &Schedule,
) -> Result<JunctionTag, DatabaseError> {
target_schedule: &DbSchedule,
) -> Result<DbJunctionTag, DatabaseError> {
sqlx::query_as!(
JunctionTag,
DbJunctionTag,
"INSERT INTO junction_tag (tag_id, schedule_id) VALUES (?, ?) RETURNING *",
self.id,
target_schedule.id

68
emgauwa-lib/src/db/types/controller_uid.rs
View file

@ -1,68 +0,0 @@
use serde::{Serialize, Serializer};
use sqlx::{Decode, Encode, Sqlite, Type};
use sqlx::database::HasArguments;
use sqlx::encode::IsNull;
use sqlx::error::BoxDynError;
use sqlx::sqlite::{SqliteTypeInfo, SqliteValueRef};
use uuid::Uuid;
#[derive(Clone, Debug)]
pub struct ControllerUid(Uuid);
impl ControllerUid {
pub fn new() -> 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())
}
}

5
emgauwa-lib/src/db/types/mod.rs
View file

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

147
emgauwa-lib/src/db/types/schedule_uid.rs
View file

@ -1,147 +0,0 @@
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())
}
}