Merge pull request #54 from mathematicalthinking/development

Development (current deployment) update to main

Author: anzook

.gitignore

@@ -66,4 +66,6 @@ typings/
 # compiled ts files
 dist
 # ethereal login info created on fly each test run
-ethereal_creds.json
+ethereal_creds.json
+*.zip
+.DS_Store

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "mt-sso",
-  "version": "0.0.0",
+  "version": "1.1.4",
   "private": true,
   "scripts": {
     "start": "node dist/bin/main",

package.json

@@ -0,0 +1 @@
+export const version = '1.1.4';

src/constants/version.ts

@@ -105,6 +105,10 @@ export const createVmtUser = async (
         ? requestBody.accountType
         : VmtAccountType.facilitator;
 
+    if (requestBodyType === 'google' && requestBody.username) {
+      username = requestBody.username;
+    }
+
     let vmtUserBody = {
       firstName,
       lastName,
@@ -114,12 +118,23 @@ export const createVmtUser = async (
       accountType,
       isEmailConfirmed,
       rooms: requestBody.rooms,
+      courses: requestBody.courses,
     };
 
+    // temp or imported user, preexisting data
     let wasFromTempUser =
-      Array.isArray(requestBody.rooms) && requestBody.rooms.length > 0;
+      (Array.isArray(requestBody.rooms) && requestBody.rooms.length > 0) ||
+      (Array.isArray(requestBody.courses) && requestBody.courses.length > 0);
+    // catch an imported proxy course user and confirm email, as it may not exist
+    if (Array.isArray(requestBody.courses) && requestBody.courses.length > 0) {
+      vmtUserBody = {
+        ...vmtUserBody,
+        isEmailConfirmed: true,
+      };
+    }
 
     let vmtUser;
+    // For any user with prior data, find and update that VMT user with mt login data
     if (wasFromTempUser) {
       vmtUser = await VmtUser.findByIdAndUpdate(requestBody._id, vmtUserBody, {
         new: true,

src/controllers/localSignup.ts

@@ -126,10 +126,57 @@ export const googleCallback = async (
 
       let isNewUser = isNil(mtUser.encUserId);
 
+      if (!isNewUser) {
+        // catch if pending user data was not added to existing VMT user
+        // Matches for VMT user with same email and 'pending' accountType
+        // env toggle to enable feature
+        if (
+          process.env.VMT_YES_TO_CONVT_PENDING &&
+          process.env.VMT_YES_TO_CONVT_PENDING.toLowerCase() === 'yes'
+        ) {
+          // find VMT user with data
+          const vmtPendingData = await VmtUser.findOne({
+            email: mtUser.email,
+            accountType: 'pending',
+          });
+          // find duplicate VMT user to remove
+          const vmtMTdata = await VmtUser.findOne({
+            email: mtUser.email,
+            ssoId: mtUser._id,
+          });
+          if (
+            vmtPendingData &&
+            vmtPendingData.accountType === 'pending' &&
+            vmtMTdata
+          ) {
+            // Swap linked Ids to link sso account with VMT account with data
+            await VmtUser.findByIdAndUpdate(vmtPendingData._id, {
+              ssoId: mtUser._id,
+              accountType: 'facilitator',
+              isEmailConfirmed: true,
+            });
+            mtUser.vmtUserId = vmtPendingData._id;
+            await mtUser.save();
+
+            // invalidate or delete duplicate record
+            await VmtUser.findByIdAndUpdate(vmtMTdata._id, {
+              isTrashed: true,
+              accountType: 'temp',
+              email: '',
+            });
+            // await VmtUser.findByIdAndUpdate(vmtMTdata._id, { ssoId: '' });
+            // await VmtUser.findByIdAndDelete(vmtMTdata._id);
+          }
+        }
+      }
+
       if (isNewUser) {
+        // check to see if the email is pre-loaded to VMT with user-data
+        const vmtUserData = await VmtUser.findOne({ email: mtUser.email });
+
         [encUser, vmtUser] = await Promise.all([
           createEncUser(mtUser, {}, 'google'),
-          createVmtUser(mtUser, {}, 'google'),
+          createVmtUser(mtUser, vmtUserData || {}, 'google'),
         ]);
 
         if (encUser === null || vmtUser === null) {

src/controllers/oauth/google.ts

@@ -250,6 +250,7 @@ export const createVmtCounterparts = async function(): Promise<void> {
     encDb.close();
   } catch (err) {
     console.log('ERRR', err);
-    throw new Error(err.message);
+    const { message } = err as Error;
+    throw new Error(message);
   }
 };

src/db_migration/addEncUsers.ts

@@ -206,7 +206,8 @@ export const createEncCounterparts = async function(): Promise<void> {
     encDb.close();
   } catch (err) {
     console.log('ERRR', err);
-    throw new Error(err.message);
+    const { message } = err as Error;
+    throw new Error(message);
   }
 };
 

src/db_migration/addVmtUsers.ts

@@ -5,7 +5,14 @@ export const connect = function connectToDb(
 ): Promise<mongoose.Connection> {
   return new Promise(
     (resolve, reject): void => {
-      const db = mongoose.createConnection(url, { useNewUrlParser: true });
+      const mongoOptions = {
+        ssl: true,
+        sslValidate: true,
+        user: process.env.MT_DB_USER,
+        pass: process.env.MT_DB_PASS,
+        useNewUrlParser: true,
+      };
+      const db = mongoose.createConnection(url, mongoOptions);
 
       db.on(
         'error',

src/db_migration/utils.ts

@@ -1,11 +1,44 @@
 import mongoose from 'mongoose';
+import { version } from '../constants/version';
+const fs = require('fs');
 
 export default (): void => {
   let uri = process.env.MT_DB_URI;
   if (typeof uri !== 'string') {
     return;
   }
-  mongoose.connect(uri, { useNewUrlParser: true });
+  let mongoOptions = {};
+  if (process.env.NODE_ENV === 'production') {
+    uri = process.env.MT_PROD_URI;
+    mongoOptions = {
+      ssl: true,
+      sslValidate: true,
+      user: process.env.MT_PROD_DB_USER,
+      pass: process.env.MT_PROD_DB_PASS,
+      sslKey: fs.readFileSync(process.env.MT_PROD_DB_SSL_KEY_DIR),
+      sslCert: fs.readFileSync(process.env.MT_PROD_DB_SSL_CERT_DIR),
+      authSource: process.env.MT_PROD_DB_AUTHDB,
+      useNewUrlParser: true,
+    };
+  } else if (process.env.NODE_ENV === 'staging') {
+    uri = process.env.MT_STAGE_URI;
+    mongoOptions = {
+      ssl: true,
+      sslValidate: true,
+      user: process.env.MT_STAGE_DB_USER,
+      pass: process.env.MT_STAGE_DB_PASS,
+      sslKey: fs.readFileSync(process.env.MT_STAGE_DB_SSL_KEY_DIR),
+      sslCert: fs.readFileSync(process.env.MT_STAGE_DB_SSL_CERT_DIR),
+      authSource: process.env.MT_STAGE_DB_AUTHDB,
+      useNewUrlParser: true,
+    };
+  } else {
+    mongoOptions = {
+      useNewUrlParser: true,
+    };
+  }
+
+  mongoose.connect(uri, mongoOptions);
 
   const db = mongoose.connection;
 
@@ -20,6 +53,7 @@ export default (): void => {
     'open',
     (): void => {
       console.log(`Successfully connected to ${uri}`);
+      console.log(`MT-SSO version v.${version}`);
     },
   );
 };