Config entry options

homeassistant/components/config/config_entries.py

@@ -17,6 +17,10 @@ async def async_setup(hass):
     hass.http.register_view(
         ConfigManagerFlowResourceView(hass.config_entries.flow))
     hass.http.register_view(ConfigManagerAvailableFlowView)
+    hass.http.register_view(
+        OptionManagerFlowIndexView(hass.config_entries.options.flow))
+    hass.http.register_view(
+        OptionManagerFlowResourceView(hass.config_entries.options.flow))
     return True
 
 
@@ -45,15 +49,19 @@ class ConfigManagerEntryIndexView(HomeAssistantView):
     name = 'api:config:config_entries:entry'
 
     async def get(self, request):
-        """List flows in progress."""
+        """List available config entries."""
         hass = request.app['hass']
+
         return self.json([{
             'entry_id': entry.entry_id,
             'domain': entry.domain,
             'title': entry.title,
             'source': entry.source,
             'state': entry.state,
             'connection_class': entry.connection_class,
+            'supports_options': hasattr(
+                config_entries.HANDLERS[entry.domain],
+                'async_get_options_flow'),
         } for entry in hass.config_entries.async_entries()])
 
 
@@ -145,3 +153,48 @@ class ConfigManagerAvailableFlowView(HomeAssistantView):
     async def get(self, request):
         """List available flow handlers."""
         return self.json(config_entries.FLOWS)
+
+
+class OptionManagerFlowIndexView(FlowManagerIndexView):
+    """View to create option flows."""
+
+    url = '/api/config/config_entries/entry/option/flow'
+    name = 'api:config:config_entries:entry:resource:option:flow'
+
+    # pylint: disable=arguments-differ
+    async def post(self, request):
+        """Handle a POST request.
+
+        handler in request is entry_id.
+        """
+        if not request['hass_user'].is_admin:
+            raise Unauthorized(
+                perm_category=CAT_CONFIG_ENTRIES, permission='edit')
+
+        # pylint: disable=no-value-for-parameter
+        return await super().post(request)
+
+
+class OptionManagerFlowResourceView(ConfigManagerFlowResourceView):
+    """View to interact with the option flow manager."""
+
+    url = '/api/config/config_entries/options/flow/{flow_id}'
+    name = 'api:config:config_entries:options:flow:resource'
+
+    async def get(self, request, flow_id):
+        """Get the current state of a data_entry_flow."""
+        if not request['hass_user'].is_admin:
+            raise Unauthorized(
+                perm_category=CAT_CONFIG_ENTRIES, permission='edit')
+
+        return await super().get(request, flow_id)
+
+    # pylint: disable=arguments-differ
+    async def post(self, request, flow_id):
+        """Handle a POST request."""
+        if not request['hass_user'].is_admin:
+            raise Unauthorized(
+                perm_category=CAT_CONFIG_ENTRIES, permission='edit')
+
+        # pylint: disable=no-value-for-parameter
+        return await super().post(request, flow_id)

homeassistant/config_entries.py

@@ -122,15 +122,15 @@ async def async_step_discovery(info):
 import logging
 import functools
 import uuid
-from typing import Set, Optional, List, Dict  # noqa pylint: disable=unused-import
+from typing import Callable, Dict, List, Optional, Set  # noqa pylint: disable=unused-import
+import weakref
 
 from homeassistant import data_entry_flow
 from homeassistant.core import callback, HomeAssistant
 from homeassistant.exceptions import HomeAssistantError, ConfigEntryNotReady
 from homeassistant.setup import async_setup_component, async_process_deps_reqs
 from homeassistant.util.decorator import Registry
 
-
 _LOGGER = logging.getLogger(__name__)
 _UNDEF = object()
 
@@ -221,12 +221,13 @@ async def async_step_discovery(info):
 class ConfigEntry:
     """Hold a configuration entry."""
 
-    __slots__ = ('entry_id', 'version', 'domain', 'title', 'data', 'source',
-                 'connection_class', 'state', '_setup_lock',
-                 '_async_cancel_retry_setup')
+    __slots__ = ('entry_id', 'version', 'domain', 'title', 'data', 'options',
+                 'source', 'connection_class', 'state', '_setup_lock',
+                 'update_listeners', '_async_cancel_retry_setup')
 
     def __init__(self, version: str, domain: str, title: str, data: dict,
                  source: str, connection_class: str,
+                 options: Optional[dict] = None,
                  entry_id: Optional[str] = None,
                  state: str = ENTRY_STATE_NOT_LOADED) -> None:
         """Initialize a config entry."""
@@ -245,6 +246,9 @@ def __init__(self, version: str, domain: str, title: str, data: dict,
         # Config data
         self.data = data
 
+        # Entry options
+        self.options = options or {}
+
         # Source of the configuration (user, discovery, cloud)
         self.source = source
 
@@ -254,6 +258,9 @@ def __init__(self, version: str, domain: str, title: str, data: dict,
         # State of the entry (LOADED, NOT_LOADED)
         self.state = state
 
+        # Listeners to call on update
+        self.update_listeners = []  # type: list
+
         # Function to cancel a scheduled retry
         self._async_cancel_retry_setup = None
 
@@ -384,6 +391,18 @@ async def async_migrate(self, hass: HomeAssistant) -> bool:
                               self.title, component.DOMAIN)
             return False
 
+    def add_update_listener(self, listener: Callable) -> Callable:
+        """Listen for when entry is updated.
+
+        Listener: Callback function(hass, entry)
+
+        Returns function to unlisten.
+        """
+        weak_listener = weakref.ref(listener)
+        self.update_listeners.append(weak_listener)
+
+        return lambda: self.update_listeners.remove(weak_listener)
+
     def as_dict(self):
         """Return dictionary version of this entry."""
         return {
@@ -392,6 +411,7 @@ def as_dict(self):
             'domain': self.domain,
             'title': self.title,
             'data': self.data,
+            'options': self.options,
             'source': self.source,
             'connection_class': self.connection_class,
         }
@@ -416,6 +436,7 @@ def __init__(self, hass: HomeAssistant, hass_config: dict) -> None:
         self.hass = hass
         self.flow = data_entry_flow.FlowManager(
             hass, self._async_create_flow, self._async_finish_flow)
+        self.options = OptionsFlowManager(hass)
         self._hass_config = hass_config
         self._entries = []  # type: List[ConfigEntry]
         self._store = hass.helpers.storage.Store(STORAGE_VERSION, STORAGE_KEY)
@@ -433,6 +454,14 @@ def async_domains(self) -> List[str]:
 
         return result
 
+    @callback
+    def async_get_entry(self, entry_id: str) -> Optional[ConfigEntry]:
+        """Return entry with matching entry_id."""
+        for entry in self._entries:
+            if entry_id == entry.entry_id:
+                return entry
+        return None
+
     @callback
     def async_entries(self, domain: Optional[str] = None) -> List[ConfigEntry]:
         """Return all entries or entries for a specific domain."""
@@ -490,14 +519,25 @@ async def async_load(self) -> None:
                 title=entry['title'],
                 # New in 0.79
                 connection_class=entry.get('connection_class',
-                                           CONN_CLASS_UNKNOWN))
+                                           CONN_CLASS_UNKNOWN),
+                # New in 0.89
+                options=entry.get('options'))
             for entry in config['entries']]
 
     @callback
-    def async_update_entry(self, entry, *, data=_UNDEF):
+    def async_update_entry(self, entry, *, data=_UNDEF, options=_UNDEF):
         """Update a config entry."""
         if data is not _UNDEF:
             entry.data = data
+
+        if options is not _UNDEF:
+            entry.options = options
+
+        if data is not _UNDEF or options is not _UNDEF:
+            for listener_ref in entry.update_listeners:
+                listener = listener_ref()
+                self.hass.async_create_task(listener(self.hass, entry))
+
         self._async_schedule_save()
 
     async def async_forward_entry_setup(self, entry, component):
@@ -547,6 +587,7 @@ async def _async_finish_flow(self, flow, result):
             domain=result['handler'],
             title=result['title'],
             data=result['data'],
+            options={},
             source=flow.context['source'],
             connection_class=flow.CONNECTION_CLASS,
         )
@@ -596,7 +637,7 @@ async def _async_create_flow(self, handler_key, *, context, data):
         flow.init_step = source
         return flow
 
-    def _async_schedule_save(self):
+    def _async_schedule_save(self) -> None:
         """Save the entity registry to a file."""
         self._store.async_delay_save(self._data_to_save, SAVE_DELAY)
 
@@ -629,3 +670,39 @@ def _async_in_progress(self):
         return [flw for flw in self.hass.config_entries.flow.async_progress()
                 if flw['handler'] == self.handler and
                 flw['flow_id'] != self.flow_id]
+
+
+class OptionsFlowManager:
+    """Flow to set options for a configuration entry."""
+
+    def __init__(self, hass: HomeAssistant) -> None:
+        """Initialize the options manager."""
+        self.hass = hass
+        self.flow = data_entry_flow.FlowManager(
+            hass, self._async_create_flow, self._async_finish_flow)
+
+    async def _async_create_flow(self, entry_id, *, context, data):
+        """Create an options flow for a config entry.
+
+        Entry_id and flow.handler is the same thing to map entry with flow.
+        """
+        entry = self.hass.config_entries.async_get_entry(entry_id)
+        if entry is None:
+            return
+        flow = HANDLERS[entry.domain].async_get_options_flow(
+            entry.data, entry.options)
+        return flow
+
+    async def _async_finish_flow(self, flow, result):
+        """Finish an options flow and update options for configuration entry.
+
+        Flow.handler and entry_id is the same thing to map flow with entry.
+        """
+        entry = self.hass.config_entries.async_get_entry(flow.handler)
+        if entry is None:
+            return
+        self.hass.config_entries.async_update_entry(
+            entry, options=result['data'])
+
+        result['result'] = True
+        return result

tests/common.py

@@ -608,13 +608,14 @@ class MockConfigEntry(config_entries.ConfigEntry):
 
     def __init__(self, *, domain='test', data=None, version=1, entry_id=None,
                  source=config_entries.SOURCE_USER, title='Mock Title',
-                 state=None,
+                 state=None, options={},
                  connection_class=config_entries.CONN_CLASS_UNKNOWN):
         """Initialize a mock config entry."""
         kwargs = {
             'entry_id': entry_id or 'mock-id',
             'domain': domain,
             'data': data or {},
+            'options': options,
             'version': version,
             'title': title,
             'connection_class': connection_class,