From 9b093e6739b35db6a599d8e84bf590bf93f9abc8 Mon Sep 17 00:00:00 2001
From: quirinecker <quirin.ecker@bajupa.com>
Date: Mon, 19 Jan 2026 11:29:37 +0100
Subject: [PATCH] Rest endpoint is now a little bit more fleshed out

---
 Cargo.lock           |  1 +
 Cargo.toml           |  2 +-
 src/handler/alarm.rs | 29 ++++++++++++++++++++++-------
 src/main.rs          |  6 +-----
 src/scheduler.rs     | 16 ++++++++++------
 src/types.rs         | 14 ++++++++++++++
 6 files changed, 49 insertions(+), 19 deletions(-)
 create mode 100644 src/types.rs

diff --git a/Cargo.lock b/Cargo.lock
index 591ed11..9953e16 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -130,6 +130,7 @@ dependencies = [
  "iana-time-zone",
  "js-sys",
  "num-traits",
+ "serde",
  "wasm-bindgen",
  "windows-link",
 ]
diff --git a/Cargo.toml b/Cargo.toml
index 706d3bc..52f2dd1 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -6,7 +6,7 @@ edition = "2024"
 [dependencies]
 gpio-cdev = "0.6.0"
 cron_tab = { version = "0.2", features = ["async"] }
-chrono = "0.4.42"
+chrono = { version = "0.4.42", features = ["serde"] }
 axum = { version = "0.8.8", features = ["macros"] }
 tokio = { version = "1.49.0", features = ["full"] }
 serde = { version = "1.0.228", features = ["derive"] }
diff --git a/src/handler/alarm.rs b/src/handler/alarm.rs
index 82c3f22..7066f8f 100644
--- a/src/handler/alarm.rs
+++ b/src/handler/alarm.rs
@@ -1,20 +1,35 @@
-use axum::{Json, extract::State};
+use axum::{Json, extract::State, http::StatusCode};
+use chrono::{DateTime, Local};
 use serde::{Deserialize, Serialize};
 
 use crate::{AppState};
+use crate::types::Alarm;
 
 #[derive(Deserialize, Serialize)]
 pub struct CreateAlarmRequest {
-	hour: String,
-	minute: String,
+	time: DateTime<Local>
+}
+
+#[derive(Deserialize, Serialize)]
+pub struct CreateAlarmResponse {
+	alarm: Alarm
+
+}
+
+#[derive(Deserialize, Serialize)]
+pub struct  AlarmError {
+	message: String
 }
 
 #[axum::debug_handler]
-pub async fn create_alarm(State(state): State<AppState>, Json(alarm): Json<CreateAlarmRequest>) -> String {
-	let result = state.scheduler.add_alarm(alarm.hour.as_str(), alarm.minute.as_str());
+pub async fn create_alarm(
+	State(state): State<AppState>,
+	Json(create_request): Json<CreateAlarmRequest>
+) -> Result<(StatusCode, Json<CreateAlarmResponse>), (StatusCode, Json<AlarmError>)> {
+	let result = state.scheduler.add_alarm(create_request.time);
 
 	match result {
-		Ok(_) => "Alarm created".to_string(),
-		Err(e) => e.to_string(),
+		Ok(alarm) => Ok((StatusCode::CREATED, Json(CreateAlarmResponse { alarm }))),
+		Err(e) => Err((StatusCode::INTERNAL_SERVER_ERROR, Json(AlarmError { message: e }))),
 	}
 }
diff --git a/src/main.rs b/src/main.rs
index f13919c..cbf2773 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -2,7 +2,6 @@ use std::{
     sync::{Arc, Mutex},
 };
 
-use chrono::{DateTime, Local};
 use cron_tab::Cron;
 use gpio_cdev::Chip;
 
@@ -12,11 +11,8 @@ mod handler;
 mod router;
 mod scheduler;
 mod ringer;
+mod types;
 
-struct Alarm {
-	enabled: bool,
-	time: DateTime<Local>
-}
 
 #[derive(Clone)]
 struct AppState {
diff --git a/src/scheduler.rs b/src/scheduler.rs
index 7e62cc4..bfff21e 100644
--- a/src/scheduler.rs
+++ b/src/scheduler.rs
@@ -1,15 +1,17 @@
 use std::sync::{Arc, Mutex};
 
-use chrono::Local;
+use chrono::{DateTime, Local, Timelike};
 use cron_tab::Cron;
 
 use crate::ringer::Ringer;
+use crate::types::Alarm;
+
 
 #[derive(Debug)]
 pub struct Scheduler<T: Ringer + 'static> {
     ringer: Arc<Mutex<T>>,
     cron: Arc<Mutex<Cron<Local>>>,
-    alarms: Arc<Mutex<Vec<String>>>,
+    alarms: Arc<Mutex<Vec<Alarm>>>,
 }
 
 impl<T: Ringer> Scheduler<T> {
@@ -39,13 +41,15 @@ impl<T: Ringer> Scheduler<T> {
         todo!()
     }
 
-    pub fn add_alarm(&self, hour: &str, minute: &str) -> Result<(), String> {
+    pub fn add_alarm(&self, time: DateTime<Local>) -> Result<Alarm, String> {
         let mut alarms = self.alarms.lock().map_err(|e| e.to_string())?;
-        let cron_schedule = format!("{} {} {} * * *", "*", minute, hour);
-        alarms.push(cron_schedule.clone());
+        let cron_schedule = format!("{} {} {} * * *", "*", time.minute(), time.hour());
+		let alarm = Alarm::new(true, time);
+        alarms.push(alarm.clone());
+		self.schedule(&cron_schedule).map_err(|e| e.to_string())?;
         println!("Added alarm {}", cron_schedule);
 
-        Ok(())
+        Ok(alarm)
     }
 
     pub fn start(&self) {
diff --git a/src/types.rs b/src/types.rs
new file mode 100644
index 0000000..a6dacea
--- /dev/null
+++ b/src/types.rs
@@ -0,0 +1,14 @@
+use chrono::{DateTime, Local};
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Serialize, Deserialize, Clone)]
+pub struct Alarm {
+    enabled: bool,
+    time: DateTime<Local>,
+}
+
+impl Alarm {
+    pub fn new(enabled: bool, time: DateTime<Local>) -> Self {
+        Self { enabled, time }
+    }
+}