core/emgauwa-lib/src/db/relays.rs

use std::ops::DerefMut;

use serde_derive::{Deserialize, Serialize};
use sqlx::pool::PoolConnection;
use sqlx::Sqlite;

use crate::db::{DbController, DbJunctionRelaySchedule, DbJunctionTag, DbSchedule, DbTag};
use crate::errors::DatabaseError;
use crate::types::Weekday;
use crate::utils;

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DbRelay {
	#[serde(skip)]
	pub id: i64,
	pub name: String,
	pub number: i64,
	#[serde(skip)]
	pub controller_id: i64,
}


impl DbRelay {
	pub async fn get_all(conn: &mut PoolConnection<Sqlite>) -> Result<Vec<DbRelay>, DatabaseError> {
		sqlx::query_as!(DbRelay, "SELECT * FROM relays")
			.fetch_all(conn.deref_mut())
			.await
			.map_err(DatabaseError::from)
	}

	pub async fn get(
		conn: &mut PoolConnection<Sqlite>,
		id: i64,
	) -> Result<Option<DbRelay>, DatabaseError> {
		sqlx::query_as!(DbRelay, "SELECT * FROM relays WHERE id = ?", id)
			.fetch_optional(conn.deref_mut())
			.await
			.map_err(DatabaseError::from)
	}

	pub async fn get_by_controller_and_num(
		conn: &mut PoolConnection<Sqlite>,
		controller: &DbController,
		number: i64,
	) -> Result<Option<DbRelay>, DatabaseError> {
		sqlx::query_as!(
			DbRelay,
			"SELECT * FROM relays WHERE controller_id = ? AND number = ?",
			controller.id,
			number
		)
		.fetch_optional(conn.deref_mut())
		.await
		.map_err(DatabaseError::from)
	}

	pub async fn get_by_controller_and_num_or_create(
		conn: &mut PoolConnection<Sqlite>,
		controller: &DbController,
		number: i64,
		new_name: &str,
	) -> Result<(DbRelay, bool), DatabaseError> {
		match DbRelay::get_by_controller_and_num(conn, controller, number).await? {
			Some(relay) => Ok((relay, false)),
			None => {
				let relay = DbRelay::create(conn, new_name, number, controller).await?;
				Ok((relay, true))
			}
		}
	}

	pub async fn get_by_tag(
		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(conn.deref_mut())
			.await
			.map_err(DatabaseError::from)
	}

	pub async fn create(
		conn: &mut PoolConnection<Sqlite>,
		new_name: &str,
		new_number: i64,
		new_controller: &DbController,
	) -> Result<DbRelay, DatabaseError> {
		sqlx::query_as!(
			DbRelay,
			"INSERT INTO relays (name, number, controller_id) VALUES (?, ?, ?) RETURNING *",
			new_name,
			new_number,
			new_controller.id,
		)
		.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 relays WHERE id = ?", self.id)
			.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<DbRelay, DatabaseError> {
		sqlx::query!("UPDATE relays SET name = ? WHERE id = ?", new_name, self.id,)
			.execute(conn.deref_mut())
			.await?;

		DbRelay::get(conn, self.id)
			.await?
			.ok_or(DatabaseError::UpdateGetError)
	}

	pub async fn get_controller(
		&self,
		conn: &mut PoolConnection<Sqlite>,
	) -> Result<DbController, DatabaseError> {
		DbController::get(conn, self.controller_id)
			.await?
			.ok_or(DatabaseError::NotFound)
	}

	pub async fn get_tags(
		&self,
		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(conn.deref_mut())
			.await
			.map_err(DatabaseError::from)
	}

	pub async fn set_tags(
		&self,
		conn: &mut PoolConnection<Sqlite>,
		new_tags: &[String],
	) -> Result<(), DatabaseError> {
		sqlx::query!("DELETE FROM junction_tag WHERE relay_id = ?", self.id)
			.execute(conn.deref_mut())
			.await?;

		for new_tag in new_tags {
			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,
		conn: &mut PoolConnection<Sqlite>,
	) -> Result<DbRelay, DatabaseError> {
		Self::get(conn, self.id)
			.await?
			.ok_or(DatabaseError::NotFound)
	}

	pub async fn get_active_schedule(
		&self,
		conn: &mut PoolConnection<Sqlite>,
	) -> Result<DbSchedule, DatabaseError> {
		let weekday = utils::get_weekday();
		DbJunctionRelaySchedule::get_schedule(conn, self, weekday as Weekday)
			.await?
			.ok_or(DatabaseError::NotFound)
	}
}