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

v0.8.14

Browse Source
This commit is contained in:
Mateusz Gruszczyński
2026-08-30 13:39:29 +02:00
parent 3e950ab5fa
commit 5c05eddb8f
83 changed files with 10130 additions and 9954 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/api/groups.rs
+249
View File
@@ -0,0 +1,249 @@
#[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)?);
state.wake_zone_control();
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)?);
state.wake_zone_control();
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}));
state.wake_zone_control();
Ok(StatusCode::NO_CONTENT)
}
fn ensure_zone_removal_safe(state: &AppState, zone_ids: &std::collections::HashSet<String>) -> Result<(), AppError> {
if zone_ids.is_empty() { return Ok(()); }
let automated_groups: std::collections::HashSet<String> = state.db.list_automations()?.into_iter()
.filter_map(|item| item.action_group_id)
.collect();
for group in state.db.list_groups()? {
let remaining = group.zone_ids.iter().filter(|zone_id| !zone_ids.contains(*zone_id)).count();
if remaining == 0 && group.zone_ids.iter().any(|zone_id| zone_ids.contains(zone_id)) && automated_groups.contains(&group.id) {
return Err(AppError::BadRequest(format!("cannot remove the last zone from group '{}' while an automation targets that group", group.name)));
}
}
Ok(())
}
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; }
if group.zone_ids.is_empty() {
state.db.delete_group(&group.id)?;
state.broadcast("group.deleted", json!({"id": group.id}));
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?))
}
fn home_assistant_group_mode(zones: &[&Zone]) -> String {
let mut value: Option<&str> = None;
for zone in zones {
let current = if zone.inherit_house_mode { "house" } else { zone.mode.as_str() };
if !matches!(current, "house" | "cool" | "heat") {
return "mixed".into();
}
if let Some(previous) = value {
if previous != current { return "mixed".into(); }
} else {
value = Some(current);
}
}
value.unwrap_or("mixed").to_string()
}
fn home_assistant_group_preset(zones: &[&Zone]) -> String {
let mut value: Option<&str> = None;
for zone in zones {
let current = zone.manual_preset.as_deref().unwrap_or("auto");
if !matches!(current, "auto" | "comfort" | "sleep" | "away") {
return "mixed".into();
}
if let Some(previous) = value {
if previous != current { return "mixed".into(); }
} else {
value = Some(current);
}
}
value.unwrap_or("mixed").to_string()
}
async fn list_home_assistant_groups(State(state): State<AppState>) -> Result<Json<Vec<Value>>, AppError> {
let groups = state.db.list_groups()?;
let zones = state.db.list_zones()?;
let devices = state.db.list_devices()?;
let plan = engine::build_control_plan(&state).await?;
let settings = state.settings.read().await.clone();
let mut output = Vec::with_capacity(groups.len());
for group in groups {
let members = zones.iter()
.filter(|zone| group.zone_ids.iter().any(|zone_id| zone_id == &zone.id))
.collect::<Vec<_>>();
let planned_members = plan.zones.iter()
.filter(|zone| group.zone_ids.iter().any(|zone_id| zone_id == &zone.zone_id))
.collect::<Vec<_>>();
let zone_names = members.iter().map(|zone| zone.name.clone()).collect::<Vec<_>>();
let member_device_ids = members.iter().map(|zone| zone.device_id.as_str()).collect::<std::collections::HashSet<_>>();
let online_devices = devices.iter()
.filter(|device| member_device_ids.contains(device.id.as_str()) && device.online)
.count();
let current_temperatures = planned_members.iter()
.filter_map(|zone| zone.current_temperature)
.collect::<Vec<_>>();
let current_temperature = if current_temperatures.is_empty() {
None
} else {
Some(current_temperatures.iter().sum::<f64>() / current_temperatures.len() as f64)
};
let mut next_events = Vec::new();
for zone in &planned_members {
for event in &zone.next_events {
let mut event = event.clone();
event.label = format!("{}: {}", zone.zone_name, event.label);
next_events.push(event);
}
}
next_events.sort_by_key(|event| event.at);
next_events.truncate(8);
let member_states = planned_members.iter().map(|zone| json!({
"zone_id": zone.zone_id,
"zone_name": zone.zone_name,
"device_id": zone.device_id,
"device_name": zone.device_name,
"enabled": zone.enabled,
"effective_enabled": zone.effective_enabled,
"mode": zone.mode,
"configured_mode": zone.configured_mode,
"inherit_house_mode": zone.inherit_house_mode,
"preset": zone.preset,
"current_temperature": zone.current_temperature,
"target_temperature": zone.target_temperature,
"demand": zone.demand,
"control_source": zone.control_source,
"current_schedule": zone.current_schedule_name,
"local_thermostat_power": zone.local_thermostat_power,
"local_thermostat_resume_at": zone.local_thermostat_resume_at,
"device_manual_override": zone.device_manual_override,
"device_manual_override_until": zone.device_manual_override_until,
})).collect::<Vec<_>>();
output.push(json!({
"id": group.id,
"name": group.name,
"zone_ids": group.zone_ids,
"zone_names": zone_names,
"power_enabled": group.power_enabled,
"effective_power": settings.house_power_enabled && group.power_enabled,
"mode": home_assistant_group_mode(&members),
"preset": home_assistant_group_preset(&members),
"house_mode": settings.house_mode,
"zone_count": members.len(),
"enabled_zones": members.iter().filter(|zone| zone.enabled).count(),
"active_zones": planned_members.iter().filter(|zone| zone.effective_enabled).count(),
"demanding_zones": planned_members.iter().filter(|zone| zone.demand).count(),
"device_count": member_device_ids.len(),
"online_devices": online_devices,
"current_temperature": current_temperature,
"members": member_states,
"next_events": next_events,
}));
}
Ok(Json(output))
}
async fn update_home_assistant_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, "home_assistant.group_control").await?))
}