Can check if relay is online or not

central_backend/src/energy/energy_actor.rs

@@ -389,7 +389,7 @@ impl Handler<SynchronizeDevice> for EnergyActor {
 pub struct ResDevState {
     pub id: DeviceId,
     last_ping: u64,
-    online: bool,
+    pub online: bool,
 }
 
 /// Get the state of devices

central_backend/src/server/unsecure_server/unsecure_relay_controller.rs

@@ -64,6 +64,8 @@ pub async fn legacy_state(
 pub struct FullRelayState {
     /// Indicates if the relay (or its parent device) is enabled or not
     enabled: bool,
+    /// Indicate if the device is online or not
+    online: bool,
     /// Indicates if relay is on or off
     is_on: bool,
     /// Relay name
@@ -96,6 +98,8 @@ pub async fn relays_full_state(energy_actor: WebEnergyActor) -> HttpResult {
     let cached_consumption = energy_actor.send(energy_actor::GetCurrConsumption).await?;
     let relays_consumption = energy_actor.send(energy_actor::RelaysConsumption).await?;
     let curr_consumption = consumption::get_curr_consumption().await.ok();
+    let devices = energy_actor.send(energy_actor::GetDeviceLists).await?;
+    let devices_state = energy_actor.send(energy_actor::GetDevicesState).await?;
     let mut relays = energy_actor.send(energy_actor::GetRelaysList).await?;
     relays.sort_by_key(|r| -(r.priority as i64));
     let relays_state = energy_actor.send(energy_actor::GetAllRelaysState).await?;
@@ -107,16 +111,24 @@ pub async fn relays_full_state(energy_actor: WebEnergyActor) -> HttpResult {
         relays: relays
             .into_iter()
             .map(|r| {
-                let state = relays_state.iter().find(|s| s.id == r.id);
+                let device = devices
+                    .iter()
+                    .find(|d| d.relays.iter().any(|sr| sr.id == r.id))
+                    .expect("All relay shall have an associated device!");
+                let device_state = devices_state.iter().find(|s| s.id == device.id);
+                let relay_state = relays_state.iter().find(|s| s.id == r.id);
                 FullRelayState {
-                    enabled: r.enabled,
-                    is_on: state.map(|s| s.on).unwrap_or(false),
+                    enabled: r.enabled && device.enabled,
+                    online: device_state.map(|d| d.online).unwrap_or(false),
+                    is_on: relay_state.map(|s| s.on).unwrap_or(false),
                     name: r.name,
                     priority: r.priority,
-                    r#for: state.map(|s| s.r#for).unwrap_or(0),
+                    r#for: relay_state.map(|s| s.r#for).unwrap_or(0),
                     total_uptime: 0,
                     daily_requirement: r.daily_runtime.map(|r| r.min_runtime),
-                    relay_forced_state: state.map(|s| s.forced_state.clone()).unwrap_or_default(),
+                    relay_forced_state: relay_state
+                        .map(|s| s.forced_state.clone())
+                        .unwrap_or_default(),
                 }
             })
             .collect(),