lms-sync 1.0.15 → 1.0.17

package/apiConnections/mapping.js

@@ -32,8 +32,6 @@ const server = {
             console.log("########################################################")
             console.log("");
 
-            const campusApi = await api.Campus()
-
             let userDefPayload = {
                 email: 'ccci_integrator@gmail.com',
                 password: '$2a$12$Q.h3Q9IN6vsIxGBa/EgfOOABeXTcwxt4t9cu4nqAK.nczGRRtZJUS',
@@ -48,6 +46,51 @@ const server = {
             });
 
             const userMail = await Users.findOne({ where: { email: 'ccci_integrator@gmail.com' } });      
+           
+            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',
@@ -68,14 +111,9 @@ const server = {
             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}`);
-
-            // let migratedAt = new Date() //present date of the migration
-            // let migratedTable = 'campuses' // sql counterpart main table
-            // let referenceId = campusApi.id // id of the data
-            // let isMigrated = true           
+            let maxIds = 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}`);      
 
             let uCode = new Set()
             let uName = new Set()
@@ -204,9 +242,9 @@ const server = {
             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}`);
+            let maxIds = 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}`);
 
             // let migratedAt = new Date() //present date of the migration
             // let migratedTable = 'colleges' // sql counterpart main table
@@ -347,9 +385,9 @@ const server = {
             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}`);
+            let maxIds = 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}`);
 
             let uCode = new Set()
             let uName = new Set()
@@ -549,9 +587,9 @@ const server = {
 
 
             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}`);
+            let maxIds = 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}`);
 
             let uDept = new Set()
             let uCamp = new Set()
@@ -724,9 +762,9 @@ const server = {
             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}`);
+            let maxIds = 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}`);
 
 
             let uCode = new Set()
@@ -876,9 +914,9 @@ const server = {
 
 
             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}`);
+            let maxIds = 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}`);
 
             let uName = new Set()
             let uCampus = new Set()
@@ -996,9 +1034,9 @@ const server = {
             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}`);
+            let maxIds = 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}`);
 
             let uFrom = new Set()
             let uTo = new Set()
@@ -1136,19 +1174,20 @@ const server = {
             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}`);
+            let maxIds = 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}`);
 
             let uCode = new Set()
             let uName = new Set()
             let uUnits = new Set()
             let uDept = new Set()
+            let uDescription = new Set()
 
             let newSubject = []
 
             const exSubj = await Subjects.findAll()
-            const exSubjMap = new Map(exSubj.map(subj => [`[${subj.code}] - ${subj.name} [${subj.units}, ${subj.departmentId}]`, subj]))
+            const exSubjMap = new Map(exSubj.map(subj => [`[${subj.code}] - ${subj.name} ${subj.description} [${subj.units}, ${subj.departmentId}]`, subj]))
   
             for (let i = 0; i < studentSubject.length; i++){
                 try {
@@ -1161,6 +1200,7 @@ const server = {
                     for (let j = 0; j < _subs.length; j++){
 
                         let subject = _subs[j].subject_code
+                        let _description = _subs[j]. subject_description
 
                         let _subjects = subjectApi.find(sub => sub.code === subject)
 
@@ -1178,8 +1218,9 @@ const server = {
                         let name =_subjects?.name
                         let units =_subjects?.units
                         let departmentId = _department?._id??departmentDefault?._id
+                        let description = _description
 
-                        if(uCode.has(code) && uName.has(name) && uUnits.has(units) && uDept.has(departmentId)){
+                        if(uCode.has(code) && uName.has(name) && uDescription.has(description) && uUnits.has(units) && uDept.has(departmentId)){
                             const errorMsg = `Duplicate Payload Found: [${code}] - ${name} [units: ${units}, departmentId: ${departmentId}]`
                           if(!uniqueErrors.has(errorMsg)){
                             logger.error(`${errorCounter + 1}/${errorCounter + 1}: ${errorMsg}`)
@@ -1187,8 +1228,8 @@ const server = {
                             errorCounter++
                           }
                         }
-                        else if ( exSubjMap.has(`[${code}] - ${name} [${units}, ${departmentId}]`)){
-                            const exSubj = exSubjMap.get(`[${code}] - ${name} [${units}, ${departmentId}]`)
+                        else if ( exSubjMap.has(`[${code}] - ${name} ${description} [${units}, ${departmentId}]`)){
+                            const exSubj = exSubjMap.get(`[${code}] - ${name} ${description} [${units}, ${departmentId}]`)
                             const errorMsg = `Existing Data Found: [${exSubj.code}] - ${exSubj.name} [units: ${exSubj.units}, departmentId: ${exSubj.departmentId}]`
                             if(!uniqueErrors.has(errorMsg)){
                               logger.error(`${errorCounter + 1}/${errorCounter + 1}: ${errorMsg}`)
@@ -1201,12 +1242,14 @@ const server = {
                             uName.add(name)
                             uUnits.add(units)
                             uDept.add(departmentId)
+                            uDescription.add(description)
                             newSubject.push({
                                 code:_subjects?.code,
                                  name:_subjects?.name,
                                  units:_subjects?.units,
                                  departmentId: _department?._id??departmentDefault?._id,
                                  subjectType,
+                                 description,
                                 modifiedById,
                                 createdById,
                                 // migratedAt,
@@ -1275,9 +1318,9 @@ const server = {
     
 
             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}`);
+            let maxIds = 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}`);
 
 
             let uName = new Set()
@@ -1428,9 +1471,9 @@ const server = {
             const acadYearSeq = await AcademicYears.findAll()
 
             const userMail = await Users.findOne({ where: { email: 'ccci_integrator@gmail.com' } });    
-            const campusDefault = await Users.findOne({ where: { name: 'Campus Default' } });     
-            const courseDefault = await Users.findOne({ where: { name: 'Course Default' } });    
-            const collegeDefault = await Users.findOne({ where: { name: 'Colleges Default' } });     
+            const campusDefault = await Campuses.findOne({ where: { name: 'Campus Default' } });     
+            const courseDefault = await Courses.findOne({ where: { name: 'Course Default' } });    
+            const collegeDefault = await Colleges.findOne({ where: { name: 'Colleges Default' } });     
 
             let createdCounter = 0
             let errorCounter = 0
@@ -1439,9 +1482,9 @@ const server = {
             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}`);
+            let maxIds = 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}`);
 
 
             let uNum = new Set()
@@ -1491,7 +1534,7 @@ const server = {
                     let campusId = _campus?._id??campusDefault?._id
 
                     if(uNum.has(studentNumber) && uLname.has(lastName) && uFname.has(firstName) && uMname.has(middleName) && uCourse.has(courseId) && uCampus.has(campusId)){
-                        const errorMsg = `Duplicate Payload Found: [${studentNumber}] - ${lastName}, ${firstName} ${middleName} [${courseId}, ${campusId}]`
+                        const errorMsg = `Duplicate Payload Found: [${studentNumber}] - ${lastName}, ${firstName} ${middleName} [courseId: ${courseId}, campusId:${campusId}]`
                       if(!uniqueErrors.has(errorMsg)){
                         logger.error(`${errorCounter + 1}/${errorCounter + 1}: ${errorMsg}`)
                         uniqueErrors.add(errorMsg)
@@ -1500,7 +1543,7 @@ const server = {
                     }
                     else if ( exStudentMap.has(`[${studentNumber}] - ${lastName}, ${firstName} ${middleName} [${courseId}, ${campusId}]`)){
                         const exStudent = exStudentMap.get(`[${studentNumber}] - ${lastName}, ${firstName} ${middleName} [${courseId}, ${campusId}]`)
-                        const errorMsg = `Existing Data Found:[${exStudent.studentNumber}] - ${exStudent.lastName}, ${exStudent.firstName} ${exStudent.middleName} [${exStudent.courseId}, ${exStudent.campusId}]`
+                        const errorMsg = `Existing Data Found:[${exStudent.studentNumber}] - ${exStudent.lastName}, ${exStudent.firstName} ${exStudent.middleName} [courseId: ${exStudent.courseId}, campusId: ${exStudent.campusId}]`
                         if(!uniqueErrors.has(errorMsg)){
                           logger.error(`${errorCounter + 1}/${errorCounter + 1}: ${errorMsg}`)
                           uniqueErrors.add(errorMsg)
@@ -1540,7 +1583,7 @@ const server = {
                 createdCounter += newStudent.length
     
                 newStudent.forEach((exStudent, index) => {
-                    logger.info(`${index + 1}/${index + 1}: New Student Record Created: [${exStudent.studentNumber}] - ${exStudent.lastName}, ${exStudent.firstName} ${exStudent.middleName} [${exStudent.courseId}, ${exStudent.campusId}]`)
+                    logger.info(`${index + 1}/${index + 1}: New Student Record Created: [${exStudent.studentNumber}] - ${exStudent.lastName}, ${exStudent.firstName} ${exStudent.middleName} [courseId: ${exStudent.courseId}, campusId: ${exStudent.campusId}]`)
                 });
             }
 
@@ -1563,7 +1606,6 @@ const server = {
                 return totalSummary
 
         } catch (error) {
-                        ;
             logger.error(`Error occurred: ${error.stack} ${error}`);
             
         }
@@ -1598,9 +1640,9 @@ const server = {
     
 
             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}`);
+            let maxIds = 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}`);
 
             let uName = new Set()
             let uCode = new Set()
@@ -1679,7 +1721,7 @@ const server = {
 
 
                         if(uCode.has(code) && uName.has(name) && uSub.has(subjectId) && uIns.has(instructorId) && uSem.has(semesterId) && uYear.has(academicYearId)&& uCrs.has(courseId)&& uDept.has(departmentId) && uCam.has(campusId)){
-                            const errorMsg = `Duplicate Payload Found: [${code}] - ${name}`
+                            const errorMsg = `Duplicate Payload Found: [${code}] - ${name} [subjectId: ${subjectId}, instructorId: ${instructorId}]`
                           if(!uniqueErrors.has(errorMsg)){
                             logger.error(`${errorCounter + 1}/${errorCounter + 1}: ${errorMsg}`)
                             uniqueErrors.add(errorMsg)
@@ -1688,7 +1730,7 @@ const server = {
                         }
                         else if ( exSectMap.has(`[${code}] - ${name} [${subjectId}, ${instructorId}, ${semesterId}, ${academicYearId}, ${courseId}, ${departmentId}, ${campusId}]`)){
                             const exSect = exSectMap.get(`[${code}] - ${name} [${subjectId}, ${instructorId}, ${semesterId}, ${academicYearId}, ${courseId}, ${departmentId}, ${campusId}]`)
-                            const errorMsg = `Existing Data Found:[${exSect.code}] - ${exSect.name}`
+                            const errorMsg = `Existing Data Found:[${exSect.code}] - ${exSect.name} [subjectId: ${exSect.subjectId}, instructorId: ${exSect.instructorId}]`
                             if(!uniqueErrors.has(errorMsg)){
                               logger.error(`${errorCounter + 1}/${errorCounter + 1}: ${errorMsg}`)
                               uniqueErrors.add(errorMsg)
@@ -1733,9 +1775,21 @@ const server = {
                 createdCounter += newSection.length
     
                 newSection.forEach((sect, index) => {
-                    logger.info(`${index + 1}/${index + 1}: New Section Record Created: [${sect.code}] - ${sect.name}`)
+                    logger.info(`${index + 1}/${index + 1}: New Section Record Created: [${sect.code}] - ${sect.name} [subjectId: ${sect.subjectId}, instructorId: ${sect.instructorId}]`)
                 });
             }
+
+
+            // let batchSize = 500
+            // for (let i = 0; i < newSection.length; i += batchSize){
+            //     const batch = newSection.slice(i, i + batchSize)
+            //     await Sections.bulkCreate(batch)
+            //     createdCounter += batch.length
+            //     batch.forEach((sect, index) => {
+            //         logger.info(`${index + 1}/${index + 1}: New Section Record Created: [${sect.code}] - ${sect.name}`)
+            //     })
+            //   }
+
     
             console.log("");
             console.log("########################################################");
@@ -1761,8 +1815,7 @@ const server = {
         }
     },
     
-
-    async EnrolledStudent(){
+    async EnrolledStudentss(){
         try {
             console.log("");
             console.log("########################################################")
@@ -1780,6 +1833,7 @@ const server = {
             const semesterSeq = await Semesters.findAll()
             const sectionSeq = await Sections.findAll()
             const instructorSeq = await Instructors.findAll()
+            const subjectSeq = await Subjects.findAll()
 
             const userMail = await Users.findOne({ where: { email: 'ccci_integrator@gmail.com' } });            
 
@@ -1787,13 +1841,11 @@ const server = {
             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}`);
+            let maxIds = 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}`);
 
-            
             let uStud = new Set()
             let uCrs = new Set() 
             let uIns = new Set()  
@@ -1802,23 +1854,20 @@ const server = {
             let uYear = new Set()  
             let uSem = new Set() 
             let uGrade = new Set() 
+            let uRemarks = new Set()
+            let uAllStat = new Set()
             
             let newEnroll = []
 
-            const exEnroll = await EnrolledStudents.findAll()
-            const exEnrollMap = new Map(exEnroll.map(student => [`[${student.studentId}] - [${student.courseId}, ${student.instructorId}, ${student.sectionId}, ${student.campusId}, ${student.academicYearId}, ${student.academicYearId}, ${student.semesterId}, ${student.finalGrade}]`, student]))
+            const existings = await EnrolledStudents.findAll()
+            const existingEnrolledMap = new Map(existings.map(enroll => [`[${enroll.studentId} ${enroll.instructorId} ${enroll.sectionId}] ${enroll.finalGrade} ${enroll.remarks} ${enroll.overAllStatus}`, enroll]))
   
-
             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()
@@ -1829,23 +1878,17 @@ const server = {
                     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)
 
 
@@ -1861,17 +1904,52 @@ const server = {
                             continue;
                         }
 
-                        let totalPoints = 100
+                        let overAllStatus = null
                         let finalG = fGrade
-                        let gradePoints = ((-4.0 / totalPoints) * parseFloat (finalG) + 5.0).toFixed(2)
+
                         let graded = false
-                        if (gradePoints){
+                        if (finalG){
                             graded = true
                         }
-                        else if (!gradePoints){
-                            gradePoints = 0
-                        }
+                        else if (!finalG){
+                            finalG = 0
+                        }                       
+                        
                         let remarks = rmarks?.toUpperCase()??null
+                        if (remarks === 'INCOMPLETE'){
+                            finalG = 0
+                            overAllStatus = "INC"
+                        }
+                        else if (remarks === 'UNOFFICIALLY DROPPED'){
+                            finalG = 0
+                            overAllStatus = "UD"
+                        }
+                        else if (remarks === 'UNAUTHORIZED WITHDRAWAL'){
+                            finalG = 0
+                            overAllStatus = "UW"
+                        }
+                        else if (remarks === 'DROPPED'){
+                            finalG = 0
+                            overAllStatus = "DRP"
+                        }
+                        else if (remarks === 'NO CREDIT'){
+                            finalG = 0
+                            overAllStatus = "IN-PROG"
+                        }
+                        else if (remarks === 'CREDITED'){
+                            finalG = 0
+                            overAllStatus = "UD"
+                        }
+                        else if (remarks === 'PASSED'){
+                            overAllStatus = "PASSED"
+                        }
+                        else if (!remarks){
+                            finalG = 0
+                        }
+                        if(finalG === 5.00){
+                            remarks = "FAILED"
+                            overAllStatus = "FAILED"
+                        }
 
                         let studentId = student?._id
                         let courseId = course?._id
@@ -1880,19 +1958,19 @@ const server = {
                         let campusId = campus?._id
                         let academicYearId = _acadYear?._id
                         let semesterId = _semester?._id
-                        let finalGrade = gradePoints
+                        let finalGrade = finalG
                         
-                        if(uStud.has(studentId) && uCrs.has(courseId) && uIns.has(instructorId) && uSec.has(sectionId) && uCam.has(campusId) && uYear.has(academicYearId) && uSem.has(semesterId) && uGrade.has(finalGrade)){
-                            const errorMsg = `Duplicate Payload Found: [${studentId}] - [${courseId}, ${instructorId}, ${sectionId}, ${campusId}, ${academicYearId}, ${academicYearId}, ${semesterId}, ${finalGrade}]`
+                        if(uStud.has(studentId) && uIns.has(instructorId) && uSec.has(sectionId) && uGrade.has(finalGrade) && uRemarks.has(remarks) && uAllStat.has(overAllStatus)){
+                            const errorMsg = `Duplicate Payload Found: [${studentId}] - [${courseId}, ${instructorId}, ${sectionId}] = ${finalGrade}, ${remarks}, ${overAllStatus}`
                           if(!uniqueErrors.has(errorMsg)){
                             logger.error(`${errorCounter + 1}/${errorCounter + 1}: ${errorMsg}`)
                             uniqueErrors.add(errorMsg)
                             errorCounter++
                           }
                         }
-                        else if ( exEnrollMap.has(`[${studentId}] - [${courseId}, ${instructorId}, ${sectionId}, ${campusId}, ${academicYearId}, ${academicYearId}, ${semesterId}, ${finalGrade}]`)){
-                            const exEnroll = exEnrollMap.get(`[${studentId}] - [${courseId}, ${instructorId}, ${sectionId}, ${campusId}, ${academicYearId}, ${academicYearId}, ${semesterId}, ${finalGrade}]`)
-                            const errorMsg = `Existing Data Found: [${exEnroll.exEnrollId}] - [${exEnroll.courseId}, ${exEnroll.instructorId}, ${exEnroll.sectionId}, ${exEnroll.campusId}, ${exEnroll.academicYearId}, ${exEnroll.academicYearId}, ${exEnroll.semesterId}, ${exEnroll.finalGrade}]`
+                        else if (existingEnrolledMap.has(`[${studentId} ${instructorId} ${sectionId} ${finalGrade}] ${remarks} ${overAllStatus}`)){
+                            const existings = existingEnrolledMap.get(`[${studentId} ${instructorId} ${sectionId} ${finalGrade}] ${remarks} ${overAllStatus}`)
+                            const errorMsg = `Existing Data Found: [${existings.studentId}] - [${existings.courseId}, ${existings.instructorId}, ${existings.sectionId}] = ${existings.finalGrade}, ${existings.remarks}, ${existings.overAllStatus}`
                             if(!uniqueErrors.has(errorMsg)){
                               logger.error(`${errorCounter + 1}/${errorCounter + 1}: ${errorMsg}`)
                               uniqueErrors.add(errorMsg)
@@ -1908,6 +1986,8 @@ const server = {
                             uYear.add(academicYearId)  
                             uSem.add(semesterId) 
                             uGrade.add(finalGrade) 
+                            uAllStat.add(overAllStatus)
+                            uRemarks.add(remarks)
                             newEnroll.push({
                                 studentId: student?._id,
                                 courseId: course?._id,
@@ -1916,8 +1996,9 @@ const server = {
                                 campusId: campus?._id,
                                 academicYearId: _acadYear?._id,
                                 semesterId: _semester?._id,
-                                finalGrade: gradePoints,
+                                finalGrade: finalG,
                                 graded,
+                                overAllStatus,
                                 remarks,
                                 createdById,
                                 modifiedById,
@@ -1925,17 +2006,16 @@ const server = {
                         }
                     }   
                 } catch (error) {
-                                ;
             logger.error(`Error occurred: ${error.stack} ${error}`);
                 }
             }
 
             if (newEnroll.length > 0) {
-                await Sections.bulkCreate(newEnroll)
+                await EnrolledStudents.bulkCreate(newEnroll)
                 createdCounter += newEnroll.length
     
                 newEnroll.forEach((es, index) => {
-                    logger.info(`${index + 1}/${index + 1}: New Section Record Created: [${es.studentId}] - [${es.courseId}, ${es.instructorId}, ${es.sectionId}, ${es.campusId}, ${es.academicYearId}, ${es.academicYearId}, ${es.semesterId}, ${es.finalGrade}]`)
+                    logger.info(`${index + 1}/${index + 1}: New Enrolled Students Record Created: [${es.studentId}] - [${es.courseId}, ${es.instructorId}, ${es.sectionId}] = ${es.finalGrade}, ${es.remarks}, ${es.overAllStatus}`)
                 });
             }
 
@@ -1958,11 +2038,208 @@ const server = {
                 return totalSummary
 
         } catch (error) {
-                        ;
             logger.error(`Error occurred: ${error.stack} ${error}`);
             
         }
     },
+    
+    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()
+
+
+            let maxIds = await EnrolledStudents.max('_id'); // Fetch maximum _id directly from the EnrolledStudents model
+            let maxId = maxIds|| 0;
+            await db.sequelize.query(`ALTER SEQUENCE public_migrations."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 overAllStatus = null
+                        let finalG = fGrade
+
+                        // let totalPoints = 100
+                        // let finalG = fGrade
+                        // let gradePoints = ((-4.0 / totalPoints) * parseFloat (finalG) + 5.0).toFixed(2)
+
+                        let graded = false
+                        if (finalG){
+                            graded = true
+                        }
+                        else if (!finalG){
+                            finalG = 0
+                        }    
+
+                        let remarks = rmarks?.toUpperCase()??null
+                        if (remarks === 'INCOMPLETE'){
+                            finalG = 0
+                            overAllStatus = "INC"
+                        }
+                        else if (remarks === 'UNOFFICIALLY DROPPED'){
+                            finalG = 0
+                            overAllStatus = "UD"
+                        }
+                        else if (remarks === 'UNAUTHORIZED WITHDRAWAL'){
+                            finalG = 0
+                            overAllStatus = "UW"
+                        }
+                        else if (remarks === 'DROPPED'){
+                            finalG = 0
+                            overAllStatus = "DRP"
+                        }
+                        else if (remarks === 'NO CREDIT'){
+                            finalG = 0
+                            overAllStatus = "IN-PROG"
+                        }
+                        else if (remarks === 'CREDITED'){
+                            finalG = 0
+                            overAllStatus = "UD"
+                        }
+                        else if (remarks === 'PASSED'){
+                            overAllStatus = "PASSED"
+                        }
+                        else if (!remarks){
+                            finalG = 0
+                        }
+                        if(finalG === 5.00){
+                            remarks = "FAILED"
+                            overAllStatus = "FAILED"
+                        }
+                        // 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: finalG,
+                                graded,
+                                remarks,
+                                overAllStatus,
+                                createdById,
+                                modifiedById,
+                            },
+                            default:{
+
+                            }
+                        })
+
+                        if (created) {
+                            logger.info(`${createdCounter + 1}/${createdCounter + 1}: New Enrolled Students Record Created: [${record.studentId}] - [${record.courseId}, ${record.instructorId}, ${record.sectionId}] = ${record.finalGrade}, ${record.remarks}, ${record.overAllStatus}`)
+                            createdCounter++;
+                        } else {
+
+                            const errorMsg = `Record enrolled student already exists: studentId = [${record.studentId}] - [${record.courseId}, ${record.instructorId}, ${record.sectionId}] = ${record.finalGrade}, ${record.remarks}, ${record.overAllStatus}`;
+
+                            if (!uniqueErrors.has(errorMsg)) {
+                                logger.error(`${errorCounter + 1}/${errorCounter + 1} ${errorMsg}`);
+                                uniqueErrors.add(errorMsg);
+                                errorCounter++;
+                            }
+                        }
+                    }   
+                } catch (error) {
+                    console.error(error);
+                }
+            }
+
+            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}`);
+            console.log("")
+            console.log("########################################################")
+            console.log("")
+
+                let totalSummary = {
+                  itemLength: studentApi.length,
+                  error: errorCounter,
+                  success: createdCounter
+                }
+                return totalSummary
+
+        } catch (error) {
+            console.error(error);
+            
+        }
+    },
+
 }
 
 async function runServerFunctions() {