@phenyxhealth/importer 1.1.7

package/src/services/phenyxApi.js

@@ -0,0 +1,483 @@
+import { doesNotMatch } from 'assert';
+import { v4 } from 'uuid';
+
+class PhenyxApi {
+    constructor() {
+        this.apiToken = null;
+        this.apiHost = null;
+        this.user = null;
+        this.config = {};
+        this.globalInfo = null;
+        this.activeTables = null;
+        this.doctors = [];
+        this.defaultDuration = {
+            firstSession: '30',
+            regularSessions: '15',
+        };
+        this.defaultCompatibleLinacs = [];
+        this.oars = [];
+    }
+
+    peerReviewedStatus = {
+        'Discussion without changes': 'Discussion without changes',
+        'No changes': 'No changes',
+        'Discusión sin cambios': 'Discussion without changes',
+        'No cambios': 'No changes',
+    }
+
+    globalTypes = {
+        humanResources: {
+            type: 'Global',
+            name: 'Human Resources Types',
+            values: {
+                RadOnc: 'RadOnc',
+                MedPhys: 'MedPhys',
+            },
+        },
+        sendingDepartment: {
+            type: 'Global',
+            name: 'Sending Department',
+        },
+        cei9: {
+            type: 'Global',
+            name: 'CEI9',
+        },
+        treatmentClass: {
+            type: 'Global',
+            name: 'Treatment Class',
+        },
+        treatmentSubClass: {
+            type: 'Global',
+            name: 'Treatment SubClass',
+        },
+        treatmentTechnique: {
+            type: 'Global',
+            name: 'Treatment Technique',
+        },
+        treatmentType: {
+            type: 'Global',
+            name: 'Treatment Type',
+        },
+        treatmentGoal: {
+            type: 'Global',
+            name: 'Treatment Goal',
+        },
+        treatmentParticles: {
+            type: 'Global',
+            name: 'Treatment Particle',
+        },
+        noTreatmentReasons: {
+            type: 'Global',
+            name: 'No Treatment Reasons',
+        },
+        ctSimProtocols: {
+            type: 'Global',
+            name: 'CT Sim Protocols',
+        },
+        linacsAllocationCriteria: {
+            type: 'Global',
+            name: 'LINACs Allocation Criteria',
+            values: {
+                default: 'Default',
+            },
+        },
+        sessionDurationCriteria: {
+            type: 'Global',
+            name: 'Session Duration Criteria',
+            values: {
+                default: 'Default',
+            },
+        },
+        contouringTools: {
+            type: 'Global',
+            name: 'Contouring Tools',
+        },
+        fractionationTypes: {
+            type: 'Global',
+            name: 'Fractionation Types',
+        },
+        dosimetryCalculationMethods: {
+            type: 'Global',
+            name: 'Dosimetry Calculation Methods',
+        },
+        dosimetrySecondaryCalculationMethods: {
+            type: 'Global',
+            name: 'Dosimetry 2nd Calculation Methods',
+        },
+        tps: {
+            type: 'Global',
+            name: 'TPS available',
+        },
+        treatmentVerificationProtocols: {
+            type: 'Global',
+            name: 'Treatment Verification Protocols',
+        },
+    }
+
+    apiCall = async ({ method, url, data }) => {
+        const fullUrl = `${this.apiHost}${url}`;
+
+        try {
+            const params = {
+                method,
+                headers: {
+                    'Content-Type': 'application/json',
+                    ...(this.apiToken ? { Authorization: `Bearer ${this.apiToken}` } : {})
+                },
+            };
+
+            if (data && method.toUpperCase() !== 'GET') params.body = JSON.stringify(data);
+
+            if (this.config.showLogs) console.log(`Calling to: ${method.toUpperCase()} ${fullUrl}\n`, params);
+
+            const response = await fetch(fullUrl, params);
+
+            if (!response.ok) {
+                const errorText = await response.text();
+                console.error(`Error: ${response.status} - ${errorText}`);
+                console.log(`Calling to: ${method.toUpperCase()} ${fullUrl}\n`, params);
+                throw new Error(`HTTP error! status: ${response.status}`);
+            }
+
+            const output = await response.json();
+
+            return output;
+        } catch (error) {
+            console.error('Request failed', error);
+            throw error;
+        }
+    }
+
+    showLogs = (showLogs) => this.config.showLogs = showLogs;
+
+    login = async ({ apiHost, user, password }) => {
+        if (!apiHost) {
+            throw new Error('Var apiHost is required');
+        }
+
+        if (!user) {
+            throw new Error('Var user is required');
+        }
+
+        if (!password) {
+            throw new Error('Var password is required');
+        }
+
+        this.apiHost = apiHost.endsWith('/') ? apiHost : `${apiHost}/`;
+
+        const response = await this.apiCall({
+            method: 'POST',
+            url: `users/login`,
+            data: { user, password },
+        });
+
+        this.apiToken = response.token;
+        this.user = response.user;
+
+        await this.retrieveGlobalInfo();
+
+        await this.retrieveActiveTables();
+
+        await this.retrieveDefaults();
+
+        await this.retrieveOars();
+    }
+
+    getToken = () => {
+        return this.apiToken;
+    };
+
+    retrieveGlobalInfo = async () => {
+        const globalInfo = await this.apiCall({
+            method: 'GET',
+            url: `global-info`,
+        });
+
+        this.globalInfo = globalInfo;
+
+        return globalInfo;
+    }
+
+    retrieveOars = async () => {
+        const response = await this.apiCall({
+            method: 'GET',
+            url: `tables/Oar`,
+        });
+
+        this.oars = response;
+
+        return response;
+    }
+
+    retrieveActiveTables = async () => {
+        const activeTables = await this.apiCall({
+            method: 'GET',
+            url: `tables/actives`,
+        });
+
+        this.activeTables = activeTables;
+
+        return activeTables;
+    }
+
+    retrieveDefaults = async () => {
+        try {
+            this.defaultCompatibleLinacs = this
+                .activeTables
+                .find(t => t.type.name === 'LINACs Allocation Table')
+                .data
+                .items
+                .find(d => d.criteriaElementName === 'Default')
+                .resources
+                .filter(r => !!r.isActive)
+                .map(r => ({
+                    id: r.resourceId,
+                    name: r.resourceName,
+                }));
+        } catch (err) {
+        }
+
+        try {
+            this.defaultDuration = this
+                .activeTables
+                .find(t => t.type.name === 'Session Duration Table')
+                .data
+                .items
+                .find(d => d.sessionDurationCriteria === 'Default');
+        } catch (err) {
+        }
+
+        return {
+            defaultDuration: this.defaultDuration,
+            defaultCompatibleLinacs: this.defaultCompatibleLinacs,
+        };
+    };
+
+    updateGlobalInfo = async (globalTypeId, data) => {
+        await this.apiCall({
+            method: 'PUT',
+            url: `global-info/${globalTypeId}`,
+            data,
+        });
+
+        await this.retrieveGlobalInfo();
+    }
+
+    getGlobalInfo = (globalType) => {
+        return this.globalInfo
+            ?.find(item => item.typeName === globalType.type)
+            ?.globalInfos
+            ?.find(item => item.name === globalType.name);
+    }
+
+    getGlobalInfoElement = (globalType, elementName) => {
+        return this.getGlobalInfo(globalType)
+            ?.elements
+            ?.find(item => item.name.toLowerCase() === elementName.toLowerCase());
+    }
+
+    getGlobalInfoElementId = (globalType, elementName) => {
+        if (!elementName) return null;
+        
+        return this.getGlobalInfoElement(globalType, elementName)?.id;
+    }
+
+    getHumanResources = async () => {
+        const response= await this.apiCall({
+            method: 'GET',
+            url: `human-resources`,
+        });
+
+        this.doctors = response;
+
+        return response;
+    }
+
+    createHumanResource = async ({ name, typeId, agenda = [] }) => {
+        return this.apiCall({
+            method: 'POST',
+            url: `human-resources`,
+            data: {
+                name,
+                typeId,
+                agenda,
+            },
+        });
+    }
+
+    getResourcesTypes = async () => {
+        return this.apiCall({
+            method: 'GET',
+            url: `resource-types`,
+        });
+    }
+
+    getResources = async () => {
+        const response = await this.apiCall({
+            method: 'GET',
+            url: `resources`,
+        });
+
+        return response;
+    }
+
+    createResource = async ({ name, author = 'ADMIN', typeId, agenda = [] }) => {
+        return this.apiCall({
+            method: 'POST',
+            url: `resources`,
+            data: {
+                name,
+                author,
+                typeId,
+                agenda,
+            },
+        });
+    }
+
+    getSendingDepartmentIdByName = (name) => {
+        const sendingDepartment = this.getGlobalInfoElement(this.globalTypes.sendingDepartment, name);
+        if (!sendingDepartment) {
+            throw new Error(`Sending Department ${name} not found`);
+        }
+        return sendingDepartment.id;
+    }
+
+    getCei9IdByName = (name) => {
+        const cei9 = this.getGlobalInfoElement(this.globalTypes.cei9, name);
+        if (!cei9) {
+            throw new Error(`CEI9 ${name} not found`);
+        }
+        return cei9.id;
+    }
+
+    createPatient = async (data) => {
+        const response = await this.apiCall({
+            method: 'POST',
+            url: `patients`,
+            data,
+        });
+
+        return response.id;
+    }
+
+    getPatients = async () => {
+        return this.apiCall({
+            method: 'GET',
+            url: `patients`,
+        });
+    }
+
+    getPatient = async (id) => {
+        return this.apiCall({
+            method: 'GET',
+            url: `patients/${id}/clinical-data`,
+        });
+    }
+
+    deletePatient = async (id) => {
+        return this.apiCall({
+            method: 'DELETE',
+            url: `patients/${id}`,
+        });
+    }
+
+    createPatientStateChanges = ({ formDataId, date = today(), humanResourceId = null, nextStateCode }) => {
+        return this.apiCall({
+            method: 'POST',
+            url: `patients/state-changes`,
+            data: {
+                date,
+                formDataId,
+                humanResourceId,
+                nextStateCode,
+            },
+        });
+    }
+
+    getRewiewedStatus = (status) => {
+        const saveStatus = this.peerReviewedStatus[status];
+        if (!saveStatus) return [];
+
+        return [{
+            id: v4(),
+            name: saveStatus,
+            coments: '',
+            date: new Date().toLocaleDateString(),
+            hour: new Date().toLocaleTimeString(),
+        }];
+    }
+
+    allStatus = {
+        NOTSTARTED: 'NOT_STARTED',
+        COMPLETED: 'COMPLETED',
+        INPROGRESS: 'IN_PROGRESS',
+        ONREQUEST: 'ON_REQUEST',
+        READYTOSTART: 'READY_TO_START',
+        DONE: 'DONE',
+        REVIEWED: 'REVIEWED',
+        VALIDATED: 'VALIDATED',
+        PEERREVIEWING: 'PEER_REVIEWING',
+        PEERREVIEWED: 'PEER_REVIEWED',
+        DONEMAIN: 'DONE',
+        DONESECONDCALCULATION: 'DONE_SECOND',
+        STARTPROPOSED: 'START_PROPOSED',
+        STARTCONFIRMED: 'START_CONFIRMED',
+        CANCELED: 'CANCELED',
+        CANCELLED: 'CANCELED',
+    }
+
+    getQaStatus = (section) => {
+        const currentStatus = section.qa.currentStatus || null;
+        return currentStatus
+            ? this.allStatus[currentStatus.toUpperCase().replaceAll(' ', '').replaceAll('_', '')]
+            : null;
+    }
+
+    getDoctorIdByName = (name) => {
+        const doc = this.doctors.find(d => d.name === name);
+        return doc ? doc.id : null;
+    }
+
+    getDoctorTypeIdByName = (name) => {
+        const doc = this.doctors.find(d => d.name === name);
+        return doc ? doc.typeId : null;
+    }
+
+    getDoctorTypeNameByName = (name) => {
+        const doc = this.doctors.find(d => d.name === name);
+        return doc ? doc.typeName : null;
+    }
+
+    getSortedQa = (qa) => {
+        const qaArray = [];
+        for (const qaKey of Object.keys(qa)) {
+            if (qa[qaKey].date) qaArray.push({
+                status: this.allStatus[qaKey.toUpperCase()],
+                ...qa[qaKey]
+            });
+        };
+        const sortedQa = qaArray.sort((a, b) => new Date(a.data) - new Date(b.data));
+
+        return sortedQa;
+    }
+
+    updateSectionQaStatus = async (qa, formDataId) => {
+        const sortedQa = this.getSortedQa(qa);
+
+        for (const item of sortedQa) {
+            await this.createPatientStateChanges({
+                formDataId,
+                date: item.date,
+                humanResourceId: this.getDoctorIdByName(item.who),
+                nextStateCode: item.status,
+            });
+        }
+    }
+
+    getElementIdByName = (type, name) => {
+        const el = this[type].find(e => e.name === name);
+        return el?.id || null;
+    }
+};
+
+export default PhenyxApi;

package/src/services/phenyxApiInstance.js

@@ -0,0 +1,5 @@
+import PhenyxApi from './phenyxApi.js';
+
+const phenyxApiInstance = new PhenyxApi();
+
+export default phenyxApiInstance;

package/src/utils/ask.js

@@ -0,0 +1,19 @@
+import readline from "readline";
+
+const ask = (question) => {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+    });
+
+    return new Promise((resolve) => {
+        rl.question(question, (answer) => {
+            rl.close();
+            resolve(answer);
+        });
+    });
+};
+
+export {
+    ask,
+};

package/src/utils/colors.js

@@ -0,0 +1,42 @@
+/**
+ * Genera un color aleatorio en formato RGB que contrasta bien tanto con fondo blanco como negro
+ * @returns {string} Color en formato "R, G, B"
+ */
+const getContrastingColor = () => {
+    // Colores base que contrastan bien tanto en blanco como en negro
+    const baseColors = [
+        [244, 67, 54],   // Rojo
+        [233, 30, 99],   // Rosa
+        [156, 39, 176],  // Morado
+        [103, 58, 183],  // Morado profundo
+        [63, 81, 181],   // Índigo
+        [33, 150, 243],  // Azul
+        [0, 188, 212],   // Cian
+        [0, 150, 136],   // Verde azulado
+        [76, 175, 80],   // Verde
+        [139, 195, 74],  // Verde lima
+        [205, 220, 57],  // Lima
+        [255, 193, 7],   // Ámbar
+        [255, 152, 0],   // Naranja
+        [255, 87, 34],   // Naranja profundo
+        [121, 85, 72],   // Marrón
+        [96, 125, 139]   // Azul grisáceo
+    ];
+
+    // Seleccionar un color base aleatorio
+    const color = baseColors[Math.floor(Math.random() * baseColors.length)];
+
+    // Añadir una pequeña variación aleatoria para más diversidad
+    // manteniendo el contraste dentro de límites seguros
+    const variation = () => Math.floor(Math.random() * 30) - 15;
+
+    const r = Math.max(0, Math.min(255, color[0] + variation()));
+    const g = Math.max(0, Math.min(255, color[1] + variation()));
+    const b = Math.max(0, Math.min(255, color[2] + variation()));
+
+    return `${r}, ${g}, ${b}`;
+};
+
+export {
+    getContrastingColor,
+};

package/src/utils/dates.js

@@ -0,0 +1,21 @@
+const formatDateString = (date) => {
+    if (!date) return '';
+    const [day, month, year] = date.split('/');
+    return `${year}-${month.padStart(2, '0')}-${day.padStart(2, '0')}`;
+};
+
+const formatDate = (date) => {
+    const year = date.getFullYear();
+    const month = (date.getMonth() + 1).toString().padStart(2, '0');
+    const day = date.getDate().toString().padStart(2, '0');
+
+    return `${year}-${month}-${day}`;
+};
+
+const today = () => formatDate(new Date());
+
+export {
+    formatDateString,
+    formatDate,
+    today,
+};

package/src/utils/text.js

@@ -0,0 +1,85 @@
+const fixText = str => str
+    .split(' ')
+    .filter(Boolean)
+    .join(' ');
+
+const fixTextList = list => {
+    const netList = list
+        .map(fixText)
+        .filter(Boolean);
+
+    const response = [];
+    const lowercaseItems = [];
+
+    for (const item of netList) {
+        if (!lowercaseItems.includes(item.toLowerCase())) {
+            response.push(item);
+            lowercaseItems.push(item.toLowerCase());
+        }
+    }
+
+    return response;
+};
+
+const getListFromField = (data, ...fields) => {
+    const list = [];
+    for (const line of data) {
+        for (const field of fields) {
+            let item = line;
+            const items = [];
+
+            for (const tree of field.split('.')) {
+                if (!item) break;
+                if (tree.startsWith('*')) {
+                    const subField = tree.substring(1);
+                    for (const key of Object.keys(item)) {
+                        if (item[key][subField]) {
+                            items.push(item[key][subField]);
+                        }
+                    }
+                } else {
+                    item = item[tree];
+                    if (typeof (item) === 'string') items.push(item);
+                }
+            }
+
+            for (const item of items) {
+                if (item && !list.includes(item)) list.push(item);
+            }
+        }
+    }
+
+    return fixTextList(list);
+};
+
+const getConditionalListFromField = (data, field, conditions) => {
+    const list = [];
+
+    for (const item of data) {
+        if (typeof item !== 'object') continue;
+
+        if (!!item[field]) {
+            let isRight = true;
+            for (const [condField, condValue] of Object.entries(conditions)) {
+                if (item[condField] !== condValue) {
+                    isRight = false;
+                    break;
+                }
+            }
+
+            if (isRight) list.push(item[field]);
+
+            continue;
+        }
+
+        list.push(...getConditionalListFromField(Object.values(item), field, conditions));
+    }
+    return fixTextList(list);
+};
+
+export {
+    fixText,
+    fixTextList,
+    getListFromField,
+    getConditionalListFromField,
+};