lms-sync 1.0.14 → 1.0.15

package/apiConnections/mappings-old.js

@@ -0,0 +1,1517 @@
+const {db, schema} = require('../models')
+const logger = require('../utils/logger')
+const api = require('../apiConnections/apiConnects')
+const moment = require('moment')
+const { Picked } = require('./semesterPick')
+
+const {
+    AcademicDepartments,
+    AcademicYears,
+    Campuses,
+    Colleges,
+    Courses,
+    EnrolledStudents,
+    Instructors,
+    Rooms,
+    Sections,
+    Students,
+    Subjects,
+    Schedules,
+    Users,
+    Semesters
+
+} = db
+
+const server = {
+
+    async Campus(){
+        try {
+            console.log("");
+            console.log("########################################################")
+            console.log("                       Campuses Migration ")
+            console.log("########################################################")
+            console.log("");
+
+            const campusApi = await api.Campus()
+            const userMail = await Users.findOne({ where: { email: 'ccci_integrator@gmail.com' } });            
+
+            let createdCounter = 0
+            let errorCounter = 0
+            let uniqueErrors = new Set()
+
+            const db_schema = schema
+// let maxIds = await Campuses.max('_id'); = await Campuses.max('_id'); // Fetch maximum _id directly from the campuses model
+            // let maxId = maxIds|| 0;
+            // await db.sequelize.query(`ALTER SEQUENCE ${db_schema}."Campuses__id_seq" RESTART WITH ${maxId + 1}`);
+  
+            for (let i = 0; i < campusApi.length; i++){
+                try {
+                    
+                    let _campus = campusApi[i]
+
+                    let modifiedById = userMail._id
+                    let createdById = userMail._id
+
+                    let [record, created] = await Campuses.findOrCreate({
+                        where:{
+                            name: _campus?.name,
+                            code: _campus?.code
+                        },
+                        defaults:{
+                            email: _campus?.email,
+                            address: _campus?.address,
+                            modifiedById,
+                            createdById
+                        }
+                    })
+                    if (created){
+                        logger.info(`New campus record created ${createdCounter + 1}/${createdCounter}: [${record.code}] - ${record.name} `)
+                        createdCounter++;
+                    }
+                    else {
+                        const errorMsg = `Record campus already exists: [${record.code}] - ${record.name} `;
+                        if (!uniqueErrors.has(errorMsg)) {
+                            logger.error(`${errorCounter + 1}/${errorCounter + 1} ${errorMsg}`);
+                            uniqueErrors.add(errorMsg);
+                            errorCounter++;
+                        }
+
+                    }
+                    
+                } catch (error) {
+                                logger.error(`Error occurred: ${error}`);
+            logger.error(`Error occurred: ${error.stack}`);
+                }
+            }
+
+            let items = createdCounter + errorCounter
+            console.log("");
+            console.log("########################################################")
+            console.log("")
+            logger.info(' Campus Data Migration Completed');
+            logger.info(`Total successful Campus records created: ${createdCounter}/${createdCounter}`);
+            logger.info(`Total Campus Error 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}`);
+            logger.error(`Error occurred: ${error.stack}`);
+            
+        }
+    },
+
+    async College(){
+        try {
+            console.log("");
+            console.log("########################################################")
+            console.log("                       Colleges Migration ")
+            console.log("########################################################")
+            console.log("");
+
+            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' } });            
+
+            let createdCounter = 0
+            let errorCounter = 0
+            let uniqueErrors = new Set()
+
+            const db_schema = schema
+// let maxIds = await Campuses.max('_id'); = await Colleges.max('_id'); // Fetch maximum _id directly from the Colleges model
+            // let maxId = maxIds|| 0;
+            // await db.sequelize.query(`ALTER SEQUENCE ${db_schema}."Colleges__id_seq" RESTART WITH ${maxId + 1}`);
+
+            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 campusDefault = 999999
+
+                    let modifiedById = userMail._id
+                    let createdById = userMail._id
+
+                    let [record, created] = await Colleges.findOrCreate({
+  
+                        where:{
+                            name: _college?.name,
+                            code: _college?.code
+                        },
+                        defaults:{
+                            campusId: _campus?._id??campusDefault,
+                            modifiedById,
+                            createdById
+                        }
+                    })
+                    if (created){
+                        logger.info(`New college record created ${createdCounter + 1}/${createdCounter + 1}: [${record.code}] - ${record.name} `)
+                        createdCounter++;
+                    }
+                    else {
+                        const errorMsg = `Record college already exists: [${record.code}] - ${record.name} `
+
+                        if (!uniqueErrors.has(errorMsg)) {
+                            logger.error(`${errorCounter + 1}/${errorCounter + 1} ${errorMsg}`);
+                            uniqueErrors.add(errorMsg);
+                            errorCounter++;
+                        }
+                    }
+                    
+                } catch (error) {
+                                logger.error(`Error occurred: ${error}`);
+            logger.error(`Error occurred: ${error.stack}`);
+                }
+            }
+
+            let items = createdCounter + errorCounter
+
+            console.log("");
+            console.log("########################################################")
+            console.log("")
+            logger.info(' College Data Migration Completed');
+            logger.info(`Total successful College records created: ${createdCounter}/${createdCounter}`);
+            logger.info(`Total College Error 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}`);
+            logger.error(`Error occurred: ${error.stack}`);
+            
+        }
+    },
+
+    async AcademicDepartment(){
+        try {
+            console.log("");
+            console.log("########################################################")
+            console.log("                       Academic Departments Migration ")
+            console.log("########################################################")
+            console.log("");
+
+            const departmentApi = await api.Department()
+            const campusApi = await api.Campus()
+            const collegeApi = await api.College()
+
+
+            const campusSeq = await Campuses.findAll()
+            const collegeSeq = await Colleges.findAll()
+            const userMail = await Users.findOne({ where: { email: 'ccci_integrator@gmail.com' } });            
+
+            let createdCounter = 0
+            let errorCounter = 0
+            let uniqueErrors = new Set()
+
+            const db_schema = schema
+// let maxIds = await Campuses.max('_id'); = await AcademicDepartments.max('_id'); // Fetch maximum _id directly from the AcademicDepartments model
+            // let maxId = maxIds|| 0;
+            // await db.sequelize.query(`ALTER SEQUENCE ${db_schema}."AcademicDepartments__id_seq" RESTART WITH ${maxId + 1}`);
+            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 campusDefault = 999999
+                    let collegeDefault = 999999
+                    let chairPersonDefault = 999999
+
+                    let modifiedById = userMail._id
+                    let createdById = userMail._id
+
+
+                    let [record, created] = await AcademicDepartments.findOrCreate({
+
+                        where:{
+                            name: _acadDept?.name,
+                            code: _acadDept?.code
+                        },
+                        defaults:{
+                            collegeId: _college?._id??collegeDefault,
+                            campusId: campus?._id??campusDefault, 
+                            chairPersonId: chairPersonDefault,
+                            modifiedById,
+                            createdById
+                        }
+                    })
+                    if (created){
+                        logger.info(`New academic department record created ${createdCounter + 1}/${createdCounter + 1}: [${record.code}] - ${record.name} `)
+                        createdCounter++;
+                    }
+                    else {
+                        const errorMsg = `Record academic department already exists: [${record.code}] - ${record.name} `
+
+                        if (!uniqueErrors.has(errorMsg)) {
+                            logger.error(`${errorCounter + 1}/${errorCounter + 1} ${errorMsg}`);
+                            uniqueErrors.add(errorMsg);
+                            errorCounter++;
+                        }
+
+                    }
+                    
+                } catch (error) {
+                                logger.error(`Error occurred: ${error}`);
+            logger.error(`Error occurred: ${error.stack}`);
+                }
+            }
+
+            let items = 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 Academic Department Error 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}`);
+            logger.error(`Error occurred: ${error.stack}`);
+            
+        }
+    },
+
+    async Course(){
+        try {
+            console.log("");
+            console.log("########################################################")
+            console.log("                       Courses Migration ")
+            console.log("########################################################")
+            console.log("");
+
+            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' } });            
+
+            let createdCounter = 0
+            let errorCounter = 0
+            let uniqueErrors = new Set()
+
+            const db_schema = schema
+// let maxIds = await Campuses.max('_id'); = await Courses.max('_id'); // Fetch maximum _id directly from the Courses model
+            // let maxId = maxIds|| 0;
+            // await db.sequelize.query(`ALTER SEQUENCE ${db_schema}."Courses__id_seq" RESTART WITH ${maxId + 1}`);
+
+            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 [record, created] = await Courses.findOrCreate({
+                        where:{
+                            name: course?.course,
+                            code: courseCode?.code,
+                            major: course?.major,
+                            campusId: campus?._id??null,
+                            departmentId: _department?._id??null,
+                            modifiedById,
+                            createdById
+                        },
+                        defaults:{
+
+
+                        }
+                    })
+
+                    if (created) {
+                        logger.info(`New course record created ${createdCounter +1}/${createdCounter +1}: [${record.code}] - ${record.name}, Major in ${record.major}`)
+                        createdCounter++                        
+                    } else {
+
+                        const errorMsg = `Record course already exists: [${record.code}] - ${record.name}, Major in ${record.major}`;
+
+                        if (!uniqueErrors.has(errorMsg)) {
+                            logger.error(`${errorCounter + 1}/${errorCounter + 1} ${errorMsg}`);
+                            uniqueErrors.add(errorMsg);
+                            errorCounter++;
+                        }
+                        
+                    }
+                    
+                } catch (error) {
+                                logger.error(`Error occurred: ${error}`);
+            logger.error(`Error occurred: ${error.stack}`);
+                }
+            }
+
+            let items = createdCounter + errorCounter
+
+
+            console.log("");
+            console.log("########################################################")
+            console.log("")
+            logger.info(' Course Data Migration Completed');
+            logger.info(`Total successful Course records created: ${createdCounter}/${createdCounter}`);
+            logger.info(`Total Course Error Records: ${errorCounter}/${errorCounter}`);
+            logger.info(`Total Record Fetched: ${items} `)
+            console.log("")
+            console.log("########################################################")
+            console.log("")
+
+                let totalSummary = {
+                  itemLength: items,
+                  error: errorCounter,
+                  success: createdCounter
+                }
+
+                uniqueErrors.clear();
+
+                return totalSummary
+            
+        } catch (error) {
+                        logger.error(`Error occurred: ${error}`);
+            logger.error(`Error occurred: ${error.stack}`);
+        }
+    },
+
+    async Room(){
+        try {
+            console.log("");
+            console.log("########################################################")
+            console.log("                       Rooms Migration ")
+            console.log("########################################################")
+            console.log("");
+
+            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()
+
+            const userMail = await Users.findOne({ where: { email: 'ccci_integrator@gmail.com' } });    
+
+            let createdCounter = 0
+            let errorCounter = 0
+            let uniqueErrors = new Set()
+
+
+            const db_schema = schema
+// let maxIds = await Campuses.max('_id'); = await Rooms.max('_id'); // Fetch maximum _id directly from the Rooms model
+            // let maxId = maxIds|| 0;
+            // await db.sequelize.query(`ALTER SEQUENCE ${db_schema}."Rooms__id_seq" RESTART WITH ${maxId + 1}`);
+
+
+            for (let i = 0; i < roomApi.length; i++){
+                try {
+                    let _room = roomApi[i]
+ 
+                    let _subject = subjectRoom.find(r => r.room_id === _room?.id)
+                    // console.log('_subject :>> ', _subject);
+
+                    let _subjects = subjectSeq.find(s => s.name === _subject?.name)
+                    // console.log('_subjects :>> ', _subjects);
+
+
+                    let _department = departmentSeq.find(dep => dep._id === _subjects?.departmentId)
+                    // console.log('_department :>> ', _department);
+
+
+                    let _campus = campusSeq.find (cam => cam._id === _department?.campusId)
+                    // console.log('_campus :>> ', _campus);
+
+
+                    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 [record, created] = await Rooms.findOrCreate({
+                        where:{
+                            name: _room?.name,
+                            campusId: _campus?._id??_campusDefault?._id??null,
+                        },
+                        defaults:{
+                            capacity,
+                            modifiedById,
+                            createdById
+
+                        }
+                    })
+                    if (created){
+                        logger.info(`New room record created ${createdCounter + 1}/${createdCounter + 1}: ${record.name} `)
+                        createdCounter++;
+                    }
+                    else {
+                        const errorMsg = `Record room already exists: ${record.name}`;
+
+                        if (!uniqueErrors.has(errorMsg)) {
+                            logger.error(`${errorCounter + 1}/${errorCounter + 1} ${errorMsg}`);
+                            uniqueErrors.add(errorMsg);
+                            errorCounter++;
+                        }
+
+                    }
+                    
+                } catch (error) {
+                                logger.error(`Error occurred: ${error}`);
+            logger.error(`Error occurred: ${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 Room Error 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}`);
+            logger.error(`Error occurred: ${error.stack}`);
+            
+        }
+    },
+
+    async Instructor(){
+        try {
+            console.log("");
+            console.log("########################################################")
+            console.log("                       Instructors Migration ")
+            console.log("########################################################")
+            console.log("");
+
+            const instructorApi = await api.Instructor()
+            const departmentApi = await api.Department()
+
+            const departmentSeq = await AcademicDepartments.findAll()
+            const campusSeq = await Campuses.findAll()
+            const userMail = await Users.findOne({ where: { email: 'ccci_integrator@gmail.com' } });            
+
+            let createdCounter = 0
+            let errorCounter = 0
+            let uniqueErrors = new Set()
+
+
+            const db_schema = schema
+// let maxIds = await Campuses.max('_id'); = await Instructors.max('_id'); // Fetch maximum _id directly from the Instructors model
+            // let maxId = maxIds|| 0;
+            // await db.sequelize.query(`ALTER SEQUENCE ${db_schema}."Instructors__id_seq" RESTART WITH ${maxId + 1}`);
+
+
+            for (let i = 0; i < instructorApi.length; i++){
+                try {
+                    let _instructor = instructorApi[i]
+
+                    let acadDepartmentMap = departmentApi.find(a => a.name === _instructor?.department_name)
+
+                    let _acadDepartment = departmentSeq.find(b => b.name === acadDepartmentMap?.name)
+
+                    let campusMap = campusSeq.find(c => c._id === _acadDepartment?.campusId)
+
+                    let academicDepartmentDefault = 999999
+
+                    let modifiedById = userMail._id
+                    let createdById = userMail._id
+                    
+
+                    let campusDefault = "MSC - Boac Campus"
+                    let _campusDefault = campusSeq.find(ccc => ccc.name === campusDefault)
+
+                    let [record, created] = await Instructors.findOrCreate({
+                        where:{
+                            firstName: _instructor?.first_name,
+                            lastName: _instructor?.last_name,
+                            middleName: _instructor?.middle_name,
+                            employeeNumber: _instructor?.faculty_id, 
+                            departmentId: _acadDepartment?._id??academicDepartmentDefault,
+                            campusId: campusMap?._id??_campusDefault?._id,
+                            modifiedById,
+                            createdById,
+                            // employeeId: record?._id??null,
+
+
+                        },
+                        defaults:{
+
+                        }
+                    })
+                    if (created){
+                        logger.info(`New instructor record created ${createdCounter + 1}/${createdCounter + 1}: [${record.employeeNumber}] - ${record.lastName}, ${record.firstName} `)
+                        createdCounter++;
+                    }
+                    else {
+                        const errorMsg = `Record instructor already exists: [${record.employeeNumber}] - ${record.lastName}, ${record.firstName}`;
+
+                        if (!uniqueErrors.has(errorMsg)) {
+                            logger.error(`${errorCounter + 1}/${errorCounter + 1} ${errorMsg}`);
+                            uniqueErrors.add(errorMsg);
+                            errorCounter++;
+                        }
+
+                    }
+                    
+                } catch (error) {
+                                logger.error(`Error occurred: ${error}`);
+            logger.error(`Error occurred: ${error.stack}`);
+                }
+            }
+
+            let items = createdCounter + errorCounter
+
+            console.log("");
+            console.log("########################################################")
+            console.log("")
+            logger.info(' Instructors Data Migration Completed');
+            logger.info(`Total successful Instructors records created: ${createdCounter}/${createdCounter}`);
+            logger.info(`Total Instructors Error 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}`);
+            logger.error(`Error occurred: ${error.stack}`);
+            
+        }
+    },
+
+    async AcademicYear(){
+        try {
+            console.log("");
+            console.log("########################################################")
+            console.log("                       Academic Years Migration ")
+            console.log("########################################################")
+            console.log("");
+
+            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;
+
+
+            const db_schema = schema
+// let maxIds = await Campuses.max('_id'); = await AcademicYears.max('_id'); // Fetch maximum _id directly from the AcademicYears model
+            // let maxId = maxIds|| 0;
+            // await db.sequelize.query(`ALTER SEQUENCE ${db_schema}."AcademicYears__id_seq" RESTART WITH ${maxId + 1}`);
+
+
+            for (let i = 0; i < acadYearResult.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 isDefault = false
+                    if(from == previousYear && to == currentYear) isDefault = true
+
+                    let modifiedById = userMail._id
+                    let createdById = userMail._id
+
+                    let [record, created] = await AcademicYears.findOrCreate({
+                        where:{
+                            from,
+                            to
+                        },
+                        defaults:{
+                            modifiedById,
+                            createdById,
+                            default: isDefault
+                        }
+                    })
+                    if (created){
+                        logger.info(`New academic year record created ${createdCounter + 1}/${createdCounter + 1}: ${record.from} - ${record.to} `)
+                        createdCounter++;
+                    }
+                    else {
+                        const errorMsg = `Record academic year already exists: ${record.from} - ${record.to}`;
+                        if (!uniqueErrors.has(errorMsg)) {
+                            logger.error(`${errorCounter + 1}/${errorCounter + 1} ${errorMsg}`);
+                            uniqueErrors.add(errorMsg);
+                            errorCounter++;
+                        }
+                    }
+                    
+                } catch (error) {
+                                logger.error(`Error occurred: ${error}`);
+            logger.error(`Error occurred: ${error.stack}`);
+                }
+            }
+
+            let items = createdCounter + errorCounter
+
+            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 Academic Years Error 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}`);
+            logger.error(`Error occurred: ${error.stack}`);
+            
+        }
+    },
+
+    async Subject(){
+        try {
+            console.log("");
+            console.log("########################################################")
+            console.log("                       Subjects Migration ")
+            console.log("########################################################")
+            console.log("");
+
+            const studentSubject = (await api.Student()).data
+
+            const subjectApi = await api.Subject()
+
+            const departmentSeq = await AcademicDepartments.findAll()
+            const userMail = await Users.findOne({ where: { email: 'ccci_integrator@gmail.com' } });            
+
+            let createdCounter = 0
+            let errorCounter = 0
+            let uniqueErrors = new Set()
+
+
+            const db_schema = schema
+// let maxIds = await Campuses.max('_id'); = await Subjects.max('_id'); // Fetch maximum _id directly from the Subjects model
+            // let maxId = maxIds|| 0;
+            // await db.sequelize.query(`ALTER SEQUENCE ${db_schema}."Subjects__id_seq" RESTART WITH ${maxId + 1}`);
+
+
+            for (let i = 0; i < studentSubject.length; i++){
+                try {
+                    let _subject = studentSubject[i]
+
+                    let _department = departmentSeq.find(dep => dep.name === _subject?.college)
+
+                    let _subs = studentSubject[i].subjects_enrolled;
+
+
+                    for (let j = 0; j < _subs.length; j++){
+
+                        let subject = _subs[j].subject_code
+
+                        let _subjects = subjectApi.find(sub => sub.code === subject)
+
+                        // return console.log('_subjects :>> ', _subjects);
+
+
+                        if (!subject) {
+                            // console.error(`Subject with code ${subjects} not found.`);
+                            continue;
+                        }
+                        if (!_subjects) {
+                            // console.error(`Subject with code ${subjects} not found.`);
+                            continue;
+                        }
+                        let subjectType = "LECTURE"
+                        let modifiedById = userMail._id
+                        let createdById = userMail._id
+
+    
+    
+                        let [record, created] = await Subjects.findOrCreate({
+                            where:{
+                                code:_subjects?.code,
+                                name:_subjects?.name,
+                                units:_subjects?.units,
+                                //add null here 
+                                departmentId: _department?._id??null,
+                                subjectType,
+                                modifiedById,
+                                createdById
+                            },
+                            defaults:{
+
+                            }
+                        })
+                        if (created){
+                            logger.info(`New subject record created ${createdCounter + 1}/${createdCounter + 1}: [${record.code}], ${record.name} `)
+                            createdCounter++;
+                        }
+                        else { 
+                            const errorMsg = `Record subject already exists: [${record.code}], ${record.name}`;
+
+                            if (!uniqueErrors.has(errorMsg)) {
+                                logger.error(`${errorCounter + 1}/${errorCounter + 1} ${errorMsg}`);
+                                uniqueErrors.add(errorMsg);
+                                errorCounter++;
+                            }
+                        }
+                    }
+
+                    
+                } catch (error) {
+                                logger.error(`Error occurred: ${error}`);
+            logger.error(`Error occurred: ${error.stack}`);
+                }
+            }
+
+            let items = createdCounter + errorCounter
+
+            console.log("");
+            console.log("########################################################")
+            console.log("")
+            logger.info(' Subjects Data Migration Completed');
+            logger.info(`Total successful Subjects records created: ${createdCounter}/${createdCounter}`);
+            logger.info(`Total Subjects Error 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}`);
+            logger.error(`Error occurred: ${error.stack}`);
+            
+        }
+    },
+
+    async Schedule(){
+        try {
+            console.log("");
+            console.log("########################################################")
+            console.log("                       Schedules Migration ")
+            console.log("########################################################")
+            console.log("");
+    
+            const scheduleApi = await api.Schedule()
+            const userMail = await Users.findOne({ where: { email: 'ccci_integrator@gmail.com' } });    
+                    
+            let createdCounter = 0
+            let errorCounter = 0
+            let uniqueErrors = new Set()
+    
+
+            const db_schema = schema
+// let maxIds = await Campuses.max('_id'); = await Schedules.max('_id'); // Fetch maximum _id directly from the Schedules model
+            // let maxId = maxIds|| 0;
+            // await db.sequelize.query(`ALTER SEQUENCE ${db_schema}."Schedules__id_seq" RESTART WITH ${maxId + 1}`);
+
+            for (let i = 0; i < scheduleApi.length; i++){
+                try {
+                    let _schedule = scheduleApi[i]
+
+                    const timeRegex = /(\d{1,2}:\d{2} [APMapm]{2}) - (\d{1,2}:\d{2} [APMapm]{2})/
+                    const matchTime = _schedule.schedule.match(timeRegex)
+
+                    if (!matchTime) {
+                        // console.error(`Invalid schedule format, check the record:${_schedule.schedule}`);
+                        continue;
+                    }
+
+                    const [_, startTime, endTime] = matchTime;
+                    const stFormat = moment(startTime, 'h:mm A').format('HH:mm:ss')
+                    const etFormat = moment(endTime, 'h:mm A').format('HH:mm:ss')
+
+
+                    let dayHandler = _schedule.schedule.split(' ')
+
+                    const dayMappings = {
+                        'M': 'Monday',
+                        'T': 'Tuesday',
+                        'W': 'Wednesday',
+                        'Th': 'Thursday',
+                        'F': 'Friday',
+                        'S': 'Saturday',
+                        'Su': 'Sunday'
+                    };
+
+                    let modifiedById = userMail._id
+                    let createdById = userMail._id
+
+
+                    let from = null
+                    let to = null
+                    let days = null
+
+                    if (dayHandler.length > 1) {
+                        days = dayHandler[0].split('').map(day => dayMappings[day]).join(', ');
+                    } else {
+                        days = dayMappings[dayHandler[0]];
+                    }
+
+
+                    let [record, created] = await Schedules.findOrCreate({
+                        where:{
+                            name: _schedule?.schedule,
+                            from : stFormat??from,
+                            to : etFormat??to,
+                            days
+                        },
+                        defaults:{
+                            modifiedById,
+                            createdById
+                        }
+                    })
+                    if (created){
+                        logger.info(`New schedule record created ${createdCounter + 1}/${createdCounter + 1}: [${record.from} - ${record.to}] ${record.name} `)
+                        createdCounter++;
+                    }
+                    else {
+                        const errorMsg = `Record schedule already exists: [${record.from} - ${record.to}] ${record.name}`;
+
+                        if (!uniqueErrors.has(errorMsg)) {
+                            logger.error(`${errorCounter + 1}/${errorCounter + 1} ${errorMsg}`);
+                            uniqueErrors.add(errorMsg);
+                            errorCounter++;
+                        }
+                    }
+    
+                } catch (error) {
+                                logger.error(`Error occurred: ${error}`);
+            logger.error(`Error occurred: ${error.stack}`);
+                }
+            }
+
+            let items = createdCounter + errorCounter
+    
+            console.log("");
+            console.log("########################################################")
+            console.log("")
+            logger.info(' Schedule Data Migration Completed');
+            logger.info(`Total successful Schedule records created: ${createdCounter}/${createdCounter}`);
+            logger.info(`Total Schedule Error 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}`);
+            logger.error(`Error occurred: ${error.stack}`);
+        }
+    },
+
+    async Student(){
+        try {
+            console.log("");
+            console.log("########################################################")
+            console.log("                       Students Migration ")
+            console.log("########################################################")
+            console.log("");
+
+            const studentApi = await api.Student()
+
+            const campusSeq = await Campuses.findAll()
+            const courseSeq = await Courses.findAll()
+            const collegeSeq = await Colleges.findAll()
+            const semesterSeq = await Semesters.findAll()
+            const acadYearSeq = await AcademicYears.findAll()
+
+            const userMail = await Users.findOne({ where: { email: 'ccci_integrator@gmail.com' } });            
+
+            let createdCounter = 0
+            let errorCounter = 0
+            let uniqueErrors = new Set()
+
+            const emailDomain = 'default.msc.edu.ph';
+
+
+            const db_schema = schema
+// let maxIds = await Campuses.max('_id'); = await Students.max('_id'); // Fetch maximum _id directly from the Students model
+            // let maxId = maxIds|| 0;
+            // await db.sequelize.query(`ALTER SEQUENCE ${db_schema}."Students__id_seq" RESTART WITH ${maxId + 1}`);
+
+            const {data} = studentApi
+            for (let i = 0; i < data.length; i++){
+                try {
+                    
+                    let _student = data[i]
+
+
+                    let _campus = campusSeq.find(a => a.name === _student?.campus)
+                    let _course = courseSeq.find(b => b.name === _student?.course)
+                    let _college = collegeSeq.find(c => c.name === _student?.college)
+                    
+                    const getLastName = _student?.last_name.toLowerCase().replace(/\s/g, '') ?? "";
+
+                    let email = `${_student?.student_number}_${getLastName}@${emailDomain}`;
+
+                    let modifiedById = userMail._id
+                    let createdById = userMail._id
+
+                    let campusDefault = 999999
+                    let courseDefault = 999999
+                    let collegeDefault = 999999
+
+
+                    let fromPrompts = await Picked()
+                    
+
+                    // let semester = "2nd Semester"
+                    let semester = fromPrompts.semester
+                    let yearsFrom = fromPrompts.yearFrom
+                    let yearsTo = fromPrompts.yearTo
+
+                    let _semester = semesterSeq.find(sem => sem.code === semester)
+                    let _acadYear = acadYearSeq.find(yr => yr.from === parseInt(yearsFrom) && yr.to === parseInt(yearsTo))
+
+                    // return
+                    let [record, created] = await Students.findOrCreate({
+                        where:{
+                            studentNumber: _student?.student_number,
+                            firstName: _student?.first_name,
+                            lastName: _student?.last_name,
+                            middleName: _student?.middle_name,
+                        },
+                        defaults:{
+                            email: email,
+                            courseId: _course?._id??courseDefault,
+                            campusId: _campus?._id??campusDefault,
+                            collegeId: _college?._id??collegeDefault,
+                            admittedYearId: _acadYear?._id ?? null,
+                            admittedSemId: _semester?._id ?? null,
+                            modifiedById,
+                            createdById
+                        }
+                    })
+                    if (created){
+                        logger.info(`New student record created ${createdCounter + 1}/${createdCounter + 1}: [${record.studentNumber}] ${record.lastName}, ${record.firstName} ${record.middleName}  `)
+                        createdCounter++;
+                    }
+                    else {
+
+                        const errorMsg = `Record student already exists: [${record.studentNumber}] ${record.lastName}, ${record.firstName} ${record.middleName}`;
+
+                        if (!uniqueErrors.has(errorMsg)) {
+                            logger.error(`${errorCounter + 1}/${errorCounter + 1} ${errorMsg}`);
+                            uniqueErrors.add(errorMsg);
+                            errorCounter++;
+                        }
+
+                    }
+                    
+                } catch (error) {
+                                logger.error(`Error occurred: ${error}`);
+            logger.error(`Error occurred: ${error.stack}`);
+                }
+            }
+
+            let items = createdCounter + errorCounter
+
+            console.log("");
+            console.log("########################################################")
+            console.log("")
+            logger.info(' Student Data Migration Completed');
+            logger.info(`Total successful Student records created: ${createdCounter}/${createdCounter}`);
+            logger.info(`Total Student Error Records: ${errorCounter}/${errorCounter}`);
+            logger.info(`Total 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}`);
+            logger.error(`Error occurred: ${error.stack}`);
+            
+        }
+    },
+
+    async Section() {
+        try {
+            console.log("");
+            console.log("########################################################");
+            console.log("                       Sections Migration ");
+            console.log("########################################################");
+            console.log("");
+    
+            const student = (await api.Student()).data;
+    
+            const subjectApi = await api.Subject();
+            const instructorApi = await api.Instructor()
+            
+            const subjectSeq = await Subjects.findAll();
+            const instructorSeq = await Instructors.findAll()
+            const courseSeq = await Courses.findAll()
+            const campusSeq = await Campuses.findAll()
+            const semesterSeq = await Semesters.findAll()
+            const acadYearSeq = await AcademicYears.findAll()
+            const acadDeptSeq = await AcademicDepartments.findAll()
+
+
+            const userMail = await Users.findOne({ where: { email: 'ccci_integrator@gmail.com' } });
+    
+            let createdCounter = 0
+            let errorCounter = 0
+            let uniqueErrors = new Set()
+    
+
+            const db_schema = schema
+// let maxIds = await Campuses.max('_id'); = await Sections.max('_id'); // Fetch maximum _id directly from the Sections model
+            // let maxId = maxIds|| 0;
+            // await db.sequelize.query(`ALTER SEQUENCE ${db_schema}."Sections__id_seq" RESTART WITH ${maxId + 1}`);
+
+
+            for (let i = 0; i < student.length; i++) {
+                try {
+
+                    let _sec = student[i]
+
+                    let _course = courseSeq.find(crs => crs.name === _sec?.course)
+                    let _campus = campusSeq.find(cam => cam.name === _sec?.campus)
+                    let _section = student[i].subjects_enrolled;
+
+    
+                    for (let j = 0; j < _section.length; j++) {
+                        let sections = _section[j].section_name
+                        let subjects = _section[j].subject_code;
+                        let instructors = _section[j].faculty_id
+    
+                        let _subject = subjectApi.find(sub => sub.code === subjects);
+
+                        let _instructor = instructorApi.find( ins => ins.faculty_id === instructors)
+
+                        let _subjects = subjectSeq.find( subs => subs.code === _subject?.code)
+
+                        let _instructors = instructorSeq.find(inst => inst.employeeNumber === _instructor?.faculty_id)
+
+                        let _insdepartment = acadDeptSeq.find(idep => idep.name === _instructor?.department_name)
+
+
+                        if (!_subject) {
+                            // console.error(`Subject with code ${subjects} not found.`);
+                            continue;
+                        }
+
+                        if (!_instructor) {
+                            // console.error(`Instructor with faculty_id ${instructors} not found.`);
+                            continue;
+                        }
+
+                        let code = sections ?? 'CODE'
+                        code = code.split(/\s+/).map((word) => word.charAt(0).toUpperCase()).join('')
+
+                    let fromPrompts = await Picked()
+                    let semester = fromPrompts.semester
+                    let yearsFrom = fromPrompts.yearFrom
+                    let yearsTo = fromPrompts.yearTo
+                    let _semester = semesterSeq.find(sem => sem.code === semester)
+                    let _acadYear = acadYearSeq.find(yr => yr.from === parseInt(yearsFrom) && yr.to === parseInt(yearsTo))
+
+                        let modifiedById = userMail._id;
+                        let createdById = userMail._id;
+
+                        let defaultSub = 99999
+                        let defaultInst = 99999
+
+                        let classType = 'SYNCHRONOUS'
+
+                        let [record, created] = await Sections.findOrCreate({
+                            where: {
+                                name: sections,
+                                code,
+                                subjectId: _subjects?._id??defaultSub??null,
+                                instructorId: _instructors?._id??defaultInst??null,
+                                classType,
+                                semesterId: _semester?._id??null,
+                                academicYearId: _acadYear?._id??null,
+                                courseId: _course?._id??null,
+                                campusId: _campus?._id??null,
+                                departmentId: _insdepartment?._id??null,
+                                modifiedById,
+                                createdById,
+
+                            },
+                            defaults: {
+                                // classType,
+                                // semesterId: _semester?._id??null,
+                                // academicYearId: _acadYear?._id??null,
+                                // courseId: _course?._id??null,
+                                // campusId: _campus?._id??null,
+                                // modifiedById,
+                                // createdById,
+                                
+                            }
+                        });
+    
+                        if (created) {
+                            logger.info(`New section record created ${createdCounter + 1}/${createdCounter + 1}: ${record.name} `);
+                            createdCounter++;
+                        } else {
+
+                            const errorMsg = `Record section already exists: ${record.name} `;
+
+                            if (!uniqueErrors.has(errorMsg)) {
+                                logger.error(`${errorCounter + 1}/${errorCounter + 1} ${errorMsg}`);
+                                uniqueErrors.add(errorMsg);
+                                errorCounter++;
+                            }
+                        }
+                    }
+                } catch (error) {
+                                logger.error(`Error occurred: ${error}`);
+            logger.error(`Error occurred: ${error.stack}`);
+                }
+            }
+
+            let items = createdCounter + errorCounter
+    
+            console.log("");
+            console.log("########################################################");
+            console.log("");
+            logger.info(' Section Data Migration Completed');
+            logger.info(`Total successful Section records created: ${createdCounter}/${createdCounter}`);
+            logger.info(`Total Section Error 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}`);
+            logger.error(`Error occurred: ${error.stack}`);
+        }
+    },
+    
+
+    async EnrolledStudent(){
+        try {
+            console.log("");
+            console.log("########################################################")
+            console.log("                       Enrolled Students Migration ")
+            console.log("########################################################")
+            console.log("");
+
+            const studentApi = (await api.Student()).data
+            const instructorApi = await api.Instructor()
+
+            const studentSeq = await Students.findAll()
+            const courseSeq = await Courses.findAll()
+            const campusSeq = await Campuses.findAll()
+            const acadYearSeq = await AcademicYears.findAll()
+            const semesterSeq = await Semesters.findAll()
+            const sectionSeq = await Sections.findAll()
+            const instructorSeq = await Instructors.findAll()
+
+            const userMail = await Users.findOne({ where: { email: 'ccci_integrator@gmail.com' } });            
+
+            let createdCounter = 0
+            let errorCounter = 0
+            let uniqueErrors = new Set()
+
+
+            const db_schema = schema
+// let maxIds = await Campuses.max('_id'); = await EnrolledStudents.max('_id'); // Fetch maximum _id directly from the EnrolledStudents model
+            // let maxId = maxIds|| 0;
+            // await db.sequelize.query(`ALTER SEQUENCE ${db_schema}."EnrolledStudents__id_seq" RESTART WITH ${maxId + 1}`);
+
+
+            for (let i = 0; i < studentApi.length; i++){
+                try {
+
+                    let _student = studentApi[i]
+
+                    let student = studentSeq.find(st => st.studentNumber === _student?.student_number)
+
+                    let campus = campusSeq.find(ca => ca.name === _student?.campus)
+                    let course = courseSeq.find(cr => cr.name === _student?.course)
+
+                    let _students = studentApi[i].subjects_enrolled
+
+                    let fromPrompts = await Picked()
+                    
+                    let semester = fromPrompts.semester
+                    let yearsFrom = fromPrompts.yearFrom
+                    let yearsTo = fromPrompts.yearTo
+                    let _semester = semesterSeq.find(sem => sem.code === semester)
+                    let _acadYear = acadYearSeq.find(yr => yr.from === parseInt(yearsFrom) && yr.to === parseInt(yearsTo))
+
+
+                    let modifiedById = userMail._id;
+                    let createdById = userMail._id;
+
+                    for (let j = 0; j < _students.length; j++){
+
+                        let instrcutor = _students[j].faculty_id
+                        let sections = _students[j].section_name
+                        let fGrade = _students[j].final_grade
+                        let rmarks = _students[j].remarks
+
+
+                        let _inst = instructorApi.find(i => i.faculty_id === instrcutor)
+
+
+                        let _instructor = instructorSeq.find(ins => ins.employeeNumber === _inst?.faculty_id)
+
+                        let _section = sectionSeq.find(sec => sec.name === sections)
+
+
+                        if (!_inst) {
+                            continue;
+                        }
+
+                        if (!_student) {
+                            continue;
+                        }
+
+                        if (!student) {
+                            continue;
+                        }
+
+
+                        let totalPoints = 100
+                        let finalG = fGrade
+                        let gradePoints = ((-4.0 / totalPoints) * parseFloat (finalG) + 5.0).toFixed(2)
+                        let graded = false
+                        if (gradePoints){
+                            graded = true
+                        }
+                        else if (!gradePoints){
+                            gradePoints = 0
+                        }
+                        let remarks = rmarks?.toUpperCase()??null
+
+                        // return
+                        let [record, created] = await EnrolledStudents.findOrCreate({
+                            where:{
+                                studentId: student?._id,
+                                courseId: course?._id,
+                                instructorId: _instructor?._id??null,
+                                sectionId: _section?._id??null,
+                                campusId: campus?._id,
+                                academicYearId: _acadYear?._id,
+                                semesterId: _semester?._id,
+                                finalGrade: gradePoints,
+                                graded,
+                                remarks,
+                                createdById,
+                                modifiedById,
+                            },
+                            default:{
+
+                            }
+                        })
+
+                        if (created) {
+                            logger.info(`New enrolled student record created ${createdCounter + 1}/${createdCounter + 1}: studentId = [${record.studentId}], sectionId = [${record.sectionId}], instructorId = [${record.instructorId}]`);
+                            createdCounter++;
+                        } else {
+
+                            const errorMsg = `Record enrolled student already exists: studentId = [${record.studentId}], sectionId = [${record.sectionId}], instructorId = [${record.instructorId}]`;
+
+                            if (!uniqueErrors.has(errorMsg)) {
+                                logger.error(`${errorCounter + 1}/${errorCounter + 1} ${errorMsg}`);
+                                uniqueErrors.add(errorMsg);
+                                errorCounter++;
+                            }
+                        }
+                    }   
+                } catch (error) {
+                                logger.error(`Error occurred: ${error}`);
+            logger.error(`Error occurred: ${error.stack}`);
+                }
+            }
+
+            let items = createdCounter + errorCounter
+
+            console.log("");
+            console.log("########################################################")
+            console.log("")
+            logger.info(' Enrolled Student Data Migration Completed');
+            logger.info(`Total successful Enrolled Student records created: ${createdCounter}/${createdCounter}`);
+            logger.info(`Total Enrolled Student Error 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}`);
+            logger.error(`Error occurred: ${error.stack}`);
+            
+        }
+    },
+}
+
+async function runServerFunctions() {
+    const results = {};
+    try {
+      for (const funcKey in server) {
+          if(typeof server[funcKey] === 'function'){
+            const funcName = server[funcKey].name; 
+            results[funcName] = await server[funcKey](); 
+          }
+      }
+    } catch (error) {
+      logger.error(`Error occurred: ${error.stack || error}`);
+    }
+    console.log("");
+    console.log("########################################################");
+    console.log("                       TOTAL SUMMARY");
+    console.log("########################################################");
+
+    Object.entries(results).map(async ([key, value]) =>{
+      console.log("");
+      console.log(`${key.toUpperCase()}:`);
+      logger.info(`total Success ${key} Record: ${value?.success??""}/${value?.itemLength??""}`);
+      logger.info(`total Error ${key} Record: ${value?.error??""}/${value?.itemLength??""}`);
+      console.log("");
+    });
+
+    console.log("########################################################");
+    console.log("                       END OF MIGRATION");
+    console.log("########################################################");
+  }
+
+
+
+
+// module.exports = server
+
+module.exports = {
+    serverTable: server,
+    Campus: server.Campus,
+    College: server.College,
+    AcademicDepartments: server.AcademicDepartment,
+    Course: server.Course,
+    Room: server.Room,
+    Instructor: server.Instructor,
+    AcademicYear: server.AcademicYear,
+    Subject: server.Subject,
+    Schedule: server.Schedule,
+    Student: server.Student,
+    Section: server.Section,
+    EnrolledStudent: server.EnrolledStudent,
+    Server: runServerFunctions,
+}