Added control for lock

Author: Gabriel Wieskamp

custom_components/mill/__init__.py

@@ -18,6 +18,7 @@
     Platform.SENSOR,
     Platform.BINARY_SENSOR,
     Platform.SWITCH,
+    Platform.SELECT,
 ]
 
 

custom_components/mill/api.py

@@ -122,6 +122,26 @@ async def async_update_token(self):
         self._token = results.get('token')
 
 
+    async def async_set_lock(self, device, setting: str):
+        """Set the lid lock setting.
+        
+        Valid settings: 'AlwaysLocked', 'AlwaysUnlocked', 'LockedWhenHot'
+        """
+        valid_settings = ['AlwaysLocked', 'AlwaysUnlocked', 'LockedWhenHot']
+        if setting not in valid_settings:
+            raise ValueError(f"Invalid lid lock setting: {setting}. Must be one of {valid_settings}")
+            
+        await self.async_update_token()
+        auth = {"Authorization": "Bearer " + self._token}
+        results = await self._api_wrapper(
+            method="post", 
+            url=f"{CLOUD_URL}/device_settings/{device}",
+            data={"settings": {"lidLockSetting": setting}},
+            headers=auth
+        )
+        LOGGER.debug(f"Lid lock setting set to {setting}: {results}")
+
+
     async def async_set_cycle(self, device, cycle_state):
         """Set the cycle."""
         await self.async_update_token()

custom_components/mill/binary_sensor.py

@@ -28,11 +28,6 @@
         name="Bucket Missing",
         device_class=BinarySensorDeviceClass.PROBLEM,
     ),
-    BinarySensorEntityDescription(
-        key="childLockEnabled",
-        name="Child Lock",
-        device_class=BinarySensorDeviceClass.LOCK,
-    ),
     BinarySensorEntityDescription(
         key="online",
         name="Online",

custom_components/mill/manifest.json

@@ -8,7 +8,7 @@
   "issue_tracker": "https://github.com/theOrakle/mill/issues",
   "loggers": ["custom_components.mill"],
   "requirements": [],
-  "version": "1.0.24",
+  "version": "1.1.1",
   "dependencies": [],
   "codeowners": ["@theOrakle"]
 }

custom_components/mill/select.py

@@ -0,0 +1,96 @@
+"""Select platform for mill."""
+from __future__ import annotations
+
+from homeassistant.components.select import SelectEntity, SelectEntityDescription
+
+from .const import DOMAIN, LOGGER
+from .coordinator import MillDataUpdateCoordinator
+from .entity import MillEntity
+
+ENTITY_DESCRIPTIONS = (
+    SelectEntityDescription(
+        key="lidLockSetting",
+        name="Lid Lock Setting",
+        icon="mdi:lock-outline",
+        options=["AlwaysLocked", "AlwaysUnlocked", "LockedWhenHot"],
+    ),
+)
+
+
+async def async_setup_entry(hass, entry, async_add_devices):
+    """Set up the select platform."""
+    coordinator = hass.data[DOMAIN][entry.entry_id]
+    entities = []
+    
+    for device in coordinator.data:
+        for entity_description in ENTITY_DESCRIPTIONS:
+            # Only add lid lock setting if the device supports it
+            if coordinator.data[device].get(entity_description.key) is not None:
+                entities.append(
+                    MillSelect(
+                        coordinator=coordinator,
+                        entity_description=entity_description,
+                        device=device
+                    )
+                )
+    
+    async_add_devices(entities)
+
+
+class MillSelect(MillEntity, SelectEntity):
+    """Mill Select class."""
+
+    def __init__(
+        self,
+        coordinator: MillDataUpdateCoordinator,
+        entity_description: SelectEntityDescription,
+        device,
+    ) -> None:
+        """Initialize the select class."""
+        super().__init__(coordinator, entity_description, device)
+        self.entity_description = entity_description
+        self.device = device
+        self._attr_options = entity_description.options
+
+    @property
+    def current_option(self) -> str | None:
+        """Return the selected entity option."""
+        desc = self.entity_description
+        lid_lock_data = self.coordinator.data[self.device].get(desc.key)
+        
+        if isinstance(lid_lock_data, dict):
+            desired = lid_lock_data.get('desired')
+            reported = lid_lock_data.get('reported')
+            # Use desired state if it differs from reported and is not None
+            if desired != reported and desired is not None:
+                current_setting = desired
+            else:
+                current_setting = reported
+        else:
+            current_setting = lid_lock_data
+        
+        # Make sure the current setting is in our options list
+        if current_setting in self._attr_options:
+            return current_setting
+        else:
+            LOGGER.warning(f"Unknown lid lock setting: {current_setting}")
+            return None
+
+    async def async_select_option(self, option: str) -> None:
+        """Change the selected option."""
+        if option not in self._attr_options:
+            LOGGER.error(f"Invalid option: {option}. Valid options: {self._attr_options}")
+            return
+            
+        await self.coordinator.client.async_set_lock(self.device, option)
+        await self.coordinator.async_request_refresh()
+
+        async def delayed_refresh():
+            import asyncio
+            await asyncio.sleep(5)  # Wait 5 seconds
+            await self.coordinator.async_request_refresh()
+            await asyncio.sleep(10)  # Wait another 10 seconds
+            await self.coordinator.async_request_refresh()
+        
+        # Run delayed refreshes in background
+        self.coordinator.hass.async_create_task(delayed_refresh())