85 lines
2.9 KiB
Rust
85 lines
2.9 KiB
Rust
#[derive(Debug, Deserialize)]
|
|
struct HaTestRequest {
|
|
entity_id: Option<String>,
|
|
}
|
|
async fn test_home_assistant(
|
|
State(state): State<AppState>,
|
|
Json(input): Json<HaTestRequest>,
|
|
) -> Result<Json<Value>, AppError> {
|
|
let settings = state.settings.read().await.clone();
|
|
let resolved_entity_id =
|
|
home_assistant::resolve_entity_id(&settings.home_assistant, input.entity_id.as_deref());
|
|
let temperature = home_assistant::read_temperature(
|
|
&state.http,
|
|
&settings.home_assistant,
|
|
resolved_entity_id.as_deref(),
|
|
Some(settings.home_assistant.sensor_stale_after_seconds),
|
|
)
|
|
.await
|
|
.map_err(|e| AppError::Device(e.to_string()))?;
|
|
Ok(Json(
|
|
json!({"ok": true, "temperature_c": temperature, "entity_id": resolved_entity_id}),
|
|
))
|
|
}
|
|
|
|
#[derive(Debug, Deserialize)]
|
|
struct HaEntityRequest {
|
|
entity_id: String,
|
|
}
|
|
|
|
async fn inspect_home_assistant_entity(
|
|
State(state): State<AppState>,
|
|
Json(input): Json<HaEntityRequest>,
|
|
) -> Result<Json<Value>, AppError> {
|
|
let settings = state.settings.read().await.clone();
|
|
let entity_id =
|
|
home_assistant::resolve_entity_id(&settings.home_assistant, Some(input.entity_id.as_str()))
|
|
.filter(|value| !value.trim().is_empty())
|
|
.ok_or_else(|| AppError::BadRequest("Home Assistant entity_id is required".into()))?;
|
|
let payload = home_assistant::read_entity(
|
|
&state.http,
|
|
&settings.home_assistant,
|
|
Some(entity_id.as_str()),
|
|
)
|
|
.await
|
|
.map_err(|e| AppError::Device(e.to_string()))?;
|
|
let raw_state = payload
|
|
.get("state")
|
|
.and_then(Value::as_str)
|
|
.unwrap_or_default()
|
|
.to_string();
|
|
let available = !matches!(raw_state.as_str(), "unknown" | "unavailable" | "");
|
|
Ok(Json(json!({
|
|
"ok": true,
|
|
"entity_id": entity_id,
|
|
"state": raw_state,
|
|
"available": available,
|
|
"attributes": payload.get("attributes").cloned().unwrap_or_else(|| json!({})),
|
|
"last_changed": payload.get("last_changed").cloned().unwrap_or(Value::Null),
|
|
"last_updated": payload.get("last_updated").cloned().unwrap_or(Value::Null),
|
|
})))
|
|
}
|
|
|
|
async fn test_notifications(
|
|
State(state): State<AppState>,
|
|
Json(mut input): Json<NotificationSettings>,
|
|
) -> Result<Json<Value>, AppError> {
|
|
let old = state.settings.read().await.notifications.clone();
|
|
if input.pushover_app_token.trim().is_empty() {
|
|
input.pushover_app_token = old.pushover_app_token;
|
|
}
|
|
if input.pushover_user_key.trim().is_empty() {
|
|
input.pushover_user_key = old.pushover_user_key;
|
|
}
|
|
if input.slack_webhook_url.trim().is_empty() {
|
|
input.slack_webhook_url = old.slack_webhook_url;
|
|
}
|
|
if input.discord_webhook_url.trim().is_empty() {
|
|
input.discord_webhook_url = old.discord_webhook_url;
|
|
}
|
|
notifications::test(&state, input)
|
|
.await
|
|
.map_err(AppError::Device)?;
|
|
Ok(Json(json!({"ok": true})))
|
|
}
|