lms-sync 1.0.11 → 1.0.13

package/apiConnections/mapping.js

@@ -1,7 +1,9 @@
-const db = require('../models')
+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,
@@ -37,6 +39,11 @@ const server = {
             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 {
                     
@@ -62,9 +69,9 @@ const server = {
                         createdCounter++;
                     }
                     else {
-                        const errorMsg = `Record campus already exists [${record.code}] - ${record.name} `;
+                        const errorMsg = `Record campus already exists: [${record.code}] - ${record.name} `;
                         if (!uniqueErrors.has(errorMsg)) {
-                            logger.error(`${errorCounter + 1}/${errorCounter + 1}: ${errorMsg}`);
+                            logger.error(`${errorCounter + 1}/${errorCounter + 1} ${errorMsg}`);
                             uniqueErrors.add(errorMsg);
                             errorCounter++;
                         }
@@ -117,6 +124,11 @@ const server = {
             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]
@@ -150,7 +162,7 @@ const server = {
                         const errorMsg = `Record college already exists: [${record.code}] - ${record.name} `
 
                         if (!uniqueErrors.has(errorMsg)) {
-                            logger.error(`${errorCounter + 1}/${errorCounter + 1}: ${errorMsg}`);
+                            logger.error(`${errorCounter + 1}/${errorCounter + 1} ${errorMsg}`);
                             uniqueErrors.add(errorMsg);
                             errorCounter++;
                         }
@@ -205,6 +217,10 @@ const server = {
             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]
@@ -245,10 +261,10 @@ const server = {
                         createdCounter++;
                     }
                     else {
-                        const errorMsg = `Record academic department already exists [${record.code}] - ${record.name} `
+                        const errorMsg = `Record academic department already exists: [${record.code}] - ${record.name} `
 
                         if (!uniqueErrors.has(errorMsg)) {
-                            logger.error(`${errorCounter + 1}/${errorCounter + 1}: ${errorMsg}`);
+                            logger.error(`${errorCounter + 1}/${errorCounter + 1} ${errorMsg}`);
                             uniqueErrors.add(errorMsg);
                             errorCounter++;
                         }
@@ -306,6 +322,11 @@ const server = {
             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 {
 
@@ -346,10 +367,10 @@ const server = {
                         createdCounter++                        
                     } else {
 
-                        const errorMsg = `Record course already exists [${record.code}] - ${record.name}, Major in ${record.major}`;
+                        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}`);
+                            logger.error(`${errorCounter + 1}/${errorCounter + 1} ${errorMsg}`);
                             uniqueErrors.add(errorMsg);
                             errorCounter++;
                         }
@@ -408,6 +429,13 @@ const server = {
             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]
@@ -455,10 +483,10 @@ const server = {
                         createdCounter++;
                     }
                     else {
-                        const errorMsg = `Record room already exists ${record.name}`;
+                        const errorMsg = `Record room already exists: ${record.name}`;
 
                         if (!uniqueErrors.has(errorMsg)) {
-                            logger.error(`${errorCounter + 1}/${errorCounter + 1}: ${errorMsg}`);
+                            logger.error(`${errorCounter + 1}/${errorCounter + 1} ${errorMsg}`);
                             uniqueErrors.add(errorMsg);
                             errorCounter++;
                         }
@@ -512,6 +540,13 @@ const server = {
             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]
@@ -554,10 +589,10 @@ const server = {
                         createdCounter++;
                     }
                     else {
-                        const errorMsg = `Record instructor already exists [${record.employeeNumber}] - ${record.lastName}, ${record.firstName}`;
+                        const errorMsg = `Record instructor already exists: [${record.employeeNumber}] - ${record.lastName}, ${record.firstName}`;
 
                         if (!uniqueErrors.has(errorMsg)) {
-                            logger.error(`${errorCounter + 1}/${errorCounter + 1}: ${errorMsg}`);
+                            logger.error(`${errorCounter + 1}/${errorCounter + 1} ${errorMsg}`);
                             uniqueErrors.add(errorMsg);
                             errorCounter++;
                         }
@@ -609,6 +644,13 @@ 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}`);
+
+
             for (let i = 0; i < acadYearResult.length; i++){
                 try {
                     let _acadyear = acadYearResult[i]
@@ -645,9 +687,9 @@ const server = {
                         createdCounter++;
                     }
                     else {
-                        const errorMsg = `Record academic year already exists ${record.from} - ${record.to}`;
+                        const errorMsg = `Record academic year already exists: ${record.from} - ${record.to}`;
                         if (!uniqueErrors.has(errorMsg)) {
-                            logger.error(`${errorCounter + 1}/${errorCounter + 1}: ${errorMsg}`);
+                            logger.error(`${errorCounter + 1}/${errorCounter + 1} ${errorMsg}`);
                             uniqueErrors.add(errorMsg);
                             errorCounter++;
                         }
@@ -700,6 +742,13 @@ const server = {
             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]
@@ -752,10 +801,10 @@ const server = {
                             createdCounter++;
                         }
                         else { 
-                            const errorMsg = `Record subject already exists [${record.code}], ${record.name}`;
+                            const errorMsg = `Record subject already exists: [${record.code}], ${record.name}`;
 
                             if (!uniqueErrors.has(errorMsg)) {
-                                logger.error(`${errorCounter + 1}/${errorCounter + 1}: ${errorMsg}`);
+                                logger.error(`${errorCounter + 1}/${errorCounter + 1} ${errorMsg}`);
                                 uniqueErrors.add(errorMsg);
                                 errorCounter++;
                             }
@@ -806,6 +855,12 @@ const server = {
             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]
@@ -867,10 +922,10 @@ const server = {
                         createdCounter++;
                     }
                     else {
-                        const errorMsg = `Record schedule already exists [${record.from} - ${record.to}] ${record.name}`;
+                        const errorMsg = `Record schedule already exists: [${record.from} - ${record.to}] ${record.name}`;
 
                         if (!uniqueErrors.has(errorMsg)) {
-                            logger.error(`${errorCounter + 1}/${errorCounter + 1}: ${errorMsg}`);
+                            logger.error(`${errorCounter + 1}/${errorCounter + 1} ${errorMsg}`);
                             uniqueErrors.add(errorMsg);
                             errorCounter++;
                         }
@@ -928,6 +983,11 @@ 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}`);
+
             const {data} = studentApi
             for (let i = 0; i < data.length; i++){
                 try {
@@ -950,18 +1010,19 @@ const server = {
                     let courseDefault = 999999
                     let collegeDefault = 999999
 
-                    let semester = "2nd Semester"
-                    let _semester = semesterSeq.find(sem => sem.code === semester)
-
-                    let acadFrom = 2023
-                    let acadTo = 2024
-
-
 
+                    let fromPrompts = await Picked()
+                    
 
+                    // let semester = "2nd Semester"
+                    let semester = fromPrompts.semester
+                    let yearsFrom = fromPrompts.yearFrom
+                    let yearsTo = fromPrompts.yearTo
 
-                    let _acadYear = acadYearSeq.find(yr => yr.from === acadFrom && yr.to === acadTo)
+                    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,
@@ -986,10 +1047,10 @@ const server = {
                     }
                     else {
 
-                        const errorMsg = `Record student already exists [${record.studentNumber}] ${record.lastName}, ${record.firstName} ${record.middleName}`;
+                        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}`);
+                            logger.error(`${errorCounter + 1}/${errorCounter + 1} ${errorMsg}`);
                             uniqueErrors.add(errorMsg);
                             errorCounter++;
                         }
@@ -1052,6 +1113,13 @@ const server = {
             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 {
 
@@ -1088,21 +1156,16 @@ const server = {
                             continue;
                         }
 
-
-
-                        
                         let code = sections ?? 'CODE'
                         code = code.split(/\s+/).map((word) => word.charAt(0).toUpperCase()).join('')
 
-                        let semester = "2nd Semester"
-                        let _semester = semesterSeq.find(sem => sem.code === semester)
-
-                        let acadFrom = 2023
-                        let acadTo = 2024
-
-                        let _acadYear = acadYearSeq.find(yr => yr.from === acadFrom && yr.to === acadTo)
+                    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;
 
@@ -1135,6 +1198,7 @@ const server = {
                                 // campusId: _campus?._id??null,
                                 // modifiedById,
                                 // createdById,
+                                
                             }
                         });
     
@@ -1143,10 +1207,10 @@ const server = {
                             createdCounter++;
                         } else {
 
-                            const errorMsg = `Record section already exists ${record.name} `;
+                            const errorMsg = `Record section already exists: ${record.name} `;
 
                             if (!uniqueErrors.has(errorMsg)) {
-                                logger.error(`${errorCounter + 1}/${errorCounter + 1}: ${errorMsg}`);
+                                logger.error(`${errorCounter + 1}/${errorCounter + 1} ${errorMsg}`);
                                 uniqueErrors.add(errorMsg);
                                 errorCounter++;
                             }
@@ -1205,6 +1269,13 @@ 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}`);
+
+
             for (let i = 0; i < studentApi.length; i++){
                 try {
 
@@ -1217,12 +1288,14 @@ const server = {
 
                     let _students = studentApi[i].subjects_enrolled
 
-                    let semester = "2nd Semester"
+                    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 acadFrom = 2023
-                    let acadTo = 2024
-                    let _acadYear = acadYearSeq.find(yr => yr.from === acadFrom && yr.to === acadTo)
 
                     let modifiedById = userMail._id;
                     let createdById = userMail._id;
@@ -1294,10 +1367,10 @@ const server = {
                             createdCounter++;
                         } else {
 
-                            const errorMsg = `Record enrolled student already exists studentId = [${record.studentId}], sectionId = [${record.sectionId}], instructorId = [${record.instructorId}]`;
+                            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}`);
+                                logger.error(`${errorCounter + 1}/${errorCounter + 1} ${errorMsg}`);
                                 uniqueErrors.add(errorMsg);
                                 errorCounter++;
                             }
@@ -1330,23 +1403,6 @@ const server = {
             
         }
     },
-    
-
-    async executeAll(){
-        await this.Campus()
-        await this.College()
-        await this.AcademicDepartment()
-        await this.Course()
-        await this.Room()
-        await this.Instructor()
-        await this.AcademicYear()
-        await this.Subject()
-        await this.Schedule()
-        await this.Student()
-        await this.Section()
-        await this.EnrolledStudent()
-
-    }
 }
 
 async function runServerFunctions() {
@@ -1385,7 +1441,18 @@ async function runServerFunctions() {
 // 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,
-    Enrolled: server.EnrolledStudent,
-    Section: server.Section
 }

package/apiConnections/tablePick.js

@@ -0,0 +1,80 @@
+const prompts = require('prompts')
+const mappings = require('./mapping')
+
+let picker = null;
+
+async function promptYearSem() {
+    const response = await prompts([
+        {
+            type: 'select',
+            name: 'Table',
+            message: 'Please Select Table:',
+            choices: [
+                { title: 'All Tables', value: 'AllTables' },
+                { title: 'Campus', value: 'Campus' },
+                { title: 'College', value: 'College' },
+                { title: 'AcademicDepartments', value: 'AcademicDepartments' },
+                { title: 'Course', value: 'Course' },
+                { title: 'Room', value: 'Room' },
+                { title: 'Instructor', value: 'Instructor' },
+                { title: 'AcademicYear', value: 'AcademicYear' },
+                { title: 'Subject', value: 'Subject' },
+                { title: 'Schedule', value: 'Schedule' },
+                { title: 'Student', value: 'Student' },
+                { title: 'Section', value: 'Section' },
+                { title: 'EnrolledStudent', value: 'EnrolledStudent' },
+            ],
+            initial: 0
+        }
+    ]);
+
+    picker = {
+        table: response.Table,
+    };
+}
+
+async function Tables() {
+    try {
+        while (true) {
+            if (!picker) {
+                await promptYearSem()
+            }
+
+            let pickTable = picker
+
+            if (pickTable.table === 'AllTables') {
+                await mappings.Server()
+            } else {
+                await mappings[pickTable.table]()
+            }
+
+            console.log('\nMigration completed for the selected table.')
+
+            picker = null // reset picker after completing the migration
+
+            const response = await prompts([
+                {
+                    type: 'confirm',
+                    name: 'continue',
+                    message: 'Do you want to pick another table?',
+                    choices:[  
+                            {title: 'Yes', value: 'yes'},
+                            {title: 'No', value: 'no'}
+                    ],
+                    initial: true
+                }
+            ])
+
+            if (!response.continue) {
+                break; // ex the loop if the user doesn't want to continue
+            }
+        }
+
+    } catch (error) {
+        console.error(error);
+    }
+}
+
+module.exports = {
+    Tables
+}

package/app.js

@@ -2,8 +2,8 @@
 
 const sequelizeStart = require('./apiConnections/sequelizeConnection'); 
 const apiConnects = require('./apiConnections/apiConnects')
-const mappings = require('./apiConnections/mapping');
 const picks = require('./apiConnections/semesterPick')
+const tables = require('./apiConnections/tablePick')
 
 async function start(){
     try {
@@ -25,7 +25,7 @@ async function start(){
         
         if(apis && startSequel){
             console.log('Both connections successful. Starting migrations...');
-            await mappings.Server()
+            const tablesPick = await tables.Tables()
         }
         else {
             console.error('Failed to establish database and api connections. Migrations not started.');

package/models/index.js

@@ -45,4 +45,4 @@ Object.keys(db).forEach(modelName => {
 db.sequelize = sequelize;
 db.Sequelize = Sequelize;
 
-module.exports = db;
+module.exports = {db, schema};

package/package.json

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