Show rotating category name in event summary if pickup is scheduled in ridwell (#152529)

Author: kylehakala

homeassistant/components/ridwell/__init__.py

@@ -20,12 +20,18 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     coordinator = RidwellDataUpdateCoordinator(hass, entry)
     await coordinator.async_initialize()
     hass.data.setdefault(DOMAIN, {})[entry.entry_id] = coordinator
+    entry.async_on_unload(entry.add_update_listener(options_update_listener))
 
     await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
 
     return True
 
 
+async def options_update_listener(hass: HomeAssistant, entry: ConfigEntry) -> None:
+    """Handle options update."""
+    await hass.config_entries.async_reload(entry.entry_id)
+
+
 async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     """Unload a config entry."""
     if unload_ok := await hass.config_entries.async_unload_platforms(entry, PLATFORMS):

homeassistant/components/ridwell/calendar.py

@@ -4,31 +4,60 @@
 
 import datetime
 
-from aioridwell.model import RidwellAccount, RidwellPickupEvent
+from aioridwell.model import PickupCategory, RidwellAccount, RidwellPickupEvent
 
 from homeassistant.components.calendar import CalendarEntity, CalendarEvent
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
-from .const import DOMAIN
+from .const import (
+    CALENDAR_TITLE_NONE,
+    CALENDAR_TITLE_ROTATING,
+    CALENDAR_TITLE_STATUS,
+    CONF_CALENDAR_TITLE,
+    DOMAIN,
+)
 from .coordinator import RidwellDataUpdateCoordinator
 from .entity import RidwellEntity
 
 
 @callback
 def async_get_calendar_event_from_pickup_event(
-    pickup_event: RidwellPickupEvent,
+    pickup_event: RidwellPickupEvent, config_entry: ConfigEntry
 ) -> CalendarEvent:
     """Get a HASS CalendarEvent from an aioridwell PickupEvent."""
-    pickup_type_string = ", ".join(
-        [
-            f"{pickup.name} (quantity: {pickup.quantity})"
-            for pickup in pickup_event.pickups
-        ]
-    )
+    pickup_items = []
+    rotating_category = ""
+    calendar_preference = config_entry.options.get(CONF_CALENDAR_TITLE, False)
+    for pickup in pickup_event.pickups:
+        pickup_items.append(f"{pickup.name} (quantity: {pickup.quantity})")
+        if pickup.category == PickupCategory.ROTATING:
+            rotating_category = pickup.name
+            break
+
+    pickup_type_string = ", ".join(pickup_items)
+    pickup_event_state = pickup_event.state.value
+    summary_base = "Ridwell Pickup"
+
+    if calendar_preference == CALENDAR_TITLE_STATUS:
+        # Use state of pickup_event (e.g., scheduled, skipped, notified, etc).
+        summary = f"{summary_base} ({pickup_event_state})"
+    elif calendar_preference == CALENDAR_TITLE_ROTATING:
+        # Use name of Rotating Category for the pickup_event.
+        if rotating_category:
+            summary = f"{summary_base} ({rotating_category})"
+        else:
+            summary = f"{summary_base} ({pickup_event_state})"
+    elif calendar_preference == CALENDAR_TITLE_NONE:
+        # Include only a basic title for the event.
+        summary = summary_base
+    else:
+        # Default to pickup status if no selection is made (e.g., scheduled, skipped, etc).
+        summary = f"{summary_base} ({pickup_event_state})"
+
     return CalendarEvent(
-        summary=f"Ridwell Pickup ({pickup_event.state.value})",
+        summary=summary,
         description=f"Pickup types: {pickup_type_string}",
         start=pickup_event.pickup_date,
         end=pickup_event.pickup_date + datetime.timedelta(days=1),
@@ -67,7 +96,9 @@ def __init__(
     @property
     def event(self) -> CalendarEvent | None:
         """Return the next upcoming event."""
-        return async_get_calendar_event_from_pickup_event(self.next_pickup_event)
+        return async_get_calendar_event_from_pickup_event(
+            self.next_pickup_event, self.coordinator.config_entry
+        )
 
     async def async_get_events(
         self,
@@ -77,6 +108,8 @@ async def async_get_events(
     ) -> list[CalendarEvent]:
         """Return calendar events within a datetime range."""
         return [
-            async_get_calendar_event_from_pickup_event(event)
+            async_get_calendar_event_from_pickup_event(
+                event, self.coordinator.config_entry
+            )
             for event in self.coordinator.data[self._account.account_id]
         ]

homeassistant/components/ridwell/config_flow.py

@@ -9,11 +9,16 @@
 from aioridwell.errors import InvalidCredentialsError, RidwellError
 import voluptuous as vol
 
-from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
+from homeassistant.config_entries import ConfigEntry, ConfigFlow, ConfigFlowResult
 from homeassistant.const import CONF_PASSWORD, CONF_USERNAME
-from homeassistant.helpers import aiohttp_client, config_validation as cv
+from homeassistant.core import callback
+from homeassistant.helpers import aiohttp_client, config_validation as cv, selector
+from homeassistant.helpers.schema_config_entry_flow import (
+    SchemaFlowFormStep,
+    SchemaOptionsFlowHandler,
+)
 
-from .const import DOMAIN, LOGGER
+from .const import CALENDAR_TITLE_OPTIONS, CONF_CALENDAR_TITLE, DOMAIN, LOGGER
 
 STEP_REAUTH_CONFIRM_DATA_SCHEMA = vol.Schema(
     {
@@ -28,6 +33,24 @@
     }
 )
 
+OPTIONS_SCHEMA = vol.Schema(
+    {
+        vol.Optional(CONF_CALENDAR_TITLE): selector.SelectSelector(
+            selector.SelectSelectorConfig(
+                options=CALENDAR_TITLE_OPTIONS,
+                multiple=False,
+                mode=selector.SelectSelectorMode.LIST,
+                translation_key=CONF_CALENDAR_TITLE,
+            ),
+        )
+    }
+)
+
+
+OPTIONS_FLOW = {
+    "init": SchemaFlowFormStep(OPTIONS_SCHEMA),
+}
+
 
 class RidwellConfigFlow(ConfigFlow, domain=DOMAIN):
     """Handle a config flow for Ridwell."""
@@ -81,6 +104,23 @@ async def _async_validate(
             data={CONF_USERNAME: self._username, CONF_PASSWORD: self._password},
         )
 
+    @staticmethod
+    @callback
+    def async_get_options_flow(
+        config_entry: ConfigEntry,
+    ) -> SchemaOptionsFlowHandler:
+        """Get options flow for this handler."""
+        try:
+            schema_options_flow_handler = SchemaOptionsFlowHandler(
+                config_entry, OPTIONS_FLOW
+            )
+        except SystemError as err:
+            LOGGER.error("Unknown System error: %s", err)
+        except RidwellError as err:
+            LOGGER.error("Unknown Ridwell error: %s", err)
+
+        return schema_options_flow_handler
+
     async def async_step_reauth(
         self, entry_data: Mapping[str, Any]
     ) -> ConfigFlowResult:

homeassistant/components/ridwell/const.py

@@ -7,3 +7,15 @@
 LOGGER = logging.getLogger(__package__)
 
 SENSOR_TYPE_NEXT_PICKUP = "next_pickup"
+
+CONF_CALENDAR_TITLE = "conf_calendar_title"
+
+CALENDAR_TITLE_STATUS = "pickup_status"
+CALENDAR_TITLE_ROTATING = "rotating_category"
+CALENDAR_TITLE_NONE = "no_detail"
+
+CALENDAR_TITLE_OPTIONS = [
+    CALENDAR_TITLE_STATUS,
+    CALENDAR_TITLE_ROTATING,
+    CALENDAR_TITLE_NONE,
+]

homeassistant/components/ridwell/strings.json

@@ -36,5 +36,27 @@
         "name": "Opt-in to next pickup"
       }
     }
+  },
+  "options": {
+    "step": {
+      "init": {
+        "description": "Customize how Ridwell events appear in Home Assistant.",
+        "data": {
+          "conf_calendar_title": "Event summary details"
+        },
+        "data_description": {
+          "conf_calendar_title": "Details included (in parentheses) after the event summary/title can be the pickup state, the name of the next rotating category, or no details at all."
+        }
+      }
+    }
+  },
+  "selector": {
+    "conf_calendar_title": {
+      "options": {
+        "no_detail": "No details",
+        "pickup_status": "Pickup status",
+        "rotating_category": "Rotating category"
+      }
+    }
   }
 }

tests/components/ridwell/test_calendar.py

@@ -0,0 +1,141 @@
+"""Test Ridwell calendar platform."""
+
+from datetime import date
+
+from aioridwell.model import EventState, RidwellPickup, RidwellPickupEvent
+import pytest
+
+from homeassistant.components.calendar import CalendarEvent
+from homeassistant.components.ridwell.calendar import (
+    async_get_calendar_event_from_pickup_event,
+)
+from homeassistant.components.ridwell.const import (
+    CALENDAR_TITLE_NONE,
+    CALENDAR_TITLE_ROTATING,
+    CALENDAR_TITLE_STATUS,
+    CONF_CALENDAR_TITLE,
+)
+from homeassistant.core import HomeAssistant
+
+START_DATE = date(2025, 10, 4)
+END_DATE = date(2025, 10, 5)
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    (
+        "pickup_name",
+        "event_state",
+        "summary_style",
+        "expected_description",
+        "expected_summary",
+    ),
+    [
+        # Valid events that should be converted.
+        # Pickup name of "Cork" is used to produce PickupCategory.ROTATING,
+        # and "Plastic Film" is used to generate a PickupCategory.STANDARD pickup.
+        (
+            "Cork",
+            EventState.SCHEDULED,
+            CALENDAR_TITLE_ROTATING,  # Display Rotating Category in summary.
+            "Pickup types: Cork (quantity: 1)",
+            "Ridwell Pickup (Cork)",
+        ),
+        (
+            "Cork",
+            EventState.SCHEDULED,
+            CALENDAR_TITLE_NONE,  # Display no extra info in summary.
+            "Pickup types: Cork (quantity: 1)",
+            "Ridwell Pickup",
+        ),
+        (
+            "Cork",
+            EventState.INITIALIZED,
+            CALENDAR_TITLE_ROTATING,  # Display Rotating Category in summary.
+            "Pickup types: Cork (quantity: 1)",
+            "Ridwell Pickup (Cork)",
+        ),
+        (
+            "Cork",
+            EventState.SKIPPED,
+            CALENDAR_TITLE_STATUS,  # Display pickup state in summary.
+            "Pickup types: Cork (quantity: 1)",
+            "Ridwell Pickup (skipped)",
+        ),
+        (
+            "Cork",
+            EventState.INITIALIZED,
+            CALENDAR_TITLE_STATUS,  # Display pickup state in summary.
+            "Pickup types: Cork (quantity: 1)",
+            "Ridwell Pickup (initialized)",
+        ),
+        (
+            "Cork",
+            EventState.UNKNOWN,
+            CALENDAR_TITLE_STATUS,  # Display pickup state in summary.
+            "Pickup types: Cork (quantity: 1)",
+            "Ridwell Pickup (unknown)",
+        ),
+    ],
+)
+async def test_calendar_event_varied_states_and_types(
+    hass: HomeAssistant,
+    config_entry,
+    pickup_name: str,
+    event_state: EventState,
+    expected_description: str,
+    expected_summary: str,
+    summary_style: str,
+) -> None:
+    """Test CalendarEvent output based on pickup type and event state."""
+
+    # Set calendar config to default
+    hass.config_entries.async_update_entry(
+        config_entry,
+        options={CONF_CALENDAR_TITLE: summary_style},
+    )
+    await hass.async_block_till_done()
+
+    # Create test pickup
+    pickup = RidwellPickup(
+        name=pickup_name,
+        offer_id=f"offer_{pickup_name.lower()}",
+        quantity=1,
+        product_id=f"product_{pickup_name.lower()}",
+        priority=1,
+    )
+
+    # Create test pickup event with the given state
+    pickup_event = RidwellPickupEvent(
+        _async_request=None,
+        event_id=f"event_{pickup_name.lower()}_{event_state.name.lower()}",
+        pickup_date=START_DATE,
+        pickups=[pickup],
+        state=event_state,
+    )
+
+    # Call the function under test
+    event = async_get_calendar_event_from_pickup_event(pickup_event, config_entry)
+
+    assert isinstance(event, CalendarEvent)
+    assert event.summary == expected_summary
+    assert event.description == expected_description
+    assert event.start == START_DATE
+    assert event.end == END_DATE
+
+
+async def test_calendar_event_with_no_pickups(
+    hass: HomeAssistant,
+    config_entry,
+) -> None:
+    """Test empty pickups."""
+    pickup_event = RidwellPickupEvent(
+        _async_request=None,
+        event_id="event_empty",
+        pickup_date=START_DATE,
+        pickups=[],
+        state=EventState.SCHEDULED,
+    )
+
+    event = async_get_calendar_event_from_pickup_event(pickup_event, config_entry)
+    assert event.description == "Pickup types: "