Add the ability to emit platform wide notifications

forge/db/models/User.js

@@ -4,6 +4,7 @@
  */
 const { DataTypes, Op, fn, col, where } = require('sequelize')
 
+const { Roles } = require('../../lib/roles.js')
 const { hash, generateUserAvatar, buildPaginationSearchClause } = require('../utils')
 
 module.exports = {
@@ -279,6 +280,47 @@ module.exports = {
                         count,
                         users: rows
                     }
+                },
+                /**
+                 * Get users with a particular role
+                 * @param {Array} roles An array of valid user roles
+                 * @param {Object} options Options
+                 * @param {Boolean} options.summary whether to return a limited user object that only contains id: default false
+                 * @returns Array of users who have at least one of the specific roles
+                 */
+                byTeamRole: async (roles = [], options) => {
+                    options = {
+                        summary: false,
+                        count: false,
+                        ...options
+                    }
+                    let attributes
+                    if (options.summary) {
+                        attributes = ['id']
+                    }
+                    const includesAdmins = roles.includes(Roles.Admin)
+                    const where = {
+                        [Op.or]: [
+                            includesAdmins ? { admin: true } : {},
+                            { '$TeamMembers.role$': { [Op.in]: roles } }
+                        ]
+                    }
+                    const query = {
+                        where,
+                        include: {
+                            model: M.TeamMember,
+                            attributes: ['role']
+                        }
+                    }
+                    if (!options.count) {
+                        query.attributes = attributes
+                        return M.User.findAll(query)
+                    } else {
+                        // Must set distinct otherwise Model.count will include
+                        // users in multiple teams multiple times.
+                        query.distinct = true
+                        return M.User.count(query)
+                    }
                 }
             },
             instance: {

forge/lib/permissions.js

@@ -10,6 +10,7 @@ const Permissions = {
     'user:edit': { description: 'Edit User Information', role: Roles.Admin, self: true },
     'user:delete': { description: 'Delete User', role: Roles.Admin, self: true },
     'user:team:list': { description: 'List a Users teams', role: Roles.Admin, self: true },
+    'user:announcements:manage': { description: 'Manage platform wide announcements', role: Roles.Admin },
     // Team Scoped Actions
     'team:create': { description: 'Create Team' },
     'team:list': { description: 'List Teams', role: Roles.Admin },

forge/notifications/index.js

@@ -45,6 +45,43 @@ module.exports = fp(async function (app, _opts) {
         })
     }
 
+    /**
+     * Sends a notification to muliple users. This does not deal with updating existing
+     * or superseding notifications as provided by the `send` function.
+     * @param {array} users who the notification is for
+     * @param {string} type the type of the notification
+     * @param {Object} data meta data for the notification - specific to the type
+     * @param {string} reference a key that can be used to lookup this notification, for example: `invite:HASHID`
+     */
+    async function sendBulk (userList, type, data, reference = null) {
+        const SEND_BATCH_SIZE = 200
+        const transaction = await app.db.sequelize.transaction()
+        try {
+            app.log.info(`Sending notification ${reference} to ${userList.length} users`)
+            let index = 0
+            let notifications = []
+            while (index < userList.length) {
+                notifications.push({
+                    UserId: userList[index].id,
+                    type,
+                    reference,
+                    data
+                })
+                if (notifications.length === SEND_BATCH_SIZE || index === userList.length - 1) {
+                    await app.db.models.Notification.bulkCreate(notifications)
+                    notifications = []
+                }
+                index++
+            }
+            await transaction.commit()
+            app.log.info(`Completed sending notification ${reference} to ${userList.length} users`)
+        } catch (error) {
+            await transaction.rollback()
+            app.log.error(`Error sending notification ${reference}: ${error.toString()}`)
+            throw error
+        }
+    }
+
     /**
      * Remove a notification for a user with the given reference.
      * For example, when an invite is accepted/rejected, we can clear the associated notification
@@ -60,6 +97,7 @@ module.exports = fp(async function (app, _opts) {
 
     app.decorate('notifications', {
         send,
+        sendBulk,
         remove
     })
 }, { name: 'app.notifications' })

forge/routes/api/admin.js

@@ -1,5 +1,7 @@
 const { Op } = require('sequelize')
 
+const { Roles } = require('../../lib/roles.js')
+
 module.exports = async function (app) {
     async function getStats () {
         const userCount = await app.db.models.User.count({ attributes: ['admin'], group: 'admin' })
@@ -392,4 +394,81 @@ module.exports = async function (app) {
         await app.db.controllers.AccessToken.removePlatformStatisticsToken()
         reply.send({ status: 'okay' })
     })
+
+    app.post('/announcements', {
+        preHandler: app.needsPermission('user:announcements:manage'),
+        schema: {
+            summary: 'Send platform wide announcements',
+            tags: ['Platform', 'Notifications', 'Announcements'],
+            body: {
+                type: 'object',
+                required: ['message', 'title', 'filter'],
+                properties: {
+                    message: { type: 'string' },
+                    title: { type: 'string' },
+                    filter: {
+                        type: 'object',
+                        properties: {
+                            roles: { type: 'array', items: { type: 'number' } }
+                        }
+                    },
+                    mock: { type: 'boolean' },
+                    to: { type: 'object' },
+                    url: { type: 'string' }
+                }
+            },
+            response: {
+                200: {
+                    type: 'object',
+                    properties: {
+                        recipientCount: { type: 'number' },
+                        mock: { type: 'boolean' }
+                    }
+                },
+                '4xx': {
+                    $ref: 'APIError'
+                }
+            }
+        }
+    }, async (request, reply) => {
+        const {
+            title,
+            message,
+            filter,
+            mock,
+            to,
+            url
+        } = request.body
+
+        const recipientRoles = filter?.roles
+        if (recipientRoles && !recipientRoles.every(value => Object.values(Roles).includes(value))) {
+            return reply.code(400).send({ code: 'bad_request', error: 'Invalid Role provided.' })
+        }
+        if (mock) {
+            // If mock is sent, return an indication of how many users would receive this notification
+            // without actually sending them.
+            const count = await app.db.models.User.byTeamRole(recipientRoles, { summary: true, count: true })
+            reply.send({
+                mock: true,
+                recipientCount: count
+            })
+            return
+        }
+
+        const recipients = await app.db.models.User.byTeamRole(recipientRoles, { summary: true })
+        const notificationType = 'announcement'
+        const titleSlug = title.replace(/[^a-zA-Z0-9-]/g, '-').toLowerCase()
+        const uniqueId = Date.now().toString(36) + Math.random().toString(36).substring(2)
+        const reference = `${uniqueId}:${titleSlug}`
+        const data = { title, message, ...(to && { to }), ...(url && { url }) }
+        await app.notifications.sendBulk(
+            recipients,
+            notificationType,
+            data,
+            reference
+        )
+        reply.send({
+            recipientCount: recipients.length
+        })
+    })
 }

frontend/src/api/admin.js

@@ -51,11 +51,27 @@ const generateStatsAccessToken = async () => {
         return res.data
     })
 }
+
 const deleteStatsAccessToken = async () => {
     return client.delete('/api/v1/admin/stats-token').then(res => {
         return res.data
     })
 }
+
+const getAnnouncementNotifications = async () => {
+    return client.get('/api/v1/admin/announcements')
+        .then(res => {
+            return res.data
+        })
+}
+
+const sendAnnouncementNotification = async ({ title, message, filter, mock, to, url }) => {
+    return client.post('/api/v1/admin/announcements', { message, title, filter, mock, to, url })
+        .then(res => {
+            return res.data
+        })
+}
+
 /**
  * Calls api routes in admin.js
  * See [routes/api/admin.js](../../../forge/routes/api/admin.js)
@@ -67,5 +83,7 @@ export default {
     getInvitations,
     getPlatformAuditLog,
     generateStatsAccessToken,
-    deleteStatsAccessToken
+    deleteStatsAccessToken,
+    getAnnouncementNotifications,
+    sendAnnouncementNotification
 }

frontend/src/components/notifications/Generic.vue

@@ -60,16 +60,29 @@ export default {
     },
     computed: {
         to () {
-            if (typeof this.notification.data?.to === 'object') { return this.notification.data.to }
-            if (typeof this.notification.data?.to === 'string') { return { path: this.notification.data.to } }
-            if (typeof this.notification.data?.url === 'string') { return { url: this.notification.data.url } }
-            if (this.notification.data?.instance?.id) {
+            switch (true) {
+            case this.notification.data?.to && typeof this.notification.data?.to === 'object':
+                return this.notification.data.to
+
+            case this.notification.data?.to && typeof this.notification.data?.to === 'string':
+                try {
+                    return JSON.parse(this.notification.data?.to)
+                } catch (e) {
+                    return { path: this.notification.data.to }
+                }
+
+            case typeof this.notification.data?.instance?.id === 'string':
                 return {
                     name: 'instance-overview',
                     params: { id: this.notification.data.instance.id }
                 }
+
+            case typeof this.notification.data?.url === 'string':
+                return { url: this.notification.data.url }
+
+            default:
+                return null // no link
             }
-            return null // no link
         },
         notificationData () {
             const event = this.knownEvents[this.notification.type] || {}

frontend/src/components/notifications/Notification.vue

@@ -72,14 +72,20 @@ export default {
         ...mapActions('ux', ['closeRightDrawer']),
         go (to) {
             this.closeRightDrawer()
-            this.notification.read = true
-            userApi.markNotificationRead(this.notification.id)
+            this.markAsRead()
+
             if (to?.url) {
                 // Handle external links
                 window.open(to.url, '_blank').focus()
             } else if (to?.name || to?.path) {
                 this.$router.push(to)
             }
+        },
+        markAsRead () {
+            if (!this.notification.read) {
+                this.notification.read = true
+                userApi.markNotificationRead(this.notification.id)
+            }
         }
     }
 }