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/commands/MakeNotificationCommand.py

@@ -0,0 +1,40 @@
+"""MakeNotificationCommand Class"""
+from cleo import Command
+from ..utils.filesystem import make_directory
+import inflection
+import os
+
+
+class MakeNotificationCommand(Command):
+    """
+    Creates a new notification class.
+
+    notification
+        {name : Name of the notification}
+    """
+
+    def __init__(self, application):
+        super().__init__()
+        self.app = application
+
+    def handle(self):
+        name = inflection.camelize(self.argument("name"))
+
+        with open(self.get_mailables_path(), "r") as f:
+            content = f.read()
+            content = content.replace("__class__", name)
+
+        file_name = os.path.join(
+            self.app.make("notifications.location").replace(".", "/"), name + ".py"
+        )
+
+        make_directory(file_name)
+
+        with open(file_name, "w") as f:
+            f.write(content)
+        self.info(f"Notification Created ({file_name})")
+
+    def get_mailables_path(self):
+        current_path = os.path.dirname(os.path.realpath(__file__))
+
+        return os.path.join(current_path, "../stubs/notification/Notification.py")

src/masonite/commands/NotificationTableCommand.py

@@ -0,0 +1,37 @@
+"""Notification Table Command."""
+from cleo import Command
+from ..utils.filesystem import make_directory
+import os
+import pathlib
+import datetime
+
+
+class NotificationTableCommand(Command):
+    """
+    Creates the notifications table needed for storing notifications in the database.
+
+    notification:table
+        {--d|--directory=database/migrations : Specifies the directory to create the migration in}
+    """
+
+    def handle(self):
+        now = datetime.datetime.today()
+
+        with open(
+            os.path.join(
+                pathlib.Path(__file__).parent.absolute(),
+                "../",
+                "stubs/notification/create_notifications_table.py",
+            )
+        ) as fp:
+            output = fp.read()
+
+        file_name = f"{now.strftime('%Y_%m_%d_%H%M%S')}_create_notifications_table.py"
+
+        path = os.path.join(os.getcwd(), self.option("directory"), file_name)
+        make_directory(path)
+
+        with open(path, "w") as fp:
+            fp.write(output)
+
+        self.info(f"Migration file created: {file_name}")

src/masonite/commands/__init__.py

@@ -10,3 +10,5 @@
 from .MakeControllerCommand import MakeControllerCommand
 from .MakeJobCommand import MakeJobCommand
 from .MakeMailableCommand import MakeMailableCommand
+from .MakeNotificationCommand import MakeNotificationCommand
+from .NotificationTableCommand import NotificationTableCommand

src/masonite/exceptions/__init__.py

@@ -15,4 +15,5 @@
     DumpException,
     InvalidSecretKey,
     InvalidCSRFToken,
+    NotificationException,
 )

src/masonite/exceptions/exceptions.py

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

src/masonite/foundation/Kernel.py

@@ -13,6 +13,8 @@
     MakeControllerCommand,
     MakeJobCommand,
     MakeMailableCommand,
+    MakeNotificationCommand,
+    NotificationTableCommand,
 )
 import os
 from ..environment import LoadEnvironment
@@ -56,6 +58,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(),
@@ -76,6 +82,8 @@ def register_commands(self):
                 MakeControllerCommand(self.application),
                 MakeJobCommand(self.application),
                 MakeMailableCommand(self.application),
+                MakeNotificationCommand(self.application),
+                NotificationTableCommand(),
             ),
         )
 

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