Add service to reset last complete

Author: chrisdoherty4

.storage/maint.store

@@ -0,0 +1,21 @@
+{
+  "version": 2,
+  "minor_version": 1,
+  "key": "maint.store",
+  "data": {
+    "entries": {
+      "entry": [
+        {
+          "task_id": "40ab9650c1ca40458c4fdb0e9ac91f64",
+          "description": "Test",
+          "last_completed": "2024-02-02",
+          "recurrence": {
+            "type": "interval",
+            "every": 7,
+            "unit": "days"
+          }
+        }
+      ]
+    }
+  }
+}

README.md

@@ -12,6 +12,8 @@ events when tasks become due so you can automate reminders or actions.
 - Flexible schedules: intervals (every N days/weeks/months) and custom weekly patterns.
 - Event `maint_task_due` fired when a task’s binary sensor turns on, including task metadata for use
   in automations.
+- Service `maint.reset_last_completed` to mark a task as completed (defaults to today, or provide a
+  specific date).
 
 ## Install
 
@@ -23,6 +25,12 @@ events when tasks become due so you can automate reminders or actions.
 3) Find **Maint** under HACS Integrations and install it.
 4) Restart Home Assistant, then add the Maint integration from *Settings → Devices & Services*.
 
+## Service
+
+Call the `maint.reset_last_completed` service to mark a task complete. Target a Maint binary sensor
+entity or pass `entry_id` and `task_id`, and optionally include `last_completed` to backdate the
+completion (defaults to today).
+
 ## What's next
 - Publish Maint to the HACS default registry so it can be installed without adding a custom
   repository.

custom_components/maint/__init__.py

@@ -12,6 +12,7 @@
 from .domain import DOMAIN
 from .models import MaintConfigEntry, MaintRuntimeData, MaintTaskStore
 from .panel import async_register_panel, async_unregister_panel
+from .services import async_register_services
 from .websocket import async_register_websocket_handlers
 
 # We only support setup from the UI so we need to load a config entry only schema.
@@ -40,6 +41,7 @@ async def async_setup(hass: HomeAssistant, _config: ConfigType) -> bool:
     data: dict[str, Any] = hass.data.setdefault(DOMAIN, {})
     _LOGGER.info("Setting up Maint integration")
     await _async_get_task_store(hass)
+    async_register_services(hass, _async_get_task_store)
     await async_register_panel(hass)
     if not data.get(DATA_KEY_WS_REGISTERED):
         async_register_websocket_handlers(hass)
@@ -90,6 +92,13 @@ async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     return unload_ok
 
 
+async def async_remove_entry(hass: HomeAssistant, entry: ConfigEntry) -> None:
+    """Remove a config entry and purge its tasks."""
+    _LOGGER.debug("Removing Maint config entry %s; purging tasks", entry.entry_id)
+    store = await _async_get_task_store(hass)
+    await store.async_remove_entry(entry.entry_id)
+
+
 async def _async_get_task_store(hass: HomeAssistant) -> MaintTaskStore:
     """Return the shared Maint task store."""
     data: dict[str, Any] = hass.data.setdefault(DOMAIN, {})

custom_components/maint/frontend/dist/main.js

@@ -10,13 +10,14 @@ const parseIsoDate = (value: string): Date | null => {
   if ([year, month, day].some((part) => Number.isNaN(part))) {
     return null;
   }
-  return new Date(Date.UTC(year, month - 1, day));
+  // Use local time to avoid UTC offsets shifting the displayed day.
+  return new Date(year, month - 1, day);
 };
 
 const formatIsoDate = (value: Date): string =>
-  `${value.getUTCFullYear().toString().padStart(4, "0")}-${(value.getUTCMonth() + 1)
+  `${value.getFullYear().toString().padStart(4, "0")}-${(value.getMonth() + 1)
     .toString()
-    .padStart(2, "0")}-${value.getUTCDate().toString().padStart(2, "0")}`;
+    .padStart(2, "0")}-${value.getDate().toString().padStart(2, "0")}`;
 
 export const parseDate = (value: string | FormDataEntryValue | null | undefined): string | null => {
   if (value === null || value === undefined) {

custom_components/maint/frontend/dist/main.js.map

@@ -371,6 +371,33 @@ async def async_update_task(
         )
         return task
 
+    async def async_set_last_completed(
+        self,
+        entry_id: str,
+        task_id: str,
+        *,
+        last_completed: date,
+    ) -> MaintTask:
+        """Update only the last completed date for a task."""
+        self.validate(
+            entry_id=entry_id,
+            task_id=task_id,
+            last_completed=last_completed,
+        )
+
+        tasks = await self._async_get_entry_tasks(entry_id)
+        task = tasks[task_id]
+        task.last_completed = last_completed
+        await self._async_save()
+        async_dispatcher_send(self._hass, SIGNAL_TASK_UPDATED, entry_id, task)
+        _LOGGER.debug(
+            "Updated last completed for Maint task %s for entry %s to %s",
+            task_id,
+            entry_id,
+            task.last_completed,
+        )
+        return task
+
     async def async_delete_task(self, entry_id: str, task_id: str) -> MaintTask:
         """Delete and return a task."""
         self.validate(entry_id=entry_id, task_id=task_id)
@@ -384,6 +411,22 @@ async def async_delete_task(self, entry_id: str, task_id: str) -> MaintTask:
         _LOGGER.debug("Deleted Maint task %s for entry %s", task.task_id, entry_id)
         return task
 
+    async def async_remove_entry(self, entry_id: str) -> None:
+        """Remove all tasks for an entry and persist."""
+        self.validate(entry_id=entry_id)
+        await self.async_load()
+        if entry_id not in self._tasks:
+            _LOGGER.debug("No Maint tasks to remove for entry %s", entry_id)
+            return
+
+        removed = self._tasks.pop(entry_id)
+        await self._async_save()
+        _LOGGER.debug(
+            "Removed Maint entry %s from task store (%s tasks purged)",
+            entry_id,
+            len(removed),
+        )
+
     async def async_get_task(self, entry_id: str, task_id: str) -> MaintTask:
         """Return a task by id."""
         self.validate(entry_id=entry_id, task_id=task_id)

custom_components/maint/frontend/src/formatting.ts

@@ -0,0 +1,105 @@
+"""Maint service registration and handlers."""
+
+from __future__ import annotations
+
+import logging
+from datetime import date, datetime
+from typing import TYPE_CHECKING, Any
+
+import voluptuous as vol
+from homeassistant.exceptions import HomeAssistantError
+from homeassistant.helpers import config_validation as cv
+from homeassistant.util import dt as dt_util
+
+from .domain import DOMAIN
+
+if TYPE_CHECKING:
+    from collections.abc import Awaitable, Callable
+
+    from homeassistant.core import HomeAssistant, ServiceCall
+
+    from .models import MaintTaskStore
+
+SERVICE_RESET_LAST_COMPLETED = "reset_last_completed"
+SERVICE_TARGET_GROUP = "task_target"
+SERVICE_ENTITY_ID = "entity_id"
+SERVICE_ENTRY_ID = "entry_id"
+SERVICE_TASK_ID = "task_id"
+SERVICE_LAST_COMPLETED = "last_completed"
+SERVICE_RESET_LAST_COMPLETED_SCHEMA = vol.Schema(
+    {
+        vol.Exclusive(SERVICE_ENTITY_ID, SERVICE_TARGET_GROUP): cv.entity_id,
+        vol.Inclusive(SERVICE_ENTRY_ID, SERVICE_TARGET_GROUP): cv.string,
+        vol.Inclusive(SERVICE_TASK_ID, SERVICE_TARGET_GROUP): cv.string,
+        vol.Optional(SERVICE_LAST_COMPLETED): cv.date,
+    },
+    extra=vol.PREVENT_EXTRA,
+)
+
+_LOGGER = logging.getLogger(__name__)
+
+DATA_KEY_SERVICES_REGISTERED = "services_registered"
+
+
+def _normalize_last_completed(value: date | datetime | None) -> date:
+    """Convert service input into a date, defaulting to today."""
+    if value is None:
+        return dt_util.now().date()
+    if isinstance(value, datetime):
+        return dt_util.as_local(value).date()
+    return value
+
+
+def _resolve_service_target(
+    hass: HomeAssistant, data: dict[str, Any]
+) -> tuple[str, str]:
+    """Return entry and task identifiers from service data."""
+    if entity_id := data.get(SERVICE_ENTITY_ID):
+        state = hass.states.get(entity_id)
+        if state is None:
+            message = f"Entity {entity_id} not found"
+            raise HomeAssistantError(message)
+        entry_id = state.attributes.get("entry_id")
+        task_id = state.attributes.get("task_id")
+        if not entry_id or not task_id:
+            message = f"Entity {entity_id} is not a Maint task sensor"
+            raise HomeAssistantError(message)
+        return str(entry_id), str(task_id)
+
+    entry_id = data[SERVICE_ENTRY_ID]
+    task_id = data[SERVICE_TASK_ID]
+    return str(entry_id), str(task_id)
+
+
+def async_register_services(
+    hass: HomeAssistant,
+    get_task_store: Callable[[HomeAssistant], Awaitable[MaintTaskStore]],
+) -> None:
+    """Register Maint services."""
+    data: dict[str, Any] = hass.data.setdefault(DOMAIN, {})
+    if data.get(DATA_KEY_SERVICES_REGISTERED):
+        return
+
+    async def async_handle_reset_last_completed(call: ServiceCall) -> None:
+        """Set a task's last completed date."""
+        entry_id, task_id = _resolve_service_target(hass, call.data)
+        last_completed = _normalize_last_completed(
+            call.data.get(SERVICE_LAST_COMPLETED)
+        )
+        store = await get_task_store(hass)
+        try:
+            await store.async_set_last_completed(
+                entry_id, task_id, last_completed=last_completed
+            )
+        except KeyError as err:
+            message = f"Task {task_id} not found for entry {entry_id}"
+            raise HomeAssistantError(message) from err
+
+    hass.services.async_register(
+        DOMAIN,
+        SERVICE_RESET_LAST_COMPLETED,
+        async_handle_reset_last_completed,
+        schema=SERVICE_RESET_LAST_COMPLETED_SCHEMA,
+    )
+    data[DATA_KEY_SERVICES_REGISTERED] = True
+    _LOGGER.debug("Registered Maint services")

custom_components/maint/models.py

@@ -0,0 +1,30 @@
+reset_last_completed:
+  name: Reset last completed
+  description: Set a Maint task's last completed date to today or a provided date.
+  target:
+    entity:
+      integration: maint
+      domain: binary_sensor
+  fields:
+    entity_id:
+      name: Task entity
+      description: Binary sensor entity for the Maint task to reset. Use entry_id/task_id instead if the entity is unavailable.
+      example: binary_sensor.maint_change_air_filter
+      selector:
+        entity:
+          integration: maint
+          domain: binary_sensor
+    entry_id:
+      name: Entry ID
+      description: Maint config entry ID. Required if entity_id is not provided.
+      example: "abc123"
+    task_id:
+      name: Task ID
+      description: Maint task ID. Required if entity_id is not provided.
+      example: "bde3c87c056d4c1b9b22e4fd3160c0f6"
+    last_completed:
+      name: Last completed
+      description: Date to store as the last completed value. Defaults to today when omitted.
+      example: "2024-05-01"
+      selector:
+        date:

custom_components/maint/services.py

@@ -9,13 +9,37 @@
       }
     }
   },
-    "options": {
-      "step": {
-        "init": {
-          "data": {
-            "sensor_prefix": "Sensor prefix"
-          }
+  "options": {
+    "step": {
+      "init": {
+        "data": {
+          "sensor_prefix": "Sensor prefix"
+        }
+      }
+    }
+  },
+  "services": {
+    "reset_last_completed": {
+      "name": "Reset last completed",
+      "description": "Set a Maint task's last completed date to today or a provided date.",
+      "fields": {
+        "entity_id": {
+          "name": "Task entity",
+          "description": "Binary sensor entity for the Maint task to reset. Use entry_id/task_id instead if the entity is unavailable."
+        },
+        "entry_id": {
+          "name": "Entry ID",
+          "description": "Maint config entry ID. Required if entity_id is not provided."
+        },
+        "task_id": {
+          "name": "Task ID",
+          "description": "Maint task ID. Required if entity_id is not provided."
+        },
+        "last_completed": {
+          "name": "Last completed",
+          "description": "Date to store as the last completed value. Defaults to today when omitted."
         }
       }
     }
   }
+}