lms-sync 1.0.83 → 1.0.85

package/apiConnections/mapping.js

@@ -4,6 +4,7 @@ const api = require('../apiConnections/apiConnects')
 const moment = require('moment')
 const { Picked } = require('./semesterPick')
 const Mixins = require('../utils/Mixins')
+const bcrypt = require('bcrypt');
 
 const {
     AcademicDepartments,
@@ -746,13 +747,17 @@ const server = {
                     let referenceId = _instructor?.id // id of the data
                     let isMigrated = true 
                     
+                    const saltRounds = 10; // Number of salt rounds
+
                     let firstName =  _instructor?.first_name
                     let lastName =  _instructor?.last_name
                     let middleName =  _instructor?.middle_name
                     let getUserName = Mixins.generateUsername(firstName, lastName)
                     let email = `${getUserName}@msumarinduque.edu.ph`
-                    let password = `${getUserName}`
-                    let temporaryPassword = password
+                    let password = getUserName
+                    const hashedPassword = await bcrypt.hash(password, saltRounds);
+
+                    let temporaryPassword = getUserName
                     let adminScopes = []
 
                     let employeeNumber =  _instructor?.faculty_id 
@@ -792,8 +797,8 @@ const server = {
                             firstName: _instructor?.first_name,
                             lastName: _instructor?.last_name,
                             middleName: _instructor?.middle_name,
-                            password: password, 
-                            temporaryPassword: password,
+                            password: hashedPassword, 
+                            temporaryPassword: getUserName,
                             email,
                             modifiedById,
                             createdById,
@@ -1975,10 +1980,6 @@ const server = {
             const yearDefault = await AcademicYears.findOne({ where: { from: 1799, to: 1800 } }); 
             const semeDefault = await Semesters.findOne({ where: { code: '1st Semester' }});
 
-
-          
-   
-
             let createdCounter = 0
             let errorCounter = 0
             let uniqueErrors = new Set()
@@ -2038,6 +2039,8 @@ const server = {
                     let defSem = semeDefault?._id
                     let defYear = yearDefault?._id
 
+                    const saltRounds = 10; // Number of salt rounds
+
                     let studentNumber = _student?.student_number
                     let firstName = _student?.first_name
                     let lastName = _student?.last_name
@@ -2048,7 +2051,9 @@ const server = {
                     let getUserName = Mixins.generateUsername(firstName, lastName)
                     let email = `${getUserName}@msumarinduque.edu.ph`
                     let password = `${getUserName}`
-                    let temporaryPassword = password
+                    
+                    const hashedPassword = await bcrypt.hash(password, saltRounds);
+                    let temporaryPassword = getUserName
                     let adminScopes = []
 
                     let migratedAt = new Date() //present date of the migration
@@ -2056,6 +2061,8 @@ const server = {
                     let referenceId = _student?.id // id of the data
                     let isMigrated = true 
 
+
+
                     if(uEmail.has(email) && uPass.has(password) && uTPass.has(temporaryPassword) && uULname.has(lastName) && uUFname.has(firstName) && uUMname.has(middleName) && uScopes.has(adminScopes)){
                         const errorMsg = `Duplicate Payload Found: [${email} - ${password} ${temporaryPassword}] - ${lastName}, ${firstName} ${middleName} ${adminScopes}`
                         if(!uniqueErrors.has(errorMsg)){
@@ -2085,8 +2092,8 @@ const server = {
                             firstName: _student?.first_name,
                             lastName: _student?.last_name,
                             middleName: _student?.middle_name,
-                            password: password, 
-                            temporaryPassword: password,
+                            password: hashedPassword, 
+                            temporaryPassword: getUserName,
                             email,
                             modifiedById,
                             createdById,

package/apiConnections/mappings-old.js

@@ -656,6 +656,339 @@ const server = {
         }
     },
 
+    async Instructor(){
+        let userIds = []
+        await db.sequelize.query('DROP FUNCTION IF EXISTS pg_temp.testfunc()');
+
+        try {
+            console.log("");
+            console.log("########################################################")
+            console.log("                 Instructors Migrations ")
+            console.log("########################################################")
+            console.log("");
+
+            const db_schema = schema
+            let maxIds = await Users.max('_id'); //Fetch maximum _id directly from the Users model
+            let maxIdsIns = await Instructors.max('_id'); //Fetch maximum _id directly from the Users model
+
+            // console.log('maxIdsIns :>> ', maxIdsIns);
+
+            let maxId = maxIds|| 0;
+            let maxIdIns = maxIdsIns|| 0;
+
+            // console.log('maxIdIns :>> ', maxIdIns);
+
+            await db.sequelize.query(`CREATE SEQUENCE IF NOT EXISTS ${db_schema}."Users__id_seq"`);      
+            await db.sequelize.query(`ALTER SEQUENCE ${db_schema}."Users__id_seq" RESTART WITH ${maxId + 1}`);
+
+            await db.sequelize.query(`CREATE SEQUENCE IF NOT EXISTS ${db_schema}."Instructors__id_seq"`);      
+            await db.sequelize.query(`ALTER SEQUENCE ${db_schema}."Instructors__id_seq" RESTART WITH ${maxIdIns + 1}`);
+            await db.sequelize.query(`DROP FUNCTION IF EXISTS ${db_schema}."pg_temp.testfunc()"`);
+
+            const instructorApi = await api.Instructor()
+            const departmentApi = await api.Department()
+
+            let userDefPayload = {
+                email: 'ccci_integrator@gmail.com',
+                password: '$2a$12$Q.h3Q9IN6vsIxGBa/EgfOOABeXTcwxt4t9cu4nqAK.nczGRRtZJUS',
+                temporaryPassword: 'P@ssw0rd123',
+                firstName: 'Androi',
+                lastName: 'Pamisaran',
+                adminScopes: [],
+                createdAt: new Date(),
+                updatedAt: new Date()
+            };
+            
+            let [userDefault, createdUser] = await Users.findOrCreate({
+                where: { email: userDefPayload.email }, 
+                defaults: userDefPayload 
+            }); 
+
+            const departmentSeq = await AcademicDepartments.findAll()
+            const campusSeq = await Campuses.findAll()
+            const employeeSeq = await Employees.findAll()
+            const userSeq = await Users.findAll()
+
+            const userMail = await Users.findOne({ where: { email: 'ccci_integrator@gmail.com' } });
+            if (!userMail){}   
+
+            const campusDefault = await Campuses.findOne({ where: { name: 'Campus Default' } });     
+            const departmentDefault = await AcademicDepartments.findOne({ where: { name: 'AcademicDepartments Default' } });   
+ 
+            let defaultPayload = {
+                firstName: 'Instructor',
+                lastName: 'Default',
+                middleName: 'Migration',
+                employeeNumber: '_Instructor', 
+                departmentId: departmentDefault?._id,
+                campusId: campusDefault?._id,
+                modifiedById: userMail?._id,
+                createdById: userMail?._id
+            };
+            
+            let [defaults, createddef] = await Instructors.findOrCreate({
+                where: { employeeNumber: defaultPayload.employeeNumber, lastName: defaultPayload.lastName}, 
+                defaults: defaultPayload 
+            });
+
+            let createdCounter = 0
+            let errorCounter = 0
+            let uniqueErrors = new Set()
+
+            let uEmail = new Set()
+            let uPass = new Set()
+            let uTPass = new Set()
+            let uULname = new Set()
+            let uUFname = new Set()
+            let uUMname = new Set()
+            let uScopes = new Set()
+
+            let newUser = []
+
+            const exUser = await Users.findAll()
+            const exUserMap = new Map(exUser.map(usr => [`[${usr.email} - ${usr.password} ${usr.temporaryPassword}] - ${usr.lastName}, ${usr.firstName} ${usr.middleName} ${usr.adminScopes}`, usr]))
+
+            let uDept = new Set()
+            let uCamp = new Set()
+            let uLname = new Set()
+            let uMname = new Set()
+            let uFname = new Set()
+            let uNum = new Set()
+
+            let newInstructor = []
+
+            const exInst = await Instructors.findAll()
+            const exInstMap = new Map(exInst.map(inst => [`[${inst.employeeNumber}] - ${inst.lastName}, ${inst.firstName} ${inst.middleName} [${inst.departmentId}, ${inst.campusId}]` , inst]))
+
+            for (let i = 0; i < instructorApi.length; i++){
+                try {
+                    let _instructor = instructorApi[i]
+
+                    let acadDepartmentMap = departmentApi.find(a => a.name === _instructor?.department_name)
+                    let _acadDepartment = departmentSeq.find(b => b.name === acadDepartmentMap?.name)
+                    let campusMap = campusSeq.find(c => c._id === _acadDepartment?.campusId)
+
+                    let employeeFind = employeeSeq.find(emps => emps.employeeNumber === _instructor?.faculty_id)
+                    let userFind = userSeq.find(eus => eus._id === employeeFind?.userId)
+                    let _userFind = userSeq.find(e => e.firstName === _instructor?.first_name && e.middleName === _instructor?.middle_name && e.lastName === _instructor?.last_name)
+
+                    // console.log('userFind :>> ', userFind);
+
+                    if(!employeeFind){}
+                    if(!userFind){}
+                    
+                    let modifiedById = userMail?._id
+                    let createdById = userMail?._id
+
+                    let campusDefault = "MSC - Boac Campus"
+                    let _campusDefault = campusSeq.find(ccc => ccc.name === campusDefault)
+
+                    let role =  _instructor?.role
+                    let isChairPerson = false
+                    let isDean = false
+                    
+                    if(role === "Program Chair"){
+                        isChairPerson = true
+                    }
+                    if(role === "Dean"){
+                        isDean = true
+                    }
+
+                    let migratedAt = new Date() //present date of the migration
+                    let migratedTable = 'Instructors' // sql counterpart main table
+                    let referenceId = _instructor?.id // id of the data
+                    let isMigrated = true 
+                    
+                    let firstName =  _instructor?.first_name
+                    let lastName =  _instructor?.last_name
+                    let middleName =  _instructor?.middle_name
+                    let getUserName = Mixins.generateUsername(firstName, lastName)
+                    let email = `${getUserName}@msumarinduque.edu.ph`
+                    let password = `${getUserName}`
+                    let temporaryPassword = password
+                    let adminScopes = []
+
+                    let employeeNumber =  _instructor?.faculty_id 
+                    let departmentId =  _acadDepartment?._id??departmentDefault?._id
+                    let campusId =  campusMap?._id??_campusDefault?._id
+                    let employeeId = employeeFind?._id??null
+                    let userId = userFind?._id??_userFind?._id
+
+                    // console.log('userId :>> ', userId);
+
+                    let [record, created] = await Users.findOrCreate({
+                        where: {
+                            firstName: _instructor?.first_name,
+                            lastName: _instructor?.last_name,
+                            middleName: _instructor?.middle_name,
+                            password: password, 
+                            temporaryPassword: password,
+                            email,
+                            modifiedById,
+                            createdById,
+                            adminScopes,
+                            migratedAt,
+                            migratedTable,
+                            // referenceId,
+                            isMigrated,
+                        },
+                        defaults:{
+
+                        }
+                    })
+
+                    if(created){
+                        console.log('record.password :>> ', record.password);
+                    }
+                    // if(uEmail.has(email) && uPass.has(password) && uTPass.has(temporaryPassword) && uULname.has(lastName) && uUFname.has(firstName) && uUMname.has(middleName) && uScopes.has(adminScopes)){
+                    //     const errorMsg = `Duplicate Payload Found: [${email} - ${password} ${temporaryPassword}] - ${lastName}, ${firstName} ${middleName} ${adminScopes}`
+                    //     if(!uniqueErrors.has(errorMsg)){
+                    //         // logger.error(`${errorCounter + 1}/${errorCounter + 1}: ${errorMsg}`)
+                    //         uniqueErrors.add(errorMsg)
+                    //         // errorCounter++
+                    //       }
+                    // }
+                    // else if (exUserMap.has(`[${email} - ${password} ${temporaryPassword}] - ${lastName}, ${firstName} ${middleName} ${adminScopes}`)){
+                    //     const exUser = exUserMap.get(`[${email} - ${password} ${temporaryPassword}] - ${lastName}, ${firstName} ${middleName} ${adminScopes}`)
+                    //     const errorMsg = `Existing Data Found: [${exUser.email} - ${exUser.password} ${exUser.temporaryPassword}] - ${exUser.lastName}, ${exUser.firstName} ${exUser.middleName} ${exUser.adminScopes}`
+                    //     if(!uniqueErrors.has(errorMsg)){
+                    //     //   logger.error(`${errorCounter + 1}/${errorCounter + 1}: ${errorMsg}`)
+                    //       uniqueErrors.add(errorMsg)
+                    //     //   errorCounter++
+                    //     }
+                    //   }
+                    // else{
+                    //     uEmail.add(email)
+                    //     uPass.add(password)
+                    //     uTPass.add(temporaryPassword)
+                    //     uULname.add(lastName)
+                    //     uUFname.add(firstName)
+                    //     uUMname.add(middleName)
+                    //     uScopes.add(adminScopes)
+                    //     newUser.push({
+                    //         firstName: _instructor?.first_name,
+                    //         lastName: _instructor?.last_name,
+                    //         middleName: _instructor?.middle_name,
+                    //         password: password, 
+                    //         temporaryPassword: password,
+                    //         email,
+                    //         modifiedById,
+                    //         createdById,
+                    //         adminScopes,
+                    //         migratedAt,
+                    //         migratedTable,
+                    //         // referenceId,
+                    //         isMigrated,
+                    //     })
+                    // }      
+                    
+
+
+
+                    // if(uNum.has(employeeNumber) && uLname.has(lastName) && uFname.has(firstName) && uMname.has(middleName) && uDept.has(departmentId) && uCamp.has(campusId)){
+                    //     const errorMsg = `Duplicate Payload Found: [${employeeNumber}] - ${lastName}, ${firstName} ${middleName} [departmentId: ${departmentId}, campusId:${campusId}]`
+                    //   if(!uniqueErrors.has(errorMsg)){
+                    //     logger.error(`${errorCounter + 1}/${errorCounter + 1}: ${errorMsg}`)
+                    //     uniqueErrors.add(errorMsg)
+                    //     errorCounter++
+                    //   }
+                    // }
+                    // else if ( exInstMap.has(`[${employeeNumber}] - ${lastName}, ${firstName} ${middleName} [${departmentId}, ${campusId}]`)){
+                    //     const exInst = exInstMap.get(`[${employeeNumber}] - ${lastName}, ${firstName} ${middleName} [${departmentId}, ${campusId}]`)
+                    //     const errorMsg = `Existing Data Found:[${exInst.employeeNumber}] - ${exInst.lastName}, ${exInst.firstName} ${exInst.middleName} [departmentId: ${exInst.departmentId}, campusId: ${exInst.campusId}]`
+                    //     if(!uniqueErrors.has(errorMsg)){
+                    //       logger.error(`${errorCounter + 1}/${errorCounter + 1}: ${errorMsg}`)
+                    //       uniqueErrors.add(errorMsg)
+                    //       errorCounter++
+                    //     }
+                    //   }
+                    // else{
+                    //     uNum.add(employeeNumber)
+                    //     uLname.add(lastName)
+                    //     uFname.add(firstName)
+                    //     uMname.add(middleName)
+                    //     uDept.add(departmentId)
+                    //     uCamp.add(campusId)
+                    //     newInstructor.push({
+                    //         firstName: _instructor?.first_name,
+                    //         lastName: _instructor?.last_name,
+                    //         middleName: _instructor?.middle_name,
+                    //         employeeNumber: _instructor?.faculty_id, 
+                    //         departmentId: _acadDepartment?._id??departmentDefault?._id,
+                    //         academicDepartmentId: _acadDepartment?._id??departmentDefault?._id,
+                    //         campusId: campusMap?._id??_campusDefault?._id??campusDefault?._id,
+                    //         isDean,
+                    //         isChairPerson,
+                    //         modifiedById,
+                    //         createdById,
+                    //         migratedAt,
+                    //         migratedTable,
+                    //         // referenceId,
+                    //         isMigrated,
+                    //         userId: userId || null,
+                    //         employeeId,
+                    //     })
+                    // }
+
+                } catch (error) {
+                logger.error(`Error occurred: ${error} ${error.stack}`);
+                }   
+            }
+
+            // if (newUser.length > 0) {
+            //     const createdUser = await Users.bulkCreate(newUser, {returning: true})
+            //     userIds = createdUser.map(_user => _user._id) // Remove const or let
+            //     // createdCounter += newUser.length
+            //     newUser.forEach((user, index) => {
+            //         // logger.info(`${index + 1}/${index + 1}: New Instructor User Record Created: [${user.email} - ${user.password} ${user.temporaryPassword}] - ${user.lastName}, ${user.firstName} ${user.middleName} ${user.adminScopes}`)
+            //     });
+            // }
+            
+
+            // if (newInstructor.length > 0) {
+            //     // Associate userIds with new instructors
+            //     // if(!newInstructor.userId){
+            //     //     newInstructor = newInstructor.map((inst, index) => ({
+            //     //         ...inst,
+            //     //         userId: userIds[index]
+            //     //     }));
+            //     // }
+            //     await Instructors.bulkCreate(newInstructor);
+            //     createdCounter += newInstructor.length;
+    
+            //     newInstructor.forEach((inst, index) => {
+            //         logger.info(`${index + 1}/${index + 1}: New Instructor Record Created: [${inst.employeeNumber}] - ${inst.lastName}, ${inst.firstName} ${inst.middleName} [ departmentId: ${inst.departmentId}, campusId: ${inst.campusId}]`);
+            //     });
+            // }
+            
+
+
+            console.log("");
+            console.log("########################################################")
+            console.log("")
+            logger.info('Instructors Data Migration Completed');
+            logger.info(`Total Successful Instructors Records Created: ${createdCounter}/${createdCounter}`);
+            logger.info(`Total Existing Instructors Records: ${errorCounter}/${errorCounter}`);
+            logger.info(`Total Records: ${createdCounter + errorCounter}`);
+            console.log("")
+            console.log("########################################################")
+            console.log("")
+
+                let totalSummary = {
+                  itemLength: createdCounter + errorCounter,
+                  error: errorCounter,
+                  success: createdCounter
+                }
+                return totalSummary
+
+        } catch (error) {
+                        ;
+            logger.error(`Error occurred: ${error} ${error.stack} `);
+            
+        }
+    },
+
+
     async AcademicYear(){
         try {
             console.log("");

package/login.json

@@ -0,0 +1,5 @@
+{
+    "email": "ictsc@mscmarinduque.edu.ph",
+    "password": "MjU8qweXLaFpDnEyfRrbY9",
+    "baseURL": "https://lms.api.msc.priisms.online/api"
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lms-sync",
-  "version": "1.0.83",
+  "version": "1.0.85",
   "description": "Migration App for MSC LMS",
   "main": "index.js",
   "scripts": {

package/target.json

@@ -0,0 +1,9 @@
+{
+    "host": "188.166.212.92",
+    "username": "migration",
+    "database": "migration",
+    "password": "Admin123",
+    "dialect": "postgres",
+    "schema": "public_migrations",
+    "logging": false  
+}