Add categories

Author: knolleary

.eslintrc

@@ -56,6 +56,13 @@
             "env": {
                 "mocha": true
             }
+        },
+        {
+            "files": ["public/js/**"],
+            "env": {
+                "browser": true,
+                "jquery": true
+            }
         }
     ]
 }

app.js

@@ -65,6 +65,7 @@ const limiter = rateLimit({
         app.use(require('./routes/users'))
         app.use(require('./routes/api'))
         app.use(require('./routes/collections'))
+        app.use(require('./routes/categories'))
         app.use(function (err, req, res, next) {
             if (err.code !== 'EBADCSRFTOKEN') {
                 console.log('here', err)

config/index.js

@@ -16,6 +16,13 @@ try {
     module.exports.session.secret = process.env.NR_SESSION_SECRET || module.exports.session.secret
     if (process.env.NR_ADMINS) {
         module.exports.admins = process.env.NR_ADMINS.split(',').map(t => t.trim())
+    } else {
+        module.exports.admins = []
+    }
+    if (process.env.NR_MODERATORS) {
+        module.exports.moderators = process.env.NR_MODS.split(',').map(t => t.trim())
+    } else {
+        module.exports.moderators = []
     }
 
     module.exports.mastodon.url = process.env.NR_MASTODON_URL || module.exports.mastodon.url

lib/categories.js

@@ -0,0 +1,79 @@
+const db = require('./db')
+const { generateSummary } = require('./utils')
+
+// Given they are largely static and there are not many, we can cache the category list
+// to save hitting the DB for every page view
+let categoryCache
+
+async function refreshCategoryCache () {
+    categoryCache = await db.categories.find().toArray()
+    categoryCache.sort((a, b) => a.name.localeCompare(b.name))
+}
+
+function normaliseName (name) {
+    return name.toLowerCase().replace(/[ /]+/g, '-').replace(/&/g, 'and')
+}
+
+async function createCategory (category) {
+    category._id = normaliseName(category.name)
+    category.updated_at = (new Date()).toISOString()
+    category.summary = generateSummary(category.description)
+    await db.categories.insertOne(category, { upsert: true })
+    await refreshCategoryCache()
+    return category._id
+}
+
+// async function removeCollection (id) {
+//     const collection = await getCollection(id)
+//     const tags = collection.tags || []
+//     const promises = []
+//     for (let i = 0; i < tags.length; i++) {
+//         promises.push(db.tags.updateOne({ _id: tags[i] }, { $inc: { count: -1 } }))
+//     }
+//     promises.push(db.tags.deleteMany({ count: { $lte: 0 } }))
+//     await Promise.all(promises)
+//     try {
+//         await db.flows.deleteOne({ _id: id })
+//     } finally {
+//         view.resetTypeCountCache()
+//     }
+// }
+
+async function getCategories () {
+    if (!categoryCache) {
+        await refreshCategoryCache()
+    }
+    return categoryCache
+}
+async function getCategory (id) {
+    const data = await db.categories.find({ _id: id }).toArray()
+    if (!data || data.length === 0) {
+        throw new Error(`Category ${id} not found`)
+    }
+    return data[0]
+}
+
+async function updateCategory (category) {
+    category.updated_at = (new Date()).toISOString()
+    if (Object.prototype.hasOwnProperty.call(category, 'description')) {
+        category.summary = generateSummary(category.description)
+    }
+    try {
+        await db.categories.updateOne(
+            { _id: category._id },
+            { $set: category }
+        )
+    } catch (err) {
+        console.log('Update category', category._id, 'ERR', err.toString())
+        throw err
+    }
+    await refreshCategoryCache()
+    return category._id
+}
+
+module.exports = {
+    getAll: getCategories,
+    create: createCategory,
+    get: getCategory,
+    update: updateCategory
+}

lib/collections.js

@@ -2,6 +2,7 @@ const crypto = require('crypto')
 
 const db = require('./db')
 const users = require('./users')
+const { generateSummary } = require('./utils')
 const view = require('./view')
 
 async function createCollection (collection) {
@@ -46,20 +47,6 @@ async function getCollection (id) {
     return data[0]
 }
 
-function generateSummary (desc) {
-    let summary = (desc || '').split('\n')[0]
-    const re = /\[(.*?)\]\(.*?\)/g
-    let m
-    while ((m = re.exec(summary)) !== null) {
-        summary = summary.substring(0, m.index) + m[1] + summary.substring(m.index + m[0].length)
-    }
-
-    if (summary.length > 150) {
-        summary = summary.substring(0, 150).split('\n')[0] + '...'
-    }
-    return summary
-}
-
 async function updateCollection (collection) {
     delete collection.type
     collection.updated_at = (new Date()).toISOString()

lib/db.js

@@ -7,7 +7,7 @@ const api = {
 }
 
 async function init () {
-    const collections = ['flows', 'nodes', 'users', 'tags', 'events', 'ratings']
+    const collections = ['flows', 'nodes', 'users', 'tags', 'events', 'ratings', 'categories']
     const client = new MongoClient(settings.mongo.url)
     await client.connect()
     const db = client.db()

lib/utils.js

@@ -100,9 +100,51 @@ async function renderMarkdown (src, opt) {
     return DOMPurify.sanitize(content)
 }
 
+/**
+ * Middleware that validates the user has a given role
+ * @param {String} role one of user/mod/admin
+ */
+function requireRole (role) {
+    return (req, res, next) => {
+        if (req.session.user) {
+            if (!role || role === 'user') {
+                // Logged in user
+                next()
+                return
+            }
+            if (role === 'admin' && req.session.user.isAdmin) {
+                next()
+                return
+            }
+            if (role === 'mod' && (req.session.user.isAdmin || req.session.user.isModerator)) {
+                next()
+                return
+            }
+        }
+        console.log('rejecting request', role, req.session.user)
+        res.status(404).send()
+    }
+}
+
+function generateSummary (desc) {
+    let summary = (desc || '').split('\n')[0]
+    const re = /\[(.*?)\]\(.*?\)/g
+    let m
+    while ((m = re.exec(summary)) !== null) {
+        summary = summary.substring(0, m.index) + m[1] + summary.substring(m.index + m[0].length)
+    }
+
+    if (summary.length > 150) {
+        summary = summary.substring(0, 150).split('\n')[0] + '...'
+    }
+    return summary
+}
+
 module.exports = {
+    generateSummary,
     renderMarkdown,
     formatDate,
     formatShortDate,
-    csrfProtection: () => csrfProtection
+    csrfProtection: () => csrfProtection,
+    requireRole
 }

lib/view.js

@@ -107,8 +107,11 @@ module.exports = {
                 }
             }
             // const typeNode = !findQuery.type || findQuery.type === 'node' || (Array.isArray(query.type) && query.type.indexOf('node') > -1)
-
-            if (query.username || query.npm_username) {
+            if (query.category) {
+                const categories = Array.isArray(query.category) ? query.category : [query.category]
+                findQuery.categories = { $in: categories }
+                countQuery.categories = { $in: categories }
+            } else if (query.username || query.npm_username) {
                 findQuery.$or = [{ gitOwners: query.username }, { npmOwners: query.npm_username || query.username }]
                 countQuery.$or = findQuery.$or
             } else {