HUDS : Armar api o controladores para situaciones activas y antecedentes

initialize.ts

@@ -106,6 +106,7 @@ export function initAPI(app: Express) {
     app.use('/api/modules/gestor-usuarios', require('./modules/gestor-usuarios').PerfilesRouter);
     app.use('/api/modules/registro-novedades', require('./modules/registro-novedades').NovedadesRouter);
     app.use('/api/modules/huds', require('./modules/huds').HudsAccesoRouter);
+    app.use('/api/modules/huds', require('./modules/huds').HudsSituacionesRouter);
     app.use('/api/modules/webhook', require('./modules/webhook').WebhookRouter);
     app.use('/api/modules/webhook', require('./modules/webhook/webhooklog').WebhookLogRouter);
     app.use('/api/modules/seguimiento-paciente', require('./modules/seguimiento-paciente').SeguimientoPacienteRouter);

modules/huds/hudsSituaciones.controller.ts

@@ -0,0 +1,133 @@
+import { PacienteCtr } from '../../core-v2/mpi/paciente/paciente.routes';
+import { SnomedCtr } from '../../core/term/controller/snomed.controller';
+import { Prestacion } from '../rup/schemas/prestacion';
+import { CarnetPerinatal } from '../perinatal/schemas/carnet-perinatal.schema';
+import { buscarEnHuds } from '../rup/controllers/rup';
+import * as moment from 'moment';
+
+import { ECLQueries } from '../../core/tm/schemas/eclqueries.schema';
+
+function registrosPorSemanticTag(registros, semanticTag) {
+    const result = [];
+    for (const registro of registros) {
+        if (registro.concepto && registro.concepto.semanticTag === semanticTag) {
+            result.push(registro);
+        }
+        if (registro.registros && registro.registros.length > 0) {
+            result.push(...registrosPorSemanticTag(registro.registros, semanticTag));
+        }
+    }
+    return result;
+}
+
+export async function situacionesActivas(pacienteID) {
+    const paciente = await PacienteCtr.findById(pacienteID);
+    if (!paciente) {
+        return null;
+    }
+
+    const result: any[] = [];
+
+    const prestaciones: any[] = await Prestacion.find({
+        'paciente.id': { $in: paciente.vinculos },
+        'estadoActual.tipo': 'validada'
+    });
+
+    for (const prestacion of prestaciones) {
+        const registros = registrosPorSemanticTag(prestacion.ejecucion.registros || [], 'trastorno');
+        for (const registro of registros) {
+            result.push({
+                tipo: 'trastorno',
+                concepto: registro.concepto,
+                fecha: prestacion.ejecucion.fecha,
+                profesional: prestacion.solicitud.profesional,
+                organizacion: prestacion.ejecucion.organizacion,
+                idPrestacion: prestacion._id,
+                tipoPrestacion: prestacion.solicitud.tipoPrestacion
+            });
+        }
+    }
+
+    // Usar vinculos para cubrir pacientes con múltiples identificadores ANDES
+    const carnet: any = await CarnetPerinatal.findOne({
+        'paciente.id': { $in: paciente.vinculos },
+        fechaFinEmbarazo: null
+    });
+
+    if (carnet && carnet.embarazoEnCurso) {
+        const controles = (carnet.controles || []).sort(
+            (a, b) => moment(b.fechaControl).valueOf() - moment(a.fechaControl).valueOf()
+        );
+        const ultimoControl = controles.length > 0 ? controles[0] : null;
+
+        if (ultimoControl && moment(ultimoControl.fechaControl).isAfter(moment().subtract(9, 'months'))) {
+            result.push({
+                tipo: 'embarazo',
+                situacion: 'embarazo en curso',
+                fechaUltimoControl: ultimoControl.fechaControl,
+                profesional: ultimoControl.profesional,
+                idPrestacion: ultimoControl.idPrestacion,
+                organizacion: ultimoControl.organizacion
+            });
+        }
+    }
+
+    return result;
+}
+
+/**
+ * Antecedentes personales: trastornos registrados en prestaciones validadas del paciente.
+ * Filtra por semanticTag === 'trastorno' en memoria (sin llamada a Snowstorm).
+ * Incluye registros anidados recursivamente.
+ */
+export async function antecedentesPersonales(pacienteID) {
+    const paciente = await PacienteCtr.findById(pacienteID);
+    if (!paciente) {
+        return null;
+    }
+
+    const eclQuery = await ECLQueries.findOne({ key: 'antecedentes_personales' });
+    const expression = eclQuery ? eclQuery.valor : '<< 312850006';
+    const conceptos = await SnomedCtr.getConceptByExpression(expression);
+
+    if (!conceptos || conceptos.length === 0) {
+        return [];
+    }
+
+    const prestaciones: any[] = await Prestacion.find({
+        'paciente.id': { $in: paciente.vinculos },
+        'estadoActual.tipo': 'validada'
+    });
+
+    const results = buscarEnHuds(prestaciones, conceptos);
+    return results.map(item => ({
+        concepto: item.registro.concepto,
+        fecha: item.fecha,
+        profesional: item.profesional,
+        organizacion: item.organizacion,
+        idPrestacion: item.idPrestacion,
+        tipoPrestacion: item.tipoPrestacion
+    }));
+}
+
+export async function antecedentesFamiliares(pacienteID) {
+    const paciente = await PacienteCtr.findById(pacienteID);
+    if (!paciente) {
+        return null;
+    }
+
+    const eclQuery = await ECLQueries.findOne({ key: 'antecedentes_familiares' });
+    const expression = eclQuery ? eclQuery.valor : '<< 57177007';
+    const conceptos = await SnomedCtr.getConceptByExpression(expression);
+
+    if (!conceptos || conceptos.length === 0) {
+        return [];
+    }
+
+    const prestaciones: any[] = await Prestacion.find({
+        'paciente.id': { $in: paciente.vinculos },
+        'estadoActual.tipo': 'validada'
+    });
+
+    return buscarEnHuds(prestaciones, conceptos);
+}

modules/huds/hudsSituaciones.routes.ts

@@ -0,0 +1,44 @@
+import * as express from 'express';
+import { Types } from 'mongoose';
+import { Auth } from '../../auth/auth.class';
+import { asyncHandler } from '@andes/api-tool';
+import { situacionesActivas, antecedentesPersonales, antecedentesFamiliares } from './hudsSituaciones.controller';
+
+const router = express.Router();
+
+router.use(Auth.authenticate());
+
+router.get('/:idPaciente/situacionesActivas', asyncHandler(async (req: any, res) => {
+    if (!Types.ObjectId.isValid(req.params.idPaciente)) {
+        return res.status(404).send('Paciente no encontrado');
+    }
+    const result = await situacionesActivas(req.params.idPaciente);
+    if (!result) {
+        return res.status(404).send('Paciente no encontrado');
+    }
+    res.json(result);
+}));
+
+router.get('/:idPaciente/antecedentesPersonales', asyncHandler(async (req: any, res) => {
+    if (!Types.ObjectId.isValid(req.params.idPaciente)) {
+        return res.status(404).send('Paciente no encontrado');
+    }
+    const result = await antecedentesPersonales(req.params.idPaciente);
+    if (!result) {
+        return res.status(404).send('Paciente no encontrado');
+    }
+    res.json(result);
+}));
+
+router.get('/:idPaciente/AntecedentesFamiliares', asyncHandler(async (req: any, res) => {
+    if (!Types.ObjectId.isValid(req.params.idPaciente)) {
+        return res.status(404).send('Paciente no encontrado');
+    }
+    const result = await antecedentesFamiliares(req.params.idPaciente);
+    if (!result) {
+        return res.status(404).send('Paciente no encontrado');
+    }
+    res.json(result);
+}));
+
+export const HudsSituacionesRouter = router;

modules/huds/index.ts

@@ -1,2 +1,3 @@
 export { HudsAccesosCtr } from './hudsAccesos.controller';
 export { HudsAccesoRouter } from './hudsAccesos.routes';
+export { HudsSituacionesRouter } from './hudsSituaciones.routes';

modules/perinatal/schemas/carnet-perinatal.schema.ts

@@ -1,6 +1,7 @@
 import { Schema, Types, model } from 'mongoose';
 import { AuditPlugin } from '@andes/mongoose-plugin-audit';
 import { PacienteSubSchema } from '../../../core-v2/mpi/paciente/paciente.schema';
+import * as moment from 'moment';
 
 export const CarnetPerinatalSchema = new Schema({
     fecha: Date,
@@ -38,6 +39,21 @@ export const CarnetPerinatalSchema = new Schema({
     nota: String
 });
 
+CarnetPerinatalSchema.virtual('embarazoEnCurso').get(function () {
+    if (this.fechaFinEmbarazo) {
+        return false;
+    }
+
+    const fechaRef = this.fechaUltimoControl || this.fecha;
+
+    if (!fechaRef) {
+        return false;
+    }
+
+    const diezMeses = moment().subtract(10, 'months').toDate();
+    return moment(fechaRef).isAfter(diezMeses);
+});
+
 CarnetPerinatalSchema.plugin(AuditPlugin);
 
 export const CarnetPerinatal = model('carnet-perinatal', CarnetPerinatalSchema, 'carnet-perinatal');