lms-sync 1.0.14 → 1.0.15
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/apiConnections/mapping.js +1033 -497
- package/apiConnections/mappings-old.js +1517 -0
- package/apiConnections/tablePick.js +1 -1
- package/app.js +6 -4
- package/models/campuses.model.js +16 -0
- package/package.json +1 -1
|
@@ -33,16 +33,57 @@ const server = {
|
|
|
33
33
|
console.log("");
|
|
34
34
|
|
|
35
35
|
const campusApi = await api.Campus()
|
|
36
|
-
|
|
36
|
+
|
|
37
|
+
let userDefPayload = {
|
|
38
|
+
email: 'ccci_integrator@gmail.com',
|
|
39
|
+
password: '$2a$12$Q.h3Q9IN6vsIxGBa/EgfOOABeXTcwxt4t9cu4nqAK.nczGRRtZJUS',
|
|
40
|
+
temporaryPassword: 'P@ssw0rd123',
|
|
41
|
+
firstName: 'Androi',
|
|
42
|
+
lastName: 'Pamisaran',
|
|
43
|
+
};
|
|
44
|
+
|
|
45
|
+
let [userDefault, createdUser] = await Users.findOrCreate({
|
|
46
|
+
where: { email: userDefPayload.email },
|
|
47
|
+
defaults: userDefPayload
|
|
48
|
+
});
|
|
49
|
+
|
|
50
|
+
const userMail = await Users.findOne({ where: { email: 'ccci_integrator@gmail.com' } });
|
|
51
|
+
|
|
52
|
+
let campusDefPayload = {
|
|
53
|
+
name: 'Campus Default',
|
|
54
|
+
code: 'DEF',
|
|
55
|
+
email: 'campus_default@gmail.com',
|
|
56
|
+
address: 'MSC',
|
|
57
|
+
modifiedById: userMail._id,
|
|
58
|
+
createdById: userMail._id
|
|
59
|
+
};
|
|
60
|
+
|
|
61
|
+
let [defaults, createddef] = await Campuses.findOrCreate({
|
|
62
|
+
where: { name: campusDefPayload.name, code: campusDefPayload.code},
|
|
63
|
+
defaults: campusDefPayload
|
|
64
|
+
});
|
|
37
65
|
|
|
38
66
|
let createdCounter = 0
|
|
39
67
|
let errorCounter = 0
|
|
40
68
|
let uniqueErrors = new Set()
|
|
41
69
|
|
|
42
70
|
const db_schema = schema
|
|
43
|
-
// let maxIds = await Campuses.max('_id'); = await Campuses.max('_id'); // Fetch maximum _id directly from the campuses model
|
|
71
|
+
// let maxIds = await Campuses.max('_id'); = await Campuses.max('_id'); // Fetch maximum _id directly from the campuses model
|
|
44
72
|
// let maxId = maxIds|| 0;
|
|
45
73
|
// await db.sequelize.query(`ALTER SEQUENCE ${db_schema}."Campuses__id_seq" RESTART WITH ${maxId + 1}`);
|
|
74
|
+
|
|
75
|
+
// let migratedAt = new Date() //present date of the migration
|
|
76
|
+
// let migratedTable = 'campuses' // sql counterpart main table
|
|
77
|
+
// let referenceId = campusApi.id // id of the data
|
|
78
|
+
// let isMigrated = true
|
|
79
|
+
|
|
80
|
+
let uCode = new Set()
|
|
81
|
+
let uName = new Set()
|
|
82
|
+
|
|
83
|
+
let newCampus = []
|
|
84
|
+
|
|
85
|
+
const existingCampus = await Campuses.findAll()
|
|
86
|
+
const existingCampusMap = new Map(existingCampus.map(campus => [`[${campus.code}] - ${campus.name}`, campus]))
|
|
46
87
|
|
|
47
88
|
for (let i = 0; i < campusApi.length; i++){
|
|
48
89
|
try {
|
|
@@ -52,58 +93,80 @@ const server = {
|
|
|
52
93
|
let modifiedById = userMail._id
|
|
53
94
|
let createdById = userMail._id
|
|
54
95
|
|
|
55
|
-
let
|
|
56
|
-
|
|
96
|
+
let name = _campus?.name
|
|
97
|
+
let code = _campus?.code
|
|
98
|
+
|
|
99
|
+
if(uCode.has(code) && uName.has(name)){
|
|
100
|
+
const errorMsg = `Duplicate Payload Found: [${code}] - ${name}`
|
|
101
|
+
if(!uniqueErrors.has(errorMsg)){
|
|
102
|
+
logger.error(`${errorCounter + 1}/${errorCounter + 1}: ${errorMsg}`)
|
|
103
|
+
uniqueErrors.add(errorMsg)
|
|
104
|
+
errorCounter++
|
|
105
|
+
}
|
|
106
|
+
}
|
|
107
|
+
else if ( existingCampusMap.has(`[${code}] - ${name}`)){
|
|
108
|
+
const existingCampus = existingCampusMap.get(`[${code}] - ${name}`)
|
|
109
|
+
const errorMsg = `Existing Data Found:[${existingCampus.code}] - ${existingCampus.name}`
|
|
110
|
+
if(!uniqueErrors.has(errorMsg)){
|
|
111
|
+
logger.error(`${errorCounter + 1}/${errorCounter + 1}: ${errorMsg}`)
|
|
112
|
+
uniqueErrors.add(errorMsg)
|
|
113
|
+
errorCounter++
|
|
114
|
+
}
|
|
115
|
+
}
|
|
116
|
+
else{
|
|
117
|
+
uCode.add(code)
|
|
118
|
+
uName.add(name)
|
|
119
|
+
newCampus.push({
|
|
57
120
|
name: _campus?.name,
|
|
58
|
-
code: _campus?.code
|
|
59
|
-
},
|
|
60
|
-
defaults:{
|
|
121
|
+
code: _campus?.code,
|
|
61
122
|
email: _campus?.email,
|
|
62
123
|
address: _campus?.address,
|
|
63
124
|
modifiedById,
|
|
64
|
-
createdById
|
|
65
|
-
|
|
66
|
-
|
|
67
|
-
|
|
68
|
-
|
|
69
|
-
|
|
70
|
-
}
|
|
71
|
-
else {
|
|
72
|
-
const errorMsg = `Record campus already exists: [${record.code}] - ${record.name} `;
|
|
73
|
-
if (!uniqueErrors.has(errorMsg)) {
|
|
74
|
-
logger.error(`${errorCounter + 1}/${errorCounter + 1} ${errorMsg}`);
|
|
75
|
-
uniqueErrors.add(errorMsg);
|
|
76
|
-
errorCounter++;
|
|
77
|
-
}
|
|
78
|
-
|
|
125
|
+
createdById,
|
|
126
|
+
// migratedAt,
|
|
127
|
+
// migratedTable,
|
|
128
|
+
// referenceId,
|
|
129
|
+
// isMigrated
|
|
130
|
+
})
|
|
79
131
|
}
|
|
80
132
|
|
|
81
133
|
} catch (error) {
|
|
82
|
-
|
|
83
|
-
|
|
134
|
+
;
|
|
135
|
+
logger.error(`Error occurred: ${error.stack} ${error}`);
|
|
84
136
|
}
|
|
85
137
|
}
|
|
86
138
|
|
|
139
|
+
// bulk create new campus records
|
|
140
|
+
if (newCampus.length > 0) {
|
|
141
|
+
await Campuses.bulkCreate(newCampus)
|
|
142
|
+
createdCounter += newCampus.length
|
|
143
|
+
|
|
144
|
+
newCampus.forEach((campus, index) => {
|
|
145
|
+
logger.info(`${index + 1}/${index + 1}: New Campus Record Created: [${campus.code}], ${campus.name}`)
|
|
146
|
+
});
|
|
147
|
+
}
|
|
148
|
+
|
|
87
149
|
console.log("");
|
|
88
150
|
console.log("########################################################")
|
|
89
151
|
console.log("")
|
|
90
|
-
logger.info('
|
|
152
|
+
logger.info('Campus Data Migration Completed');
|
|
91
153
|
logger.info(`Total successful Campus records created: ${createdCounter}/${createdCounter}`);
|
|
92
154
|
logger.info(`Total Campus Error Records: ${errorCounter}/${errorCounter}`);
|
|
155
|
+
logger.info(`Total records: ${createdCounter + errorCounter}`);
|
|
93
156
|
console.log("")
|
|
94
157
|
console.log("########################################################")
|
|
95
158
|
console.log("")
|
|
96
159
|
|
|
97
160
|
let totalSummary = {
|
|
98
|
-
itemLength:
|
|
161
|
+
itemLength: createdCounter + errorCounter,
|
|
99
162
|
error: errorCounter,
|
|
100
163
|
success: createdCounter
|
|
101
164
|
}
|
|
102
165
|
return totalSummary
|
|
103
166
|
|
|
104
167
|
} catch (error) {
|
|
105
|
-
|
|
106
|
-
logger.error(`Error occurred: ${error.stack
|
|
168
|
+
;
|
|
169
|
+
logger.error(`Error occurred: ${error.stack} ${error}`);
|
|
107
170
|
|
|
108
171
|
}
|
|
109
172
|
},
|
|
@@ -120,17 +183,44 @@ const server = {
|
|
|
120
183
|
const campusApi = await api.Campus()
|
|
121
184
|
|
|
122
185
|
const campusSeq = await Campuses.findAll()
|
|
123
|
-
const userMail = await Users.findOne({ where: { email: 'ccci_integrator@gmail.com' } });
|
|
186
|
+
const userMail = await Users.findOne({ where: { email: 'ccci_integrator@gmail.com' } });
|
|
187
|
+
const campusDefault = await Campuses.findOne({ where: { name: 'Campus Default' } });
|
|
188
|
+
|
|
189
|
+
let defaultPayload = {
|
|
190
|
+
name: 'Colleges Default',
|
|
191
|
+
code: 'DefCol',
|
|
192
|
+
campusId: campusDefault._id,
|
|
193
|
+
modifiedById: userMail._id,
|
|
194
|
+
createdById: userMail._id
|
|
195
|
+
};
|
|
196
|
+
|
|
197
|
+
let [defaults, createddef] = await Colleges.findOrCreate({
|
|
198
|
+
where: { name: defaultPayload.name, code: defaultPayload.code},
|
|
199
|
+
defaults: defaultPayload
|
|
200
|
+
});
|
|
124
201
|
|
|
125
202
|
let createdCounter = 0
|
|
126
203
|
let errorCounter = 0
|
|
127
204
|
let uniqueErrors = new Set()
|
|
128
205
|
|
|
129
206
|
const db_schema = schema
|
|
130
|
-
// let maxIds = await Campuses.max('_id'); = await Colleges.max('_id'); // Fetch maximum _id directly from the Colleges model
|
|
207
|
+
// let maxIds = await Campuses.max('_id'); = await Colleges.max('_id'); // Fetch maximum _id directly from the Colleges model
|
|
131
208
|
// let maxId = maxIds|| 0;
|
|
132
209
|
// await db.sequelize.query(`ALTER SEQUENCE ${db_schema}."Colleges__id_seq" RESTART WITH ${maxId + 1}`);
|
|
133
210
|
|
|
211
|
+
// let migratedAt = new Date() //present date of the migration
|
|
212
|
+
// let migratedTable = 'colleges' // sql counterpart main table
|
|
213
|
+
// let referenceId = collegeApi.id // id of the data
|
|
214
|
+
// let isMigrated = true
|
|
215
|
+
|
|
216
|
+
let uCode = new Set()
|
|
217
|
+
let uName = new Set()
|
|
218
|
+
|
|
219
|
+
let newColleges = []
|
|
220
|
+
|
|
221
|
+
const existingCollege = await Colleges.findAll()
|
|
222
|
+
const existingCollegeMap = new Map(existingCollege.map(college => [`[${college.code}] - ${college.name}`, college]))
|
|
223
|
+
|
|
134
224
|
for (let i = 0; i < collegeApi.length; i++){
|
|
135
225
|
try {
|
|
136
226
|
let _college = collegeApi[i]
|
|
@@ -138,64 +228,81 @@ const server = {
|
|
|
138
228
|
let campusMap = campusApi.find(a => a.id === _college?.campus_id)
|
|
139
229
|
|
|
140
230
|
let _campus = campusSeq.find(b => b.name === campusMap?.name)
|
|
141
|
-
|
|
142
|
-
let campusDefault = 999999
|
|
143
231
|
|
|
144
232
|
let modifiedById = userMail._id
|
|
145
233
|
let createdById = userMail._id
|
|
146
234
|
|
|
147
|
-
let
|
|
148
|
-
|
|
149
|
-
|
|
235
|
+
let name = _college?.name
|
|
236
|
+
let code = _college?.code
|
|
237
|
+
|
|
238
|
+
if(uCode.has(code) && uName.has(name)){
|
|
239
|
+
const errorMsg = `Duplicate Payload Found: [${code}] - ${name}`
|
|
240
|
+
if(!uniqueErrors.has(errorMsg)){
|
|
241
|
+
logger.error(`${errorCounter + 1}/${errorCounter + 1}: ${errorMsg}`)
|
|
242
|
+
uniqueErrors.add(errorMsg)
|
|
243
|
+
errorCounter++
|
|
244
|
+
}
|
|
245
|
+
}
|
|
246
|
+
else if ( existingCollegeMap.has(`[${code}] - ${name}`)){
|
|
247
|
+
const existingCollege = existingCollegeMap.get(`[${code}] - ${name}`)
|
|
248
|
+
const errorMsg = `Existing Data Found:[${existingCollege.code}] - ${existingCollege.name}`
|
|
249
|
+
if(!uniqueErrors.has(errorMsg)){
|
|
250
|
+
logger.error(`${errorCounter + 1}/${errorCounter + 1}: ${errorMsg}`)
|
|
251
|
+
uniqueErrors.add(errorMsg)
|
|
252
|
+
errorCounter++
|
|
253
|
+
}
|
|
254
|
+
}
|
|
255
|
+
else{
|
|
256
|
+
uCode.add(code)
|
|
257
|
+
uName.add(name)
|
|
258
|
+
newColleges.push({
|
|
150
259
|
name: _college?.name,
|
|
151
|
-
code: _college?.code
|
|
152
|
-
|
|
153
|
-
defaults:{
|
|
154
|
-
campusId: _campus?._id??campusDefault,
|
|
260
|
+
code: _college?.code,
|
|
261
|
+
campusId: _campus?._id??campusDefault?._id,
|
|
155
262
|
modifiedById,
|
|
156
263
|
createdById
|
|
157
|
-
}
|
|
158
|
-
})
|
|
159
|
-
if (created){
|
|
160
|
-
logger.info(`New college record created ${createdCounter + 1}/${createdCounter + 1}: [${record.code}] - ${record.name} `)
|
|
161
|
-
createdCounter++;
|
|
162
|
-
}
|
|
163
|
-
else {
|
|
164
|
-
const errorMsg = `Record college already exists: [${record.code}] - ${record.name} `
|
|
165
|
-
|
|
166
|
-
if (!uniqueErrors.has(errorMsg)) {
|
|
167
|
-
logger.error(`${errorCounter + 1}/${errorCounter + 1} ${errorMsg}`);
|
|
168
|
-
uniqueErrors.add(errorMsg);
|
|
169
|
-
errorCounter++;
|
|
170
|
-
}
|
|
264
|
+
})
|
|
171
265
|
}
|
|
172
266
|
|
|
173
267
|
} catch (error) {
|
|
174
|
-
|
|
175
|
-
logger.error(`Error occurred: ${error.stack
|
|
268
|
+
;
|
|
269
|
+
logger.error(`Error occurred: ${error.stack} ${error}`);
|
|
176
270
|
}
|
|
177
271
|
}
|
|
178
272
|
|
|
273
|
+
// bulk create new campus records
|
|
274
|
+
if (newColleges.length > 0) {
|
|
275
|
+
await Colleges.bulkCreate(newColleges)
|
|
276
|
+
createdCounter += newColleges.length
|
|
277
|
+
|
|
278
|
+
newColleges.forEach((colleges, index) => {
|
|
279
|
+
logger.info(`${index + 1}/${index + 1}: New Colleges Record Created: [${colleges.code}], ${colleges.name}`)
|
|
280
|
+
});
|
|
281
|
+
}
|
|
282
|
+
|
|
283
|
+
let itemLength = createdCounter + errorCounter;
|
|
284
|
+
|
|
179
285
|
console.log("");
|
|
180
286
|
console.log("########################################################")
|
|
181
287
|
console.log("")
|
|
182
|
-
logger.info('
|
|
288
|
+
logger.info('College Data Migration Completed');
|
|
183
289
|
logger.info(`Total successful College records created: ${createdCounter}/${createdCounter}`);
|
|
184
290
|
logger.info(`Total College Error Records: ${errorCounter}/${errorCounter}`);
|
|
291
|
+
logger.info(`Total records: ${itemLength}`)
|
|
185
292
|
console.log("")
|
|
186
293
|
console.log("########################################################")
|
|
187
294
|
console.log("")
|
|
188
295
|
|
|
189
296
|
let totalSummary = {
|
|
190
|
-
itemLength:
|
|
297
|
+
itemLength: itemLength,
|
|
191
298
|
error: errorCounter,
|
|
192
299
|
success: createdCounter
|
|
193
300
|
}
|
|
194
301
|
return totalSummary
|
|
195
302
|
|
|
196
303
|
} catch (error) {
|
|
197
|
-
|
|
198
|
-
logger.error(`Error occurred: ${error.stack
|
|
304
|
+
;
|
|
305
|
+
logger.error(`Error occurred: ${error.stack} ${error}`);
|
|
199
306
|
|
|
200
307
|
}
|
|
201
308
|
},
|
|
@@ -211,11 +318,29 @@ const server = {
|
|
|
211
318
|
const departmentApi = await api.Department()
|
|
212
319
|
const campusApi = await api.Campus()
|
|
213
320
|
const collegeApi = await api.College()
|
|
214
|
-
|
|
321
|
+
const instructorApi = await api.Instructor()
|
|
215
322
|
|
|
216
323
|
const campusSeq = await Campuses.findAll()
|
|
217
324
|
const collegeSeq = await Colleges.findAll()
|
|
218
|
-
const
|
|
325
|
+
const departmentSeq = await AcademicDepartments.findAll()
|
|
326
|
+
const userMail = await Users.findOne({ where: { email: 'ccci_integrator@gmail.com' } });
|
|
327
|
+
const campusDefault = await Campuses.findOne({ where: { name: 'Campus Default' } });
|
|
328
|
+
const collegeDefault = await Colleges.findOne({ where: { name: 'Colleges Default' } });
|
|
329
|
+
|
|
330
|
+
let defaultPayload = {
|
|
331
|
+
name: 'AcademicDepartments Default',
|
|
332
|
+
code: 'AcadDeptDef',
|
|
333
|
+
campusId: campusDefault._id,
|
|
334
|
+
collegeId: collegeDefault._id,
|
|
335
|
+
chairPersonId: 99999,
|
|
336
|
+
modifiedById: userMail._id,
|
|
337
|
+
createdById: userMail._id
|
|
338
|
+
};
|
|
339
|
+
|
|
340
|
+
let [defaults, createddef] = await AcademicDepartments.findOrCreate({
|
|
341
|
+
where: { name: defaultPayload.name, code: defaultPayload.code},
|
|
342
|
+
defaults: defaultPayload
|
|
343
|
+
});
|
|
219
344
|
|
|
220
345
|
let createdCounter = 0
|
|
221
346
|
let errorCounter = 0
|
|
@@ -225,326 +350,525 @@ const server = {
|
|
|
225
350
|
// let maxIds = await Campuses.max('_id'); = await AcademicDepartments.max('_id'); // Fetch maximum _id directly from the AcademicDepartments model
|
|
226
351
|
// let maxId = maxIds|| 0;
|
|
227
352
|
// await db.sequelize.query(`ALTER SEQUENCE ${db_schema}."AcademicDepartments__id_seq" RESTART WITH ${maxId + 1}`);
|
|
353
|
+
|
|
354
|
+
let uCode = new Set()
|
|
355
|
+
let uName = new Set()
|
|
356
|
+
let newAcadDept = []
|
|
357
|
+
const exAcadDept = await AcademicDepartments.findAll()
|
|
358
|
+
const exAcadDeptMap = new Map(exAcadDept.map(dept => [`[${dept.code}] - ${dept.name}`, dept]))
|
|
359
|
+
|
|
360
|
+
let uCodeTwo = new Set()
|
|
361
|
+
let uNameTwo = new Set()
|
|
362
|
+
let newAcadDeptTwo = []
|
|
363
|
+
const exAcadDeptTwo = await AcademicDepartments.findAll()
|
|
364
|
+
const exAcadDeptMapTwo = new Map(exAcadDeptTwo.map(dept => [`[${dept.code}] - ${dept.name}`, dept]))
|
|
365
|
+
|
|
228
366
|
for (let i = 0; i < departmentApi.length; i++){
|
|
229
367
|
try {
|
|
230
368
|
let _acadDept = departmentApi[i]
|
|
231
|
-
|
|
232
|
-
|
|
233
369
|
let _college = collegeSeq.find( col => col.code === _acadDept?.code)
|
|
234
|
-
|
|
235
370
|
let college = collegeApi.find( cols => cols.code === _acadDept?.code)
|
|
236
|
-
|
|
237
371
|
let _campus = campusApi.find(cam => cam.id === college?.campus_id)
|
|
238
|
-
|
|
239
372
|
let campus = campusSeq.find(camp => camp.code === _campus?.code)
|
|
240
|
-
|
|
241
|
-
let
|
|
242
|
-
let
|
|
243
|
-
let
|
|
373
|
+
let chairPersonDefault = 0
|
|
374
|
+
let modifiedById = userMail._id
|
|
375
|
+
let createdById = userMail._id
|
|
376
|
+
let name = _acadDept?.name
|
|
377
|
+
let code = _acadDept?.code
|
|
378
|
+
|
|
379
|
+
if(uCode.has(code) && uName.has(name)){
|
|
380
|
+
const errorMsg = `Duplicate Payload Found: [${code}] - ${name}`
|
|
381
|
+
if(!uniqueErrors.has(errorMsg)){
|
|
382
|
+
logger.error(`${errorCounter + 1}/${errorCounter + 1}: ${errorMsg}`)
|
|
383
|
+
uniqueErrors.add(errorMsg)
|
|
384
|
+
errorCounter++
|
|
385
|
+
}
|
|
386
|
+
}
|
|
387
|
+
else if ( exAcadDeptMap.has(`[${code}] - ${name}`)){
|
|
388
|
+
const exAcadDept = exAcadDeptMap.get(`[${code}] - ${name}`)
|
|
389
|
+
const errorMsg = `Existing Data Found:[${exAcadDept.code}] - ${exAcadDept.name}`
|
|
390
|
+
if(!uniqueErrors.has(errorMsg)){
|
|
391
|
+
logger.error(`${errorCounter + 1}/${errorCounter + 1}: ${errorMsg}`)
|
|
392
|
+
uniqueErrors.add(errorMsg)
|
|
393
|
+
errorCounter++
|
|
394
|
+
}
|
|
395
|
+
}
|
|
396
|
+
else{
|
|
397
|
+
uCode.add(code)
|
|
398
|
+
uName.add(name)
|
|
399
|
+
newAcadDept.push({
|
|
400
|
+
name: _acadDept?.name,
|
|
401
|
+
code: _acadDept?.code,
|
|
402
|
+
collegeId: _college?._id??collegeDefault?._id,
|
|
403
|
+
campusId: campus?._id??campusDefault?._id,
|
|
404
|
+
modifiedById,
|
|
405
|
+
createdById
|
|
406
|
+
})
|
|
407
|
+
}
|
|
408
|
+
} catch (error) {
|
|
409
|
+
logger.error(`Error occurred: ${error.stack} ${error}`);
|
|
410
|
+
}
|
|
411
|
+
}
|
|
412
|
+
if (newAcadDept.length > 0) {
|
|
413
|
+
await AcademicDepartments.bulkCreate(newAcadDept)
|
|
414
|
+
createdCounter += newAcadDept.length
|
|
415
|
+
|
|
416
|
+
newAcadDept.forEach((dept, index) => {
|
|
417
|
+
logger.info(`${index + 1}/${index + 1}: New Academic Department Record Created: [${dept.code}], ${dept.name}`)
|
|
418
|
+
});
|
|
419
|
+
}
|
|
244
420
|
|
|
421
|
+
|
|
422
|
+
//additional departments from instructors api
|
|
423
|
+
for (let j = 0; j < instructorApi.length; j++) {
|
|
424
|
+
try {
|
|
425
|
+
let instructor = instructorApi[j];
|
|
245
426
|
let modifiedById = userMail._id
|
|
246
427
|
let createdById = userMail._id
|
|
247
428
|
|
|
429
|
+
let acadDepartmentMap = departmentApi.find(a => a.name === instructor?.department_name)
|
|
248
430
|
|
|
249
|
-
let
|
|
431
|
+
let _acadDepartment = departmentSeq.find(b => b.name === acadDepartmentMap?.name)
|
|
250
432
|
|
|
251
|
-
|
|
252
|
-
|
|
253
|
-
|
|
254
|
-
|
|
255
|
-
|
|
256
|
-
|
|
257
|
-
|
|
258
|
-
|
|
259
|
-
|
|
260
|
-
|
|
433
|
+
let campusMap = campusSeq.find(c => c._id === _acadDepartment?.campusId)
|
|
434
|
+
|
|
435
|
+
let campusDefault = "MSC - Boac Campus"
|
|
436
|
+
let _campusDefault = campusSeq.find(ccc => ccc.name === campusDefault)
|
|
437
|
+
|
|
438
|
+
let code = instructor?.department_name ?? 'CODE'
|
|
439
|
+
code = code.split(/\s+/).map((word) => word.charAt(0).toUpperCase()).join('')
|
|
440
|
+
|
|
441
|
+
let name = instructor?.department_name
|
|
442
|
+
|
|
443
|
+
if(uCodeTwo.has(code) && uNameTwo.has(name)){
|
|
444
|
+
const errorMsg = `Duplicate Payload Found: [${code}] - ${name}`
|
|
445
|
+
if(!uniqueErrors.has(errorMsg)){
|
|
446
|
+
logger.error(`${errorCounter + 1}/${errorCounter + 1}: ${errorMsg}`)
|
|
447
|
+
uniqueErrors.add(errorMsg)
|
|
448
|
+
errorCounter++
|
|
449
|
+
}
|
|
450
|
+
}
|
|
451
|
+
else if ( exAcadDeptMapTwo.has(`[${code}] - ${name}`)){
|
|
452
|
+
const exAcadDeptTwo = exAcadDeptMapTwo.get(`[${code}] - ${name}`)
|
|
453
|
+
const errorMsg = `Existing Data Found:[${exAcadDeptTwo.code}] - ${exAcadDeptTwo.name}`
|
|
454
|
+
if(!uniqueErrors.has(errorMsg)){
|
|
455
|
+
logger.error(`${errorCounter + 1}/${errorCounter + 1}: ${errorMsg}`)
|
|
456
|
+
uniqueErrors.add(errorMsg)
|
|
457
|
+
errorCounter++
|
|
261
458
|
}
|
|
262
|
-
})
|
|
263
|
-
if (created){
|
|
264
|
-
logger.info(`New academic department record created ${createdCounter + 1}/${createdCounter + 1}: [${record.code}] - ${record.name} `)
|
|
265
|
-
createdCounter++;
|
|
266
459
|
}
|
|
267
|
-
else
|
|
268
|
-
|
|
460
|
+
else{
|
|
461
|
+
uCodeTwo.add(code)
|
|
462
|
+
uNameTwo.add(name)
|
|
463
|
+
newAcadDeptTwo.push({
|
|
464
|
+
name: instructor?.department_name,
|
|
465
|
+
code: code,
|
|
466
|
+
modifiedById,
|
|
467
|
+
createdById,
|
|
468
|
+
campusId: campusMap?._id??_campusDefault?._id,
|
|
469
|
+
collegeId: collegeDefault?._id,
|
|
470
|
+
|
|
471
|
+
})
|
|
472
|
+
}
|
|
269
473
|
|
|
270
|
-
if (!uniqueErrors.has(errorMsg)) {
|
|
271
|
-
logger.error(`${errorCounter + 1}/${errorCounter + 1} ${errorMsg}`);
|
|
272
|
-
uniqueErrors.add(errorMsg);
|
|
273
|
-
errorCounter++;
|
|
274
|
-
}
|
|
275
474
|
|
|
276
|
-
}
|
|
277
|
-
|
|
278
475
|
} catch (error) {
|
|
279
|
-
|
|
280
|
-
logger.error(`Error occurred: ${error.stack || error}`);
|
|
476
|
+
logger.error(`Error occurred: ${error} ${error.stack}`);
|
|
281
477
|
}
|
|
282
478
|
}
|
|
479
|
+
if (newAcadDeptTwo.length > 0) {
|
|
480
|
+
await AcademicDepartments.bulkCreate(newAcadDeptTwo)
|
|
481
|
+
createdCounter += newAcadDeptTwo.length
|
|
482
|
+
|
|
483
|
+
newAcadDeptTwo.forEach((deptTwo, index) => {
|
|
484
|
+
logger.info(`${index + 1}/${index + 1}: New Academic Department Record Created: [${deptTwo.code}], ${deptTwo.name}`)
|
|
485
|
+
});
|
|
486
|
+
}
|
|
283
487
|
|
|
284
488
|
console.log("");
|
|
285
489
|
console.log("########################################################")
|
|
286
490
|
console.log("")
|
|
287
|
-
logger.info('
|
|
491
|
+
logger.info('Academic Department Data Migration Completed');
|
|
288
492
|
logger.info(`Total successful Academic Department records created: ${createdCounter}/${createdCounter}`);
|
|
289
493
|
logger.info(`Total Academic Department Error Records: ${errorCounter}/${errorCounter}`);
|
|
494
|
+
logger.info(`Total records: ${createdCounter + errorCounter}`);
|
|
290
495
|
console.log("")
|
|
291
496
|
console.log("########################################################")
|
|
292
497
|
console.log("")
|
|
293
498
|
|
|
294
499
|
let totalSummary = {
|
|
295
|
-
itemLength:
|
|
500
|
+
itemLength: createdCounter + errorCounter,
|
|
296
501
|
error: errorCounter,
|
|
297
502
|
success: createdCounter
|
|
298
503
|
}
|
|
299
504
|
return totalSummary
|
|
300
505
|
|
|
301
506
|
} catch (error) {
|
|
302
|
-
logger.error(`Error occurred: ${error}`);
|
|
303
|
-
|
|
304
|
-
|
|
507
|
+
logger.error(`Error occurred: ${error} ${error.stack}`);
|
|
508
|
+
logger.error(`Error occurredsss: ${error.stack}`);
|
|
305
509
|
}
|
|
306
510
|
},
|
|
307
511
|
|
|
308
|
-
async
|
|
512
|
+
async Instructor(){
|
|
309
513
|
try {
|
|
310
514
|
console.log("");
|
|
311
515
|
console.log("########################################################")
|
|
312
|
-
console.log("
|
|
516
|
+
console.log(" Instructors Migration ")
|
|
313
517
|
console.log("########################################################")
|
|
314
518
|
console.log("");
|
|
315
519
|
|
|
316
|
-
const
|
|
317
|
-
|
|
318
|
-
const courseApi = await api.Course()
|
|
319
|
-
const collegeApi = await api.College()
|
|
520
|
+
const instructorApi = await api.Instructor()
|
|
320
521
|
const departmentApi = await api.Department()
|
|
321
|
-
|
|
322
|
-
const acadDeptSeq = await AcademicDepartments.findAll()
|
|
323
522
|
|
|
523
|
+
const departmentSeq = await AcademicDepartments.findAll()
|
|
324
524
|
const campusSeq = await Campuses.findAll()
|
|
325
|
-
const
|
|
525
|
+
const instructorSeq = await Instructors.findAll()
|
|
526
|
+
const userMail = await Users.findOne({ where: { email: 'ccci_integrator@gmail.com' } });
|
|
527
|
+
const campusDefault = await Campuses.findOne({ where: { name: 'Campus Default' } });
|
|
528
|
+
const departmentDefault = await AcademicDepartments.findOne({ where: { name: 'AcademicDepartments Default' } });
|
|
529
|
+
|
|
530
|
+
let defaultPayload = {
|
|
531
|
+
firstName: 'Instructor',
|
|
532
|
+
lastName: 'Default',
|
|
533
|
+
middleName: 'Migration',
|
|
534
|
+
employeeNumber: '_Instructor',
|
|
535
|
+
departmentId: departmentDefault?._id,
|
|
536
|
+
campusId: campusDefault?._id,
|
|
537
|
+
modifiedById: userMail._id,
|
|
538
|
+
createdById: userMail._id
|
|
539
|
+
};
|
|
540
|
+
|
|
541
|
+
let [defaults, createddef] = await Instructors.findOrCreate({
|
|
542
|
+
where: { employeeNumber: defaultPayload.employeeNumber, lastName: defaultPayload.lastName},
|
|
543
|
+
defaults: defaultPayload
|
|
544
|
+
});
|
|
326
545
|
|
|
327
546
|
let createdCounter = 0
|
|
328
547
|
let errorCounter = 0
|
|
329
548
|
let uniqueErrors = new Set()
|
|
330
549
|
|
|
550
|
+
|
|
331
551
|
const db_schema = schema
|
|
332
|
-
// let maxIds = await Campuses.max('_id'); = await
|
|
552
|
+
// let maxIds = await Campuses.max('_id'); = await Instructors.max('_id'); // Fetch maximum _id directly from the Instructors model
|
|
333
553
|
// let maxId = maxIds|| 0;
|
|
334
|
-
// await db.sequelize.query(`ALTER SEQUENCE ${db_schema}."
|
|
554
|
+
// await db.sequelize.query(`ALTER SEQUENCE ${db_schema}."Instructors__id_seq" RESTART WITH ${maxId + 1}`);
|
|
335
555
|
|
|
336
|
-
|
|
337
|
-
|
|
556
|
+
let uDept = new Set()
|
|
557
|
+
let uCamp = new Set()
|
|
558
|
+
let uLname = new Set()
|
|
559
|
+
let uMname = new Set()
|
|
560
|
+
let uFname = new Set()
|
|
561
|
+
let uNum = new Set()
|
|
338
562
|
|
|
339
|
-
|
|
340
|
-
let courseCode = courseApi.find(crs => crs.name === course?.course)
|
|
341
|
-
let campus = campusSeq.find(camp => camp.name === course?.campus)
|
|
563
|
+
let newInstructor = []
|
|
342
564
|
|
|
343
|
-
|
|
344
|
-
|
|
345
|
-
|
|
565
|
+
const exInst = await Instructors.findAll()
|
|
566
|
+
const exInstMap = new Map(exInst.map(inst => [`[${inst.employeeNumber}] - ${inst.lastName}, ${inst.firstName} ${inst.middleName} [${inst.departmentId}, ${inst.campusId}]` , inst]))
|
|
567
|
+
|
|
568
|
+
for (let i = 0; i < instructorApi.length; i++){
|
|
569
|
+
try {
|
|
570
|
+
let _instructor = instructorApi[i]
|
|
346
571
|
|
|
572
|
+
let acadDepartmentMap = departmentApi.find(a => a.name === _instructor?.department_name)
|
|
347
573
|
|
|
574
|
+
let _acadDepartment = departmentSeq.find(b => b.name === acadDepartmentMap?.name)
|
|
348
575
|
|
|
349
|
-
|
|
576
|
+
let campusMap = campusSeq.find(c => c._id === _acadDepartment?.campusId)
|
|
350
577
|
|
|
351
578
|
let modifiedById = userMail._id
|
|
352
579
|
let createdById = userMail._id
|
|
353
580
|
|
|
354
|
-
|
|
355
|
-
let
|
|
356
|
-
where:{
|
|
357
|
-
name: course?.course,
|
|
358
|
-
code: courseCode?.code,
|
|
359
|
-
major: course?.major,
|
|
360
|
-
campusId: campus?._id??null,
|
|
361
|
-
departmentId: _department?._id??null,
|
|
362
|
-
modifiedById,
|
|
363
|
-
createdById
|
|
364
|
-
},
|
|
365
|
-
defaults:{
|
|
366
|
-
|
|
367
|
-
|
|
368
|
-
}
|
|
369
|
-
})
|
|
370
|
-
|
|
371
|
-
if (created) {
|
|
372
|
-
logger.info(`New course record created ${createdCounter +1}/${createdCounter +1}: [${record.code}] - ${record.name}, Major in ${record.major}`)
|
|
373
|
-
createdCounter++
|
|
374
|
-
} else {
|
|
581
|
+
let campusDefault = "MSC - Boac Campus"
|
|
582
|
+
let _campusDefault = campusSeq.find(ccc => ccc.name === campusDefault)
|
|
375
583
|
|
|
376
|
-
|
|
584
|
+
let role = _instructor?.role
|
|
377
585
|
|
|
378
|
-
|
|
379
|
-
|
|
380
|
-
|
|
381
|
-
|
|
586
|
+
let isChairPerson = false
|
|
587
|
+
let isDean = false
|
|
588
|
+
|
|
589
|
+
if(role === "Program Chair"){
|
|
590
|
+
isChairPerson = true
|
|
591
|
+
}
|
|
592
|
+
if(role === "Dean"){
|
|
593
|
+
isDean = true
|
|
594
|
+
}
|
|
595
|
+
|
|
596
|
+
let firstName = _instructor?.first_name
|
|
597
|
+
let lastName = _instructor?.last_name
|
|
598
|
+
let middleName = _instructor?.middle_name
|
|
599
|
+
let employeeNumber = _instructor?.faculty_id
|
|
600
|
+
let departmentId = _acadDepartment?._id??departmentDefault?._id
|
|
601
|
+
let campusId = campusMap?._id??_campusDefault?._id
|
|
602
|
+
|
|
603
|
+
if(uNum.has(employeeNumber) && uLname.has(lastName) && uFname.has(firstName) && uMname.has(middleName) && uDept.has(departmentId) && uCamp.has(campusId)){
|
|
604
|
+
const errorMsg = `Duplicate Payload Found: [${employeeNumber}] - ${lastName}, ${firstName} ${middleName} [departmentId: ${departmentId}, campusId:${campusId}]`
|
|
605
|
+
if(!uniqueErrors.has(errorMsg)){
|
|
606
|
+
logger.error(`${errorCounter + 1}/${errorCounter + 1}: ${errorMsg}`)
|
|
607
|
+
uniqueErrors.add(errorMsg)
|
|
608
|
+
errorCounter++
|
|
609
|
+
}
|
|
610
|
+
}
|
|
611
|
+
else if ( exInstMap.has(`[${employeeNumber}] - ${lastName}, ${firstName} ${middleName} [${departmentId}, ${campusId}]`)){
|
|
612
|
+
const exInst = exInstMap.get(`[${employeeNumber}] - ${lastName}, ${firstName} ${middleName} [${departmentId}, ${campusId}]`)
|
|
613
|
+
const errorMsg = `Existing Data Found:[${exInst.employeeNumber}] - ${exInst.lastName}, ${exInst.firstName} ${exInst.middleName} [departmentId: ${exInst.departmentId}, campusId: ${exInst.campusId}]`
|
|
614
|
+
if(!uniqueErrors.has(errorMsg)){
|
|
615
|
+
logger.error(`${errorCounter + 1}/${errorCounter + 1}: ${errorMsg}`)
|
|
616
|
+
uniqueErrors.add(errorMsg)
|
|
617
|
+
errorCounter++
|
|
382
618
|
}
|
|
383
|
-
|
|
619
|
+
}
|
|
620
|
+
else{
|
|
621
|
+
uNum.add(employeeNumber)
|
|
622
|
+
uLname.add(lastName)
|
|
623
|
+
uFname.add(firstName)
|
|
624
|
+
uMname.add(middleName)
|
|
625
|
+
uDept.add(departmentId)
|
|
626
|
+
uCamp.add(campusId)
|
|
627
|
+
newInstructor.push({
|
|
628
|
+
firstName: _instructor?.first_name,
|
|
629
|
+
lastName: _instructor?.last_name,
|
|
630
|
+
middleName: _instructor?.middle_name,
|
|
631
|
+
employeeNumber: _instructor?.faculty_id,
|
|
632
|
+
departmentId: _acadDepartment?._id??departmentDefault?._id,
|
|
633
|
+
academicDepartmentId: _acadDepartment?._id??departmentDefault?._id,
|
|
634
|
+
campusId: campusMap?._id??_campusDefault?._id??campusDefault?._id,
|
|
635
|
+
isDean,
|
|
636
|
+
isChairPerson,
|
|
637
|
+
modifiedById,
|
|
638
|
+
createdById,
|
|
639
|
+
})
|
|
384
640
|
}
|
|
385
641
|
|
|
386
642
|
} catch (error) {
|
|
387
|
-
|
|
388
|
-
|
|
389
|
-
|
|
643
|
+
logger.error(`Error occurred: ${error} ${error.stack}`);
|
|
644
|
+
}
|
|
645
|
+
}
|
|
646
|
+
|
|
647
|
+
if (newInstructor.length > 0) {
|
|
648
|
+
|
|
649
|
+
await Instructors.bulkCreate(newInstructor)
|
|
650
|
+
createdCounter += newInstructor.length
|
|
651
|
+
|
|
652
|
+
newInstructor.forEach((inst, index) => {
|
|
653
|
+
logger.info(`${index + 1}/${index + 1}: New Instructor Record Created: [${inst.employeeNumber}] - ${inst.lastName}, ${inst.firstName} ${inst.middleName} [ departmentId: ${inst.departmentId}, campusId: ${inst.campusId}]`)
|
|
654
|
+
});
|
|
655
|
+
|
|
390
656
|
}
|
|
391
657
|
|
|
392
658
|
|
|
393
659
|
console.log("");
|
|
394
660
|
console.log("########################################################")
|
|
395
661
|
console.log("")
|
|
396
|
-
logger.info('
|
|
397
|
-
logger.info(`Total successful
|
|
398
|
-
logger.info(`Total
|
|
662
|
+
logger.info('Instructors Data Migration Completed');
|
|
663
|
+
logger.info(`Total successful Instructors records created: ${createdCounter}/${createdCounter}`);
|
|
664
|
+
logger.info(`Total Instructors Error Records: ${errorCounter}/${errorCounter}`);
|
|
665
|
+
logger.info(`Total records: ${createdCounter + errorCounter}`);
|
|
666
|
+
|
|
399
667
|
console.log("")
|
|
400
668
|
console.log("########################################################")
|
|
401
669
|
console.log("")
|
|
402
670
|
|
|
403
671
|
let totalSummary = {
|
|
404
|
-
itemLength:
|
|
672
|
+
itemLength: createdCounter + errorCounter,
|
|
405
673
|
error: errorCounter,
|
|
406
674
|
success: createdCounter
|
|
407
675
|
}
|
|
408
|
-
|
|
409
|
-
uniqueErrors.clear();
|
|
410
|
-
|
|
411
676
|
return totalSummary
|
|
412
|
-
|
|
677
|
+
|
|
413
678
|
} catch (error) {
|
|
414
|
-
|
|
415
|
-
logger.error(`Error occurred: ${error.stack
|
|
679
|
+
;
|
|
680
|
+
logger.error(`Error occurred: ${error} ${error.stack} `);
|
|
681
|
+
|
|
416
682
|
}
|
|
417
683
|
},
|
|
418
684
|
|
|
419
|
-
async
|
|
685
|
+
async Course(){
|
|
420
686
|
try {
|
|
421
687
|
console.log("");
|
|
422
688
|
console.log("########################################################")
|
|
423
|
-
console.log("
|
|
689
|
+
console.log(" Courses Migration ")
|
|
424
690
|
console.log("########################################################")
|
|
425
691
|
console.log("");
|
|
426
692
|
|
|
427
|
-
const
|
|
428
|
-
|
|
693
|
+
const studentApi = (await api.Student()).data
|
|
694
|
+
|
|
695
|
+
const courseApi = await api.Course()
|
|
696
|
+
const collegeApi = await api.College()
|
|
697
|
+
const departmentApi = await api.Department()
|
|
698
|
+
|
|
699
|
+
const acadDeptSeq = await AcademicDepartments.findAll()
|
|
429
700
|
|
|
430
|
-
const subjectSeq = await Subjects.findAll()
|
|
431
701
|
const campusSeq = await Campuses.findAll()
|
|
432
|
-
const
|
|
702
|
+
const userMail = await Users.findOne({ where: { email: 'ccci_integrator@gmail.com' } });
|
|
703
|
+
const campusDefault = await Campuses.findOne({ where: { name: 'Campus Default' } });
|
|
704
|
+
const departmentDefault = await AcademicDepartments.findOne({ where: { name: 'AcademicDepartments Default' } });
|
|
705
|
+
|
|
706
|
+
let defaultPayload = {
|
|
707
|
+
name: 'Course Default',
|
|
708
|
+
code: 'CORDEF',
|
|
709
|
+
major: 'Major Course',
|
|
710
|
+
campusId: campusDefault._id,
|
|
711
|
+
departmentId: departmentDefault._id,
|
|
712
|
+
modifiedById: userMail._id,
|
|
713
|
+
createdById: userMail._id
|
|
714
|
+
};
|
|
715
|
+
|
|
716
|
+
let [defaults, createddef] = await Courses.findOrCreate({
|
|
717
|
+
where: { name: defaultPayload.name, code: defaultPayload.code},
|
|
718
|
+
defaults: defaultPayload
|
|
719
|
+
});
|
|
433
720
|
|
|
434
|
-
const userMail = await Users.findOne({ where: { email: 'ccci_integrator@gmail.com' } });
|
|
435
721
|
|
|
436
722
|
let createdCounter = 0
|
|
437
723
|
let errorCounter = 0
|
|
438
724
|
let uniqueErrors = new Set()
|
|
439
725
|
|
|
440
|
-
|
|
441
726
|
const db_schema = schema
|
|
442
|
-
// let maxIds = await Campuses.max('_id'); = await
|
|
727
|
+
// let maxIds = await Campuses.max('_id'); = await Courses.max('_id'); // Fetch maximum _id directly from the Courses model
|
|
443
728
|
// let maxId = maxIds|| 0;
|
|
444
|
-
// await db.sequelize.query(`ALTER SEQUENCE ${db_schema}."
|
|
445
|
-
|
|
446
|
-
|
|
447
|
-
for (let i = 0; i < roomApi.length; i++){
|
|
448
|
-
try {
|
|
449
|
-
let _room = roomApi[i]
|
|
450
|
-
|
|
451
|
-
let _subject = subjectRoom.find(r => r.room_id === _room?.id)
|
|
452
|
-
// console.log('_subject :>> ', _subject);
|
|
453
|
-
|
|
454
|
-
let _subjects = subjectSeq.find(s => s.name === _subject?.name)
|
|
455
|
-
// console.log('_subjects :>> ', _subjects);
|
|
456
|
-
|
|
457
|
-
|
|
458
|
-
let _department = departmentSeq.find(dep => dep._id === _subjects?.departmentId)
|
|
459
|
-
// console.log('_department :>> ', _department);
|
|
729
|
+
// await db.sequelize.query(`ALTER SEQUENCE ${db_schema}."Courses__id_seq" RESTART WITH ${maxId + 1}`);
|
|
460
730
|
|
|
461
731
|
|
|
462
|
-
|
|
463
|
-
|
|
732
|
+
let uCode = new Set()
|
|
733
|
+
let uName = new Set()
|
|
734
|
+
let uMajor = new Set()
|
|
735
|
+
let uCampus = new Set()
|
|
736
|
+
let uDept = new Set()
|
|
464
737
|
|
|
738
|
+
let newCourse = []
|
|
465
739
|
|
|
466
|
-
|
|
740
|
+
const exCourse = await Courses.findAll()
|
|
741
|
+
const exCourseMap = new Map(exCourse.map(course => [`[${course.code}] - ${course.name}, ${course.major} [${course.campusId}, ${course.departmentId}]`, course]))
|
|
742
|
+
|
|
467
743
|
|
|
468
|
-
|
|
744
|
+
for (let i = 0; i < studentApi.length; i++){
|
|
745
|
+
try {
|
|
469
746
|
|
|
470
|
-
let
|
|
747
|
+
let course = studentApi[i]
|
|
748
|
+
let courseCode = courseApi.find(crs => crs.name === course?.course)
|
|
749
|
+
let campus = campusSeq.find(camp => camp.name === course?.campus)
|
|
471
750
|
|
|
472
|
-
|
|
751
|
+
let college = collegeApi.find(col => col.name === course?.college)
|
|
752
|
+
let department = departmentApi.find(dep => dep.name === college?.name)
|
|
753
|
+
let _department = acadDeptSeq.find(ad => ad.name === department?.name)
|
|
473
754
|
|
|
474
755
|
let modifiedById = userMail._id
|
|
475
756
|
let createdById = userMail._id
|
|
476
757
|
|
|
477
|
-
|
|
478
|
-
|
|
479
|
-
|
|
480
|
-
|
|
481
|
-
|
|
482
|
-
defaults:{
|
|
483
|
-
capacity,
|
|
484
|
-
modifiedById,
|
|
485
|
-
createdById
|
|
758
|
+
let name = course?.course
|
|
759
|
+
let code = courseCode?.code
|
|
760
|
+
let major = course?.major
|
|
761
|
+
let campusId = campus?._id??null
|
|
762
|
+
let departmentId = _department?._id??null
|
|
486
763
|
|
|
487
|
-
}
|
|
488
|
-
})
|
|
489
|
-
if (created){
|
|
490
|
-
logger.info(`New room record created ${createdCounter + 1}/${createdCounter + 1}: ${record.name} `)
|
|
491
|
-
createdCounter++;
|
|
492
|
-
}
|
|
493
|
-
else {
|
|
494
|
-
const errorMsg = `Record room already exists: ${record.name}`;
|
|
495
764
|
|
|
496
|
-
if (!uniqueErrors.has(errorMsg)) {
|
|
497
|
-
logger.error(`${errorCounter + 1}/${errorCounter + 1} ${errorMsg}`);
|
|
498
|
-
uniqueErrors.add(errorMsg);
|
|
499
|
-
errorCounter++;
|
|
500
|
-
}
|
|
501
765
|
|
|
502
|
-
|
|
766
|
+
if(uCode.has(code) && uName.has(name) && uMajor.has(major) && uCampus.has(campusId) && uDept.has(departmentId)){
|
|
767
|
+
const errorMsg = `Duplicate Payload Found: [${code}] - ${name}, ${major} [campusId: ${campusId}, academicDepartmentId: ${departmentId}]`
|
|
768
|
+
if(!uniqueErrors.has(errorMsg)){
|
|
769
|
+
logger.error(`${errorCounter + 1}/${errorCounter + 1}: ${errorMsg}`)
|
|
770
|
+
uniqueErrors.add(errorMsg)
|
|
771
|
+
errorCounter++
|
|
772
|
+
}
|
|
773
|
+
}
|
|
774
|
+
else if ( exCourseMap.has(`[${code}] - ${name}, ${major} [${campusId}, ${departmentId}]`)){
|
|
775
|
+
const exCourse = exCourseMap.get(`[${code}] - ${name}, ${major} [${campusId}, ${departmentId}]`)
|
|
776
|
+
const errorMsg = `Existing Data Found: [${exCourse.code}] - ${exCourse.name}, ${exCourse.major} [campusId: ${exCourse.campusId}, academicDepartmentId: ${exCourse.departmentId}]`
|
|
777
|
+
if(!uniqueErrors.has(errorMsg)){
|
|
778
|
+
logger.error(`${errorCounter + 1}/${errorCounter + 1}: ${errorMsg}`)
|
|
779
|
+
uniqueErrors.add(errorMsg)
|
|
780
|
+
errorCounter++
|
|
781
|
+
}
|
|
782
|
+
}
|
|
783
|
+
else{
|
|
784
|
+
uCode.add(code)
|
|
785
|
+
uName.add(name)
|
|
786
|
+
uMajor.add(major)
|
|
787
|
+
uCampus.add(campusId)
|
|
788
|
+
uDept.add(departmentId)
|
|
789
|
+
newCourse.push({
|
|
790
|
+
name: course?.course,
|
|
791
|
+
code: courseCode?.code,
|
|
792
|
+
major: course?.major,
|
|
793
|
+
campusId: campus?._id??campusDefault?._id,
|
|
794
|
+
departmentId: _department?._id??departmentDefault?._id,
|
|
795
|
+
modifiedById,
|
|
796
|
+
createdById
|
|
797
|
+
})
|
|
798
|
+
}
|
|
503
799
|
|
|
504
800
|
} catch (error) {
|
|
505
|
-
|
|
506
|
-
logger.error(`Error occurred: ${error.stack
|
|
801
|
+
;
|
|
802
|
+
logger.error(`Error occurred: ${error.stack} ${error}`);
|
|
507
803
|
}
|
|
508
804
|
}
|
|
509
805
|
|
|
806
|
+
if (newCourse.length > 0) {
|
|
807
|
+
await Courses.bulkCreate(newCourse)
|
|
808
|
+
createdCounter += newCourse.length
|
|
809
|
+
|
|
810
|
+
newCourse.forEach((course, index) => {
|
|
811
|
+
logger.info(`${index + 1}/${index + 1}: New Courses Record Created: [${course.code}] - ${course.name}, ${course.major} [courseId: ${course.campusId}, academicDepartmentId: ${course.departmentId}]`)
|
|
812
|
+
});
|
|
813
|
+
}
|
|
814
|
+
|
|
815
|
+
|
|
510
816
|
console.log("");
|
|
511
817
|
console.log("########################################################")
|
|
512
818
|
console.log("")
|
|
513
|
-
logger.info('
|
|
514
|
-
logger.info(`Total successful
|
|
515
|
-
logger.info(`Total
|
|
819
|
+
logger.info('Course Data Migration Completed');
|
|
820
|
+
logger.info(`Total successful Course records created: ${createdCounter}/${createdCounter}`);
|
|
821
|
+
logger.info(`Total Course Error Records: ${errorCounter}/${errorCounter}`);
|
|
516
822
|
console.log("")
|
|
517
823
|
console.log("########################################################")
|
|
518
824
|
console.log("")
|
|
519
825
|
|
|
520
826
|
let totalSummary = {
|
|
521
|
-
itemLength:
|
|
827
|
+
itemLength: courseApi.length,
|
|
522
828
|
error: errorCounter,
|
|
523
829
|
success: createdCounter
|
|
524
830
|
}
|
|
525
|
-
return totalSummary
|
|
526
831
|
|
|
527
|
-
|
|
528
|
-
|
|
529
|
-
|
|
832
|
+
uniqueErrors.clear();
|
|
833
|
+
|
|
834
|
+
return totalSummary
|
|
530
835
|
|
|
836
|
+
} catch (error) {
|
|
837
|
+
;
|
|
838
|
+
logger.error(`Error occurred: ${error.stack} ${error}`);
|
|
531
839
|
}
|
|
532
840
|
},
|
|
533
841
|
|
|
534
|
-
async
|
|
842
|
+
async Room(){
|
|
535
843
|
try {
|
|
536
844
|
console.log("");
|
|
537
845
|
console.log("########################################################")
|
|
538
|
-
console.log("
|
|
846
|
+
console.log(" Rooms Migration ")
|
|
539
847
|
console.log("########################################################")
|
|
540
848
|
console.log("");
|
|
541
849
|
|
|
542
|
-
const
|
|
543
|
-
const
|
|
850
|
+
const subjectRoom = await api.Subject()
|
|
851
|
+
const roomApi = await api.Room()
|
|
544
852
|
|
|
545
|
-
const
|
|
853
|
+
const subjectSeq = await Subjects.findAll()
|
|
546
854
|
const campusSeq = await Campuses.findAll()
|
|
547
|
-
const
|
|
855
|
+
const departmentSeq = await AcademicDepartments.findAll()
|
|
856
|
+
|
|
857
|
+
const userMail = await Users.findOne({ where: { email: 'ccci_integrator@gmail.com' } });
|
|
858
|
+
const campusesDefault = await Campuses.findOne({ where: { name: 'Campus Default' } });
|
|
859
|
+
|
|
860
|
+
let defaultPayload = {
|
|
861
|
+
name: 'Rooms Default',
|
|
862
|
+
campusId: campusesDefault._id,
|
|
863
|
+
capacity: 40,
|
|
864
|
+
modifiedById: userMail._id,
|
|
865
|
+
createdById: userMail._id
|
|
866
|
+
};
|
|
867
|
+
|
|
868
|
+
let [defaults, createddef] = await Rooms.findOrCreate({
|
|
869
|
+
where: { name: defaultPayload.name},
|
|
870
|
+
defaults: defaultPayload
|
|
871
|
+
});
|
|
548
872
|
|
|
549
873
|
let createdCounter = 0
|
|
550
874
|
let errorCounter = 0
|
|
@@ -552,89 +876,104 @@ const server = {
|
|
|
552
876
|
|
|
553
877
|
|
|
554
878
|
const db_schema = schema
|
|
555
|
-
// let maxIds = await Campuses.max('_id'); = await
|
|
879
|
+
// let maxIds = await Campuses.max('_id'); = await Rooms.max('_id'); // Fetch maximum _id directly from the Rooms model
|
|
556
880
|
// let maxId = maxIds|| 0;
|
|
557
|
-
// await db.sequelize.query(`ALTER SEQUENCE ${db_schema}."
|
|
558
|
-
|
|
559
|
-
|
|
560
|
-
for (let i = 0; i < instructorApi.length; i++){
|
|
561
|
-
try {
|
|
562
|
-
let _instructor = instructorApi[i]
|
|
563
|
-
|
|
564
|
-
let acadDepartmentMap = departmentApi.find(a => a.name === _instructor?.department_name)
|
|
881
|
+
// await db.sequelize.query(`ALTER SEQUENCE ${db_schema}."Rooms__id_seq" RESTART WITH ${maxId + 1}`);
|
|
565
882
|
|
|
566
|
-
|
|
883
|
+
let uName = new Set()
|
|
884
|
+
let uCampus = new Set()
|
|
567
885
|
|
|
568
|
-
|
|
886
|
+
let newRoom = []
|
|
569
887
|
|
|
570
|
-
|
|
888
|
+
const exRoom = await Rooms.findAll()
|
|
889
|
+
const exRoomMap = new Map(exRoom.map(room => [`[${room.name}] - ${room.campusId}`, room]))
|
|
890
|
+
|
|
571
891
|
|
|
572
|
-
|
|
573
|
-
|
|
574
|
-
|
|
892
|
+
for (let i = 0; i < roomApi.length; i++){
|
|
893
|
+
try {
|
|
894
|
+
let _room = roomApi[i]
|
|
895
|
+
|
|
896
|
+
let _subject = subjectRoom.find(r => r.room_id === _room?.id)
|
|
897
|
+
let _subjects = subjectSeq.find(s => s.name === _subject?.name)
|
|
898
|
+
let _department = departmentSeq.find(dep => dep._id === _subjects?.departmentId)
|
|
899
|
+
let _campus = campusSeq.find (cam => cam._id === _department?.campusId)
|
|
575
900
|
|
|
901
|
+
let capacity = 50
|
|
576
902
|
let campusDefault = "MSC - Boac Campus"
|
|
577
903
|
let _campusDefault = campusSeq.find(ccc => ccc.name === campusDefault)
|
|
578
904
|
|
|
579
|
-
|
|
580
|
-
where:{
|
|
581
|
-
firstName: _instructor?.first_name,
|
|
582
|
-
lastName: _instructor?.last_name,
|
|
583
|
-
middleName: _instructor?.middle_name,
|
|
584
|
-
employeeNumber: _instructor?.faculty_id,
|
|
585
|
-
departmentId: _acadDepartment?._id??academicDepartmentDefault,
|
|
586
|
-
campusId: campusMap?._id??_campusDefault?._id,
|
|
587
|
-
modifiedById,
|
|
588
|
-
createdById,
|
|
589
|
-
// employeeId: record?._id??null,
|
|
905
|
+
// return console.log('campusDefault :>> ', campusDefault);
|
|
590
906
|
|
|
907
|
+
let modifiedById = userMail._id
|
|
908
|
+
let createdById = userMail._id
|
|
591
909
|
|
|
592
|
-
|
|
593
|
-
|
|
910
|
+
let name = _room?.name
|
|
911
|
+
let campusId = _campus?._id??_campusDefault?._id??null
|
|
594
912
|
|
|
595
|
-
|
|
596
|
-
|
|
597
|
-
|
|
598
|
-
logger.
|
|
599
|
-
|
|
913
|
+
if(uName.has(name) && uCampus.has(campusId)){
|
|
914
|
+
const errorMsg = `Duplicate Payload Found: [${name}] - campusId: ${campusId}`
|
|
915
|
+
if(!uniqueErrors.has(errorMsg)){
|
|
916
|
+
logger.error(`${errorCounter + 1}/${errorCounter + 1}: ${errorMsg}`)
|
|
917
|
+
uniqueErrors.add(errorMsg)
|
|
918
|
+
errorCounter++
|
|
919
|
+
}
|
|
600
920
|
}
|
|
601
|
-
else {
|
|
602
|
-
const
|
|
603
|
-
|
|
604
|
-
if
|
|
605
|
-
|
|
606
|
-
|
|
607
|
-
|
|
921
|
+
else if ( exRoomMap.has(`[${name}] - ${campusId}`)){
|
|
922
|
+
const exRoom = exRoomMap.get(`[${name}] - ${campusId}`)
|
|
923
|
+
const errorMsg = `Existing Data Found:[${exRoom.name}] - campusId: ${exRoom.campusId}`
|
|
924
|
+
if(!uniqueErrors.has(errorMsg)){
|
|
925
|
+
logger.error(`${errorCounter + 1}/${errorCounter + 1}: ${errorMsg}`)
|
|
926
|
+
uniqueErrors.add(errorMsg)
|
|
927
|
+
errorCounter++
|
|
608
928
|
}
|
|
609
|
-
|
|
929
|
+
}
|
|
930
|
+
else{
|
|
931
|
+
uName.add(name)
|
|
932
|
+
uCampus.add(campusId)
|
|
933
|
+
newRoom.push({
|
|
934
|
+
name: _room?.name,
|
|
935
|
+
campusId: _campus?._id??_campusDefault?._id??campusesDefault._id,
|
|
936
|
+
capacity,
|
|
937
|
+
modifiedById,
|
|
938
|
+
createdById
|
|
939
|
+
})
|
|
610
940
|
}
|
|
611
941
|
|
|
612
942
|
} catch (error) {
|
|
613
|
-
|
|
614
|
-
logger.error(`Error occurred: ${error.stack
|
|
943
|
+
;
|
|
944
|
+
logger.error(`Error occurred: ${error.stack} ${error}`);
|
|
615
945
|
}
|
|
616
946
|
}
|
|
617
947
|
|
|
948
|
+
if (newRoom.length > 0) {
|
|
949
|
+
await Rooms.bulkCreate(newRoom)
|
|
950
|
+
createdCounter += newRoom.length
|
|
951
|
+
|
|
952
|
+
newRoom.forEach((room, index) => {
|
|
953
|
+
logger.info(`${index + 1}/${index + 1}: New Rooms Record Created: [${room.name}], campusId: ${room.campusId}`)
|
|
954
|
+
});
|
|
955
|
+
}
|
|
956
|
+
|
|
618
957
|
console.log("");
|
|
619
958
|
console.log("########################################################")
|
|
620
959
|
console.log("")
|
|
621
|
-
logger.info('
|
|
622
|
-
logger.info(`Total successful
|
|
623
|
-
logger.info(`Total
|
|
960
|
+
logger.info('Room Data Migration Completed');
|
|
961
|
+
logger.info(`Total successful Room records created: ${createdCounter}/${createdCounter}`);
|
|
962
|
+
logger.info(`Total Room Error Records: ${errorCounter}/${errorCounter}`);
|
|
963
|
+
logger.info(`Total records: ${createdCounter + errorCounter}`);
|
|
624
964
|
console.log("")
|
|
625
965
|
console.log("########################################################")
|
|
626
966
|
console.log("")
|
|
627
967
|
|
|
628
968
|
let totalSummary = {
|
|
629
|
-
itemLength:
|
|
969
|
+
itemLength: createdCounter + errorCounter,
|
|
630
970
|
error: errorCounter,
|
|
631
971
|
success: createdCounter
|
|
632
972
|
}
|
|
633
973
|
return totalSummary
|
|
634
974
|
|
|
635
975
|
} catch (error) {
|
|
636
|
-
|
|
637
|
-
logger.error(`Error occurred: ${error.stack || error}`);
|
|
976
|
+
logger.error(`Error occurred: ${error.stack} ${error}`);
|
|
638
977
|
|
|
639
978
|
}
|
|
640
979
|
},
|
|
@@ -656,12 +995,19 @@ const server = {
|
|
|
656
995
|
|
|
657
996
|
const { acadYearResult, currentSchoolYear } = acadYearApi;
|
|
658
997
|
|
|
659
|
-
|
|
660
998
|
const db_schema = schema
|
|
661
|
-
// let maxIds = await Campuses.max('_id'); = await AcademicYears.max('_id'); // Fetch maximum _id directly from the AcademicYears model
|
|
999
|
+
// let maxIds = await Campuses.max('_id'); = await AcademicYears.max('_id'); // Fetch maximum _id directly from the AcademicYears model
|
|
662
1000
|
// let maxId = maxIds|| 0;
|
|
663
1001
|
// await db.sequelize.query(`ALTER SEQUENCE ${db_schema}."AcademicYears__id_seq" RESTART WITH ${maxId + 1}`);
|
|
664
1002
|
|
|
1003
|
+
let uFrom = new Set()
|
|
1004
|
+
let uTo = new Set()
|
|
1005
|
+
|
|
1006
|
+
let newYears = []
|
|
1007
|
+
|
|
1008
|
+
const exYear = await AcademicYears.findAll()
|
|
1009
|
+
const exYearMap = new Map(exYear.map(year => [`[${year.from} - ${year.to}]`, year]))
|
|
1010
|
+
|
|
665
1011
|
|
|
666
1012
|
for (let i = 0; i < acadYearResult.length; i++){
|
|
667
1013
|
try {
|
|
@@ -683,56 +1029,72 @@ const server = {
|
|
|
683
1029
|
let modifiedById = userMail._id
|
|
684
1030
|
let createdById = userMail._id
|
|
685
1031
|
|
|
686
|
-
|
|
687
|
-
|
|
1032
|
+
|
|
1033
|
+
if(uFrom.has(from) && uTo.has(to)){
|
|
1034
|
+
const errorMsg = `Duplicate Payload Found: [${from} - ${to}]`
|
|
1035
|
+
if(!uniqueErrors.has(errorMsg)){
|
|
1036
|
+
logger.error(`${errorCounter + 1}/${errorCounter + 1}: ${errorMsg}`)
|
|
1037
|
+
uniqueErrors.add(errorMsg)
|
|
1038
|
+
errorCounter++
|
|
1039
|
+
}
|
|
1040
|
+
}
|
|
1041
|
+
else if ( exYearMap.has(`[${from} - ${to}]`)){
|
|
1042
|
+
const exYear = exYearMap.get(`[${from} - ${to}]`)
|
|
1043
|
+
const errorMsg = `Existing Data Found:[${exYear.from} - ${exYear.to}]`
|
|
1044
|
+
if(!uniqueErrors.has(errorMsg)){
|
|
1045
|
+
logger.error(`${errorCounter + 1}/${errorCounter + 1}: ${errorMsg}`)
|
|
1046
|
+
uniqueErrors.add(errorMsg)
|
|
1047
|
+
errorCounter++
|
|
1048
|
+
}
|
|
1049
|
+
}
|
|
1050
|
+
else{
|
|
1051
|
+
uFrom.add(from)
|
|
1052
|
+
uTo.add(to)
|
|
1053
|
+
newYears.push({
|
|
688
1054
|
from,
|
|
689
|
-
to
|
|
690
|
-
},
|
|
691
|
-
defaults:{
|
|
1055
|
+
to,
|
|
692
1056
|
modifiedById,
|
|
693
1057
|
createdById,
|
|
694
1058
|
default: isDefault
|
|
695
|
-
}
|
|
696
|
-
})
|
|
697
|
-
if (created){
|
|
698
|
-
logger.info(`New academic year record created ${createdCounter + 1}/${createdCounter + 1}: ${record.from} - ${record.to} `)
|
|
699
|
-
createdCounter++;
|
|
700
|
-
}
|
|
701
|
-
else {
|
|
702
|
-
const errorMsg = `Record academic year already exists: ${record.from} - ${record.to}`;
|
|
703
|
-
if (!uniqueErrors.has(errorMsg)) {
|
|
704
|
-
logger.error(`${errorCounter + 1}/${errorCounter + 1} ${errorMsg}`);
|
|
705
|
-
uniqueErrors.add(errorMsg);
|
|
706
|
-
errorCounter++;
|
|
707
|
-
}
|
|
1059
|
+
})
|
|
708
1060
|
}
|
|
709
1061
|
|
|
710
1062
|
} catch (error) {
|
|
711
|
-
|
|
712
|
-
logger.error(`Error occurred: ${error.stack
|
|
1063
|
+
;
|
|
1064
|
+
logger.error(`Error occurred: ${error.stack} ${error}`);
|
|
713
1065
|
}
|
|
714
1066
|
}
|
|
715
1067
|
|
|
1068
|
+
if (newYears.length > 0) {
|
|
1069
|
+
await AcademicYears.bulkCreate(newYears)
|
|
1070
|
+
createdCounter += newYears.length
|
|
1071
|
+
|
|
1072
|
+
newYears.forEach((year, index) => {
|
|
1073
|
+
logger.info(`${index + 1}/${index + 1}: New Academic Years Record Created: [${year.from} - ${year.to}]`)
|
|
1074
|
+
});
|
|
1075
|
+
}
|
|
1076
|
+
|
|
716
1077
|
console.log("");
|
|
717
1078
|
console.log("########################################################")
|
|
718
1079
|
console.log("")
|
|
719
|
-
logger.info('
|
|
1080
|
+
logger.info('Academic Years Data Migration Completed');
|
|
720
1081
|
logger.info(`Total successful Academic Years records created: ${createdCounter}/${createdCounter}`);
|
|
721
1082
|
logger.info(`Total Academic Years Error Records: ${errorCounter}/${errorCounter}`);
|
|
1083
|
+
logger.info(`Total records: ${createdCounter + errorCounter}`);
|
|
722
1084
|
console.log("")
|
|
723
1085
|
console.log("########################################################")
|
|
724
1086
|
console.log("")
|
|
725
1087
|
|
|
726
1088
|
let totalSummary = {
|
|
727
|
-
itemLength:
|
|
1089
|
+
itemLength: createdCounter + errorCounter,
|
|
728
1090
|
error: errorCounter,
|
|
729
1091
|
success: createdCounter
|
|
730
1092
|
}
|
|
731
1093
|
return totalSummary
|
|
732
1094
|
|
|
733
1095
|
} catch (error) {
|
|
734
|
-
|
|
735
|
-
logger.error(`Error occurred: ${error.stack
|
|
1096
|
+
;
|
|
1097
|
+
logger.error(`Error occurred: ${error.stack} ${error}`);
|
|
736
1098
|
|
|
737
1099
|
}
|
|
738
1100
|
},
|
|
@@ -750,19 +1112,44 @@ const server = {
|
|
|
750
1112
|
const subjectApi = await api.Subject()
|
|
751
1113
|
|
|
752
1114
|
const departmentSeq = await AcademicDepartments.findAll()
|
|
753
|
-
const userMail = await Users.findOne({ where: { email: 'ccci_integrator@gmail.com' } });
|
|
754
|
-
|
|
1115
|
+
const userMail = await Users.findOne({ where: { email: 'ccci_integrator@gmail.com' } });
|
|
1116
|
+
|
|
1117
|
+
const departmentDefault = await AcademicDepartments.findOne({ where: { name: 'AcademicDepartments Default' } });
|
|
1118
|
+
|
|
1119
|
+
let defaultPayload = {
|
|
1120
|
+
code:'Sub Def',
|
|
1121
|
+
name:'Subject Default',
|
|
1122
|
+
units:3,
|
|
1123
|
+
departmentId: departmentDefault?._id??null,
|
|
1124
|
+
subjectType: "LECTURE",
|
|
1125
|
+
modifiedById: userMail._id,
|
|
1126
|
+
createdById: userMail._id
|
|
1127
|
+
};
|
|
1128
|
+
|
|
1129
|
+
let [defaults, createddef] = await Subjects.findOrCreate({
|
|
1130
|
+
where: { name: defaultPayload.name, code: defaultPayload.code},
|
|
1131
|
+
defaults: defaultPayload
|
|
1132
|
+
});
|
|
1133
|
+
|
|
755
1134
|
let createdCounter = 0
|
|
756
1135
|
let errorCounter = 0
|
|
757
1136
|
let uniqueErrors = new Set()
|
|
758
1137
|
|
|
759
|
-
|
|
760
1138
|
const db_schema = schema
|
|
761
|
-
// let maxIds = await Campuses.max('_id'); = await Subjects.max('_id'); // Fetch maximum _id directly from the Subjects model
|
|
1139
|
+
// let maxIds = await Campuses.max('_id'); = await Subjects.max('_id'); // Fetch maximum _id directly from the Subjects model
|
|
762
1140
|
// let maxId = maxIds|| 0;
|
|
763
1141
|
// await db.sequelize.query(`ALTER SEQUENCE ${db_schema}."Subjects__id_seq" RESTART WITH ${maxId + 1}`);
|
|
764
1142
|
|
|
1143
|
+
let uCode = new Set()
|
|
1144
|
+
let uName = new Set()
|
|
1145
|
+
let uUnits = new Set()
|
|
1146
|
+
let uDept = new Set()
|
|
1147
|
+
|
|
1148
|
+
let newSubject = []
|
|
765
1149
|
|
|
1150
|
+
const exSubj = await Subjects.findAll()
|
|
1151
|
+
const exSubjMap = new Map(exSubj.map(subj => [`[${subj.code}] - ${subj.name} [${subj.units}, ${subj.departmentId}]`, subj]))
|
|
1152
|
+
|
|
766
1153
|
for (let i = 0; i < studentSubject.length; i++){
|
|
767
1154
|
try {
|
|
768
1155
|
let _subject = studentSubject[i]
|
|
@@ -771,71 +1158,86 @@ const server = {
|
|
|
771
1158
|
|
|
772
1159
|
let _subs = studentSubject[i].subjects_enrolled;
|
|
773
1160
|
|
|
774
|
-
|
|
775
1161
|
for (let j = 0; j < _subs.length; j++){
|
|
776
1162
|
|
|
777
1163
|
let subject = _subs[j].subject_code
|
|
778
1164
|
|
|
779
1165
|
let _subjects = subjectApi.find(sub => sub.code === subject)
|
|
780
1166
|
|
|
781
|
-
// return console.log('_subjects :>> ', _subjects);
|
|
782
|
-
|
|
783
|
-
|
|
784
1167
|
if (!subject) {
|
|
785
|
-
// console.error(`Subject with code ${subjects} not found.`);
|
|
786
1168
|
continue;
|
|
787
1169
|
}
|
|
788
1170
|
if (!_subjects) {
|
|
789
|
-
// console.error(`Subject with code ${subjects} not found.`);
|
|
790
1171
|
continue;
|
|
791
1172
|
}
|
|
792
1173
|
let subjectType = "LECTURE"
|
|
793
1174
|
let modifiedById = userMail._id
|
|
794
1175
|
let createdById = userMail._id
|
|
795
1176
|
|
|
796
|
-
|
|
797
|
-
|
|
798
|
-
let
|
|
799
|
-
|
|
1177
|
+
let code =_subjects?.code
|
|
1178
|
+
let name =_subjects?.name
|
|
1179
|
+
let units =_subjects?.units
|
|
1180
|
+
let departmentId = _department?._id??departmentDefault?._id
|
|
1181
|
+
|
|
1182
|
+
if(uCode.has(code) && uName.has(name) && uUnits.has(units) && uDept.has(departmentId)){
|
|
1183
|
+
const errorMsg = `Duplicate Payload Found: [${code}] - ${name} [units: ${units}, departmentId: ${departmentId}]`
|
|
1184
|
+
if(!uniqueErrors.has(errorMsg)){
|
|
1185
|
+
logger.error(`${errorCounter + 1}/${errorCounter + 1}: ${errorMsg}`)
|
|
1186
|
+
uniqueErrors.add(errorMsg)
|
|
1187
|
+
errorCounter++
|
|
1188
|
+
}
|
|
1189
|
+
}
|
|
1190
|
+
else if ( exSubjMap.has(`[${code}] - ${name} [${units}, ${departmentId}]`)){
|
|
1191
|
+
const exSubj = exSubjMap.get(`[${code}] - ${name} [${units}, ${departmentId}]`)
|
|
1192
|
+
const errorMsg = `Existing Data Found: [${exSubj.code}] - ${exSubj.name} [units: ${exSubj.units}, departmentId: ${exSubj.departmentId}]`
|
|
1193
|
+
if(!uniqueErrors.has(errorMsg)){
|
|
1194
|
+
logger.error(`${errorCounter + 1}/${errorCounter + 1}: ${errorMsg}`)
|
|
1195
|
+
uniqueErrors.add(errorMsg)
|
|
1196
|
+
errorCounter++
|
|
1197
|
+
}
|
|
1198
|
+
}
|
|
1199
|
+
else{
|
|
1200
|
+
uCode.add(code)
|
|
1201
|
+
uName.add(name)
|
|
1202
|
+
uUnits.add(units)
|
|
1203
|
+
uDept.add(departmentId)
|
|
1204
|
+
newSubject.push({
|
|
800
1205
|
code:_subjects?.code,
|
|
801
|
-
|
|
802
|
-
|
|
803
|
-
|
|
804
|
-
|
|
805
|
-
subjectType,
|
|
1206
|
+
name:_subjects?.name,
|
|
1207
|
+
units:_subjects?.units,
|
|
1208
|
+
departmentId: _department?._id??departmentDefault?._id,
|
|
1209
|
+
subjectType,
|
|
806
1210
|
modifiedById,
|
|
807
|
-
createdById
|
|
808
|
-
|
|
809
|
-
|
|
810
|
-
|
|
811
|
-
|
|
812
|
-
|
|
813
|
-
if (created){
|
|
814
|
-
logger.info(`New subject record created ${createdCounter + 1}/${createdCounter + 1}: [${record.code}], ${record.name} `)
|
|
815
|
-
createdCounter++;
|
|
1211
|
+
createdById,
|
|
1212
|
+
// migratedAt,
|
|
1213
|
+
// migratedTable,
|
|
1214
|
+
// referenceId,
|
|
1215
|
+
// isMigrated
|
|
1216
|
+
})
|
|
816
1217
|
}
|
|
817
|
-
else {
|
|
818
|
-
const errorMsg = `Record subject already exists: [${record.code}], ${record.name}`;
|
|
819
1218
|
|
|
820
|
-
if (!uniqueErrors.has(errorMsg)) {
|
|
821
|
-
logger.error(`${errorCounter + 1}/${errorCounter + 1} ${errorMsg}`);
|
|
822
|
-
uniqueErrors.add(errorMsg);
|
|
823
|
-
errorCounter++;
|
|
824
|
-
}
|
|
825
|
-
}
|
|
826
1219
|
}
|
|
827
1220
|
|
|
828
1221
|
|
|
829
1222
|
} catch (error) {
|
|
830
|
-
|
|
831
|
-
logger.error(`Error occurred: ${error.stack
|
|
1223
|
+
;
|
|
1224
|
+
logger.error(`Error occurred: ${error.stack} ${error}`);
|
|
832
1225
|
}
|
|
833
1226
|
}
|
|
834
1227
|
|
|
1228
|
+
if (newSubject.length > 0) {
|
|
1229
|
+
await Subjects.bulkCreate(newSubject)
|
|
1230
|
+
createdCounter += newSubject.length
|
|
1231
|
+
|
|
1232
|
+
newSubject.forEach((subj, index) => {
|
|
1233
|
+
logger.info(`${index + 1}/${index + 1}: New Subject Record Created: [${subj.code}] - ${subj.name} [units: ${subj.units}, departmentId: ${subj.departmentId}]`)
|
|
1234
|
+
});
|
|
1235
|
+
}
|
|
1236
|
+
|
|
835
1237
|
console.log("");
|
|
836
1238
|
console.log("########################################################")
|
|
837
1239
|
console.log("")
|
|
838
|
-
logger.info('
|
|
1240
|
+
logger.info('Subjects Data Migration Completed');
|
|
839
1241
|
logger.info(`Total successful Subjects records created: ${createdCounter}/${createdCounter}`);
|
|
840
1242
|
logger.info(`Total Subjects Error Records: ${errorCounter}/${errorCounter}`);
|
|
841
1243
|
console.log("")
|
|
@@ -850,8 +1252,8 @@ const server = {
|
|
|
850
1252
|
return totalSummary
|
|
851
1253
|
|
|
852
1254
|
} catch (error) {
|
|
853
|
-
|
|
854
|
-
logger.error(`Error occurred: ${error.stack
|
|
1255
|
+
;
|
|
1256
|
+
logger.error(`Error occurred: ${error.stack} ${error}`);
|
|
855
1257
|
|
|
856
1258
|
}
|
|
857
1259
|
},
|
|
@@ -873,10 +1275,22 @@ const server = {
|
|
|
873
1275
|
|
|
874
1276
|
|
|
875
1277
|
const db_schema = schema
|
|
876
|
-
// let maxIds = await Campuses.max('_id'); = await Schedules.max('_id'); // Fetch maximum _id directly from the Schedules model
|
|
1278
|
+
// let maxIds = await Campuses.max('_id'); = await Schedules.max('_id'); // Fetch maximum _id directly from the Schedules model
|
|
877
1279
|
// let maxId = maxIds|| 0;
|
|
878
1280
|
// await db.sequelize.query(`ALTER SEQUENCE ${db_schema}."Schedules__id_seq" RESTART WITH ${maxId + 1}`);
|
|
879
1281
|
|
|
1282
|
+
|
|
1283
|
+
let uName = new Set()
|
|
1284
|
+
let uFrom = new Set()
|
|
1285
|
+
let uTo = new Set()
|
|
1286
|
+
let uDays = new Set()
|
|
1287
|
+
|
|
1288
|
+
let newSchedule = []
|
|
1289
|
+
|
|
1290
|
+
const exSched = await Schedules.findAll()
|
|
1291
|
+
const exSchedMap = new Map(exSched.map(sched => [`${sched.name} - [${sched.from} - ${sched.to}, ${sched.days}]`, sched]))
|
|
1292
|
+
|
|
1293
|
+
|
|
880
1294
|
for (let i = 0; i < scheduleApi.length; i++){
|
|
881
1295
|
try {
|
|
882
1296
|
let _schedule = scheduleApi[i]
|
|
@@ -910,8 +1324,6 @@ const server = {
|
|
|
910
1324
|
let createdById = userMail._id
|
|
911
1325
|
|
|
912
1326
|
|
|
913
|
-
let from = null
|
|
914
|
-
let to = null
|
|
915
1327
|
let days = null
|
|
916
1328
|
|
|
917
1329
|
if (dayHandler.length > 1) {
|
|
@@ -920,59 +1332,82 @@ const server = {
|
|
|
920
1332
|
days = dayMappings[dayHandler[0]];
|
|
921
1333
|
}
|
|
922
1334
|
|
|
923
|
-
|
|
924
|
-
let
|
|
925
|
-
|
|
1335
|
+
let name = _schedule?.schedule
|
|
1336
|
+
let from = stFormat??from??null
|
|
1337
|
+
let to = etFormat??to??null
|
|
1338
|
+
|
|
1339
|
+
if(uName.has(name) && uFrom.has(from) && uTo.has(to) && uDays.has(days)){
|
|
1340
|
+
const errorMsg = `Duplicate Payload Found: ${name} - [${from} - ${to}, ${days}]`
|
|
1341
|
+
if(!uniqueErrors.has(errorMsg)){
|
|
1342
|
+
logger.error(`${errorCounter + 1}/${errorCounter + 1}: ${errorMsg}`)
|
|
1343
|
+
uniqueErrors.add(errorMsg)
|
|
1344
|
+
errorCounter++
|
|
1345
|
+
}
|
|
1346
|
+
}
|
|
1347
|
+
else if ( exSchedMap.has(`${name} - [${from} - ${to}, ${days}]`)){
|
|
1348
|
+
const exSched = exSchedMap.get(`${name} - [${from} - ${to}, ${days}]`)
|
|
1349
|
+
const errorMsg = `Existing Data Found: ${exSched.name} - [${exSched.from} - ${exSched.to}, ${exSched.days}]`
|
|
1350
|
+
if(!uniqueErrors.has(errorMsg)){
|
|
1351
|
+
logger.error(`${errorCounter + 1}/${errorCounter + 1}: ${errorMsg}`)
|
|
1352
|
+
uniqueErrors.add(errorMsg)
|
|
1353
|
+
errorCounter++
|
|
1354
|
+
}
|
|
1355
|
+
}
|
|
1356
|
+
else{
|
|
1357
|
+
uName.add(name)
|
|
1358
|
+
uFrom.add(from)
|
|
1359
|
+
uTo.add(to)
|
|
1360
|
+
uDays.add(days)
|
|
1361
|
+
newSchedule.push({
|
|
926
1362
|
name: _schedule?.schedule,
|
|
927
1363
|
from : stFormat??from,
|
|
928
1364
|
to : etFormat??to,
|
|
929
|
-
days
|
|
930
|
-
},
|
|
931
|
-
defaults:{
|
|
1365
|
+
days,
|
|
932
1366
|
modifiedById,
|
|
933
1367
|
createdById
|
|
934
|
-
}
|
|
935
|
-
})
|
|
936
|
-
if (created){
|
|
937
|
-
logger.info(`New schedule record created ${createdCounter + 1}/${createdCounter + 1}: [${record.from} - ${record.to}] ${record.name} `)
|
|
938
|
-
createdCounter++;
|
|
939
|
-
}
|
|
940
|
-
else {
|
|
941
|
-
const errorMsg = `Record schedule already exists: [${record.from} - ${record.to}] ${record.name}`;
|
|
942
1368
|
|
|
943
|
-
|
|
944
|
-
|
|
945
|
-
|
|
946
|
-
|
|
947
|
-
}
|
|
1369
|
+
// migratedAt,
|
|
1370
|
+
// migratedTable,
|
|
1371
|
+
// referenceId,
|
|
1372
|
+
// isMigrated
|
|
1373
|
+
})
|
|
948
1374
|
}
|
|
949
|
-
|
|
950
1375
|
} catch (error) {
|
|
951
|
-
|
|
952
|
-
logger.error(`Error occurred: ${error.stack
|
|
1376
|
+
;
|
|
1377
|
+
logger.error(`Error occurred: ${error.stack} ${error}`);
|
|
953
1378
|
}
|
|
954
1379
|
}
|
|
1380
|
+
|
|
1381
|
+
if (newSchedule.length > 0) {
|
|
1382
|
+
await Schedules.bulkCreate(newSchedule)
|
|
1383
|
+
createdCounter += newSchedule.length
|
|
1384
|
+
|
|
1385
|
+
newSchedule.forEach((exSched, index) => {
|
|
1386
|
+
logger.info(`${index + 1}/${index + 1}: New Schedule Record Created: ${exSched.name} - [${exSched.from} - ${exSched.to}, ${exSched.days}]`)
|
|
1387
|
+
});
|
|
1388
|
+
}
|
|
955
1389
|
|
|
956
1390
|
console.log("");
|
|
957
1391
|
console.log("########################################################")
|
|
958
1392
|
console.log("")
|
|
959
|
-
logger.info('
|
|
1393
|
+
logger.info('Schedule Data Migration Completed');
|
|
960
1394
|
logger.info(`Total successful Schedule records created: ${createdCounter}/${createdCounter}`);
|
|
961
1395
|
logger.info(`Total Schedule Error Records: ${errorCounter}/${errorCounter}`);
|
|
1396
|
+
logger.info(`Total records: ${createdCounter + errorCounter}`);
|
|
962
1397
|
console.log("")
|
|
963
1398
|
console.log("########################################################")
|
|
964
1399
|
console.log("")
|
|
965
1400
|
|
|
966
1401
|
let totalSummary = {
|
|
967
|
-
itemLength:
|
|
1402
|
+
itemLength: createdCounter + errorCounter,
|
|
968
1403
|
error: errorCounter,
|
|
969
1404
|
success: createdCounter
|
|
970
1405
|
}
|
|
971
1406
|
return totalSummary
|
|
972
1407
|
|
|
973
1408
|
} catch (error) {
|
|
974
|
-
|
|
975
|
-
logger.error(`Error occurred: ${error.stack
|
|
1409
|
+
;
|
|
1410
|
+
logger.error(`Error occurred: ${error.stack} ${error}`);
|
|
976
1411
|
}
|
|
977
1412
|
},
|
|
978
1413
|
|
|
@@ -992,7 +1427,10 @@ const server = {
|
|
|
992
1427
|
const semesterSeq = await Semesters.findAll()
|
|
993
1428
|
const acadYearSeq = await AcademicYears.findAll()
|
|
994
1429
|
|
|
995
|
-
const userMail = await Users.findOne({ where: { email: 'ccci_integrator@gmail.com' } });
|
|
1430
|
+
const userMail = await Users.findOne({ where: { email: 'ccci_integrator@gmail.com' } });
|
|
1431
|
+
const campusDefault = await Users.findOne({ where: { name: 'Campus Default' } });
|
|
1432
|
+
const courseDefault = await Users.findOne({ where: { name: 'Course Default' } });
|
|
1433
|
+
const collegeDefault = await Users.findOne({ where: { name: 'Colleges Default' } });
|
|
996
1434
|
|
|
997
1435
|
let createdCounter = 0
|
|
998
1436
|
let errorCounter = 0
|
|
@@ -1000,19 +1438,30 @@ const server = {
|
|
|
1000
1438
|
|
|
1001
1439
|
const emailDomain = 'default.msc.edu.ph';
|
|
1002
1440
|
|
|
1003
|
-
|
|
1004
1441
|
const db_schema = schema
|
|
1005
|
-
// let maxIds = await Campuses.max('_id'); = await Students.max('_id'); // Fetch maximum _id directly from the Students model
|
|
1442
|
+
// let maxIds = await Campuses.max('_id'); = await Students.max('_id'); // Fetch maximum _id directly from the Students model
|
|
1006
1443
|
// let maxId = maxIds|| 0;
|
|
1007
1444
|
// await db.sequelize.query(`ALTER SEQUENCE ${db_schema}."Students__id_seq" RESTART WITH ${maxId + 1}`);
|
|
1008
1445
|
|
|
1446
|
+
|
|
1447
|
+
let uNum = new Set()
|
|
1448
|
+
let uLname = new Set()
|
|
1449
|
+
let uMname = new Set()
|
|
1450
|
+
let uFname = new Set()
|
|
1451
|
+
let uCourse = new Set()
|
|
1452
|
+
let uCampus = new Set()
|
|
1453
|
+
|
|
1454
|
+
let newStudent = []
|
|
1455
|
+
|
|
1456
|
+
const exStudent = await Students.findAll()
|
|
1457
|
+
const exStudentMap = new Map(exStudent.map(student => [`[${student.studentNumber}] - ${student.lastName}, ${student.firstName} ${student.middleName} [${student.courseId}, ${student.campusId}]`, student]))
|
|
1458
|
+
|
|
1009
1459
|
const {data} = studentApi
|
|
1460
|
+
|
|
1010
1461
|
for (let i = 0; i < data.length; i++){
|
|
1011
1462
|
try {
|
|
1012
|
-
|
|
1013
1463
|
let _student = data[i]
|
|
1014
1464
|
|
|
1015
|
-
|
|
1016
1465
|
let _campus = campusSeq.find(a => a.name === _student?.campus)
|
|
1017
1466
|
let _course = courseSeq.find(b => b.name === _student?.course)
|
|
1018
1467
|
let _college = collegeSeq.find(c => c.name === _student?.college)
|
|
@@ -1024,14 +1473,8 @@ const server = {
|
|
|
1024
1473
|
let modifiedById = userMail._id
|
|
1025
1474
|
let createdById = userMail._id
|
|
1026
1475
|
|
|
1027
|
-
let campusDefault = 999999
|
|
1028
|
-
let courseDefault = 999999
|
|
1029
|
-
let collegeDefault = 999999
|
|
1030
|
-
|
|
1031
|
-
|
|
1032
1476
|
let fromPrompts = await Picked()
|
|
1033
|
-
|
|
1034
|
-
|
|
1477
|
+
|
|
1035
1478
|
// let semester = "2nd Semester"
|
|
1036
1479
|
let semester = fromPrompts.semester
|
|
1037
1480
|
let yearsFrom = fromPrompts.yearFrom
|
|
@@ -1040,67 +1483,88 @@ const server = {
|
|
|
1040
1483
|
let _semester = semesterSeq.find(sem => sem.code === semester)
|
|
1041
1484
|
let _acadYear = acadYearSeq.find(yr => yr.from === parseInt(yearsFrom) && yr.to === parseInt(yearsTo))
|
|
1042
1485
|
|
|
1043
|
-
|
|
1044
|
-
let
|
|
1045
|
-
|
|
1486
|
+
let studentNumber = _student?.student_number
|
|
1487
|
+
let firstName = _student?.first_name
|
|
1488
|
+
let lastName = _student?.last_name
|
|
1489
|
+
let middleName = _student?.middle_name
|
|
1490
|
+
let courseId = _course?._id??courseDefault?._id
|
|
1491
|
+
let campusId = _campus?._id??campusDefault?._id
|
|
1492
|
+
|
|
1493
|
+
if(uNum.has(studentNumber) && uLname.has(lastName) && uFname.has(firstName) && uMname.has(middleName) && uCourse.has(courseId) && uCampus.has(campusId)){
|
|
1494
|
+
const errorMsg = `Duplicate Payload Found: [${studentNumber}] - ${lastName}, ${firstName} ${middleName} [${courseId}, ${campusId}]`
|
|
1495
|
+
if(!uniqueErrors.has(errorMsg)){
|
|
1496
|
+
logger.error(`${errorCounter + 1}/${errorCounter + 1}: ${errorMsg}`)
|
|
1497
|
+
uniqueErrors.add(errorMsg)
|
|
1498
|
+
errorCounter++
|
|
1499
|
+
}
|
|
1500
|
+
}
|
|
1501
|
+
else if ( exStudentMap.has(`[${studentNumber}] - ${lastName}, ${firstName} ${middleName} [${courseId}, ${campusId}]`)){
|
|
1502
|
+
const exStudent = exStudentMap.get(`[${studentNumber}] - ${lastName}, ${firstName} ${middleName} [${courseId}, ${campusId}]`)
|
|
1503
|
+
const errorMsg = `Existing Data Found:[${exStudent.studentNumber}] - ${exStudent.lastName}, ${exStudent.firstName} ${exStudent.middleName} [${exStudent.courseId}, ${exStudent.campusId}]`
|
|
1504
|
+
if(!uniqueErrors.has(errorMsg)){
|
|
1505
|
+
logger.error(`${errorCounter + 1}/${errorCounter + 1}: ${errorMsg}`)
|
|
1506
|
+
uniqueErrors.add(errorMsg)
|
|
1507
|
+
errorCounter++
|
|
1508
|
+
}
|
|
1509
|
+
}
|
|
1510
|
+
else{
|
|
1511
|
+
uNum.add(studentNumber)
|
|
1512
|
+
uLname.add(lastName)
|
|
1513
|
+
uMname.add(middleName)
|
|
1514
|
+
uFname.add(firstName)
|
|
1515
|
+
uCourse.add(courseId)
|
|
1516
|
+
uCampus.add(campusId)
|
|
1517
|
+
newStudent.push({
|
|
1046
1518
|
studentNumber: _student?.student_number,
|
|
1047
1519
|
firstName: _student?.first_name,
|
|
1048
1520
|
lastName: _student?.last_name,
|
|
1049
1521
|
middleName: _student?.middle_name,
|
|
1050
|
-
},
|
|
1051
|
-
defaults:{
|
|
1052
1522
|
email: email,
|
|
1053
|
-
courseId: _course?._id??courseDefault,
|
|
1054
|
-
campusId: _campus?._id??campusDefault,
|
|
1055
|
-
collegeId: _college?._id??collegeDefault,
|
|
1523
|
+
courseId: _course?._id??courseDefault?._id,
|
|
1524
|
+
campusId: _campus?._id??campusDefault?._id,
|
|
1525
|
+
collegeId: _college?._id??collegeDefault?._id,
|
|
1056
1526
|
admittedYearId: _acadYear?._id ?? null,
|
|
1057
1527
|
admittedSemId: _semester?._id ?? null,
|
|
1058
1528
|
modifiedById,
|
|
1059
|
-
createdById
|
|
1060
|
-
}
|
|
1061
|
-
})
|
|
1062
|
-
if (created){
|
|
1063
|
-
logger.info(`New student record created ${createdCounter + 1}/${createdCounter + 1}: [${record.studentNumber}] ${record.lastName}, ${record.firstName} ${record.middleName} `)
|
|
1064
|
-
createdCounter++;
|
|
1065
|
-
}
|
|
1066
|
-
else {
|
|
1067
|
-
|
|
1068
|
-
const errorMsg = `Record student already exists: [${record.studentNumber}] ${record.lastName}, ${record.firstName} ${record.middleName}`;
|
|
1069
|
-
|
|
1070
|
-
if (!uniqueErrors.has(errorMsg)) {
|
|
1071
|
-
logger.error(`${errorCounter + 1}/${errorCounter + 1} ${errorMsg}`);
|
|
1072
|
-
uniqueErrors.add(errorMsg);
|
|
1073
|
-
errorCounter++;
|
|
1074
|
-
}
|
|
1075
|
-
|
|
1529
|
+
createdById,
|
|
1530
|
+
})
|
|
1076
1531
|
}
|
|
1077
1532
|
|
|
1078
1533
|
} catch (error) {
|
|
1079
|
-
|
|
1080
|
-
logger.error(`Error occurred: ${error.stack || error}`);
|
|
1534
|
+
logger.error(`Error occurred: ${error.stack} ${error}`);
|
|
1081
1535
|
}
|
|
1082
1536
|
}
|
|
1083
1537
|
|
|
1538
|
+
if (newStudent.length > 0) {
|
|
1539
|
+
await Students.bulkCreate(newStudent)
|
|
1540
|
+
createdCounter += newStudent.length
|
|
1541
|
+
|
|
1542
|
+
newStudent.forEach((exStudent, index) => {
|
|
1543
|
+
logger.info(`${index + 1}/${index + 1}: New Student Record Created: [${exStudent.studentNumber}] - ${exStudent.lastName}, ${exStudent.firstName} ${exStudent.middleName} [${exStudent.courseId}, ${exStudent.campusId}]`)
|
|
1544
|
+
});
|
|
1545
|
+
}
|
|
1546
|
+
|
|
1084
1547
|
console.log("");
|
|
1085
1548
|
console.log("########################################################")
|
|
1086
1549
|
console.log("")
|
|
1087
|
-
logger.info('
|
|
1550
|
+
logger.info('Student Data Migration Completed');
|
|
1088
1551
|
logger.info(`Total successful Student records created: ${createdCounter}/${createdCounter}`);
|
|
1089
1552
|
logger.info(`Total Student Error Records: ${errorCounter}/${errorCounter}`);
|
|
1553
|
+
logger.info(`Total records: ${createdCounter + errorCounter}`);
|
|
1090
1554
|
console.log("")
|
|
1091
1555
|
console.log("########################################################")
|
|
1092
1556
|
console.log("")
|
|
1093
1557
|
|
|
1094
1558
|
let totalSummary = {
|
|
1095
|
-
itemLength:
|
|
1559
|
+
itemLength: createdCounter + errorCounter,
|
|
1096
1560
|
error: errorCounter,
|
|
1097
1561
|
success: createdCounter
|
|
1098
1562
|
}
|
|
1099
1563
|
return totalSummary
|
|
1100
1564
|
|
|
1101
1565
|
} catch (error) {
|
|
1102
|
-
|
|
1103
|
-
logger.error(`Error occurred: ${error.stack
|
|
1566
|
+
;
|
|
1567
|
+
logger.error(`Error occurred: ${error.stack} ${error}`);
|
|
1104
1568
|
|
|
1105
1569
|
}
|
|
1106
1570
|
},
|
|
@@ -1126,9 +1590,8 @@ const server = {
|
|
|
1126
1590
|
const acadYearSeq = await AcademicYears.findAll()
|
|
1127
1591
|
const acadDeptSeq = await AcademicDepartments.findAll()
|
|
1128
1592
|
|
|
1129
|
-
|
|
1130
1593
|
const userMail = await Users.findOne({ where: { email: 'ccci_integrator@gmail.com' } });
|
|
1131
|
-
|
|
1594
|
+
|
|
1132
1595
|
let createdCounter = 0
|
|
1133
1596
|
let errorCounter = 0
|
|
1134
1597
|
let uniqueErrors = new Set()
|
|
@@ -1139,7 +1602,21 @@ const server = {
|
|
|
1139
1602
|
// let maxId = maxIds|| 0;
|
|
1140
1603
|
// await db.sequelize.query(`ALTER SEQUENCE ${db_schema}."Sections__id_seq" RESTART WITH ${maxId + 1}`);
|
|
1141
1604
|
|
|
1142
|
-
|
|
1605
|
+
let uName = new Set()
|
|
1606
|
+
let uCode = new Set()
|
|
1607
|
+
let uSub = new Set()
|
|
1608
|
+
let uIns = new Set()
|
|
1609
|
+
let uSem = new Set()
|
|
1610
|
+
let uYear = new Set()
|
|
1611
|
+
let uCrs = new Set()
|
|
1612
|
+
let uDept = new Set()
|
|
1613
|
+
let uCam = new Set()
|
|
1614
|
+
|
|
1615
|
+
let newSection = []
|
|
1616
|
+
|
|
1617
|
+
const exSect = await Sections.findAll()
|
|
1618
|
+
const exSectMap = new Map(exSect.map(sect => [`[${sect.code}] - ${sect.name} [${sect.subjectId}, ${sect.instructorId}, ${sect.semesterId}, ${sect.academicYearId}, ${sect.courseId}, ${sect.departmentId}, ${sect.campusId}]`, sect]))
|
|
1619
|
+
|
|
1143
1620
|
for (let i = 0; i < student.length; i++) {
|
|
1144
1621
|
try {
|
|
1145
1622
|
|
|
@@ -1179,27 +1656,60 @@ const server = {
|
|
|
1179
1656
|
let code = sections ?? 'CODE'
|
|
1180
1657
|
code = code.split(/\s+/).map((word) => word.charAt(0).toUpperCase()).join('')
|
|
1181
1658
|
|
|
1182
|
-
|
|
1183
|
-
|
|
1184
|
-
|
|
1185
|
-
|
|
1186
|
-
|
|
1187
|
-
|
|
1659
|
+
let fromPrompts = await Picked()
|
|
1660
|
+
let semester = fromPrompts.semester
|
|
1661
|
+
let yearsFrom = fromPrompts.yearFrom
|
|
1662
|
+
let yearsTo = fromPrompts.yearTo
|
|
1663
|
+
let _semester = semesterSeq.find(sem => sem.code === semester)
|
|
1664
|
+
let _acadYear = acadYearSeq.find(yr => yr.from === parseInt(yearsFrom) && yr.to === parseInt(yearsTo))
|
|
1188
1665
|
|
|
1189
1666
|
let modifiedById = userMail._id;
|
|
1190
1667
|
let createdById = userMail._id;
|
|
1191
1668
|
|
|
1192
|
-
let defaultSub = 99999
|
|
1193
|
-
let defaultInst = 99999
|
|
1194
|
-
|
|
1195
1669
|
let classType = 'SYNCHRONOUS'
|
|
1196
|
-
|
|
1197
|
-
let
|
|
1198
|
-
|
|
1670
|
+
|
|
1671
|
+
let name = sections
|
|
1672
|
+
let subjectId = _subjects?._id??null
|
|
1673
|
+
let instructorId = _instructors?._id??null
|
|
1674
|
+
let semesterId = _semester?._id??null
|
|
1675
|
+
let academicYearId = _acadYear?._id??null
|
|
1676
|
+
let courseId = _course?._id??null
|
|
1677
|
+
let departmentId = _insdepartment?._id??null
|
|
1678
|
+
let campusId = _campus?._id??null
|
|
1679
|
+
|
|
1680
|
+
|
|
1681
|
+
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)){
|
|
1682
|
+
const errorMsg = `Duplicate Payload Found: [${code}] - ${name}`
|
|
1683
|
+
if(!uniqueErrors.has(errorMsg)){
|
|
1684
|
+
logger.error(`${errorCounter + 1}/${errorCounter + 1}: ${errorMsg}`)
|
|
1685
|
+
uniqueErrors.add(errorMsg)
|
|
1686
|
+
errorCounter++
|
|
1687
|
+
}
|
|
1688
|
+
}
|
|
1689
|
+
else if ( exSectMap.has(`[${code}] - ${name} [${subjectId}, ${instructorId}, ${semesterId}, ${academicYearId}, ${courseId}, ${departmentId}, ${campusId}]`)){
|
|
1690
|
+
const exSect = exSectMap.get(`[${code}] - ${name} [${subjectId}, ${instructorId}, ${semesterId}, ${academicYearId}, ${courseId}, ${departmentId}, ${campusId}]`)
|
|
1691
|
+
const errorMsg = `Existing Data Found:[${exSect.code}] - ${exSect.name}`
|
|
1692
|
+
if(!uniqueErrors.has(errorMsg)){
|
|
1693
|
+
logger.error(`${errorCounter + 1}/${errorCounter + 1}: ${errorMsg}`)
|
|
1694
|
+
uniqueErrors.add(errorMsg)
|
|
1695
|
+
errorCounter++
|
|
1696
|
+
}
|
|
1697
|
+
}
|
|
1698
|
+
else{
|
|
1699
|
+
uName.add(name)
|
|
1700
|
+
uCode.add(code)
|
|
1701
|
+
uSub.add(subjectId)
|
|
1702
|
+
uIns.add(instructorId)
|
|
1703
|
+
uSem.add(semesterId)
|
|
1704
|
+
uYear.add(academicYearId)
|
|
1705
|
+
uCrs.add(courseId)
|
|
1706
|
+
uDept.add(departmentId)
|
|
1707
|
+
uCam .add(campusId)
|
|
1708
|
+
newSection.push({
|
|
1199
1709
|
name: sections,
|
|
1200
1710
|
code,
|
|
1201
|
-
subjectId: _subjects?._id??
|
|
1202
|
-
instructorId: _instructors?._id??
|
|
1711
|
+
subjectId: _subjects?._id??null,
|
|
1712
|
+
instructorId: _instructors?._id??null,
|
|
1203
1713
|
classType,
|
|
1204
1714
|
semesterId: _semester?._id??null,
|
|
1205
1715
|
academicYearId: _acadYear?._id??null,
|
|
@@ -1208,60 +1718,46 @@ const server = {
|
|
|
1208
1718
|
departmentId: _insdepartment?._id??null,
|
|
1209
1719
|
modifiedById,
|
|
1210
1720
|
createdById,
|
|
1211
|
-
|
|
1212
|
-
},
|
|
1213
|
-
defaults: {
|
|
1214
|
-
// classType,
|
|
1215
|
-
// semesterId: _semester?._id??null,
|
|
1216
|
-
// academicYearId: _acadYear?._id??null,
|
|
1217
|
-
// courseId: _course?._id??null,
|
|
1218
|
-
// campusId: _campus?._id??null,
|
|
1219
|
-
// modifiedById,
|
|
1220
|
-
// createdById,
|
|
1221
|
-
|
|
1222
|
-
}
|
|
1223
|
-
});
|
|
1224
|
-
|
|
1225
|
-
if (created) {
|
|
1226
|
-
logger.info(`New section record created ${createdCounter + 1}/${createdCounter + 1}: ${record.name} `);
|
|
1227
|
-
createdCounter++;
|
|
1228
|
-
} else {
|
|
1229
|
-
|
|
1230
|
-
const errorMsg = `Record section already exists: ${record.name} `;
|
|
1231
|
-
|
|
1232
|
-
if (!uniqueErrors.has(errorMsg)) {
|
|
1233
|
-
logger.error(`${errorCounter + 1}/${errorCounter + 1} ${errorMsg}`);
|
|
1234
|
-
uniqueErrors.add(errorMsg);
|
|
1235
|
-
errorCounter++;
|
|
1236
|
-
}
|
|
1721
|
+
})
|
|
1237
1722
|
}
|
|
1723
|
+
|
|
1238
1724
|
}
|
|
1239
1725
|
} catch (error) {
|
|
1240
|
-
|
|
1241
|
-
logger.error(`Error occurred: ${error.stack
|
|
1726
|
+
;
|
|
1727
|
+
logger.error(`Error occurred: ${error.stack} ${error}`);
|
|
1242
1728
|
}
|
|
1243
1729
|
}
|
|
1730
|
+
|
|
1731
|
+
if (newSection.length > 0) {
|
|
1732
|
+
await Sections.bulkCreate(newSection)
|
|
1733
|
+
createdCounter += newSection.length
|
|
1734
|
+
|
|
1735
|
+
newSection.forEach((sect, index) => {
|
|
1736
|
+
logger.info(`${index + 1}/${index + 1}: New Section Record Created: [${sect.code}] - ${sect.name}`)
|
|
1737
|
+
});
|
|
1738
|
+
}
|
|
1244
1739
|
|
|
1245
1740
|
console.log("");
|
|
1246
1741
|
console.log("########################################################");
|
|
1247
1742
|
console.log("");
|
|
1248
|
-
logger.info('
|
|
1743
|
+
logger.info('Section Data Migration Completed');
|
|
1249
1744
|
logger.info(`Total successful Section records created: ${createdCounter}/${createdCounter}`);
|
|
1250
1745
|
logger.info(`Total Section Error Records: ${errorCounter}/${errorCounter}`);
|
|
1746
|
+
logger.info(`Total records: ${createdCounter + errorCounter}`);
|
|
1251
1747
|
console.log("");
|
|
1252
1748
|
console.log("########################################################");
|
|
1253
1749
|
console.log("");
|
|
1254
1750
|
|
|
1255
1751
|
let totalSummary = {
|
|
1256
|
-
itemLength:
|
|
1752
|
+
itemLength: createdCounter + errorCounter,
|
|
1257
1753
|
error: errorCounter,
|
|
1258
1754
|
success: createdCounter
|
|
1259
1755
|
};
|
|
1260
1756
|
return totalSummary;
|
|
1261
1757
|
|
|
1262
1758
|
} catch (error) {
|
|
1263
|
-
|
|
1264
|
-
logger.error(`Error occurred: ${error.stack
|
|
1759
|
+
;
|
|
1760
|
+
logger.error(`Error occurred: ${error.stack} ${error}`);
|
|
1265
1761
|
}
|
|
1266
1762
|
},
|
|
1267
1763
|
|
|
@@ -1297,6 +1793,21 @@ const server = {
|
|
|
1297
1793
|
// let maxId = maxIds|| 0;
|
|
1298
1794
|
// await db.sequelize.query(`ALTER SEQUENCE ${db_schema}."EnrolledStudents__id_seq" RESTART WITH ${maxId + 1}`);
|
|
1299
1795
|
|
|
1796
|
+
|
|
1797
|
+
let uStud = new Set()
|
|
1798
|
+
let uCrs = new Set()
|
|
1799
|
+
let uIns = new Set()
|
|
1800
|
+
let uSec = new Set()
|
|
1801
|
+
let uCam = new Set()
|
|
1802
|
+
let uYear = new Set()
|
|
1803
|
+
let uSem = new Set()
|
|
1804
|
+
let uGrade = new Set()
|
|
1805
|
+
|
|
1806
|
+
let newEnroll = []
|
|
1807
|
+
|
|
1808
|
+
const exEnroll = await EnrolledStudents.findAll()
|
|
1809
|
+
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]))
|
|
1810
|
+
|
|
1300
1811
|
|
|
1301
1812
|
for (let i = 0; i < studentApi.length; i++){
|
|
1302
1813
|
try {
|
|
@@ -1350,7 +1861,6 @@ const server = {
|
|
|
1350
1861
|
continue;
|
|
1351
1862
|
}
|
|
1352
1863
|
|
|
1353
|
-
|
|
1354
1864
|
let totalPoints = 100
|
|
1355
1865
|
let finalG = fGrade
|
|
1356
1866
|
let gradePoints = ((-4.0 / totalPoints) * parseFloat (finalG) + 5.0).toFixed(2)
|
|
@@ -1363,9 +1873,42 @@ const server = {
|
|
|
1363
1873
|
}
|
|
1364
1874
|
let remarks = rmarks?.toUpperCase()??null
|
|
1365
1875
|
|
|
1366
|
-
|
|
1367
|
-
let
|
|
1368
|
-
|
|
1876
|
+
let studentId = student?._id
|
|
1877
|
+
let courseId = course?._id
|
|
1878
|
+
let instructorId = _instructor?._id??null
|
|
1879
|
+
let sectionId = _section?._id??null
|
|
1880
|
+
let campusId = campus?._id
|
|
1881
|
+
let academicYearId = _acadYear?._id
|
|
1882
|
+
let semesterId = _semester?._id
|
|
1883
|
+
let finalGrade = gradePoints
|
|
1884
|
+
|
|
1885
|
+
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)){
|
|
1886
|
+
const errorMsg = `Duplicate Payload Found: [${studentId}] - [${courseId}, ${instructorId}, ${sectionId}, ${campusId}, ${academicYearId}, ${academicYearId}, ${semesterId}, ${finalGrade}]`
|
|
1887
|
+
if(!uniqueErrors.has(errorMsg)){
|
|
1888
|
+
logger.error(`${errorCounter + 1}/${errorCounter + 1}: ${errorMsg}`)
|
|
1889
|
+
uniqueErrors.add(errorMsg)
|
|
1890
|
+
errorCounter++
|
|
1891
|
+
}
|
|
1892
|
+
}
|
|
1893
|
+
else if ( exEnrollMap.has(`[${studentId}] - [${courseId}, ${instructorId}, ${sectionId}, ${campusId}, ${academicYearId}, ${academicYearId}, ${semesterId}, ${finalGrade}]`)){
|
|
1894
|
+
const exEnroll = exEnrollMap.get(`[${studentId}] - [${courseId}, ${instructorId}, ${sectionId}, ${campusId}, ${academicYearId}, ${academicYearId}, ${semesterId}, ${finalGrade}]`)
|
|
1895
|
+
const errorMsg = `Existing Data Found: [${exEnroll.exEnrollId}] - [${exEnroll.courseId}, ${exEnroll.instructorId}, ${exEnroll.sectionId}, ${exEnroll.campusId}, ${exEnroll.academicYearId}, ${exEnroll.academicYearId}, ${exEnroll.semesterId}, ${exEnroll.finalGrade}]`
|
|
1896
|
+
if(!uniqueErrors.has(errorMsg)){
|
|
1897
|
+
logger.error(`${errorCounter + 1}/${errorCounter + 1}: ${errorMsg}`)
|
|
1898
|
+
uniqueErrors.add(errorMsg)
|
|
1899
|
+
errorCounter++
|
|
1900
|
+
}
|
|
1901
|
+
}
|
|
1902
|
+
else{
|
|
1903
|
+
uStud.add(studentId)
|
|
1904
|
+
uCrs.add(courseId)
|
|
1905
|
+
uIns.add(instructorId)
|
|
1906
|
+
uSec.add(sectionId)
|
|
1907
|
+
uCam.add(campusId)
|
|
1908
|
+
uYear.add(academicYearId)
|
|
1909
|
+
uSem.add(semesterId)
|
|
1910
|
+
uGrade.add(finalGrade)
|
|
1911
|
+
newEnroll.push({
|
|
1369
1912
|
studentId: student?._id,
|
|
1370
1913
|
courseId: course?._id,
|
|
1371
1914
|
instructorId: _instructor?._id??null,
|
|
@@ -1378,52 +1921,45 @@ const server = {
|
|
|
1378
1921
|
remarks,
|
|
1379
1922
|
createdById,
|
|
1380
1923
|
modifiedById,
|
|
1381
|
-
}
|
|
1382
|
-
default:{
|
|
1383
|
-
|
|
1384
|
-
}
|
|
1385
|
-
})
|
|
1386
|
-
|
|
1387
|
-
if (created) {
|
|
1388
|
-
logger.info(`New enrolled student record created ${createdCounter + 1}/${createdCounter + 1}: studentId = [${record.studentId}], sectionId = [${record.sectionId}], instructorId = [${record.instructorId}]`);
|
|
1389
|
-
createdCounter++;
|
|
1390
|
-
} else {
|
|
1391
|
-
|
|
1392
|
-
const errorMsg = `Record enrolled student already exists: studentId = [${record.studentId}], sectionId = [${record.sectionId}], instructorId = [${record.instructorId}]`;
|
|
1393
|
-
|
|
1394
|
-
if (!uniqueErrors.has(errorMsg)) {
|
|
1395
|
-
logger.error(`${errorCounter + 1}/${errorCounter + 1} ${errorMsg}`);
|
|
1396
|
-
uniqueErrors.add(errorMsg);
|
|
1397
|
-
errorCounter++;
|
|
1398
|
-
}
|
|
1924
|
+
})
|
|
1399
1925
|
}
|
|
1400
1926
|
}
|
|
1401
1927
|
} catch (error) {
|
|
1402
|
-
|
|
1403
|
-
logger.error(`Error occurred: ${error.stack
|
|
1928
|
+
;
|
|
1929
|
+
logger.error(`Error occurred: ${error.stack} ${error}`);
|
|
1404
1930
|
}
|
|
1405
1931
|
}
|
|
1406
1932
|
|
|
1933
|
+
if (newEnroll.length > 0) {
|
|
1934
|
+
await Sections.bulkCreate(newEnroll)
|
|
1935
|
+
createdCounter += newEnroll.length
|
|
1936
|
+
|
|
1937
|
+
newEnroll.forEach((es, index) => {
|
|
1938
|
+
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}]`)
|
|
1939
|
+
});
|
|
1940
|
+
}
|
|
1941
|
+
|
|
1407
1942
|
console.log("");
|
|
1408
1943
|
console.log("########################################################")
|
|
1409
1944
|
console.log("")
|
|
1410
|
-
logger.info('
|
|
1945
|
+
logger.info('Enrolled Student Data Migration Completed');
|
|
1411
1946
|
logger.info(`Total successful Enrolled Student records created: ${createdCounter}/${createdCounter}`);
|
|
1412
1947
|
logger.info(`Total Enrolled Student Error Records: ${errorCounter}/${errorCounter}`);
|
|
1948
|
+
logger.info(`Total records: ${createdCounter + errorCounter}`);
|
|
1413
1949
|
console.log("")
|
|
1414
1950
|
console.log("########################################################")
|
|
1415
1951
|
console.log("")
|
|
1416
1952
|
|
|
1417
1953
|
let totalSummary = {
|
|
1418
|
-
itemLength:
|
|
1954
|
+
itemLength: createdCounter + errorCounter,
|
|
1419
1955
|
error: errorCounter,
|
|
1420
1956
|
success: createdCounter
|
|
1421
1957
|
}
|
|
1422
1958
|
return totalSummary
|
|
1423
1959
|
|
|
1424
1960
|
} catch (error) {
|
|
1425
|
-
|
|
1426
|
-
logger.error(`Error occurred: ${error.stack
|
|
1961
|
+
;
|
|
1962
|
+
logger.error(`Error occurred: ${error.stack} ${error}`);
|
|
1427
1963
|
|
|
1428
1964
|
}
|
|
1429
1965
|
},
|
|
@@ -1439,7 +1975,7 @@ async function runServerFunctions() {
|
|
|
1439
1975
|
}
|
|
1440
1976
|
}
|
|
1441
1977
|
} catch (error) {
|
|
1442
|
-
logger.error(`Error occurred: ${error.stack
|
|
1978
|
+
logger.error(`Error occurred: ${error.stack} ${error}`);
|
|
1443
1979
|
}
|
|
1444
1980
|
console.log("");
|
|
1445
1981
|
console.log("########################################################");
|