326 lines
11 KiB
JavaScript
326 lines
11 KiB
JavaScript
const dotenv = require("dotenv");
|
|
const path = require("path");
|
|
const mariadb = require("mariadb");
|
|
|
|
dotenv.config({ path: path.resolve(process.cwd(), ".env") });
|
|
|
|
const {
|
|
DB_HOST,
|
|
DB_PORT,
|
|
DB_USERNAME,
|
|
DB_PASSWORD,
|
|
DB_DATABASE,
|
|
DB_CONNECT_TIMEOUT_MS,
|
|
DB_SOCKET_TIMEOUT_MS,
|
|
} = process.env;
|
|
|
|
function parseTimeout(value, fallback) {
|
|
if (value === undefined || value === null || value === "") {
|
|
return fallback;
|
|
}
|
|
|
|
const parsed = Number(value);
|
|
if (!Number.isFinite(parsed) || parsed <= 0) {
|
|
throw new Error(`Invalid timeout value: ${value}`);
|
|
}
|
|
|
|
return parsed;
|
|
}
|
|
|
|
function parseArgs(argv) {
|
|
const args = {
|
|
dryRun: false,
|
|
actorId: null,
|
|
courseId: null,
|
|
memberId: null,
|
|
};
|
|
|
|
for (let i = 2; i < argv.length; i++) {
|
|
const token = argv[i];
|
|
if (token === "--dry-run") {
|
|
args.dryRun = true;
|
|
continue;
|
|
}
|
|
|
|
if (token.startsWith("--actor=")) {
|
|
args.actorId = Number(token.split("=")[1]);
|
|
continue;
|
|
}
|
|
|
|
if (token.startsWith("--course=")) {
|
|
args.courseId = Number(token.split("=")[1]);
|
|
continue;
|
|
}
|
|
|
|
if (token.startsWith("--member=")) {
|
|
args.memberId = Number(token.split("=")[1]);
|
|
continue;
|
|
}
|
|
}
|
|
|
|
if (args.actorId !== null && Number.isNaN(args.actorId)) {
|
|
throw new Error("--actor must be a number");
|
|
}
|
|
if (args.courseId !== null && Number.isNaN(args.courseId)) {
|
|
throw new Error("--course must be a number");
|
|
}
|
|
if (args.memberId !== null && Number.isNaN(args.memberId)) {
|
|
throw new Error("--member must be a number");
|
|
}
|
|
|
|
return args;
|
|
}
|
|
|
|
function buildScopeClause(args, tableAlias = "") {
|
|
const prefix = tableAlias ? `${tableAlias}.` : "";
|
|
const clauses = [];
|
|
const params = [];
|
|
|
|
if (args.courseId !== null) {
|
|
clauses.push(`${prefix}course_id = ?`);
|
|
params.push(args.courseId);
|
|
}
|
|
|
|
if (args.memberId !== null) {
|
|
clauses.push(`${prefix}member_id = ?`);
|
|
params.push(args.memberId);
|
|
}
|
|
|
|
if (!clauses.length) {
|
|
return { sql: "", params };
|
|
}
|
|
|
|
return {
|
|
sql: ` AND ${clauses.join(" AND ")}`,
|
|
params,
|
|
};
|
|
}
|
|
|
|
function key(memberId, courseId) {
|
|
return `${memberId}:${courseId}`;
|
|
}
|
|
|
|
(async () => {
|
|
const args = parseArgs(process.argv);
|
|
|
|
const conn = await mariadb.createConnection({
|
|
host: DB_HOST,
|
|
port: Number(DB_PORT),
|
|
user: DB_USERNAME,
|
|
password: DB_PASSWORD,
|
|
database: DB_DATABASE,
|
|
multipleStatements: false,
|
|
connectTimeout: parseTimeout(DB_CONNECT_TIMEOUT_MS, 10000),
|
|
socketTimeout: parseTimeout(DB_SOCKET_TIMEOUT_MS, 60000),
|
|
});
|
|
|
|
try {
|
|
const schemaCheck = await conn.query("SHOW COLUMNS FROM members_qualifications LIKE 'course_id';");
|
|
if (!schemaCheck.length) {
|
|
throw new Error("members_qualifications.course_id does not exist. Run qualification migration first.");
|
|
}
|
|
|
|
const scoped = buildScopeClause(args);
|
|
const evidenceScopedClauses = [];
|
|
const evidenceScopedParams = [];
|
|
if (args.courseId !== null) {
|
|
evidenceScopedClauses.push("e.course_id = ?");
|
|
evidenceScopedParams.push(args.courseId);
|
|
}
|
|
if (args.memberId !== null) {
|
|
evidenceScopedClauses.push("ca.attendee_id = ?");
|
|
evidenceScopedParams.push(args.memberId);
|
|
}
|
|
const evidenceScopedSql = evidenceScopedClauses.length
|
|
? ` AND ${evidenceScopedClauses.join(" AND ")}`
|
|
: "";
|
|
|
|
const evidenceRows = await conn.query(
|
|
`SELECT
|
|
ca.attendee_id AS member_id,
|
|
e.course_id,
|
|
e.id AS course_event_id,
|
|
e.event_date,
|
|
IFNULL(e.is_challenge, 0) AS is_challenge,
|
|
IFNULL(e.hasBookwork, 0) AS event_has_bookwork,
|
|
IFNULL(e.hasQual, 0) AS event_has_qual,
|
|
ca.passed_bookwork,
|
|
ca.passed_qual,
|
|
IFNULL(c.hasBookwork, 0) AS course_has_bookwork,
|
|
IFNULL(c.hasQual, 0) AS course_has_qual
|
|
FROM course_events e
|
|
INNER JOIN courses c ON c.id = e.course_id
|
|
INNER JOIN course_attendees ca ON ca.course_event_id = e.id
|
|
WHERE ca.attendee_role_id = 2
|
|
AND (e.deleted IS NULL OR e.deleted = 0)
|
|
${evidenceScopedSql}
|
|
ORDER BY ca.attendee_id ASC, e.course_id ASC, e.event_date DESC, e.id DESC;`,
|
|
evidenceScopedParams
|
|
);
|
|
|
|
const aggregateByPair = new Map();
|
|
for (const row of evidenceRows) {
|
|
const memberId = Number(row.member_id);
|
|
const courseId = Number(row.course_id);
|
|
const mapKey = key(memberId, courseId);
|
|
const bookworkEvidence = Number(row.event_has_bookwork) === 1 && Number(row.passed_bookwork) === 1;
|
|
const qualEvidence = Number(row.event_has_qual) === 1 && Number(row.passed_qual) === 1;
|
|
const challengeQualEvidence = Number(row.is_challenge) === 1 && Number(row.event_has_qual) === 1 && Number(row.passed_qual) === 1;
|
|
|
|
const existing = aggregateByPair.get(mapKey) || {
|
|
memberId,
|
|
courseId,
|
|
courseHasBookwork: Number(row.course_has_bookwork) === 1,
|
|
courseHasQual: Number(row.course_has_qual) === 1,
|
|
hasBookworkPass: false,
|
|
hasQualPass: false,
|
|
hasChallengeQualPass: false,
|
|
latestEvidence: null,
|
|
};
|
|
|
|
existing.hasBookworkPass = existing.hasBookworkPass || bookworkEvidence;
|
|
existing.hasQualPass = existing.hasQualPass || qualEvidence;
|
|
existing.hasChallengeQualPass = existing.hasChallengeQualPass || challengeQualEvidence;
|
|
|
|
if (bookworkEvidence || qualEvidence || challengeQualEvidence) {
|
|
const nextLatest = {
|
|
courseEventId: Number(row.course_event_id),
|
|
eventDate: row.event_date,
|
|
};
|
|
|
|
if (!existing.latestEvidence) {
|
|
existing.latestEvidence = nextLatest;
|
|
} else {
|
|
const currentDate = new Date(existing.latestEvidence.eventDate).getTime();
|
|
const nextDate = new Date(nextLatest.eventDate).getTime();
|
|
if (nextDate > currentDate || (nextDate === currentDate && nextLatest.courseEventId > existing.latestEvidence.courseEventId)) {
|
|
existing.latestEvidence = nextLatest;
|
|
}
|
|
}
|
|
}
|
|
|
|
aggregateByPair.set(mapKey, existing);
|
|
}
|
|
|
|
const latestByPair = new Map();
|
|
for (const [mapKey, pair] of aggregateByPair.entries()) {
|
|
const hasBookwork = pair.courseHasBookwork;
|
|
const hasQual = pair.courseHasQual;
|
|
|
|
let qualifies = false;
|
|
if (hasBookwork && hasQual) {
|
|
qualifies = (pair.hasBookworkPass && pair.hasQualPass) || pair.hasChallengeQualPass;
|
|
} else if (hasBookwork && !hasQual) {
|
|
qualifies = pair.hasBookworkPass;
|
|
} else if (!hasBookwork && hasQual) {
|
|
qualifies = pair.hasQualPass;
|
|
}
|
|
|
|
if (qualifies && pair.latestEvidence) {
|
|
latestByPair.set(mapKey, {
|
|
memberId: pair.memberId,
|
|
courseId: pair.courseId,
|
|
courseEventId: pair.latestEvidence.courseEventId,
|
|
eventDate: pair.latestEvidence.eventDate,
|
|
});
|
|
}
|
|
}
|
|
|
|
const currentRows = await conn.query(
|
|
`SELECT member_id, course_id
|
|
FROM members_qualifications
|
|
WHERE active = 1
|
|
AND (deleted IS NULL OR deleted = 0)
|
|
${scoped.sql};`,
|
|
scoped.params
|
|
);
|
|
|
|
const currentKeys = new Set(currentRows.map((r) => key(Number(r.member_id), Number(r.course_id))));
|
|
const nextKeys = new Set(Array.from(latestByPair.keys()));
|
|
|
|
let wouldDeactivate = 0;
|
|
currentKeys.forEach((k) => {
|
|
if (!nextKeys.has(k)) {
|
|
wouldDeactivate++;
|
|
}
|
|
});
|
|
|
|
const summary = {
|
|
dryRun: args.dryRun,
|
|
scope: {
|
|
memberId: args.memberId,
|
|
courseId: args.courseId,
|
|
},
|
|
actorId: args.actorId,
|
|
historicalPassingRows: evidenceRows.length,
|
|
activePairsComputed: latestByPair.size,
|
|
currentlyActivePairs: currentRows.length,
|
|
wouldDeactivate,
|
|
};
|
|
|
|
if (args.dryRun) {
|
|
console.log("Qualification backfill dry run summary:");
|
|
console.log(JSON.stringify(summary, null, 2));
|
|
return;
|
|
}
|
|
|
|
await conn.beginTransaction();
|
|
|
|
const deactivateReason = "Backfill recompute from historical training reports";
|
|
|
|
const deactivateResult = await conn.query(
|
|
`UPDATE members_qualifications mq
|
|
SET mq.active = 0,
|
|
mq.revoked_by_id = ?,
|
|
mq.revoked_reason = ?,
|
|
mq.revoked_at = UTC_TIMESTAMP(),
|
|
mq.updated_at = current_timestamp()
|
|
WHERE mq.active = 1
|
|
AND (mq.deleted IS NULL OR mq.deleted = 0)
|
|
${buildScopeClause(args, "mq").sql};`,
|
|
[args.actorId, deactivateReason].concat(buildScopeClause(args, "mq").params)
|
|
);
|
|
|
|
let upserts = 0;
|
|
for (const item of latestByPair.values()) {
|
|
await conn.query(
|
|
`INSERT INTO members_qualifications
|
|
(member_id, course_id, event_date, active, awarded_by_id, revoked_by_id, revoked_reason, revoked_at, source_course_event_id, deleted)
|
|
VALUES (?, ?, ?, 1, ?, NULL, NULL, NULL, ?, 0)
|
|
ON DUPLICATE KEY UPDATE
|
|
event_date = VALUES(event_date),
|
|
active = 1,
|
|
awarded_by_id = VALUES(awarded_by_id),
|
|
revoked_by_id = NULL,
|
|
revoked_reason = NULL,
|
|
revoked_at = NULL,
|
|
source_course_event_id = VALUES(source_course_event_id),
|
|
deleted = 0,
|
|
updated_at = current_timestamp();`,
|
|
[item.memberId, item.courseId, item.eventDate, args.actorId, item.courseEventId]
|
|
);
|
|
upserts++;
|
|
}
|
|
|
|
await conn.commit();
|
|
|
|
console.log("Qualification backfill complete:");
|
|
console.log(JSON.stringify({
|
|
...summary,
|
|
deactivatedRows: deactivateResult.affectedRows,
|
|
upserts,
|
|
}, null, 2));
|
|
} catch (error) {
|
|
try {
|
|
await conn.rollback();
|
|
} catch (_ignored) {
|
|
// No-op rollback failure.
|
|
}
|
|
console.error("Qualification backfill failed:");
|
|
console.error(error);
|
|
process.exitCode = 1;
|
|
} finally {
|
|
await conn.end();
|
|
}
|
|
})();
|