@phenyxhealth/importer 1.1.7

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@phenyxhealth/importer",
+  "version": "1.1.7",
+  "type": "module",
+  "description": "Imports a Phenyx-compatible JSON file with patients into a PhenyxHealth instance.",
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "./src/index.js",
+  "bin": {
+    "importer": "./src/index.js"
+  },
+  "scripts": {
+    "dev": "node ./src/index.js test/importer-config.json"
+  },
+  "author": "Diego M. Béjar",
+  "license": "ISC",
+  "dependencies": {
+    "@dmbejar/json-files": "^1.1.6",
+    "uuid": "13.0.0"
+  }
+}

package/src/controllers/doctors.js

@@ -0,0 +1,26 @@
+import ApiInstance from "../services/phenyxApiInstance.js";
+
+const beSureDoctorExists = async (toBe) => {
+    const currentDoctors = await ApiInstance.getHumanResources();
+
+    for (const doctor of toBe) {
+        const doctorName = doctor.name;
+        const doctorTypeId = ApiInstance.getGlobalInfoElementId(ApiInstance.globalTypes.humanResources, ApiInstance.globalTypes.humanResources.values[doctor.hrGroup]);
+        const doctorExists = !!currentDoctors
+            .find(item => item.name === doctorName && item.typeId === doctorTypeId);
+
+        if (!doctorExists) {
+            console.log(`Adding ${doctor.name}...`);
+            await ApiInstance.createHumanResource({
+                name: doctor.name,
+                typeId: doctorTypeId,
+            });
+        }
+    }
+
+    return await ApiInstance.getHumanResources();
+};
+
+export {
+    beSureDoctorExists,
+};

package/src/controllers/global.js

@@ -0,0 +1,84 @@
+import { v4 } from 'uuid';
+import ApiInstance from '../services/phenyxApiInstance.js';
+import { getContrastingColor } from '../utils/colors.js';
+
+const checkGlobals = async (mustBe, extraValues = []) => {
+    const {
+        name,
+        values = {},
+    } = mustBe;
+
+    // Sacar los valores de global
+    const currentContent = ApiInstance.getGlobalInfo(mustBe);
+
+    if (!currentContent) throw new Error(`Global info ${name} not found`);
+
+    // Añadir los valores extra
+    for (const extraValue of extraValues) {
+        if (!values[extraValue]) {
+            values[extraValue] = extraValue;
+        }
+    }
+
+    // Asegurarnos que existen los tipos especificadas
+    const valuesToCheck = [];
+    for (const key of Object.keys(values)) {
+        valuesToCheck.push(values[key]);
+    }
+
+    // Meter la info
+    if (valuesToCheck.length) await beSureGlobalExists(currentContent, valuesToCheck);
+};
+
+const beSureGlobalExists = async (currentList, toBeList) => {
+    const {
+        id,
+        name,
+        elements,
+    } = currentList;
+
+    let listUpdated = false;
+
+    for (const element of currentList.elements) {
+        if (!element.modality) {
+            element.modality = '';
+        }
+    }
+
+    for (const item of toBeList) {
+        const element = elements.find(element => element.name === item && !element.isDeleted);
+
+        if (!element) {
+            console.log(`Adding ${item} to ${name}...`);
+            const creationDate = new Date().toISOString();
+            elements.push({
+                id: v4(),
+                color: getContrastingColor(),
+                name: item,
+                createdAt: creationDate,
+                updatedAt: creationDate,
+                isDeleted: false,
+                modality: '',
+            })
+            listUpdated = true;
+            continue;
+        }
+
+        if (!element.color) {
+            element.color = getContrastingColor();
+            element.updatedAt = new Date().toISOString();
+            listUpdated = true;
+        }
+
+        if(!element.modality) {
+            element.modality = '';
+        }
+    }
+
+    if (listUpdated) await ApiInstance.updateGlobalInfo(id, currentList);
+};
+
+export {
+    checkGlobals,
+    beSureGlobalExists,
+};

package/src/controllers/linacs.js

@@ -0,0 +1,34 @@
+import ApiInstance from '../services/phenyxApiInstance.js';
+
+const beSureLinacsExists = async (toBe) => {
+    // Sacar todos los recursos
+    const resources = await ApiInstance.getResources();
+    // Sacar el typeId de LINAC
+    const linacsTypeId = (await ApiInstance.getResourcesTypes())
+        .find(type => type.name === 'LINAC')
+        .id;
+
+    // Sacar solo los LINACs
+    const existingLinacs = resources.filter(item => item.typeId === linacsTypeId);
+
+    // Crear los que falten
+    for (const linac of toBe) {
+        if (!existingLinacs.find(item => item.name === linac)) {
+            console.log(`Adding ${linac}...`);
+            await ApiInstance.createResource({
+                name: linac,
+                typeId: linacsTypeId,
+            });
+        }
+    }
+    
+    const updatedLinacs = await ApiInstance.getResources();
+
+    const response = updatedLinacs.filter(item => item.typeId === linacsTypeId);
+
+    return response;
+};
+
+export {
+    beSureLinacsExists,
+};

package/src/controllers/login.js

@@ -0,0 +1,15 @@
+import ApiInstance from '../services/phenyxApiInstance.js';
+
+const login = (config) => {
+    const {
+        apiUrl: apiHost,
+        apiUser: user,
+        apiPwd: password,
+    } = config;
+
+    return ApiInstance.login({ apiHost, user, password });
+};
+
+export {
+    login,
+};

package/src/index.js

@@ -0,0 +1,47 @@
+#!/usr/bin/env node
+
+import path from "path";
+import { loadJson } from "@dmbejar/json-files";
+import { ask } from "./utils/ask.js";
+import { clearPatients } from "./scripts/clearPatients.js";
+import { importer } from "./scripts/importer.js";
+
+const work = async () => {
+    const args = process.argv.slice(2);
+
+    if (args.length === 0) {
+        console.log('No se proporcionaron argumentos.');
+        console.log('Uso: npx  @phenyxhealth/importer <archivo.json>');
+        return;
+    }
+
+    const configFileName = args[0];
+    const config = loadJson({ fileName: path.resolve(process.cwd(), configFileName) });
+
+    console.log('Leyendo configuración desde:', configFileName);
+
+    if (!config.ok) {
+        console.log(config.error);
+        return;
+    }
+
+    if (config.data.deleteExistingPatients) {
+        const verifyDelete = 'yes, delete all';
+
+        const deletePatients = await ask(`Want to delete all patients before importing? ¡This operation is irreversible! Write "${verifyDelete}" to confirm: `);
+
+        if (deletePatients.toLowerCase().trim() === verifyDelete) {
+            await clearPatients(config.data);
+        } else {
+            console.log('Skipping patients deletion');
+        }
+    }
+
+    const folder = configFileName.substring(0, configFileName.lastIndexOf('/'));
+    
+    if(folder) process.chdir(folder);
+
+    await importer(config.data);
+}
+
+work();

package/src/scripts/clearPatients.js

@@ -0,0 +1,20 @@
+import ApiInstance from '../services/phenyxApiInstance.js';
+import { login } from '../controllers/login.js';
+
+const clearPatients = async (config) => {
+    await login(config);
+    
+    const allPatients = await ApiInstance.getPatients();
+    const allPatientsIds = allPatients.map(p => p.id);
+
+    for (const patientId of allPatientsIds) {
+        console.log(`Deleting patient ${patientId}`);
+        await ApiInstance.deletePatient(patientId);
+    }
+    
+    console.log('All patients deleted');
+};
+
+export {
+    clearPatients,
+}

package/src/scripts/importer-old.js

@@ -0,0 +1,435 @@
+import path from 'path';
+import { loadJson } from '@dmbejar/json-files';
+import ApiInstance from '../services/phenyxApiInstance.js';
+import { login } from '../controllers/login.js';
+import { lowerCaseList, getListFromColumn } from '../utils/text.js';
+import { checkGlobals } from '../controllers/global.js';
+import { beSureDoctorExists } from '../controllers/doctors.js';
+import { today } from '../utils/dates.js';
+import { beSureLinacsExists } from '../controllers/linacs.js';
+
+const importer = async (config) => {
+    // Config
+    ApiInstance.showLogs(config.showLogs);
+
+    const {
+        inputFile,
+    } = config;
+
+    console.log(`Importing patients from "${inputFile}"...`);
+
+    const {
+        ok: loadOk,
+        error: patientsError,
+        data: patients,
+    } = loadJson({ fileName: path.resolve(process.cwd(), inputFile) });
+
+    if (!loadOk) {
+        console.error('Error loading input file:', patientsError);
+        return;
+    }
+
+    console.log('Verifying globals...');
+
+    await login(config);
+
+    // check globals
+    checkGlobals(ApiInstance.globalTypes.sendingDepartment, lowerCaseList(getListFromColumn(patients, 'sendingDepartment')));
+    checkGlobals(ApiInstance.globalTypes.cei9, getListFromColumn(patients, 'cei9'));
+    checkGlobals(ApiInstance.globalTypes.treatmentClass, lowerCaseList(getListFromColumn(patients, 'treatmentClass')));
+    checkGlobals(ApiInstance.globalTypes.treatmentSubClass, lowerCaseList(getListFromColumn(patients, 'treatmentSubClass')));
+    checkGlobals(ApiInstance.globalTypes.treatmentTechnique, getListFromColumn(patients, 'treatmentTechnique'));
+    checkGlobals(ApiInstance.globalTypes.ctSimProtocols, getListFromColumn(patients, 'simulationProtocol'));
+
+    // Dar de alta cada LINAC que no exista
+    const linacs = await beSureLinacsExists(getListFromColumn(patients, 'confirmedLinac'));
+
+    // Dar de alta cada médico que no exista
+    const radOncs = await beSureDoctorExists(getListFromColumn(patients, 'assignedRadOnc', 'peerReviewedDoctor'), ApiInstance.globalTypes.humanResources.values.RadOnc);
+    const medPhys = await beSureDoctorExists(getListFromColumn(patients, 'dosimetryMedPhys'), ApiInstance.globalTypes.humanResources.values.MedPhys);
+
+    // Verificar los defaults
+    const defaultCompatibleLinacs = ApiInstance.defaultCompatibleLinacs;
+
+    if (!defaultCompatibleLinacs.length) {
+        console.log('\n\nERROR: No default compatible linacs found');
+        return;
+    }
+
+    const defaultDuration = ApiInstance.defaultDuration;
+    if (!defaultDuration) {
+        console.log('\n\nERROR: No default duration found');
+        return;
+    }
+
+    // Los pacientes
+    const allPatients = await ApiInstance.getPatients();
+    const allPatientsIds = allPatients.map(p => p.patientId);
+
+    let contadorPacientes = 0;
+    const ignoredPatients = [];
+
+    console.log('Uploading patients...');
+
+    // Alta de los pacientes
+    for (const patientInfo of patients) {
+        const {
+            patientId,
+            registrationDate,
+            assignedRadOnc,
+            peerReviewedDoctor,
+            peerReviewedStatus,
+            sendingDepartment,
+            firstConsultDate,
+            cei9,
+            tnm,
+            stage,
+            treatmentClass,
+            treatmentSubClass,
+            treatmentTechnique,
+            sessionsCompleted,
+            sessionsTotal,
+            fractionationPattern,
+            ctAppDate,
+            notificationDate,
+            confirmedDate,
+            simulationProtocol,
+            qaCompletedDate,
+            confirmedLinac,
+            dosimetryMedPhys,
+            dosimetryQaInProgressDate,
+            dosimetryQaCompletedDate,
+            confirmedStartingDate,
+            treatmentStop,
+            linacAllocationCriteria,
+            sessionDurationCriteria,
+            groupRRHH,
+            patientName,
+        } = patientInfo;
+
+        if (allPatientsIds.includes(patientId)) {
+            console.log(`El paciente ${patientId} ya existe`);
+            ignoredPatients.push(patientId);
+            continue;
+        }
+
+        console.log('Procesando paciente:', patientId);
+
+        // Convertir ciertos datos
+        const sendingDepartmentId = ApiInstance.getSendingDepartmentIdByName(sendingDepartment);
+        const cei9Id = ApiInstance.getGlobalInfoElementId(ApiInstance.globalTypes.cei9, cei9);
+        const treatmentClassId = ApiInstance.getGlobalInfoElementId(ApiInstance.globalTypes.treatmentClass, treatmentClass);
+        const treatmentSubClassId = ApiInstance.getGlobalInfoElementId(ApiInstance.globalTypes.treatmentSubClass, treatmentSubClass);
+        const linacAllocationCriteriaId = ApiInstance.getGlobalInfoElementId(ApiInstance.globalTypes.linacsAllocationCriteria, linacAllocationCriteria || 'Default');
+        const confirmedLinacId = linacs.find(linac => linac.name === confirmedLinac)?.id || '';
+        const sessionDurationCriteriaId = ApiInstance.getGlobalInfoElementId(ApiInstance.globalTypes.sessionDurationCriteria, sessionDurationCriteria || 'Default');
+        const treatmentTechniqueId = ApiInstance.getGlobalInfoElementId(ApiInstance.globalTypes.treatmentTechnique, treatmentTechnique);
+        const simulationProtocolId = ApiInstance.getGlobalInfoElementId(ApiInstance.globalTypes.ctSimProtocols, simulationProtocol);
+        const dosimetryMedPhysId = medPhys.find(med => med.name === dosimetryMedPhys)?.id || '';
+        const pendingSessions = sessionsTotal - sessionsCompleted;
+        const peerReviewedDoctorId = radOncs.find(radOnc => radOnc.name === peerReviewedDoctor)?.id || '';
+
+        const peerReviewedData = ApiInstance.getRewiewedStatus(peerReviewedStatus);
+
+        // Crear el formData
+        const formData = {
+            registration: {
+                patientId: patientId.trim() || `IM-${(i + 1).toString().padStart(6, '0')}`,
+                registrationDate: registrationDate,
+                firstConsultProposal: firstConsultDate,
+                assignedRadOnc: assignedRadOnc,
+                sendingDepartment: sendingDepartmentId,
+            },
+            consultation: {
+                cei: cei9Id,
+                tnm: tnm,
+                estadio: stage,
+                treatmentClass: treatmentClassId,
+                treatmentSubClass: treatmentSubClassId,
+                earlierStartDate: "",
+                latestStartDate: "",
+                mandatoryStartDate: "",
+                priority: "",
+                shift: "Morning",
+                treatmentType: "",
+                treatmentGoal: "",
+                noTreatment: false,
+                why: "",
+                state: "NOT_STARTED",
+                compatibleLinacs: defaultCompatibleLinacs,
+                firstSesionDuration: defaultDuration.firstSession,
+                regularSesionDuration: defaultDuration.regularSessions,
+                linacAllocationCriteria: linacAllocationCriteriaId,
+                sessionDurationCriteria: sessionDurationCriteriaId,
+                treatmentParticle: "",
+                treatmentTechnique: treatmentTechniqueId,
+                numberOfFractions: sessionsTotal,
+                fractionation: "",
+                fractionPattern: fractionationPattern,
+                weeklySessions: "",
+                daysBetweenSessions: "",
+                comments: "",
+                ctSim: "",
+                ctApplicationDate: ctAppDate,
+                stateChanges: []
+            },
+            onHold: {
+                items: [
+                    {
+                        id: 1,
+                        start: "",
+                        end: "",
+                        motivation: "",
+                        comments: ""
+                    }
+                ],
+                state: "NOT_STARTED",
+                stateChanges: []
+            },
+            treatmentSimulation: {
+                notificationDate: notificationDate,
+                confirmedDate: confirmedDate,
+                simulationProtocol: simulationProtocolId,
+                ctGuidelines: "",
+                comments: "",
+                state: "NOT_STARTED",
+                stateChanges: [],
+                atachedFiles: []
+            },
+            contouringOar: {
+                guidelines: "",
+                proposedRrhh: "",
+                rrhhId: "",
+                countouringTool: "",
+                oarTableId: "",
+                comments: "",
+                state: "NOT_STARTED",
+                stateChanges: []
+            },
+            contouringVolumes: {
+                guidelines: "",
+                proposedRrhh: "",
+                rrhhId: "",
+                countouringTool: "",
+                comments: "",
+                volumesDescription: [
+                    {
+                        id: 1,
+                        name: "PTV1",
+                        desc: "PTVASOC1"
+                    }
+                ],
+                volumesDose: [
+                    {
+                        ptv: "PTV1",
+                        ptvAsoc: "PTVASOC1",
+                        total: "100",
+                        dose: 100,
+                        fracPattern: "CMD"
+                    },
+                    {
+                        ptv: "PTV1",
+                        ptvAsoc: "PTVASOC1",
+                        total: "100",
+                        dose: 100,
+                        fracPattern: "CMD"
+                    }
+                ],
+                state: "NOT_STARTED",
+                stateChanges: []
+            },
+            treatmentDefinition: {
+                compatibleLinacs: defaultCompatibleLinacs,
+                firstSesionDuration: defaultDuration.firstSession,
+                regularSesionDuration: defaultDuration.regularSessions,
+                linacAllocationCriteria: linacAllocationCriteriaId,
+                sessionDurationCriteria: sessionDurationCriteriaId,
+                treatmentParticle: "",
+                treatmentTechnique: treatmentTechniqueId,
+                numberOfFractions: sessionsTotal,
+                fractionation: "",
+                fractionPattern: fractionationPattern,
+                weeklySessions: "",
+                daysBetweenSessions: "",
+                comments: "",
+                peerReviewed: peerReviewedData,
+                oarAndPtvTables: [
+                    {
+                        ptv: "PTV1",
+                        ptvasoc: "PTVASOC1"
+                    },
+                    {
+                        ptv: "PTV1",
+                        ptvasoc: "PTVASOC1"
+                    }
+                ],
+                checkListPeerReview: {
+                    targetVolumes: false,
+                    oarVolumes: false,
+                    targetDoses: false,
+                    oarToleranceTables: false,
+                    treatmentTechnique: false,
+                    fractionation: false
+                },
+                state: "NOT_STARTED",
+                stateChanges: []
+            },
+            dosimetry: {
+                proposedLinac: confirmedLinacId,
+                confirmedLinac: confirmedLinacId,
+                groupRrhh: groupRRHH,
+                idRrhh: dosimetryMedPhysId,
+                calculationMethod: "",
+                typeOfPlanning: "",
+                tpsUsed: "",
+                secondGroupRrhh: "",
+                secondIdRrhh: "",
+                secondCalculationMethod: "",
+                dosimetryComplete: false,
+                planDefinitionComplete: false,
+                dosimetricReportComplete: false,
+                state: "NOT_STARTED",
+                stateChanges: [],
+                dosimetricReportFiles: [],
+                treatmentPlanFiles: []
+            },
+            treatmentVerification: {
+                description: "",
+                comments: "",
+                verificationProtocol: "",
+                state: "NOT_STARTED",
+                stateChanges: [],
+                verificationReportFiles: [],
+                uploadFiles: []
+            },
+            treatmentDelivery: {
+                numberOfFractions: sessionsTotal,
+                confirmedLinac: confirmedLinacId,
+                treatmentTechnique: treatmentTechniqueId,
+                tentativeTreatmentStart: "",
+                confirmedTreatmentStart: confirmedStartingDate,
+                numberOfCompleteSessions: sessionsCompleted,
+                numberOfPendingSessions: pendingSessions,
+                startAssignedShift: "",
+                startConfirmedStartDate: "",
+                startWeeklyAssignedDays: [],
+                interruptedEstimatedEndDate: "",
+                interruAssignedShift: "",
+                interruptedConfirmedStartDate: "",
+                interruptedMotivation: "",
+                canceledMotivation: "",
+                stateChanges: []
+            },
+            nursing: {
+                rows: [
+                    {
+                        namefield: "value",
+                        namefield2: "value2",
+                        namefield3: "value2",
+                        namefield4: "value2",
+                        namefield5: "value2",
+                        namefield6: "value2"
+                    },
+                    {
+                        namefield: "value",
+                        namefield2: "value2",
+                        namefield3: "value2",
+                        namefield4: "value2",
+                        namefield5: "value2",
+                        namefield6: "value2"
+                    }
+                ],
+                state: "NOT_STARTED",
+                stateChanges: []
+            }
+        }
+
+        // Guardar el paciente
+        const createdId = await ApiInstance.createPatient({ firstName: patientName.trim(), formData });
+
+        // Recuperar el cliente
+        const patient = await ApiInstance.getPatient(createdId);
+
+        // Ajustar estados
+        if (peerReviewedDoctorId) {
+            await ApiInstance.createPatientStateChanges({
+                formDataId: patient.formData.treatmentDefinition.id,
+                humanResourceId: peerReviewedDoctorId,
+                date: today(),
+                nextStateCode: 'PEER_REVIEWED',
+            });
+        }
+
+        if (qaCompletedDate) {
+            await ApiInstance.createPatientStateChanges({
+                formDataId: patient.formData.treatmentDefinition.id,
+                date: qaCompletedDate,
+                nextStateCode: 'COMPLETED',
+            });
+        }
+
+        if (dosimetryQaInProgressDate) {
+            await ApiInstance.createPatientStateChanges({
+                formDataId: patient.formData.dosimetry.id,
+                date: dosimetryQaInProgressDate,
+                nextStateCode: 'IN_PROGRESS',
+            });
+        }
+
+        if (dosimetryQaCompletedDate) {
+            await ApiInstance.createPatientStateChanges({
+                formDataId: patient.formData.dosimetry.id,
+                date: dosimetryQaCompletedDate,
+                nextStateCode: 'COMPLETED',
+            });
+        }
+
+        if (confirmedStartingDate && today() < confirmedStartingDate) {
+            await ApiInstance.createPatientStateChanges({
+                formDataId: patient.formData.treatmentDelivery.id,
+                date: confirmedStartingDate,
+                nextStateCode: 'START_CONFIRMED',
+            });
+        }
+
+        if (parseInt(sessionsCompleted)) {
+            await ApiInstance.createPatientStateChanges({
+                formDataId: patient.formData.treatmentDelivery.id,
+                date: confirmedStartingDate || today(),
+                nextStateCode: 'IN_PROGRESS',
+            });
+        }
+
+        if (treatmentStop.toUpperCase().startsWith('CANC')) {
+            await ApiInstance.createPatientStateChanges({
+                formDataId: patient.formData.treatmentDelivery.id,
+                date: today(),
+                nextStateCode: 'CANCELED',
+            });
+        }
+
+        if (treatmentStop.toUpperCase().startsWith('INT')) {
+            await ApiInstance.createPatientStateChanges({
+                formDataId: patient.formData.treatmentDelivery.id,
+                date: today(),
+                nextStateCode: 'INTERRUPTED',
+            });
+        }
+
+        if (!!sessionsCompleted && sessionsCompleted != 0 && sessionsCompleted === sessionsTotal) {
+            await ApiInstance.createPatientStateChanges({
+                formDataId: patient.formData.treatmentDelivery.id,
+                date: today(),
+                nextStateCode: 'COMPLETED',
+            });
+        }
+
+        contadorPacientes++;
+    }
+
+    if (ignoredPatients.length) console.error('\n\nLos siguientes pacientes no se han podido importar porque ya existían en el sistema:', ignoredPatients.join(', '));
+};
+
+export {
+    importer,
+};