Merge branch 'master' into screen_reader

Author: ericgpark

.eslintignore

@@ -1 +1,7 @@
-node_modules
+node_modules
+
+*.js
+
+*.tsx
+
+*.jsx

.gitignore

@@ -27,4 +27,7 @@ yarn-error.log*
 
 
 #configuration
-.vscode
+.vscode
+
+.eslintignore
+

package.json

@@ -46,6 +46,7 @@
     "fix-path": "^3.0.0",
     "js-beautify": "^1.10.0",
     "monaco-editor": "^0.17.0",
+    "mongoose": "^5.12.13",
     "node-pty": "^0.10.0",
     "react": "^16.8.6",
     "react-autosuggest": "^9.4.3",
@@ -116,5 +117,6 @@
     "react-test-renderer": "^16.12.0",
     "spectron": "^5.0.0",
     "test-data-bot": "^0.8.0"
-  }
+  },
+  "proxy": "http://localhost:3001"
 }

server/controllers/cookieController.js

@@ -0,0 +1,13 @@
+const cookieController = {};
+
+cookieController.setSSIDCookie = (req, res, next) => {
+  res.cookie('ssid', JSON.stringify(res.locals.userId).replace(/\"/g, ''));
+  return next();
+};
+
+cookieController.deleteCookie = (req, res, next) => {
+  res.clearCookie('ssid');
+  return next();
+};
+
+module.exports = cookieController;

server/controllers/sessionController.js

@@ -0,0 +1,29 @@
+const Session = require('../models/sessionModel');
+
+const sessionController = {};
+
+sessionController.startSession = (req, res, next) => {
+  Session.create({ cookieId: res.locals.userId }, (err, result) => {
+    if (err && err.code !== 11000) return next(err);
+    res.locals.ssid = req.cookies.ssid;
+    return next();
+  });
+};
+
+sessionController.endSession = (req, res, next) => {
+  Session.deleteMany({ cookieId: req.cookies.ssid }, (err) => {
+    if (err) return next(err);
+    return next();
+  });
+};
+
+sessionController.isLoggedIn = (req, res, next) => {
+  console.log('sessionController.isLoggedIn: req.cookies.ssid:', req.cookies.ssid);
+  Session.find({ cookieId: req.cookies.ssid }, (err, data) => {
+    if (err) return next(err);
+    if (data.length === 0) return next('User Not Logged In');
+    return next();
+  });
+};
+
+module.exports = sessionController;

server/controllers/testStateController.js

@@ -0,0 +1,24 @@
+const TestState = require('../models/testStateModel');
+
+const testStateController = {};
+
+testStateController.upload = (req, res, next) => {
+  TestState.create(
+    { userId: req.cookies.ssid, testName: req.body.testName, testState: req.body.testState },
+    (err) => {
+      if (err) return next('Upload Failed');
+      return next();
+    }
+  );
+};
+
+testStateController.getTests = (req, res, next) => {
+  TestState.find({ userId: req.cookies.ssid }, (err, result) => {
+    if (err) return next(err);
+    if (result.length === 0) return next('User Has No Saved Tests');
+    res.locals.tests = result;
+    return next();
+  });
+};
+
+module.exports = testStateController;

server/controllers/userController.js

@@ -0,0 +1,64 @@
+const User = require('../models/userModel');
+const bcrypt = require('bcrypt');
+
+const userController = {};
+
+// Middleware to encrypt passwords using bcrypt
+userController.bcrypt = (req, res, next) => {
+  // The cost factor determines how much time is needed to calculate a single bcrypt hash
+  const saltRounds = 10;
+  // Destructure password from request body
+  const { password } = req.body;
+  // Generate the salt by passing in saltRounds (cost factor)
+  bcrypt.genSalt(saltRounds, (err, salt) => {
+    // Hash a password by passing in the plaintext into the hash function
+    bcrypt.hash(password, salt, (err, hash) => {
+      // Save encrypted password into res.locals to be accessed later
+      res.locals.encryptedPassword = hash;
+      return next();
+    });
+  });
+};
+
+// Middleware to save user information in database
+userController.signup = (req, res, next) => {
+  // collection.create method to insert new user
+  User.create(
+    // Pass in username from request body and encrypted password
+    { username: req.body.username, password: res.locals.encryptedPassword },
+    // Callback to handle results of query
+    (err, newUser) => {
+      // If there is an error, invoke global error handler
+      if (err) return next('Account already exists');
+      // Save user ID into response locals
+      res.locals.userId = newUser._id;
+      // Inovke next middleware
+      return next();
+    }
+  );
+};
+
+// Middleware to check credentials and log user into application
+userController.login = (req, res, next) => {
+  // Collection.find method to look for all user instances with passed username
+  User.find({ username: req.body.username }, (err, result) => {
+    // If there is an error, invoke global error handler
+    if (err) return next(err);
+    // If there are no matching usernames, invoke global error handler
+    if (result.length === 0) return next('Incorrect username');
+    // If there is a user with passed username, use the bcrypt.compare method to compare plaintext password with encrypted password
+    bcrypt.compare(req.body.password, result[0].password, (err, match) => {
+      // If an error occurs in the compare method, invoke global error handler
+      if (err) return next(err);
+      // If there is a match, invoke next middleware
+      if (match) {
+        res.locals.userId = result[0]._id;
+        return next();
+      }
+      // If there is no match, invoke global error handler
+      return next('Incorrect password');
+    });
+  });
+};
+
+module.exports = userController;

server/models/sessionModel.js

@@ -0,0 +1,16 @@
+const mongoose = require('mongoose');
+const Schema = mongoose.Schema;
+
+/**
+ * Check out the `createdAt` field below. This is set up to use Mongo's automatic document
+ * expiration service by giving the Mongoose schema the `expires` property.
+ * After 30 seconds, the session will automatically be removed from the collection!
+ * (actually, Mongo's cleanup service only runs once per minute so the session
+ * could last up to 90 seconds before it's deleted, but still pretty cool!)
+ */
+const sessionSchema = new Schema({
+  cookieId: { type: String, required: true, unique: true },
+  createdAt: { type: Date, expires: 120, default: Date.now },
+});
+
+module.exports = mongoose.model('Session', sessionSchema);

server/models/testStateModel.js

@@ -0,0 +1,12 @@
+const mongoose = require('mongoose');
+
+const Schema = mongoose.Schema;
+
+const testStateSchema = new Schema({
+  userId: { type: String, require: true },
+  testName: { type: String, require: true },
+  testState: { type: Object },
+});
+const TestState = mongoose.model('testState', testStateSchema);
+
+module.exports = TestState;

server/models/userModel.js

@@ -0,0 +1,20 @@
+const mongoose = require('mongoose');
+
+const MONGO_URI =
+  'mongodb+srv://ericgpark:jENk%[email protected]/myFirstDatabase?retryWrites=true&w=majority';
+
+mongoose
+  .connect(MONGO_URI, { useNewUrlParser: true, useUnifiedTopology: true })
+  .then(() => console.log('Connected to Mongo DB Successfully'))
+  .catch((err) => console.log(err));
+
+const Schema = mongoose.Schema;
+
+// Schema and model for 'user' collection
+const userSchema = new Schema({
+  username: { type: String, require: true, unique: true },
+  password: { type: String, require: true },
+});
+const User = mongoose.model('user', userSchema);
+
+module.exports = User;