Integrate with frontend web app

.github/workflows/node.js-with-docker-db.yml

@@ -24,7 +24,8 @@ jobs:
 
     strategy:
       matrix:
-        node-version: [14]
+        node-version: ['lts/*']
+        check-latest: true
 
     # If the Pull Request is coming from a fork (pull_request_target), ensure it's opened by "dependabot[bot]". Otherwise, clone it normally.
     # References:

.github/workflows/node.js.yml

@@ -22,7 +22,8 @@ jobs:
 
     strategy:
       matrix:
-        node-version: [14.x]
+        node-version: ['lts/*']
+        check-latest: true
 
     steps:
       - uses: actions/[email protected]

.gitignore

@@ -104,4 +104,6 @@ dist
 .tern-port
 
 # custom
-*firebase-adminsdk*.json
+*firebase-adminsdk*.json
+.gcloudignore
+app.yaml

app.js

@@ -4,14 +4,13 @@ const morgan = require('morgan');
 const cors = require('cors');
 const mongoose = require('mongoose');
 const config = require('./utils/config');
-
-const rootRouter = require('./routes/root');
-const usersRouter = require('./routes/api/users');
-
 const middleware = require('./utils/middleware');
 const logger = require('./utils/logger');
+const rootRouter = require('./routes/root');
+const usersRouter = require('./routes/api/users');
 const authRouter = require('./routes/api/auth');
 const softwareRouter = require('./routes/api/software');
+const searchRouter = require('./routes/api/search');
 
 const app = express();
 
@@ -56,6 +55,7 @@ app.use(rootRouter);
 app.use('/api/users', usersRouter);
 app.use('/api/auth', authRouter);
 app.use('/api/software', softwareRouter);
+app.use('/api/search', searchRouter);
 
 app.use(middleware.unknownEndPoint);
 app.use(middleware.errorHandler);

controllers/api/searchController.js

@@ -0,0 +1,30 @@
+const Software = require('../../models/software');
+
+const searchSoftware = async (req, res) => {
+  const page = parseInt(req.query.page, 10) || 0;
+  const perPage = parseInt(req.query.per_page, 10) || 30;
+  const query = {
+    name: {
+      $regex: req.query.q,
+      $options: 'i',
+    },
+  };
+
+  const queryResponse = await Software.find(query)
+    .sort({ name: 'asc' })
+    .skip(page * perPage)
+    .limit(perPage)
+    .populate('meta.addedByUser', { username: 1, name: 1 })
+    .populate('meta.updatedByUser', { username: 1, name: 1 });
+
+  const totalQueryResultCount = await Software.find(query).countDocuments();
+
+  return res.status(200).json({
+    totalQueryResultCount,
+    queryResponse,
+  });
+};
+
+module.exports = {
+  searchSoftware,
+};

controllers/api/softwareController.js

@@ -25,6 +25,7 @@ const postSoftware = async (req, res) => {
   const softwareObject = {
     ...body,
     meta: {
+      ...body.meta,
       addedByUser: userId,
       updatedByUser: userId,
     },
@@ -146,10 +147,36 @@ const deleteSoftwareById = async (req, res) => {
   return res.status(204).end();
 };
 
+const getRecentAddedSoftware = async (req, res) => {
+  const count = parseInt(req.query.count, 10) || 5;
+
+  const response = await Software.find({})
+    .sort({ createdAt: 'desc' })
+    .limit(count)
+    .populate('meta.addedByUser', { username: 1, name: 1 })
+    .populate('meta.updatedByUser', { username: 1, name: 1 });
+
+  return res.status(200).json(response);
+};
+
+const getRecentUpdatedSoftware = async (req, res) => {
+  const count = parseInt(req.query.count, 10) || 5;
+
+  const response = await Software.find({})
+    .sort({ updatedAt: 'desc' })
+    .limit(count)
+    .populate('meta.addedByUser', { username: 1, name: 1 })
+    .populate('meta.updatedByUser', { username: 1, name: 1 });
+
+  return res.status(200).json(response);
+};
+
 module.exports = {
   getSoftware,
   postSoftware,
   patchSoftwareById,
   getSoftwareById,
   deleteSoftwareById,
+  getRecentAddedSoftware,
+  getRecentUpdatedSoftware,
 };

controllers/api/usersController.js

@@ -1,6 +1,7 @@
 const User = require('../../models/user');
 const firebaseAdmin = require('../../utils/firebaseConfig');
 const jwtUtils = require('../../utils/jwtUtils');
+const { checkUsernameValidity } = require('../../utils/api/usersUtils');
 
 const getUsers = async (req, res) => {
   const users = await User.find({}).populate([
@@ -17,17 +18,24 @@ const getUsers = async (req, res) => {
 };
 
 const postUsers = async (req, res) => {
-  const { body } = req;
+  const { username } = req.body;
 
   const authToken = jwtUtils.getReqAuthToken(req);
+
   const decodedToken = await jwtUtils.verifyAuthToken(authToken, false);
 
+  if (!decodedToken) {
+    return res.status(401).json({
+      error: 'Missing/Invalid Token',
+    });
+  }
+
   const response = await firebaseAdmin.auth().getUser(decodedToken.uid);
 
   const userRecord = response.toJSON();
 
   const user = new User({
-    username: body.username,
+    username: !username ? null : username,
     name: userRecord.displayName,
     email: userRecord.email,
     firebaseUid: userRecord.uid,
@@ -36,14 +44,42 @@ const postUsers = async (req, res) => {
   const savedUser = await user.save();
 
   // Set custom claim with backend user id (different from firebase user id)
-  await firebaseAdmin
-    .auth()
-    .setCustomUserClaims(decodedToken.uid, { backendId: savedUser.id });
+  await firebaseAdmin.auth().setCustomUserClaims(decodedToken.uid, {
+    backendId: savedUser.id,
+    username: savedUser.username,
+  });
 
   return res.status(201).json(savedUser);
 };
 
+const postUserAvailability = async (req, res) => {
+  const { username } = req.body;
+
+  if (!username) {
+    return res.status(400).json({
+      error: 'Missing username in request.',
+    });
+  }
+
+  const isValidUsername = checkUsernameValidity(username);
+
+  if (!isValidUsername) {
+    return res.status(400).json({
+      error: 'Invalid username.',
+    });
+  }
+
+  const response = await User.findOne({
+    username,
+  }).lean();
+
+  return res.json({
+    usernameStatus: response === null ? 'Available' : 'Not Available',
+  });
+};
+
 module.exports = {
   getUsers,
   postUsers,
+  postUserAvailability,
 };

models/software.js

@@ -1,6 +1,7 @@
 const mongoose = require('mongoose');
 const { isURL } = require('validator');
 const uniqueValidator = require('mongoose-unique-validator');
+const { ALLOWED_VIDEO_HOST_WHITELIST } = require('../utils/config');
 
 const softwareSchema = new mongoose.Schema(
   {
@@ -26,6 +27,12 @@ const softwareSchema = new mongoose.Schema(
       trim: true,
       default: '0.0.0',
     },
+    shortDescription: {
+      type: String,
+      trim: true,
+      maxlength: 100,
+      required: [true, 'Software short description is required'],
+    },
     description: {
       type: String,
       trim: true,
@@ -34,9 +41,10 @@ const softwareSchema = new mongoose.Schema(
     homePage: {
       type: String,
       validate: [
-        (value) => isURL(value, {
-          protocols: ['http', 'https'],
-        }),
+        (value) =>
+          isURL(value, {
+            protocols: ['http', 'https'],
+          }),
         'A valid url is required',
       ],
       required: [true, 'Software homepage url is required'],
@@ -51,6 +59,12 @@ const softwareSchema = new mongoose.Schema(
       type: Boolean,
       required: true,
     },
+    pricing: {
+      type: String,
+      trim: true,
+      lowercase: true,
+      required: [true, 'Software pricing is required'],
+    },
     buildOn: {
       type: [
         {
@@ -64,21 +78,45 @@ const softwareSchema = new mongoose.Schema(
     developedBy: {
       type: [
         {
-          type: mongoose.Schema.Types.ObjectId,
-          ref: 'User',
+          type: String,
+          trim: true,
+          lowercase: true,
         },
       ],
       default: [],
     },
     maintainedBy: {
       type: [
         {
-          type: mongoose.Schema.Types.ObjectId,
-          ref: 'User',
+          type: String,
+          trim: true,
+          lowercase: true,
         },
       ],
       default: [],
     },
+    videoLink: {
+      type: String,
+      validate: [
+        (value) => {
+          if (value) {
+            return isURL(value, {
+              protocols: ['http', 'https'],
+              host_whitelist: ALLOWED_VIDEO_HOST_WHITELIST,
+            });
+          }
+          return true;
+        },
+        'A valid video url is required (Only youtube.com or vimeo.com are supported)',
+      ],
+      default: '',
+    },
+    twitterUsername: {
+      type: String,
+      trim: true,
+      lowercase: true,
+      default: '',
+    },
     query: {
       isEnabled: {
         type: Boolean,
@@ -87,19 +125,21 @@ const softwareSchema = new mongoose.Schema(
       updateUrl: {
         type: String,
         validate: [
-          (value) => isURL(value, {
-            protocols: ['http', 'https'],
-          }) || value === '',
+          (value) =>
+            isURL(value, {
+              protocols: ['http', 'https'],
+            }) || value === '',
           'A valid update url is required',
         ],
         default: '',
       },
       downloadUrl: {
         type: String,
         validate: [
-          (value) => isURL(value, {
-            protocols: ['http', 'https', 'ftp'],
-          }) || value === '',
+          (value) =>
+            isURL(value, {
+              protocols: ['http', 'https', 'ftp'],
+            }) || value === '',
           'A valid download url is required',
         ],
         default: '',

models/user.js

@@ -1,15 +1,15 @@
 const mongoose = require('mongoose');
 const uniqueValidator = require('mongoose-unique-validator');
 const { isEmail, normalizeEmail } = require('validator');
+const { ALLOWED_USERNAME_REGEX } = require('../utils/config');
 
-const usernameRegex = RegExp('^[a-z0-9_.-]+$');
+const usernameRegex = RegExp(ALLOWED_USERNAME_REGEX);
 
 const userSchema = new mongoose.Schema(
   {
     username: {
       type: String,
       required: [true, 'Missing username'],
-      minlength: [6, 'The username should be at least 6 characters long'],
       unique: true,
       lowercase: true,
       trim: true,