@phenyxhealth/sdk 1.0.0

package/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "@phenyxhealth/sdk",
+  "version": "1.0.0",
+  "type": "module",
+  "description": "PhenyxHealth API client SDK for interacting with PhenyxHealth instances.",
+  "main": "./src/index.js",
+  "exports": {
+    ".": "./src/index.js"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "author": "Diego M. Béjar",
+  "license": "ISC",
+  "dependencies": {
+    "uuid": "13.0.0"
+  }
+}

package/src/PhenyxApi.js

@@ -0,0 +1,483 @@
+import { v4 } from 'uuid';
+import { today } from './utils/dates.js';
+
+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/controllers/doctors.js

@@ -0,0 +1,24 @@
+const beSureDoctorExists = async (apiInstance, 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,83 @@
+import { v4 } from 'uuid';
+import { getContrastingColor } from '../utils/colors.js';
+
+const checkGlobals = async (apiInstance, 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(apiInstance, currentContent, valuesToCheck);
+};
+
+const beSureGlobalExists = async (apiInstance, 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,32 @@
+const beSureLinacsExists = async (apiInstance, 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/index.js

@@ -0,0 +1,6 @@
+export { default as PhenyxApi } from './PhenyxApi.js';
+export { checkGlobals, beSureGlobalExists } from './controllers/global.js';
+export { beSureDoctorExists } from './controllers/doctors.js';
+export { beSureLinacsExists } from './controllers/linacs.js';
+export { today, formatDateString, formatDate } from './utils/dates.js';
+export { getContrastingColor } from './utils/colors.js';

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,
+};