Bump to version 1.0.3

.drone.yml

@@ -46,6 +46,11 @@ steps:
         path: /usr/local/cargo/registry
       - name: web_app
         path: /tmp/web_build
+      - name: releases
+        path: /tmp/releases
+    when:
+      event:
+        - tag
     depends_on:
       - backend_check
       - web_build
@@ -54,13 +59,41 @@ steps:
       - mv /tmp/web_build/dist static
       - cargo build --release
       - ls -lah target/release/central_backend
+      - mv target/release/central_backend /tmp/releases/central_backend
 
+  # Build ESP32 program
   - name: esp32_compile
     image: espressif/idf:v5.5.1
+    volumes:
+      - name: releases
+        path: /tmp/releases
     commands:
       - cd esp32_device
       - /opt/esp/entrypoint.sh idf.py build
       - ls -lah build/main.bin
+      - cp build/main.bin /tmp/releases/wt32-eth01.bin
+
+  # Auto-release to Gitea
+  - name: gitea_release
+    image: plugins/gitea-release
+    depends_on:
+    - backend_compile
+    - esp32_compile
+    when:
+      event:
+        - tag
+    volumes:
+      - name: releases
+        path: /tmp/releases
+    environment:
+      PLUGIN_API_KEY:
+        from_secret: GITEA_API_KEY # needs permission write:repository
+    settings:
+      base_url: https://gitea.communiquons.org
+      files:
+        - /tmp/releases/central_backend
+        - /tmp/releases/wt32-eth01.bin
+      checksum: sha512
 
 
 volumes:
@@ -68,3 +101,5 @@ volumes:
     temp: {}
   - name: web_app
     temp: {}
+  - name: releases
+    temp: {}

central_backend/Cargo.lock

@@ -640,7 +640,7 @@ dependencies = [
 
 [[package]]
 name = "central_backend"
-version = "1.0.2"
+version = "1.0.3"
 dependencies = [
  "actix",
  "actix-cors",

central_backend/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "central_backend"
-version = "1.0.2"
+version = "1.0.3"
 edition = "2024"
 
 [dependencies]

central_backend/engine_test/test_turn_forced_off.yaml

@@ -0,0 +1,33 @@
+devices:
+  - id: dev1
+    info:
+      reference: A
+      version: 0.0.1
+      max_relays: 1
+    time_create: 1
+    time_update: 1
+    name: Dev1
+    description: Day1
+    validated: true
+    enabled: true
+    relays:
+      - id: dcb3fd91-bf9b-4de3-99e5-92c1c7dd72e9
+        name: R1
+        enabled: true
+        priority: 1
+        consumption: 100
+        minimal_uptime: 10
+        minimal_downtime: 10
+        depends_on: []
+        conflicts_with: []
+
+        on: false
+        for: 5000
+        forced_state:
+          type: Off
+          for_secs: 500
+        should_be_on: false
+
+    online: true
+
+curr_consumption: -10000

central_backend/engine_test/test_turn_forced_on.yaml

@@ -0,0 +1,49 @@
+devices:
+  - id: dev1
+    info:
+      reference: A
+      version: 0.0.1
+      max_relays: 1
+    time_create: 1
+    time_update: 1
+    name: Dev1
+    description: Day1
+    validated: true
+    enabled: true
+    relays:
+      - id: dcb3fd91-bf9b-4de3-99e5-92c1c7dd72e9
+        name: R1
+        enabled: true
+        priority: 1
+        consumption: 100
+        minimal_uptime: 10
+        minimal_downtime: 10
+        depends_on: []
+        conflicts_with: []
+
+        on: false
+        for: 500
+        forced_state:
+          type: On
+          for_secs: 500
+        should_be_on: true
+
+      - id: dcb3fd91-bf9b-4de3-99e5-92c1c7dd72f0
+        name: R2
+        enabled: true
+        priority: 1
+        consumption: 100
+        minimal_uptime: 10
+        minimal_downtime: 10
+        depends_on: [ ]
+        conflicts_with: [ ]
+
+        on: false
+        for: 500
+        forced_state:
+          type: None
+        should_be_on: false
+
+    online: true
+
+curr_consumption: 10000

central_backend/src/energy/energy_actor.rs

@@ -8,7 +8,7 @@ use crate::energy::consumption;
 use crate::energy::consumption::EnergyConsumption;
 use crate::energy::consumption_cache::ConsumptionCache;
 use crate::energy::consumption_history_file::ConsumptionHistoryFile;
-use crate::energy::engine::EnergyEngine;
+use crate::energy::engine::{EnergyEngine, RelayForcedState};
 use crate::utils::time_utils::time_secs;
 use actix::prelude::*;
 use openssl::x509::X509Req;
@@ -328,6 +328,19 @@ impl Handler<UpdateDeviceRelay> for EnergyActor {
     }
 }
 
+#[derive(Message)]
+#[rtype(result = "anyhow::Result<()>")]
+pub struct SetRelayForcedState(pub DeviceRelayID, pub RelayForcedState);
+
+impl Handler<SetRelayForcedState> for EnergyActor {
+    type Result = anyhow::Result<()>;
+
+    fn handle(&mut self, msg: SetRelayForcedState, _ctx: &mut Context<Self>) -> Self::Result {
+        self.engine.relay_state(msg.0).set_forced(msg.1);
+        Ok(())
+    }
+}
+
 /// Delete a device relay
 #[derive(Message)]
 #[rtype(result = "anyhow::Result<()>")]
@@ -408,6 +421,7 @@ pub struct ResRelayState {
     pub id: DeviceRelayID,
     pub on: bool,
     pub r#for: usize,
+    pub forced_state: RelayForcedState,
 }
 
 /// Get the state of all relays
@@ -427,6 +441,7 @@ impl Handler<GetAllRelaysState> for EnergyActor {
                 id: d.id,
                 on: state.is_on(),
                 r#for: state.state_for(),
+                forced_state: state.actual_forced_state(),
             })
         }
 

central_backend/src/energy/engine.rs

@@ -25,19 +25,83 @@ impl DeviceState {
     }
 }
 
+#[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,
+    },
+}
+
+impl SetRelayForcedStateReq {
+    pub fn to_forced_state(&self) -> RelayForcedState {
+        match &self {
+            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,
+            },
+        }
+    }
+}
+
+#[derive(Default, Debug, Clone, Eq, PartialEq, serde::Serialize, serde::Deserialize)]
+#[serde(tag = "type")]
+pub enum RelayForcedState {
+    #[default]
+    None,
+    Off {
+        until: u64,
+    },
+    On {
+        until: u64,
+    },
+}
+
 #[derive(Default, Clone)]
 pub struct RelayState {
     on: bool,
     since: usize,
+    forced_state: RelayForcedState,
 }
 
 impl RelayState {
+    /// Get actual forced state (returns None if state is expired)
+    pub fn actual_forced_state(&self) -> RelayForcedState {
+        match self.forced_state {
+            RelayForcedState::Off { until } if until > time_secs() => {
+                RelayForcedState::Off { until }
+            }
+            RelayForcedState::On { until } if until > time_secs() => RelayForcedState::On { until },
+            _ => RelayForcedState::None,
+        }
+    }
+
     pub fn is_on(&self) -> bool {
-        self.on
+        let forced_state = self.actual_forced_state();
+        (self.on || matches!(forced_state, RelayForcedState::On { .. }))
+            && !matches!(forced_state, RelayForcedState::Off { .. })
     }
 
     fn is_off(&self) -> bool {
-        !self.on
+        !self.is_on()
+    }
+
+    /// Check if relay state is enforced
+    pub fn is_forced(&self) -> bool {
+        self.actual_forced_state() != RelayForcedState::None
+    }
+
+    pub fn set_forced(&mut self, s: RelayForcedState) {
+        self.since = time_secs() as usize;
+        self.forced_state = s;
     }
 
     pub fn state_for(&self) -> usize {
@@ -146,7 +210,11 @@ impl EnergyEngine {
                     r.name,
                     r.consumption,
                     format!("{} / {}", r.minimal_downtime, r.minimal_uptime),
-                    status.is_on().to_string(),
+                    status.is_on().to_string()
+                        + match status.is_forced() {
+                            true => " (Forced)",
+                            false => "",
+                        },
                     status.since,
                     match dev_online {
                         true => "Online",
@@ -192,19 +260,28 @@ impl EnergyEngine {
 
         let mut new_relays_state = self.relays_state.clone();
 
-        // Forcefully turn off relays that belongs to offline devices
+        // Forcefully turn off disabled relays
         for d in devices {
-            if !self.device_state(&d.id).is_online() {
             for r in &d.relays {
+                if !r.enabled || !d.enabled {
                     new_relays_state.get_mut(&r.id).unwrap().on = false;
                 }
             }
         }
 
-        // Forcefully turn off disabled relays
+        // Apply forced relays state
         for d in devices {
             for r in &d.relays {
-                if !r.enabled || !d.enabled {
+                if self.relay_state(r.id).is_forced() {
+                    new_relays_state.get_mut(&r.id).unwrap().on = self.relay_state(r.id).is_on();
+                }
+            }
+        }
+
+        // Forcefully turn off relays that belongs to offline devices
+        for d in devices {
+            if !self.device_state(&d.id).is_online() {
+                for r in &d.relays {
                     new_relays_state.get_mut(&r.id).unwrap().on = false;
                 }
             }
@@ -216,7 +293,9 @@ impl EnergyEngine {
 
             for d in devices {
                 for r in &d.relays {
-                    if new_relays_state.get(&r.id).unwrap().is_off() {
+                    if new_relays_state.get(&r.id).unwrap().is_off()
+                        || new_relays_state.get(&r.id).unwrap().is_forced()
+                    {
                         continue;
                     }
 
@@ -240,7 +319,7 @@ impl EnergyEngine {
             for d in devices {
                 for r in &d.relays {
                     let state = new_relays_state.get(&r.id).unwrap();
-                    if state.is_off() {
+                    if state.is_off() || state.is_forced() {
                         continue;
                     }
 
@@ -271,7 +350,9 @@ impl EnergyEngine {
                     continue;
                 }
 
-                if new_relays_state.get(&r.id).unwrap().is_on() {
+                if new_relays_state.get(&r.id).unwrap().is_on()
+                    || new_relays_state.get(&r.id).unwrap().is_forced()
+                {
                     continue;
                 }
 
@@ -298,7 +379,7 @@ impl EnergyEngine {
             }
         }
 
-        // Order relays
+        // Order relays to select the ones with the most elevated priorities
         let mut ordered_relays = devices
             .iter()
             .filter(|d| self.device_state(&d.id).is_online() && d.enabled)
@@ -308,10 +389,13 @@ impl EnergyEngine {
         ordered_relays.sort_by_key(|r| r.priority);
         ordered_relays.reverse();
 
+        // Select relays to start, starting with those with highest priorities
         loop {
             let mut changed = false;
             for relay in &ordered_relays {
-                if new_relays_state.get(&relay.id).unwrap().is_on() {
+                if new_relays_state.get(&relay.id).unwrap().is_on()
+                    || new_relays_state.get(&relay.id).unwrap().is_forced()
+                {
                     continue;
                 }
 
@@ -383,7 +467,7 @@ impl EnergyEngine {
 mod test {
     use crate::devices::device::{Device, DeviceId, DeviceRelayID};
     use crate::energy::consumption::EnergyConsumption;
-    use crate::energy::engine::EnergyEngine;
+    use crate::energy::engine::{EnergyEngine, SetRelayForcedStateReq};
     use crate::utils::time_utils::time_secs;
     use rust_embed::Embed;
 
@@ -392,6 +476,8 @@ mod test {
         id: DeviceRelayID,
         on: bool,
         r#for: usize,
+        #[serde(default)]
+        forced_state: SetRelayForcedStateReq,
         should_be_on: bool,
     }
 
@@ -439,6 +525,7 @@ mod test {
                 let s = engine.relay_state(r.id);
                 s.on = r.on;
                 s.since = time_secs() as usize - r.r#for;
+                s.forced_state = r.forced_state.to_forced_state()
             }
         }
 

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,5 +1,6 @@
 use crate::devices::device::{DeviceId, DeviceRelay, DeviceRelayID};
 use crate::energy::energy_actor;
+use crate::energy::engine::SetRelayForcedStateReq;
 use crate::server::WebEnergyActor;
 use crate::server::custom_error::HttpResult;
 use actix_web::{HttpResponse, web};
@@ -85,6 +86,29 @@ pub async fn update(
     Ok(HttpResponse::Accepted().finish())
 }
 
+/// 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,
+            req.to_forced_state(),
+        ))
+        .await??;
+
+    Ok(HttpResponse::Accepted().finish())
+}
+
 /// Delete an existing relay
 pub async fn delete(actor: WebEnergyActor, path: web::Path<RelayIDInPath>) -> HttpResult {
     actor

central_frontend/src/api/RelayApi.ts

@@ -1,10 +1,19 @@
 import { APIClient } from "./ApiClient";
 import { Device, DeviceRelay } from "./DeviceApi";
 
+export type RelayForcedState =
+  | { type: "None" }
+  | { type: "Off" | "On"; until: number };
+
+export type SetRelayForcedState =
+  | { type: "None" }
+  | { type: "Off" | "On"; for_secs: number };
+
 export interface RelayStatus {
   id: string;
   on: boolean;
   for: number;
+  forced_state: RelayForcedState;
 }
 
 export type RelaysStatus = Map<string, RelayStatus>;
@@ -48,6 +57,20 @@ export class RelayApi {
     });
   }
 
+  /**
+   * Set relay forced state
+   */
+  static async SetForcedState(
+    relay: DeviceRelay,
+    forced: SetRelayForcedState
+  ): Promise<void> {
+    await APIClient.exec({
+      method: "PUT",
+      uri: `/relay/${relay.id}/forced_state`,
+      jsonData: forced,
+    });
+  }
+
   /**
    * Delete a relay configuration
    */

central_frontend/src/dialogs/SelectForcedStateDurationDialog.tsx

@@ -0,0 +1,53 @@
+import {
+  Button,
+  Dialog,
+  DialogActions,
+  DialogContent,
+  DialogContentText,
+  DialogTitle,
+  TextField,
+} from "@mui/material";
+import { DeviceRelay } from "../api/DeviceApi";
+import React from "react";
+
+export function SelectForcedStateDurationDialog(p: {
+  relay: DeviceRelay;
+  forcedState: string;
+  onCancel: () => void;
+  onSubmit: (duration: number) => void;
+}): React.ReactElement {
+  const [duration, setDuration] = React.useState(60);
+
+  return (
+    <Dialog open onClose={p.onCancel}>
+      <DialogTitle>Set forced relay state</DialogTitle>
+      <DialogContent>
+        <DialogContentText>
+          Please specify the number of minutes the relay <i>{p.relay.name}</i>{" "}
+          will remain in forced state <i>{p.forcedState}</i>:
+        </DialogContentText>
+
+        <TextField
+          label="Duration (min)"
+          variant="standard"
+          value={Math.floor(duration / 60)}
+          onChange={(e) => {
+            const val = Number.parseInt(e.target.value);
+            setDuration((Number.isNaN(val) ? 1 : val) * 60);
+          }}
+          fullWidth
+          style={{ marginTop: "5px" }}
+        />
+
+        <p>Equivalent in seconds: {duration} secs</p>
+        <p>Equivalent in hours: {duration / 3600} hours</p>
+      </DialogContent>
+      <DialogActions>
+        <Button onClick={p.onCancel}>Cancel</Button>
+        <Button onClick={() => p.onSubmit(duration)} autoFocus>
+          Start timer
+        </Button>
+      </DialogActions>
+    </Dialog>
+  );
+}

central_frontend/src/routes/DeviceRoute/DeviceRelays.tsx

@@ -10,16 +10,16 @@ import {
 } from "@mui/material";
 import React from "react";
 import { Device, DeviceRelay } from "../../api/DeviceApi";
+import { RelayApi, RelayStatus } from "../../api/RelayApi";
 import { EditDeviceRelaysDialog } from "../../dialogs/EditDeviceRelaysDialog";
-import { DeviceRouteCard } from "./DeviceRouteCard";
+import { useAlert } from "../../hooks/context_providers/AlertDialogProvider";
 import { useConfirm } from "../../hooks/context_providers/ConfirmDialogProvider";
 import { useLoadingMessage } from "../../hooks/context_providers/LoadingMessageProvider";
-import { RelayApi, RelayStatus } from "../../api/RelayApi";
 import { useSnackbar } from "../../hooks/context_providers/SnackbarProvider";
-import { useAlert } from "../../hooks/context_providers/AlertDialogProvider";
 import { AsyncWidget } from "../../widgets/AsyncWidget";
-import { TimeWidget } from "../../widgets/TimeWidget";
 import { BoolText } from "../../widgets/BoolText";
+import { TimeWidget } from "../../widgets/TimeWidget";
+import { DeviceRouteCard } from "./DeviceRouteCard";
 
 export function DeviceRelays(p: {
   device: Device;
@@ -145,7 +145,8 @@ function RelayEntryStatus(
       errMsg="Failed to load relay status!"
       build={() => (
         <>
-          <BoolText val={state!.on} positive="ON" negative="OFF" /> for{" "}
+          <BoolText val={state!.on} positive="ON" negative="OFF" />{" "}
+          {state?.forced_state.type !== "None" && <b>Forced</b>} for{" "}
           <TimeWidget diff time={state!.for} />
         </>
       )}

central_frontend/src/routes/RelaysListRoute.tsx

@@ -16,12 +16,13 @@ import React from "react";
 import { useNavigate } from "react-router-dom";
 import { Device, DeviceApi, DeviceRelay, DeviceURL } from "../api/DeviceApi";
 import { RelayApi, RelaysStatus } from "../api/RelayApi";
+import { ServerApi } from "../api/ServerApi";
 import { AsyncWidget } from "../widgets/AsyncWidget";
 import { BoolText } from "../widgets/BoolText";
+import { CopyToClipboard } from "../widgets/CopyToClipboard";
+import { RelayForcedState } from "../widgets/RelayForcedState";
 import { SolarEnergyRouteContainer } from "../widgets/SolarEnergyRouteContainer";
 import { TimeWidget } from "../widgets/TimeWidget";
-import { CopyToClipboard } from "../widgets/CopyToClipboard";
-import { ServerApi } from "../api/ServerApi";
 
 export function RelaysListRoute(p: {
   homeWidget?: boolean;
@@ -104,6 +105,7 @@ function RelaysList(p: {
             <TableCell>Priority</TableCell>
             <TableCell>Consumption</TableCell>
             <TableCell>Status</TableCell>
+            <TableCell>Forced state</TableCell>
             <TableCell></TableCell>
           </TableRow>
         </TableHead>
@@ -129,6 +131,13 @@ function RelaysList(p: {
                 />{" "}
                 for <TimeWidget diff time={p.status.get(row.id)!.for} />
               </TableCell>
+              <TableCell>
+                <RelayForcedState
+                  relay={row}
+                  state={p.status.get(row.id)!}
+                  onUpdated={p.onReload}
+                />
+              </TableCell>
               <TableCell>
                 <Tooltip title="Copy legacy api status">
                   <CopyToClipboard

central_frontend/src/widgets/RelayForcedState.tsx

@@ -0,0 +1,79 @@
+import { MenuItem, Select, SelectChangeEvent } from "@mui/material";
+import { DeviceRelay } from "../api/DeviceApi";
+import { RelayApi, RelayStatus, SetRelayForcedState } from "../api/RelayApi";
+import { TimeWidget } from "./TimeWidget";
+import { useLoadingMessage } from "../hooks/context_providers/LoadingMessageProvider";
+import { useAlert } from "../hooks/context_providers/AlertDialogProvider";
+import { useSnackbar } from "../hooks/context_providers/SnackbarProvider";
+import React from "react";
+import { SelectForcedStateDurationDialog } from "../dialogs/SelectForcedStateDurationDialog";
+
+export function RelayForcedState(p: {
+  relay: DeviceRelay;
+  state: RelayStatus;
+  onUpdated: () => void;
+}): React.ReactElement {
+  const loadingMessage = useLoadingMessage();
+  const alert = useAlert();
+  const snackbar = useSnackbar();
+
+  const [futureStateType, setFutureStateType] = React.useState<
+    string | undefined
+  >();
+
+  const handleChange = (event: SelectChangeEvent) => {
+    if (event.target.value == "None") {
+      submitChange({ type: "None" });
+    } else {
+      setFutureStateType(event.target.value);
+    }
+  };
+
+  const submitChange = async (state: SetRelayForcedState) => {
+    try {
+      loadingMessage.show("Setting forced state...");
+      await RelayApi.SetForcedState(p.relay, state);
+      p.onUpdated();
+      snackbar("Forced state successfully updated!");
+    } catch (e) {
+      console.error(`Failed to set relay forced state! ${e}`);
+      alert(`Failed to set loading state for relay! ${e}`);
+    } finally {
+      loadingMessage.hide();
+    }
+  };
+
+  return (
+    <>
+      <Select
+        value={p.state.forced_state.type}
+        onChange={handleChange}
+        size="small"
+        variant="standard"
+      >
+        <MenuItem value={"None"}>None</MenuItem>
+        <MenuItem value={"Off"}>Off</MenuItem>
+        <MenuItem value={"On"}>On</MenuItem>
+      </Select>
+      {p.state.forced_state.type !== "None" && (
+        <>
+          <TimeWidget future time={p.state.forced_state.until} /> left
+        </>
+      )}
+
+      {futureStateType !== undefined && (
+        <SelectForcedStateDurationDialog
+          {...p}
+          forcedState={futureStateType}
+          onCancel={() => setFutureStateType(undefined)}
+          onSubmit={(d) =>
+            submitChange({
+              type: futureStateType as any,
+              for_secs: d,
+            })
+          }
+        />
+      )}
+    </>
+  );
+}

central_frontend/src/widgets/TimeWidget.tsx

@@ -51,13 +51,14 @@ export function timeDiff(a: number, b: number): string {
   return `${diffYears} years`;
 }
 
-export function timeDiffFromNow(t: number): string {
-  return timeDiff(t, time());
+export function timeDiffFromNow(t: number, future?: boolean): string {
+  return future ? timeDiff(time(), t) : timeDiff(t, time());
 }
 
 export function TimeWidget(p: {
   time?: number;
   diff?: boolean;
+  future?: boolean;
 }): React.ReactElement {
   if (!p.time) return <></>;
   return (
@@ -65,7 +66,9 @@ export function TimeWidget(p: {
       title={formatDate(p.diff ? new Date().getTime() / 1000 - p.time : p.time)}
       arrow
     >
-      <span>{p.diff ? timeDiff(0, p.time) : timeDiffFromNow(p.time)}</span>
+      <span>
+        {p.diff ? timeDiff(0, p.time) : timeDiffFromNow(p.time, p.future)}
+      </span>
     </Tooltip>
   );
 }

esp32_device/version.txt

@@ -1 +1 @@
-1.0.2
+1.0.3