Add read-only calendar from url

homeassistant/components/local_calendar/calendar.py

@@ -26,14 +26,18 @@
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers.entity_platform import AddEntitiesCallback
+from homeassistant.helpers.event import async_track_time_interval
+from homeassistant.helpers.httpx_client import get_async_client
 from homeassistant.util import dt as dt_util
 
-from .const import CONF_CALENDAR_NAME, DOMAIN
+from .const import CONF_CALENDAR_NAME, CONF_CALENDAR_URL, CONF_SYNC_INTERVAL, DOMAIN
 from .store import LocalCalendarStore
 
 _LOGGER = logging.getLogger(__name__)
 
 PRODID = "-//homeassistant.io//local_calendar 1.0//EN"
+DEFAULT_SYNC_INTERVAL = timedelta(days=1)
+MIN_SYNC_INTERVAL = timedelta(hours=1)
 
 
 async def async_setup_entry(
@@ -48,21 +52,34 @@
         IcsCalendarStream.calendar_from_ics, ics
     )
     calendar.prodid = PRODID
-
     name = config_entry.data[CONF_CALENDAR_NAME]
-    entity = LocalCalendarEntity(store, calendar, name, unique_id=config_entry.entry_id)
+    url = config_entry.data.get(CONF_CALENDAR_URL)
+    if url:
+        update_interval = config_entry.data.get(CONF_SYNC_INTERVAL)
+        if update_interval:
+            update_interval = timedelta(**update_interval)
+        else:
+            update_interval = DEFAULT_SYNC_INTERVAL
+        update_interval = max(update_interval, MIN_SYNC_INTERVAL)
+        entity: LocalCalendarEntityBase = RemoteCalendarEntity(
+            store,
+            calendar,
+            name,
+            unique_id=config_entry.entry_id,
+            url=url,
+            update_interval=update_interval,
+        )
+    else:
+        entity = LocalCalendarEntity(
+            store, calendar, name, unique_id=config_entry.entry_id
+        )
     async_add_entities([entity], True)
 
 
-class LocalCalendarEntity(CalendarEntity):
-    """A calendar entity backed by a local iCalendar file."""
+class LocalCalendarEntityBase(CalendarEntity):
+    """Class for a read-only calendar entity backed by a local iCalendar file."""
 
     _attr_has_entity_name = True
-    _attr_supported_features = (
-        CalendarEntityFeature.CREATE_EVENT
-        | CalendarEntityFeature.DELETE_EVENT
-        | CalendarEntityFeature.UPDATE_EVENT
-    )
 
     def __init__(
         self,
@@ -71,7 +88,7 @@
         name: str,
         unique_id: str,
     ) -> None:
-        """Initialize LocalCalendarEntity."""
+        """Initialize LocalCalendarEntityBase."""
         self._store = store
         self._calendar = calendar
         self._event: CalendarEvent | None = None
@@ -107,6 +124,71 @@
         content = IcsCalendarStream.calendar_to_ics(self._calendar)
         await self._store.async_store(content)
 
+
+class RemoteCalendarEntity(LocalCalendarEntityBase):
+    """A read-only calendar that we get and refresh from a url."""
+
+    def __init__(
+        self,
+        store: LocalCalendarStore,
+        calendar: Calendar,
+        name: str,
+        unique_id: str,
+        url: str,
+        update_interval: timedelta,
+    ) -> None:
+        """Initialize a remote read-only calendar."""
+        super().__init__(store, calendar, name, unique_id)
+        self._url = url
+        self._client = None
+        self._track_fetch = None
+        self._etag = None
+        self._update_interval = update_interval
+
+    async def _fetch_calendar_and_update(self):
+        headers = {}
+        if self._etag:
+            headers["If-None-Match"] = self._etag
+        res = await self._client.get(self._url, headers=headers)
+        if res.status_code == 304:  # Not modified
+            return
+        res.raise_for_status()
+        self._etag = res.headers.get("ETag")
+        self._calendar = await self.hass.async_add_executor_job(
+            IcsCalendarStream.calendar_from_ics, res.text
+        )
+        self._calendar.prodid = PRODID
+        content = await self.hass.async_add_executor_job(
+            IcsCalendarStream.calendar_to_ics, self._calendar
+        )
+        await self._store.async_store(content)
+        await self.async_update_ha_state(force_refresh=True)
+
+    async def async_added_to_hass(self):
+        """Once initialized, get the calendar, and schedule future updates."""
+        self._client = get_async_client(self.hass)
+        self.hass.loop.create_task(self._fetch_calendar_and_update())
+        self._track_fetch = async_track_time_interval(
+            self.hass,
+            lambda now: self.hass.loop.create_task(self._fetch_calendar_and_update()),
+            self._update_interval,
+        )
+
+    async def async_will_remove_from_hass(self):
+        """If the entity is removed, we do not need to keep fetching the calendar."""
+        if self._track_fetch is not None:
+            self._track_fetch()
+
+
+class LocalCalendarEntity(LocalCalendarEntityBase):
+    """A calendar entity backed by a local iCalendar file."""
+
+    _attr_supported_features = (
+        CalendarEntityFeature.CREATE_EVENT
+        | CalendarEntityFeature.DELETE_EVENT
+        | CalendarEntityFeature.UPDATE_EVENT
+    )
+
     async def async_create_event(self, **kwargs: Any) -> None:
         """Add a new event to calendar."""
         event = _parse_event(kwargs)

homeassistant/components/local_calendar/config_flow.py

@@ -2,18 +2,44 @@
 
 from __future__ import annotations
 
+import logging
 from typing import Any
 
+import httpx
 import voluptuous as vol
 
 from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
+from homeassistant.helpers.httpx_client import get_async_client
+from homeassistant.helpers.selector import (
+    DurationSelector,
+    DurationSelectorConfig,
+    TextSelector,
+    TextSelectorConfig,
+    TextSelectorType,
+)
 from homeassistant.util import slugify
 
-from .const import CONF_CALENDAR_NAME, CONF_STORAGE_KEY, DOMAIN
+from .const import (
+    CONF_CALENDAR_NAME,
+    CONF_CALENDAR_URL,
+    CONF_STORAGE_KEY,
+    CONF_SYNC_INTERVAL,
+    DOMAIN,
+)
+
+_LOGGER = logging.getLogger(__name__)
 
 STEP_USER_DATA_SCHEMA = vol.Schema(
     {
         vol.Required(CONF_CALENDAR_NAME): str,
+        vol.Optional(CONF_CALENDAR_URL): TextSelector(
+            TextSelectorConfig(type=TextSelectorType.URL)
+        ),
+        vol.Optional(CONF_SYNC_INTERVAL): DurationSelector(
+            DurationSelectorConfig(
+                enable_day=True, enable_millisecond=False, allow_negative=False
+            )
+        ),
     }
 )
 
@@ -35,6 +61,31 @@
         key = slugify(user_input[CONF_CALENDAR_NAME])
         self._async_abort_entries_match({CONF_STORAGE_KEY: key})
         user_input[CONF_STORAGE_KEY] = key
+        if url := user_input.get(CONF_CALENDAR_URL):
+            try:
+                vol.Schema(vol.Url())(url)
+            except vol.Invalid:
+                return self.async_show_form(
+                    step_id="user",
+                    data_schema=self.add_suggested_values_to_schema(
+                        data_schema=STEP_USER_DATA_SCHEMA, suggested_values=user_input
+                    ),
+                    errors={CONF_CALENDAR_URL: "invalid_url"},
+                    last_step=True,
+                )
+            client = get_async_client(self.hass)
+            res = await client.get(url)
+            try:
+                res.raise_for_status()
+            except httpx.HTTPError:
+                return self.async_show_form(
+                    step_id="user",
+                    data_schema=self.add_suggested_values_to_schema(
+                        data_schema=STEP_USER_DATA_SCHEMA, suggested_values=user_input
+                    ),
+                    errors={CONF_CALENDAR_URL: "cannot_connect"},
+                    last_step=True,
+                )
         return self.async_create_entry(
             title=user_input[CONF_CALENDAR_NAME], data=user_input
         )

homeassistant/components/local_calendar/const.py

@@ -3,4 +3,6 @@
 DOMAIN = "local_calendar"
 
 CONF_CALENDAR_NAME = "calendar_name"
+CONF_CALENDAR_URL = "calendar_url"
 CONF_STORAGE_KEY = "storage_key"
+CONF_SYNC_INTERVAL = "update_interval"

homeassistant/components/local_calendar/strings.json

@@ -1,11 +1,17 @@
 {
   "title": "Local Calendar",
   "config": {
+    "error": {
+      "cannot_connect": "can't connect to URL",
+      "invalid_url": "Invalid URL"
+    },
     "step": {
       "user": {
         "description": "Please choose a name for your new calendar",
         "data": {
-          "calendar_name": "Calendar Name"
+          "calendar_name": "Calendar Name",
+          "calendar_url": "Calendar URL. If given, create a read-only calendar.",
+          "update_interval": "Update interval (applies to read-only calendars)"
         }
       }
     }