255 lines
7.7 KiB
Python
255 lines
7.7 KiB
Python
"""Provides functionality to notify people."""
|
|
import asyncio
|
|
from functools import partial
|
|
import logging
|
|
from typing import Optional
|
|
|
|
import voluptuous as vol
|
|
|
|
from homeassistant.const import CONF_NAME, CONF_PLATFORM
|
|
from homeassistant.exceptions import HomeAssistantError
|
|
from homeassistant.helpers import config_per_platform, discovery
|
|
import homeassistant.helpers.config_validation as cv
|
|
from homeassistant.helpers.typing import HomeAssistantType
|
|
from homeassistant.loader import bind_hass
|
|
from homeassistant.setup import async_prepare_setup_platform
|
|
from homeassistant.util import slugify
|
|
|
|
# mypy: allow-untyped-defs, no-check-untyped-defs
|
|
|
|
_LOGGER = logging.getLogger(__name__)
|
|
|
|
# Platform specific data
|
|
ATTR_DATA = "data"
|
|
|
|
# Text to notify user of
|
|
ATTR_MESSAGE = "message"
|
|
|
|
# Target of the notification (user, device, etc)
|
|
ATTR_TARGET = "target"
|
|
|
|
# Title of notification
|
|
ATTR_TITLE = "title"
|
|
ATTR_TITLE_DEFAULT = "Home Assistant"
|
|
|
|
DOMAIN = "notify"
|
|
|
|
SERVICE_NOTIFY = "notify"
|
|
|
|
NOTIFY_SERVICES = "notify_services"
|
|
SERVICE = "service"
|
|
TARGETS = "targets"
|
|
FRIENDLY_NAME = "friendly_name"
|
|
TARGET_FRIENDLY_NAME = "target_friendly_name"
|
|
|
|
PLATFORM_SCHEMA = vol.Schema(
|
|
{vol.Required(CONF_PLATFORM): cv.string, vol.Optional(CONF_NAME): cv.string},
|
|
extra=vol.ALLOW_EXTRA,
|
|
)
|
|
|
|
NOTIFY_SERVICE_SCHEMA = vol.Schema(
|
|
{
|
|
vol.Required(ATTR_MESSAGE): cv.template,
|
|
vol.Optional(ATTR_TITLE): cv.template,
|
|
vol.Optional(ATTR_TARGET): vol.All(cv.ensure_list, [cv.string]),
|
|
vol.Optional(ATTR_DATA): dict,
|
|
}
|
|
)
|
|
|
|
|
|
@bind_hass
|
|
async def async_reload(hass, integration_name):
|
|
"""Register notify services for an integration."""
|
|
if (
|
|
NOTIFY_SERVICES not in hass.data
|
|
or integration_name not in hass.data[NOTIFY_SERVICES]
|
|
):
|
|
return
|
|
|
|
tasks = [
|
|
_async_setup_notify_services(hass, data)
|
|
for data in hass.data[NOTIFY_SERVICES][integration_name]
|
|
]
|
|
await asyncio.gather(*tasks)
|
|
|
|
|
|
async def _async_setup_notify_services(hass, data):
|
|
"""Create or remove the notify services."""
|
|
notify_service = data[SERVICE]
|
|
friendly_name = data[FRIENDLY_NAME]
|
|
targets = data[TARGETS]
|
|
|
|
async def _async_notify_message(service):
|
|
"""Handle sending notification message service calls."""
|
|
await _async_notify_message_service(hass, service, notify_service, targets)
|
|
|
|
if hasattr(notify_service, "targets"):
|
|
target_friendly_name = data[TARGET_FRIENDLY_NAME]
|
|
stale_targets = set(targets)
|
|
|
|
for name, target in notify_service.targets.items():
|
|
target_name = slugify(f"{target_friendly_name}_{name}")
|
|
if target_name in stale_targets:
|
|
stale_targets.remove(target_name)
|
|
if target_name in targets:
|
|
continue
|
|
targets[target_name] = target
|
|
hass.services.async_register(
|
|
DOMAIN,
|
|
target_name,
|
|
_async_notify_message,
|
|
schema=NOTIFY_SERVICE_SCHEMA,
|
|
)
|
|
|
|
for stale_target_name in stale_targets:
|
|
del targets[stale_target_name]
|
|
hass.services.async_remove(
|
|
DOMAIN,
|
|
stale_target_name,
|
|
)
|
|
|
|
friendly_name_slug = slugify(friendly_name)
|
|
if hass.services.has_service(DOMAIN, friendly_name_slug):
|
|
return
|
|
|
|
hass.services.async_register(
|
|
DOMAIN,
|
|
friendly_name_slug,
|
|
_async_notify_message,
|
|
schema=NOTIFY_SERVICE_SCHEMA,
|
|
)
|
|
|
|
|
|
async def _async_notify_message_service(hass, service, notify_service, targets):
|
|
"""Handle sending notification message service calls."""
|
|
kwargs = {}
|
|
message = service.data[ATTR_MESSAGE]
|
|
title = service.data.get(ATTR_TITLE)
|
|
|
|
if title:
|
|
title.hass = hass
|
|
kwargs[ATTR_TITLE] = title.async_render()
|
|
|
|
if targets.get(service.service) is not None:
|
|
kwargs[ATTR_TARGET] = [targets[service.service]]
|
|
elif service.data.get(ATTR_TARGET) is not None:
|
|
kwargs[ATTR_TARGET] = service.data.get(ATTR_TARGET)
|
|
|
|
message.hass = hass
|
|
kwargs[ATTR_MESSAGE] = message.async_render()
|
|
kwargs[ATTR_DATA] = service.data.get(ATTR_DATA)
|
|
|
|
await notify_service.async_send_message(**kwargs)
|
|
|
|
|
|
async def async_setup(hass, config):
|
|
"""Set up the notify services."""
|
|
hass.data.setdefault(NOTIFY_SERVICES, {})
|
|
|
|
async def async_setup_platform(
|
|
integration_name, p_config=None, discovery_info=None
|
|
):
|
|
"""Set up a notify platform."""
|
|
if p_config is None:
|
|
p_config = {}
|
|
|
|
platform = await async_prepare_setup_platform(
|
|
hass, config, DOMAIN, integration_name
|
|
)
|
|
|
|
if platform is None:
|
|
_LOGGER.error("Unknown notification service specified")
|
|
return
|
|
|
|
_LOGGER.info("Setting up %s.%s", DOMAIN, integration_name)
|
|
notify_service = None
|
|
try:
|
|
if hasattr(platform, "async_get_service"):
|
|
notify_service = await platform.async_get_service(
|
|
hass, p_config, discovery_info
|
|
)
|
|
elif hasattr(platform, "get_service"):
|
|
notify_service = await hass.async_add_job(
|
|
platform.get_service, hass, p_config, discovery_info
|
|
)
|
|
else:
|
|
raise HomeAssistantError("Invalid notify platform.")
|
|
|
|
if notify_service is None:
|
|
# Platforms can decide not to create a service based
|
|
# on discovery data.
|
|
if discovery_info is None:
|
|
_LOGGER.error(
|
|
"Failed to initialize notification service %s", integration_name
|
|
)
|
|
return
|
|
|
|
except Exception: # pylint: disable=broad-except
|
|
_LOGGER.exception("Error setting up platform %s", integration_name)
|
|
return
|
|
|
|
notify_service.hass = hass
|
|
|
|
if discovery_info is None:
|
|
discovery_info = {}
|
|
|
|
target_friendly_name = (
|
|
p_config.get(CONF_NAME) or discovery_info.get(CONF_NAME) or integration_name
|
|
)
|
|
friendly_name = (
|
|
p_config.get(CONF_NAME) or discovery_info.get(CONF_NAME) or SERVICE_NOTIFY
|
|
)
|
|
|
|
data = {
|
|
FRIENDLY_NAME: friendly_name,
|
|
# The targets use a slightly different friendly name
|
|
# selection pattern than the base service
|
|
TARGET_FRIENDLY_NAME: target_friendly_name,
|
|
SERVICE: notify_service,
|
|
TARGETS: {},
|
|
}
|
|
hass.data[NOTIFY_SERVICES].setdefault(integration_name, [])
|
|
hass.data[NOTIFY_SERVICES][integration_name].append(data)
|
|
|
|
await _async_setup_notify_services(hass, data)
|
|
|
|
hass.config.components.add(f"{DOMAIN}.{integration_name}")
|
|
|
|
return True
|
|
|
|
setup_tasks = [
|
|
async_setup_platform(integration_name, p_config)
|
|
for integration_name, p_config in config_per_platform(config, DOMAIN)
|
|
]
|
|
|
|
if setup_tasks:
|
|
await asyncio.wait(setup_tasks)
|
|
|
|
async def async_platform_discovered(platform, info):
|
|
"""Handle for discovered platform."""
|
|
await async_setup_platform(platform, discovery_info=info)
|
|
|
|
discovery.async_listen_platform(hass, DOMAIN, async_platform_discovered)
|
|
|
|
return True
|
|
|
|
|
|
class BaseNotificationService:
|
|
"""An abstract class for notification services."""
|
|
|
|
hass: Optional[HomeAssistantType] = None
|
|
|
|
def send_message(self, message, **kwargs):
|
|
"""Send a message.
|
|
|
|
kwargs can contain ATTR_TITLE to specify a title.
|
|
"""
|
|
raise NotImplementedError()
|
|
|
|
async def async_send_message(self, message, **kwargs):
|
|
"""Send a message.
|
|
|
|
kwargs can contain ATTR_TITLE to specify a title.
|
|
"""
|
|
await self.hass.async_add_job(partial(self.send_message, message, **kwargs))
|