lms-sync 1.0.45 → 1.0.47

package/apiConnections/mapping.js

@@ -3,6 +3,7 @@ const logger = require('../utils/logger')
 const api = require('../apiConnections/apiConnects')
 const moment = require('moment')
 const { Picked } = require('./semesterPick')
+const Mixins = require('../utils/Mixins')
 
 const {
     AcademicDepartments,
@@ -38,9 +39,8 @@ const server = {
             let maxIdsUser = await Users.max('_id'); //Fetch maximum _id directly from the campuses model
 
             let maxId = maxIds|| 0;
-            let maxIdSems = maxIdsSem|| 0;
-            let maxIdUsers = maxIdsUser|| 0;
-
+            let maxIdSems = maxIdsSem || 0;
+            let maxIdUsers = maxIdsUser || 0;
 
             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 ${maxIdUsers + 1}`);  
@@ -135,8 +135,6 @@ const server = {
             let errorCounter = 0
             let uniqueErrors = new Set()
 
-            
-
             let uCode = new Set()
             let uName = new Set()
 
@@ -156,6 +154,11 @@ const server = {
                     let name = _campus?.name
                     let code = _campus?.code
 
+                    let migratedAt = new Date() //present date of the migration
+                    let migratedTable = 'Campuses' // sql counterpart main table
+                    let referenceId = _campus?.id // id of the data
+                    let isMigrated = true 
+
                     if(uCode.has(code) && uName.has(name)){
                         const errorMsg = `Duplicate Payload Found: [${code}] - ${name}`
                       if(!uniqueErrors.has(errorMsg)){
@@ -183,10 +186,10 @@ const server = {
                             address: _campus?.address,
                             modifiedById,
                             createdById,
-                            // migratedAt,
-                            // migratedTable,
-                            // referenceId,
-                            // isMigrated
+                            migratedAt,
+                            migratedTable,
+                            referenceId,
+                            isMigrated
                         })
                     }
                     
@@ -267,12 +270,7 @@ const server = {
 
             let createdCounter = 0
             let errorCounter = 0
-            let uniqueErrors = new Set()
-
-            // let migratedAt = new Date() //present date of the migration
-            // let migratedTable = 'colleges' // sql counterpart main table
-            // let referenceId = collegeApi.id // id of the data
-            // let isMigrated = true           
+            let uniqueErrors = new Set()          
 
             let uCode = new Set()
             let uName = new Set()
@@ -296,6 +294,11 @@ const server = {
                     let name = _college?.name
                     let code = _college?.code
 
+                    let migratedAt = new Date() //present date of the migration
+                    let migratedTable = 'Colleges' // sql counterpart main table
+                    let referenceId = _college.id // id of the data
+                    let isMigrated = true 
+
                     if(uCode.has(code) && uName.has(name)){
                         const errorMsg = `Duplicate Payload Found: [${code}] - ${name}`
                       if(!uniqueErrors.has(errorMsg)){
@@ -321,7 +324,15 @@ const server = {
                             code: _college?.code,
                             campusId: _campus?._id??campusDefault?._id,
                             modifiedById,
-                            createdById
+                            createdById,
+                            migratedAt,
+                            migratedTable,
+                            referenceId,
+                            isMigrated,
+                            migratedAt,
+                            migratedTable,
+                            referenceId,
+                            isMigrated
                         })
                     }
                     
@@ -372,7 +383,7 @@ const server = {
         try {
             console.log("");
             console.log("########################################################")
-            console.log("                       Academic Departments Migration ")
+            console.log("            Academic Departments Migration ")
             console.log("########################################################")
             console.log("");
 
@@ -424,6 +435,7 @@ const server = {
             let newAcadDeptTwo = []
             const exAcadDeptTwo = await AcademicDepartments.findAll()
             const exAcadDeptMapTwo = new Map(exAcadDeptTwo.map(dept => [`[${dept.code}] - ${dept.name}`, dept]))
+            
 
             for (let i = 0; i < departmentApi.length; i++){
                 try {
@@ -438,6 +450,11 @@ const server = {
                     let name = _acadDept?.name
                     let code = _acadDept?.code
 
+                    let migratedAt = new Date() //present date of the migration
+                    let migratedTable = 'Departments' // sql counterpart main table
+                    let referenceId = _acadDept.id // id of the data
+                    let isMigrated = true 
+
                     if(uCode.has(code) && uName.has(name)){
                         const errorMsg = `Duplicate Payload Found: [${code}] - ${name}`
                       if(!uniqueErrors.has(errorMsg)){
@@ -464,7 +481,11 @@ const server = {
                             collegeId: _college?._id??collegeDefault?._id,
                             campusId: campus?._id??campusDefault?._id, 
                             modifiedById,
-                            createdById
+                            createdById,
+                            migratedAt,
+                            migratedTable,
+                            referenceId,
+                            isMigrated
                         })
                     }
                 } catch (error) {
@@ -572,6 +593,279 @@ const server = {
     },
 
     async Instructor(){
+        let userIds = []
+        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
+
+            let maxId = maxIds|| 0;
+            let maxIdIns = maxIdsIns|| 0;
+
+            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}`);
+
+            const instructorApi = await api.Instructor()
+            const departmentApi = await api.Department()
+
+            const departmentSeq = await AcademicDepartments.findAll()
+            const campusSeq = await Campuses.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 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
+
+                    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,
+                        })
+                    }      
+                    
+                    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
+                        })
+                    }
+
+                } 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
+                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}]`);
+                });
+            }
+
+
+            // if (newInstructor.length > 0) {
+                
+            //     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('User Instructors Data Creation Completed');
+            logger.info(`Total successful User Instructors records created: ${createdCounter}/${createdCounter}`);
+            logger.info(`Total User Instructors Error 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 Instructorsss(){
         try {
             console.log("");
             console.log("########################################################")
@@ -590,8 +884,10 @@ const server = {
 
             const departmentSeq = await AcademicDepartments.findAll()
             const campusSeq = await Campuses.findAll()
-            const instructorSeq = await Instructors.findAll()
-            const userMail = await Users.findOne({ where: { email: 'ccci_integrator@gmail.com' } });  
+            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' } });   
  
@@ -627,16 +923,18 @@ const server = {
             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 findUser = await userSeq.find( f => f.lastName === _instructor?.last_name && f.firstName === _instructor?.first_name && f.middleName === _instructor?.middle_name)
 
                     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 modifiedById = userMail?._id
                     let createdById = userMail?._id
 
@@ -644,7 +942,6 @@ const server = {
                     let _campusDefault = campusSeq.find(ccc => ccc.name === campusDefault)
 
                     let role =  _instructor?.role
-
                     let isChairPerson = false
                     let isDean = false
                     
@@ -661,6 +958,7 @@ const server = {
                     let employeeNumber =  _instructor?.faculty_id 
                     let departmentId =  _acadDepartment?._id??departmentDefault?._id
                     let campusId =  campusMap?._id??_campusDefault?._id
+                    let userId = findUser?._id
 
                     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}]`
@@ -698,11 +996,12 @@ const server = {
                             isChairPerson,
                             modifiedById,
                             createdById,
+                            userId
                         })
                     }
                     
                 } catch (error) {
-            logger.error(`Error occurred: ${error} ${error.stack}`);
+                logger.error(`Error occurred: ${error} ${error.stack}`);
                 }   
             }
 
@@ -717,7 +1016,6 @@ const server = {
 
             }
 
-
             console.log("");
             console.log("########################################################")
             console.log("")
@@ -823,6 +1121,10 @@ const server = {
                           let campusId =  campus?._id??null
                           let departmentId =  _department?._id??null
 
+                          let migratedAt = new Date() //present date of the migration
+                          let migratedTable = 'Courses' // sql counterpart main table
+                          let referenceId = courseCode?.id // id of the data
+                          let isMigrated = true 
 
 
                           if(uCode.has(code) && uName.has(name) && uMajor.has(major) && uCampus.has(campusId) && uDept.has(departmentId)){
@@ -855,7 +1157,11 @@ const server = {
                                 campusId: campus?._id??campusDefault?._id,
                                 departmentId: _department?._id??departmentDefault?._id,
                                 modifiedById,
-                                createdById
+                                createdById,
+                                migratedAt,
+                                migratedTable,
+                                referenceId,
+                                isMigrated
                             })
                         }
                     
@@ -969,6 +1275,11 @@ const server = {
                     let modifiedById = userMail?._id
                     let createdById = userMail?._id
 
+                    let migratedAt = new Date() //present date of the migration
+                    let migratedTable = 'Rooms' // sql counterpart main table
+                    let referenceId = _room?.id // id of the data
+                    let isMigrated = true 
+
                     let name =  _room?.name
                     let campusId =  _campus?._id??_campusDefault?._id??null
 
@@ -997,7 +1308,11 @@ const server = {
                             campusId: _campus?._id??_campusDefault?._id??campusesDefault._id,
                             capacity,
                             modifiedById,
-                            createdById
+                            createdById,
+                            migratedAt,
+                            migratedTable,
+                            referenceId,
+                            isMigrated
                         })
                     }
                     
@@ -1093,6 +1408,11 @@ const server = {
                     let modifiedById = userMail?._id
                     let createdById = userMail?._id
 
+                    let migratedAt = new Date() //present date of the migration
+                    let migratedTable = 'AcademicYears' // sql counterpart main table
+                    let referenceId = _acadyear?.id // id of the data
+                    let isMigrated = true 
+
 
                     if(uFrom.has(from) && uTo.has(to)){
                         const errorMsg = `Duplicate Payload Found: [${from} - ${to}]`
@@ -1119,7 +1439,11 @@ const server = {
                             to,
                             modifiedById,
                             createdById,
-                            default: isDefault
+                            default: isDefault,
+                            migratedAt,
+                            migratedTable,
+                            referenceId,
+                            isMigrated
                         })
                     }
                     
@@ -1247,6 +1571,11 @@ const server = {
                         let departmentId = _department?._id??departmentDefault?._id
                         let description = _description
 
+                        let migratedAt = new Date() //present date of the migration
+                        let migratedTable = 'Subjects' // sql counterpart main table
+                        let referenceId = _subjects?.subject_id // id of the data
+                        let isMigrated = true 
+
                         if(uCode.has(code) && uName.has(name) && uDescription.has(description) && uUnits.has(units) && uDept.has(departmentId)){
                             const errorMsg = `Duplicate Payload Found: [${code}] - ${name} [units: ${units}, departmentId: ${departmentId}]`
                           if(!uniqueErrors.has(errorMsg)){
@@ -1279,10 +1608,10 @@ const server = {
                                  description,
                                 modifiedById,
                                 createdById,
-                                // migratedAt,
-                                // migratedTable,
-                                // referenceId,
-                                // isMigrated
+                                migratedAt,
+                                migratedTable,
+                                referenceId,
+                                isMigrated
                             })
                         }
 
@@ -1395,6 +1724,11 @@ const server = {
 
                     let days = null
 
+                    let migratedAt = new Date() //present date of the migration
+                    let migratedTable = 'Schedules' // sql counterpart main table
+                    let referenceId = _schedule?.schedule_id // id of the data
+                    let isMigrated = true 
+
                     if (dayHandler.length > 1) {
                         days = dayHandler[0].split('').map(day => dayMappings[day]).join(', ');
                     } else {
@@ -1433,12 +1767,11 @@ const server = {
                             to : etFormat??to,
                             days,
                             modifiedById,
-                            createdById
-
-                            // migratedAt,
-                            // migratedTable,
-                            // referenceId,
-                            // isMigrated
+                            createdById,
+                            migratedAt,
+                            migratedTable,
+                            referenceId,
+                            isMigrated
                         })
                     }
                 } catch (error) {
@@ -1481,6 +1814,7 @@ const server = {
     },
 
     async Student(){
+        let userIds = []
         try {
             console.log("");
             console.log("########################################################")
@@ -1489,8 +1823,15 @@ const server = {
             console.log("");
 
             const db_schema = schema
+            let maxIdsU = await Users.max('_id'); //Fetch maximum _id directly from the Users model
             let maxIds = await Students.max('_id'); // Fetch maximum _id directly from the Students model
+            
             let maxId = maxIds|| 0;
+            let maxIdU = maxIdsU|| 0;
+
+            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 ${maxIdU + 1}`);
+
             await db.sequelize.query(`CREATE SEQUENCE IF NOT EXISTS ${db_schema}."Students__id_seq"`);
             await db.sequelize.query(`ALTER SEQUENCE ${db_schema}."Students__id_seq" RESTART WITH ${maxId + 1}`);
 
@@ -1511,7 +1852,18 @@ const server = {
             let errorCounter = 0
             let uniqueErrors = new Set()
 
-            const emailDomain = 'default.msc.edu.ph';
+            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 uNum = new Set()
             let uLname = new Set()
@@ -1534,10 +1886,237 @@ const server = {
                     let _campus = campusSeq.find(a => a.name === _student?.campus)
                     let _course = courseSeq.find(b => b.name === _student?.course)
                     let _college = collegeSeq.find(c => c.name === _student?.college)
+
+                    let modifiedById = userMail?._id
+                    let createdById = userMail?._id
+
+                    let fromPrompts = await Picked()
+                
+                    // let semester = "2nd Semester"
+                    let semester = fromPrompts.semester
+                    let yearsFrom = fromPrompts.yearFrom
+                    let yearsTo = fromPrompts.yearTo
+
+                    let _semester = semesterSeq.find(sem => sem.code === semester)
+                    let _acadYear = acadYearSeq.find(yr => yr.from === parseInt(yearsFrom) && yr.to === parseInt(yearsTo))
+
+                    let studentNumber = _student?.student_number
+                    let firstName = _student?.first_name
+                    let lastName = _student?.last_name
+                    let middleName = _student?.middle_name
+                    let courseId = _course?._id??courseDefault?._id
+                    let campusId = _campus?._id??campusDefault?._id
+
+                    let getUserName = Mixins.generateUsername(firstName, lastName)
+                    let email = `${getUserName}@msumarinduque.edu.ph`
+                    let password = `${getUserName}`
+                    let temporaryPassword = password
+                    let adminScopes = []
+
+                    let migratedAt = new Date() //present date of the migration
+                    let migratedTable = 'Students' // sql counterpart main table
+                    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)){
+                            // 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: _student?.first_name,
+                            lastName: _student?.last_name,
+                            middleName: _student?.middle_name,
+                            password: password, 
+                            temporaryPassword: password,
+                            email,
+                            modifiedById,
+                            createdById,
+                            adminScopes,
+                        })
+                    }    
+
+                    if(uNum.has(studentNumber) && uLname.has(lastName) && uFname.has(firstName) && uMname.has(middleName) && uCourse.has(courseId) && uCampus.has(campusId)){
+                        const errorMsg = `Duplicate Payload Found: [${studentNumber}] - ${lastName}, ${firstName} ${middleName} [courseId: ${courseId}, campusId:${campusId}]`
+                      if(!uniqueErrors.has(errorMsg)){
+                        logger.error(`${errorCounter + 1}/${errorCounter + 1}: ${errorMsg}`)
+                        uniqueErrors.add(errorMsg)
+                        errorCounter++
+                      }
+                    }
+                    else if ( exStudentMap.has(`[${studentNumber}] - ${lastName}, ${firstName} ${middleName} [${courseId}, ${campusId}]`)){
+                        const exStudent = exStudentMap.get(`[${studentNumber}] - ${lastName}, ${firstName} ${middleName} [${courseId}, ${campusId}]`)
+                        const errorMsg = `Existing Data Found:[${exStudent.studentNumber}] - ${exStudent.lastName}, ${exStudent.firstName} ${exStudent.middleName} [courseId: ${exStudent.courseId}, campusId: ${exStudent.campusId}]`
+                        if(!uniqueErrors.has(errorMsg)){
+                          logger.error(`${errorCounter + 1}/${errorCounter + 1}: ${errorMsg}`)
+                          uniqueErrors.add(errorMsg)
+                          errorCounter++
+                        }
+                      }
+                    else{
+                        uNum.add(studentNumber)
+                        uLname.add(lastName)
+                        uMname.add(middleName)
+                        uFname.add(firstName)
+                        uCourse.add(courseId)
+                        uCampus.add(campusId)
+                        newStudent.push({
+                            studentNumber: _student?.student_number,
+                            firstName: _student?.first_name,
+                            lastName: _student?.last_name,
+                            middleName: _student?.middle_name,
+                            email: email,
+                            courseId: _course?._id??courseDefault?._id,
+                            campusId: _campus?._id??campusDefault?._id,
+                            collegeId: _college?._id??collegeDefault?._id,
+                            admittedYearId: _acadYear?._id ?? null,
+                            admittedSemId: _semester?._id ?? null,
+                            modifiedById,
+                            createdById,
+                            migratedAt,
+                            migratedTable,
+                            // referenceId,
+                            isMigrated
+                        })
+                    }
                     
-                    const getLastName = _student?.last_name.toLowerCase().replace(/\s/g, '') ?? "";
+                } catch (error) {
+                logger.error(`Error occurred: ${error.stack} ${error}`);
+                }
+            }
+
+            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 Student User Record Created: [${user.email} - ${user.password} ${user.temporaryPassword}] - ${user.lastName}, ${user.firstName} ${user.middleName} ${user.adminScopes}`)
+                });
+            }
+            
+            if (newStudent.length > 0) {
+                // Associate userIds with new students
+                newStudent = newStudent.map((exStudent, index) => ({
+                    ...exStudent,
+                    userId: userIds[index]
+                }));
+    
+                await Students.bulkCreate(newStudent);
+                createdCounter += newStudent.length;
+    
+                newStudent.forEach((exStudent, index) => {
+                    logger.info(`${index + 1}/${index + 1}: New Student Record Created: [${exStudent.studentNumber}] - ${exStudent.lastName}, ${exStudent.firstName} ${exStudent.middleName} [courseId: ${exStudent.courseId}, campusId: ${exStudent.campusId}]`)
+                 });
+            }
+
+            // if (newStudent.length > 0) {
+            //     await Students.bulkCreate(newStudent)
+            //     createdCounter += newStudent.length
+    
+            //     newStudent.forEach((exStudent, index) => {
+            //         logger.info(`${index + 1}/${index + 1}: New Student Record Created: [${exStudent.studentNumber}] - ${exStudent.lastName}, ${exStudent.firstName} ${exStudent.middleName} [courseId: ${exStudent.courseId}, campusId: ${exStudent.campusId}]`)
+            //     });
+            // }
+
+            console.log("");
+            console.log("########################################################")
+            console.log("")
+            logger.info('Student Data Migration Completed');
+            logger.info(`Total successful Student records created: ${createdCounter}/${createdCounter}`);
+            logger.info(`Total Student Error 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.stack} ${error}`);
+            
+        }
+    },
 
-                    let email = `${_student?.student_number}_${getLastName}@${emailDomain}`;
+    async Studentsss(){
+        try {
+            console.log("");
+            console.log("########################################################")
+            console.log("                       Students Migration ")
+            console.log("########################################################")
+            console.log("");
+
+            const db_schema = schema
+            let maxIds = await Students.max('_id'); // Fetch maximum _id directly from the Students model
+            let maxId = maxIds|| 0;
+            await db.sequelize.query(`CREATE SEQUENCE IF NOT EXISTS ${db_schema}."Students__id_seq"`);
+            await db.sequelize.query(`ALTER SEQUENCE ${db_schema}."Students__id_seq" RESTART WITH ${maxId + 1}`);
+
+            const studentApi = await api.Student()
+
+            const campusSeq = await Campuses.findAll()
+            const courseSeq = await Courses.findAll()
+            const collegeSeq = await Colleges.findAll()
+            const semesterSeq = await Semesters.findAll()
+            const acadYearSeq = await AcademicYears.findAll()
+            const userSeq = await Users.findAll() 
+
+            const userMail = await Users.findOne({ where: { email: 'ccci_integrator@gmail.com' } });    
+            const campusDefault = await Campuses.findOne({ where: { name: 'Campus Default' } });     
+            const courseDefault = await Courses.findOne({ where: { name: 'Course Default' } });    
+            const collegeDefault = await Colleges.findOne({ where: { name: 'Colleges Default' } });     
+
+            let createdCounter = 0
+            let errorCounter = 0
+            let uniqueErrors = new Set()
+
+            let uNum = new Set()
+            let uLname = new Set()
+            let uMname = new Set()
+            let uFname = new Set()
+            let uCourse = new Set()
+            let uCampus = new Set()
+
+            let newStudent = []
+
+            const exStudent = await Students.findAll()
+            const exStudentMap = new Map(exStudent.map(student => [`[${student.studentNumber}] - ${student.lastName}, ${student.firstName} ${student.middleName} [${student.courseId}, ${student.campusId}]`, student]))
+  
+            const {data} = studentApi
+
+            for (let i = 0; i < data.length; i++){
+                try {
+                    let _student = data[i]
+
+                    let _campus = campusSeq.find(a => a.name === _student?.campus)
+                    let _course = courseSeq.find(b => b.name === _student?.course)
+                    let _college = collegeSeq.find(c => c.name === _student?.college)
+
+                    let findUser = await userSeq.find( f => f.lastName === _student?.last_name && f.firstName === _student?.first_name && f.middleName === _student?.middle_name)
 
                     let modifiedById = userMail?._id
                     let createdById = userMail?._id
@@ -1559,6 +2138,12 @@ const server = {
                     let courseId = _course?._id??courseDefault?._id
                     let campusId = _campus?._id??campusDefault?._id
 
+                    let getUserName = Mixins.generateUsername(firstName, lastName)
+                    let email = `${getUserName}@msumarinduque.edu.ph`
+
+                    let userId = findUser?._id
+
+
                     if(uNum.has(studentNumber) && uLname.has(lastName) && uFname.has(firstName) && uMname.has(middleName) && uCourse.has(courseId) && uCampus.has(campusId)){
                         const errorMsg = `Duplicate Payload Found: [${studentNumber}] - ${lastName}, ${firstName} ${middleName} [courseId: ${courseId}, campusId:${campusId}]`
                       if(!uniqueErrors.has(errorMsg)){
@@ -1596,6 +2181,7 @@ const server = {
                             admittedSemId: _semester?._id ?? null,
                             modifiedById,
                             createdById,
+                            userId
                         })
                     }
                     
@@ -1655,6 +2241,7 @@ const server = {
     
             const subjectApi = await api.Subject();
             const instructorApi = await api.Instructor()
+            const sectionApi = await api.Section()
             
             const subjectSeq = await Subjects.findAll();
             const instructorSeq = await Instructors.findAll()
@@ -1711,6 +2298,8 @@ const server = {
                         let _insdepartment = acadDeptSeq.find(idep => idep.name === _instructor?.department_name)
 
 
+                        let _sections = sectionApi.find(sect => sect.name === sections)
+
                         if (!_subject) {
                             // console.error(`Subject with code ${subjects} not found.`);
                             continue;
@@ -1745,6 +2334,11 @@ const server = {
                         let departmentId =  _insdepartment?._id??null
                         let campusId =  _campus?._id??null
 
+                        let migratedAt = new Date() //present date of the migration
+                        let migratedTable = 'Sections' // sql counterpart main table
+                        let referenceId = _sections?.id // id of the data
+                        let isMigrated = true 
+
 
                         if(uCode.has(code) && uName.has(name) && uSub.has(subjectId) && uIns.has(instructorId) && uSem.has(semesterId) && uYear.has(academicYearId)&& uCrs.has(courseId)&& uDept.has(departmentId) && uCam.has(campusId)){
                             const errorMsg = `Duplicate Payload Found: [${code}] - ${name} [subjectId: ${subjectId}, instructorId: ${instructorId}]`
@@ -1786,6 +2380,10 @@ const server = {
                                 departmentId: _insdepartment?._id??null,
                                 modifiedById,
                                 createdById,
+                                migratedAt,
+                                migratedTable,
+                                referenceId,
+                                isMigrated
                             })
                         }
 
@@ -1908,6 +2506,11 @@ const server = {
                     let modifiedById = userMail?._id;
                     let createdById = userMail?._id;
 
+                                        let migratedAt = new Date() //present date of the migration
+                    let migratedTable = 'campuses' // sql counterpart main table
+                    let referenceId = _campus?.id // id of the data
+                    let isMigrated = true 
+
                     for (let j = 0; j < _students.length; j++){
                         let instrcutor = _students[j].faculty_id
                         let sections = _students[j].section_name
@@ -1977,6 +2580,7 @@ const server = {
                             remarks = "FAILED"
                             overAllStatus = "FAILED"
                         }
+                        
 
                         let studentId = student?._id
                         let courseId = course?._id
@@ -2126,6 +2730,11 @@ const server = {
                     let modifiedById = userMail?._id;
                     let createdById = userMail?._id;
 
+                    let migratedAt = new Date() //present date of the migration
+                    let migratedTable = 'Students' // sql counterpart main table
+                    let referenceId = _student?.id // id of the data
+                    let isMigrated = true 
+
                     for (let j = 0; j < _students.length; j++){
 
                         let instrcutor = _students[j].faculty_id
@@ -2220,6 +2829,10 @@ const server = {
                                 overAllStatus,
                                 createdById,
                                 modifiedById,
+                                migratedAt,
+                                migratedTable,
+                                // referenceId,
+                                isMigrated
                             },
                             default:{
 
@@ -2312,10 +2925,12 @@ module.exports = {
     AcademicDepartments: server.AcademicDepartment,
     Course: server.Course,
     Room: server.Room,
+    UserInstructor: server.UserInstructor,
     Instructor: server.Instructor,
     AcademicYear: server.AcademicYear,
     Subject: server.Subject,
     Schedule: server.Schedule,
+    UserStudents: server.UserStudents,
     Student: server.Student,
     Section: server.Section,
     EnrolledStudent: server.EnrolledStudent,