Add macros

emgauwa-lib/src/db/macro.rs

@@ -0,0 +1,166 @@
+use std::ops::DerefMut;
+
+use serde_derive::{Deserialize, Serialize};
+use sqlx::pool::PoolConnection;
+use sqlx::Sqlite;
+
+use crate::db::{DbController, DbMacroAction, DbRelay, DbSchedule};
+use crate::errors::DatabaseError;
+use crate::types::{EmgauwaUid, RequestMacroAction};
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct DbMacro {
+	#[serde(skip)]
+	pub id: i64,
+	#[serde(rename = "id")]
+	pub uid: EmgauwaUid,
+	pub name: String,
+}
+
+
+impl DbMacro {
+	pub async fn get_all(conn: &mut PoolConnection<Sqlite>) -> Result<Vec<DbMacro>, DatabaseError> {
+		sqlx::query_as!(DbMacro, "SELECT * FROM macros")
+			.fetch_all(conn.deref_mut())
+			.await
+			.map_err(DatabaseError::from)
+	}
+
+	pub async fn get(
+		conn: &mut PoolConnection<Sqlite>,
+		id: i64,
+	) -> Result<Option<DbMacro>, DatabaseError> {
+		sqlx::query_as!(DbMacro, "SELECT * FROM macros WHERE id = ?", id)
+			.fetch_optional(conn.deref_mut())
+			.await
+			.map_err(DatabaseError::from)
+	}
+
+	pub async fn get_by_uid(
+		conn: &mut PoolConnection<Sqlite>,
+		filter_uid: &EmgauwaUid,
+	) -> Result<Option<DbMacro>, DatabaseError> {
+		sqlx::query_as!(DbMacro, "SELECT * FROM macros WHERE uid = ?", filter_uid)
+			.fetch_optional(conn.deref_mut())
+			.await
+			.map_err(DatabaseError::from)
+	}
+
+	pub async fn create(
+		conn: &mut PoolConnection<Sqlite>,
+		new_uid: EmgauwaUid,
+		new_name: &str,
+	) -> Result<DbMacro, DatabaseError> {
+		sqlx::query_as!(
+			DbMacro,
+			"INSERT INTO macros (uid, name) VALUES (?, ?) RETURNING *",
+			new_uid,
+			new_name
+		)
+		.fetch_optional(conn.deref_mut())
+		.await?
+		.ok_or(DatabaseError::InsertGetError)
+	}
+
+	pub async fn delete(&self, conn: &mut PoolConnection<Sqlite>) -> Result<(), DatabaseError> {
+		sqlx::query!("DELETE FROM macros WHERE id = ?", self.id)
+			.execute(conn.deref_mut())
+			.await
+			.map(|res| match res.rows_affected() {
+				0 => Err(DatabaseError::DeleteError),
+				_ => Ok(()),
+			})?
+	}
+
+	pub async fn delete_by_uid(
+		conn: &mut PoolConnection<Sqlite>,
+		filter_uid: EmgauwaUid,
+	) -> Result<(), DatabaseError> {
+		if sqlx::query_scalar!("SELECT 1 FROM macros WHERE uid = ?", filter_uid)
+			.fetch_optional(conn.deref_mut())
+			.await?
+			.is_none()
+		{
+			return Err(DatabaseError::NotFound);
+		}
+
+		sqlx::query!("DELETE FROM macros WHERE uid = ?", filter_uid)
+			.execute(conn.deref_mut())
+			.await
+			.map(|res| match res.rows_affected() {
+				0 => Err(DatabaseError::DeleteError),
+				_ => Ok(()),
+			})?
+	}
+
+	pub async fn update(
+		&self,
+		conn: &mut PoolConnection<Sqlite>,
+		new_name: &str,
+	) -> Result<DbMacro, DatabaseError> {
+		sqlx::query!("UPDATE relays SET name = ? WHERE id = ?", new_name, self.id,)
+			.execute(conn.deref_mut())
+			.await?;
+
+		DbMacro::get(conn, self.id)
+			.await?
+			.ok_or(DatabaseError::UpdateGetError)
+	}
+
+	pub async fn set_actions(
+		&self,
+		conn: &mut PoolConnection<Sqlite>,
+		new_actions: &[RequestMacroAction],
+	) -> Result<(), DatabaseError> {
+		sqlx::query!("DELETE FROM macro_actions WHERE macro_id = ?", self.id)
+			.execute(conn.deref_mut())
+			.await?;
+
+		for new_action in new_actions {
+			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(conn, &controller, new_action.relay.number)
+					.await?
+					.ok_or(DatabaseError::NotFound)?;
+
+			let schedule = DbSchedule::get_by_uid(conn, &new_action.schedule.id)
+				.await?
+				.ok_or(DatabaseError::NotFound)?;
+
+			DbMacroAction::create(conn, self, &relay, &schedule, new_action.weekday).await?;
+		}
+		Ok(())
+	}
+
+	pub async fn get_actions(
+		&self,
+		conn: &mut PoolConnection<Sqlite>,
+	) -> Result<Vec<DbMacroAction>, DatabaseError> {
+		sqlx::query_as!(
+			DbMacroAction,
+			"SELECT * FROM macro_actions WHERE macro_id = ?",
+			self.id
+		)
+		.fetch_all(conn.deref_mut())
+		.await
+		.map_err(DatabaseError::from)
+	}
+
+	pub async fn get_actions_weekday(
+		&self,
+		conn: &mut PoolConnection<Sqlite>,
+		weekday: i64,
+	) -> Result<Vec<DbMacroAction>, DatabaseError> {
+		sqlx::query_as!(
+			DbMacroAction,
+			"SELECT * FROM macro_actions WHERE macro_id = ? AND weekday = ?",
+			self.id,
+			weekday
+		)
+		.fetch_all(conn.deref_mut())
+		.await
+		.map_err(DatabaseError::from)
+	}
+}

emgauwa-lib/src/db/macro_action.rs

@@ -0,0 +1,99 @@
+use std::ops::DerefMut;
+
+use sqlx::pool::PoolConnection;
+use sqlx::Sqlite;
+
+use crate::db::{DbMacro, DbRelay, DbSchedule};
+use crate::errors::DatabaseError;
+
+#[derive(Debug, Clone)]
+pub struct DbMacroAction {
+	pub id: i64,
+	pub macro_id: i64,
+	pub relay_id: i64,
+	pub schedule_id: i64,
+	pub weekday: i64, // should be u8, but sqlite will store it as i64
+}
+
+
+impl DbMacroAction {
+	pub async fn get_all(
+		conn: &mut PoolConnection<Sqlite>,
+	) -> Result<Vec<DbMacroAction>, DatabaseError> {
+		sqlx::query_as!(DbMacroAction, "SELECT * FROM macro_actions")
+			.fetch_all(conn.deref_mut())
+			.await
+			.map_err(DatabaseError::from)
+	}
+
+	pub async fn get(
+		conn: &mut PoolConnection<Sqlite>,
+		id: i64,
+	) -> Result<Option<DbMacroAction>, DatabaseError> {
+		sqlx::query_as!(
+			DbMacroAction,
+			"SELECT * FROM macro_actions WHERE id = ?",
+			id
+		)
+		.fetch_optional(conn.deref_mut())
+		.await
+		.map_err(DatabaseError::from)
+	}
+
+	pub async fn create(
+		conn: &mut PoolConnection<Sqlite>,
+		new_macro: &DbMacro,
+		new_relay: &DbRelay,
+		new_schedule: &DbSchedule,
+		new_weekday: i64,
+	) -> Result<DbMacroAction, DatabaseError> {
+		sqlx::query_as!(
+			DbMacroAction,
+			"INSERT INTO macro_actions (macro_id, relay_id, schedule_id, weekday) VALUES (?, ?, ?, ?) RETURNING *",
+			new_macro.id,
+			new_relay.id,
+			new_schedule.id,
+			new_weekday
+		)
+		.fetch_optional(conn.deref_mut())
+		.await?
+		.ok_or(DatabaseError::InsertGetError)
+	}
+
+	pub async fn delete(&self, conn: &mut PoolConnection<Sqlite>) -> Result<(), DatabaseError> {
+		sqlx::query!("DELETE FROM macro_actions WHERE id = ?", self.id)
+			.execute(conn.deref_mut())
+			.await
+			.map(|res| match res.rows_affected() {
+				0 => Err(DatabaseError::DeleteError),
+				_ => Ok(()),
+			})?
+	}
+
+	pub async fn get_relay(
+		&self,
+		conn: &mut PoolConnection<Sqlite>,
+	) -> Result<DbRelay, DatabaseError> {
+		DbRelay::get(conn, self.relay_id)
+			.await?
+			.ok_or(DatabaseError::NotFound)
+	}
+
+	pub async fn get_schedule(
+		&self,
+		conn: &mut PoolConnection<Sqlite>,
+	) -> Result<DbSchedule, DatabaseError> {
+		DbSchedule::get(conn, self.schedule_id)
+			.await?
+			.ok_or(DatabaseError::NotFound)
+	}
+
+	pub async fn get_macro(
+		&self,
+		conn: &mut PoolConnection<Sqlite>,
+	) -> Result<DbMacro, DatabaseError> {
+		DbMacro::get(conn, self.macro_id)
+			.await?
+			.ok_or(DatabaseError::NotFound)
+	}
+}

emgauwa-lib/src/db/mod.rs

@@ -7,6 +7,8 @@ use sqlx::{ConnectOptions, Pool, Sqlite};
 mod controllers;
 mod junction_relay_schedule;
 mod junction_tag;
+mod r#macro;
+mod macro_action;
 mod model_utils;
 mod relays;
 mod schedules;
@@ -15,6 +17,8 @@ mod tag;
 pub use controllers::DbController;
 pub use junction_relay_schedule::DbJunctionRelaySchedule;
 pub use junction_tag::DbJunctionTag;
+pub use macro_action::DbMacroAction;
+pub use r#macro::DbMacro;
 pub use relays::DbRelay;
 pub use schedules::{DbPeriods, DbSchedule};
 pub use tag::DbTag;

emgauwa-lib/src/models/macro.rs

@@ -0,0 +1,42 @@
+use futures::executor::block_on;
+use serde_derive::{Deserialize, Serialize};
+use sqlx::pool::PoolConnection;
+use sqlx::Sqlite;
+
+use crate::db::DbMacro;
+use crate::errors::DatabaseError;
+use crate::models::{convert_db_list, FromDbModel, MacroAction};
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct Macro {
+	#[serde(flatten)]
+	pub m: DbMacro,
+	pub actions: Vec<MacroAction>,
+}
+
+
+impl FromDbModel for Macro {
+	type DbModel = DbMacro;
+	type DbModelCache = ();
+
+	fn from_db_model(
+		conn: &mut PoolConnection<Sqlite>,
+		db_model: Self::DbModel,
+	) -> Result<Self, DatabaseError> {
+		Self::from_db_model_cache(conn, db_model, ())
+	}
+
+	fn from_db_model_cache(
+		conn: &mut PoolConnection<Sqlite>,
+		db_model: Self::DbModel,
+		_cache: Self::DbModelCache,
+	) -> Result<Self, DatabaseError> {
+		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,
+			actions,
+		})
+	}
+}

emgauwa-lib/src/models/macro_action.rs

@@ -0,0 +1,56 @@
+use futures::executor::block_on;
+use serde_derive::{Deserialize, Serialize};
+use sqlx::pool::PoolConnection;
+use sqlx::Sqlite;
+
+use crate::db::{DbJunctionRelaySchedule, DbMacroAction};
+use crate::errors::{DatabaseError, EmgauwaError};
+use crate::models::{FromDbModel, Relay, Schedule};
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct MacroAction {
+	pub schedule: Schedule,
+	pub relay: Relay,
+	pub weekday: i64,
+}
+
+
+impl FromDbModel for MacroAction {
+	type DbModel = DbMacroAction;
+	type DbModelCache = ();
+
+	fn from_db_model(
+		conn: &mut PoolConnection<Sqlite>,
+		db_model: Self::DbModel,
+	) -> Result<Self, DatabaseError> {
+		Self::from_db_model_cache(conn, db_model, ())
+	}
+
+	fn from_db_model_cache(
+		conn: &mut PoolConnection<Sqlite>,
+		db_model: Self::DbModel,
+		_cache: Self::DbModelCache,
+	) -> Result<Self, DatabaseError> {
+		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(conn))?;
+		let relay = Relay::from_db_model(conn, relay_db)?;
+
+		let weekday = db_model.weekday;
+
+		Ok(MacroAction {
+			schedule,
+			relay,
+			weekday,
+		})
+	}
+}
+
+impl MacroAction {
+	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(())
+	}
+}

emgauwa-lib/src/models/mod.rs

@@ -1,9 +1,13 @@
 mod controller;
+mod r#macro;
+mod macro_action;
 mod relay;
 mod schedule;
 mod tag;
 
 pub use controller::Controller;
+pub use macro_action::MacroAction;
+pub use r#macro::Macro;
 pub use relay::Relay;
 pub use schedule::Schedule;
 use sqlx::pool::PoolConnection;

emgauwa-lib/src/types/request.rs

@@ -4,7 +4,7 @@ use sqlx::Sqlite;
 
 use crate::db::{DbPeriods, DbSchedule};
 use crate::errors::DatabaseError;
-use crate::types::ScheduleUid;
+use crate::types::{EmgauwaUid, ScheduleUid};
 
 #[derive(Debug, Serialize, Deserialize)]
 pub struct RequestScheduleCreate {
@@ -48,6 +48,41 @@ pub struct RequestTagCreate {
 	pub tag: String,
 }
 
+#[derive(Debug, Serialize, Deserialize)]
+pub struct RequestMacroActionRelay {
+	pub number: i64,
+	pub controller_id: EmgauwaUid,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct RequestMacroActionSchedule {
+	pub id: ScheduleUid,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct RequestMacroAction {
+	pub weekday: i64,
+	pub relay: RequestMacroActionRelay,
+	pub schedule: RequestMacroActionSchedule,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct RequestMacroCreate {
+	pub name: String,
+	pub actions: Vec<RequestMacroAction>,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct RequestMacroUpdate {
+	pub name: Option<String>,
+	pub actions: Option<Vec<RequestMacroAction>>,
+}
+
+#[derive(Debug, Deserialize)]
+pub struct RequestMacroExecute {
+	pub weekday: Option<i64>,
+}
+
 impl RequestScheduleId {
 	pub async fn get_schedule(
 		&self,