Backend auth

api/package.json

@@ -16,13 +16,16 @@
     "debug": "~2.6.9",
     "dotenv": "^8.2.0",
     "express": "~4.16.1",
+    "express-session": "^1.17.1",
     "helmet": "^3.21.1",
     "http-errors": "~1.6.3",
     "if-env": "^1.0.4",
     "isomorphic-unfetch": "^3.0.0",
     "mongodb": "^3.3.2",
     "mongoose": "^5.7.5",
-    "morgan": "~1.9.1"
+    "morgan": "~1.9.1",
+    "passport": "^0.4.1",
+    "passport-google-oauth20": "^2.0.0"
   },
   "devDependencies": {
     "babel-eslint": "^10.0.3",

api/src/api/auth.js

@@ -0,0 +1,36 @@
+const express = require('express');
+const router = express.Router();
+const passport = require('passport');
+
+router.get('/user', (req, res) => {
+  const user = req.user || null;
+
+  res.json({
+    result: user,
+    success: true,
+  });
+});
+
+router.get(
+  '/login',
+  passport.authenticate('google', { scope: ['profile', 'email'] }),
+);
+
+router.get(
+  '/callback',
+  passport.authenticate('google', { failureRedirect: '/login' }),
+  (req, res) => {
+    // Successful authentication, redirect home.
+    res.redirect('/');
+  },
+);
+
+router.post('/logout', (req, res) => {
+  req.logout();
+  res.json({
+    message: 'Logged out',
+    success: true,
+  });
+});
+
+module.exports = router;

api/src/api/home.js

@@ -1,6 +1,7 @@
 const express = require('express');
 const router = express.Router();
 const { errorWrap } = require('../middleware');
+const { requireRegistered } = require('../middleware/auth');
 
 const Home = require('../models/home');
 
@@ -16,4 +17,17 @@ router.get(
   }),
 );
 
+router.get(
+  '/registeredOnly',
+  [requireRegistered],
+  errorWrap(async (req, res) => {
+    const home = await Home.findOne();
+    res.status(200).json({
+      message: `Successfully returned home text`,
+      success: true,
+      result: home.text,
+    });
+  }),
+);
+
 module.exports = router;

api/src/api/index.js

@@ -1,5 +1,7 @@
 const home = require('./home');
+const auth = require('./auth');
 
 module.exports = {
   home,
+  auth,
 };

api/src/app.js

@@ -7,8 +7,10 @@ const helmet = require('helmet');
 const logger = require('morgan');
 const mongoose = require('mongoose');
 const path = require('path');
-const routes = require('./routes');
+const session = require('express-session');
 const bodyParser = require('body-parser');
+const passport = require('passport');
+const routes = require('./routes');
 
 const app = express();
 const { errorHandler } = require('./middleware');
@@ -40,6 +42,21 @@ app.use(logger('dev'));
 app.use(bodyParser.json({ limit: '2.1mb' }));
 app.use(bodyParser.urlencoded({ limit: '2.1mb', extended: false }));
 
+// Session support, needed for authentication
+app.use(
+  session({
+    secret: process.env.SESSION_SECRET,
+    cookie: {},
+    resave: false,
+    saveUninitialized: false,
+  }),
+);
+
+// Passport setup
+require('./passport-setup');
+app.use(passport.initialize());
+app.use(passport.session());
+
 app.use('/', routes);
 
 app.get('/', (req, res) => res.json('API working!'));

api/src/middleware/auth.js

@@ -0,0 +1,41 @@
+const { levelEnum } = require('../models/member');
+
+const requireLevel = (levels) => (req, res, next) => {
+  console.log(req.user);
+  if (!req.user || !levels.includes(req.user.level)) {
+    return res.status(401).json({
+      success: false,
+      message: 'Unauthorized',
+    });
+  } else {
+    next();
+  }
+};
+
+const requireRegistered = requireLevel(Object.values(levelEnum));
+
+const requireMember = requireLevel([
+  levelEnum.ADMIN,
+  levelEnum.DIRECTOR,
+  levelEnum.LEAD,
+  levelEnum.MEMBER,
+]);
+
+const requireLead = requireLevel([
+  levelEnum.ADMIN,
+  levelEnum.DIRECTOR,
+  levelEnum.LEAD,
+]);
+
+const requireDirector = requireLevel([levelEnum.ADMIN, levelEnum.DIRECTOR]);
+
+const requireAdmin = requireLevel([levelEnum.ADMIN]);
+
+module.exports = {
+  requireLevel,
+  requireRegistered,
+  requireMember,
+  requireLead,
+  requireDirector,
+  requireAdmin,
+};

api/src/middleware/index.js

@@ -1,7 +1,9 @@
 const errorHandler = require('./errorHandler');
 const errorWrap = require('./errorWrap');
+const auth = require('./auth');
 
 module.exports = {
   errorHandler,
   errorWrap,
+  auth,
 };

api/src/models/member.js

@@ -53,50 +53,50 @@ const classStandingEnum = {
 };
 
 const Member = new mongoose.Schema({
-  firstName: { type: String, required: true },
-  lastName: { type: String, required: true },
+  firstName: { type: String, required: false },
+  lastName: { type: String, required: false },
   oauthID: { type: String, required: true, unique: true },
-  email: { type: String, required: true, unique: true },
-  phone: { type: String, required: true },
-  netID: { type: String, required: true },
-  UIN: { type: String, required: true },
-  major: { type: String, required: true },
-  birthdate: { type: Date, required: true },
+  email: { type: String, required: false, unique: true },
+  phone: { type: String, required: false },
+  netID: { type: String, required: false },
+  UIN: { type: String, required: false },
+  major: { type: String, required: false },
+  birthdate: { type: Date, required: false },
   github: { type: String, required: false },
   snapchat: { type: String, required: false },
   instagram: { type: String, required: false },
-  areDuesPaid: { type: Boolean, required: true },
+  areDuesPaid: { type: Boolean, required: false },
 
-  gradYear: { type: Number, required: true },
+  gradYear: { type: Number, required: false },
   gradSemester: {
     type: String,
     enum: Object.values(semesterEnum),
-    required: true,
+    required: false,
   },
 
   classStanding: {
     type: String,
     enum: Object.values(classStandingEnum),
-    required: true,
+    required: false,
   },
 
-  generationYear: { type: Number, required: true },
+  generationYear: { type: Number, required: false },
   generationSemester: {
     type: String,
     enum: Object.values(semesterEnum),
-    required: true,
+    required: false,
   },
 
   location: {
     type: String,
     enum: Object.values(locationEnum),
-    required: true,
+    required: false,
   },
 
   role: {
     type: String,
     enum: Object.values(roleEnum),
-    required: true,
+    required: false,
   },
 
   level: {
@@ -108,7 +108,7 @@ const Member = new mongoose.Schema({
   status: {
     type: String,
     enum: Object.values(statusEnum),
-    required: true,
+    required: false,
   },
 });
 

api/src/passport-setup.js

@@ -0,0 +1,52 @@
+const GoogleStrategy = require('passport-google-oauth20').Strategy;
+const passport = require('passport');
+const Member = require('./models/member');
+
+// Defines the default level a user gets assigned with upon first sign-in
+const DEFAULT_LEVEL = process.env.DEFAULT_LEVEL || Member.levelEnum.TBD;
+
+passport.serializeUser((user, done) => {
+  done(null, user._id);
+});
+
+passport.deserializeUser((id, done) => {
+  // Find in DB and return user
+  Member.findById(id, (err, user) => {
+    if (err) {
+      console.error('err');
+      done(err);
+    }
+    done(null, user);
+  });
+});
+
+passport.use(
+  new GoogleStrategy(
+    {
+      clientID: process.env.GOOGLE_CLIENT_ID,
+      clientSecret: process.env.GOOGLE_CLIENT_SECRET,
+      callbackURL: process.env.OAUTH_CALLBACK_URI,
+    },
+    async (accessToken, refreshToken, profile, cb) => {
+      // find the user in the database based on their oauth id
+      const user = await Member.findOne({ oauthID: profile.id });
+
+      console.log(profile);
+
+      if (user) {
+        // user exists
+        return cb(null, user);
+      } else {
+        const newUser = await new Member({
+          firstName: profile.name.givenName,
+          lastName: profile.name.familyName,
+          oauthID: profile.id,
+          email: profile.emails[0].value,
+          level: DEFAULT_LEVEL,
+        }).save();
+
+        cb(null, newUser);
+      }
+    },
+  ),
+);

api/src/routes/index.js

@@ -1,8 +1,9 @@
 const express = require('express');
 
 const router = express.Router();
-const { home } = require('../api');
+const { home, auth } = require('../api');
 
 router.use('/api/home', home);
+router.use('/api/auth', auth);
 
 module.exports = router;

api/test/dummy.test.js

@@ -0,0 +1,3 @@
+describe('Dummy test', () => {
+  test('Dummy test', () => {});
+});