tidy up more stuff...

controllers/helpers.js

@@ -1,4 +1,3 @@
-/* eslint-disable no-restricted-syntax */
 function formatDuration(durationSeconds) {
   const durationSecondsRound = Math.round(durationSeconds);
   const secs = durationSecondsRound % 60;
@@ -19,6 +18,7 @@ function formatDuration(durationSeconds) {
 // TODO remove this - looks like its used in old server.js
 function simpleStringify(object) {
   const simpleObject = {};
+  // eslint-disable-next-line no-restricted-syntax
   for (const prop in object) {
     if (!Object.prototype.hasOwnProperty.call(object, prop)) {
       continue;
@@ -39,5 +39,7 @@ function formatDate(timestampMs) {
 }
 
 module.exports = {
-  formatDuration, simpleStringify, formatDate,
+  formatDuration,
+  simpleStringify,
+  formatDate,
 };

controllers/users.js

@@ -53,18 +53,12 @@ async function verifyEmailToken(token) {
     return { success: false, status: 404, data: { badToken: true } };
   }
   if (account.verified === 1) {
-    return { success: true, status: 404, data: { alreadyVerified: true } };
+    return { success: true, status: 409, data: { alreadyVerified: true } };
   }
 
   await orm.models.accounts.update(
-    {
-      verified: true,
-    },
-    {
-      where: {
-        id: account.id,
-      },
-    },
+    { verified: true },
+    { where: { id: account.id } },
   );
 
   return { success: true, status: 200, data: { successfullyVerified: true } };

routes/api/devices.js

@@ -3,9 +3,11 @@ const crypto = require('crypto');
 const dirTree = require('directory-tree');
 const config = require('../../config');
 
+/* eslint-disable no-unused-vars */
 const userController = require('../../controllers/users');
 const deviceController = require('../../controllers/devices');
 const authenticationController = require('../../controllers/authentication');
+/* eslint-enable no-unused-vars */
 
 async function isAuthenticated(req, res, next) {
   const account = await authenticationController.getAuthenticatedAccount(req);

routes/api/realtime.js

@@ -1,9 +1,11 @@
 const router = require('express').Router();
 
+/* eslint-disable no-unused-vars */
 const authenticationController = require('../../controllers/authentication');
 const userController = require('../../controllers/users');
 const deviceController = require('../../controllers/devices');
 const models = require('../../models/index.model');
+/* eslint-enable no-unused-vars */
 
 const whitelistParams = {
   getmessage: true,
@@ -33,7 +35,8 @@ router.get('/dongle/:dongle_id/connected', async (req, res) => {
     });
   }
 
-  const device = await deviceController.getDeviceFromDongle(req.params.dongle_id);
+  const { dongle_id: dongleId } = req.params;
+  const device = await deviceController.getDeviceFromDongle(dongleId);
   if (!device) {
     return res.status(400).json({
       error: true,
@@ -52,54 +55,100 @@ router.get('/dongle/:dongle_id/connected', async (req, res) => {
     });
   }
 
-  const deviceConnected = await req.athenaWebsocketTemp.isDeviceConnected(account.id, device.id, device.dongle_id);
+  // eslint-disable-next-line max-len
+  const isConnected = await req.athenaWebsocketTemp.isDeviceConnected(account.id, device.id, dongleId);
 
   return res.status(200).json({
-    success: true, dongle_id: device.dongle_id, data: deviceConnected,
+    success: true,
+    dongle_id: device.dongle_id,
+    data: isConnected,
   });
 });
 
 router.get('/dongle/:dongle_id/send/:method/', async (req, res) => {
+  const { method } = req.params;
+  if (!whitelistParams[method.toLowerCase()]) {
+    return res.status(409).json({
+      error: true,
+      errorMsg: 'invalid_method',
+      errorObject: { method },
+    });
+  }
+
   const account = await authenticationController.getAuthenticatedAccount(req);
   if (account == null) {
-    return res.status(403).json({ error: true, errorMsg: 'Unauthenticated', errorObject: { authenticated: false } });
+    return res.status(403).json({
+      error: true,
+      errorMsg: 'Unauthenticated',
+      errorObject: { authenticated: false },
+    });
   }
 
-  if (!whitelistParams[req.params.method.toLowerCase()]) {
-    return res.status(409).json({ error: true, errorMsg: 'invalid_method' });
-  }
-  const device = await deviceController.getDeviceFromDongle(req.params.dongle_id);
+  const { dongle_id: dongleId } = req.params;
+  const device = await deviceController.getDeviceFromDongle(dongleId);
   if (!device) {
-    return res.status(400).json({ error: true, errorMsg: 'no_dongle', errorObject: { authenticated: true, dongle_exists: false } });
+    return res.status(400).json({
+      error: true,
+      errorMsg: 'no_dongle',
+      errorObject: { authenticated: true, dongle_exists: false },
+    });
   }
 
-  // TODO support delgation of access
+  // TODO support delegation of access
   // TODO remove indication of dongle existing
   if (device.account_id !== account.id) {
-    return res.status(403).json({ error: true, errorMsg: 'unauthorised', errorObject: { authenticated: true, dongle_exists: true, authorised_user: false } });
+    return res.status(403).json({
+      error: true,
+      errorMsg: 'unauthorised',
+      errorObject: { authenticated: true, dongle_exists: true, authorised_user: false },
+    });
   }
 
-  const data = await req.athenaWebsocketTemp.invoke(req.params.method, null, device.dongle_id, account.id);
+  const data = await req.athenaWebsocketTemp.invoke(method, null, dongleId, account.id);
 
   return res.status(200).json({
-    success: true, dongle_id: device.dongle_id, method: req.params.method, data,
+    success: true,
+    dongle_id: dongleId,
+    method,
+    data,
   });
 });
 
 router.get('/dongle/:dongle_id/get', async (req, res) => {
   const account = await authenticationController.getAuthenticatedAccount(req);
   if (account == null) {
-    return res.status(403).json({ error: true, errorMsg: 'Unauthenticated', errorObject: { authenticated: false } });
+    return res.status(403).json({
+      error: true,
+      errorMsg: 'Unauthenticated',
+      errorObject: { authenticated: false },
+    });
   }
   const device = await deviceController.getDeviceFromDongle(req.params.dongle_id);
   if (!device) {
-    return res.status(400).json({ error: true, errorMsg: 'no_dongle', errorObject: { authenticated: true, dongle_exists: false } });
+    return res.status(400).json({
+      error: true,
+      errorMsg: 'no_dongle',
+      errorObject: {
+        authenticated: true,
+        dongle_exists: false,
+      },
+    });
   }
   if (device.account_id !== account.id) {
-    return res.status(403).json({ error: true, errorMsg: 'unauthorised', errorObject: { authenticated: true, dongle_exists: true, authorised_user: false } });
+    return res.status(403).json({
+      error: true,
+      errorMsg: 'unauthorised',
+      errorObject: {
+        authenticated: true,
+        dongle_exists: true,
+        authorised_user: false,
+      },
+    });
   }
 
-  return res.json(await models.models.athena_returned_data.findAll({ where: { device_id: device.id } }));
+  return res.json(await models.models.athena_returned_data.findAll({
+    where: { device_id: device.id },
+  }));
 });
 
 router.get('/dongle/:dongle_id/temp/nav/:lat/:long', async (req, res) => {

routes/api/registration.js

@@ -1,34 +1,35 @@
 const bodyParser = require('body-parser');
 const router = require('express').Router();
-const config = require('../../config');
 
 const userController = require('../../controllers/users');
 
 router.post('/retropilot/0/register/email', bodyParser.urlencoded({ extended: true }), async (req, res) => {
-  if (!req.body.hasOwnProperty('email') || req.body.email === '' || !req.body.hasOwnProperty('password') || req.body.password === '') {
+  const { email, password } = req.body;
+  if (!email || !password) {
     // FIXME: use logger.warn
     console.error('/useradmin/register/token - Malformed Request!');
-    return res.json({ success: false, msg: 'malformed request' }).status(400);
+    return res.status(400).json({ success: false, msg: 'malformed request' });
   }
 
   const accountStatus = await userController.createAccount(req.body.email, req.body.password);
   if (accountStatus && accountStatus.status) {
-    return res.json(accountStatus).status(accountStatus.status);
+    return res.status(accountStatus.status).json(accountStatus);
   }
-  return res.json({ success: false, msg: 'contact server admin' }).status(500);
+  return res.status(500).json({ success: false, msg: 'contact server admin' });
 });
 
 router.get('/retropilot/0/register/verify/:token', bodyParser.urlencoded({ extended: true }), async (req, res) => {
-  if (!req.params.token) {
-    res.json({ success: false, status: 400, data: { missingToken: true } }).status(400);
+  const { token } = req.params;
+  if (!token) {
+    return res.status(400).json({ success: false, status: 400, data: { missingToken: true } });
   }
 
   const verified = await userController.verifyEmailToken(req.params.token);
 
   if (verified && verified.status) {
-    return res.json(verified).status(verified.status);
+    return res.status(verified.status).json(verified);
   }
-  return res.json({ success: false, msg: 'contact server admin' }).status(500);
+  return res.status(500).json({ success: false, msg: 'contact server admin' });
 });
 
 module.exports = router;