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

use actix_web::{delete, get, post, put, web, HttpResponse};
use serde::{Deserialize, Serialize};
use sqlx::pool::PoolConnection;
use sqlx::{Pool, Sqlite};

use crate::db::errors::DatabaseError;
use crate::db::{Periods, Schedule};
use crate::db::Tag;
use crate::db::types::ScheduleUid;
use crate::handlers::errors::ApiError;
use crate::return_models::ReturnSchedule;

#[derive(Debug, Serialize, Deserialize)]
pub struct RequestSchedule {
	name: String,
	periods: Periods,
	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 schedules = Schedule::get_all(&mut pool_conn).await?;

	let return_schedules: Vec<ReturnSchedule> =
		schedules.into_iter().map(|s| ReturnSchedule::from_schedule(s, &mut pool_conn)).collect();

	Ok(HttpResponse::Ok().json(return_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 = Tag::get_by_tag(&mut pool_conn, &tag).await?;

	let schedules = Schedule::get_by_tag(&mut pool_conn, &tag_db).await?;

	let return_schedules: Vec<ReturnSchedule> =
		schedules.into_iter().map(|s| ReturnSchedule::from_schedule(s, &mut pool_conn)).collect();

	Ok(HttpResponse::Ok().json(return_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 = Schedule::get_by_uid(&mut pool_conn, &uid).await?;

	let return_schedule = ReturnSchedule::from_schedule(schedule, &mut pool_conn);
	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 = Schedule::create(&mut pool_conn, &data.name, &data.periods).await?;

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

	let return_schedule = ReturnSchedule::from_schedule(new_schedule, &mut pool_conn);
	Ok(HttpResponse::Created().json(return_schedule))
}

async fn add_list_single(
	conn: &mut PoolConnection<Sqlite>,
	request_schedule: &RequestSchedule,
) -> Result<Schedule, DatabaseError> {
	let new_schedule =
		Schedule::create(conn, &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 result: Vec<Result<Schedule, DatabaseError>> = data
		.as_slice()
		.iter()
		.map(|request_schedule| {
			futures::executor::block_on(add_list_single(&mut pool_conn, request_schedule))
		})
		.collect();

	let mut return_schedules: Vec<ReturnSchedule> = Vec::new();
	for schedule in result {
		match schedule {
			Ok(schedule) => return_schedules.push(ReturnSchedule::from_schedule(schedule, &mut pool_conn)),
			Err(e) => return Ok(HttpResponse::from(e)),
		}
	}
	Ok(HttpResponse::Created().json(return_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 = Schedule::get_by_uid(&mut pool_conn, &uid).await?;

	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 = ReturnSchedule::from_schedule(schedule, &mut pool_conn);
	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(_) => {
			Schedule::delete_by_uid(&mut pool_conn, uid).await?;
			Ok(HttpResponse::Ok().json("schedule got deleted"))
		}
	}
}