Refactor open garage (#26179)

* Use defined constant in open garage

* refactor open garage

* style

* style

* refactor

* refactor

* refactor

* remove vehicle state

homeassistant/components/opengarage/cover.py

@@ -6,19 +6,20 @@ import voluptuous as vol
 
 from homeassistant.components.cover import (
     CoverDevice,
+    DEVICE_CLASS_GARAGE,
     PLATFORM_SCHEMA,
     SUPPORT_OPEN,
     SUPPORT_CLOSE,
 )
 from homeassistant.const import (
-    CONF_DEVICE,
     CONF_NAME,
-    STATE_UNKNOWN,
     STATE_CLOSED,
     STATE_OPEN,
     CONF_COVERS,
     CONF_HOST,
     CONF_PORT,
+    STATE_CLOSING,
+    STATE_OPENING,
 )
 import homeassistant.helpers.config_validation as cv
 
@@ -28,17 +29,11 @@ ATTR_DISTANCE_SENSOR = "distance_sensor"
 ATTR_DOOR_STATE = "door_state"
 ATTR_SIGNAL_STRENGTH = "wifi_signal"
 
-CONF_DEVICE_ID = "device_id"
 CONF_DEVICE_KEY = "device_key"
 
 DEFAULT_NAME = "OpenGarage"
 DEFAULT_PORT = 80
 
-STATE_CLOSING = "closing"
-STATE_OFFLINE = "offline"
-STATE_OPENING = "opening"
-STATE_STOPPED = "stopped"
-
 STATES_MAP = {0: STATE_CLOSED, 1: STATE_OPEN}
 
 COVER_SCHEMA = vol.Schema(
@@ -60,16 +55,15 @@ def setup_platform(hass, config, add_entities, discovery_info=None):
     covers = []
     devices = config.get(CONF_COVERS)
 
-    for device_id, device_config in devices.items():
+    for device_config in devices.values():
         args = {
             CONF_NAME: device_config.get(CONF_NAME),
             CONF_HOST: device_config.get(CONF_HOST),
             CONF_PORT: device_config.get(CONF_PORT),
-            CONF_DEVICE_ID: device_config.get(CONF_DEVICE, device_id),
             CONF_DEVICE_KEY: device_config.get(CONF_DEVICE_KEY),
         }
 
-        covers.append(OpenGarageCover(hass, args))
+        covers.append(OpenGarageCover(args))
 
     add_entities(covers, True)
 
@@ -77,17 +71,14 @@ def setup_platform(hass, config, add_entities, discovery_info=None):
 class OpenGarageCover(CoverDevice):
     """Representation of a OpenGarage cover."""
 
-    def __init__(self, hass, args):
+    def __init__(self, args):
         """Initialize the cover."""
         self.opengarage_url = "http://{}:{}".format(args[CONF_HOST], args[CONF_PORT])
-        self.hass = hass
         self._name = args[CONF_NAME]
-        self.device_id = args["device_id"]
         self._device_key = args[CONF_DEVICE_KEY]
         self._state = None
         self._state_before_move = None
-        self.dist = None
+        self._device_state_attributes = {}
-        self.signal = None
         self._available = True
 
     @property
@@ -103,36 +94,27 @@ class OpenGarageCover(CoverDevice):
     @property
     def device_state_attributes(self):
         """Return the device state attributes."""
-        data = {}
+        return self._device_state_attributes
-
-        if self.signal is not None:
-            data[ATTR_SIGNAL_STRENGTH] = self.signal
-
-        if self.dist is not None:
-            data[ATTR_DISTANCE_SENSOR] = self.dist
-
-        if self._state is not None:
-            data[ATTR_DOOR_STATE] = self._state
-
-        return data
 
     @property
     def is_closed(self):
         """Return if the cover is closed."""
-        if self._state in [STATE_UNKNOWN, STATE_OFFLINE]:
+        if self._state is None:
             return None
         return self._state in [STATE_CLOSED, STATE_OPENING]
 
     def close_cover(self, **kwargs):
         """Close the cover."""
-        if self._state not in [STATE_CLOSED, STATE_CLOSING]:
+        if self._state in [STATE_CLOSED, STATE_CLOSING]:
+            return
         self._state_before_move = self._state
         self._state = STATE_CLOSING
         self._push_button()
 
     def open_cover(self, **kwargs):
         """Open the cover."""
-        if self._state not in [STATE_OPEN, STATE_OPENING]:
+        if self._state in [STATE_OPEN, STATE_OPENING]:
+            return
         self._state_before_move = self._state
         self._state = STATE_OPENING
         self._push_button()
@@ -140,11 +122,19 @@ class OpenGarageCover(CoverDevice):
     def update(self):
         """Get updated status from API."""
         try:
-            status = self._get_status()
+            status = requests.get(
-            if self._name is None:
+                "{}/jc".format(self.opengarage_url), timeout=10
-                if status["name"] is not None:
+            ).json()
+        except requests.exceptions.RequestException as ex:
+            _LOGGER.error(
+                "Unable to connect to OpenGarage device: %(reason)s", dict(reason=ex)
+            )
+            self._available = False
+            return
+
+        if self._name is None and status["name"] is not None:
             self._name = status["name"]
-            state = STATES_MAP.get(status.get("door"), STATE_UNKNOWN)
+        state = STATES_MAP.get(status.get("door"))
         if self._state_before_move is not None:
             if self._state_before_move != state:
                 self._state = state
@@ -153,43 +143,42 @@ class OpenGarageCover(CoverDevice):
             self._state = state
 
         _LOGGER.debug("%s status: %s", self._name, self._state)
-            self.signal = status.get("rssi")
+        if status.get("rssi") is not None:
-            self.dist = status.get("dist")
+            self._device_state_attributes[ATTR_SIGNAL_STRENGTH] = status.get("rssi")
-            self._available = True
+        if status.get("dist") is not None:
-        except requests.exceptions.RequestException as ex:
+            self._device_state_attributes[ATTR_DISTANCE_SENSOR] = status.get("dist")
-            _LOGGER.error(
+        if self._state is not None:
-                "Unable to connect to OpenGarage device: %(reason)s", dict(reason=ex)
+            self._device_state_attributes[ATTR_DOOR_STATE] = self._state
-            )
-            self._state = STATE_OFFLINE
 
-    def _get_status(self):
+        self._available = True
-        """Get latest status."""
-        url = "{}/jc".format(self.opengarage_url)
-        ret = requests.get(url, timeout=10)
-        return ret.json()
 
     def _push_button(self):
         """Send commands to API."""
-        url = "{}/cc?dkey={}&click=1".format(self.opengarage_url, self._device_key)
+        result = -1
         try:
-            response = requests.get(url, timeout=10).json()
+            result = requests.get(
-            if response["result"] == 2:
+                "{}/cc?dkey={}&click=1".format(self.opengarage_url, self._device_key),
-                _LOGGER.error(
+                timeout=10,
-                    "Unable to control %s: Device key is incorrect", self._name
+            ).json()["result"]
-                )
-                self._state = self._state_before_move
-                self._state_before_move = None
         except requests.exceptions.RequestException as ex:
             _LOGGER.error(
                 "Unable to connect to OpenGarage device: %(reason)s", dict(reason=ex)
             )
+        if result == 1:
+            return
+
+        if result == 2:
+            _LOGGER.error("Unable to control %s: Device key is incorrect", self._name)
+        elif result > 2:
+            _LOGGER.error("Unable to control %s: Error code %s", self._name, result)
+
         self._state = self._state_before_move
         self._state_before_move = None
 
     @property
     def device_class(self):
         """Return the class of this device, from component DEVICE_CLASSES."""
-        return "garage"
+        return DEVICE_CLASS_GARAGE
 
     @property
     def supported_features(self):