131 lines
4.4 KiB
Rust
131 lines
4.4 KiB
Rust
//! # Devices entities definition
|
|
|
|
use crate::constants::StaticConstraints;
|
|
|
|
/// Device information provided directly by the device during syncrhonisation.
|
|
///
|
|
/// It should not be editable fro the Web UI
|
|
#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
|
|
pub struct DeviceInfo {
|
|
/// Device reference
|
|
reference: String,
|
|
/// Device firmware / software version
|
|
version: semver::Version,
|
|
/// Maximum number of relay that the device can support
|
|
max_relays: usize,
|
|
}
|
|
|
|
impl DeviceInfo {
|
|
/// Identify errors in device information definition
|
|
pub fn error(&self) -> Option<&str> {
|
|
if self.reference.trim().is_empty() {
|
|
return Some("Given device reference is empty or blank!");
|
|
}
|
|
|
|
if self.max_relays == 0 {
|
|
return Some("Given device cannot handle any relay!");
|
|
}
|
|
|
|
None
|
|
}
|
|
}
|
|
|
|
/// Device identifier
|
|
#[derive(Clone, Debug, serde::Serialize, serde::Deserialize, Eq, PartialEq, Hash)]
|
|
pub struct DeviceId(pub String);
|
|
|
|
/// Single device information
|
|
#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
|
|
pub struct Device {
|
|
/// The device ID
|
|
pub id: DeviceId,
|
|
/// Information about the device
|
|
///
|
|
/// These information shall not be editable from the webui. They are automatically updated during
|
|
/// device synchronization
|
|
pub info: DeviceInfo,
|
|
/// Time at which device was initially enrolled
|
|
pub time_create: u64,
|
|
/// Time at which device was last updated
|
|
pub time_update: u64,
|
|
/// Name given to the device on the Web UI
|
|
pub name: String,
|
|
/// Description given to the device on the Web UI
|
|
pub description: String,
|
|
/// Specify whether the device has been validated or not. Validated devices are given a
|
|
/// certificate
|
|
pub validated: bool,
|
|
/// Specify whether the device is enabled or not
|
|
pub enabled: bool,
|
|
/// Information about the relays handled by the device
|
|
///
|
|
/// There cannot be more than [info.max_relays] relays
|
|
pub relays: Vec<DeviceRelay>,
|
|
}
|
|
|
|
/// Structure that contains information about the minimal expected execution
|
|
/// time of a device
|
|
#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
|
|
pub struct DailyMinRuntime {
|
|
/// Minimum time, in seconds, that this relay should run each day
|
|
pub min_runtime: usize,
|
|
/// The seconds in the days (from 00:00) where the counter is reset
|
|
pub reset_time: usize,
|
|
/// The hours during which the relay should be turned on to reach expected runtime
|
|
pub catch_up_hours: Vec<usize>,
|
|
}
|
|
|
|
#[derive(Clone, Copy, Debug, serde::Serialize, serde::Deserialize, Eq, PartialEq)]
|
|
pub struct DeviceRelayID(uuid::Uuid);
|
|
|
|
/// Single device relay information
|
|
#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
|
|
pub struct DeviceRelay {
|
|
/// Device relay id. Should be unique across the whole application
|
|
id: DeviceRelayID,
|
|
/// Human-readable name for the relay
|
|
name: String,
|
|
/// Whether this relay can be turned on or not
|
|
enabled: bool,
|
|
/// Relay priority when selecting relays to turn on. 0 = lowest priority
|
|
priority: usize,
|
|
/// Estimated consumption of the electrical equipment triggered by the relay
|
|
consumption: usize,
|
|
/// Minimal time this relay shall be left on before it can be turned off (in seconds)
|
|
minimal_uptime: usize,
|
|
/// Minimal time this relay shall be left off before it can be turned on again (in seconds)
|
|
minimal_downtime: usize,
|
|
/// Optional minimal runtime requirements for this relay
|
|
daily_runtime: Option<DailyMinRuntime>,
|
|
/// Specify relay that must be turned on before this relay can be started
|
|
depends_on: Vec<DeviceRelayID>,
|
|
/// Specify relays that must be turned off before this relay can be started
|
|
conflicts_with: Vec<DeviceRelayID>,
|
|
}
|
|
|
|
/// Device general information
|
|
///
|
|
/// This structure is used to update device information
|
|
#[derive(serde::Deserialize, Debug, Clone)]
|
|
pub struct DeviceGeneralInfo {
|
|
pub name: String,
|
|
pub description: String,
|
|
pub enabled: bool,
|
|
}
|
|
|
|
impl DeviceGeneralInfo {
|
|
/// Check for errors in the structure
|
|
pub fn error(&self) -> Option<&'static str> {
|
|
let constraints = StaticConstraints::default();
|
|
if !constraints.dev_name_len.validate(&self.name) {
|
|
return Some("Invalid device name length!");
|
|
}
|
|
|
|
if !constraints.dev_description_len.validate(&self.description) {
|
|
return Some("Invalid device description length!");
|
|
}
|
|
|
|
None
|
|
}
|
|
}
|