emgauwa/common
2
0
Fork 0
Code Issues Pull requests Packages Projects Releases Wiki Activity

Compare commits

base: emgauwa:19e2ea003b577b738d4aa962c78bb28220af89ca
Branches Tags
emgauwa:main
emgauwa:v0.5.0
...
compare: emgauwa:8e4ddb8e44adb90e4cfb5ed63b7b94f3c1ca7704
Branches Tags
emgauwa:main
emgauwa:v0.5.0

3 commits
19e2ea003b ... 8e4ddb8e44

Author SHA1 Message Date
Tobias Reisinger 8e4ddb8e44
Fix wrong table in macro update 2024-05-02 21:14:28 +02:00
Tobias Reisinger 98db89ce03
Fix is_on function for Periods 2024-05-02 20:12:43 +02:00
Tobias Reisinger fc4c1df09a
Revert "Add sql transactions" 
This caused the error "locked database".
This reverts commit 19e2ea003b.
 2024-05-02 19:35:22 +02:00
20 changed files with 268 additions and 248 deletions
Show stats Expand all files Collapse all files

2
Cargo.toml
View file

@ -23,7 +23,7 @@ chrono = { version = "0.4", features = ["serde"] }
sqlx = { version = "0.7", features = ["sqlite", "runtime-tokio", "macros", "chrono"] }
libsqlite3-sys = { version = "*", features = ["bundled"] }
uuid = "1.6"
uuid = { version = "1.8", features = ["v4"] }
futures = "0.3"
libc = "0.2"

2
Makefile
View file

@ -1,3 +1,5 @@
export DATABASE_URL=sqlite://${PWD}/emgauwa-dev.sqlite
sqlx:
cargo sqlx database drop -y
cargo sqlx database create

58
src/db/controllers.rs
View file

@ -1,7 +1,7 @@
use std::ops::DerefMut;
use serde_derive::{Deserialize, Serialize};
use sqlx::Transaction;
use sqlx::pool::PoolConnection;
use sqlx::Sqlite;
use crate::db::{DbRelay, DbTag};
@ -21,26 +21,26 @@ pub struct DbController {
impl DbController {
pub async fn get_all(
tx: &mut Transaction<'_, Sqlite>,
conn: &mut PoolConnection<Sqlite>,
) -> Result<Vec<DbController>, DatabaseError> {
sqlx::query_as!(DbController, "SELECT * FROM controllers")
.fetch_all(tx.deref_mut())
.fetch_all(conn.deref_mut())
.await
.map_err(DatabaseError::from)
}
pub async fn get(
tx: &mut Transaction<'_, Sqlite>,
conn: &mut PoolConnection<Sqlite>,
id: i64,
) -> Result<Option<DbController>, DatabaseError> {
sqlx::query_as!(DbController, "SELECT * FROM controllers WHERE id = ?", id)
.fetch_optional(tx.deref_mut())
.fetch_optional(conn.deref_mut())
.await
.map_err(DatabaseError::from)
}
pub async fn get_by_uid(
tx: &mut Transaction<'_, Sqlite>,
conn: &mut PoolConnection<Sqlite>,
filter_uid: &EmgauwaUid,
) -> Result<Option<DbController>, DatabaseError> {
sqlx::query_as!(
@ -48,39 +48,39 @@ impl DbController {
"SELECT * FROM controllers WHERE uid = ?",
filter_uid
)
.fetch_optional(tx.deref_mut())
.fetch_optional(conn.deref_mut())
.await
.map_err(DatabaseError::from)
}
pub async fn get_by_uid_or_create(
tx: &mut Transaction<'_, Sqlite>,
conn: &mut PoolConnection<Sqlite>,
uid: &EmgauwaUid,
new_name: &str,
new_relay_count: i64,
) -> Result<DbController, DatabaseError> {
match DbController::get_by_uid(tx, uid).await? {
match DbController::get_by_uid(conn, uid).await? {
Some(tag) => Ok(tag),
None => DbController::create(tx, uid, new_name, new_relay_count).await,
None => DbController::create(conn, uid, new_name, new_relay_count).await,
}
}
pub async fn get_by_tag(
tx: &mut Transaction<'_, Sqlite>,
conn: &mut PoolConnection<Sqlite>,
tag: &DbTag,
) -> Result<Vec<DbController>, DatabaseError> {
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(tx.deref_mut())
.fetch_all(conn.deref_mut())
.await
.map_err(DatabaseError::from)
}
pub async fn delete_by_uid(
tx: &mut Transaction<'_, Sqlite>,
conn: &mut PoolConnection<Sqlite>,
filter_uid: EmgauwaUid,
) -> Result<(), DatabaseError> {
if sqlx::query_scalar!("SELECT 1 FROM controllers WHERE uid = ?", filter_uid)
.fetch_optional(tx.deref_mut())
.fetch_optional(conn.deref_mut())
.await?
.is_none()
{
@ -88,7 +88,7 @@ impl DbController {
}
sqlx::query!("DELETE FROM controllers WHERE uid = ?", filter_uid)
.execute(tx.deref_mut())
.execute(conn.deref_mut())
.await
.map(|res| match res.rows_affected() {
0 => Err(DatabaseError::DeleteError),
@ -97,7 +97,7 @@ impl DbController {
}
pub async fn create(
tx: &mut Transaction<'_, Sqlite>,
conn: &mut PoolConnection<Sqlite>,
new_uid: &EmgauwaUid,
new_name: &str,
new_relay_count: i64,
@ -109,14 +109,14 @@ impl DbController {
new_name,
new_relay_count,
)
.fetch_optional(tx.deref_mut())
.fetch_optional(conn.deref_mut())
.await?
.ok_or(DatabaseError::InsertGetError)
}
pub async fn update(
&self,
tx: &mut Transaction<'_, Sqlite>,
conn: &mut PoolConnection<Sqlite>,
new_name: &str,
new_relay_count: i64,
) -> Result<DbController, DatabaseError> {
@ -126,17 +126,17 @@ impl DbController {
new_relay_count,
self.id,
)
.execute(tx.deref_mut())
.execute(conn.deref_mut())
.await?;
Self::get(tx, self.id)
Self::get(conn, self.id)
.await?
.ok_or(DatabaseError::UpdateGetError)
}
pub async fn update_active(
&self,
tx: &mut Transaction<'_, Sqlite>,
conn: &mut PoolConnection<Sqlite>,
new_active: bool,
) -> Result<DbController, DatabaseError> {
sqlx::query!(
@ -144,40 +144,40 @@ impl DbController {
new_active,
self.id,
)
.execute(tx.deref_mut())
.execute(conn.deref_mut())
.await?;
Self::get(tx, self.id)
Self::get(conn, self.id)
.await?
.ok_or(DatabaseError::UpdateGetError)
}
pub async fn get_relays(
&self,
tx: &mut Transaction<'_, Sqlite>,
conn: &mut PoolConnection<Sqlite>,
) -> Result<Vec<DbRelay>, DatabaseError> {
sqlx::query_as!(
DbRelay,
"SELECT * FROM relays WHERE controller_id = ?",
self.id
)
.fetch_all(tx.deref_mut())
.fetch_all(conn.deref_mut())
.await
.map_err(DatabaseError::from)
}
pub async fn all_inactive(tx: &mut Transaction<'_, Sqlite>) -> Result<(), DatabaseError> {
pub async fn all_inactive(conn: &mut PoolConnection<Sqlite>) -> Result<(), DatabaseError> {
sqlx::query!("UPDATE controllers SET active = 0")
.execute(tx.deref_mut())
.execute(conn.deref_mut())
.await?;
Ok(())
}
pub async fn reload(
&self,
tx: &mut Transaction<'_, Sqlite>,
conn: &mut PoolConnection<Sqlite>,
) -> Result<DbController, DatabaseError> {
Self::get(tx, self.id)
Self::get(conn, self.id)
.await?
.ok_or(DatabaseError::NotFound)
}

36
src/db/junction_relay_schedule.rs
View file

@ -1,6 +1,6 @@
use std::ops::DerefMut;
use sqlx::Transaction;
use sqlx::pool::PoolConnection;
use sqlx::Sqlite;
use crate::db::{DbRelay, DbSchedule};
@ -16,7 +16,7 @@ pub struct DbJunctionRelaySchedule {
impl DbJunctionRelaySchedule {
pub async fn get(
tx: &mut Transaction<'_, Sqlite>,
conn: &mut PoolConnection<Sqlite>,
id: i64,
) -> Result<Option<DbJunctionRelaySchedule>, DatabaseError> {
sqlx::query_as!(
@ -24,13 +24,13 @@ impl DbJunctionRelaySchedule {
"SELECT * FROM junction_relay_schedule WHERE id = ?",
id
)
.fetch_optional(tx.deref_mut())
.fetch_optional(conn.deref_mut())
.await
.map_err(DatabaseError::from)
}
pub async fn get_junction_by_relay_and_weekday(
tx: &mut Transaction<'_, Sqlite>,
conn: &mut PoolConnection<Sqlite>,
relay: &DbRelay,
weekday: Weekday,
) -> Result<Option<DbJunctionRelaySchedule>, DatabaseError> {
@ -40,13 +40,13 @@ impl DbJunctionRelaySchedule {
relay.id,
weekday
)
.fetch_optional(tx.deref_mut())
.fetch_optional(conn.deref_mut())
.await
.map_err(DatabaseError::from)
}
pub async fn get_relays(
tx: &mut Transaction<'_, Sqlite>,
conn: &mut PoolConnection<Sqlite>,
schedule: &DbSchedule,
) -> Result<Vec<DbRelay>, DatabaseError> {
sqlx::query_as!(
@ -57,13 +57,13 @@ impl DbJunctionRelaySchedule {
ORDER BY junction_relay_schedule.weekday"#,
schedule.id
)
.fetch_all(tx.deref_mut())
.fetch_all(conn.deref_mut())
.await
.map_err(DatabaseError::from)
}
pub async fn get_schedule(
tx: &mut Transaction<'_, Sqlite>,
conn: &mut PoolConnection<Sqlite>,
relay: &DbRelay,
weekday: Weekday,
) -> Result<Option<DbSchedule>, DatabaseError> {
@ -75,13 +75,13 @@ impl DbJunctionRelaySchedule {
relay.id,
weekday
)
.fetch_optional(tx.deref_mut())
.fetch_optional(conn.deref_mut())
.await
.map_err(DatabaseError::from)
}
pub async fn get_schedules(
tx: &mut Transaction<'_, Sqlite>,
conn: &mut PoolConnection<Sqlite>,
relay: &DbRelay,
) -> Result<Vec<DbSchedule>, DatabaseError> {
sqlx::query_as!(
@ -92,18 +92,18 @@ impl DbJunctionRelaySchedule {
ORDER BY junction_relay_schedule.weekday"#,
relay.id
)
.fetch_all(tx.deref_mut())
.fetch_all(conn.deref_mut())
.await
.map_err(DatabaseError::from)
}
pub async fn set_schedule(
tx: &mut Transaction<'_, Sqlite>,
conn: &mut PoolConnection<Sqlite>,
relay: &DbRelay,
schedule: &DbSchedule,
weekday: Weekday,
) -> Result<DbJunctionRelaySchedule, DatabaseError> {
match Self::get_junction_by_relay_and_weekday(tx, relay, weekday).await? {
match Self::get_junction_by_relay_and_weekday(conn, relay, weekday).await? {
None => sqlx::query_as!(
DbJunctionRelaySchedule,
"INSERT INTO junction_relay_schedule (weekday, relay_id, schedule_id) VALUES (?, ?, ?) RETURNING *",
@ -111,7 +111,7 @@ impl DbJunctionRelaySchedule {
relay.id,
schedule.id
)
.fetch_optional(tx.deref_mut())
.fetch_optional(conn.deref_mut())
.await?
.ok_or(DatabaseError::InsertGetError),
@ -123,10 +123,10 @@ impl DbJunctionRelaySchedule {
schedule.id,
junction.id
)
.execute(tx.deref_mut())
.execute(conn.deref_mut())
.await?;
Self::get(tx, junction.id)
Self::get(conn, junction.id)
.await?
.ok_or(DatabaseError::UpdateGetError)
}
@ -134,12 +134,12 @@ impl DbJunctionRelaySchedule {
}
pub async fn set_schedules(
tx: &mut Transaction<'_, Sqlite>,
conn: &mut PoolConnection<Sqlite>,
relay: &DbRelay,
schedules: Vec<&DbSchedule>,
) -> Result<(), DatabaseError> {
for (weekday, schedule) in schedules.iter().enumerate() {
Self::set_schedule(tx, relay, schedule, weekday as Weekday).await?;
Self::set_schedule(conn, relay, schedule, weekday as Weekday).await?;
}
Ok(())
}

10
src/db/junction_tag.rs
View file

@ -1,6 +1,6 @@
use std::ops::DerefMut;
use sqlx::Transaction;
use sqlx::pool::PoolConnection;
use sqlx::Sqlite;
use crate::db::{DbRelay, DbSchedule, DbTag};
@ -15,7 +15,7 @@ pub struct DbJunctionTag {
impl DbJunctionTag {
pub async fn link_relay(
tx: &mut Transaction<'_, Sqlite>,
conn: &mut PoolConnection<Sqlite>,
tag: &DbTag,
relay: &DbRelay,
) -> Result<DbJunctionTag, DatabaseError> {
@ -25,13 +25,13 @@ impl DbJunctionTag {
tag.id,
relay.id
)
.fetch_optional(tx.deref_mut())
.fetch_optional(conn.deref_mut())
.await?
.ok_or(DatabaseError::InsertGetError)
}
pub async fn link_schedule(
tx: &mut Transaction<'_, Sqlite>,
conn: &mut PoolConnection<Sqlite>,
tag: &DbTag,
schedule: &DbSchedule,
) -> Result<DbJunctionTag, DatabaseError> {
@ -41,7 +41,7 @@ impl DbJunctionTag {
tag.id,
schedule.id
)
.fetch_optional(tx.deref_mut())
.fetch_optional(conn.deref_mut())
.await?
.ok_or(DatabaseError::InsertGetError)
}

56
src/db/macro.rs
View file

@ -1,7 +1,7 @@
use std::ops::DerefMut;
use serde_derive::{Deserialize, Serialize};
use sqlx::Transaction;
use sqlx::pool::PoolConnection;
use sqlx::Sqlite;
use crate::db::{DbController, DbMacroAction, DbRelay, DbSchedule};
@ -18,35 +18,35 @@ pub struct DbMacro {
}
impl DbMacro {
pub async fn get_all(tx: &mut Transaction<'_, Sqlite>) -> Result<Vec<DbMacro>, DatabaseError> {
pub async fn get_all(conn: &mut PoolConnection<Sqlite>) -> Result<Vec<DbMacro>, DatabaseError> {
sqlx::query_as!(DbMacro, "SELECT * FROM macros")
.fetch_all(tx.deref_mut())
.fetch_all(conn.deref_mut())
.await
.map_err(DatabaseError::from)
}
pub async fn get(
tx: &mut Transaction<'_, Sqlite>,
conn: &mut PoolConnection<Sqlite>,
id: i64,
) -> Result<Option<DbMacro>, DatabaseError> {
sqlx::query_as!(DbMacro, "SELECT * FROM macros WHERE id = ?", id)
.fetch_optional(tx.deref_mut())
.fetch_optional(conn.deref_mut())
.await
.map_err(DatabaseError::from)
}
pub async fn get_by_uid(
tx: &mut Transaction<'_, Sqlite>,
conn: &mut PoolConnection<Sqlite>,
filter_uid: &EmgauwaUid,
) -> Result<Option<DbMacro>, DatabaseError> {
sqlx::query_as!(DbMacro, "SELECT * FROM macros WHERE uid = ?", filter_uid)
.fetch_optional(tx.deref_mut())
.fetch_optional(conn.deref_mut())
.await
.map_err(DatabaseError::from)
}
pub async fn create(
tx: &mut Transaction<'_, Sqlite>,
conn: &mut PoolConnection<Sqlite>,
new_uid: EmgauwaUid,
new_name: &str,
) -> Result<DbMacro, DatabaseError> {
@ -56,14 +56,14 @@ impl DbMacro {
new_uid,
new_name
)
.fetch_optional(tx.deref_mut())
.fetch_optional(conn.deref_mut())
.await?
.ok_or(DatabaseError::InsertGetError)
}
pub async fn delete(&self, tx: &mut Transaction<'_, Sqlite>) -> Result<(), DatabaseError> {
pub async fn delete(&self, conn: &mut PoolConnection<Sqlite>) -> Result<(), DatabaseError> {
sqlx::query!("DELETE FROM macros WHERE id = ?", self.id)
.execute(tx.deref_mut())
.execute(conn.deref_mut())
.await
.map(|res| match res.rows_affected() {
0 => Err(DatabaseError::DeleteError),
@ -72,11 +72,11 @@ impl DbMacro {
}
pub async fn delete_by_uid(
tx: &mut Transaction<'_, Sqlite>,
conn: &mut PoolConnection<Sqlite>,
filter_uid: EmgauwaUid,
) -> Result<(), DatabaseError> {
if sqlx::query_scalar!("SELECT 1 FROM macros WHERE uid = ?", filter_uid)
.fetch_optional(tx.deref_mut())
.fetch_optional(conn.deref_mut())
.await?
.is_none()
{
@ -84,7 +84,7 @@ impl DbMacro {
}
sqlx::query!("DELETE FROM macros WHERE uid = ?", filter_uid)
.execute(tx.deref_mut())
.execute(conn.deref_mut())
.await
.map(|res| match res.rows_affected() {
0 => Err(DatabaseError::DeleteError),
@ -94,62 +94,62 @@ impl DbMacro {
pub async fn update(
&self,
tx: &mut Transaction<'_, Sqlite>,
conn: &mut PoolConnection<Sqlite>,
new_name: &str,
) -> Result<DbMacro, DatabaseError> {
sqlx::query!("UPDATE relays SET name = ? WHERE id = ?", new_name, self.id,)
.execute(tx.deref_mut())
sqlx::query!("UPDATE macros SET name = ? WHERE id = ?", new_name, self.id,)
.execute(conn.deref_mut())
.await?;
DbMacro::get(tx, self.id)
DbMacro::get(conn, self.id)
.await?
.ok_or(DatabaseError::UpdateGetError)
}
pub async fn set_actions(
&self,
tx: &mut Transaction<'_, Sqlite>,
conn: &mut PoolConnection<Sqlite>,
new_actions: &[RequestMacroAction],
) -> Result<(), DatabaseError> {
sqlx::query!("DELETE FROM macro_actions WHERE macro_id = ?", self.id)
.execute(tx.deref_mut())
.execute(conn.deref_mut())
.await?;
for new_action in new_actions {
let controller = DbController::get_by_uid(tx, &new_action.relay.controller_id)
let controller = DbController::get_by_uid(conn, &new_action.relay.controller_id)
.await?
.ok_or(DatabaseError::NotFound)?;
let relay =
DbRelay::get_by_controller_and_num(tx, &controller, new_action.relay.number)
DbRelay::get_by_controller_and_num(conn, &controller, new_action.relay.number)
.await?
.ok_or(DatabaseError::NotFound)?;
let schedule = DbSchedule::get_by_uid(tx, &new_action.schedule.id)
let schedule = DbSchedule::get_by_uid(conn, &new_action.schedule.id)
.await?
.ok_or(DatabaseError::NotFound)?;
DbMacroAction::create(tx, self, &relay, &schedule, new_action.weekday).await?;
DbMacroAction::create(conn, self, &relay, &schedule, new_action.weekday).await?;
}
Ok(())
}
pub async fn get_actions(
&self,
tx: &mut Transaction<'_, Sqlite>,
conn: &mut PoolConnection<Sqlite>,
) -> Result<Vec<DbMacroAction>, DatabaseError> {
sqlx::query_as!(
DbMacroAction,
"SELECT * FROM macro_actions WHERE macro_id = ?",
self.id
)
.fetch_all(tx.deref_mut())
.fetch_all(conn.deref_mut())
.await
.map_err(DatabaseError::from)
}
pub async fn get_actions_weekday(
&self,
tx: &mut Transaction<'_, Sqlite>,
conn: &mut PoolConnection<Sqlite>,
weekday: i64,
) -> Result<Vec<DbMacroAction>, DatabaseError> {
sqlx::query_as!(
@ -158,7 +158,7 @@ impl DbMacro {
self.id,
weekday
)
.fetch_all(tx.deref_mut())
.fetch_all(conn.deref_mut())
.await
.map_err(DatabaseError::from)
}

30
src/db/macro_action.rs
View file

@ -1,6 +1,6 @@
use std::ops::DerefMut;
use sqlx::Transaction;
use sqlx::pool::PoolConnection;
use sqlx::Sqlite;
use crate::db::{DbMacro, DbRelay, DbSchedule};
@ -17,16 +17,16 @@ pub struct DbMacroAction {
impl DbMacroAction {
pub async fn get_all(
tx: &mut Transaction<'_, Sqlite>,
conn: &mut PoolConnection<Sqlite>,
) -> Result<Vec<DbMacroAction>, DatabaseError> {
sqlx::query_as!(DbMacroAction, "SELECT * FROM macro_actions")
.fetch_all(tx.deref_mut())
.fetch_all(conn.deref_mut())
.await
.map_err(DatabaseError::from)
}
pub async fn get(
tx: &mut Transaction<'_, Sqlite>,
conn: &mut PoolConnection<Sqlite>,
id: i64,
) -> Result<Option<DbMacroAction>, DatabaseError> {
sqlx::query_as!(
@ -34,13 +34,13 @@ impl DbMacroAction {
"SELECT * FROM macro_actions WHERE id = ?",
id
)
.fetch_optional(tx.deref_mut())
.fetch_optional(conn.deref_mut())
.await
.map_err(DatabaseError::from)
}
pub async fn create(
tx: &mut Transaction<'_, Sqlite>,
conn: &mut PoolConnection<Sqlite>,
new_macro: &DbMacro,
new_relay: &DbRelay,
new_schedule: &DbSchedule,
@ -54,14 +54,14 @@ impl DbMacroAction {
new_schedule.id,
new_weekday
)
.fetch_optional(tx.deref_mut())
.fetch_optional(conn.deref_mut())
.await?
.ok_or(DatabaseError::InsertGetError)
}
pub async fn delete(&self, tx: &mut Transaction<'_, Sqlite>) -> Result<(), DatabaseError> {
pub async fn delete(&self, conn: &mut PoolConnection<Sqlite>) -> Result<(), DatabaseError> {
sqlx::query!("DELETE FROM macro_actions WHERE id = ?", self.id)
.execute(tx.deref_mut())
.execute(conn.deref_mut())
.await
.map(|res| match res.rows_affected() {
0 => Err(DatabaseError::DeleteError),
@ -71,27 +71,27 @@ impl DbMacroAction {
pub async fn get_relay(
&self,
tx: &mut Transaction<'_, Sqlite>,
conn: &mut PoolConnection<Sqlite>,
) -> Result<DbRelay, DatabaseError> {
DbRelay::get(tx, self.relay_id)
DbRelay::get(conn, self.relay_id)
.await?
.ok_or(DatabaseError::NotFound)
}
pub async fn get_schedule(
&self,
tx: &mut Transaction<'_, Sqlite>,
conn: &mut PoolConnection<Sqlite>,
) -> Result<DbSchedule, DatabaseError> {
DbSchedule::get(tx, self.schedule_id)
DbSchedule::get(conn, self.schedule_id)
.await?
.ok_or(DatabaseError::NotFound)
}
pub async fn get_macro(
&self,
tx: &mut Transaction<'_, Sqlite>,
conn: &mut PoolConnection<Sqlite>,
) -> Result<DbMacro, DatabaseError> {
DbMacro::get(tx, self.macro_id)
DbMacro::get(conn, self.macro_id)
.await?
.ok_or(DatabaseError::NotFound)
}

8
src/db/mod.rs
View file

@ -46,12 +46,10 @@ pub async fn init(db: &str) -> Result<Pool<Sqlite>, EmgauwaError> {
run_migrations(&pool).await?;
let mut tx = pool.begin().await?;
let mut pool_conn = pool.acquire().await?;
DbSchedule::get_on(&mut tx).await?;
DbSchedule::get_off(&mut tx).await?;
tx.commit().await?;
DbSchedule::get_on(&mut pool_conn).await?;
DbSchedule::get_off(&mut pool_conn).await?;
Ok(pool)
}

28
src/db/model_utils.rs
View file

@ -1,10 +1,10 @@
use chrono::{NaiveTime, Timelike};
use serde::{Deserialize, Serialize};
use sqlx::{Decode, Encode, Sqlite, Type};
use sqlx::database::HasArguments;
use sqlx::encode::IsNull;
use sqlx::error::BoxDynError;
use sqlx::sqlite::{SqliteTypeInfo, SqliteValueRef};
use sqlx::{Decode, Encode, Sqlite, Type};
use crate::db::DbPeriods;
@ -51,13 +51,33 @@ impl Period {
}
}
pub fn is_always_on(&self) -> bool {
self.start.eq(&self.end)
}
pub fn is_on(&self, now: &NaiveTime) -> bool {
self.start.eq(&self.end) || (self.start.le(now) && self.end.gt(now))
if self.is_always_on() {
return true;
}
let start_after_now = self.start.gt(now);
// add check for end time being 00:00 because end being 00:00 would cause end_after_now to always be false
// this will handle end like 24:00 and end_after_now will be true
let end_after_now = self.end.gt(now) || self.end.eq(&NaiveTime::MIN);
let start_before_end = self.start.lt(&self.end);
match (start_after_now, end_after_now, start_before_end) {
(false, false, true) => false, // both before now; start before end means "normal" period before now
(false, false, false) => true, // both before now; end before start means "inversed" period around now
(true, false, _) => false, // only start after now
(false, true, _) => true, // only end after now
(true, true, true) => false, // both after now but start first
(true, true, false) => true, // both after now but end first
}
}
pub fn get_next_time(&self, now: &NaiveTime) -> Option<NaiveTime> {
if self.start.eq(&self.end) {
// this period is always on
if self.is_always_on() {
return None;
}

62
src/db/relays.rs
View file

@ -1,7 +1,7 @@
use std::ops::DerefMut;
use serde_derive::{Deserialize, Serialize};
use sqlx::Transaction;
use sqlx::pool::PoolConnection;
use sqlx::Sqlite;
use crate::db::{DbController, DbJunctionRelaySchedule, DbJunctionTag, DbSchedule, DbTag};
@ -20,25 +20,25 @@ pub struct DbRelay {
}
impl DbRelay {
pub async fn get_all(tx: &mut Transaction<'_, Sqlite>) -> Result<Vec<DbRelay>, DatabaseError> {
pub async fn get_all(conn: &mut PoolConnection<Sqlite>) -> Result<Vec<DbRelay>, DatabaseError> {
sqlx::query_as!(DbRelay, "SELECT * FROM relays")
.fetch_all(tx.deref_mut())
.fetch_all(conn.deref_mut())
.await
.map_err(DatabaseError::from)
}
pub async fn get(
tx: &mut Transaction<'_, Sqlite>,
conn: &mut PoolConnection<Sqlite>,
id: i64,
) -> Result<Option<DbRelay>, DatabaseError> {
sqlx::query_as!(DbRelay, "SELECT * FROM relays WHERE id = ?", id)
.fetch_optional(tx.deref_mut())
.fetch_optional(conn.deref_mut())
.await
.map_err(DatabaseError::from)
}
pub async fn get_by_controller_and_num(
tx: &mut Transaction<'_, Sqlite>,
conn: &mut PoolConnection<Sqlite>,
controller: &DbController,
number: i64,
) -> Result<Option<DbRelay>, DatabaseError> {
@ -48,38 +48,38 @@ impl DbRelay {
controller.id,
number
)
.fetch_optional(tx.deref_mut())
.fetch_optional(conn.deref_mut())
.await
.map_err(DatabaseError::from)
}
pub async fn get_by_controller_and_num_or_create(
tx: &mut Transaction<'_, Sqlite>,
conn: &mut PoolConnection<Sqlite>,
controller: &DbController,
number: i64,
new_name: &str,
) -> Result<(DbRelay, bool), DatabaseError> {
match DbRelay::get_by_controller_and_num(tx, controller, number).await? {
match DbRelay::get_by_controller_and_num(conn, controller, number).await? {
Some(relay) => Ok((relay, false)),
None => {
let relay = DbRelay::create(tx, new_name, number, controller).await?;
let relay = DbRelay::create(conn, new_name, number, controller).await?;
Ok((relay, true))
}
}
}
pub async fn get_by_tag(
tx: &mut Transaction<'_, Sqlite>,
conn: &mut PoolConnection<Sqlite>,
tag: &DbTag,
) -> Result<Vec<DbRelay>, DatabaseError> {
sqlx::query_as!(DbRelay, "SELECT relay.* FROM relays AS relay INNER JOIN junction_tag ON junction_tag.relay_id = relay.id WHERE junction_tag.tag_id = ?", tag.id)
.fetch_all(tx.deref_mut())
.fetch_all(conn.deref_mut())
.await
.map_err(DatabaseError::from)
}
pub async fn create(
tx: &mut Transaction<'_, Sqlite>,
conn: &mut PoolConnection<Sqlite>,
new_name: &str,
new_number: i64,
new_controller: &DbController,
@ -91,14 +91,14 @@ impl DbRelay {
new_number,
new_controller.id,
)
.fetch_optional(tx.deref_mut())
.fetch_optional(conn.deref_mut())
.await?
.ok_or(DatabaseError::InsertGetError)
}
pub async fn delete(&self, tx: &mut Transaction<'_, Sqlite>) -> Result<(), DatabaseError> {
pub async fn delete(&self, conn: &mut PoolConnection<Sqlite>) -> Result<(), DatabaseError> {
sqlx::query!("DELETE FROM relays WHERE id = ?", self.id)
.execute(tx.deref_mut())
.execute(conn.deref_mut())
.await
.map(|res| match res.rows_affected() {
0 => Err(DatabaseError::DeleteError),
@ -108,68 +108,68 @@ impl DbRelay {
pub async fn update(
&self,
tx: &mut Transaction<'_, Sqlite>,
conn: &mut PoolConnection<Sqlite>,
new_name: &str,
) -> Result<DbRelay, DatabaseError> {
sqlx::query!("UPDATE relays SET name = ? WHERE id = ?", new_name, self.id,)
.execute(tx.deref_mut())
.execute(conn.deref_mut())
.await?;
DbRelay::get(tx, self.id)
DbRelay::get(conn, self.id)
.await?
.ok_or(DatabaseError::UpdateGetError)
}
pub async fn get_controller(
&self,
tx: &mut Transaction<'_, Sqlite>,
conn: &mut PoolConnection<Sqlite>,
) -> Result<DbController, DatabaseError> {
DbController::get(tx, self.controller_id)
DbController::get(conn, self.controller_id)
.await?
.ok_or(DatabaseError::NotFound)
}
pub async fn get_tags(
&self,
tx: &mut Transaction<'_, Sqlite>,
conn: &mut PoolConnection<Sqlite>,
) -> Result<Vec<String>, DatabaseError> {
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(tx.deref_mut())
.fetch_all(conn.deref_mut())
.await
.map_err(DatabaseError::from)
}
pub async fn set_tags(
&self,
tx: &mut Transaction<'_, Sqlite>,
conn: &mut PoolConnection<Sqlite>,
new_tags: &[String],
) -> Result<(), DatabaseError> {
sqlx::query!("DELETE FROM junction_tag WHERE relay_id = ?", self.id)
.execute(tx.deref_mut())
.execute(conn.deref_mut())
.await?;
for new_tag in new_tags {
let tag: DbTag = DbTag::get_by_tag_or_create(tx, new_tag).await?;
DbJunctionTag::link_relay(tx, &tag, self).await?;
let tag: DbTag = DbTag::get_by_tag_or_create(conn, new_tag).await?;
DbJunctionTag::link_relay(conn, &tag, self).await?;
}
Ok(())
}
pub async fn reload(
&self,
tx: &mut Transaction<'_, Sqlite>,
conn: &mut PoolConnection<Sqlite>,
) -> Result<DbRelay, DatabaseError> {
Self::get(tx, self.id)
Self::get(conn, self.id)
.await?
.ok_or(DatabaseError::NotFound)
}
pub async fn get_active_schedule(
&self,
tx: &mut Transaction<'_, Sqlite>,
conn: &mut PoolConnection<Sqlite>,
) -> Result<DbSchedule, DatabaseError> {
let weekday = utils::get_weekday();
DbJunctionRelaySchedule::get_schedule(tx, self, weekday as Weekday)
DbJunctionRelaySchedule::get_schedule(conn, self, weekday as Weekday)
.await?
.ok_or(DatabaseError::NotFound)
}

64
src/db/schedules.rs
View file

@ -3,7 +3,7 @@ use std::ops::DerefMut;
use chrono::NaiveTime;
use serde_derive::{Deserialize, Serialize};
use sqlx::Transaction;
use sqlx::pool::PoolConnection;
use sqlx::Sqlite;
use crate::db::model_utils::Period;
@ -26,26 +26,26 @@ pub struct DbPeriods(pub Vec<Period>);
impl DbSchedule {
pub async fn get_all(
tx: &mut Transaction<'_, Sqlite>,
conn: &mut PoolConnection<Sqlite>,
) -> Result<Vec<DbSchedule>, DatabaseError> {
sqlx::query_as!(DbSchedule, "SELECT * FROM schedules")
.fetch_all(tx.deref_mut())
.fetch_all(conn.deref_mut())
.await
.map_err(DatabaseError::from)
}
pub async fn get(
tx: &mut Transaction<'_, Sqlite>,
conn: &mut PoolConnection<Sqlite>,
id: i64,
) -> Result<Option<DbSchedule>, DatabaseError> {
sqlx::query_as!(DbSchedule, "SELECT * FROM schedules WHERE id = ?", id)
.fetch_optional(tx.deref_mut())
.fetch_optional(conn.deref_mut())
.await
.map_err(DatabaseError::from)
}
pub async fn get_by_uid(
tx: &mut Transaction<'_, Sqlite>,
conn: &mut PoolConnection<Sqlite>,
filter_uid: &ScheduleUid,
) -> Result<Option<DbSchedule>, DatabaseError> {
sqlx::query_as!(
@ -53,23 +53,23 @@ impl DbSchedule {
"SELECT * FROM schedules WHERE uid = ?",
filter_uid
)
.fetch_optional(tx.deref_mut())
.fetch_optional(conn.deref_mut())
.await
.map_err(DatabaseError::from)
}
pub async fn get_by_tag(
tx: &mut Transaction<'_, Sqlite>,
conn: &mut PoolConnection<Sqlite>,
tag: &DbTag,
) -> Result<Vec<DbSchedule>, DatabaseError> {
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(tx.deref_mut())
.fetch_all(conn.deref_mut())
.await
.map_err(DatabaseError::from)
}
pub async fn delete_by_uid(
tx: &mut Transaction<'_, Sqlite>,
conn: &mut PoolConnection<Sqlite>,
filter_uid: ScheduleUid,
) -> Result<(), DatabaseError> {
let filter_uid = match filter_uid {
@ -79,7 +79,7 @@ impl DbSchedule {
}?;
if sqlx::query_scalar!("SELECT 1 FROM schedules WHERE uid = ?", filter_uid)
.fetch_optional(tx.deref_mut())
.fetch_optional(conn.deref_mut())
.await?
.is_none()
{
@ -87,7 +87,7 @@ impl DbSchedule {
}
sqlx::query!("DELETE FROM schedules WHERE uid = ?", filter_uid)
.execute(tx.deref_mut())
.execute(conn.deref_mut())
.await
.map(|res| match res.rows_affected() {
0 => Err(DatabaseError::DeleteError),
@ -96,7 +96,7 @@ impl DbSchedule {
}
pub async fn create(
tx: &mut Transaction<'_, Sqlite>,
conn: &mut PoolConnection<Sqlite>,
new_uid: ScheduleUid,
new_name: &str,
new_periods: &DbPeriods,
@ -108,45 +108,45 @@ impl DbSchedule {
new_name,
new_periods,
)
.fetch_optional(tx.deref_mut())
.fetch_optional(conn.deref_mut())
.await?
.ok_or(DatabaseError::InsertGetError)
}
pub async fn get_by_uid_or_create(
tx: &mut Transaction<'_, Sqlite>,
conn: &mut PoolConnection<Sqlite>,
uid: ScheduleUid,
name: &str,
periods: &DbPeriods,
) -> Result<(DbSchedule, bool), DatabaseError> {
match DbSchedule::get_by_uid(tx, &uid).await? {
match DbSchedule::get_by_uid(conn, &uid).await? {
Some(schedule) => Ok((schedule, false)),
None => {
let schedule = DbSchedule::create(tx, uid, name, periods).await?;
let schedule = DbSchedule::create(conn, uid, name, periods).await?;
Ok((schedule, true))
}
}
}
pub async fn get_on(tx: &mut Transaction<'_, Sqlite>) -> Result<DbSchedule, DatabaseError> {
if let Some(schedule) = DbSchedule::get_by_uid(tx, &ScheduleUid::On).await? {
pub async fn get_on(conn: &mut PoolConnection<Sqlite>) -> Result<DbSchedule, DatabaseError> {
if let Some(schedule) = DbSchedule::get_by_uid(conn, &ScheduleUid::On).await? {
return Ok(schedule);
}
let periods = DbPeriods(vec![Period::new_on()]);
Self::create(tx, ScheduleUid::On, "On", &periods).await
Self::create(conn, ScheduleUid::On, "On", &periods).await
}
pub async fn get_off(tx: &mut Transaction<'_, Sqlite>) -> Result<DbSchedule, DatabaseError> {
if let Some(schedule) = DbSchedule::get_by_uid(tx, &ScheduleUid::Off).await? {
pub async fn get_off(conn: &mut PoolConnection<Sqlite>) -> Result<DbSchedule, DatabaseError> {
if let Some(schedule) = DbSchedule::get_by_uid(conn, &ScheduleUid::Off).await? {
return Ok(schedule);
}
let periods = DbPeriods(vec![]);
Self::create(tx, ScheduleUid::Off, "Off", &periods).await
Self::create(conn, ScheduleUid::Off, "Off", &periods).await
}
pub async fn update(
&self,
tx: &mut Transaction<'_, Sqlite>,
conn: &mut PoolConnection<Sqlite>,
new_name: &str,
new_periods: &DbPeriods,
) -> Result<DbSchedule, DatabaseError> {
@ -162,35 +162,35 @@ impl DbSchedule {
new_periods,
self.id,
)
.execute(tx.deref_mut())
.execute(conn.deref_mut())
.await?;
DbSchedule::get(tx, self.id)
DbSchedule::get(conn, self.id)
.await?
.ok_or(DatabaseError::UpdateGetError)
}
pub async fn get_tags(
&self,
tx: &mut Transaction<'_, Sqlite>,
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.schedule_id = ?", self.id)
.fetch_all(tx.deref_mut())
.fetch_all(conn.deref_mut())
.await?)
}
pub async fn set_tags(
&self,
tx: &mut Transaction<'_, Sqlite>,
conn: &mut PoolConnection<Sqlite>,
new_tags: &[String],
) -> Result<(), DatabaseError> {
sqlx::query!("DELETE FROM junction_tag WHERE schedule_id = ?", self.id)
.execute(tx.deref_mut())
.execute(conn.deref_mut())
.await?;
for new_tag in new_tags {
let tag: DbTag = DbTag::get_by_tag_or_create(tx, new_tag).await?;
DbJunctionTag::link_schedule(tx, &tag, self).await?;
let tag: DbTag = DbTag::get_by_tag_or_create(conn, new_tag).await?;
DbJunctionTag::link_schedule(conn, &tag, self).await?;
}
Ok(())
}

30
src/db/tag.rs
View file

@ -1,7 +1,7 @@
use std::ops::DerefMut;
use serde_derive::Serialize;
use sqlx::Transaction;
use sqlx::pool::PoolConnection;
use sqlx::Sqlite;
use crate::errors::DatabaseError;
@ -14,7 +14,7 @@ pub struct DbTag {
impl DbTag {
pub async fn create(
tx: &mut Transaction<'_, Sqlite>,
conn: &mut PoolConnection<Sqlite>,
new_tag: &str,
) -> Result<DbTag, DatabaseError> {
if new_tag.is_empty() {
@ -26,54 +26,54 @@ impl DbTag {
"INSERT INTO tags (tag) VALUES (?) RETURNING *",
new_tag
)
.fetch_optional(tx.deref_mut())
.fetch_optional(conn.deref_mut())
.await?
.ok_or(DatabaseError::InsertGetError)
}
pub async fn get_all(tx: &mut Transaction<'_, Sqlite>) -> Result<Vec<DbTag>, DatabaseError> {
pub async fn get_all(conn: &mut PoolConnection<Sqlite>) -> Result<Vec<DbTag>, DatabaseError> {
sqlx::query_as!(DbTag, "SELECT * FROM tags")
.fetch_all(tx.deref_mut())
.fetch_all(conn.deref_mut())
.await
.map_err(DatabaseError::from)
}
pub async fn get(
tx: &mut Transaction<'_, Sqlite>,
conn: &mut PoolConnection<Sqlite>,
id: i64,
) -> Result<Option<DbTag>, DatabaseError> {
sqlx::query_as!(DbTag, "SELECT * FROM tags WHERE id = ?", id)
.fetch_optional(tx.deref_mut())
.fetch_optional(conn.deref_mut())
.await
.map_err(DatabaseError::from)
}
pub async fn get_by_tag_or_create(
tx: &mut Transaction<'_, Sqlite>,
conn: &mut PoolConnection<Sqlite>,
target_tag: &str,
) -> Result<DbTag, DatabaseError> {
match DbTag::get_by_tag(tx, target_tag).await? {
match DbTag::get_by_tag(conn, target_tag).await? {
Some(tag) => Ok(tag),
None => DbTag::create(tx, target_tag).await,
None => DbTag::create(conn, target_tag).await,
}
}
pub async fn get_by_tag(
tx: &mut Transaction<'_, Sqlite>,
conn: &mut PoolConnection<Sqlite>,
target_tag: &str,
) -> Result<Option<DbTag>, DatabaseError> {
sqlx::query_as!(DbTag, "SELECT * FROM tags WHERE tag = ?", target_tag)
.fetch_optional(tx.deref_mut())
.fetch_optional(conn.deref_mut())
.await
.map_err(DatabaseError::from)
}
pub async fn delete_by_tag(
tx: &mut Transaction<'_, Sqlite>,
conn: &mut PoolConnection<Sqlite>,
filter_tag: &str,
) -> Result<(), DatabaseError> {
if sqlx::query_scalar!("SELECT 1 FROM tags WHERE tag = ?", filter_tag)
.fetch_optional(tx.deref_mut())
.fetch_optional(conn.deref_mut())
.await?
.is_none()
{
@ -81,7 +81,7 @@ impl DbTag {
}
sqlx::query!("DELETE FROM tags WHERE tag = ?", filter_tag)
.execute(tx.deref_mut())
.execute(conn.deref_mut())
.await
.map(|res| match res.rows_affected() {
0 => Err(DatabaseError::DeleteError),

18
src/models/controller.rs
View file

@ -4,7 +4,7 @@ use actix::MessageResponse;
use chrono::NaiveTime;
use futures::executor::block_on;
use serde_derive::{Deserialize, Serialize};
use sqlx::Transaction;
use sqlx::pool::PoolConnection;
use sqlx::Sqlite;
use crate::db::DbController;
@ -24,16 +24,16 @@ impl FromDbModel for Controller {
type DbModelCache = Vec<Relay>;
fn from_db_model(
tx: &mut Transaction<'_, Sqlite>,
conn: &mut PoolConnection<Sqlite>,
db_model: Self::DbModel,
) -> Result<Self, DatabaseError> {
let relays_db = block_on(db_model.get_relays(tx))?;
let cache = convert_db_list_cache(tx, relays_db, db_model.clone())?;
Self::from_db_model_cache(tx, db_model, cache)
let relays_db = block_on(db_model.get_relays(conn))?;
let cache = convert_db_list_cache(conn, relays_db, db_model.clone())?;
Self::from_db_model_cache(conn, db_model, cache)
}
fn from_db_model_cache(
_tx: &mut Transaction<'_, Sqlite>,
_conn: &mut PoolConnection<Sqlite>,
db_model: Self::DbModel,
cache: Self::DbModelCache,
) -> Result<Self, DatabaseError> {
@ -45,10 +45,10 @@ impl FromDbModel for Controller {
}
impl Controller {
pub fn reload(&mut self, tx: &mut Transaction<'_, Sqlite>) -> Result<(), EmgauwaError> {
self.c = block_on(self.c.reload(tx))?;
pub fn reload(&mut self, conn: &mut PoolConnection<Sqlite>) -> Result<(), EmgauwaError> {
self.c = block_on(self.c.reload(conn))?;
for relay in &mut self.relays {
relay.reload(tx)?;
relay.reload(conn)?;
}
Ok(())
}

12
src/models/macro.rs
View file

@ -1,6 +1,6 @@
use futures::executor::block_on;
use serde_derive::{Deserialize, Serialize};
use sqlx::Transaction;
use sqlx::pool::PoolConnection;
use sqlx::Sqlite;
use crate::db::DbMacro;
@ -19,19 +19,19 @@ impl FromDbModel for Macro {
type DbModelCache = ();
fn from_db_model(
tx: &mut Transaction<'_, Sqlite>,
conn: &mut PoolConnection<Sqlite>,
db_model: Self::DbModel,
) -> Result<Self, DatabaseError> {
Self::from_db_model_cache(tx, db_model, ())
Self::from_db_model_cache(conn, db_model, ())
}
fn from_db_model_cache(
tx: &mut Transaction<'_, Sqlite>,
conn: &mut PoolConnection<Sqlite>,
db_model: Self::DbModel,
_cache: Self::DbModelCache,
) -> Result<Self, DatabaseError> {
let actions_db = block_on(db_model.get_actions(tx))?;
let actions: Vec<MacroAction> = convert_db_list(tx, actions_db)?;
let actions_db = block_on(db_model.get_actions(conn))?;
let actions: Vec<MacroAction> = convert_db_list(conn, actions_db)?;
Ok(Macro {
m: db_model,

20
src/models/macro_action.rs
View file

@ -1,6 +1,6 @@
use futures::executor::block_on;
use serde_derive::{Deserialize, Serialize};
use sqlx::Transaction;
use sqlx::pool::PoolConnection;
use sqlx::Sqlite;
use crate::db::{DbJunctionRelaySchedule, DbMacroAction};
@ -19,22 +19,22 @@ impl FromDbModel for MacroAction {
type DbModelCache = ();
fn from_db_model(
tx: &mut Transaction<'_, Sqlite>,
conn: &mut PoolConnection<Sqlite>,
db_model: Self::DbModel,
) -> Result<Self, DatabaseError> {
Self::from_db_model_cache(tx, db_model, ())
Self::from_db_model_cache(conn, db_model, ())
}
fn from_db_model_cache(
tx: &mut Transaction<'_, Sqlite>,
conn: &mut PoolConnection<Sqlite>,
db_model: Self::DbModel,
_cache: Self::DbModelCache,
) -> Result<Self, DatabaseError> {
let schedule_db = block_on(db_model.get_schedule(tx))?;
let schedule = Schedule::from_db_model(tx, schedule_db)?;
let schedule_db = block_on(db_model.get_schedule(conn))?;
let schedule = Schedule::from_db_model(conn, schedule_db)?;
let relay_db = block_on(db_model.get_relay(tx))?;
let relay = Relay::from_db_model(tx, relay_db)?;
let relay_db = block_on(db_model.get_relay(conn))?;
let relay = Relay::from_db_model(conn, relay_db)?;
let weekday = db_model.weekday;
@ -47,8 +47,8 @@ impl FromDbModel for MacroAction {
}
impl MacroAction {
pub async fn execute(&self, tx: &mut Transaction<'_, Sqlite>) -> Result<(), EmgauwaError> {
DbJunctionRelaySchedule::set_schedule(tx, &self.relay.r, &self.schedule.s, self.weekday)
pub async fn execute(&self, conn: &mut PoolConnection<Sqlite>) -> Result<(), EmgauwaError> {
DbJunctionRelaySchedule::set_schedule(conn, &self.relay.r, &self.schedule.s, self.weekday)
.await?;
Ok(())
}

20
src/models/mod.rs
View file

@ -10,7 +10,7 @@ pub use macro_action::MacroAction;
pub use r#macro::Macro;
pub use relay::Relay;
pub use schedule::Schedule;
use sqlx::Transaction;
use sqlx::pool::PoolConnection;
use sqlx::Sqlite;
pub use tag::Tag;
@ -21,14 +21,14 @@ pub trait FromDbModel {
type DbModelCache: Clone;
fn from_db_model(
tx: &mut Transaction<'_, Sqlite>,
conn: &mut PoolConnection<Sqlite>,
db_model: Self::DbModel,
) -> Result<Self, DatabaseError>
where
Self: Sized;
fn from_db_model_cache(
tx: &mut Transaction<'_, Sqlite>,
conn: &mut PoolConnection<Sqlite>,
db_model: Self::DbModel,
cache: Self::DbModelCache,
) -> Result<Self, DatabaseError>
@ -37,15 +37,15 @@ pub trait FromDbModel {
}
fn convert_db_list_generic<T: FromDbModel>(
tx: &mut Transaction<'_, Sqlite>,
conn: &mut PoolConnection<Sqlite>,
db_models: Vec<T::DbModel>,
cache: Option<T::DbModelCache>,
) -> Result<Vec<T>, DatabaseError> {
let mut result: Vec<T> = Vec::new();
for db_model in db_models {
let new = match &cache {
Some(c) => T::from_db_model_cache(tx, db_model, c.clone()),
None => T::from_db_model(tx, db_model),
Some(c) => T::from_db_model_cache(conn, db_model, c.clone()),
None => T::from_db_model(conn, db_model),
}?;
result.push(new);
}
@ -53,16 +53,16 @@ fn convert_db_list_generic<T: FromDbModel>(
}
pub fn convert_db_list<T: FromDbModel>(
tx: &mut Transaction<'_, Sqlite>,
conn: &mut PoolConnection<Sqlite>,
db_models: Vec<T::DbModel>,
) -> Result<Vec<T>, DatabaseError> {
convert_db_list_generic(tx, db_models, None)
convert_db_list_generic(conn, db_models, None)
}
pub fn convert_db_list_cache<T: FromDbModel>(
tx: &mut Transaction<'_, Sqlite>,
conn: &mut PoolConnection<Sqlite>,
db_models: Vec<T::DbModel>,
cache: T::DbModelCache,
) -> Result<Vec<T>, DatabaseError> {
convert_db_list_generic(tx, db_models, Some(cache))
convert_db_list_generic(conn, db_models, Some(cache))
}

28
src/models/relay.rs
View file

@ -3,7 +3,7 @@ use std::time::Instant;
use chrono::NaiveTime;
use futures::executor::block_on;
use serde_derive::{Deserialize, Serialize};
use sqlx::Transaction;
use sqlx::pool::PoolConnection;
use sqlx::Sqlite;
use crate::db::{DbController, DbJunctionRelaySchedule, DbRelay, DbSchedule};
@ -32,23 +32,23 @@ impl FromDbModel for Relay {
type DbModelCache = DbController;
fn from_db_model(
tx: &mut Transaction<'_, Sqlite>,
conn: &mut PoolConnection<Sqlite>,
db_model: Self::DbModel,
) -> Result<Self, DatabaseError> {
let cache = block_on(db_model.get_controller(tx))?;
Self::from_db_model_cache(tx, db_model, cache)
let cache = block_on(db_model.get_controller(conn))?;
Self::from_db_model_cache(conn, db_model, cache)
}
fn from_db_model_cache(
tx: &mut Transaction<'_, Sqlite>,
conn: &mut PoolConnection<Sqlite>,
db_model: Self::DbModel,
cache: Self::DbModelCache,
) -> Result<Self, DatabaseError> {
let tags = block_on(db_model.get_tags(tx))?;
let tags = block_on(db_model.get_tags(conn))?;
let controller_id = cache.uid.clone();
let schedules = block_on(DbJunctionRelaySchedule::get_schedules(tx, &db_model))?;
let active_schedule = block_on(db_model.get_active_schedule(tx))?;
let schedules = block_on(DbJunctionRelaySchedule::get_schedules(conn, &db_model))?;
let active_schedule = block_on(db_model.get_active_schedule(conn))?;
let is_on = None;
@ -66,19 +66,19 @@ impl FromDbModel for Relay {
}
impl Relay {
pub fn reload(&mut self, tx: &mut Transaction<'_, Sqlite>) -> Result<(), DatabaseError> {
self.r = block_on(self.r.reload(tx))?;
self.schedules = block_on(DbJunctionRelaySchedule::get_schedules(tx, &self.r))?;
self.reload_active_schedule(tx)?;
pub fn reload(&mut self, conn: &mut PoolConnection<Sqlite>) -> Result<(), DatabaseError> {
self.r = block_on(self.r.reload(conn))?;
self.schedules = block_on(DbJunctionRelaySchedule::get_schedules(conn, &self.r))?;
self.reload_active_schedule(conn)?;
Ok(())
}
pub fn reload_active_schedule(
&mut self,
tx: &mut Transaction<'_, Sqlite>,
conn: &mut PoolConnection<Sqlite>,
) -> Result<(), DatabaseError> {
self.active_schedule = block_on(self.r.get_active_schedule(tx))?;
self.active_schedule = block_on(self.r.get_active_schedule(conn))?;
Ok(())
}

10
src/models/schedule.rs
View file

@ -1,6 +1,6 @@
use futures::executor::block_on;
use serde_derive::{Deserialize, Serialize};
use sqlx::Transaction;
use sqlx::pool::PoolConnection;
use sqlx::Sqlite;
use crate::db::DbSchedule;
@ -19,15 +19,15 @@ impl FromDbModel for Schedule {
type DbModelCache = Vec<String>;
fn from_db_model(
tx: &mut Transaction<'_, Sqlite>,
conn: &mut PoolConnection<Sqlite>,
db_model: Self::DbModel,
) -> Result<Self, DatabaseError> {
let cache = block_on(db_model.get_tags(tx))?;
Self::from_db_model_cache(tx, db_model, cache)
let cache = block_on(db_model.get_tags(conn))?;
Self::from_db_model_cache(conn, db_model, cache)
}
fn from_db_model_cache(
_tx: &mut Transaction<'_, Sqlite>,
_conn: &mut PoolConnection<Sqlite>,
db_model: Self::DbModel,
cache: Self::DbModelCache,
) -> Result<Self, DatabaseError> {

16
src/models/tag.rs
View file

@ -1,7 +1,7 @@
use actix::MessageResponse;
use futures::executor::block_on;
use serde_derive::{Deserialize, Serialize};
use sqlx::Transaction;
use sqlx::pool::PoolConnection;
use sqlx::Sqlite;
use crate::db::{DbRelay, DbSchedule, DbTag};
@ -20,21 +20,21 @@ impl FromDbModel for Tag {
type DbModelCache = (Vec<Relay>, Vec<Schedule>);
fn from_db_model(
tx: &mut Transaction<'_, Sqlite>,
conn: &mut PoolConnection<Sqlite>,
db_model: Self::DbModel,
) -> Result<Self, DatabaseError> {
let db_schedules = block_on(DbSchedule::get_by_tag(tx, &db_model))?;
let schedules: Vec<Schedule> = convert_db_list(tx, db_schedules)?;
let db_schedules = block_on(DbSchedule::get_by_tag(conn, &db_model))?;
let schedules: Vec<Schedule> = convert_db_list(conn, db_schedules)?;
let db_relays = block_on(DbRelay::get_by_tag(tx, &db_model))?;
let relays: Vec<Relay> = convert_db_list(tx, db_relays)?;
let db_relays = block_on(DbRelay::get_by_tag(conn, &db_model))?;
let relays: Vec<Relay> = convert_db_list(conn, db_relays)?;
let cache = (relays, schedules);
Self::from_db_model_cache(tx, db_model, cache)
Self::from_db_model_cache(conn, db_model, cache)
}
fn from_db_model_cache(
_tx: &mut Transaction<'_, Sqlite>,
_conn: &mut PoolConnection<Sqlite>,
db_model: Self::DbModel,
cache: Self::DbModelCache,
) -> Result<Self, DatabaseError> {

6
src/types/request.rs
View file

@ -1,5 +1,5 @@
use serde_derive::{Deserialize, Serialize};
use sqlx::Transaction;
use sqlx::pool::PoolConnection;
use sqlx::Sqlite;
use crate::db::{DbPeriods, DbSchedule};
@ -86,9 +86,9 @@ pub struct RequestMacroExecute {
impl RequestScheduleId {
pub async fn get_schedule(
&self,
tx: &mut Transaction<'_, Sqlite>,
conn: &mut PoolConnection<Sqlite>,
) -> Result<DbSchedule, DatabaseError> {
DbSchedule::get_by_uid(tx, &self.id)
DbSchedule::get_by_uid(conn, &self.id)
.await?
.ok_or(DatabaseError::NotFound)
}