Revert config_flow

Author: Helvio88

custom_components/bluebubbles/config_flow.py

@@ -1,72 +1,87 @@
-"""The BlueBubbles integration."""
+"""Config flow for BlueBubbles integration."""
 import logging
-import re
 
 import aiohttp
+import voluptuous as vol
 
-from homeassistant.config_entries import ConfigEntry
-from homeassistant.core import HomeAssistant, ServiceCall
+from homeassistant import config_entries
+from homeassistant.const import CONF_HOST
+from homeassistant.helpers import selector
 
-from .const import CONF_HOST, CONF_PASSWORD, CONF_SSL, DOMAIN
+from .const import CONF_PASSWORD, CONF_SSL, DOMAIN
 
 _LOGGER = logging.getLogger(__name__)
 
-PLATFORMS: list[str] = []
 
-
-async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
-    """Set up BlueBubbles from a config entry."""
-
-    hass.data.setdefault(DOMAIN, {})
-    hass.data[DOMAIN][entry.entry_id] = entry.data
-
-    async def send_message(service_call: ServiceCall) -> None:
-        """Handle the send_message service."""
-        conf = entry.data
-        host = conf[CONF_HOST]
-        password = conf[CONF_PASSWORD]
-        ssl = conf[CONF_SSL]
-        private_api = conf.get("private_api", False)
-
-        addresses_str = service_call.data.get("addresses", "").strip()
-        message = service_call.data.get("message", "").strip()
-
-        if not addresses_str:
-            raise ValueError("At least one address is required")
-        if not message:
-            raise ValueError("Message is required")
-
-        # Split by , or ; and trim
-        addresses = [n.strip() for n in re.split(r'[,;]', addresses_str) if n.strip()]
-
-        if not addresses:
-            raise ValueError("No valid addresses provided")
-
-        url = f"{host}/api/v1/chat/new"
-        params = {"password": password}
-        method = "private-api" if private_api else "apple-script"
-        payload = {"addresses": addresses, "message": message, "method": method}
-
-        try:
-            async with aiohttp.ClientSession() as session, session.post(
-                url,
-                json=payload,
-                params=params,
-                ssl=ssl
-            ) as response:
-                response.raise_for_status()
-                _LOGGER.debug("Message sent successfully")
-        except aiohttp.ClientError as err:
-            _LOGGER.error("Error sending message: %s. Payload: %s", err, payload)
-            raise
-
-    hass.services.async_register(DOMAIN, "send_message", send_message)
-
-    return True
-
-
-async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
-    """Unload a config entry."""
-    hass.services.async_remove(DOMAIN, "send_message")
-    hass.data[DOMAIN].pop(entry.entry_id)
-    return True
+class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
+    """Handle a config flow for BlueBubbles."""
+
+    VERSION = 1
+
+    async def async_step_user(self, user_input=None) -> config_entries.ConfigFlowResult:
+        """Handle the initial step."""
+
+        if user_input is not None:
+            errors = {}
+
+            host = user_input[CONF_HOST]
+            password = user_input[CONF_PASSWORD]
+            ssl = user_input[CONF_SSL]
+            url = f"{host}/api/v1/server/info"
+            params = {"password": password}
+
+            try:
+                async with aiohttp.ClientSession() as session, session.get(
+                    url,
+                    params=params,
+                    ssl=ssl
+                ) as response:
+                    response.raise_for_status()
+                    json_data = await response.json()
+                    if json_data.get("status") != 200:
+                        raise ValueError(f"Invalid status in response: {json_data.get('status')}")
+                    data = json_data["data"]
+                    private_api = data["private_api"]
+                    detected_imessage = data["detected_imessage"]
+                    entry_data = user_input.copy()
+                    entry_data["private_api"] = private_api
+                    _LOGGER.debug("Successfully connected to BlueBubbles")
+                    return self.async_create_entry(title=detected_imessage, data=entry_data)
+            except (aiohttp.ClientError, ValueError, KeyError) as err:
+                _LOGGER.error("Error connecting to BlueBubbles: %s", err)
+                errors["base"] = "cannot_connect"
+            except Exception as err:
+                _LOGGER.error("Unexpected error: %s", err)
+                errors["base"] = "unknown"
+
+            return self.async_show_form(
+                step_id="user",
+                data_schema=vol.Schema(
+                    {
+                        vol.Required(CONF_HOST): selector.TextSelector(
+                            selector.TextSelectorConfig(type=selector.TextSelectorType.URL)
+                        ),
+                        vol.Required(CONF_PASSWORD): selector.TextSelector(
+                            selector.TextSelectorConfig(type=selector.TextSelectorType.PASSWORD)
+                        ),
+                        vol.Optional(CONF_SSL, default=False): selector.BooleanSelector(),
+                    }
+                ),
+                errors=errors,
+            )
+
+        return self.async_show_form(
+            step_id="user",
+            data_schema=vol.Schema(
+                {
+                    vol.Required(CONF_HOST): selector.TextSelector(
+                        selector.TextSelectorConfig(type=selector.TextSelectorType.URL)
+                    ),
+                    vol.Required(CONF_PASSWORD): selector.TextSelector(
+                        selector.TextSelectorConfig(type=selector.TextSelectorType.PASSWORD)
+                    ),
+                    vol.Optional(CONF_SSL, default=False): selector.BooleanSelector(),
+                }
+            ),
+            errors={},
+        )