lms-sync 1.0.92 → 1.0.94

package/apiConnections/mapping.js

@@ -23,43 +23,33 @@ const {
     Users,
     Semesters,
     Employees,
+    UserRoles,
+    Applications,
+    Roles
 
 
 } = db
 
 const server = {
 
-    async Campus(){
+    async AcademicYear(){
         try {
             await db.sequelize.query('DROP FUNCTION IF EXISTS pg_temp.testfunc()');
+
             console.log("");
             console.log("########################################################")
-            console.log("                     Campuses Migration ")
+            console.log("                       Academic Years Migration ")
             console.log("########################################################")
             console.log("");
 
             const db_schema = schema
-            let maxIds = await Campuses.max('_id'); //Fetch maximum _id directly from the campuses model
-            let maxIdsSem = await Semesters.max('_id'); //Fetch maximum _id directly from the campuses model
-            let maxIdsUser = await Users.max('_id'); //Fetch maximum _id directly from the campuses model
-
+            let maxIds = await AcademicYears.max('_id'); // Fetch maximum _id directly from the AcademicYears model
             let maxId = maxIds|| 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}`);  
-
-            await db.sequelize.query(`CREATE SEQUENCE IF NOT EXISTS ${db_schema}."Campuses__id_seq"`);      
-            await db.sequelize.query(`ALTER SEQUENCE ${db_schema}."Campuses__id_seq" RESTART WITH ${maxId + 1}`);  
-            
-            await db.sequelize.query(`CREATE SEQUENCE IF NOT EXISTS ${db_schema}."Semesters__id_seq"`);      
-            await db.sequelize.query(`ALTER SEQUENCE ${db_schema}."Semesters__id_seq" RESTART WITH ${maxIdSems + 1}`);    
-            
+            await db.sequelize.query(`CREATE SEQUENCE IF NOT EXISTS ${db_schema}."AcademicYears__id_seq"`);      
+            await db.sequelize.query(`ALTER SEQUENCE ${db_schema}."AcademicYears__id_seq" RESTART WITH ${maxId + 1}`);
             await db.sequelize.query(`DROP FUNCTION IF EXISTS ${db_schema}."pg_temp.testfunc()"`);
 
 
-
             let userDefPayload = {
                 email: 'ccci_integrator@gmail.com',
                 password: '$2a$12$Q.h3Q9IN6vsIxGBa/EgfOOABeXTcwxt4t9cu4nqAK.nczGRRtZJUS',
@@ -76,122 +66,62 @@ const server = {
                 defaults: userDefPayload 
             }); 
 
-            const userMail = await Users.findOne({ where: { email: 'ccci_integrator@gmail.com' } });     
+            const acadYearApi = await api.AcademicYear()
+            const userMail = await Users.findOne({ where: { email: 'ccci_integrator@gmail.com' } });          
 
-            let yearDefPayload = {
-                from: 1799,
-                to: 1800,
-                modifiedById: userMail?._id,
-                createdById: userMail?._id,
-                default: false,
-            }
-            let [yeardef, createdyear] = await AcademicYears.findOrCreate({
-                where: { 
-                    from: yearDefPayload.from,
-                    to: yearDefPayload.to,
-                }, 
-                defaults: yearDefPayload 
-            }); 
+            let createdCounter = 0
+            let errorCounter = 0
+            let uniqueErrors = new Set()
 
-            // let semesterData = [
-            //     {
-            //         code: '1st Semester',
-            //         description: '1st Semester',
-            //         modifiedById: userMail?._id,
-            //         createdById: userMail?._id
-            //     },
-            //     {
-            //         code: '2nd Semester',
-            //         description: '2nd Semester',
-            //         modifiedById: userMail?._id,
-            //         createdById: userMail?._id
-            //     },
-            //     {
-            //         code: 'Summer',
-            //         description: 'Summer',
-            //         modifiedById: userMail?._id,
-            //         createdById: userMail?._id
-            //     },
-            //     {
-            //         code: 'School Year',
-            //         description: 'School Year',
-            //         modifiedById: userMail?._id,
-            //         createdById: userMail?._id
-            //     }
-                
-            // ]
+            const { acadYearResult, currentSchoolYear } = acadYearApi;
 
-            // for (let sem = 0; sem < semesterData.length; sem++) {
-            //     const semesters = semesterData[sem];
-                
-            //     let semestersPayload = {
-            //         code: semesters.code,
-            //         description: semesters.description,
-            //         modifiedById: userMail?._id,
-            //         createdById: userMail?._id
-            //     }
 
-            //     let [semdefaults, semcreateddef] = await Semesters.findOrCreate({
-            //     where: { code: semestersPayload.code}, 
-            //     defaults: semestersPayload 
-            // });
-            // }
+            let uFrom = new Set()
+            let uTo = new Set()
 
-            const campusApi = await api.Campus()
-            
-            let campusDefPayload = {
-                name: 'Campus Default',
-                code: 'DEF',
-                email: 'campus_default@gmail.com',
-                address: 'MSC',
-                modifiedById: userMail?._id,
-                createdById: userMail?._id
-            };
-            
-            let [defaults, createddef] = await Campuses.findOrCreate({
-                where: { name: campusDefPayload.name, code: campusDefPayload.code}, 
-                defaults: campusDefPayload 
-            });
+            let newYears = []
 
-            let createdCounter = 0
-            let errorCounter = 0
-            let uniqueErrors = new Set()
+            const exYear = await AcademicYears.findAll()
+            const exYearMap = new Map(exYear.map(year => [`[${year.from} - ${year.to}]`, year]))
+  
 
-            let uCode = new Set()
-            let uName = new Set()
+            for (let i = 0; i < acadYearResult.length; i++){
+                try {
+                    let _acadyear = acadYearResult[i]
+                    //  console.log('_acadyear :>> ', _acadyear);
 
-            let newCampus = []
+                    let [from, to] = _acadyear.year.split('-')
 
-            const existingCampus = await Campuses.findAll()
-            const existingCampusMap = new Map(existingCampus.map(campus => [`[${campus.code}] - ${campus.name}`, campus]))
-    
-            for (let i = 0; i < campusApi.length; i++){
-                try {
-                    
-                    let _campus = campusApi[i]
+                    to = /^\d+$/.test(to) ? parseInt(to, 10) : null;
+                    from = /^\d+$/.test(from) ? parseInt(from, 10) : null;
+
+                    let defaultDate = new Date()
+                    let currentYear = defaultDate.getFullYear()
+                    let previousYear = currentYear - 1
+
+                    let isDefault = false
+                    if(from == previousYear && to == currentYear) isDefault = true
 
                     let modifiedById = userMail?._id
                     let createdById = userMail?._id
 
-                    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 migratedTable = 'AcademicYears' // sql counterpart main table
+                    let referenceId = _acadyear?.id // id of the data
                     let isMigrated = true 
 
-                    if(uCode.has(code) && uName.has(name)){
-                        const errorMsg = `Duplicate Payload Found: [${code}] - ${name}`
+
+                    if(uFrom.has(from) && uTo.has(to)){
+                        const errorMsg = `Duplicate Payload Found: [${from} - ${to}]`
                       if(!uniqueErrors.has(errorMsg)){
                         logger.error(`${errorCounter + 1}/${errorCounter + 1}: ${errorMsg}`)
                         uniqueErrors.add(errorMsg)
                         errorCounter++
                       }
                     }
-                    else if ( existingCampusMap.has(`[${code}] - ${name}`)){
-                        const existingCampus = existingCampusMap.get(`[${code}] - ${name}`)
-                        const errorMsg = `Existing Data Found:[${existingCampus.code}] - ${existingCampus.name}`
+                    else if ( exYearMap.has(`[${from} - ${to}]`)){
+                        const exYear = exYearMap.get(`[${from} - ${to}]`)
+                        const errorMsg = `Existing Data Found:[${exYear.from} - ${exYear.to}]`
                         if(!uniqueErrors.has(errorMsg)){
                           logger.error(`${errorCounter + 1}/${errorCounter + 1}: ${errorMsg}`)
                           uniqueErrors.add(errorMsg)
@@ -199,15 +129,14 @@ const server = {
                         }
                       }
                     else{
-                        uCode.add(code)
-                        uName.add(name)
-                        newCampus.push({
-                            name: _campus?.name,
-                            code: _campus?.code,
-                            email: _campus?.email,
-                            address: _campus?.address,
+                        uFrom.add(from)
+                        uTo.add(to)
+                        newYears.push({
+                            from,
+                            to,
                             modifiedById,
                             createdById,
+                            default: isDefault,
                             migratedAt,
                             migratedTable,
                             referenceId,
@@ -216,27 +145,26 @@ const server = {
                     }
                     
                 } catch (error) {
-                ;
-                logger.error(`Error occurred: ${error.stack} ${error}`);
+                                ;
+            logger.error(`Error occurred: ${error.stack} ${error}`);
                 }
             }
 
-             // bulk create new campus Records
-          if (newCampus.length > 0) {
-            await Campuses.bulkCreate(newCampus)
-            createdCounter += newCampus.length
-
-            newCampus.forEach((campus, index) => {
-                logger.info(`${index + 1}/${index + 1}: New Campus Record Created: [${campus.code}], ${campus.name}`)
-            });
-        }
+            if (newYears.length > 0) {
+                await AcademicYears.bulkCreate(newYears)
+                createdCounter += newYears.length
+    
+                newYears.forEach((year, index) => {
+                    logger.info(`${index + 1}/${index + 1}: New Academic Years Record Created: [${year.from} - ${year.to}]`)
+                });
+            }
 
             console.log("");
             console.log("########################################################")
             console.log("")
-            logger.info('Campus Data Migration Completed');
-            logger.info(`Total Successful Campus Records Created: ${createdCounter}/${createdCounter}`);
-            logger.info(`Total Existing Campus Records: ${errorCounter}/${errorCounter}`);
+            logger.info('Academic Years Data Migration Completed');
+            logger.info(`Total Successful Academic Years Records Created: ${createdCounter}/${createdCounter}`);
+            logger.info(`Total Existing Academic Years Records: ${errorCounter}/${errorCounter}`);
             logger.info(`Total Records: ${createdCounter + errorCounter}`);
             console.log("")
             console.log("########################################################")
@@ -256,86 +184,86 @@ const server = {
         }
     },
 
-    async College(){
+    async Semester(){
         try {
             await db.sequelize.query('DROP FUNCTION IF EXISTS pg_temp.testfunc()');
 
             console.log("");
             console.log("########################################################")
-            console.log("                       Colleges Migration ")
+            console.log("                 Semesters Migration ")
             console.log("########################################################")
             console.log("");
 
             const db_schema = schema
-            let maxIds = await Colleges.max('_id'); // Fetch maximum _id directly from the Colleges model
+            let maxIds = await AcademicYears.max('_id'); // Fetch maximum _id directly from the AcademicYears model
             let maxId = maxIds|| 0;
-            await db.sequelize.query(`CREATE SEQUENCE IF NOT EXISTS ${db_schema}."Colleges__id_seq"`);      
-            await db.sequelize.query(`ALTER SEQUENCE ${db_schema}."Colleges__id_seq" RESTART WITH ${maxId + 1}`);
-
+            await db.sequelize.query(`CREATE SEQUENCE IF NOT EXISTS ${db_schema}."Semesters__id_seq"`);      
+            await db.sequelize.query(`ALTER SEQUENCE ${db_schema}."Semesters__id_seq" RESTART WITH ${maxId + 1}`);
             await db.sequelize.query(`DROP FUNCTION IF EXISTS ${db_schema}."pg_temp.testfunc()"`);
 
-            const collegeApi = await api.College()
-            const campusApi = await api.Campus()
 
-            const campusSeq = await Campuses.findAll()
-            const userMail = await Users.findOne({ where: { email: 'ccci_integrator@gmail.com' } });   
-            const campusDefault = await Campuses.findOne({ where: { name: 'Campus Default' } });              
-            
-            let defaultPayload = {
-                name: 'Colleges Default',
-                code: 'DefCol',
-                campusId: campusDefault._id,
-                modifiedById: userMail?._id,
-                createdById: userMail?._id
+            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 [defaults, createddef] = await Colleges.findOrCreate({
-                where: { name: defaultPayload.name, code: defaultPayload.code}, 
-                defaults: defaultPayload 
-            });
+            let [userDefault, createdUser] = await Users.findOrCreate({
+                where: { email: userDefPayload.email }, 
+                defaults: userDefPayload 
+            }); 
+            
+            const acadYearApi = await api.AcademicYear()
+            const userMail = await Users.findOne({ where: { email: 'ccci_integrator@gmail.com' } });          
 
             let createdCounter = 0
             let errorCounter = 0
-            let uniqueErrors = new Set()          
+            let uniqueErrors = new Set()
+
+            const { acadYearResult, currentSchoolYear } = acadYearApi;
+
 
             let uCode = new Set()
-            let uName = new Set()
+            let uDesc = new Set()
 
-            let newColleges = []
+            let newYears = []
 
-            const existingCollege = await Colleges.findAll()
-            const existingCollegeMap = new Map(existingCollege.map(college => [`[${college.code}] - ${college.name}`, college]))
+            const exYear = await Semesters.findAll()
+            const exYearMap = new Map(exYear.map(sem => [`[${sem.code}] ${sem.description}`, sem]))
+  
 
-            for (let i = 0; i < collegeApi.length; i++){
+            for (let i = 0; i < acadYearResult.length; i++){
                 try {
-                    let _college = collegeApi[i]
-
-                    let campusMap = campusApi.find(a => a.id === _college?.campus_id)
-
-                    let _campus = campusSeq.find(b => b.name === campusMap?.name)
+                    let _acadyear = acadYearResult[i]
 
                     let modifiedById = userMail?._id
                     let createdById = userMail?._id
 
-                    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 migratedTable = 'AcademicYears' // sql counterpart main table
+                    let referenceId = _acadyear?.id // id of the data
                     let isMigrated = true 
 
-                    if(uCode.has(code) && uName.has(name)){
-                        const errorMsg = `Duplicate Payload Found: [${code}] - ${name}`
+                    let code = _acadyear?.term
+                    let description = _acadyear?.term
+
+
+                    if(uCode.has(code) && uDesc.has(description)){
+                        const errorMsg = `Duplicate Payload Found: [${code}] ${description}]`
                       if(!uniqueErrors.has(errorMsg)){
                         logger.error(`${errorCounter + 1}/${errorCounter + 1}: ${errorMsg}`)
                         uniqueErrors.add(errorMsg)
                         errorCounter++
                       }
                     }
-                    else if ( existingCollegeMap.has(`[${code}] - ${name}`)){
-                        const existingCollege = existingCollegeMap.get(`[${code}] - ${name}`)
-                        const errorMsg = `Existing Data Found:[${existingCollege.code}] - ${existingCollege.name}`
+                    else if ( exYearMap.has(`[${code}] ${description}`)){
+                        const exYear = exYearMap.get(`[${code}] ${description}`)
+                        const errorMsg = `Existing Data Found:[${exYear.code}] ${exYear.description}]`
                         if(!uniqueErrors.has(errorMsg)){
                           logger.error(`${errorCounter + 1}/${errorCounter + 1}: ${errorMsg}`)
                           uniqueErrors.add(errorMsg)
@@ -344,20 +272,15 @@ const server = {
                       }
                     else{
                         uCode.add(code)
-                        uName.add(name)
-                        newColleges.push({
-                            name: _college?.name,
-                            code: _college?.code,
-                            campusId: _campus?._id??campusDefault?._id,
+                        uDesc.add(description)
+                        newYears.push({
+                            code,
+                            description,
                             modifiedById,
                             createdById,
                             migratedAt,
                             migratedTable,
                             referenceId,
-                            isMigrated,
-                            migratedAt,
-                            migratedTable,
-                            referenceId,
                             isMigrated
                         })
                     }
@@ -368,31 +291,28 @@ const server = {
                 }
             }
 
-            // bulk create new campus Records
-          if (newColleges.length > 0) {
-            await Colleges.bulkCreate(newColleges)
-            createdCounter += newColleges.length
-
-            newColleges.forEach((colleges, index) => {
-                logger.info(`${index + 1}/${index + 1}: New Colleges Record Created: [${colleges.code}], ${colleges.name}`)
-            });
-        }
-
-        let itemLength = createdCounter + errorCounter;
+            if (newYears.length > 0) {
+                await Semesters.bulkCreate(newYears)
+                createdCounter += newYears.length
+    
+                newYears.forEach((year, index) => {
+                    logger.info(`${index + 1}/${index + 1}: New Semesters Years Record Created: [${year.code} - ${year.description}]`)
+                });
+            }
 
             console.log("");
             console.log("########################################################")
             console.log("")
-            logger.info('College Data Migration Completed');
-            logger.info(`Total Successful College Records Created: ${createdCounter}/${createdCounter}`);
-            logger.info(`Total Existing College Records: ${errorCounter}/${errorCounter}`);
-            logger.info(`Total Records: ${itemLength}`)
+            logger.info('Semesters Data Migration Completed');
+            logger.info(`Total Successful Semesters Records Created: ${createdCounter}/${createdCounter}`);
+            logger.info(`Total Existing Semesters Records: ${errorCounter}/${errorCounter}`);
+            logger.info(`Total Records: ${createdCounter + errorCounter}`);
             console.log("")
             console.log("########################################################")
             console.log("")
 
                 let totalSummary = {
-                  itemLength: itemLength,
+                  itemLength: createdCounter + errorCounter,
                   error: errorCounter,
                   success: createdCounter
                 }
@@ -405,48 +325,128 @@ const server = {
         }
     },
 
-    async AcademicDepartment(){
+    async Campus(){
         try {
             await db.sequelize.query('DROP FUNCTION IF EXISTS pg_temp.testfunc()');
-
             console.log("");
             console.log("########################################################")
-            console.log("            Academic Departments Migration ")
+            console.log("                     Campuses Migration ")
             console.log("########################################################")
             console.log("");
 
             const db_schema = schema
-            let maxIds = await AcademicDepartments.max('_id'); // Fetch maximum _id directly from the AcademicDepartments model
+            let maxIds = await Campuses.max('_id'); //Fetch maximum _id directly from the campuses model
+            let maxIdsSem = await Semesters.max('_id'); //Fetch maximum _id directly from the campuses model
+            let maxIdsUser = await Users.max('_id'); //Fetch maximum _id directly from the campuses model
+
             let maxId = maxIds|| 0;
-            await db.sequelize.query(`CREATE SEQUENCE IF NOT EXISTS ${db_schema}."AcademicDepartments__id_seq"`);      
-            await db.sequelize.query(`ALTER SEQUENCE ${db_schema}."AcademicDepartments__id_seq" RESTART WITH ${maxId + 1}`);
+            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}`);  
+
+            await db.sequelize.query(`CREATE SEQUENCE IF NOT EXISTS ${db_schema}."Campuses__id_seq"`);      
+            await db.sequelize.query(`ALTER SEQUENCE ${db_schema}."Campuses__id_seq" RESTART WITH ${maxId + 1}`);  
+            
+            await db.sequelize.query(`CREATE SEQUENCE IF NOT EXISTS ${db_schema}."Semesters__id_seq"`);      
+            await db.sequelize.query(`ALTER SEQUENCE ${db_schema}."Semesters__id_seq" RESTART WITH ${maxIdSems + 1}`);    
+            
             await db.sequelize.query(`DROP FUNCTION IF EXISTS ${db_schema}."pg_temp.testfunc()"`);
 
-            const departmentApi = await api.Department()
-            const campusApi = await api.Campus()
-            const collegeApi = await api.College()
-            const instructorApi = await api.Instructor()
 
-            const campusSeq = await Campuses.findAll()
-            const collegeSeq = await Colleges.findAll()
-            const departmentSeq = await AcademicDepartments.findAll()
-            const userMail = await Users.findOne({ where: { email: 'ccci_integrator@gmail.com' } });    
-            const campusDefault = await Campuses.findOne({ where: { name: 'Campus Default' } });        
-            const collegeDefault = await Colleges.findOne({ where: { name: 'Colleges Default' } });      
+
+            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 defaultPayload = {
-                name: 'AcademicDepartments Default',
-                code: 'AcadDeptDef',
-                campusId: campusDefault._id,
-                collegeId: collegeDefault._id,
-                chairPersonId: 99999,
+            let [userDefault, createdUser] = await Users.findOrCreate({
+                where: { email: userDefPayload.email }, 
+                defaults: userDefPayload 
+            }); 
+
+            const userMail = await Users.findOne({ where: { email: 'ccci_integrator@gmail.com' } });     
+
+            let yearDefPayload = {
+                from: 1799,
+                to: 1800,
+                modifiedById: userMail?._id,
+                createdById: userMail?._id,
+                default: false,
+            }
+            let [yeardef, createdyear] = await AcademicYears.findOrCreate({
+                where: { 
+                    from: yearDefPayload.from,
+                    to: yearDefPayload.to,
+                }, 
+                defaults: yearDefPayload 
+            }); 
+
+            // let semesterData = [
+            //     {
+            //         code: '1st Semester',
+            //         description: '1st Semester',
+            //         modifiedById: userMail?._id,
+            //         createdById: userMail?._id
+            //     },
+            //     {
+            //         code: '2nd Semester',
+            //         description: '2nd Semester',
+            //         modifiedById: userMail?._id,
+            //         createdById: userMail?._id
+            //     },
+            //     {
+            //         code: 'Summer',
+            //         description: 'Summer',
+            //         modifiedById: userMail?._id,
+            //         createdById: userMail?._id
+            //     },
+            //     {
+            //         code: 'School Year',
+            //         description: 'School Year',
+            //         modifiedById: userMail?._id,
+            //         createdById: userMail?._id
+            //     }
+                
+            // ]
+
+            // for (let sem = 0; sem < semesterData.length; sem++) {
+            //     const semesters = semesterData[sem];
+                
+            //     let semestersPayload = {
+            //         code: semesters.code,
+            //         description: semesters.description,
+            //         modifiedById: userMail?._id,
+            //         createdById: userMail?._id
+            //     }
+
+            //     let [semdefaults, semcreateddef] = await Semesters.findOrCreate({
+            //     where: { code: semestersPayload.code}, 
+            //     defaults: semestersPayload 
+            // });
+            // }
+
+            const campusApi = await api.Campus()
+            
+            let campusDefPayload = {
+                name: 'Campus Default',
+                code: 'DEF',
+                email: 'campus_default@gmail.com',
+                address: 'MSC',
                 modifiedById: userMail?._id,
                 createdById: userMail?._id
             };
             
-            let [defaults, createddef] = await AcademicDepartments.findOrCreate({
-                where: { name: defaultPayload.name, code: defaultPayload.code}, 
-                defaults: defaultPayload 
+            let [defaults, createddef] = await Campuses.findOrCreate({
+                where: { name: campusDefPayload.name, code: campusDefPayload.code}, 
+                defaults: campusDefPayload 
             });
 
             let createdCounter = 0
@@ -455,33 +455,26 @@ const server = {
 
             let uCode = new Set()
             let uName = new Set()
-            let newAcadDept = []
-            const exAcadDept = await AcademicDepartments.findAll()
-            const exAcadDeptMap = new Map(exAcadDept.map(dept => [`[${dept.code}] - ${dept.name}`, dept]))
 
-            let uCodeTwo = new Set()
-            let uNameTwo = new Set()
-            let newAcadDeptTwo = []
-            const exAcadDeptTwo = await AcademicDepartments.findAll()
-            const exAcadDeptMapTwo = new Map(exAcadDeptTwo.map(dept => [`[${dept.code}] - ${dept.name}`, dept]))
-            
+            let newCampus = []
 
-            for (let i = 0; i < departmentApi.length; i++){
+            const existingCampus = await Campuses.findAll()
+            const existingCampusMap = new Map(existingCampus.map(campus => [`[${campus.code}] - ${campus.name}`, campus]))
+    
+            for (let i = 0; i < campusApi.length; i++){
                 try {
-                    let _acadDept = departmentApi[i]
-                    let _college = collegeSeq.find( col => col.code === _acadDept?.code)
-                    let college = collegeApi.find( cols => cols.code === _acadDept?.code)
-                    let _campus = campusApi.find(cam => cam.id === college?.campus_id)
-                    let campus = campusSeq.find(camp => camp.code === _campus?.code)
-                    let chairPersonDefault = 0
+                    
+                    let _campus = campusApi[i]
+
                     let modifiedById = userMail?._id
                     let createdById = userMail?._id
-                    let name = _acadDept?.name
-                    let code = _acadDept?.code
+
+                    let name = _campus?.name
+                    let code = _campus?.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 migratedTable = 'Campuses' // sql counterpart main table
+                    let referenceId = _campus?.id // id of the data
                     let isMigrated = true 
 
                     if(uCode.has(code) && uName.has(name)){
@@ -492,9 +485,9 @@ const server = {
                         errorCounter++
                       }
                     }
-                    else if ( exAcadDeptMap.has(`[${code}] - ${name}`)){
-                        const exAcadDept = exAcadDeptMap.get(`[${code}] - ${name}`)
-                        const errorMsg = `Existing Data Found:[${exAcadDept.code}] - ${exAcadDept.name}`
+                    else if ( existingCampusMap.has(`[${code}] - ${name}`)){
+                        const existingCampus = existingCampusMap.get(`[${code}] - ${name}`)
+                        const errorMsg = `Existing Data Found:[${existingCampus.code}] - ${existingCampus.name}`
                         if(!uniqueErrors.has(errorMsg)){
                           logger.error(`${errorCounter + 1}/${errorCounter + 1}: ${errorMsg}`)
                           uniqueErrors.add(errorMsg)
@@ -504,11 +497,11 @@ const server = {
                     else{
                         uCode.add(code)
                         uName.add(name)
-                        newAcadDept.push({
-                            name: _acadDept?.name,
-                            code: _acadDept?.code,
-                            collegeId: _college?._id??collegeDefault?._id,
-                            campusId: campus?._id??campusDefault?._id, 
+                        newCampus.push({
+                            name: _campus?.name,
+                            code: _campus?.code,
+                            email: _campus?.email,
+                            address: _campus?.address,
                             modifiedById,
                             createdById,
                             migratedAt,
@@ -517,166 +510,238 @@ const server = {
                             isMigrated
                         })
                     }
+                    
                 } catch (error) {
-            logger.error(`Error occurred: ${error.stack} ${error}`);
+                ;
+                logger.error(`Error occurred: ${error.stack} ${error}`);
                 }
             }
-            if (newAcadDept.length > 0) {
-                await AcademicDepartments.bulkCreate(newAcadDept)
-                createdCounter += newAcadDept.length
-    
-                newAcadDept.forEach((dept, index) => {
-                    logger.info(`${index + 1}/${index + 1}: New Academic Department Record Created: [${dept.code}], ${dept.name}`)
-                });
-            }
 
-                                   
-            //additional departments from instructors api
-            for (let j = 0; j < instructorApi.length; j++) {
-                try {
-                    let instructor = instructorApi[j];
-                    let modifiedById = userMail?._id
-                    let createdById = userMail?._id
+             // bulk create new campus Records
+          if (newCampus.length > 0) {
+            await Campuses.bulkCreate(newCampus)
+            createdCounter += newCampus.length
 
-                    let acadDepartmentMap = departmentApi.find(a => a.name === instructor?.department_name)
+            newCampus.forEach((campus, index) => {
+                logger.info(`${index + 1}/${index + 1}: New Campus Record Created: [${campus.code}], ${campus.name}`)
+            });
+        }
 
-                    let _acadDepartment = departmentSeq.find(b => b.name === acadDepartmentMap?.name)
+            console.log("");
+            console.log("########################################################")
+            console.log("")
+            logger.info('Campus Data Migration Completed');
+            logger.info(`Total Successful Campus Records Created: ${createdCounter}/${createdCounter}`);
+            logger.info(`Total Existing Campus Records: ${errorCounter}/${errorCounter}`);
+            logger.info(`Total Records: ${createdCounter + errorCounter}`);
+            console.log("")
+            console.log("########################################################")
+            console.log("")
 
-                    let campusMap = campusSeq.find(c => c._id === _acadDepartment?.campusId)
+                let totalSummary = {
+                  itemLength: createdCounter + errorCounter,
+                  error: errorCounter,
+                  success: createdCounter
+                }
+                return totalSummary
 
-                    let campusDefault = "MSC - Boac Campus"
-                    let _campusDefault = campusSeq.find(ccc => ccc.name === campusDefault)
+        } catch (error) {
+                        ;
+            logger.error(`Error occurred: ${error.stack} ${error}`);
+            
+        }
+    },
 
-                    let code = instructor?.department_name ?? 'CODE'
-                    code = code.split(/\s+/).map((word) => word.charAt(0).toUpperCase()).join('')
+    async College(){
+        try {
+            await db.sequelize.query('DROP FUNCTION IF EXISTS pg_temp.testfunc()');
 
-                    let name = instructor?.department_name
+            console.log("");
+            console.log("########################################################")
+            console.log("                       Colleges Migration ")
+            console.log("########################################################")
+            console.log("");
 
-                    if(uCodeTwo.has(code) && uNameTwo.has(name)){
+            const db_schema = schema
+            let maxIds = await Colleges.max('_id'); // Fetch maximum _id directly from the Colleges model
+            let maxId = maxIds|| 0;
+            await db.sequelize.query(`CREATE SEQUENCE IF NOT EXISTS ${db_schema}."Colleges__id_seq"`);      
+            await db.sequelize.query(`ALTER SEQUENCE ${db_schema}."Colleges__id_seq" RESTART WITH ${maxId + 1}`);
+
+            await db.sequelize.query(`DROP FUNCTION IF EXISTS ${db_schema}."pg_temp.testfunc()"`);
+
+            const collegeApi = await api.College()
+            const campusApi = await api.Campus()
+
+            const campusSeq = await Campuses.findAll()
+            const userMail = await Users.findOne({ where: { email: 'ccci_integrator@gmail.com' } });   
+            const campusDefault = await Campuses.findOne({ where: { name: 'Campus Default' } });              
+            
+            let defaultPayload = {
+                name: 'Colleges Default',
+                code: 'DefCol',
+                campusId: campusDefault._id,
+                modifiedById: userMail?._id,
+                createdById: userMail?._id
+            };
+            
+            let [defaults, createddef] = await Colleges.findOrCreate({
+                where: { name: defaultPayload.name, code: defaultPayload.code}, 
+                defaults: defaultPayload 
+            });
+
+            let createdCounter = 0
+            let errorCounter = 0
+            let uniqueErrors = new Set()          
+
+            let uCode = new Set()
+            let uName = new Set()
+
+            let newColleges = []
+
+            const existingCollege = await Colleges.findAll()
+            const existingCollegeMap = new Map(existingCollege.map(college => [`[${college.code}] - ${college.name}`, college]))
+
+            for (let i = 0; i < collegeApi.length; i++){
+                try {
+                    let _college = collegeApi[i]
+
+                    let campusMap = campusApi.find(a => a.id === _college?.campus_id)
+
+                    let _campus = campusSeq.find(b => b.name === campusMap?.name)
+
+                    let modifiedById = userMail?._id
+                    let createdById = userMail?._id
+
+                    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)){
+                      if(!uniqueErrors.has(errorMsg)){
                         logger.error(`${errorCounter + 1}/${errorCounter + 1}: ${errorMsg}`)
                         uniqueErrors.add(errorMsg)
                         errorCounter++
+                      }
                     }
-                    }
-                    else if ( exAcadDeptMapTwo.has(`[${code}] - ${name}`)){
-                        const exAcadDeptTwo = exAcadDeptMapTwo.get(`[${code}] - ${name}`)
-                        const errorMsg = `Existing Data Found:[${exAcadDeptTwo.code}] - ${exAcadDeptTwo.name}`
+                    else if ( existingCollegeMap.has(`[${code}] - ${name}`)){
+                        const existingCollege = existingCollegeMap.get(`[${code}] - ${name}`)
+                        const errorMsg = `Existing Data Found:[${existingCollege.code}] - ${existingCollege.name}`
                         if(!uniqueErrors.has(errorMsg)){
-                        logger.error(`${errorCounter + 1}/${errorCounter + 1}: ${errorMsg}`)
-                        uniqueErrors.add(errorMsg)
-                        errorCounter++
+                          logger.error(`${errorCounter + 1}/${errorCounter + 1}: ${errorMsg}`)
+                          uniqueErrors.add(errorMsg)
+                          errorCounter++
                         }
-                    }
+                      }
                     else{
-                        uCodeTwo.add(code)
-                        uNameTwo.add(name)
-                        newAcadDeptTwo.push({
-                            name: instructor?.department_name,
-                            code: code,
+                        uCode.add(code)
+                        uName.add(name)
+                        newColleges.push({
+                            name: _college?.name,
+                            code: _college?.code,
+                            campusId: _campus?._id??campusDefault?._id,
                             modifiedById,
                             createdById,
-                            campusId: campusMap?._id??_campusDefault?._id,  
-                            collegeId: collegeDefault?._id,
-                        
+                            migratedAt,
+                            migratedTable,
+                            referenceId,
+                            isMigrated,
+                            migratedAt,
+                            migratedTable,
+                            referenceId,
+                            isMigrated
                         })
                     }
-
-
+                    
                 } catch (error) {
-                    logger.error(`Error occurred: ${error} ${error.stack}`);                                 
+                                ;
+            logger.error(`Error occurred: ${error.stack} ${error}`);
                 }
             }
-            if (newAcadDeptTwo.length > 0) {
-                await AcademicDepartments.bulkCreate(newAcadDeptTwo)
-                createdCounter += newAcadDeptTwo.length
 
-                newAcadDeptTwo.forEach((deptTwo, index) => {
-                    logger.info(`${index + 1}/${index + 1}: New Academic Department Record Created: [${deptTwo.code}], ${deptTwo.name}`)
-                });
-            }
+            // bulk create new campus Records
+          if (newColleges.length > 0) {
+            await Colleges.bulkCreate(newColleges)
+            createdCounter += newColleges.length
+
+            newColleges.forEach((colleges, index) => {
+                logger.info(`${index + 1}/${index + 1}: New Colleges Record Created: [${colleges.code}], ${colleges.name}`)
+            });
+        }
+
+        let itemLength = createdCounter + errorCounter;
 
             console.log("");
             console.log("########################################################")
             console.log("")
-            logger.info('Academic Department Data Migration Completed');
-            logger.info(`Total Successful Academic Department Records Created: ${createdCounter}/${createdCounter}`);
-            logger.info(`Total Existing Academic Department Records: ${errorCounter}/${errorCounter}`);
-            logger.info(`Total Records: ${createdCounter + errorCounter}`);
+            logger.info('College Data Migration Completed');
+            logger.info(`Total Successful College Records Created: ${createdCounter}/${createdCounter}`);
+            logger.info(`Total Existing College Records: ${errorCounter}/${errorCounter}`);
+            logger.info(`Total Records: ${itemLength}`)
             console.log("")
             console.log("########################################################")
             console.log("")
 
                 let totalSummary = {
-                  itemLength: createdCounter + errorCounter,
+                  itemLength: itemLength,
                   error: errorCounter,
                   success: createdCounter
                 }
                 return totalSummary
 
         } catch (error) {
-                        logger.error(`Error occurred: ${error} ${error.stack}`);
-                        logger.error(`Error occurredsss: ${error.stack}`);            
+                        ;
+            logger.error(`Error occurred: ${error.stack} ${error}`);
+            
         }
     },
 
-    async Instructor(){
-        let userIds = []
-        await db.sequelize.query('DROP FUNCTION IF EXISTS pg_temp.testfunc()');
-
+    async AcademicDepartment(){
         try {
+            await db.sequelize.query('DROP FUNCTION IF EXISTS pg_temp.testfunc()');
+
             console.log("");
             console.log("########################################################")
-            console.log("                 Instructors Migrations ")
+            console.log("            Academic Departments Migration ")
             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 maxIds = await AcademicDepartments.max('_id'); // Fetch maximum _id directly from the AcademicDepartments model
             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(`CREATE SEQUENCE IF NOT EXISTS ${db_schema}."AcademicDepartments__id_seq"`);      
+            await db.sequelize.query(`ALTER SEQUENCE ${db_schema}."AcademicDepartments__id_seq" RESTART WITH ${maxId + 1}`);
             await db.sequelize.query(`DROP FUNCTION IF EXISTS ${db_schema}."pg_temp.testfunc()"`);
 
-            const instructorApi = await api.Instructor()
             const departmentApi = await api.Department()
+            const campusApi = await api.Campus()
+            const collegeApi = await api.College()
+            const instructorApi = await api.Instructor()
 
-            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' } });   
- 
+            const collegeSeq = await Colleges.findAll()
+            const departmentSeq = await AcademicDepartments.findAll()
+            const userMail = await Users.findOne({ where: { email: 'ccci_integrator@gmail.com' } });    
+            const campusDefault = await Campuses.findOne({ where: { name: 'Campus Default' } });        
+            const collegeDefault = await Colleges.findOne({ where: { name: 'Colleges Default' } });      
+            
             let defaultPayload = {
-                firstName: 'Instructor',
-                lastName: 'Default',
-                middleName: 'Migration',
-                employeeNumber: '_Instructor', 
-                departmentId: departmentDefault?._id,
-                campusId: campusDefault?._id,
+                name: 'AcademicDepartments Default',
+                code: 'AcadDeptDef',
+                campusId: campusDefault._id,
+                collegeId: collegeDefault._id,
+                chairPersonId: 99999,
                 modifiedById: userMail?._id,
                 createdById: userMail?._id
             };
             
-            let [defaults, createddef] = await Instructors.findOrCreate({
-                where: { employeeNumber: defaultPayload.employeeNumber, lastName: defaultPayload.lastName}, 
+            let [defaults, createddef] = await AcademicDepartments.findOrCreate({
+                where: { name: defaultPayload.name, code: defaultPayload.code}, 
                 defaults: defaultPayload 
             });
 
@@ -684,8 +749,239 @@ const server = {
             let errorCounter = 0
             let uniqueErrors = new Set()
 
-            let uEmail = new Set()
-            let uPass = new Set()
+            let uCode = new Set()
+            let uName = new Set()
+            let newAcadDept = []
+            const exAcadDept = await AcademicDepartments.findAll()
+            const exAcadDeptMap = new Map(exAcadDept.map(dept => [`[${dept.code}] - ${dept.name}`, dept]))
+
+            let uCodeTwo = new Set()
+            let uNameTwo = new Set()
+            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 {
+                    let _acadDept = departmentApi[i]
+                    let _college = collegeSeq.find( col => col.code === _acadDept?.code)
+                    let college = collegeApi.find( cols => cols.code === _acadDept?.code)
+                    let _campus = campusApi.find(cam => cam.id === college?.campus_id)
+                    let campus = campusSeq.find(camp => camp.code === _campus?.code)
+                    let chairPersonDefault = 0
+                    let modifiedById = userMail?._id
+                    let createdById = userMail?._id
+                    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)){
+                        logger.error(`${errorCounter + 1}/${errorCounter + 1}: ${errorMsg}`)
+                        uniqueErrors.add(errorMsg)
+                        errorCounter++
+                      }
+                    }
+                    else if ( exAcadDeptMap.has(`[${code}] - ${name}`)){
+                        const exAcadDept = exAcadDeptMap.get(`[${code}] - ${name}`)
+                        const errorMsg = `Existing Data Found:[${exAcadDept.code}] - ${exAcadDept.name}`
+                        if(!uniqueErrors.has(errorMsg)){
+                          logger.error(`${errorCounter + 1}/${errorCounter + 1}: ${errorMsg}`)
+                          uniqueErrors.add(errorMsg)
+                          errorCounter++
+                        }
+                      }
+                    else{
+                        uCode.add(code)
+                        uName.add(name)
+                        newAcadDept.push({
+                            name: _acadDept?.name,
+                            code: _acadDept?.code,
+                            collegeId: _college?._id??collegeDefault?._id,
+                            campusId: campus?._id??campusDefault?._id, 
+                            modifiedById,
+                            createdById,
+                            migratedAt,
+                            migratedTable,
+                            referenceId,
+                            isMigrated
+                        })
+                    }
+                } catch (error) {
+            logger.error(`Error occurred: ${error.stack} ${error}`);
+                }
+            }
+            if (newAcadDept.length > 0) {
+                await AcademicDepartments.bulkCreate(newAcadDept)
+                createdCounter += newAcadDept.length
+    
+                newAcadDept.forEach((dept, index) => {
+                    logger.info(`${index + 1}/${index + 1}: New Academic Department Record Created: [${dept.code}], ${dept.name}`)
+                });
+            }
+
+                                   
+            //additional departments from instructors api
+            for (let j = 0; j < instructorApi.length; j++) {
+                try {
+                    let instructor = instructorApi[j];
+                    let modifiedById = userMail?._id
+                    let createdById = userMail?._id
+
+                    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 campusDefault = "MSC - Boac Campus"
+                    let _campusDefault = campusSeq.find(ccc => ccc.name === campusDefault)
+
+                    let code = instructor?.department_name ?? 'CODE'
+                    code = code.split(/\s+/).map((word) => word.charAt(0).toUpperCase()).join('')
+
+                    let name = instructor?.department_name
+
+                    if(uCodeTwo.has(code) && uNameTwo.has(name)){
+                        const errorMsg = `Duplicate Payload Found: [${code}] - ${name}`
+                    if(!uniqueErrors.has(errorMsg)){
+                        logger.error(`${errorCounter + 1}/${errorCounter + 1}: ${errorMsg}`)
+                        uniqueErrors.add(errorMsg)
+                        errorCounter++
+                    }
+                    }
+                    else if ( exAcadDeptMapTwo.has(`[${code}] - ${name}`)){
+                        const exAcadDeptTwo = exAcadDeptMapTwo.get(`[${code}] - ${name}`)
+                        const errorMsg = `Existing Data Found:[${exAcadDeptTwo.code}] - ${exAcadDeptTwo.name}`
+                        if(!uniqueErrors.has(errorMsg)){
+                        logger.error(`${errorCounter + 1}/${errorCounter + 1}: ${errorMsg}`)
+                        uniqueErrors.add(errorMsg)
+                        errorCounter++
+                        }
+                    }
+                    else{
+                        uCodeTwo.add(code)
+                        uNameTwo.add(name)
+                        newAcadDeptTwo.push({
+                            name: instructor?.department_name,
+                            code: code,
+                            modifiedById,
+                            createdById,
+                            campusId: campusMap?._id??_campusDefault?._id,  
+                            collegeId: collegeDefault?._id,
+                        
+                        })
+                    }
+
+
+                } catch (error) {
+                    logger.error(`Error occurred: ${error} ${error.stack}`);                                 
+                }
+            }
+            if (newAcadDeptTwo.length > 0) {
+                await AcademicDepartments.bulkCreate(newAcadDeptTwo)
+                createdCounter += newAcadDeptTwo.length
+
+                newAcadDeptTwo.forEach((deptTwo, index) => {
+                    logger.info(`${index + 1}/${index + 1}: New Academic Department Record Created: [${deptTwo.code}], ${deptTwo.name}`)
+                });
+            }
+
+            console.log("");
+            console.log("########################################################")
+            console.log("")
+            logger.info('Academic Department Data Migration Completed');
+            logger.info(`Total Successful Academic Department Records Created: ${createdCounter}/${createdCounter}`);
+            logger.info(`Total Existing Academic Department 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}`);
+                        logger.error(`Error occurredsss: ${error.stack}`);            
+        }
+    },
+
+    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()
+
+            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()
@@ -695,7 +991,8 @@ const server = {
             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]))
+            const exUserMap = new Map(exUser.map(usr => [`${usr.lastName}, ${usr.firstName} ${usr.middleName}`, usr]))
+            // 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()
@@ -709,6 +1006,15 @@ 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]))
 
+            let uApplication = new Set()
+            let uRole = new Set ()
+            let uUser = new Set ()
+
+            let newUserRole = []
+
+            const exURole = await UserRoles.findAll()
+            const exURoleMap = new Map (exURole.map( role => [`${role.applicationId} ${role.roleId} ${role.userId}`, role]))
+
             for (let i = 0; i < instructorApi.length; i++){
                 try {
                     let _instructor = instructorApi[i]
@@ -732,17 +1038,6 @@ const server = {
                     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
@@ -753,13 +1048,6 @@ const server = {
                     let firstName =  _instructor?.first_name
                     let lastName =  _instructor?.last_name
                     let middleName =  _instructor?.middle_name
-                    let getUserName = Mixins.generateUsername(firstName, lastName)
-                    let email = `${getUserName}@mscmarinduque.edu.ph`
-                    let password = getUserName
-                    const hashedPassword = await bcrypt.hash(password, saltRounds);
-
-                    let temporaryPassword = getUserName
-                    let adminScopes = []
 
                     let employeeNumber =  _instructor?.faculty_id 
                     let departmentId =  _acadDepartment?._id??departmentDefault?._id
@@ -767,19 +1055,65 @@ const server = {
                     let employeeId = employeeFind?._id??null
                     let userId = userFind?._id??_userFind?._id
 
-                    // console.log('userId :>> ', userId);
+                    let getfNameU = _instructor?.first_name.split("")[0].toUpperCase()||""
+                    let getfNameL = _instructor?.first_name.split("")[0].toLowerCase()||""
+                    let getlName = _instructor?.last_name.toLowerCase().replace(/\s/g, '')?? ""
+                    let lastNameWithoutTitles = _instructor?.last_name.split(',')[0].toLowerCase().replace(/\s/g, '')?? ""
+                    let _lastName = _instructor?.last_name.split(',')[0].replace(/\s/g, '')?? ""
 
-                    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}`)
+
+                    let email = `${employeeNumber}.${getfNameL}${lastNameWithoutTitles}@mscmarinduque.edu.ph`
+                    let password = `${employeeNumber}${getfNameU}${lastNameWithoutTitles}`
+                    const hashedPassword = await bcrypt.hash(password, saltRounds);
+
+                    let temporaryPassword = `${employeeNumber}${getfNameU}${lastNameWithoutTitles}`
+                    let adminScopes = []
+
+                    const userApp = await Applications.findOne({ where: { name: "Learning Management System - Instructor" }})
+
+                    let role =  _instructor?.role
+                    let isChairPerson = false
+                    let isDean = false
+                    
+                    if(role === "Program Chair"){
+                        isChairPerson = true
+                    }
+                    if(role === "Dean"){
+                        isDean = true
+                    }
+
+                    let roleCategory
+
+                    if (isDean === true){
+                        roleCategory = await Roles.findOne({where: {name: 'Dean'}})
+
+                    }
+                    else if (isDean === true && departmentId){
+                        roleCategory = await Roles.findOne({where: {description: 'Access all sections under the department'}})
+                    }
+                    else{
+                        roleCategory = await Roles.findOne({where: {name: 'Instructor'}})
+                    }
+
+                    let roleId = roleCategory?._id
+                    let applicationId = userApp?._id
+
+
+
+
+                    // console.log('userId :>> ', userId);
+
+                    if(uULname.has(lastName) && uUFname.has(firstName)){
+                        const errorMsg = `Duplicate Payload Found: ${lastName}, ${firstName}`
+                        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}`
+                    else if (exUserMap.has(`${lastName}, ${firstName} ${middleName}`)){
+                        const exUser = exUserMap.get(`${lastName}, ${firstName} ${middleName}`)
+                        const errorMsg = `Existing Data Found: ${exUser.lastName}, ${exUser.firstName}`
                         if(!uniqueErrors.has(errorMsg)){
                         //   logger.error(`${errorCounter + 1}/${errorCounter + 1}: ${errorMsg}`)
                           uniqueErrors.add(errorMsg)
@@ -796,10 +1130,10 @@ const server = {
                         uScopes.add(adminScopes)
                         newUser.push({
                             firstName: _instructor?.first_name,
-                            lastName: _instructor?.last_name,
+                            lastName: _lastName,
                             middleName: _instructor?.middle_name,
                             password: hashedPassword, 
-                            temporaryPassword: getUserName,
+                            temporaryPassword: password,
                             email,
                             modifiedById,
                             createdById,
@@ -810,7 +1144,24 @@ const server = {
                             isMigrated,
                         })
                     }      
-                    
+
+                    //user roles creation
+                    if(
+                        uApplication.add(applicationId),
+                        uRole.add(roleId),
+                        uUser.add(userId)){
+                            newUserRole.push({
+                                applicationId,
+                                roleId,
+                                userId,
+                                migratedAt,
+                                migratedTable,
+                                isMigrated,
+                            })
+                        }
+                       
+
+                        //instructors creation
                     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)){
@@ -837,7 +1188,7 @@ const server = {
                         uCamp.add(campusId)
                         newInstructor.push({
                             firstName: _instructor?.first_name,
-                            lastName: _instructor?.last_name,
+                            lastName: _lastName,
                             middleName: _instructor?.middle_name,
                             employeeNumber: _instructor?.faculty_id, 
                             departmentId: _acadDepartment?._id??departmentDefault?._id,
@@ -869,6 +1220,22 @@ const server = {
                     // 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 (newUserRole.length > 0) {
+                // Associate userIds with new instructors
+                if(!newUserRole.userId){
+                    newUserRole = newUserRole.map((inst, index) => ({
+                        ...inst,
+                        userId: userIds[index]
+                    }));
+                }
+                await UserRoles.bulkCreate(newUserRole);
+                createdCounter += newUserRole.length;
+    
+                newUserRole.forEach((inst, index) => {
+                    logger.info(`${index + 1}/${index + 1}: User Role Created: ${inst.applicationId} ${inst.roleId} ${inst.userId}`);
+                });
+            }
             
 
             if (newInstructor.length > 0) {
@@ -886,565 +1253,261 @@ const server = {
                     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 AcadDeptInstructor(){
-        try {
-            await db.sequelize.query('DROP FUNCTION IF EXISTS pg_temp.testfunc()');
-
-            console.log("");
-            console.log("########################################################")
-            console.log("      Academic Department Instructors Migrations ")
-            console.log("########################################################")
-            console.log("");
             
-            const db_schema = schema
-            let maxIds = await AcademicDepartmentInstructors.max('_id'); //Fetch maximum _id directly from the Users model
-            let maxId = maxIds|| 0;
-            await db.sequelize.query(`CREATE SEQUENCE IF NOT EXISTS ${db_schema}."AcademicDepartmentInstructors__id_seq"`);      
-            await db.sequelize.query(`ALTER SEQUENCE ${db_schema}."AcademicDepartmentInstructors__id_seq" RESTART WITH ${maxId + 1}`);
-            await db.sequelize.query(`DROP FUNCTION IF EXISTS ${db_schema}."pg_temp.testfunc()"`);
-
-            const instructorApi = await api.Instructor()
-
-            const instructorSeq = await Instructors.findAll()
-            const departmentSeq = await AcademicDepartments.findAll()
-
-            const userMail = await Users.findOne({ where: { email: 'ccci_integrator@gmail.com' } });
-            if (!userMail){}   
-
-            let createdCounter = 0
-            let errorCounter = 0
-            let uniqueErrors = new Set()
-
-            for(let i = 0; i < instructorApi.length; i++){
-                try {
-                    let instructor = instructorApi[i]
-
-                    let _instructor = instructorSeq.find(num => num.employeeNumber === instructor?.faculty_id)
-                    let _department = departmentSeq.find(dep => dep._id === _instructor?.departmentId) 
-
-                    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 modifiedById = userMail._id
-                    let createdById = userMail._id
-
-                    let [record, created] = await AcademicDepartmentInstructors.findOrCreate({
-                        where:{
-                            instructorId: _instructor?._id,
-                            academicDepartmentId: _department?._id,
-                        },
-                        defaults:{
-                            instructorId: _instructor?._id,
-                            academicDepartmentId: _department?._id,
-                            modifiedById,
-                            createdById,
-                            migratedAt,
-                            migratedTable,
-                            isMigrated,
-                        }
-                    })
-                    if (created){
-                        logger.info(`${createdCounter + 1}/${createdCounter + 1} New Academic Department Instructor Record Created: instructorId: ${record.instructorId}, academicDepartmentId: ${record.academicDepartmentId} `)
-                        createdCounter++;
-                    }
-                    else {
-                        const errorMsg = `Academic Department Instructor Record Already Exists: instructorId: ${record.instructorId}, academicDepartmentId: ${record.academicDepartmentId}`;
 
-                        if (!uniqueErrors.has(errorMsg)) {
-                            logger.error(`${errorCounter + 1}/${errorCounter + 1} ${errorMsg}`);
-                            uniqueErrors.add(errorMsg);
-                            errorCounter++;
-                        }
 
-                    }                    
-                    } catch (error) {
-                        logger.error(`Error occurred: ${error} ${error.stack}`);
-                }
-            }
-            let items = createdCounter + errorCounter
             console.log("");
             console.log("########################################################")
             console.log("")
-            logger.info('Academic Department Instructors Data Migration Completed');
-            logger.info(`Total Successful Records Created: ${createdCounter}/${createdCounter}`);
-            logger.info(`Total Existing Records: ${errorCounter}/${errorCounter}`);
-            logger.info(`Total Record Fetched: ${items} `)
-            console.log("")
-            console.log("########################################################")
-            console.log("")
-
-                let totalSummary = {
-                  itemLength: items,
-                  error: errorCounter,
-                  success: createdCounter
-                }
-                return totalSummary
-
-        } catch (error) {
-            logger.error(`Error occurred: ${error} ${error.stack}`);
-        }
-    },
-
-    async Course(){
-        try {
-            await db.sequelize.query('DROP FUNCTION IF EXISTS pg_temp.testfunc()');
-
-            console.log("");
-            console.log("########################################################")
-            console.log("                       Courses Migration ")
-            console.log("########################################################")
-            console.log("");
-
-            const db_schema = schema
-            let maxIds = await Courses.max('_id'); //Fetch maximum _id directly from the Courses model
-            let maxId = maxIds|| 0;
-            await db.sequelize.query(`CREATE SEQUENCE IF NOT EXISTS ${db_schema}."Courses__id_seq"`);      
-            await db.sequelize.query(`ALTER SEQUENCE ${db_schema}."Courses__id_seq" RESTART WITH ${maxId + 1}`);
-            await db.sequelize.query(`DROP FUNCTION IF EXISTS ${db_schema}."pg_temp.testfunc()"`);
-
-            const studentApi = (await api.Student()).data
-            
-            const courseApi = await api.Course()
-            const collegeApi = await api.College()
-            const departmentApi = await api.Department()
-            
-            const acadDeptSeq = await AcademicDepartments.findAll()
-
-            const campusSeq = await Campuses.findAll()
-            const userMail = await Users.findOne({ where: { email: 'ccci_integrator@gmail.com' } });        
-            const campusDefault = await Campuses.findOne({ where: { name: 'Campus Default' } });   
-            const departmentDefault = await AcademicDepartments.findOne({ where: { name: 'AcademicDepartments Default' } });   
-
-            let defaultPayload = {
-                name: 'Course Default',
-                code: 'CORDEF',
-                major: 'Major Course',
-                campusId: campusDefault._id,
-                departmentId: departmentDefault._id,
-                modifiedById: userMail?._id,
-                createdById: userMail?._id
-            };
-            
-            let [defaults, createddef] = await Courses.findOrCreate({
-                where: { name: defaultPayload.name, code: defaultPayload.code}, 
-                defaults: defaultPayload 
-            });
-
-
-            let createdCounter = 0
-            let errorCounter = 0
-            let uniqueErrors = new Set()
-
-            let uCode = new Set()
-            let uName = new Set()
-            let uMajor = new Set()
-            let uCampus = new Set()
-            let uDept = new Set()
-
-            let newCourse = []
-
-            const exCourse = await Courses.findAll()
-            const exCourseMap = new Map(exCourse.map(course => [`[${course.code}] - ${course.name}, ${course.major} [${course.campusId}, ${course.departmentId}]`, course]))
-  
-
-            for (let i = 0; i < studentApi.length; i++){
-                try {
-
-                    let course = studentApi[i]
-                    let courseCode = courseApi.find(crs => crs.name === course?.course)
-                    let campus = campusSeq.find(camp => camp.name === course?.campus) 
-
-                    let college = collegeApi.find(col => col.name === course?.college)
-                    let department = departmentApi.find(dep => dep.name === college?.name)
-                    let _department = acadDeptSeq.find(ad => ad.name === department?.name)
-
-                    let modifiedById = userMail?._id
-                    let createdById = userMail?._id
-
-                          let name =  course?.course
-                          let code =  courseCode?.code
-                          let major =  course?.major
-                          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)){
-                            const errorMsg = `Duplicate Payload Found: [${code}] - ${name}, ${major} [campusId: ${campusId}, academicDepartmentId: ${departmentId}]`
-                          if(!uniqueErrors.has(errorMsg)){
-                            logger.error(`${errorCounter + 1}/${errorCounter + 1}: ${errorMsg}`)
-                            uniqueErrors.add(errorMsg)
-                            errorCounter++
-                          }
-                        }
-                        else if ( exCourseMap.has(`[${code}] - ${name}, ${major} [${campusId}, ${departmentId}]`)){
-                            const exCourse = exCourseMap.get(`[${code}] - ${name}, ${major} [${campusId}, ${departmentId}]`)
-                            const errorMsg = `Existing Data Found: [${exCourse.code}] - ${exCourse.name}, ${exCourse.major} [campusId: ${exCourse.campusId}, academicDepartmentId: ${exCourse.departmentId}]`
-                            if(!uniqueErrors.has(errorMsg)){
-                              logger.error(`${errorCounter + 1}/${errorCounter + 1}: ${errorMsg}`)
-                              uniqueErrors.add(errorMsg)
-                              errorCounter++
-                            }
-                          }
-                        else{
-                            uCode.add(code)
-                            uName.add(name)
-                            uMajor.add(major)
-                            uCampus.add(campusId)
-                            uDept.add(departmentId)
-                            newCourse.push({
-                                name: course?.course,
-                                code: courseCode?.code,
-                                major: course?.major,
-                                campusId: campus?._id??campusDefault?._id,
-                                departmentId: _department?._id??departmentDefault?._id,
-                                modifiedById,
-                                createdById,
-                                migratedAt,
-                                migratedTable,
-                                referenceId,
-                                isMigrated
-                            })
-                        }
-                    
-                } catch (error) {
-                                ;
-            logger.error(`Error occurred: ${error.stack} ${error}`);
-                }
-            }
-
-            if (newCourse.length > 0) {
-                await Courses.bulkCreate(newCourse)
-                createdCounter += newCourse.length
-    
-                newCourse.forEach((course, index) => {
-                    logger.info(`${index + 1}/${index + 1}: New Courses Record Created: [${course.code}] - ${course.name}, ${course.major} [courseId: ${course.campusId}, academicDepartmentId: ${course.departmentId}]`)
-                });
-            }
-
-
-            console.log("");
-            console.log("########################################################")
-            console.log("")
-            logger.info('Course Data Migration Completed');
-            logger.info(`Total Successful Course Records Created: ${createdCounter}/${createdCounter}`);
-            logger.info(`Total Existing Course Records: ${errorCounter}/${errorCounter}`);
+            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: courseApi.length,
+                  itemLength: createdCounter + errorCounter,
                   error: errorCounter,
                   success: createdCounter
                 }
-
-                uniqueErrors.clear();
-
                 return totalSummary
-            
+
         } catch (error) {
                         ;
-            logger.error(`Error occurred: ${error.stack} ${error}`);
+            logger.error(`Error occurred: ${error} ${error.stack} `);
+            
         }
     },
 
-    async Room(){
+    async AcadDeptInstructor(){
         try {
             await db.sequelize.query('DROP FUNCTION IF EXISTS pg_temp.testfunc()');
 
             console.log("");
             console.log("########################################################")
-            console.log("                       Rooms Migration ")
+            console.log("      Academic Department Instructors Migrations ")
             console.log("########################################################")
             console.log("");
-
+            
             const db_schema = schema
-            let maxIds = await Rooms.max('_id'); // Fetch maximum _id directly from the Rooms model
+            let maxIds = await AcademicDepartmentInstructors.max('_id'); //Fetch maximum _id directly from the Users model
             let maxId = maxIds|| 0;
-            await db.sequelize.query(`CREATE SEQUENCE IF NOT EXISTS ${db_schema}."Rooms__id_seq"`);      
-            await db.sequelize.query(`ALTER SEQUENCE ${db_schema}."Rooms__id_seq" RESTART WITH ${maxId + 1}`);
+            await db.sequelize.query(`CREATE SEQUENCE IF NOT EXISTS ${db_schema}."AcademicDepartmentInstructors__id_seq"`);      
+            await db.sequelize.query(`ALTER SEQUENCE ${db_schema}."AcademicDepartmentInstructors__id_seq" RESTART WITH ${maxId + 1}`);
             await db.sequelize.query(`DROP FUNCTION IF EXISTS ${db_schema}."pg_temp.testfunc()"`);
 
-            const subjectRoom = await api.Subject()
-            const roomApi = await api.Room()
+            const instructorApi = await api.Instructor()
 
-            const subjectSeq = await Subjects.findAll()
-            const campusSeq = await Campuses.findAll()
+            const instructorSeq = await Instructors.findAll()
             const departmentSeq = await AcademicDepartments.findAll()
 
-            const userMail = await Users.findOne({ where: { email: 'ccci_integrator@gmail.com' } });    
-            const campusesDefault = await Campuses.findOne({ where: { name: 'Campus Default' } });   
-
-            let defaultPayload = {
-                name: 'Rooms Default',
-                campusId: campusesDefault._id,
-                capacity: 40,
-                modifiedById: userMail?._id,
-                createdById: userMail?._id
-            };
-            
-            let [defaults, createddef] = await Rooms.findOrCreate({
-                where: { name: defaultPayload.name}, 
-                defaults: defaultPayload 
-            });
+            const userMail = await Users.findOne({ where: { email: 'ccci_integrator@gmail.com' } });
+            if (!userMail){}   
 
             let createdCounter = 0
             let errorCounter = 0
             let uniqueErrors = new Set()
 
-            let uName = new Set()
-            let uCampus = new Set()
-
-            let newRoom = []
-
-            const exRoom = await Rooms.findAll()
-            const exRoomMap = new Map(exRoom.map(room => [`[${room.name}] - ${room.campusId}`, room]))
-  
-
-            for (let i = 0; i < roomApi.length; i++){
+            for(let i = 0; i < instructorApi.length; i++){
                 try {
-                    let _room = roomApi[i]
- 
-                    let _subject = subjectRoom.find(r => r.room_id === _room?.id)
-                    let _subjects = subjectSeq.find(s => s.name === _subject?.name)
-                    let _department = departmentSeq.find(dep => dep._id === _subjects?.departmentId)
-                    let _campus = campusSeq.find (cam => cam._id === _department?.campusId)
-
-                    let capacity = 50
-                    let campusDefault = "MSC - Boac Campus"
-                    let _campusDefault = campusSeq.find(ccc => ccc.name === campusDefault)
-
-                    // return console.log('campusDefault :>> ', campusDefault);
+                    let instructor = instructorApi[i]
 
-                    let modifiedById = userMail?._id
-                    let createdById = userMail?._id
+                    let _instructor = instructorSeq.find(num => num.employeeNumber === instructor?.faculty_id)
+                    let _department = departmentSeq.find(dep => dep._id === _instructor?.departmentId) 
 
                     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 migratedTable = 'Instructors' // sql counterpart main table
+                    let referenceId = _instructor?.id // id of the data
                     let isMigrated = true 
 
-                    let name =  _room?.name
-                    let campusId =  _campus?._id??_campusDefault?._id??null
+                    let modifiedById = userMail._id
+                    let createdById = userMail._id
 
-                    if(uName.has(name) && uCampus.has(campusId)){
-                        const errorMsg = `Duplicate Payload Found: [${name}] - campusId: ${campusId}`
-                      if(!uniqueErrors.has(errorMsg)){
-                        logger.error(`${errorCounter + 1}/${errorCounter + 1}: ${errorMsg}`)
-                        uniqueErrors.add(errorMsg)
-                        errorCounter++
-                      }
-                    }
-                    else if ( exRoomMap.has(`[${name}] - ${campusId}`)){
-                        const exRoom = exRoomMap.get(`[${name}] - ${campusId}`)
-                        const errorMsg = `Existing Data Found:[${exRoom.name}] - campusId: ${exRoom.campusId}`
-                        if(!uniqueErrors.has(errorMsg)){
-                          logger.error(`${errorCounter + 1}/${errorCounter + 1}: ${errorMsg}`)
-                          uniqueErrors.add(errorMsg)
-                          errorCounter++
-                        }
-                      }
-                    else{
-                        uName.add(name)
-                        uCampus.add(campusId)
-                        newRoom.push({
-                            name: _room?.name,
-                            campusId: _campus?._id??_campusDefault?._id??campusesDefault._id,
-                            capacity,
+                    let [record, created] = await AcademicDepartmentInstructors.findOrCreate({
+                        where:{
+                            instructorId: _instructor?._id,
+                            academicDepartmentId: _department?._id,
+                        },
+                        defaults:{
+                            instructorId: _instructor?._id,
+                            academicDepartmentId: _department?._id,
                             modifiedById,
                             createdById,
                             migratedAt,
                             migratedTable,
-                            referenceId,
-                            isMigrated
-                        })
+                            isMigrated,
+                        }
+                    })
+                    if (created){
+                        logger.info(`${createdCounter + 1}/${createdCounter + 1} New Academic Department Instructor Record Created: instructorId: ${record.instructorId}, academicDepartmentId: ${record.academicDepartmentId} `)
+                        createdCounter++;
                     }
-                    
-                } catch (error) {
-                                ;
-            logger.error(`Error occurred: ${error.stack} ${error}`);
-                }
-            }
+                    else {
+                        const errorMsg = `Academic Department Instructor Record Already Exists: instructorId: ${record.instructorId}, academicDepartmentId: ${record.academicDepartmentId}`;
 
-            if (newRoom.length > 0) {
-                await Rooms.bulkCreate(newRoom)
-                createdCounter += newRoom.length
-    
-                newRoom.forEach((room, index) => {
-                    logger.info(`${index + 1}/${index + 1}: New Rooms Record Created: [${room.name}], campusId: ${room.campusId}`)
-                });
-            }
+                        if (!uniqueErrors.has(errorMsg)) {
+                            logger.error(`${errorCounter + 1}/${errorCounter + 1} ${errorMsg}`);
+                            uniqueErrors.add(errorMsg);
+                            errorCounter++;
+                        }
 
+                    }                    
+                    } catch (error) {
+                        logger.error(`Error occurred: ${error} ${error.stack}`);
+                }
+            }
+            let items = createdCounter + errorCounter
             console.log("");
             console.log("########################################################")
             console.log("")
-            logger.info('Room Data Migration Completed');
-            logger.info(`Total Successful Room Records Created: ${createdCounter}/${createdCounter}`);
-            logger.info(`Total Existing Room Records: ${errorCounter}/${errorCounter}`);
-            logger.info(`Total Records: ${createdCounter + errorCounter}`);
+            logger.info('Academic Department Instructors Data Migration Completed');
+            logger.info(`Total Successful Records Created: ${createdCounter}/${createdCounter}`);
+            logger.info(`Total Existing Records: ${errorCounter}/${errorCounter}`);
+            logger.info(`Total Record Fetched: ${items} `)
             console.log("")
             console.log("########################################################")
             console.log("")
 
                 let totalSummary = {
-                  itemLength: createdCounter + errorCounter,
+                  itemLength: items,
                   error: errorCounter,
                   success: createdCounter
                 }
                 return totalSummary
 
         } catch (error) {
-            logger.error(`Error occurred: ${error.stack} ${error}`);
-            
+            logger.error(`Error occurred: ${error} ${error.stack}`);
         }
     },
 
-    async AcademicYear(){
+    async Course(){
         try {
             await db.sequelize.query('DROP FUNCTION IF EXISTS pg_temp.testfunc()');
 
             console.log("");
             console.log("########################################################")
-            console.log("                       Academic Years Migration ")
+            console.log("                       Courses Migration ")
             console.log("########################################################")
             console.log("");
 
             const db_schema = schema
-            let maxIds = await AcademicYears.max('_id'); // Fetch maximum _id directly from the AcademicYears model
+            let maxIds = await Courses.max('_id'); //Fetch maximum _id directly from the Courses model
             let maxId = maxIds|| 0;
-            await db.sequelize.query(`CREATE SEQUENCE IF NOT EXISTS ${db_schema}."AcademicYears__id_seq"`);      
-            await db.sequelize.query(`ALTER SEQUENCE ${db_schema}."AcademicYears__id_seq" RESTART WITH ${maxId + 1}`);
+            await db.sequelize.query(`CREATE SEQUENCE IF NOT EXISTS ${db_schema}."Courses__id_seq"`);      
+            await db.sequelize.query(`ALTER SEQUENCE ${db_schema}."Courses__id_seq" RESTART WITH ${maxId + 1}`);
             await db.sequelize.query(`DROP FUNCTION IF EXISTS ${db_schema}."pg_temp.testfunc()"`);
 
+            const studentApi = (await api.Student()).data
+            
+            const courseApi = await api.Course()
+            const collegeApi = await api.College()
+            const departmentApi = await api.Department()
+            
+            const acadDeptSeq = await AcademicDepartments.findAll()
 
-            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()
+            const campusSeq = await Campuses.findAll()
+            const userMail = await Users.findOne({ where: { email: 'ccci_integrator@gmail.com' } });        
+            const campusDefault = await Campuses.findOne({ where: { name: 'Campus Default' } });   
+            const departmentDefault = await AcademicDepartments.findOne({ where: { name: 'AcademicDepartments Default' } });   
+
+            let defaultPayload = {
+                name: 'Course Default',
+                code: 'CORDEF',
+                major: 'Major Course',
+                campusId: campusDefault._id,
+                departmentId: departmentDefault._id,
+                modifiedById: userMail?._id,
+                createdById: userMail?._id
             };
             
-            let [userDefault, createdUser] = await Users.findOrCreate({
-                where: { email: userDefPayload.email }, 
-                defaults: userDefPayload 
-            }); 
+            let [defaults, createddef] = await Courses.findOrCreate({
+                where: { name: defaultPayload.name, code: defaultPayload.code}, 
+                defaults: defaultPayload 
+            });
 
-            const acadYearApi = await api.AcademicYear()
-            const userMail = await Users.findOne({ where: { email: 'ccci_integrator@gmail.com' } });          
 
             let createdCounter = 0
             let errorCounter = 0
             let uniqueErrors = new Set()
 
-            const { acadYearResult, currentSchoolYear } = acadYearApi;
-
-
-            let uFrom = new Set()
-            let uTo = new Set()
+            let uCode = new Set()
+            let uName = new Set()
+            let uMajor = new Set()
+            let uCampus = new Set()
+            let uDept = new Set()
 
-            let newYears = []
+            let newCourse = []
 
-            const exYear = await AcademicYears.findAll()
-            const exYearMap = new Map(exYear.map(year => [`[${year.from} - ${year.to}]`, year]))
+            const exCourse = await Courses.findAll()
+            const exCourseMap = new Map(exCourse.map(course => [`[${course.code}] - ${course.name}, ${course.major} [${course.campusId}, ${course.departmentId}]`, course]))
   
 
-            for (let i = 0; i < acadYearResult.length; i++){
+            for (let i = 0; i < studentApi.length; i++){
                 try {
-                    let _acadyear = acadYearResult[i]
-                    //  console.log('_acadyear :>> ', _acadyear);
-
-                    let [from, to] = _acadyear.year.split('-')
 
-                    to = /^\d+$/.test(to) ? parseInt(to, 10) : null;
-                    from = /^\d+$/.test(from) ? parseInt(from, 10) : null;
-
-                    let defaultDate = new Date()
-                    let currentYear = defaultDate.getFullYear()
-                    let previousYear = currentYear - 1
+                    let course = studentApi[i]
+                    let courseCode = courseApi.find(crs => crs.name === course?.course)
+                    let campus = campusSeq.find(camp => camp.name === course?.campus) 
 
-                    let isDefault = false
-                    if(from == previousYear && to == currentYear) isDefault = true
+                    let college = collegeApi.find(col => col.name === course?.college)
+                    let department = departmentApi.find(dep => dep.name === college?.name)
+                    let _department = acadDeptSeq.find(ad => ad.name === department?.name)
 
                     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 
+                          let name =  course?.course
+                          let code =  courseCode?.code
+                          let major =  course?.major
+                          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(uFrom.has(from) && uTo.has(to)){
-                        const errorMsg = `Duplicate Payload Found: [${from} - ${to}]`
-                      if(!uniqueErrors.has(errorMsg)){
-                        logger.error(`${errorCounter + 1}/${errorCounter + 1}: ${errorMsg}`)
-                        uniqueErrors.add(errorMsg)
-                        errorCounter++
-                      }
-                    }
-                    else if ( exYearMap.has(`[${from} - ${to}]`)){
-                        const exYear = exYearMap.get(`[${from} - ${to}]`)
-                        const errorMsg = `Existing Data Found:[${exYear.from} - ${exYear.to}]`
-                        if(!uniqueErrors.has(errorMsg)){
-                          logger.error(`${errorCounter + 1}/${errorCounter + 1}: ${errorMsg}`)
-                          uniqueErrors.add(errorMsg)
-                          errorCounter++
+                          if(uCode.has(code) && uName.has(name) && uMajor.has(major) && uCampus.has(campusId) && uDept.has(departmentId)){
+                            const errorMsg = `Duplicate Payload Found: [${code}] - ${name}, ${major} [campusId: ${campusId}, academicDepartmentId: ${departmentId}]`
+                          if(!uniqueErrors.has(errorMsg)){
+                            logger.error(`${errorCounter + 1}/${errorCounter + 1}: ${errorMsg}`)
+                            uniqueErrors.add(errorMsg)
+                            errorCounter++
+                          }
+                        }
+                        else if ( exCourseMap.has(`[${code}] - ${name}, ${major} [${campusId}, ${departmentId}]`)){
+                            const exCourse = exCourseMap.get(`[${code}] - ${name}, ${major} [${campusId}, ${departmentId}]`)
+                            const errorMsg = `Existing Data Found: [${exCourse.code}] - ${exCourse.name}, ${exCourse.major} [campusId: ${exCourse.campusId}, academicDepartmentId: ${exCourse.departmentId}]`
+                            if(!uniqueErrors.has(errorMsg)){
+                              logger.error(`${errorCounter + 1}/${errorCounter + 1}: ${errorMsg}`)
+                              uniqueErrors.add(errorMsg)
+                              errorCounter++
+                            }
+                          }
+                        else{
+                            uCode.add(code)
+                            uName.add(name)
+                            uMajor.add(major)
+                            uCampus.add(campusId)
+                            uDept.add(departmentId)
+                            newCourse.push({
+                                name: course?.course,
+                                code: courseCode?.code,
+                                major: course?.major,
+                                campusId: campus?._id??campusDefault?._id,
+                                departmentId: _department?._id??departmentDefault?._id,
+                                modifiedById,
+                                createdById,
+                                migratedAt,
+                                migratedTable,
+                                referenceId,
+                                isMigrated
+                            })
                         }
-                      }
-                    else{
-                        uFrom.add(from)
-                        uTo.add(to)
-                        newYears.push({
-                            from,
-                            to,
-                            modifiedById,
-                            createdById,
-                            default: isDefault,
-                            migratedAt,
-                            migratedTable,
-                            referenceId,
-                            isMigrated
-                        })
-                    }
                     
                 } catch (error) {
                                 ;
@@ -1452,120 +1515,132 @@ const server = {
                 }
             }
 
-            if (newYears.length > 0) {
-                await AcademicYears.bulkCreate(newYears)
-                createdCounter += newYears.length
+            if (newCourse.length > 0) {
+                await Courses.bulkCreate(newCourse)
+                createdCounter += newCourse.length
     
-                newYears.forEach((year, index) => {
-                    logger.info(`${index + 1}/${index + 1}: New Academic Years Record Created: [${year.from} - ${year.to}]`)
+                newCourse.forEach((course, index) => {
+                    logger.info(`${index + 1}/${index + 1}: New Courses Record Created: [${course.code}] - ${course.name}, ${course.major} [courseId: ${course.campusId}, academicDepartmentId: ${course.departmentId}]`)
                 });
             }
 
+
             console.log("");
             console.log("########################################################")
             console.log("")
-            logger.info('Academic Years Data Migration Completed');
-            logger.info(`Total Successful Academic Years Records Created: ${createdCounter}/${createdCounter}`);
-            logger.info(`Total Existing Academic Years Records: ${errorCounter}/${errorCounter}`);
-            logger.info(`Total Records: ${createdCounter + errorCounter}`);
+            logger.info('Course Data Migration Completed');
+            logger.info(`Total Successful Course Records Created: ${createdCounter}/${createdCounter}`);
+            logger.info(`Total Existing Course Records: ${errorCounter}/${errorCounter}`);
             console.log("")
             console.log("########################################################")
             console.log("")
 
                 let totalSummary = {
-                  itemLength: createdCounter + errorCounter,
+                  itemLength: courseApi.length,
                   error: errorCounter,
                   success: createdCounter
                 }
-                return totalSummary
 
+                uniqueErrors.clear();
+
+                return totalSummary
+            
         } catch (error) {
                         ;
             logger.error(`Error occurred: ${error.stack} ${error}`);
-            
         }
     },
 
-    async Semester(){
+    async Room(){
         try {
             await db.sequelize.query('DROP FUNCTION IF EXISTS pg_temp.testfunc()');
 
             console.log("");
             console.log("########################################################")
-            console.log("                 Semesters Migration ")
+            console.log("                       Rooms Migration ")
             console.log("########################################################")
             console.log("");
 
             const db_schema = schema
-            let maxIds = await AcademicYears.max('_id'); // Fetch maximum _id directly from the AcademicYears model
+            let maxIds = await Rooms.max('_id'); // Fetch maximum _id directly from the Rooms model
             let maxId = maxIds|| 0;
-            await db.sequelize.query(`CREATE SEQUENCE IF NOT EXISTS ${db_schema}."Semesters__id_seq"`);      
-            await db.sequelize.query(`ALTER SEQUENCE ${db_schema}."Semesters__id_seq" RESTART WITH ${maxId + 1}`);
+            await db.sequelize.query(`CREATE SEQUENCE IF NOT EXISTS ${db_schema}."Rooms__id_seq"`);      
+            await db.sequelize.query(`ALTER SEQUENCE ${db_schema}."Rooms__id_seq" RESTART WITH ${maxId + 1}`);
             await db.sequelize.query(`DROP FUNCTION IF EXISTS ${db_schema}."pg_temp.testfunc()"`);
 
+            const subjectRoom = await api.Subject()
+            const roomApi = await api.Room()
+
+            const subjectSeq = await Subjects.findAll()
+            const campusSeq = await Campuses.findAll()
+            const departmentSeq = await AcademicDepartments.findAll()
 
-            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()
+            const userMail = await Users.findOne({ where: { email: 'ccci_integrator@gmail.com' } });    
+            const campusesDefault = await Campuses.findOne({ where: { name: 'Campus Default' } });   
+
+            let defaultPayload = {
+                name: 'Rooms Default',
+                campusId: campusesDefault._id,
+                capacity: 40,
+                modifiedById: userMail?._id,
+                createdById: userMail?._id
             };
             
-            let [userDefault, createdUser] = await Users.findOrCreate({
-                where: { email: userDefPayload.email }, 
-                defaults: userDefPayload 
-            }); 
-            
-            const acadYearApi = await api.AcademicYear()
-            const userMail = await Users.findOne({ where: { email: 'ccci_integrator@gmail.com' } });          
+            let [defaults, createddef] = await Rooms.findOrCreate({
+                where: { name: defaultPayload.name}, 
+                defaults: defaultPayload 
+            });
 
             let createdCounter = 0
             let errorCounter = 0
             let uniqueErrors = new Set()
 
-            const { acadYearResult, currentSchoolYear } = acadYearApi;
-
-
-            let uCode = new Set()
-            let uDesc = new Set()
+            let uName = new Set()
+            let uCampus = new Set()
 
-            let newYears = []
+            let newRoom = []
 
-            const exYear = await Semesters.findAll()
-            const exYearMap = new Map(exYear.map(sem => [`[${sem.code}] ${sem.description}`, sem]))
+            const exRoom = await Rooms.findAll()
+            const exRoomMap = new Map(exRoom.map(room => [`[${room.name}] - ${room.campusId}`, room]))
   
 
-            for (let i = 0; i < acadYearResult.length; i++){
+            for (let i = 0; i < roomApi.length; i++){
                 try {
-                    let _acadyear = acadYearResult[i]
+                    let _room = roomApi[i]
+ 
+                    let _subject = subjectRoom.find(r => r.room_id === _room?.id)
+                    let _subjects = subjectSeq.find(s => s.name === _subject?.name)
+                    let _department = departmentSeq.find(dep => dep._id === _subjects?.departmentId)
+                    let _campus = campusSeq.find (cam => cam._id === _department?.campusId)
+
+                    let capacity = 50
+                    let campusDefault = "MSC - Boac Campus"
+                    let _campusDefault = campusSeq.find(ccc => ccc.name === campusDefault)
+
+                    // return console.log('campusDefault :>> ', campusDefault);
 
                     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 migratedTable = 'Rooms' // sql counterpart main table
+                    let referenceId = _room?.id // id of the data
                     let isMigrated = true 
 
-                    let code = _acadyear?.term
-                    let description = _acadyear?.term
-
+                    let name =  _room?.name
+                    let campusId =  _campus?._id??_campusDefault?._id??null
 
-                    if(uCode.has(code) && uDesc.has(description)){
-                        const errorMsg = `Duplicate Payload Found: [${code}] ${description}]`
+                    if(uName.has(name) && uCampus.has(campusId)){
+                        const errorMsg = `Duplicate Payload Found: [${name}] - campusId: ${campusId}`
                       if(!uniqueErrors.has(errorMsg)){
                         logger.error(`${errorCounter + 1}/${errorCounter + 1}: ${errorMsg}`)
                         uniqueErrors.add(errorMsg)
                         errorCounter++
                       }
                     }
-                    else if ( exYearMap.has(`[${code}] ${description}`)){
-                        const exYear = exYearMap.get(`[${code}] ${description}`)
-                        const errorMsg = `Existing Data Found:[${exYear.code}] ${exYear.description}]`
+                    else if ( exRoomMap.has(`[${name}] - ${campusId}`)){
+                        const exRoom = exRoomMap.get(`[${name}] - ${campusId}`)
+                        const errorMsg = `Existing Data Found:[${exRoom.name}] - campusId: ${exRoom.campusId}`
                         if(!uniqueErrors.has(errorMsg)){
                           logger.error(`${errorCounter + 1}/${errorCounter + 1}: ${errorMsg}`)
                           uniqueErrors.add(errorMsg)
@@ -1573,11 +1648,12 @@ const server = {
                         }
                       }
                     else{
-                        uCode.add(code)
-                        uDesc.add(description)
-                        newYears.push({
-                            code,
-                            description,
+                        uName.add(name)
+                        uCampus.add(campusId)
+                        newRoom.push({
+                            name: _room?.name,
+                            campusId: _campus?._id??_campusDefault?._id??campusesDefault._id,
+                            capacity,
                             modifiedById,
                             createdById,
                             migratedAt,
@@ -1593,21 +1669,21 @@ const server = {
                 }
             }
 
-            if (newYears.length > 0) {
-                await Semesters.bulkCreate(newYears)
-                createdCounter += newYears.length
+            if (newRoom.length > 0) {
+                await Rooms.bulkCreate(newRoom)
+                createdCounter += newRoom.length
     
-                newYears.forEach((year, index) => {
-                    logger.info(`${index + 1}/${index + 1}: New Semesters Years Record Created: [${year.code} - ${year.description}]`)
+                newRoom.forEach((room, index) => {
+                    logger.info(`${index + 1}/${index + 1}: New Rooms Record Created: [${room.name}], campusId: ${room.campusId}`)
                 });
             }
 
             console.log("");
             console.log("########################################################")
             console.log("")
-            logger.info('Semesters Data Migration Completed');
-            logger.info(`Total Successful Semesters Records Created: ${createdCounter}/${createdCounter}`);
-            logger.info(`Total Existing Semesters Records: ${errorCounter}/${errorCounter}`);
+            logger.info('Room Data Migration Completed');
+            logger.info(`Total Successful Room Records Created: ${createdCounter}/${createdCounter}`);
+            logger.info(`Total Existing Room Records: ${errorCounter}/${errorCounter}`);
             logger.info(`Total Records: ${createdCounter + errorCounter}`);
             console.log("")
             console.log("########################################################")
@@ -1621,7 +1697,6 @@ const server = {
                 return totalSummary
 
         } catch (error) {
-                        ;
             logger.error(`Error occurred: ${error.stack} ${error}`);
             
         }
@@ -1990,6 +2065,8 @@ const server = {
             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' } });
             
@@ -2032,6 +2109,15 @@ const server = {
             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 uApplication = new Set()
+            let uRole = new Set ()
+            let uUser = new Set ()
+
+            let newUserRole = []
+
+            const exURole = await UserRoles.findAll()
+            const exURoleMap = new Map (exURole.map( role => [`${role.applicationId} ${role.roleId} ${role.userId}`, role]))
+
             let uNum = new Set()
             let uLname = new Set()
             let uMname = new Set()
@@ -2083,20 +2169,27 @@ const server = {
                     let courseId = _course?._id??courseDefault?._id
                     let campusId = _campus?._id??campusDefault?._id
 
-                    let getUserName = Mixins.generateUsername(firstName, lastName)
-                    let email = `${getUserName}@mscmarinduque.edu.ph`
-                    let password = `${getUserName}`
-                    
-                    const hashedPassword = await bcrypt.hash(password, saltRounds);
-                    let temporaryPassword = getUserName
-                    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 
 
+                    let getfNameU = _student?.first_name.split("")[0].toUpperCase()||""
+                    let getfNameL = _student?.first_name.split("")[0].toLowerCase()||""
+                    let getlName = _student?.last_name.toLowerCase().replace(/\s/g, '')?? ""
+
+                    let email = `${studentNumber}.${getfNameL}${getlName}@mscmarinduque.edu.ph`
+                    let password = `${studentNumber}${getfNameU}${getlName}`
+                    
+                    const hashedPassword = await bcrypt.hash(password, saltRounds);
+                    let temporaryPassword = `${studentNumber}${getfNameU}${getlName}`
+                    let adminScopes = []
+
+                    const roleSeq = await Roles.findOne({ where: { name: "Student" }})
+                    const userApp = await Applications.findOne({ where: { name: "Learning Management System - Student/Parent" }})
 
+                    let roleId = roleSeq?._id
+                    let applicationId = userApp?._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}`
@@ -2128,7 +2221,7 @@ const server = {
                             lastName: _student?.last_name,
                             middleName: _student?.middle_name,
                             password: hashedPassword, 
-                            temporaryPassword: getUserName,
+                            temporaryPassword: password,
                             email,
                             modifiedById,
                             createdById,
@@ -2140,6 +2233,21 @@ const server = {
                         })
                     }    
 
+                                        
+                    if(
+                        uApplication.add(applicationId),
+                        uRole.add(roleId)
+                        ){
+                            newUserRole.push({
+                                applicationId,
+                                roleId,
+                                migratedAt,
+                                migratedTable,
+                                isMigrated,
+                            })
+                        }
+
+
                     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)){
@@ -2197,6 +2305,23 @@ const server = {
                     // 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 (newUserRole.length > 0) {
+                // Associate userIds with new students
+                newUserRole = newUserRole.map((exStudent, index) => ({
+                    ...exStudent,
+                    userId: userIds[index]
+                }));
+    
+                await UserRoles.bulkCreate(newUserRole);
+                createdCounter += newUserRole.length;
+    
+                newUserRole.forEach((exStudent, index) => {
+                    logger.info(`${index + 1}/${index + 1}: ${exStudent.userId} ${exStudent.applicationId} ${exStudent.roleId} `)
+                 });
+            }
+
+            
             
             if (newStudent.length > 0) {
                 // Associate userIds with new students
@@ -2772,6 +2897,8 @@ async function runServerFunctions() {
 
 module.exports = {
     serverTable: server,
+    AcademicYear: server.AcademicYear,
+    Semester: server.Semester,
     Campus: server.Campus,
     College: server.College,
     AcademicDepartments: server.AcademicDepartment,
@@ -2779,8 +2906,6 @@ module.exports = {
     Room: server.Room,
     Instructor: server.Instructor,
     AcadDeptInstructor: server.AcadDeptInstructor,
-    AcademicYear: server.AcademicYear,
-    Semester: server.Semester,
     Subject: server.Subject,
     Schedule: server.Schedule,
     Student: server.Student,