mos.ru power sensors

appdaemon/settings/apps/notification/target.py

@@ -0,0 +1,128 @@
+"""Define various notification target types."""
+# pylint: disable=too-few-public-methods
+from typing import Dict, List
+
+from const import CONF_PEOPLE
+from core import Base  # pylint: disable=no-name-in-module
+
+
+class Target:
+    """Define a target for generic notifications."""
+
+    def __init__(self, notify_service: str) -> None:
+        """Initialize."""
+        self.payload = {}  # type: Dict[str, str]
+        self.service_call = "notify/{0}".format(notify_service)
+
+
+class SlackTarget(Target):
+    """Define a target for Slack notifications."""
+
+    def __init__(self, channel: str = None, mention: str = None) -> None:
+        """Initialize."""
+        super().__init__("slack")
+
+        if channel:
+            self.payload["target"] = "#{0}".format(channel)
+        if mention:
+            self.payload["message"] = "{0}: ".format(mention)
+
+
+class TargetFactory:
+    """Define an abstract factory."""
+
+    def __init__(self, app: Base, target: str) -> None:
+        """Initialization."""
+        self._app = app
+        self._target = target
+
+    def build(self) -> List:
+        """Build  notification target objects from a string representation."""
+        raise NotImplementedError()
+
+
+class NotifierFactory(TargetFactory):
+    """Define a factory to build generic notification targets."""
+
+    def build(self) -> List[Target]:
+        """Build  notification target objects from a string representation."""
+        return [Target(self._target)]
+
+
+class PersonFactory(TargetFactory):
+    """Define a factory to build notification targets specific to a person."""
+
+    def build(self) -> List[Target]:
+        """Build notification target objects from a string representation."""
+        name = self._target.split("person:")[1]
+
+        try:
+            person = next(
+                (p for p in self._app.global_vars[CONF_PEOPLE] if p.first_name == name)
+            )
+        except StopIteration:
+            self._app.error("Unknown person: {0}".format(self._target))
+            return []
+
+        targets = []  # type: List[Target]
+        for target in person.notifiers:
+            targets += get_targets_from_string(self._app, target)
+
+        return targets
+
+
+class PresenceFactory(TargetFactory):
+    """Define a factory to build notification targets specific to presence."""
+
+    def build(self) -> List[Target]:
+        """Build notification target objects from a string representation."""
+        presence = self._target.split(":")[1]
+        presence_manager = self._app.get_app("presence_manager")
+
+        try:
+            presence_method = getattr(presence_manager, "whos_{0}".format(presence))
+        except AttributeError:
+            self._app.error("Unknown presence target: {0}".format(presence))
+            return []
+
+        targets = []  # type: List[Target]
+        for person in presence_method():
+            for target in person.notifiers:
+                targets += get_targets_from_string(self._app, target)
+
+        return targets
+
+
+class SlackFactory(TargetFactory):
+    """Define a factory to build Slack notification targets."""
+
+    def build(self) -> List[SlackTarget]:
+        """Build notification target objects from a string representation."""
+        data = self._target.split(":")
+
+        if len(data) == 1:
+            return [SlackTarget(None, None)]
+
+        splits = data[1].split("/")
+
+        if len(splits) == 2:
+            return [SlackTarget(splits[0], splits[1])]
+
+        if "@" in splits[0]:
+            return [SlackTarget(None, splits[0])]
+
+        return [SlackTarget(splits[0], None)]
+
+
+def get_targets_from_string(app: Base, target: str) -> List[Target]:
+    """Return the appropriate factory for the passed target."""
+    if target.startswith("person:"):
+        factory = PersonFactory(app, target)
+    elif target.startswith("presence:"):
+        factory = PresenceFactory(app, target)  # type: ignore
+    elif target.startswith("slack:"):
+        factory = SlackFactory(app, target)  # type: ignore
+    else:
+        factory = NotifierFactory(app, target)  # type: ignore
+
+    return factory.build()