* Correct google calendar test name * Rewrite calendar component * Save component in hass.data. * Rename device_state_attributes to state_attributes. * Remove offset attribute from base state_attributes. * Extract offset helpers to calendar component. * Clean imports. * Remove stale constants. * Remove name and add async_get_events. * Add normalize_event helper function. Copied from #21495. * Add event property to base entity. * Use event property for calendar state. * Ensure event start and end. * Remove entity init. * Add comment about event data class. * Temporary keep old start and end datetime format. * Convert demo calendar * Convert google calendar * Convert google calendar. * Clean up google component. * Keep offset feature by using offset helpers. * Convert caldav calendar * Clean up caldav calendar. * Update caldav cal on addition. * Bring back offset to caldav calendar. * Copy caldav event on update. * Convert todoist calendar
213 lines
6.5 KiB
Python
213 lines
6.5 KiB
Python
"""Support for Google Calendar event device sensors."""
|
|
from datetime import timedelta
|
|
import logging
|
|
import re
|
|
|
|
from aiohttp import web
|
|
|
|
from homeassistant.components import http
|
|
from homeassistant.const import STATE_OFF, STATE_ON
|
|
from homeassistant.helpers.config_validation import ( # noqa
|
|
PLATFORM_SCHEMA, PLATFORM_SCHEMA_BASE, time_period_str)
|
|
from homeassistant.helpers.entity import Entity
|
|
from homeassistant.helpers.entity_component import EntityComponent
|
|
from homeassistant.helpers.template import DATE_STR_FORMAT
|
|
from homeassistant.util import dt
|
|
|
|
_LOGGER = logging.getLogger(__name__)
|
|
|
|
DOMAIN = 'calendar'
|
|
ENTITY_ID_FORMAT = DOMAIN + '.{}'
|
|
SCAN_INTERVAL = timedelta(seconds=60)
|
|
|
|
|
|
async def async_setup(hass, config):
|
|
"""Track states and offer events for calendars."""
|
|
component = hass.data[DOMAIN] = EntityComponent(
|
|
_LOGGER, DOMAIN, hass, SCAN_INTERVAL, DOMAIN)
|
|
|
|
hass.http.register_view(CalendarListView(component))
|
|
hass.http.register_view(CalendarEventView(component))
|
|
|
|
# Doesn't work in prod builds of the frontend: home-assistant-polymer#1289
|
|
# hass.components.frontend.async_register_built_in_panel(
|
|
# 'calendar', 'calendar', 'hass:calendar')
|
|
|
|
await component.async_setup(config)
|
|
return True
|
|
|
|
|
|
def get_date(date):
|
|
"""Get the dateTime from date or dateTime as a local."""
|
|
if 'date' in date:
|
|
return dt.start_of_local_day(dt.dt.datetime.combine(
|
|
dt.parse_date(date['date']), dt.dt.time.min))
|
|
return dt.as_local(dt.parse_datetime(date['dateTime']))
|
|
|
|
|
|
def normalize_event(event):
|
|
"""Normalize a calendar event."""
|
|
normalized_event = {}
|
|
|
|
start = event.get('start')
|
|
end = event.get('end')
|
|
start = get_date(start) if start is not None else None
|
|
end = get_date(end) if end is not None else None
|
|
normalized_event['dt_start'] = start
|
|
normalized_event['dt_end'] = end
|
|
|
|
start = start.strftime(DATE_STR_FORMAT) if start is not None else None
|
|
end = end.strftime(DATE_STR_FORMAT) if end is not None else None
|
|
normalized_event['start'] = start
|
|
normalized_event['end'] = end
|
|
|
|
# cleanup the string so we don't have a bunch of double+ spaces
|
|
summary = event.get('summary', '')
|
|
normalized_event['message'] = re.sub(' +', '', summary).strip()
|
|
normalized_event['location'] = event.get('location', '')
|
|
normalized_event['description'] = event.get('description', '')
|
|
normalized_event['all_day'] = 'date' in event['start']
|
|
|
|
return normalized_event
|
|
|
|
|
|
def calculate_offset(event, offset):
|
|
"""Calculate event offset.
|
|
|
|
Return the updated event with the offset_time included.
|
|
"""
|
|
summary = event.get('summary', '')
|
|
# check if we have an offset tag in the message
|
|
# time is HH:MM or MM
|
|
reg = '{}([+-]?[0-9]{{0,2}}(:[0-9]{{0,2}})?)'.format(offset)
|
|
search = re.search(reg, summary)
|
|
if search and search.group(1):
|
|
time = search.group(1)
|
|
if ':' not in time:
|
|
if time[0] == '+' or time[0] == '-':
|
|
time = '{}0:{}'.format(time[0], time[1:])
|
|
else:
|
|
time = '0:{}'.format(time)
|
|
|
|
offset_time = time_period_str(time)
|
|
summary = (
|
|
summary[:search.start()] + summary[search.end():]).strip()
|
|
event['summary'] = summary
|
|
else:
|
|
offset_time = dt.dt.timedelta() # default it
|
|
|
|
event['offset_time'] = offset_time
|
|
return event
|
|
|
|
|
|
def is_offset_reached(event):
|
|
"""Have we reached the offset time specified in the event title."""
|
|
start = get_date(event['start'])
|
|
if start is None or event['offset_time'] == dt.dt.timedelta():
|
|
return False
|
|
|
|
return start + event['offset_time'] <= dt.now(start.tzinfo)
|
|
|
|
|
|
class CalendarEventDevice(Entity):
|
|
"""A calendar event device."""
|
|
|
|
@property
|
|
def event(self):
|
|
"""Return the next upcoming event."""
|
|
raise NotImplementedError()
|
|
|
|
@property
|
|
def state_attributes(self):
|
|
"""Return the entity state attributes."""
|
|
event = self.event
|
|
if event is None:
|
|
return None
|
|
|
|
event = normalize_event(event)
|
|
return {
|
|
'message': event['message'],
|
|
'all_day': event['all_day'],
|
|
'start_time': event['start'],
|
|
'end_time': event['end'],
|
|
'location': event['location'],
|
|
'description': event['description'],
|
|
}
|
|
|
|
@property
|
|
def state(self):
|
|
"""Return the state of the calendar event."""
|
|
event = self.event
|
|
if event is None:
|
|
return STATE_OFF
|
|
|
|
event = normalize_event(event)
|
|
start = event['dt_start']
|
|
end = event['dt_end']
|
|
|
|
if start is None or end is None:
|
|
return STATE_OFF
|
|
|
|
now = dt.now()
|
|
|
|
if start <= now < end:
|
|
return STATE_ON
|
|
|
|
return STATE_OFF
|
|
|
|
async def async_get_events(self, hass, start_date, end_date):
|
|
"""Return calendar events within a datetime range."""
|
|
raise NotImplementedError()
|
|
|
|
|
|
class CalendarEventView(http.HomeAssistantView):
|
|
"""View to retrieve calendar content."""
|
|
|
|
url = '/api/calendars/{entity_id}'
|
|
name = 'api:calendars:calendar'
|
|
|
|
def __init__(self, component):
|
|
"""Initialize calendar view."""
|
|
self.component = component
|
|
|
|
async def get(self, request, entity_id):
|
|
"""Return calendar events."""
|
|
entity = self.component.get_entity(entity_id)
|
|
start = request.query.get('start')
|
|
end = request.query.get('end')
|
|
if None in (start, end, entity):
|
|
return web.Response(status=400)
|
|
try:
|
|
start_date = dt.parse_datetime(start)
|
|
end_date = dt.parse_datetime(end)
|
|
except (ValueError, AttributeError):
|
|
return web.Response(status=400)
|
|
event_list = await entity.async_get_events(
|
|
request.app['hass'], start_date, end_date)
|
|
return self.json(event_list)
|
|
|
|
|
|
class CalendarListView(http.HomeAssistantView):
|
|
"""View to retrieve calendar list."""
|
|
|
|
url = '/api/calendars'
|
|
name = "api:calendars"
|
|
|
|
def __init__(self, component):
|
|
"""Initialize calendar view."""
|
|
self.component = component
|
|
|
|
async def get(self, request):
|
|
"""Retrieve calendar list."""
|
|
hass = request.app['hass']
|
|
calendar_list = []
|
|
|
|
for entity in self.component.entities:
|
|
state = hass.states.get(entity.entity_id)
|
|
calendar_list.append({
|
|
"name": state.name,
|
|
"entity_id": entity.entity_id,
|
|
})
|
|
|
|
return self.json(sorted(calendar_list, key=lambda x: x['name']))
|