lms-sync 1.0.13 → 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 -473
- 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,56 +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
|
-
|
|
134
|
+
;
|
|
135
|
+
logger.error(`Error occurred: ${error.stack} ${error}`);
|
|
83
136
|
}
|
|
84
137
|
}
|
|
85
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
|
+
|
|
86
149
|
console.log("");
|
|
87
150
|
console.log("########################################################")
|
|
88
151
|
console.log("")
|
|
89
|
-
logger.info('
|
|
152
|
+
logger.info('Campus Data Migration Completed');
|
|
90
153
|
logger.info(`Total successful Campus records created: ${createdCounter}/${createdCounter}`);
|
|
91
154
|
logger.info(`Total Campus Error Records: ${errorCounter}/${errorCounter}`);
|
|
155
|
+
logger.info(`Total records: ${createdCounter + errorCounter}`);
|
|
92
156
|
console.log("")
|
|
93
157
|
console.log("########################################################")
|
|
94
158
|
console.log("")
|
|
95
159
|
|
|
96
160
|
let totalSummary = {
|
|
97
|
-
itemLength:
|
|
161
|
+
itemLength: createdCounter + errorCounter,
|
|
98
162
|
error: errorCounter,
|
|
99
163
|
success: createdCounter
|
|
100
164
|
}
|
|
101
165
|
return totalSummary
|
|
102
166
|
|
|
103
167
|
} catch (error) {
|
|
104
|
-
|
|
168
|
+
;
|
|
169
|
+
logger.error(`Error occurred: ${error.stack} ${error}`);
|
|
105
170
|
|
|
106
171
|
}
|
|
107
172
|
},
|
|
@@ -118,17 +183,44 @@ const server = {
|
|
|
118
183
|
const campusApi = await api.Campus()
|
|
119
184
|
|
|
120
185
|
const campusSeq = await Campuses.findAll()
|
|
121
|
-
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
|
+
});
|
|
122
201
|
|
|
123
202
|
let createdCounter = 0
|
|
124
203
|
let errorCounter = 0
|
|
125
204
|
let uniqueErrors = new Set()
|
|
126
205
|
|
|
127
206
|
const db_schema = schema
|
|
128
|
-
// 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
|
|
129
208
|
// let maxId = maxIds|| 0;
|
|
130
209
|
// await db.sequelize.query(`ALTER SEQUENCE ${db_schema}."Colleges__id_seq" RESTART WITH ${maxId + 1}`);
|
|
131
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
|
+
|
|
132
224
|
for (let i = 0; i < collegeApi.length; i++){
|
|
133
225
|
try {
|
|
134
226
|
let _college = collegeApi[i]
|
|
@@ -136,62 +228,81 @@ const server = {
|
|
|
136
228
|
let campusMap = campusApi.find(a => a.id === _college?.campus_id)
|
|
137
229
|
|
|
138
230
|
let _campus = campusSeq.find(b => b.name === campusMap?.name)
|
|
139
|
-
|
|
140
|
-
let campusDefault = 999999
|
|
141
231
|
|
|
142
232
|
let modifiedById = userMail._id
|
|
143
233
|
let createdById = userMail._id
|
|
144
234
|
|
|
145
|
-
let
|
|
146
|
-
|
|
147
|
-
|
|
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({
|
|
148
259
|
name: _college?.name,
|
|
149
|
-
code: _college?.code
|
|
150
|
-
|
|
151
|
-
defaults:{
|
|
152
|
-
campusId: _campus?._id??campusDefault,
|
|
260
|
+
code: _college?.code,
|
|
261
|
+
campusId: _campus?._id??campusDefault?._id,
|
|
153
262
|
modifiedById,
|
|
154
263
|
createdById
|
|
155
|
-
}
|
|
156
|
-
})
|
|
157
|
-
if (created){
|
|
158
|
-
logger.info(`New college record created ${createdCounter + 1}/${createdCounter + 1}: [${record.code}] - ${record.name} `)
|
|
159
|
-
createdCounter++;
|
|
160
|
-
}
|
|
161
|
-
else {
|
|
162
|
-
const errorMsg = `Record college already exists: [${record.code}] - ${record.name} `
|
|
163
|
-
|
|
164
|
-
if (!uniqueErrors.has(errorMsg)) {
|
|
165
|
-
logger.error(`${errorCounter + 1}/${errorCounter + 1} ${errorMsg}`);
|
|
166
|
-
uniqueErrors.add(errorMsg);
|
|
167
|
-
errorCounter++;
|
|
168
|
-
}
|
|
264
|
+
})
|
|
169
265
|
}
|
|
170
266
|
|
|
171
267
|
} catch (error) {
|
|
172
|
-
|
|
268
|
+
;
|
|
269
|
+
logger.error(`Error occurred: ${error.stack} ${error}`);
|
|
173
270
|
}
|
|
174
271
|
}
|
|
175
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
|
+
|
|
176
285
|
console.log("");
|
|
177
286
|
console.log("########################################################")
|
|
178
287
|
console.log("")
|
|
179
|
-
logger.info('
|
|
288
|
+
logger.info('College Data Migration Completed');
|
|
180
289
|
logger.info(`Total successful College records created: ${createdCounter}/${createdCounter}`);
|
|
181
290
|
logger.info(`Total College Error Records: ${errorCounter}/${errorCounter}`);
|
|
291
|
+
logger.info(`Total records: ${itemLength}`)
|
|
182
292
|
console.log("")
|
|
183
293
|
console.log("########################################################")
|
|
184
294
|
console.log("")
|
|
185
295
|
|
|
186
296
|
let totalSummary = {
|
|
187
|
-
itemLength:
|
|
297
|
+
itemLength: itemLength,
|
|
188
298
|
error: errorCounter,
|
|
189
299
|
success: createdCounter
|
|
190
300
|
}
|
|
191
301
|
return totalSummary
|
|
192
302
|
|
|
193
303
|
} catch (error) {
|
|
194
|
-
|
|
304
|
+
;
|
|
305
|
+
logger.error(`Error occurred: ${error.stack} ${error}`);
|
|
195
306
|
|
|
196
307
|
}
|
|
197
308
|
},
|
|
@@ -207,11 +318,29 @@ const server = {
|
|
|
207
318
|
const departmentApi = await api.Department()
|
|
208
319
|
const campusApi = await api.Campus()
|
|
209
320
|
const collegeApi = await api.College()
|
|
210
|
-
|
|
321
|
+
const instructorApi = await api.Instructor()
|
|
211
322
|
|
|
212
323
|
const campusSeq = await Campuses.findAll()
|
|
213
324
|
const collegeSeq = await Colleges.findAll()
|
|
214
|
-
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
|
+
});
|
|
215
344
|
|
|
216
345
|
let createdCounter = 0
|
|
217
346
|
let errorCounter = 0
|
|
@@ -221,320 +350,525 @@ const server = {
|
|
|
221
350
|
// let maxIds = await Campuses.max('_id'); = await AcademicDepartments.max('_id'); // Fetch maximum _id directly from the AcademicDepartments model
|
|
222
351
|
// let maxId = maxIds|| 0;
|
|
223
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
|
+
|
|
224
366
|
for (let i = 0; i < departmentApi.length; i++){
|
|
225
367
|
try {
|
|
226
368
|
let _acadDept = departmentApi[i]
|
|
227
|
-
|
|
228
|
-
|
|
229
369
|
let _college = collegeSeq.find( col => col.code === _acadDept?.code)
|
|
230
|
-
|
|
231
370
|
let college = collegeApi.find( cols => cols.code === _acadDept?.code)
|
|
232
|
-
|
|
233
371
|
let _campus = campusApi.find(cam => cam.id === college?.campus_id)
|
|
234
|
-
|
|
235
372
|
let campus = campusSeq.find(camp => camp.code === _campus?.code)
|
|
236
|
-
|
|
237
|
-
let
|
|
238
|
-
let
|
|
239
|
-
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
|
+
}
|
|
240
420
|
|
|
421
|
+
|
|
422
|
+
//additional departments from instructors api
|
|
423
|
+
for (let j = 0; j < instructorApi.length; j++) {
|
|
424
|
+
try {
|
|
425
|
+
let instructor = instructorApi[j];
|
|
241
426
|
let modifiedById = userMail._id
|
|
242
427
|
let createdById = userMail._id
|
|
243
428
|
|
|
429
|
+
let acadDepartmentMap = departmentApi.find(a => a.name === instructor?.department_name)
|
|
244
430
|
|
|
245
|
-
let
|
|
431
|
+
let _acadDepartment = departmentSeq.find(b => b.name === acadDepartmentMap?.name)
|
|
246
432
|
|
|
247
|
-
|
|
248
|
-
|
|
249
|
-
|
|
250
|
-
|
|
251
|
-
|
|
252
|
-
|
|
253
|
-
|
|
254
|
-
|
|
255
|
-
|
|
256
|
-
|
|
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++
|
|
257
458
|
}
|
|
258
|
-
})
|
|
259
|
-
if (created){
|
|
260
|
-
logger.info(`New academic department record created ${createdCounter + 1}/${createdCounter + 1}: [${record.code}] - ${record.name} `)
|
|
261
|
-
createdCounter++;
|
|
262
459
|
}
|
|
263
|
-
else
|
|
264
|
-
|
|
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
|
+
}
|
|
265
473
|
|
|
266
|
-
if (!uniqueErrors.has(errorMsg)) {
|
|
267
|
-
logger.error(`${errorCounter + 1}/${errorCounter + 1} ${errorMsg}`);
|
|
268
|
-
uniqueErrors.add(errorMsg);
|
|
269
|
-
errorCounter++;
|
|
270
|
-
}
|
|
271
474
|
|
|
272
|
-
}
|
|
273
|
-
|
|
274
475
|
} catch (error) {
|
|
275
|
-
|
|
476
|
+
logger.error(`Error occurred: ${error} ${error.stack}`);
|
|
276
477
|
}
|
|
277
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
|
+
}
|
|
278
487
|
|
|
279
488
|
console.log("");
|
|
280
489
|
console.log("########################################################")
|
|
281
490
|
console.log("")
|
|
282
|
-
logger.info('
|
|
491
|
+
logger.info('Academic Department Data Migration Completed');
|
|
283
492
|
logger.info(`Total successful Academic Department records created: ${createdCounter}/${createdCounter}`);
|
|
284
493
|
logger.info(`Total Academic Department Error Records: ${errorCounter}/${errorCounter}`);
|
|
494
|
+
logger.info(`Total records: ${createdCounter + errorCounter}`);
|
|
285
495
|
console.log("")
|
|
286
496
|
console.log("########################################################")
|
|
287
497
|
console.log("")
|
|
288
498
|
|
|
289
499
|
let totalSummary = {
|
|
290
|
-
itemLength:
|
|
500
|
+
itemLength: createdCounter + errorCounter,
|
|
291
501
|
error: errorCounter,
|
|
292
502
|
success: createdCounter
|
|
293
503
|
}
|
|
294
504
|
return totalSummary
|
|
295
505
|
|
|
296
506
|
} catch (error) {
|
|
297
|
-
|
|
298
|
-
|
|
507
|
+
logger.error(`Error occurred: ${error} ${error.stack}`);
|
|
508
|
+
logger.error(`Error occurredsss: ${error.stack}`);
|
|
299
509
|
}
|
|
300
510
|
},
|
|
301
511
|
|
|
302
|
-
async
|
|
512
|
+
async Instructor(){
|
|
303
513
|
try {
|
|
304
514
|
console.log("");
|
|
305
515
|
console.log("########################################################")
|
|
306
|
-
console.log("
|
|
516
|
+
console.log(" Instructors Migration ")
|
|
307
517
|
console.log("########################################################")
|
|
308
518
|
console.log("");
|
|
309
519
|
|
|
310
|
-
const
|
|
311
|
-
|
|
312
|
-
const courseApi = await api.Course()
|
|
313
|
-
const collegeApi = await api.College()
|
|
520
|
+
const instructorApi = await api.Instructor()
|
|
314
521
|
const departmentApi = await api.Department()
|
|
315
|
-
|
|
316
|
-
const acadDeptSeq = await AcademicDepartments.findAll()
|
|
317
522
|
|
|
523
|
+
const departmentSeq = await AcademicDepartments.findAll()
|
|
318
524
|
const campusSeq = await Campuses.findAll()
|
|
319
|
-
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
|
+
});
|
|
320
545
|
|
|
321
546
|
let createdCounter = 0
|
|
322
547
|
let errorCounter = 0
|
|
323
548
|
let uniqueErrors = new Set()
|
|
324
549
|
|
|
550
|
+
|
|
325
551
|
const db_schema = schema
|
|
326
|
-
// 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
|
|
327
553
|
// let maxId = maxIds|| 0;
|
|
328
|
-
// await db.sequelize.query(`ALTER SEQUENCE ${db_schema}."
|
|
554
|
+
// await db.sequelize.query(`ALTER SEQUENCE ${db_schema}."Instructors__id_seq" RESTART WITH ${maxId + 1}`);
|
|
329
555
|
|
|
330
|
-
|
|
331
|
-
|
|
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()
|
|
332
562
|
|
|
333
|
-
|
|
334
|
-
let courseCode = courseApi.find(crs => crs.name === course?.course)
|
|
335
|
-
let campus = campusSeq.find(camp => camp.name === course?.campus)
|
|
563
|
+
let newInstructor = []
|
|
336
564
|
|
|
337
|
-
|
|
338
|
-
|
|
339
|
-
|
|
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]
|
|
340
571
|
|
|
572
|
+
let acadDepartmentMap = departmentApi.find(a => a.name === _instructor?.department_name)
|
|
341
573
|
|
|
574
|
+
let _acadDepartment = departmentSeq.find(b => b.name === acadDepartmentMap?.name)
|
|
342
575
|
|
|
343
|
-
|
|
576
|
+
let campusMap = campusSeq.find(c => c._id === _acadDepartment?.campusId)
|
|
344
577
|
|
|
345
578
|
let modifiedById = userMail._id
|
|
346
579
|
let createdById = userMail._id
|
|
347
580
|
|
|
348
|
-
|
|
349
|
-
let
|
|
350
|
-
where:{
|
|
351
|
-
name: course?.course,
|
|
352
|
-
code: courseCode?.code,
|
|
353
|
-
major: course?.major,
|
|
354
|
-
campusId: campus?._id??null,
|
|
355
|
-
departmentId: _department?._id??null,
|
|
356
|
-
modifiedById,
|
|
357
|
-
createdById
|
|
358
|
-
},
|
|
359
|
-
defaults:{
|
|
360
|
-
|
|
361
|
-
|
|
362
|
-
}
|
|
363
|
-
})
|
|
364
|
-
|
|
365
|
-
if (created) {
|
|
366
|
-
logger.info(`New course record created ${createdCounter +1}/${createdCounter +1}: [${record.code}] - ${record.name}, Major in ${record.major}`)
|
|
367
|
-
createdCounter++
|
|
368
|
-
} else {
|
|
581
|
+
let campusDefault = "MSC - Boac Campus"
|
|
582
|
+
let _campusDefault = campusSeq.find(ccc => ccc.name === campusDefault)
|
|
369
583
|
|
|
370
|
-
|
|
584
|
+
let role = _instructor?.role
|
|
371
585
|
|
|
372
|
-
|
|
373
|
-
|
|
374
|
-
|
|
375
|
-
|
|
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++
|
|
376
618
|
}
|
|
377
|
-
|
|
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
|
+
})
|
|
378
640
|
}
|
|
379
641
|
|
|
380
642
|
} catch (error) {
|
|
381
|
-
|
|
382
|
-
}
|
|
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
|
+
|
|
383
656
|
}
|
|
384
657
|
|
|
385
658
|
|
|
386
659
|
console.log("");
|
|
387
660
|
console.log("########################################################")
|
|
388
661
|
console.log("")
|
|
389
|
-
logger.info('
|
|
390
|
-
logger.info(`Total successful
|
|
391
|
-
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
|
+
|
|
392
667
|
console.log("")
|
|
393
668
|
console.log("########################################################")
|
|
394
669
|
console.log("")
|
|
395
670
|
|
|
396
671
|
let totalSummary = {
|
|
397
|
-
itemLength:
|
|
672
|
+
itemLength: createdCounter + errorCounter,
|
|
398
673
|
error: errorCounter,
|
|
399
674
|
success: createdCounter
|
|
400
675
|
}
|
|
401
|
-
|
|
402
|
-
uniqueErrors.clear();
|
|
403
|
-
|
|
404
676
|
return totalSummary
|
|
405
|
-
|
|
677
|
+
|
|
406
678
|
} catch (error) {
|
|
407
|
-
|
|
679
|
+
;
|
|
680
|
+
logger.error(`Error occurred: ${error} ${error.stack} `);
|
|
681
|
+
|
|
408
682
|
}
|
|
409
683
|
},
|
|
410
684
|
|
|
411
|
-
async
|
|
685
|
+
async Course(){
|
|
412
686
|
try {
|
|
413
687
|
console.log("");
|
|
414
688
|
console.log("########################################################")
|
|
415
|
-
console.log("
|
|
689
|
+
console.log(" Courses Migration ")
|
|
416
690
|
console.log("########################################################")
|
|
417
691
|
console.log("");
|
|
418
692
|
|
|
419
|
-
const
|
|
420
|
-
|
|
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()
|
|
421
700
|
|
|
422
|
-
const subjectSeq = await Subjects.findAll()
|
|
423
701
|
const campusSeq = await Campuses.findAll()
|
|
424
|
-
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
|
+
});
|
|
425
720
|
|
|
426
|
-
const userMail = await Users.findOne({ where: { email: 'ccci_integrator@gmail.com' } });
|
|
427
721
|
|
|
428
722
|
let createdCounter = 0
|
|
429
723
|
let errorCounter = 0
|
|
430
724
|
let uniqueErrors = new Set()
|
|
431
725
|
|
|
432
|
-
|
|
433
726
|
const db_schema = schema
|
|
434
|
-
// 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
|
|
435
728
|
// let maxId = maxIds|| 0;
|
|
436
|
-
// await db.sequelize.query(`ALTER SEQUENCE ${db_schema}."
|
|
437
|
-
|
|
438
|
-
|
|
439
|
-
for (let i = 0; i < roomApi.length; i++){
|
|
440
|
-
try {
|
|
441
|
-
let _room = roomApi[i]
|
|
442
|
-
|
|
443
|
-
let _subject = subjectRoom.find(r => r.room_id === _room?.id)
|
|
444
|
-
// console.log('_subject :>> ', _subject);
|
|
445
|
-
|
|
446
|
-
let _subjects = subjectSeq.find(s => s.name === _subject?.name)
|
|
447
|
-
// console.log('_subjects :>> ', _subjects);
|
|
448
|
-
|
|
449
|
-
|
|
450
|
-
let _department = departmentSeq.find(dep => dep._id === _subjects?.departmentId)
|
|
451
|
-
// console.log('_department :>> ', _department);
|
|
729
|
+
// await db.sequelize.query(`ALTER SEQUENCE ${db_schema}."Courses__id_seq" RESTART WITH ${maxId + 1}`);
|
|
452
730
|
|
|
453
731
|
|
|
454
|
-
|
|
455
|
-
|
|
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()
|
|
456
737
|
|
|
738
|
+
let newCourse = []
|
|
457
739
|
|
|
458
|
-
|
|
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
|
+
|
|
459
743
|
|
|
460
|
-
|
|
744
|
+
for (let i = 0; i < studentApi.length; i++){
|
|
745
|
+
try {
|
|
461
746
|
|
|
462
|
-
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)
|
|
463
750
|
|
|
464
|
-
|
|
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)
|
|
465
754
|
|
|
466
755
|
let modifiedById = userMail._id
|
|
467
756
|
let createdById = userMail._id
|
|
468
757
|
|
|
469
|
-
|
|
470
|
-
|
|
471
|
-
|
|
472
|
-
|
|
473
|
-
|
|
474
|
-
defaults:{
|
|
475
|
-
capacity,
|
|
476
|
-
modifiedById,
|
|
477
|
-
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
|
|
478
763
|
|
|
479
|
-
}
|
|
480
|
-
})
|
|
481
|
-
if (created){
|
|
482
|
-
logger.info(`New room record created ${createdCounter + 1}/${createdCounter + 1}: ${record.name} `)
|
|
483
|
-
createdCounter++;
|
|
484
|
-
}
|
|
485
|
-
else {
|
|
486
|
-
const errorMsg = `Record room already exists: ${record.name}`;
|
|
487
764
|
|
|
488
|
-
if (!uniqueErrors.has(errorMsg)) {
|
|
489
|
-
logger.error(`${errorCounter + 1}/${errorCounter + 1} ${errorMsg}`);
|
|
490
|
-
uniqueErrors.add(errorMsg);
|
|
491
|
-
errorCounter++;
|
|
492
|
-
}
|
|
493
765
|
|
|
494
|
-
|
|
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
|
+
}
|
|
495
799
|
|
|
496
800
|
} catch (error) {
|
|
497
|
-
|
|
801
|
+
;
|
|
802
|
+
logger.error(`Error occurred: ${error.stack} ${error}`);
|
|
498
803
|
}
|
|
499
804
|
}
|
|
500
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
|
+
|
|
501
816
|
console.log("");
|
|
502
817
|
console.log("########################################################")
|
|
503
818
|
console.log("")
|
|
504
|
-
logger.info('
|
|
505
|
-
logger.info(`Total successful
|
|
506
|
-
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}`);
|
|
507
822
|
console.log("")
|
|
508
823
|
console.log("########################################################")
|
|
509
824
|
console.log("")
|
|
510
825
|
|
|
511
826
|
let totalSummary = {
|
|
512
|
-
itemLength:
|
|
827
|
+
itemLength: courseApi.length,
|
|
513
828
|
error: errorCounter,
|
|
514
829
|
success: createdCounter
|
|
515
830
|
}
|
|
516
|
-
return totalSummary
|
|
517
831
|
|
|
518
|
-
|
|
519
|
-
|
|
832
|
+
uniqueErrors.clear();
|
|
833
|
+
|
|
834
|
+
return totalSummary
|
|
520
835
|
|
|
836
|
+
} catch (error) {
|
|
837
|
+
;
|
|
838
|
+
logger.error(`Error occurred: ${error.stack} ${error}`);
|
|
521
839
|
}
|
|
522
840
|
},
|
|
523
841
|
|
|
524
|
-
async
|
|
842
|
+
async Room(){
|
|
525
843
|
try {
|
|
526
844
|
console.log("");
|
|
527
845
|
console.log("########################################################")
|
|
528
|
-
console.log("
|
|
846
|
+
console.log(" Rooms Migration ")
|
|
529
847
|
console.log("########################################################")
|
|
530
848
|
console.log("");
|
|
531
849
|
|
|
532
|
-
const
|
|
533
|
-
const
|
|
850
|
+
const subjectRoom = await api.Subject()
|
|
851
|
+
const roomApi = await api.Room()
|
|
534
852
|
|
|
535
|
-
const
|
|
853
|
+
const subjectSeq = await Subjects.findAll()
|
|
536
854
|
const campusSeq = await Campuses.findAll()
|
|
537
|
-
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
|
+
});
|
|
538
872
|
|
|
539
873
|
let createdCounter = 0
|
|
540
874
|
let errorCounter = 0
|
|
@@ -542,87 +876,104 @@ const server = {
|
|
|
542
876
|
|
|
543
877
|
|
|
544
878
|
const db_schema = schema
|
|
545
|
-
// 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
|
|
546
880
|
// let maxId = maxIds|| 0;
|
|
547
|
-
// await db.sequelize.query(`ALTER SEQUENCE ${db_schema}."
|
|
548
|
-
|
|
549
|
-
|
|
550
|
-
for (let i = 0; i < instructorApi.length; i++){
|
|
551
|
-
try {
|
|
552
|
-
let _instructor = instructorApi[i]
|
|
553
|
-
|
|
554
|
-
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}`);
|
|
555
882
|
|
|
556
|
-
|
|
883
|
+
let uName = new Set()
|
|
884
|
+
let uCampus = new Set()
|
|
557
885
|
|
|
558
|
-
|
|
886
|
+
let newRoom = []
|
|
559
887
|
|
|
560
|
-
|
|
888
|
+
const exRoom = await Rooms.findAll()
|
|
889
|
+
const exRoomMap = new Map(exRoom.map(room => [`[${room.name}] - ${room.campusId}`, room]))
|
|
890
|
+
|
|
561
891
|
|
|
562
|
-
|
|
563
|
-
|
|
564
|
-
|
|
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)
|
|
565
900
|
|
|
901
|
+
let capacity = 50
|
|
566
902
|
let campusDefault = "MSC - Boac Campus"
|
|
567
903
|
let _campusDefault = campusSeq.find(ccc => ccc.name === campusDefault)
|
|
568
904
|
|
|
569
|
-
|
|
570
|
-
where:{
|
|
571
|
-
firstName: _instructor?.first_name,
|
|
572
|
-
lastName: _instructor?.last_name,
|
|
573
|
-
middleName: _instructor?.middle_name,
|
|
574
|
-
employeeNumber: _instructor?.faculty_id,
|
|
575
|
-
departmentId: _acadDepartment?._id??academicDepartmentDefault,
|
|
576
|
-
campusId: campusMap?._id??_campusDefault?._id,
|
|
577
|
-
modifiedById,
|
|
578
|
-
createdById,
|
|
579
|
-
// employeeId: record?._id??null,
|
|
905
|
+
// return console.log('campusDefault :>> ', campusDefault);
|
|
580
906
|
|
|
907
|
+
let modifiedById = userMail._id
|
|
908
|
+
let createdById = userMail._id
|
|
581
909
|
|
|
582
|
-
|
|
583
|
-
|
|
910
|
+
let name = _room?.name
|
|
911
|
+
let campusId = _campus?._id??_campusDefault?._id??null
|
|
584
912
|
|
|
585
|
-
|
|
586
|
-
|
|
587
|
-
|
|
588
|
-
logger.
|
|
589
|
-
|
|
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
|
+
}
|
|
590
920
|
}
|
|
591
|
-
else {
|
|
592
|
-
const
|
|
593
|
-
|
|
594
|
-
if
|
|
595
|
-
|
|
596
|
-
|
|
597
|
-
|
|
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++
|
|
598
928
|
}
|
|
599
|
-
|
|
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
|
+
})
|
|
600
940
|
}
|
|
601
941
|
|
|
602
942
|
} catch (error) {
|
|
603
|
-
|
|
943
|
+
;
|
|
944
|
+
logger.error(`Error occurred: ${error.stack} ${error}`);
|
|
604
945
|
}
|
|
605
946
|
}
|
|
606
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
|
+
|
|
607
957
|
console.log("");
|
|
608
958
|
console.log("########################################################")
|
|
609
959
|
console.log("")
|
|
610
|
-
logger.info('
|
|
611
|
-
logger.info(`Total successful
|
|
612
|
-
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}`);
|
|
613
964
|
console.log("")
|
|
614
965
|
console.log("########################################################")
|
|
615
966
|
console.log("")
|
|
616
967
|
|
|
617
968
|
let totalSummary = {
|
|
618
|
-
itemLength:
|
|
969
|
+
itemLength: createdCounter + errorCounter,
|
|
619
970
|
error: errorCounter,
|
|
620
971
|
success: createdCounter
|
|
621
972
|
}
|
|
622
973
|
return totalSummary
|
|
623
974
|
|
|
624
975
|
} catch (error) {
|
|
625
|
-
|
|
976
|
+
logger.error(`Error occurred: ${error.stack} ${error}`);
|
|
626
977
|
|
|
627
978
|
}
|
|
628
979
|
},
|
|
@@ -644,12 +995,19 @@ const server = {
|
|
|
644
995
|
|
|
645
996
|
const { acadYearResult, currentSchoolYear } = acadYearApi;
|
|
646
997
|
|
|
647
|
-
|
|
648
998
|
const db_schema = schema
|
|
649
|
-
// 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
|
|
650
1000
|
// let maxId = maxIds|| 0;
|
|
651
1001
|
// await db.sequelize.query(`ALTER SEQUENCE ${db_schema}."AcademicYears__id_seq" RESTART WITH ${maxId + 1}`);
|
|
652
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
|
+
|
|
653
1011
|
|
|
654
1012
|
for (let i = 0; i < acadYearResult.length; i++){
|
|
655
1013
|
try {
|
|
@@ -671,54 +1029,72 @@ const server = {
|
|
|
671
1029
|
let modifiedById = userMail._id
|
|
672
1030
|
let createdById = userMail._id
|
|
673
1031
|
|
|
674
|
-
|
|
675
|
-
|
|
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({
|
|
676
1054
|
from,
|
|
677
|
-
to
|
|
678
|
-
},
|
|
679
|
-
defaults:{
|
|
1055
|
+
to,
|
|
680
1056
|
modifiedById,
|
|
681
1057
|
createdById,
|
|
682
1058
|
default: isDefault
|
|
683
|
-
}
|
|
684
|
-
})
|
|
685
|
-
if (created){
|
|
686
|
-
logger.info(`New academic year record created ${createdCounter + 1}/${createdCounter + 1}: ${record.from} - ${record.to} `)
|
|
687
|
-
createdCounter++;
|
|
688
|
-
}
|
|
689
|
-
else {
|
|
690
|
-
const errorMsg = `Record academic year already exists: ${record.from} - ${record.to}`;
|
|
691
|
-
if (!uniqueErrors.has(errorMsg)) {
|
|
692
|
-
logger.error(`${errorCounter + 1}/${errorCounter + 1} ${errorMsg}`);
|
|
693
|
-
uniqueErrors.add(errorMsg);
|
|
694
|
-
errorCounter++;
|
|
695
|
-
}
|
|
1059
|
+
})
|
|
696
1060
|
}
|
|
697
1061
|
|
|
698
1062
|
} catch (error) {
|
|
699
|
-
|
|
1063
|
+
;
|
|
1064
|
+
logger.error(`Error occurred: ${error.stack} ${error}`);
|
|
700
1065
|
}
|
|
701
1066
|
}
|
|
702
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
|
+
|
|
703
1077
|
console.log("");
|
|
704
1078
|
console.log("########################################################")
|
|
705
1079
|
console.log("")
|
|
706
|
-
logger.info('
|
|
1080
|
+
logger.info('Academic Years Data Migration Completed');
|
|
707
1081
|
logger.info(`Total successful Academic Years records created: ${createdCounter}/${createdCounter}`);
|
|
708
1082
|
logger.info(`Total Academic Years Error Records: ${errorCounter}/${errorCounter}`);
|
|
1083
|
+
logger.info(`Total records: ${createdCounter + errorCounter}`);
|
|
709
1084
|
console.log("")
|
|
710
1085
|
console.log("########################################################")
|
|
711
1086
|
console.log("")
|
|
712
1087
|
|
|
713
1088
|
let totalSummary = {
|
|
714
|
-
itemLength:
|
|
1089
|
+
itemLength: createdCounter + errorCounter,
|
|
715
1090
|
error: errorCounter,
|
|
716
1091
|
success: createdCounter
|
|
717
1092
|
}
|
|
718
1093
|
return totalSummary
|
|
719
1094
|
|
|
720
1095
|
} catch (error) {
|
|
721
|
-
|
|
1096
|
+
;
|
|
1097
|
+
logger.error(`Error occurred: ${error.stack} ${error}`);
|
|
722
1098
|
|
|
723
1099
|
}
|
|
724
1100
|
},
|
|
@@ -736,19 +1112,44 @@ const server = {
|
|
|
736
1112
|
const subjectApi = await api.Subject()
|
|
737
1113
|
|
|
738
1114
|
const departmentSeq = await AcademicDepartments.findAll()
|
|
739
|
-
const userMail = await Users.findOne({ where: { email: 'ccci_integrator@gmail.com' } });
|
|
740
|
-
|
|
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
|
+
|
|
741
1134
|
let createdCounter = 0
|
|
742
1135
|
let errorCounter = 0
|
|
743
1136
|
let uniqueErrors = new Set()
|
|
744
1137
|
|
|
745
|
-
|
|
746
1138
|
const db_schema = schema
|
|
747
|
-
// 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
|
|
748
1140
|
// let maxId = maxIds|| 0;
|
|
749
1141
|
// await db.sequelize.query(`ALTER SEQUENCE ${db_schema}."Subjects__id_seq" RESTART WITH ${maxId + 1}`);
|
|
750
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 = []
|
|
751
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
|
+
|
|
752
1153
|
for (let i = 0; i < studentSubject.length; i++){
|
|
753
1154
|
try {
|
|
754
1155
|
let _subject = studentSubject[i]
|
|
@@ -757,70 +1158,86 @@ const server = {
|
|
|
757
1158
|
|
|
758
1159
|
let _subs = studentSubject[i].subjects_enrolled;
|
|
759
1160
|
|
|
760
|
-
|
|
761
1161
|
for (let j = 0; j < _subs.length; j++){
|
|
762
1162
|
|
|
763
1163
|
let subject = _subs[j].subject_code
|
|
764
1164
|
|
|
765
1165
|
let _subjects = subjectApi.find(sub => sub.code === subject)
|
|
766
1166
|
|
|
767
|
-
// return console.log('_subjects :>> ', _subjects);
|
|
768
|
-
|
|
769
|
-
|
|
770
1167
|
if (!subject) {
|
|
771
|
-
// console.error(`Subject with code ${subjects} not found.`);
|
|
772
1168
|
continue;
|
|
773
1169
|
}
|
|
774
1170
|
if (!_subjects) {
|
|
775
|
-
// console.error(`Subject with code ${subjects} not found.`);
|
|
776
1171
|
continue;
|
|
777
1172
|
}
|
|
778
1173
|
let subjectType = "LECTURE"
|
|
779
1174
|
let modifiedById = userMail._id
|
|
780
1175
|
let createdById = userMail._id
|
|
781
1176
|
|
|
782
|
-
|
|
783
|
-
|
|
784
|
-
let
|
|
785
|
-
|
|
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({
|
|
786
1205
|
code:_subjects?.code,
|
|
787
|
-
|
|
788
|
-
|
|
789
|
-
|
|
790
|
-
|
|
791
|
-
subjectType,
|
|
1206
|
+
name:_subjects?.name,
|
|
1207
|
+
units:_subjects?.units,
|
|
1208
|
+
departmentId: _department?._id??departmentDefault?._id,
|
|
1209
|
+
subjectType,
|
|
792
1210
|
modifiedById,
|
|
793
|
-
createdById
|
|
794
|
-
|
|
795
|
-
|
|
796
|
-
|
|
797
|
-
|
|
798
|
-
|
|
799
|
-
if (created){
|
|
800
|
-
logger.info(`New subject record created ${createdCounter + 1}/${createdCounter + 1}: [${record.code}], ${record.name} `)
|
|
801
|
-
createdCounter++;
|
|
1211
|
+
createdById,
|
|
1212
|
+
// migratedAt,
|
|
1213
|
+
// migratedTable,
|
|
1214
|
+
// referenceId,
|
|
1215
|
+
// isMigrated
|
|
1216
|
+
})
|
|
802
1217
|
}
|
|
803
|
-
else {
|
|
804
|
-
const errorMsg = `Record subject already exists: [${record.code}], ${record.name}`;
|
|
805
1218
|
|
|
806
|
-
if (!uniqueErrors.has(errorMsg)) {
|
|
807
|
-
logger.error(`${errorCounter + 1}/${errorCounter + 1} ${errorMsg}`);
|
|
808
|
-
uniqueErrors.add(errorMsg);
|
|
809
|
-
errorCounter++;
|
|
810
|
-
}
|
|
811
|
-
}
|
|
812
1219
|
}
|
|
813
1220
|
|
|
814
1221
|
|
|
815
1222
|
} catch (error) {
|
|
816
|
-
|
|
1223
|
+
;
|
|
1224
|
+
logger.error(`Error occurred: ${error.stack} ${error}`);
|
|
817
1225
|
}
|
|
818
1226
|
}
|
|
819
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
|
+
|
|
820
1237
|
console.log("");
|
|
821
1238
|
console.log("########################################################")
|
|
822
1239
|
console.log("")
|
|
823
|
-
logger.info('
|
|
1240
|
+
logger.info('Subjects Data Migration Completed');
|
|
824
1241
|
logger.info(`Total successful Subjects records created: ${createdCounter}/${createdCounter}`);
|
|
825
1242
|
logger.info(`Total Subjects Error Records: ${errorCounter}/${errorCounter}`);
|
|
826
1243
|
console.log("")
|
|
@@ -835,7 +1252,8 @@ const server = {
|
|
|
835
1252
|
return totalSummary
|
|
836
1253
|
|
|
837
1254
|
} catch (error) {
|
|
838
|
-
|
|
1255
|
+
;
|
|
1256
|
+
logger.error(`Error occurred: ${error.stack} ${error}`);
|
|
839
1257
|
|
|
840
1258
|
}
|
|
841
1259
|
},
|
|
@@ -857,10 +1275,22 @@ const server = {
|
|
|
857
1275
|
|
|
858
1276
|
|
|
859
1277
|
const db_schema = schema
|
|
860
|
-
// 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
|
|
861
1279
|
// let maxId = maxIds|| 0;
|
|
862
1280
|
// await db.sequelize.query(`ALTER SEQUENCE ${db_schema}."Schedules__id_seq" RESTART WITH ${maxId + 1}`);
|
|
863
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
|
+
|
|
864
1294
|
for (let i = 0; i < scheduleApi.length; i++){
|
|
865
1295
|
try {
|
|
866
1296
|
let _schedule = scheduleApi[i]
|
|
@@ -894,8 +1324,6 @@ const server = {
|
|
|
894
1324
|
let createdById = userMail._id
|
|
895
1325
|
|
|
896
1326
|
|
|
897
|
-
let from = null
|
|
898
|
-
let to = null
|
|
899
1327
|
let days = null
|
|
900
1328
|
|
|
901
1329
|
if (dayHandler.length > 1) {
|
|
@@ -904,57 +1332,82 @@ const server = {
|
|
|
904
1332
|
days = dayMappings[dayHandler[0]];
|
|
905
1333
|
}
|
|
906
1334
|
|
|
907
|
-
|
|
908
|
-
let
|
|
909
|
-
|
|
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({
|
|
910
1362
|
name: _schedule?.schedule,
|
|
911
1363
|
from : stFormat??from,
|
|
912
1364
|
to : etFormat??to,
|
|
913
|
-
days
|
|
914
|
-
},
|
|
915
|
-
defaults:{
|
|
1365
|
+
days,
|
|
916
1366
|
modifiedById,
|
|
917
1367
|
createdById
|
|
918
|
-
}
|
|
919
|
-
})
|
|
920
|
-
if (created){
|
|
921
|
-
logger.info(`New schedule record created ${createdCounter + 1}/${createdCounter + 1}: [${record.from} - ${record.to}] ${record.name} `)
|
|
922
|
-
createdCounter++;
|
|
923
|
-
}
|
|
924
|
-
else {
|
|
925
|
-
const errorMsg = `Record schedule already exists: [${record.from} - ${record.to}] ${record.name}`;
|
|
926
1368
|
|
|
927
|
-
|
|
928
|
-
|
|
929
|
-
|
|
930
|
-
|
|
931
|
-
}
|
|
1369
|
+
// migratedAt,
|
|
1370
|
+
// migratedTable,
|
|
1371
|
+
// referenceId,
|
|
1372
|
+
// isMigrated
|
|
1373
|
+
})
|
|
932
1374
|
}
|
|
933
|
-
|
|
934
1375
|
} catch (error) {
|
|
935
|
-
|
|
1376
|
+
;
|
|
1377
|
+
logger.error(`Error occurred: ${error.stack} ${error}`);
|
|
936
1378
|
}
|
|
937
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
|
+
}
|
|
938
1389
|
|
|
939
1390
|
console.log("");
|
|
940
1391
|
console.log("########################################################")
|
|
941
1392
|
console.log("")
|
|
942
|
-
logger.info('
|
|
1393
|
+
logger.info('Schedule Data Migration Completed');
|
|
943
1394
|
logger.info(`Total successful Schedule records created: ${createdCounter}/${createdCounter}`);
|
|
944
1395
|
logger.info(`Total Schedule Error Records: ${errorCounter}/${errorCounter}`);
|
|
1396
|
+
logger.info(`Total records: ${createdCounter + errorCounter}`);
|
|
945
1397
|
console.log("")
|
|
946
1398
|
console.log("########################################################")
|
|
947
1399
|
console.log("")
|
|
948
1400
|
|
|
949
1401
|
let totalSummary = {
|
|
950
|
-
itemLength:
|
|
1402
|
+
itemLength: createdCounter + errorCounter,
|
|
951
1403
|
error: errorCounter,
|
|
952
1404
|
success: createdCounter
|
|
953
1405
|
}
|
|
954
1406
|
return totalSummary
|
|
955
1407
|
|
|
956
1408
|
} catch (error) {
|
|
957
|
-
|
|
1409
|
+
;
|
|
1410
|
+
logger.error(`Error occurred: ${error.stack} ${error}`);
|
|
958
1411
|
}
|
|
959
1412
|
},
|
|
960
1413
|
|
|
@@ -974,7 +1427,10 @@ const server = {
|
|
|
974
1427
|
const semesterSeq = await Semesters.findAll()
|
|
975
1428
|
const acadYearSeq = await AcademicYears.findAll()
|
|
976
1429
|
|
|
977
|
-
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' } });
|
|
978
1434
|
|
|
979
1435
|
let createdCounter = 0
|
|
980
1436
|
let errorCounter = 0
|
|
@@ -982,19 +1438,30 @@ const server = {
|
|
|
982
1438
|
|
|
983
1439
|
const emailDomain = 'default.msc.edu.ph';
|
|
984
1440
|
|
|
985
|
-
|
|
986
1441
|
const db_schema = schema
|
|
987
|
-
// 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
|
|
988
1443
|
// let maxId = maxIds|| 0;
|
|
989
1444
|
// await db.sequelize.query(`ALTER SEQUENCE ${db_schema}."Students__id_seq" RESTART WITH ${maxId + 1}`);
|
|
990
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
|
+
|
|
991
1459
|
const {data} = studentApi
|
|
1460
|
+
|
|
992
1461
|
for (let i = 0; i < data.length; i++){
|
|
993
1462
|
try {
|
|
994
|
-
|
|
995
1463
|
let _student = data[i]
|
|
996
1464
|
|
|
997
|
-
|
|
998
1465
|
let _campus = campusSeq.find(a => a.name === _student?.campus)
|
|
999
1466
|
let _course = courseSeq.find(b => b.name === _student?.course)
|
|
1000
1467
|
let _college = collegeSeq.find(c => c.name === _student?.college)
|
|
@@ -1006,14 +1473,8 @@ const server = {
|
|
|
1006
1473
|
let modifiedById = userMail._id
|
|
1007
1474
|
let createdById = userMail._id
|
|
1008
1475
|
|
|
1009
|
-
let campusDefault = 999999
|
|
1010
|
-
let courseDefault = 999999
|
|
1011
|
-
let collegeDefault = 999999
|
|
1012
|
-
|
|
1013
|
-
|
|
1014
1476
|
let fromPrompts = await Picked()
|
|
1015
|
-
|
|
1016
|
-
|
|
1477
|
+
|
|
1017
1478
|
// let semester = "2nd Semester"
|
|
1018
1479
|
let semester = fromPrompts.semester
|
|
1019
1480
|
let yearsFrom = fromPrompts.yearFrom
|
|
@@ -1022,65 +1483,88 @@ const server = {
|
|
|
1022
1483
|
let _semester = semesterSeq.find(sem => sem.code === semester)
|
|
1023
1484
|
let _acadYear = acadYearSeq.find(yr => yr.from === parseInt(yearsFrom) && yr.to === parseInt(yearsTo))
|
|
1024
1485
|
|
|
1025
|
-
|
|
1026
|
-
let
|
|
1027
|
-
|
|
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({
|
|
1028
1518
|
studentNumber: _student?.student_number,
|
|
1029
1519
|
firstName: _student?.first_name,
|
|
1030
1520
|
lastName: _student?.last_name,
|
|
1031
1521
|
middleName: _student?.middle_name,
|
|
1032
|
-
},
|
|
1033
|
-
defaults:{
|
|
1034
1522
|
email: email,
|
|
1035
|
-
courseId: _course?._id??courseDefault,
|
|
1036
|
-
campusId: _campus?._id??campusDefault,
|
|
1037
|
-
collegeId: _college?._id??collegeDefault,
|
|
1523
|
+
courseId: _course?._id??courseDefault?._id,
|
|
1524
|
+
campusId: _campus?._id??campusDefault?._id,
|
|
1525
|
+
collegeId: _college?._id??collegeDefault?._id,
|
|
1038
1526
|
admittedYearId: _acadYear?._id ?? null,
|
|
1039
1527
|
admittedSemId: _semester?._id ?? null,
|
|
1040
1528
|
modifiedById,
|
|
1041
|
-
createdById
|
|
1042
|
-
}
|
|
1043
|
-
})
|
|
1044
|
-
if (created){
|
|
1045
|
-
logger.info(`New student record created ${createdCounter + 1}/${createdCounter + 1}: [${record.studentNumber}] ${record.lastName}, ${record.firstName} ${record.middleName} `)
|
|
1046
|
-
createdCounter++;
|
|
1047
|
-
}
|
|
1048
|
-
else {
|
|
1049
|
-
|
|
1050
|
-
const errorMsg = `Record student already exists: [${record.studentNumber}] ${record.lastName}, ${record.firstName} ${record.middleName}`;
|
|
1051
|
-
|
|
1052
|
-
if (!uniqueErrors.has(errorMsg)) {
|
|
1053
|
-
logger.error(`${errorCounter + 1}/${errorCounter + 1} ${errorMsg}`);
|
|
1054
|
-
uniqueErrors.add(errorMsg);
|
|
1055
|
-
errorCounter++;
|
|
1056
|
-
}
|
|
1057
|
-
|
|
1529
|
+
createdById,
|
|
1530
|
+
})
|
|
1058
1531
|
}
|
|
1059
1532
|
|
|
1060
1533
|
} catch (error) {
|
|
1061
|
-
|
|
1534
|
+
logger.error(`Error occurred: ${error.stack} ${error}`);
|
|
1062
1535
|
}
|
|
1063
1536
|
}
|
|
1064
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
|
+
|
|
1065
1547
|
console.log("");
|
|
1066
1548
|
console.log("########################################################")
|
|
1067
1549
|
console.log("")
|
|
1068
|
-
logger.info('
|
|
1550
|
+
logger.info('Student Data Migration Completed');
|
|
1069
1551
|
logger.info(`Total successful Student records created: ${createdCounter}/${createdCounter}`);
|
|
1070
1552
|
logger.info(`Total Student Error Records: ${errorCounter}/${errorCounter}`);
|
|
1553
|
+
logger.info(`Total records: ${createdCounter + errorCounter}`);
|
|
1071
1554
|
console.log("")
|
|
1072
1555
|
console.log("########################################################")
|
|
1073
1556
|
console.log("")
|
|
1074
1557
|
|
|
1075
1558
|
let totalSummary = {
|
|
1076
|
-
itemLength:
|
|
1559
|
+
itemLength: createdCounter + errorCounter,
|
|
1077
1560
|
error: errorCounter,
|
|
1078
1561
|
success: createdCounter
|
|
1079
1562
|
}
|
|
1080
1563
|
return totalSummary
|
|
1081
1564
|
|
|
1082
1565
|
} catch (error) {
|
|
1083
|
-
|
|
1566
|
+
;
|
|
1567
|
+
logger.error(`Error occurred: ${error.stack} ${error}`);
|
|
1084
1568
|
|
|
1085
1569
|
}
|
|
1086
1570
|
},
|
|
@@ -1106,9 +1590,8 @@ const server = {
|
|
|
1106
1590
|
const acadYearSeq = await AcademicYears.findAll()
|
|
1107
1591
|
const acadDeptSeq = await AcademicDepartments.findAll()
|
|
1108
1592
|
|
|
1109
|
-
|
|
1110
1593
|
const userMail = await Users.findOne({ where: { email: 'ccci_integrator@gmail.com' } });
|
|
1111
|
-
|
|
1594
|
+
|
|
1112
1595
|
let createdCounter = 0
|
|
1113
1596
|
let errorCounter = 0
|
|
1114
1597
|
let uniqueErrors = new Set()
|
|
@@ -1119,7 +1602,21 @@ const server = {
|
|
|
1119
1602
|
// let maxId = maxIds|| 0;
|
|
1120
1603
|
// await db.sequelize.query(`ALTER SEQUENCE ${db_schema}."Sections__id_seq" RESTART WITH ${maxId + 1}`);
|
|
1121
1604
|
|
|
1122
|
-
|
|
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
|
+
|
|
1123
1620
|
for (let i = 0; i < student.length; i++) {
|
|
1124
1621
|
try {
|
|
1125
1622
|
|
|
@@ -1159,27 +1656,60 @@ const server = {
|
|
|
1159
1656
|
let code = sections ?? 'CODE'
|
|
1160
1657
|
code = code.split(/\s+/).map((word) => word.charAt(0).toUpperCase()).join('')
|
|
1161
1658
|
|
|
1162
|
-
|
|
1163
|
-
|
|
1164
|
-
|
|
1165
|
-
|
|
1166
|
-
|
|
1167
|
-
|
|
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))
|
|
1168
1665
|
|
|
1169
1666
|
let modifiedById = userMail._id;
|
|
1170
1667
|
let createdById = userMail._id;
|
|
1171
1668
|
|
|
1172
|
-
let defaultSub = 99999
|
|
1173
|
-
let defaultInst = 99999
|
|
1174
|
-
|
|
1175
1669
|
let classType = 'SYNCHRONOUS'
|
|
1176
|
-
|
|
1177
|
-
let
|
|
1178
|
-
|
|
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({
|
|
1179
1709
|
name: sections,
|
|
1180
1710
|
code,
|
|
1181
|
-
subjectId: _subjects?._id??
|
|
1182
|
-
instructorId: _instructors?._id??
|
|
1711
|
+
subjectId: _subjects?._id??null,
|
|
1712
|
+
instructorId: _instructors?._id??null,
|
|
1183
1713
|
classType,
|
|
1184
1714
|
semesterId: _semester?._id??null,
|
|
1185
1715
|
academicYearId: _acadYear?._id??null,
|
|
@@ -1188,58 +1718,46 @@ const server = {
|
|
|
1188
1718
|
departmentId: _insdepartment?._id??null,
|
|
1189
1719
|
modifiedById,
|
|
1190
1720
|
createdById,
|
|
1191
|
-
|
|
1192
|
-
},
|
|
1193
|
-
defaults: {
|
|
1194
|
-
// classType,
|
|
1195
|
-
// semesterId: _semester?._id??null,
|
|
1196
|
-
// academicYearId: _acadYear?._id??null,
|
|
1197
|
-
// courseId: _course?._id??null,
|
|
1198
|
-
// campusId: _campus?._id??null,
|
|
1199
|
-
// modifiedById,
|
|
1200
|
-
// createdById,
|
|
1201
|
-
|
|
1202
|
-
}
|
|
1203
|
-
});
|
|
1204
|
-
|
|
1205
|
-
if (created) {
|
|
1206
|
-
logger.info(`New section record created ${createdCounter + 1}/${createdCounter + 1}: ${record.name} `);
|
|
1207
|
-
createdCounter++;
|
|
1208
|
-
} else {
|
|
1209
|
-
|
|
1210
|
-
const errorMsg = `Record section already exists: ${record.name} `;
|
|
1211
|
-
|
|
1212
|
-
if (!uniqueErrors.has(errorMsg)) {
|
|
1213
|
-
logger.error(`${errorCounter + 1}/${errorCounter + 1} ${errorMsg}`);
|
|
1214
|
-
uniqueErrors.add(errorMsg);
|
|
1215
|
-
errorCounter++;
|
|
1216
|
-
}
|
|
1721
|
+
})
|
|
1217
1722
|
}
|
|
1723
|
+
|
|
1218
1724
|
}
|
|
1219
1725
|
} catch (error) {
|
|
1220
|
-
|
|
1726
|
+
;
|
|
1727
|
+
logger.error(`Error occurred: ${error.stack} ${error}`);
|
|
1221
1728
|
}
|
|
1222
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
|
+
}
|
|
1223
1739
|
|
|
1224
1740
|
console.log("");
|
|
1225
1741
|
console.log("########################################################");
|
|
1226
1742
|
console.log("");
|
|
1227
|
-
logger.info('
|
|
1743
|
+
logger.info('Section Data Migration Completed');
|
|
1228
1744
|
logger.info(`Total successful Section records created: ${createdCounter}/${createdCounter}`);
|
|
1229
1745
|
logger.info(`Total Section Error Records: ${errorCounter}/${errorCounter}`);
|
|
1746
|
+
logger.info(`Total records: ${createdCounter + errorCounter}`);
|
|
1230
1747
|
console.log("");
|
|
1231
1748
|
console.log("########################################################");
|
|
1232
1749
|
console.log("");
|
|
1233
1750
|
|
|
1234
1751
|
let totalSummary = {
|
|
1235
|
-
itemLength:
|
|
1752
|
+
itemLength: createdCounter + errorCounter,
|
|
1236
1753
|
error: errorCounter,
|
|
1237
1754
|
success: createdCounter
|
|
1238
1755
|
};
|
|
1239
1756
|
return totalSummary;
|
|
1240
1757
|
|
|
1241
1758
|
} catch (error) {
|
|
1242
|
-
|
|
1759
|
+
;
|
|
1760
|
+
logger.error(`Error occurred: ${error.stack} ${error}`);
|
|
1243
1761
|
}
|
|
1244
1762
|
},
|
|
1245
1763
|
|
|
@@ -1275,6 +1793,21 @@ const server = {
|
|
|
1275
1793
|
// let maxId = maxIds|| 0;
|
|
1276
1794
|
// await db.sequelize.query(`ALTER SEQUENCE ${db_schema}."EnrolledStudents__id_seq" RESTART WITH ${maxId + 1}`);
|
|
1277
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
|
+
|
|
1278
1811
|
|
|
1279
1812
|
for (let i = 0; i < studentApi.length; i++){
|
|
1280
1813
|
try {
|
|
@@ -1328,7 +1861,6 @@ const server = {
|
|
|
1328
1861
|
continue;
|
|
1329
1862
|
}
|
|
1330
1863
|
|
|
1331
|
-
|
|
1332
1864
|
let totalPoints = 100
|
|
1333
1865
|
let finalG = fGrade
|
|
1334
1866
|
let gradePoints = ((-4.0 / totalPoints) * parseFloat (finalG) + 5.0).toFixed(2)
|
|
@@ -1341,9 +1873,42 @@ const server = {
|
|
|
1341
1873
|
}
|
|
1342
1874
|
let remarks = rmarks?.toUpperCase()??null
|
|
1343
1875
|
|
|
1344
|
-
|
|
1345
|
-
let
|
|
1346
|
-
|
|
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({
|
|
1347
1912
|
studentId: student?._id,
|
|
1348
1913
|
courseId: course?._id,
|
|
1349
1914
|
instructorId: _instructor?._id??null,
|
|
@@ -1356,50 +1921,45 @@ const server = {
|
|
|
1356
1921
|
remarks,
|
|
1357
1922
|
createdById,
|
|
1358
1923
|
modifiedById,
|
|
1359
|
-
}
|
|
1360
|
-
default:{
|
|
1361
|
-
|
|
1362
|
-
}
|
|
1363
|
-
})
|
|
1364
|
-
|
|
1365
|
-
if (created) {
|
|
1366
|
-
logger.info(`New enrolled student record created ${createdCounter + 1}/${createdCounter + 1}: studentId = [${record.studentId}], sectionId = [${record.sectionId}], instructorId = [${record.instructorId}]`);
|
|
1367
|
-
createdCounter++;
|
|
1368
|
-
} else {
|
|
1369
|
-
|
|
1370
|
-
const errorMsg = `Record enrolled student already exists: studentId = [${record.studentId}], sectionId = [${record.sectionId}], instructorId = [${record.instructorId}]`;
|
|
1371
|
-
|
|
1372
|
-
if (!uniqueErrors.has(errorMsg)) {
|
|
1373
|
-
logger.error(`${errorCounter + 1}/${errorCounter + 1} ${errorMsg}`);
|
|
1374
|
-
uniqueErrors.add(errorMsg);
|
|
1375
|
-
errorCounter++;
|
|
1376
|
-
}
|
|
1924
|
+
})
|
|
1377
1925
|
}
|
|
1378
1926
|
}
|
|
1379
1927
|
} catch (error) {
|
|
1380
|
-
|
|
1928
|
+
;
|
|
1929
|
+
logger.error(`Error occurred: ${error.stack} ${error}`);
|
|
1381
1930
|
}
|
|
1382
1931
|
}
|
|
1383
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
|
+
|
|
1384
1942
|
console.log("");
|
|
1385
1943
|
console.log("########################################################")
|
|
1386
1944
|
console.log("")
|
|
1387
|
-
logger.info('
|
|
1945
|
+
logger.info('Enrolled Student Data Migration Completed');
|
|
1388
1946
|
logger.info(`Total successful Enrolled Student records created: ${createdCounter}/${createdCounter}`);
|
|
1389
1947
|
logger.info(`Total Enrolled Student Error Records: ${errorCounter}/${errorCounter}`);
|
|
1948
|
+
logger.info(`Total records: ${createdCounter + errorCounter}`);
|
|
1390
1949
|
console.log("")
|
|
1391
1950
|
console.log("########################################################")
|
|
1392
1951
|
console.log("")
|
|
1393
1952
|
|
|
1394
1953
|
let totalSummary = {
|
|
1395
|
-
itemLength:
|
|
1954
|
+
itemLength: createdCounter + errorCounter,
|
|
1396
1955
|
error: errorCounter,
|
|
1397
1956
|
success: createdCounter
|
|
1398
1957
|
}
|
|
1399
1958
|
return totalSummary
|
|
1400
1959
|
|
|
1401
1960
|
} catch (error) {
|
|
1402
|
-
|
|
1961
|
+
;
|
|
1962
|
+
logger.error(`Error occurred: ${error.stack} ${error}`);
|
|
1403
1963
|
|
|
1404
1964
|
}
|
|
1405
1965
|
},
|
|
@@ -1415,7 +1975,7 @@ async function runServerFunctions() {
|
|
|
1415
1975
|
}
|
|
1416
1976
|
}
|
|
1417
1977
|
} catch (error) {
|
|
1418
|
-
logger.error(`Error occurred: ${error.stack
|
|
1978
|
+
logger.error(`Error occurred: ${error.stack} ${error}`);
|
|
1419
1979
|
}
|
|
1420
1980
|
console.log("");
|
|
1421
1981
|
console.log("########################################################");
|