Can set forced state to relays

central_backend/src/server/servers.rs

@@ -231,6 +231,10 @@ pub async fn secure_server(energy_actor: EnergyActorAddr) -> anyhow::Result<()>
                 "/web_api/relay/{id}",
                 web::put().to(relays_controller::update),
             )
+            .route(
+                "/web_api/relay/{id}/forced_state",
+                web::put().to(relays_controller::set_forced_state),
+            )
             .route(
                 "/web_api/relay/{id}",
                 web::delete().to(relays_controller::delete),

central_backend/src/server/web_api/relays_controller.rs

@@ -1,7 +1,9 @@
 use crate::devices::device::{DeviceId, DeviceRelay, DeviceRelayID};
 use crate::energy::energy_actor;
+use crate::energy::engine::RelayForcedState;
 use crate::server::WebEnergyActor;
 use crate::server::custom_error::HttpResult;
+use crate::utils::time_utils::time_secs;
 use actix_web::{HttpResponse, web};
 
 /// Get the full list of relays
@@ -85,6 +87,50 @@ pub async fn update(
     Ok(HttpResponse::Accepted().finish())
 }
 
+#[derive(Default, Debug, Clone, Eq, PartialEq, serde::Serialize, serde::Deserialize)]
+#[serde(tag = "type")]
+pub enum SetRelayForcedStateReq {
+    #[default]
+    None,
+    Off {
+        for_secs: u64,
+    },
+    On {
+        for_secs: u64,
+    },
+}
+
+/// Set relay forced status
+pub async fn set_forced_state(
+    actor: WebEnergyActor,
+    req: web::Json<SetRelayForcedStateReq>,
+    path: web::Path<RelayIDInPath>,
+) -> HttpResult {
+    // Check if relay exists first
+    let list = actor.send(energy_actor::GetAllRelaysState).await?;
+    if !list.into_iter().any(|r| r.id == path.id) {
+        return Ok(HttpResponse::NotFound().json("Relay not found!"));
+    };
+
+    // Update relay forced state
+    actor
+        .send(energy_actor::SetRelayForcedState(
+            path.id,
+            match &req.0 {
+                SetRelayForcedStateReq::None => RelayForcedState::None,
+                SetRelayForcedStateReq::Off { for_secs } => RelayForcedState::Off {
+                    until: time_secs() + for_secs,
+                },
+                SetRelayForcedStateReq::On { for_secs } => RelayForcedState::On {
+                    until: time_secs() + for_secs,
+                },
+            },
+        ))
+        .await??;
+
+    Ok(HttpResponse::Accepted().finish())
+}
+
 /// Delete an existing relay
 pub async fn delete(actor: WebEnergyActor, path: web::Path<RelayIDInPath>) -> HttpResult {
     actor