Add notifications

requirements.txt

@@ -3,4 +3,7 @@ black
 cryptography
 masonite-orm
 python-dotenv
-waitress
+waitress
+responses
+slackblocks
+hashids

setup.py

@@ -125,6 +125,8 @@
             "boto3",
             "pusher",
             "pymemcache",
+            "vonage",
+            "slackblocks",
         ],
     },
     # If there are data files included in your packages that need to be

src/masonite/exceptions/__init__.py

@@ -15,5 +15,6 @@
     DumpException,
     InvalidSecretKey,
     InvalidCSRFToken,
+    NotificationException,
     InvalidToken,
 )

src/masonite/exceptions/exceptions.py

@@ -108,3 +108,7 @@ class ProjectProviderHttpError(Exception):
 
 class ProjectTargetNotEmpty(Exception):
     pass
+
+
+class NotificationException(Exception):
+    pass

src/masonite/foundation/Kernel.py

@@ -57,6 +57,10 @@ def register_framework(self):
 
         self.application.bind("base_url", "http://localhost:8000")
 
+        self.application.bind(
+            "notifications.location", "tests/integrations/notifications"
+        )
+
         self.application.bind(
             "router",
             Router(),

src/masonite/notification/AnonymousNotifiable.py

@@ -0,0 +1,39 @@
+"""Anonymous Notifiable mixin"""
+
+from .Notifiable import Notifiable
+
+
+class AnonymousNotifiable(Notifiable):
+    """Anonymous notifiable allowing to send notification without having
+    a notifiable entity.
+
+    Usage:
+        self.notification.route("sms", "+3346474764").send(WelcomeNotification())
+    """
+
+    def __init__(self, application=None):
+        self.application = application
+        self._routes = {}
+
+    def route(self, driver, recipient):
+        """Define which driver using to route the notification."""
+        if driver == "database":
+            raise ValueError(
+                "The database driver does not support on-demand notifications."
+            )
+        self._routes[driver] = recipient
+        return self
+
+    def route_notification_for(self, driver):
+        try:
+            return self._routes[driver]
+        except KeyError:
+            raise ValueError(
+                "Routing has not been defined for the driver {}".format(driver)
+            )
+
+    def send(self, notification, dry=False, fail_silently=False):
+        """Send the given notification."""
+        return self.application.make("notification").send(
+            self, notification, self._routes, dry, fail_silently
+        )

src/masonite/notification/DatabaseNotification.py

@@ -0,0 +1,38 @@
+"""DatabaseNotification Model."""
+import pendulum
+from masoniteorm.relationships import morph_to
+from masoniteorm.models import Model
+
+
+class DatabaseNotification(Model):
+    """DatabaseNotification Model allowing notifications to be stored in database."""
+
+    __fillable__ = ["id", "type", "data", "read_at", "notifiable_id", "notifiable_type"]
+    __table__ = "notifications"
+
+    @morph_to("notifiable_type", "notifiable_id")
+    def notifiable(self):
+        """Get the notifiable entity that the notification belongs to."""
+        return
+
+    def mark_as_read(self):
+        """Mark the notification as read."""
+        if not self.read_at:
+            self.read_at = pendulum.now()
+            return self.save(query=True)
+
+    def mark_as_unread(self):
+        """Mark the notification as unread."""
+        if self.read_at:
+            self.read_at = None
+            return self.save(query=True)
+
+    @property
+    def is_read(self):
+        """Determine if a notification has been read."""
+        return self.read_at is not None
+
+    @property
+    def is_unread(self):
+        """Determine if a notification has not been read yet."""
+        return self.read_at is None

src/masonite/notification/MockNotification.py

@@ -0,0 +1,120 @@
+from .NotificationManager import NotificationManager
+from .AnonymousNotifiable import AnonymousNotifiable
+from .Notification import Notification
+
+
+class NotificationWithAsserts(Notification):
+    def assertSentVia(self, *drivers):
+        sent_via = self.via(self.notifiable)
+        for driver in drivers:
+            assert (
+                driver in sent_via
+            ), f"notification sent via {sent_via}, not {driver}."
+        return self
+
+    def assertEqual(self, value, reference):
+        assert value == reference, "{value} not equal to {reference}."
+        return self
+
+    def assertNotEqual(self, value, reference):
+        assert value != reference, "{value} equal to {reference}."
+        return self
+
+    def assertIn(self, value, container):
+        assert value in container, "{value} not in {container}."
+        return self
+
+    @classmethod
+    def patch(cls, target):
+        for k in cls.__dict__:
+            obj = getattr(cls, k)
+            if not k.startswith("_") and callable(obj):
+                setattr(target, k, obj)
+
+
+class MockNotification(NotificationManager):
+    def __init__(self, application, *args, **kwargs):
+        super().__init__(application, *args, **kwargs)
+        self.count = 0
+        self.last_notifiable = None
+        self.last_notification = None
+
+    def send(
+        self, notifiables, notification, drivers=[], dry=False, fail_silently=False
+    ):
+        _notifiables = []
+        for notifiable in self._format_notifiables(notifiables):
+            if isinstance(notifiable, AnonymousNotifiable):
+                _notifiables.extend(notifiable._routes.values())
+            else:
+                _notifiables.append(notifiable)
+
+        notification_key = notification.type()
+        NotificationWithAsserts.patch(notification.__class__)
+        for notifiable in _notifiables:
+            notification.notifiable = notifiable  # for asserts
+            old_notifs = self.sent_notifications.get(notifiable, {})
+            old_notifs.update(
+                {
+                    notification_key: old_notifs.get(notification_key, [])
+                    + [notification]
+                }
+            )
+            self.sent_notifications.update({notifiable: old_notifs})
+            self.count += 1
+        self.last_notification = notification
+        self.last_notifiable = notifiable
+        return self
+
+    def resetCount(self):
+        """Reset sent notifications count."""
+        self.count = 0
+        self.sent_notifications = {}
+        self.last_notifiable = None
+        self.last_notification = None
+        return self
+
+    def assertNothingSent(self):
+        assert self.count == 0, f"{self.count} notifications have been sent."
+        return self
+
+    def assertCount(self, count):
+        assert (
+            self.count == count
+        ), f"{self.count} notifications have been sent, not {count}."
+        return self
+
+    def assertSentTo(
+        self, notifiable, notification_class, callable_assert=None, count=None
+    ):
+        notification_key = notification_class.__name__
+        notifiable_notifications = self.sent_notifications.get(notifiable, [])
+        assert notification_key in notifiable_notifications
+        if count:
+            sent_count = len(notifiable_notifications.get(notification_key, []))
+            assert (
+                sent_count == count
+            ), f"{notification_key} has been sent to {notifiable} {sent_count} times"
+        if callable_assert:
+            # assert last notification sent for this notifiable
+            notification = notifiable_notifications.get(notification_key)[-1]
+            assert callable_assert(notifiable, notification)
+        return self
+
+    def last(self):
+        """Get last sent mocked notification if any."""
+        return self.last_notification
+
+    def assertLast(self, callable_assert):
+        if not self.last_notifiable or not self.last_notification:
+            raise AssertionError("No notification has been sent.")
+        assert callable_assert(self.last_notifiable, self.last_notification)
+        return self
+
+    def assertNotSentTo(self, notifiable, notification_class):
+        notification_key = notification_class.__name__
+        notifiable_notifications = self.sent_notifications.get(notifiable, [])
+        assert (
+            notification_key not in notifiable_notifications
+        ), f"{notification_key} has been sent to {notifiable}."
+        return self

src/masonite/notification/Notifiable.py

@@ -0,0 +1,63 @@
+"""Notifiable mixin"""
+from masoniteorm.relationships import has_many
+
+from .DatabaseNotification import DatabaseNotification
+from ..exceptions.exceptions import NotificationException
+
+
+class Notifiable:
+    """Notifiable mixin allowing to send notification to a model. It's often used with the
+    User model.
+
+    Usage:
+        user.notify(WelcomeNotification())
+    """
+
+    def notify(self, notification, drivers=[], dry=False, fail_silently=False):
+        """Send the given notification."""
+        from wsgi import application
+
+        return application.make("notification").send(
+            self, notification, drivers, dry, fail_silently
+        )
+
+    def route_notification_for(self, driver):
+        """Get the notification routing information for the given driver. If method has not been
+        defined on the model: for mail driver try to use 'email' field of model."""
+        # check if routing has been specified on the model
+        method_name = "route_notification_for_{0}".format(driver)
+
+        try:
+            method = getattr(self, method_name)
+            return method()
+        except AttributeError:
+            # if no method is defined on notifiable use default
+            if driver == "database":
+                # with database channel, notifications are saved to database
+                pass
+            elif driver == "mail":
+                return self.email
+            else:
+                raise NotificationException(
+                    "Notifiable model does not implement {}".format(method_name)
+                )
+
+    @has_many("id", "notifiable_id")
+    def notifications(self):
+        """Get all notifications sent to the model instance. Only for 'database'
+        notifications."""
+        return DatabaseNotification.where("notifiable_type", "users").order_by(
+            "created_at", direction="DESC"
+        )
+
+    @property
+    def unread_notifications(self):
+        """Get the model instance unread notifications. Only for 'database'
+        notifications."""
+        return self.notifications.where("read_at", "==", None)
+
+    @property
+    def read_notifications(self):
+        """Get the model instance read notifications. Only for 'database'
+        notifications."""
+        return self.notifications.where("read_at", "!=", None)

src/masonite/notification/Notification.py

@@ -0,0 +1,39 @@
+"""Base Notification facade."""
+
+
+class Notification:
+    def via(self, notifiable):
+        """Defines the notification's delivery channels."""
+        raise NotImplementedError("via() method should be implemented.")
+
+    def should_send(self):
+        return True
+
+    def ignore_errors(self):
+        return False
+
+    def broadcast_on(self):
+        return "broadcast"
+
+    @classmethod
+    def type(cls):
+        """Get notification type defined with class name."""
+        return cls.__name__
+
+    def dry(self):
+        """Sets whether the notification should be sent or not.
+
+        Returns:
+            self
+        """
+        self._dry = True
+        return self
+
+    def fail_silently(self):
+        """Sets whether the notification can fail silently (without raising exceptions).
+
+        Returns:
+            self
+        """
+        self._fail_silently = True
+        return self