Config flow for hunterdouglas_powerview

.coveragerc

@@ -311,7 +311,10 @@ omit =
     homeassistant/components/huawei_lte/*
     homeassistant/components/huawei_router/device_tracker.py
     homeassistant/components/hue/light.py
+    homeassistant/components/hunterdouglas_powerview/__init__.py
     homeassistant/components/hunterdouglas_powerview/scene.py
+    homeassistant/components/hunterdouglas_powerview/cover.py
+    homeassistant/components/hunterdouglas_powerview/entity.py
     homeassistant/components/hydrawise/*
     homeassistant/components/hyperion/light.py
     homeassistant/components/ialarm/alarm_control_panel.py

CODEOWNERS

@@ -174,6 +174,7 @@ homeassistant/components/http/* @home-assistant/core
 homeassistant/components/huawei_lte/* @scop
 homeassistant/components/huawei_router/* @abmantis
 homeassistant/components/hue/* @balloob
+homeassistant/components/hunterdouglas_powerview/* @bdraco
 homeassistant/components/iammeter/* @lewei50
 homeassistant/components/iaqualink/* @flz
 homeassistant/components/icloud/* @Quentame

homeassistant/components/hunterdouglas_powerview/__init__.py

@@ -1 +1,194 @@
-"""The hunterdouglas_powerview component."""
+"""The Hunter Douglas PowerView integration."""
+import asyncio
+from datetime import timedelta
+import logging
+
+from aiopvapi.helpers.aiorequest import AioRequest
+from aiopvapi.helpers.constants import ATTR_ID
+from aiopvapi.helpers.tools import base64_to_unicode
+from aiopvapi.rooms import Rooms
+from aiopvapi.scenes import Scenes
+from aiopvapi.shades import Shades
+from aiopvapi.userdata import UserData
+import async_timeout
+import voluptuous as vol
+
+from homeassistant.config_entries import SOURCE_IMPORT, ConfigEntry
+from homeassistant.const import CONF_HOST
+from homeassistant.core import HomeAssistant, callback
+from homeassistant.exceptions import ConfigEntryNotReady
+from homeassistant.helpers.aiohttp_client import async_get_clientsession
+import homeassistant.helpers.config_validation as cv
+from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
+
+from .const import (
+    COORDINATOR,
+    DEVICE_FIRMWARE,
+    DEVICE_INFO,
+    DEVICE_MAC_ADDRESS,
+    DEVICE_MODEL,
+    DEVICE_NAME,
+    DEVICE_REVISION,
+    DEVICE_SERIAL_NUMBER,
+    DOMAIN,
+    FIRMWARE_IN_USERDATA,
+    HUB_EXCEPTIONS,
+    HUB_NAME,
+    MAC_ADDRESS_IN_USERDATA,
+    MAINPROCESSOR_IN_USERDATA_FIRMWARE,
+    MODEL_IN_MAINPROCESSOR,
+    PV_API,
+    PV_ROOM_DATA,
+    PV_SCENE_DATA,
+    PV_SHADE_DATA,
+    PV_SHADES,
+    REVISION_IN_MAINPROCESSOR,
+    ROOM_DATA,
+    SCENE_DATA,
+    SERIAL_NUMBER_IN_USERDATA,
+    SHADE_DATA,
+    USER_DATA,
+)
+
+DEVICE_SCHEMA = vol.Schema(
+    {DOMAIN: vol.Schema({vol.Required(CONF_HOST): cv.string})}, extra=vol.ALLOW_EXTRA
+)
+
+
+def _has_all_unique_hosts(value):
+    """Validate that each hub configured has a unique host."""
+    hosts = [device[CONF_HOST] for device in value]
+    schema = vol.Schema(vol.Unique())
+    schema(hosts)
+    return value
+
+
+CONFIG_SCHEMA = vol.Schema(
+    {DOMAIN: vol.All(cv.ensure_list, [DEVICE_SCHEMA], _has_all_unique_hosts)},
+    extra=vol.ALLOW_EXTRA,
+)
+
+
+PLATFORMS = ["cover", "scene"]
+_LOGGER = logging.getLogger(__name__)
+
+
+async def async_setup(hass: HomeAssistant, hass_config: dict):
+    """Set up the Hunter Douglas PowerView component."""
+    hass.data.setdefault(DOMAIN, {})
+
+    if DOMAIN not in hass_config:
+        return True
+
+    for conf in hass_config[DOMAIN]:
+        hass.async_create_task(
+            hass.config_entries.flow.async_init(
+                DOMAIN, context={"source": SOURCE_IMPORT}, data=conf
+            )
+        )
+
+    return True
+
+
+async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry):
+    """Set up Hunter Douglas PowerView from a config entry."""
+
+    config = entry.data
+
+    hub_address = config.get(CONF_HOST)
+    websession = async_get_clientsession(hass)
+
+    pv_request = AioRequest(hub_address, loop=hass.loop, websession=websession)
+
+    try:
+        async with async_timeout.timeout(10):
+            device_info = await async_get_device_info(pv_request)
+    except HUB_EXCEPTIONS:
+        _LOGGER.error("Connection error to PowerView hub: %s", hub_address)
+        raise ConfigEntryNotReady
+    if not device_info:
+        _LOGGER.error("Unable to initialize PowerView hub: %s", hub_address)
+        raise ConfigEntryNotReady
+
+    rooms = Rooms(pv_request)
+    room_data = _async_map_data_by_id((await rooms.get_resources())[ROOM_DATA])
+
+    scenes = Scenes(pv_request)
+    scene_data = _async_map_data_by_id((await scenes.get_resources())[SCENE_DATA])
+
+    shades = Shades(pv_request)
+    shade_data = _async_map_data_by_id((await shades.get_resources())[SHADE_DATA])
+
+    async def async_update_data():
+        """Fetch data from shade endpoint."""
+        async with async_timeout.timeout(10):
+            shade_entries = await shades.get_resources()
+        if not shade_entries:
+            raise UpdateFailed(f"Failed to fetch new shade data.")
+        return _async_map_data_by_id(shade_entries[SHADE_DATA])
+
+    coordinator = DataUpdateCoordinator(
+        hass,
+        _LOGGER,
+        name="powerview hub",
+        update_method=async_update_data,
+        update_interval=timedelta(seconds=60),
+    )
+
+    hass.data[DOMAIN][entry.entry_id] = {
+        PV_API: pv_request,
+        PV_ROOM_DATA: room_data,
+        PV_SCENE_DATA: scene_data,
+        PV_SHADES: shades,
+        PV_SHADE_DATA: shade_data,
+        COORDINATOR: coordinator,
+        DEVICE_INFO: device_info,
+    }
+
+    for component in PLATFORMS:
+        hass.async_create_task(
+            hass.config_entries.async_forward_entry_setup(entry, component)
+        )
+
+    return True
+
+
+async def async_get_device_info(pv_request):
+    """Determine device info."""
+    userdata = UserData(pv_request)
+    resources = await userdata.get_resources()
+    userdata_data = resources[USER_DATA]
+
+    main_processor_info = userdata_data[FIRMWARE_IN_USERDATA][
+        MAINPROCESSOR_IN_USERDATA_FIRMWARE
+    ]
+    return {
+        DEVICE_NAME: base64_to_unicode(userdata_data[HUB_NAME]),
+        DEVICE_MAC_ADDRESS: userdata_data[MAC_ADDRESS_IN_USERDATA],
+        DEVICE_SERIAL_NUMBER: userdata_data[SERIAL_NUMBER_IN_USERDATA],
+        DEVICE_REVISION: main_processor_info[REVISION_IN_MAINPROCESSOR],
+        DEVICE_FIRMWARE: main_processor_info,
+        DEVICE_MODEL: main_processor_info[MODEL_IN_MAINPROCESSOR],
+    }
+
+
+@callback
+def _async_map_data_by_id(data):
+    """Return a dict with the key being the id for a list of entries."""
+    return {entry[ATTR_ID]: entry for entry in data}
+
+
+async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry):
+    """Unload a config entry."""
+    unload_ok = all(
+        await asyncio.gather(
+            *[
+                hass.config_entries.async_forward_entry_unload(entry, component)
+                for component in PLATFORMS
+            ]
+        )
+    )
+    if unload_ok:
+        hass.data[DOMAIN].pop(entry.entry_id)
+
+    return unload_ok

homeassistant/components/hunterdouglas_powerview/config_flow.py

@@ -0,0 +1,135 @@
+"""Config flow for Hunter Douglas PowerView integration."""
+import logging
+
+from aiopvapi.helpers.aiorequest import AioRequest
+import async_timeout
+import voluptuous as vol
+
+from homeassistant import config_entries, core, exceptions
+from homeassistant.const import CONF_HOST, CONF_NAME
+from homeassistant.helpers.aiohttp_client import async_get_clientsession
+
+from . import async_get_device_info
+from .const import DEVICE_NAME, DEVICE_SERIAL_NUMBER, HUB_EXCEPTIONS
+from .const import DOMAIN  # pylint:disable=unused-import
+
+_LOGGER = logging.getLogger(__name__)
+
+DATA_SCHEMA = vol.Schema({vol.Required(CONF_HOST): str})
+HAP_SUFFIX = "._hap._tcp.local."
+
+
+async def validate_input(hass: core.HomeAssistant, data):
+    """Validate the user input allows us to connect.
+
+    Data has the keys from DATA_SCHEMA with values provided by the user.
+    """
+
+    hub_address = data[CONF_HOST]
+    websession = async_get_clientsession(hass)
+
+    pv_request = AioRequest(hub_address, loop=hass.loop, websession=websession)
+
+    try:
+        async with async_timeout.timeout(10):
+            device_info = await async_get_device_info(pv_request)
+    except HUB_EXCEPTIONS:
+        raise CannotConnect
+    if not device_info:
+        raise CannotConnect
+
+    # Return info that you want to store in the config entry.
+    return {
+        "title": device_info[DEVICE_NAME],
+        "unique_id": device_info[DEVICE_SERIAL_NUMBER],
+    }
+
+
+class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
+    """Handle a config flow for Hunter Douglas PowerView."""
+
+    VERSION = 1
+    CONNECTION_CLASS = config_entries.CONN_CLASS_LOCAL_POLL
+
+    def __init__(self):
+        """Initialize the powerview config flow."""
+        self.powerview_config = {}
+
+    async def async_step_user(self, user_input=None):
+        """Handle the initial step."""
+        errors = {}
+        if user_input is not None:
+            if self._host_already_configured(user_input[CONF_HOST]):
+                return self.async_abort(reason="already_configured")
+            try:
+                info = await validate_input(self.hass, user_input)
+            except CannotConnect:
+                errors["base"] = "cannot_connect"
+            except Exception:  # pylint: disable=broad-except
+                _LOGGER.exception("Unexpected exception")
+                errors["base"] = "unknown"
+
+            if not errors:
+                await self.async_set_unique_id(info["unique_id"])
+                return self.async_create_entry(
+                    title=info["title"], data={CONF_HOST: user_input[CONF_HOST]}
+                )
+
+        return self.async_show_form(
+            step_id="user", data_schema=DATA_SCHEMA, errors=errors
+        )
+
+    async def async_step_import(self, user_input=None):
+        """Handle the initial step."""
+        return await self.async_step_user(user_input)
+
+    async def async_step_homekit(self, homekit_info):
+        """Handle HomeKit discovery."""
+
+        # If we already have the host configured do
+        # not open connections to it if we can avoid it.
+        if self._host_already_configured(homekit_info[CONF_HOST]):
+            return self.async_abort(reason="already_configured")
+
+        try:
+            info = await validate_input(self.hass, homekit_info)
+        except CannotConnect:
+            return self.async_abort(reason="cannot_connect")
+        except Exception:  # pylint: disable=broad-except
+            return self.async_abort(reason="unknown")
+
+        await self.async_set_unique_id(info["unique_id"], raise_on_progress=False)
+        self._abort_if_unique_id_configured({CONF_HOST: homekit_info["host"]})
+
+        name = homekit_info["name"]
+        if name.endswith(HAP_SUFFIX):
+            name = name[: -len(HAP_SUFFIX)]
+
+        self.powerview_config = {
+            CONF_HOST: homekit_info["host"],
+            CONF_NAME: name,
+        }
+        return await self.async_step_link()
+
+    async def async_step_link(self, user_input=None):
+        """Attempt to link with Powerview."""
+        if user_input is not None:
+            return self.async_create_entry(
+                title=self.powerview_config[CONF_NAME],
+                data={CONF_HOST: self.powerview_config[CONF_HOST]},
+            )
+
+        return self.async_show_form(
+            step_id="link", description_placeholders=self.powerview_config
+        )
+
+    def _host_already_configured(self, host):
+        """See if we already have a hub with the host address configured."""
+        existing_hosts = {
+            entry.data[CONF_HOST] for entry in self._async_current_entries()
+        }
+        return host in existing_hosts
+
+
+class CannotConnect(exceptions.HomeAssistantError):
+    """Error to indicate we cannot connect."""