Add config flow to NS (home-assistant#151567)

Signed-off-by: Heindrich Paul <[email protected]>
Co-authored-by: Norbert Rittel <[email protected]>
Co-authored-by: Franck Nijhof <[email protected]>
Co-authored-by: Copilot <[email protected]>
Co-authored-by: Joostlek <[email protected]>

Author: 5 people

CODEOWNERS

@@ -1 +1,56 @@
-"""The nederlandse_spoorwegen component."""
+"""The Nederlandse Spoorwegen integration."""
+
+from __future__ import annotations
+
+import logging
+
+from ns_api import NSAPI, RequestParametersError
+import requests
+
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.const import CONF_API_KEY, Platform
+from homeassistant.core import HomeAssistant
+from homeassistant.exceptions import ConfigEntryNotReady
+
+_LOGGER = logging.getLogger(__name__)
+
+
+type NSConfigEntry = ConfigEntry[NSAPI]
+
+PLATFORMS = [Platform.SENSOR]
+
+
+async def async_setup_entry(hass: HomeAssistant, entry: NSConfigEntry) -> bool:
+    """Set up Nederlandse Spoorwegen from a config entry."""
+    api_key = entry.data[CONF_API_KEY]
+
+    client = NSAPI(api_key)
+
+    try:
+        await hass.async_add_executor_job(client.get_stations)
+    except (
+        requests.exceptions.ConnectionError,
+        requests.exceptions.HTTPError,
+    ) as error:
+        _LOGGER.error("Could not connect to the internet: %s", error)
+        raise ConfigEntryNotReady from error
+    except RequestParametersError as error:
+        _LOGGER.error("Could not fetch stations, please check configuration: %s", error)
+        raise ConfigEntryNotReady from error
+
+    entry.runtime_data = client
+
+    entry.async_on_unload(entry.add_update_listener(async_reload_entry))
+
+    await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
+    return True
+
+
+async def async_reload_entry(hass: HomeAssistant, entry: NSConfigEntry) -> None:
+    """Reload NS integration when options are updated."""
+    await hass.config_entries.async_reload(entry.entry_id)
+
+
+async def async_unload_entry(hass: HomeAssistant, entry: NSConfigEntry) -> bool:
+    """Unload a config entry."""
+    return await hass.config_entries.async_unload_platforms(entry, PLATFORMS)

homeassistant/components/nederlandse_spoorwegen/__init__.py

@@ -0,0 +1,176 @@
+"""Config flow for Nederlandse Spoorwegen integration."""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+from ns_api import NSAPI, Station
+from requests.exceptions import (
+    ConnectionError as RequestsConnectionError,
+    HTTPError,
+    Timeout,
+)
+import voluptuous as vol
+
+from homeassistant.config_entries import (
+    ConfigEntry,
+    ConfigFlow,
+    ConfigFlowResult,
+    ConfigSubentryData,
+    ConfigSubentryFlow,
+    SubentryFlowResult,
+)
+from homeassistant.const import CONF_API_KEY
+from homeassistant.core import callback
+from homeassistant.helpers.selector import (
+    SelectOptionDict,
+    SelectSelector,
+    SelectSelectorConfig,
+    TimeSelector,
+)
+
+from .const import (
+    CONF_FROM,
+    CONF_NAME,
+    CONF_ROUTES,
+    CONF_TIME,
+    CONF_TO,
+    CONF_VIA,
+    DOMAIN,
+)
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class NSConfigFlow(ConfigFlow, domain=DOMAIN):
+    """Handle a config flow for Nederlandse Spoorwegen."""
+
+    VERSION = 1
+    MINOR_VERSION = 1
+
+    async def async_step_user(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Handle the initial step of the config flow (API key)."""
+        errors: dict[str, str] = {}
+        if user_input is not None:
+            self._async_abort_entries_match(user_input)
+            client = NSAPI(user_input[CONF_API_KEY])
+            try:
+                await self.hass.async_add_executor_job(client.get_stations)
+            except HTTPError:
+                errors["base"] = "invalid_auth"
+            except (RequestsConnectionError, Timeout):
+                errors["base"] = "cannot_connect"
+            except Exception:
+                _LOGGER.exception("Unexpected exception validating API key")
+                errors["base"] = "unknown"
+            if not errors:
+                return self.async_create_entry(
+                    title="Nederlandse Spoorwegen",
+                    data={CONF_API_KEY: user_input[CONF_API_KEY]},
+                )
+        return self.async_show_form(
+            step_id="user",
+            data_schema=vol.Schema({vol.Required(CONF_API_KEY): str}),
+            errors=errors,
+        )
+
+    async def async_step_import(self, import_data: dict[str, Any]) -> ConfigFlowResult:
+        """Handle import from YAML configuration."""
+        self._async_abort_entries_match({CONF_API_KEY: import_data[CONF_API_KEY]})
+
+        client = NSAPI(import_data[CONF_API_KEY])
+        try:
+            stations = await self.hass.async_add_executor_job(client.get_stations)
+        except HTTPError:
+            return self.async_abort(reason="invalid_auth")
+        except (RequestsConnectionError, Timeout):
+            return self.async_abort(reason="cannot_connect")
+        except Exception:
+            _LOGGER.exception("Unexpected exception validating API key")
+            return self.async_abort(reason="unknown")
+
+        station_codes = {station.code for station in stations}
+
+        subentries: list[ConfigSubentryData] = []
+        for route in import_data.get(CONF_ROUTES, []):
+            # Convert station codes to uppercase for consistency with UI routes
+            for key in (CONF_FROM, CONF_TO, CONF_VIA):
+                if key in route:
+                    route[key] = route[key].upper()
+                    if route[key] not in station_codes:
+                        return self.async_abort(reason="invalid_station")
+
+            subentries.append(
+                ConfigSubentryData(
+                    title=route[CONF_NAME],
+                    subentry_type="route",
+                    data=route,
+                    unique_id=None,
+                )
+            )
+
+        return self.async_create_entry(
+            title="Nederlandse Spoorwegen",
+            data={CONF_API_KEY: import_data[CONF_API_KEY]},
+            subentries=subentries,
+        )
+
+    @classmethod
+    @callback
+    def async_get_supported_subentry_types(
+        cls, config_entry: ConfigEntry
+    ) -> dict[str, type[ConfigSubentryFlow]]:
+        """Return subentries supported by this integration."""
+        return {"route": RouteSubentryFlowHandler}
+
+
+class RouteSubentryFlowHandler(ConfigSubentryFlow):
+    """Handle subentry flow for adding and modifying routes."""
+
+    def __init__(self) -> None:
+        """Initialize route subentry flow."""
+        self.stations: dict[str, Station] = {}
+
+    async def async_step_user(
+        self, user_input: dict[str, Any] | None = None
+    ) -> SubentryFlowResult:
+        """Add a new route subentry."""
+        if user_input is not None:
+            return self.async_create_entry(title=user_input[CONF_NAME], data=user_input)
+        client = NSAPI(self._get_entry().data[CONF_API_KEY])
+        if not self.stations:
+            try:
+                self.stations = {
+                    station.code: station
+                    for station in await self.hass.async_add_executor_job(
+                        client.get_stations
+                    )
+                }
+            except (RequestsConnectionError, Timeout, HTTPError, ValueError):
+                return self.async_abort(reason="cannot_connect")
+
+        options = [
+            SelectOptionDict(label=station.names["long"], value=code)
+            for code, station in self.stations.items()
+        ]
+        return self.async_show_form(
+            step_id="user",
+            data_schema=vol.Schema(
+                {
+                    vol.Required(CONF_NAME): str,
+                    vol.Required(CONF_FROM): SelectSelector(
+                        SelectSelectorConfig(options=options, sort=True),
+                    ),
+                    vol.Required(CONF_TO): SelectSelector(
+                        SelectSelectorConfig(options=options, sort=True),
+                    ),
+                    vol.Optional(CONF_VIA): SelectSelector(
+                        SelectSelectorConfig(options=options, sort=True),
+                    ),
+                    vol.Optional(CONF_TIME): TimeSelector(),
+                }
+            ),
+        )

homeassistant/components/nederlandse_spoorwegen/config_flow.py

@@ -0,0 +1,17 @@
+"""Constants for the Nederlandse Spoorwegen integration."""
+
+DOMAIN = "nederlandse_spoorwegen"
+
+CONF_ROUTES = "routes"
+CONF_FROM = "from"
+CONF_TO = "to"
+CONF_VIA = "via"
+CONF_TIME = "time"
+CONF_NAME = "name"
+
+# Attribute and schema keys
+ATTR_ROUTE = "route"
+ATTR_TRIPS = "trips"
+ATTR_FIRST_TRIP = "first_trip"
+ATTR_NEXT_TRIP = "next_trip"
+ATTR_ROUTES = "routes"

homeassistant/components/nederlandse_spoorwegen/const.py

@@ -1,8 +1,10 @@
 {
   "domain": "nederlandse_spoorwegen",
   "name": "Nederlandse Spoorwegen (NS)",
-  "codeowners": ["@YarmoM"],
+  "codeowners": ["@YarmoM", "@heindrichpaul"],
+  "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/nederlandse_spoorwegen",
+  "integration_type": "service",
   "iot_class": "cloud_polling",
   "quality_scale": "legacy",
   "requirements": ["nsapi==3.1.2"]