gru/gree-controller
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

v0.6.8

Browse Source
This commit is contained in:
Mateusz Gruszczyński
2026-08-25 18:10:51 +02:00
parent 440c7c3a8d
commit 26d8f9f83a
21 changed files with 1031 additions and 98 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/api.rs
+180 -6
View File
@@ -23,7 +23,7 @@ use crate::{
home_assistant,
influxdb,
notifications,
models::{ApiTokenInfo, Automation, ConfigurationExport, DebugSettings, Device, DeviceCommand, DevicePatch, DiscoveryRequest, ManualDeviceRequest, HaReading, NotificationSettings, Reading, RuntimeSettings, Schedule, Zone, ZoneControlPatch, ZoneReading},
models::{ApiTokenInfo, Automation, ClimateGroup, ConfigurationExport, DebugSettings, Device, DeviceCommand, DevicePatch, DiscoveryRequest, GroupControlPatch, ManualDeviceRequest, HaReading, NotificationSettings, Reading, RuntimeSettings, Schedule, Zone, ZoneControlPatch, ZoneReading},
protocol::merge_discovered,
state::AppState,
};
@@ -51,6 +51,9 @@ pub fn router(state: AppState) -> Router {
.route("/api/zones/:id", get(get_zone).put(update_zone).delete(delete_zone))
.route("/api/zones/:id/control", post(update_zone_control))
.route("/api/zones/:id/schedule-template", post(apply_schedule_template))
.route("/api/groups", get(list_groups).post(create_group))
.route("/api/groups/:id", get(get_group).put(update_group).delete(delete_group))
.route("/api/groups/:id/control", post(update_group_control))
.route("/api/house/control", post(update_house_control))
.route("/api/house/power", post(update_house_power))
.route("/api/house/preset", post(update_house_preset))
@@ -205,6 +208,7 @@ async fn build_bootstrap(state: &AppState) -> Result<Value, AppError> {
Ok(json!({
"devices": state.db.list_devices()?,
"zones": state.db.list_zones()?,
"groups": state.db.list_groups()?,
"schedules": state.db.list_schedules()?,
"automations": state.db.list_automations()?,
"access_tokens": state.db.list_api_tokens()?,
@@ -367,7 +371,12 @@ async fn patch_device(State(state): State<AppState>, Path(id): Path<String>, Jso
}
async fn delete_device(State(state): State<AppState>, Path(id): Path<String>) -> Result<StatusCode, AppError> {
let removed_zone_ids: std::collections::HashSet<String> = state.db.list_zones()?.into_iter()
.filter(|zone| zone.device_id == id)
.map(|zone| zone.id)
.collect();
if !state.db.delete_device(&id)? { return Err(AppError::NotFound(format!("device {id}"))); }
remove_zone_ids_from_groups(&state, &removed_zone_ids)?;
state.log("info", "device.deleted", "Device deleted", json!({"device_id": id}));
state.broadcast("device.deleted", json!({"id": id}));
Ok(StatusCode::NO_CONTENT)
@@ -591,9 +600,121 @@ async fn update_zone_control(State(state): State<AppState>, Path(id): Path<Strin
Ok(Json(zone))
}
#[derive(Debug, Deserialize)]
struct GroupInput {
name: String,
#[serde(default)]
zone_ids: Vec<String>,
#[serde(default)]
power_enabled: Option<bool>,
}
fn normalize_group_zone_ids(zone_ids: Vec<String>) -> Vec<String> {
let mut values: Vec<String> = zone_ids.into_iter()
.map(|value| value.trim().to_string())
.filter(|value| !value.is_empty())
.collect();
values.sort();
values.dedup();
values
}
fn validate_group_input(state: &AppState, input: &GroupInput) -> Result<Vec<String>, AppError> {
if input.name.trim().is_empty() {
return Err(AppError::BadRequest("group name is required".into()));
}
let zone_ids = normalize_group_zone_ids(input.zone_ids.clone());
if zone_ids.is_empty() {
return Err(AppError::BadRequest("group must contain at least one zone".into()));
}
for zone_id in &zone_ids {
if state.db.get_zone(zone_id)?.is_none() {
return Err(AppError::BadRequest(format!("group references missing zone {zone_id}")));
}
}
Ok(zone_ids)
}
async fn list_groups(State(state): State<AppState>) -> Result<Json<Vec<ClimateGroup>>, AppError> {
Ok(Json(state.db.list_groups()?))
}
async fn get_group(State(state): State<AppState>, Path(id): Path<String>) -> Result<Json<ClimateGroup>, AppError> {
state.db.get_group(&id)?.map(Json).ok_or_else(|| AppError::NotFound(format!("group {id}")))
}
async fn create_group(State(state): State<AppState>, Json(input): Json<GroupInput>) -> Result<(StatusCode, Json<ClimateGroup>), AppError> {
let zone_ids = validate_group_input(&state, &input)?;
let now = Utc::now();
let group = ClimateGroup {
id: Uuid::new_v4().to_string(),
name: input.name.trim().to_string(),
zone_ids,
power_enabled: input.power_enabled.unwrap_or(true),
created_at: now,
updated_at: now,
};
state.db.save_group(&group)?;
state.broadcast("group.created", serde_json::to_value(&group)?);
Ok((StatusCode::CREATED, Json(group)))
}
async fn update_group(State(state): State<AppState>, Path(id): Path<String>, Json(input): Json<GroupInput>) -> Result<Json<ClimateGroup>, AppError> {
let existing = state.db.get_group(&id)?.ok_or_else(|| AppError::NotFound(format!("group {id}")))?;
let zone_ids = validate_group_input(&state, &input)?;
let group = ClimateGroup {
id,
name: input.name.trim().to_string(),
zone_ids,
power_enabled: input.power_enabled.unwrap_or(existing.power_enabled),
created_at: existing.created_at,
updated_at: Utc::now(),
};
state.db.save_group(&group)?;
state.broadcast("group.updated", serde_json::to_value(&group)?);
Ok(Json(group))
}
async fn delete_group(State(state): State<AppState>, Path(id): Path<String>) -> Result<StatusCode, AppError> {
if state.db.list_automations()?.iter().any(|item| item.action_group_id.as_deref() == Some(id.as_str())) {
return Err(AppError::BadRequest("group is used by an automation; remove or retarget that automation first".into()));
}
if !state.db.delete_group(&id)? { return Err(AppError::NotFound(format!("group {id}"))); }
state.broadcast("group.deleted", json!({"id": id}));
Ok(StatusCode::NO_CONTENT)
}
fn remove_zone_ids_from_groups(state: &AppState, zone_ids: &std::collections::HashSet<String>) -> Result<(), AppError> {
if zone_ids.is_empty() { return Ok(()); }
for mut group in state.db.list_groups()? {
let before = group.zone_ids.len();
group.zone_ids.retain(|zone_id| !zone_ids.contains(zone_id));
if group.zone_ids.len() == before { continue; }
group.updated_at = Utc::now();
state.db.save_group(&group)?;
state.broadcast("group.updated", serde_json::to_value(&group)?);
}
Ok(())
}
async fn update_group_control(State(state): State<AppState>, Path(id): Path<String>, Json(patch): Json<GroupControlPatch>) -> Result<Json<Value>, AppError> {
Ok(Json(engine::control_group(&state, &id, patch, "group.quick_control").await?))
}
#[derive(Debug, Deserialize)]
struct HouseControlPatch { mode: String }
fn enable_all_groups(state: &AppState) -> Result<(), AppError> {
for mut group in state.db.list_groups()? {
if group.power_enabled { continue; }
group.power_enabled = true;
group.updated_at = Utc::now();
state.db.save_group(&group)?;
state.broadcast("group.updated", serde_json::to_value(&group)?);
}
Ok(())
}
async fn command_all_enabled_devices_power(state: &AppState, power: bool, source: &str) -> Result<Vec<Value>, AppError> {
let mut failed = Vec::new();
for device in state.db.list_devices()? {
@@ -634,6 +755,7 @@ async fn update_house_control(State(state): State<AppState>, Json(input): Json<H
};
state.broadcast("settings.updated", payload.clone());
if activate_all {
enable_all_groups(&state)?;
let failed = command_all_enabled_devices_power(&state, true, "house_mode").await?;
if !failed.is_empty() {
state.log("warn", "house.mode_power_partial", "House mode enabled master power, but some devices could not be powered on", json!({
@@ -662,6 +784,7 @@ async fn update_house_power(State(state): State<AppState>, Json(input): Json<Hou
}
}
if input.power { enable_all_groups(&state)?; }
let failed = command_all_enabled_devices_power(&state, input.power, "house_power").await?;
let devices = state.db.list_devices()?;
@@ -697,6 +820,7 @@ async fn update_house_preset(State(state): State<AppState>, Json(input): Json<Ho
public_settings(&settings)
};
state.broadcast("settings.updated", settings_payload.clone());
enable_all_groups(&state)?;
let schedules = state.db.list_schedules()?;
let mut zones = state.db.list_zones()?;
@@ -778,6 +902,9 @@ async fn apply_schedule_template(State(state): State<AppState>, Path(id): Path<S
async fn delete_zone(State(state): State<AppState>, Path(id): Path<String>) -> Result<StatusCode, AppError> {
if !state.db.delete_zone(&id)? { return Err(AppError::NotFound(format!("zone {id}"))); }
let mut removed = std::collections::HashSet::new();
removed.insert(id.clone());
remove_zone_ids_from_groups(&state, &removed)?;
state.broadcast("zone.deleted", json!({"id": id}));
Ok(StatusCode::NO_CONTENT)
}
@@ -851,8 +978,13 @@ struct AutomationInput {
threshold: Option<f64>,
#[serde(default)]
at_time: Option<String>,
#[serde(default)]
action_device_id: String,
#[serde(default)]
action_group_id: Option<String>,
#[serde(default)]
action_preset: Option<String>,
#[serde(default)]
action: DeviceCommand,
#[serde(default = "automation_cooldown")]
cooldown_seconds: u64,
@@ -873,12 +1005,36 @@ impl AutomationInput {
}
_ => return Err(AppError::BadRequest("unsupported automation trigger".into())),
}
let action_group_id = self.action_group_id.as_deref().map(str::trim).filter(|value| !value.is_empty());
if action_group_id.is_none() && self.action_device_id.trim().is_empty() {
return Err(AppError::BadRequest("automation action needs a device or group".into()));
}
if let Some(preset) = self.action_preset.as_deref().map(str::trim).filter(|value| !value.is_empty()) {
if action_group_id.is_none() {
return Err(AppError::BadRequest("automation preset actions require a group target".into()));
}
if !matches!(preset, "auto" | "comfort" | "sleep" | "away") {
return Err(AppError::BadRequest("unsupported group automation preset".into()));
}
}
if action_group_id.is_some() {
if let Some(mode) = self.action.mode.as_deref() {
if !matches!(mode, "auto" | "house" | "cool" | "heat") {
return Err(AppError::BadRequest("group automation mode must be house, cool or heat".into()));
}
}
if self.action.target_temperature.is_some() {
return Err(AppError::BadRequest("group automation target temperature is not supported; use a group preset".into()));
}
}
Ok(())
}
fn into_automation(self, id: String, created_at: chrono::DateTime<Utc>, last_fired_at: Option<chrono::DateTime<Utc>>) -> Automation {
Automation { id, name: self.name.trim().into(), enabled: self.enabled,
trigger_kind: self.trigger_kind, trigger_device_id: self.trigger_device_id,
threshold: self.threshold, at_time: self.at_time, action_device_id: self.action_device_id,
threshold: self.threshold, at_time: self.at_time, action_device_id: self.action_device_id.trim().to_string(),
action_group_id: self.action_group_id.map(|value| value.trim().to_string()).filter(|value| !value.is_empty()),
action_preset: self.action_preset.map(|value| value.trim().to_string()).filter(|value| !value.is_empty()),
action: self.action, cooldown_seconds: self.cooldown_seconds.max(30), last_fired_at,
created_at, updated_at: Utc::now() }
}
@@ -889,7 +1045,11 @@ async fn get_automation(State(state): State<AppState>, Path(id): Path<String>) -
}
async fn create_automation(State(state): State<AppState>, Json(input): Json<AutomationInput>) -> Result<(StatusCode, Json<Automation>), AppError> {
input.validate()?;
if state.db.get_device(&input.action_device_id)?.is_none() { return Err(AppError::BadRequest("automation action device does not exist".into())); }
if let Some(group_id) = input.action_group_id.as_deref().map(str::trim).filter(|value| !value.is_empty()) {
if state.db.get_group(group_id)?.is_none() { return Err(AppError::BadRequest("automation action group does not exist".into())); }
} else if state.db.get_device(input.action_device_id.trim())?.is_none() {
return Err(AppError::BadRequest("automation action device does not exist".into()));
}
let item = input.into_automation(Uuid::new_v4().to_string(), Utc::now(), None);
state.db.save_automation(&item)?;
state.broadcast("automation.created", serde_json::to_value(&item)?);
@@ -898,7 +1058,11 @@ async fn create_automation(State(state): State<AppState>, Json(input): Json<Auto
async fn update_automation(State(state): State<AppState>, Path(id): Path<String>, Json(input): Json<AutomationInput>) -> Result<Json<Automation>, AppError> {
input.validate()?;
let existing = state.db.get_automation(&id)?.ok_or_else(|| AppError::NotFound(format!("automation {id}")))?;
if state.db.get_device(&input.action_device_id)?.is_none() { return Err(AppError::BadRequest("automation action device does not exist".into())); }
if let Some(group_id) = input.action_group_id.as_deref().map(str::trim).filter(|value| !value.is_empty()) {
if state.db.get_group(group_id)?.is_none() { return Err(AppError::BadRequest("automation action group does not exist".into())); }
} else if state.db.get_device(input.action_device_id.trim())?.is_none() {
return Err(AppError::BadRequest("automation action device does not exist".into()));
}
let item = input.into_automation(id, existing.created_at, existing.last_fired_at);
state.db.save_automation(&item)?;
state.broadcast("automation.updated", serde_json::to_value(&item)?);
@@ -1352,8 +1516,18 @@ fn validate_configuration_export(export: &ConfigurationExport) -> Result<(), App
if export.schedules.iter().any(|item| !zones.contains(item.zone_id.as_str())) {
return Err(AppError::BadRequest("import contains a schedule referencing a missing zone".into()));
}
if export.automations.iter().any(|item| !devices.contains(item.action_device_id.as_str())) {
return Err(AppError::BadRequest("import contains an automation referencing a missing device".into()));
if export.groups.iter().any(|group| group.zone_ids.iter().any(|zone_id| !zones.contains(zone_id.as_str()))) {
return Err(AppError::BadRequest("import contains a group referencing a missing zone".into()));
}
let groups: std::collections::HashSet<&str> = export.groups.iter().map(|item| item.id.as_str()).collect();
if export.automations.iter().any(|item| {
if let Some(group_id) = item.action_group_id.as_deref().filter(|value| !value.is_empty()) {
!groups.contains(group_id)
} else {
!devices.contains(item.action_device_id.as_str())
}
}) {
return Err(AppError::BadRequest("import contains an automation referencing a missing device or group".into()));
}
if export.automations.iter().any(|item| item.trigger_device_id.as_deref().is_some_and(|id| !devices.contains(id))) {
return Err(AppError::BadRequest("import contains an automation trigger referencing a missing device".into()));