common/emgauwa-core/src/handlers/v1/schedules.rs

use actix_web::{delete, get, post, put, web, HttpResponse};
use emgauwa_lib::db::errors::DatabaseError;
use emgauwa_lib::db::{DbPeriods, DbSchedule, DbTag};
use emgauwa_lib::models::{convert_db_list, FromDbModel, Schedule};
use emgauwa_lib::types::ScheduleUid;
use serde::{Deserialize, Serialize};
use sqlx::pool::PoolConnection;
use sqlx::{Pool, Sqlite};

use crate::handlers::errors::ApiError;

#[derive(Debug, Serialize, Deserialize)]
pub struct RequestSchedule {
	name: String,
	periods: DbPeriods,
	#[serde(default)] // empty tags are allowed
	tags: Vec<String>,
}

#[get("/api/v1/schedules")]
pub async fn index(pool: web::Data<Pool<Sqlite>>) -> Result<HttpResponse, ApiError> {
	let mut pool_conn = pool.acquire().await?;

	let db_schedules = DbSchedule::get_all(&mut pool_conn).await?;
	let schedules: Vec<Schedule> = convert_db_list(&mut pool_conn, db_schedules)?;

	Ok(HttpResponse::Ok().json(schedules))
}

#[get("/api/v1/schedules/tag/{tag}")]
pub async fn tagged(
	pool: web::Data<Pool<Sqlite>>,
	path: web::Path<(String,)>,
) -> Result<HttpResponse, ApiError> {
	let mut pool_conn = pool.acquire().await?;

	let (tag,) = path.into_inner();
	let tag_db = DbTag::get_by_tag(&mut pool_conn, &tag)
		.await?
		.ok_or(DatabaseError::NotFound)?;

	let db_schedules = DbSchedule::get_by_tag(&mut pool_conn, &tag_db).await?;
	let schedules: Vec<Schedule> = convert_db_list(&mut pool_conn, db_schedules)?;

	Ok(HttpResponse::Ok().json(schedules))
}

#[get("/api/v1/schedules/{schedule_id}")]
pub async fn show(
	pool: web::Data<Pool<Sqlite>>,
	path: web::Path<(String,)>,
) -> Result<HttpResponse, ApiError> {
	let mut pool_conn = pool.acquire().await?;

	let (schedule_uid,) = path.into_inner();
	let uid = ScheduleUid::try_from(schedule_uid.as_str()).or(Err(ApiError::BadUid))?;

	let schedule = DbSchedule::get_by_uid(&mut pool_conn, &uid)
		.await?
		.ok_or(DatabaseError::NotFound)?;

	let return_schedule = Schedule::from_db_model(&mut pool_conn, schedule)?;
	Ok(HttpResponse::Ok().json(return_schedule))
}

#[post("/api/v1/schedules")]
pub async fn add(
	pool: web::Data<Pool<Sqlite>>,
	data: web::Json<RequestSchedule>,
) -> Result<HttpResponse, ApiError> {
	let mut pool_conn = pool.acquire().await?;

	let new_schedule = DbSchedule::create(
		&mut pool_conn,
		ScheduleUid::default(),
		&data.name,
		&data.periods,
	)
	.await?;

	new_schedule
		.set_tags(&mut pool_conn, data.tags.as_slice())
		.await?;

	let return_schedule = Schedule::from_db_model(&mut pool_conn, new_schedule)?;
	Ok(HttpResponse::Created().json(return_schedule))
}

async fn add_list_single(
	conn: &mut PoolConnection<Sqlite>,
	request_schedule: &RequestSchedule,
) -> Result<DbSchedule, DatabaseError> {
	let new_schedule = DbSchedule::create(
		conn,
		ScheduleUid::default(),
		&request_schedule.name,
		&request_schedule.periods,
	)
	.await?;

	new_schedule
		.set_tags(conn, request_schedule.tags.as_slice())
		.await?;

	Ok(new_schedule)
}

#[post("/api/v1/schedules/list")]
pub async fn add_list(
	pool: web::Data<Pool<Sqlite>>,
	data: web::Json<Vec<RequestSchedule>>,
) -> Result<HttpResponse, ApiError> {
	let mut pool_conn = pool.acquire().await?;

	let mut db_schedules: Vec<DbSchedule> = Vec::new();
	for s in data.iter() {
		let new_s = futures::executor::block_on(add_list_single(&mut pool_conn, s))?;
		db_schedules.push(new_s);
	}

	let schedules: Vec<Schedule> = convert_db_list(&mut pool_conn, db_schedules)?;
	Ok(HttpResponse::Created().json(schedules))
}

#[put("/api/v1/schedules/{schedule_id}")]
pub async fn update(
	pool: web::Data<Pool<Sqlite>>,
	path: web::Path<(String,)>,
	data: web::Json<RequestSchedule>,
) -> Result<HttpResponse, ApiError> {
	let mut pool_conn = pool.acquire().await?;

	let (schedule_uid,) = path.into_inner();
	let uid = ScheduleUid::try_from(schedule_uid.as_str()).or(Err(ApiError::BadUid))?;

	let schedule = DbSchedule::get_by_uid(&mut pool_conn, &uid)
		.await?
		.ok_or(DatabaseError::NotFound)?;

	let schedule = schedule
		.update(&mut pool_conn, data.name.as_str(), &data.periods)
		.await?;

	schedule
		.set_tags(&mut pool_conn, data.tags.as_slice())
		.await?;

	let return_schedule = Schedule::from_db_model(&mut pool_conn, schedule)?;
	Ok(HttpResponse::Ok().json(return_schedule))
}

#[delete("/api/v1/schedules/{schedule_id}")]
pub async fn delete(
	pool: web::Data<Pool<Sqlite>>,
	path: web::Path<(String,)>,
) -> Result<HttpResponse, ApiError> {
	let mut pool_conn = pool.acquire().await?;

	let (schedule_uid,) = path.into_inner();
	let uid = ScheduleUid::try_from(schedule_uid.as_str()).or(Err(ApiError::BadUid))?;

	match uid {
		ScheduleUid::Off => Err(ApiError::ProtectedSchedule),
		ScheduleUid::On => Err(ApiError::ProtectedSchedule),
		ScheduleUid::Any(_) => {
			DbSchedule::delete_by_uid(&mut pool_conn, uid).await?;
			Ok(HttpResponse::Ok().json("schedule got deleted"))
		}
	}
}