Added push notifications and subscriptions (#103)

* Added subscriptions and expo push tokens

* Changed field type of uuid on subscription model to string

* Added test push token in seeder

* Added push notification ticket error handling

* began with notifications

* notification model is done, created migration, added beforeCreate/beforeDelete for notification in events model

* added tests for subsrcriptions and started making tests for notifications, though hthey need a controller and routes (endpoints)

* can now fetch existing notification in the system by knowing their Id's

* added tests, passing

* added serialization for the updated_at and created_at field

* added filtering to date for notifications

* fixed CI tests, moved 'hooks' outside from the events model... sad. It was pretty. The creation and deletion of notification is now done in EventsController

* added tests

* refactored notification check into an if statement

* moved  to seperate file, is now exported

* added tests for datetime format checking etc

* added nation.oid to notification model

* Added pg-boss scheduler

* Send push notifications on notification model create

* Added receipt fetching to Expo service

* Formatted code

* Fixed subscription callback execution

* Fixed broken tests

* Skipped tests in CI using skipInCi

* Cleaned up push ticket error validation

* Added notification filtering based on token

* Updated insomnia workspace

* Throw error if query push token is invalid

* Added test for making sure only matching notifications are returned

* Formatted code

* moved function so utils file'

* Updated subscription tests

* Skipped removal of notification when deleting events

Co-authored-by: Fredrik Engstrand <[email protected]>
Co-authored-by: Fredrik Engstrand <[email protected]>

Author: McFrappe

.adonisrc.json

@@ -13,7 +13,14 @@
         "Database": "database",
         "Contracts": "contracts"
     },
-    "preloads": ["./start/routes", "./start/kernel"],
+    "preloads": [
+        "./start/routes",
+        "./start/kernel",
+        {
+            "file": "./start/rules",
+            "environment": ["web"]
+        }
+    ],
     "providers": ["./providers/AppProvider", "@adonisjs/core", "@adonisjs/lucid", "@adonisjs/auth"],
     "aceProviders": ["@adonisjs/repl"],
     "metaFiles": [

.env

@@ -3,3 +3,4 @@ HOST=0.0.0.0
 NODE_ENV=development
 APP_KEY=yklM2_A0w5HdcDn22kwHWJS1Mcu4Exra
 DB_CONNECTION=pg
+EXPO_ACCESS_TOKEN=q1nBkAG6kGmV3cD-OYrlCRFEHFAXAstVUGRwjUSD

.insomnia/Workspace/nationskollen.json

@@ -5,18 +5,22 @@
  * @category Controller
  * @module EventsController
  */
+import {
+    getNation,
+    getEvent,
+    getValidatedData,
+} from 'App/Utils/Request'
 import { DateTime } from 'luxon'
 import Event from 'App/Models/Event'
 import { getPageNumber } from 'App/Utils/Paginate'
 import { ExtractScopes } from '@ioc:Adonis/Lucid/Model'
 import { HttpContextContract } from '@ioc:Adonis/Core/HttpContext'
 import { attemptFileUpload, attemptFileRemoval } from 'App/Utils/Upload'
-import { getNation, getEvent, getValidatedData } from 'App/Utils/Request'
+import PaginationValidator from 'App/Validators/PaginationValidator'
 import EventUpdateValidator from 'App/Validators/Events/UpdateValidator'
 import EventCreateValidator from 'App/Validators/Events/CreateValidator'
 import EventUploadValidator from 'App/Validators/Events/UploadValidator'
 import EventFilterValidator from 'App/Validators/Events/FilterValidator'
-import PaginationValidator from 'App/Validators/PaginationValidator'
 
 /**
  * Event controller
@@ -26,7 +30,7 @@ export default class EventsController {
      * Method that applies given filters depedning on what type of event to
      * filter after
      * @param scopes - The different scopes that exists in the system
-     * @param filters - The filder to apply
+     * @param filters - The filter to apply
      */
     private applyFilters(
         scopes: ExtractScopes<typeof Event>,
@@ -37,12 +41,14 @@ export default class EventsController {
             scopes.onDate(filters.date)
         } else {
             if (filters.before) {
-                // Filter based on when the event ends, i.e. all events before a certain date
+                // Filter based on when the event ends, i.e. all events before
+                // a certain date
                 scopes.beforeDate(filters.before)
             }
 
             if (filters.after) {
-                // Filter based on when the event start, i.e. all events after a certain date
+                // Filter based on when the event start, i.e. all events after
+                // a certain date
                 scopes.afterDate(filters.after)
             }
         }
@@ -155,6 +161,8 @@ export default class EventsController {
             await event.preload('category')
         }
 
+        await event.createNotification()
+
         return event.toJSON()
     }
 

app/Controllers/Http/EventsController.ts

@@ -0,0 +1,75 @@
+/**
+ * Implements the endpoints that handles notifications
+ *
+ * @category Controller
+ * @module NotificationsController
+ */
+import { DateTime } from 'luxon'
+import { getPageNumber } from 'App/Utils/Paginate'
+import Notification from 'App/Models/Notification'
+import Subscription from 'App/Models/Subscription'
+import { ExtractScopes } from '@ioc:Adonis/Lucid/Model'
+import { HttpContextContract } from '@ioc:Adonis/Core/HttpContext'
+import PaginationValidator from 'App/Validators/PaginationValidator'
+import { getNotification, getValidatedData } from 'App/Utils/Request'
+import InvalidPushTokenException from 'App/Exceptions/InvalidPushTokenException'
+import NotificationFilterValidator from 'App/Validators/Notifications/FilterValidator'
+
+export default class NotificationsController {
+    /**
+     * Method that applies given filters to notifications
+     *
+     * @param scopes - The different scopes that exists in the system
+     * @param filters - The filter to apply
+     */
+    private applyFilters(
+        scopes: ExtractScopes<typeof Notification>,
+        filters: Record<string, DateTime | undefined>
+    ) {
+        if (filters.after) {
+            // Filter based on when the event start, i.e. all events after a
+            // certain date
+            scopes.afterDate(filters.after)
+        }
+
+        // Order events based on the 'created_at' field
+        scopes.inOrder()
+    }
+
+    /**
+     * Method to retrieve all the notifications in the system
+     * The actual function call is done by a request (CRUD) which are specified
+     * in `Routes.ts`
+     */
+    public async all({ request }: HttpContextContract) {
+        const { after, token } = await getValidatedData(request, NotificationFilterValidator, true)
+        const specified = await getValidatedData(request, PaginationValidator, true)
+
+        const query = Notification.query().apply((scopes) => {
+            this.applyFilters(scopes, { after })
+        })
+
+        if (token) {
+            const subscriptions = await Subscription.forToken(token)
+
+            if (!subscriptions) {
+                throw new InvalidPushTokenException()
+            }
+
+            query.whereIn(
+                ['nation_id', 'subscription_topic_id'],
+                subscriptions.map((subscription) => [
+                    subscription.nationId,
+                    subscription.subscriptionTopicId,
+                ])
+            )
+        }
+
+        const notifications = await query.paginate(getPageNumber(specified.page), specified.amount)
+        return notifications.toJSON()
+    }
+
+    public async index({ request }: HttpContextContract) {
+        return getNotification(request).toJSON()
+    }
+}

app/Controllers/Http/NotificationsController.ts

@@ -0,0 +1,64 @@
+/**
+ * Implements the endpoints that allow users to subscribe and
+ * unsubscribe to topics of a student nation.
+ *
+ * @category Controller
+ * @module SubscriptionsController
+ */
+import PushToken from 'App/Models/PushToken'
+import Subscription from 'App/Models/Subscription'
+import SubscriptionTopic from 'App/Models/SubscriptionTopic'
+import { HttpContextContract } from '@ioc:Adonis/Core/HttpContext'
+import { getSubscription, getValidatedData } from 'App/Utils/Request'
+import PushTokenNotFoundException from 'App/Exceptions/PushTokenNotFoundException'
+import SubscriptionQueryValidator from 'App/Validators/Subscriptions/QueryValidator'
+import SubscriptionCreateValidator from 'App/Validators/Subscriptions/CreateValidator'
+
+export default class SubscriptionsController {
+    /**
+     * Fetch all the available {@link SubscriptionTopic|subscription topics}
+     */
+    public async topics(_: HttpContextContract) {
+        const topics = await SubscriptionTopic.all()
+        return topics.map((topic) => topic.toJSON())
+    }
+
+    /**
+     * Fetch all the subscriptions for a {@link PushToken|push token}
+     */
+    public async all({ request }: HttpContextContract) {
+        const query = await getValidatedData(request, SubscriptionQueryValidator)
+        const pushToken = await PushToken.findBy('token', query.token)
+
+        if (!pushToken) {
+            throw new PushTokenNotFoundException()
+        }
+
+        const subscriptions = await Subscription.query().where('pushTokenId', pushToken.id)
+
+        return subscriptions.map((subscription) => subscription.toJSON())
+    }
+
+    /**
+     * Creates a subscription to a topic for a {@link PushToken|push token}
+     */
+    public async create({ request }: HttpContextContract) {
+        const { oid, topic, token } = await getValidatedData(request, SubscriptionCreateValidator)
+        const pushToken = await PushToken.firstOrCreate({ token })
+        const subscription = await Subscription.firstOrCreate({
+            nationId: oid,
+            pushTokenId: pushToken.id,
+            subscriptionTopicId: topic,
+        })
+
+        return subscription.toJSON()
+    }
+
+    /**
+     * Deletes a subscription to a topic for a {@link PushToken|push token}
+     */
+    public async delete({ request }: HttpContextContract) {
+        const subscription = getSubscription(request)
+        await subscription.delete()
+    }
+}

app/Controllers/Http/SubscriptionsController.ts

@@ -0,0 +1,11 @@
+/**
+ * @category Exceptions
+ * @module InvalidPushTokenException
+ */
+import DefaultException from 'App/Exceptions/DefaultException'
+
+export default class InvalidPushTokenException extends DefaultException {
+    constructor() {
+        super('Invalid push token', 400)
+    }
+}

app/Exceptions/InvalidPushTokenException.ts

@@ -0,0 +1,11 @@
+/**
+ * @category Exceptions
+ * @module NotificationNotFoundException
+ */
+import DefaultException from 'App/Exceptions/DefaultException'
+
+export default class NotificationNotFoundException extends DefaultException {
+    constructor() {
+        super('Could not find notification', 404)
+    }
+}

app/Exceptions/NotificationNotFoundException.ts

@@ -0,0 +1,11 @@
+/**
+ * @category Exceptions
+ * @module PushTokenNotFoundException
+ */
+import DefaultException from 'App/Exceptions/DefaultException'
+
+export default class PushTokenNotFoundException extends DefaultException {
+    constructor() {
+        super('Could not find push token', 404)
+    }
+}

app/Exceptions/PushTokenNotFoundException.ts

@@ -0,0 +1,11 @@
+/**
+ * @category Exceptions
+ * @module SubscriptionNotFoundException
+ */
+import DefaultException from 'App/Exceptions/DefaultException'
+
+export default class SubscriptionNotFoundException extends DefaultException {
+    constructor() {
+        super('Could not find subscription', 404)
+    }
+}

app/Exceptions/SubscriptionNotFoundException.ts

@@ -0,0 +1,29 @@
+/**
+ * Exceptions in this middleware are:
+ *
+ * - {@link NotificationNotFoundException}
+ *
+ * @category Middleware
+ * @module NotifactionMiddleware
+ *
+ */
+
+import Notification from 'App/Models/Notification'
+import { HttpContextContract } from '@ioc:Adonis/Core/HttpContext'
+import NotificationNotFoundException from 'App/Exceptions/NotificationNotFoundException'
+
+export default class NotifactionMiddleware {
+    public async handle({ request, params }: HttpContextContract, next: () => Promise<void>) {
+        let notification: Notification | null
+
+        notification = await Notification.findBy('id', params.nid)
+
+        if (!notification) {
+            throw new NotificationNotFoundException()
+        }
+
+        request.notification = notification
+
+        await next()
+    }
+}

app/Middleware/Notification.ts

@@ -0,0 +1,40 @@
+/**
+ * Exceptions in this middleware are:
+ *
+ * - {@link SubscriptionNotFound}
+ *
+ * @category Middleware
+ * @module SubscriptionMiddleware
+ *
+ */
+
+import Subscription from 'App/Models/Subscription'
+import { HttpContextContract } from '@ioc:Adonis/Core/HttpContext'
+import SubscriptionNotFoundException from 'App/Exceptions/SubscriptionNotFoundException'
+
+export default class SubscriptionMiddleware {
+    public async handle(
+        { request, params }: HttpContextContract,
+        next: () => Promise<void>,
+        options: string[]
+    ) {
+        let subscription: Subscription | null
+
+        if (options.includes('preload')) {
+            subscription = await Subscription.query()
+                .where('uuid', params.uuid)
+                .preload('pushToken')
+                .first()
+        } else {
+            subscription = await Subscription.findBy('uuid', params.uuid)
+        }
+
+        if (!subscription) {
+            throw new SubscriptionNotFoundException()
+        }
+
+        request.subscription = subscription
+
+        await next()
+    }
+}