Developer

initialize.ts

@@ -123,6 +123,8 @@ export function initAPI(app: Express) {
     app.use('/api/modules', require('./modules/constantes').ConstantesRouter);
     app.use('/api/modules', require('./modules/recetas').RecetasRouter);
     app.use('/api/modules', require('./modules/insumos').InsumosRouter);
+    app.use('/api/modules', require('./modules/recetas/recetasInsumos').RecetaInsumoRouter);
+
 
     if (configPrivate.hosts.BI_QUERY) {
         app.use(

modules/insumos/insumos-schema.ts

@@ -1,7 +1,6 @@
 import * as mongoose from 'mongoose';
 import { AuditPlugin } from '@andes/mongoose-plugin-audit';
 
-
 export const insumoSchema = new mongoose.Schema({
     nombre: String,
     codigo: [{

modules/insumos/insumos.routes.ts

@@ -7,9 +7,15 @@ class InsumosResource extends ResourceBase {
     resourceName = 'insumos';
     middlewares = [Auth.authenticate()];
     searchFileds = {
-        nombre: MongoQuery.partialString,
-        'codigo.valor': MongoQuery.partialString,
-        tipo: MongoQuery.equalMatch,
+        nombre: (value: any) => {
+            if (value && value.charAt(0) === '^') {
+                const searchPattern = value.substring(1);
+                const escaped = searchPattern.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\$&');
+                return { $regex: escaped, $options: 'i' };
+            }
+            return value;
+        },
+        tipo: MongoQuery.inArray,
         estado: MongoQuery.equalMatch,
         requiereEspecificacion: MongoQuery.equalMatch,
     };

modules/recetas/recetas.routes.ts

@@ -2,7 +2,7 @@ import { asyncHandler, Request, Response } from '@andes/api-tool';
 import { MongoQuery, ResourceBase } from '@andes/core';
 import { Auth } from '../../auth/auth.class';
 import { Receta } from './receta-schema';
-import { buscarRecetas, getMotivosReceta, setEstadoDispensa, suspender, actualizarAppNotificada, cancelarDispensa, create, buscarRecetasPorProfesional } from './recetasController';
+import { buscarRecetas, getMotivosReceta, setEstadoDispensa, suspender, actualizarAppNotificada, cancelarDispensa, create, buscarRecetasPorProfesional, buscarRecetasConFiltros, verificarRecetaExistente } from './recetasController';
 import { ParamsIncorrect } from './recetas.error';
 
 class RecetasResource extends ResourceBase {
@@ -41,6 +41,26 @@ export const getByProfesional = async (req, res) => {
     res.json(result);
 };
 
+export const getConFiltros = async (req, res) => {
+    const result = await buscarRecetasConFiltros(req);
+    res.json(result);
+};
+
+export const getVerificarReceta = async (req, res) => {
+    try {
+        const { documento, sexo, conceptId } = req.query;
+        if (!documento || !sexo) {
+            const error = new ParamsIncorrect('Se requieren los parámetros documento y sexo');
+            return res.status(error.status).json(error);
+        }
+        const result = await verificarRecetaExistente(documento as string, sexo as string, conceptId as string);
+        res.json(result);
+    } catch (err) {
+        const status = (err as any).status || 400;
+        res.status(status).json(err);
+    }
+};
+
 export const patch = async (req, res) => {
     const operacion = req.body.op ? req.body.op.toLowerCase() : '';
     let result, status;
@@ -95,6 +115,8 @@ const authorizeByToken = async (req: Request, res: Response, next) =>
 RecetasRouter.use(Auth.authenticate());
 RecetasRouter.get('/recetas', authorizeByToken, asyncHandler(get));
 RecetasRouter.get('/recetas/motivos', asyncHandler(getMotivos));
-RecetasRouter.get('/recetas/profesional/:id', authorizeByToken,asyncHandler(getByProfesional));
+RecetasRouter.get('/recetas/filtros', authorizeByToken, asyncHandler(getConFiltros));
+RecetasRouter.get('/recetas/profesional/:id', authorizeByToken, asyncHandler(getByProfesional));
+RecetasRouter.get('/recetas/verificar', authorizeByToken, asyncHandler(getVerificarReceta));
 RecetasRouter.patch('/recetas', authorizeByToken, asyncHandler(patch));
 RecetasRouter.post('/recetas', authorizeByToken, asyncHandler(post));

modules/recetas/recetasController.ts

@@ -158,7 +158,7 @@ export async function buscarRecetas(req) {
             const estadoDispensaArray = params.estadoDispensa.replace(/ /g, '').split(',');
             options['estadoDispensaActual.tipo'] = { $in: estadoDispensaArray };
         } else {
-            options['estadoDispensaActual.tipo'] = 'sin-dispensa';
+            options['estadoActual.tipo'] = null;
         }
         const estadoArray = params.estado ? params.estado.replace(/ /g, '').split(',') : [];
         const fechaFin = params.fechaFin ? moment(params.fechaFin).endOf('day').toDate() : moment().endOf('day').toDate();
@@ -197,6 +197,7 @@ export async function buscarRecetas(req) {
             }
         }
         let recetas: any = await Receta.find(options);
+
         if (!recetas.length) {
             return [];
         }
@@ -221,6 +222,100 @@ export async function buscarRecetas(req) {
         return recetas;
     } catch (err) {
         await informarLog.error('buscarRecetas', { params, options }, err, req);
+
+        return err;
+    }
+}
+
+/**
+ * Busca recetas filtrando por rango de fechas y estado.
+ * Incluye estados de receta y de dispensa simultáneamente.
+ *
+ * Parámetros (req.query):
+ * - fechaInicio: fecha inicial del rango (opcional)
+ * - fechaFin: fecha final del rango (opcional)
+ * - estado: uno o varios estados separados por coma (opcional)
+ *
+ * Ejemplo de estados: 'pendiente,vigente,vencida,sin-dispensa,dispensada,dispensa-parcial'
+ */
+export async function buscarRecetasConFiltros(req) {
+    try {
+        const { fechaInicio, fechaFin, estado, documento, sexo } = req.query;
+        const filter: any = {};
+        const statusVal = req.query.status;
+        const estadoVal = estado;
+        let estadoParam = null;
+
+        if (estadoVal && statusVal) {
+            estadoParam = `${estadoVal},${statusVal}`;
+        } else {
+            estadoParam = estadoVal ?? statusVal;
+        }
+        if (!estadoParam || String(estadoParam).trim() === '') {
+            estadoParam = 'vigente';
+        }
+
+        // Validación mínima: al menos un filtro
+        if (!documento && !sexo && !estadoParam) {
+            throw new ParamsIncorrect();
+        }
+
+        // Filtro por rango de fechas sobre fechaRegistro
+        if (fechaInicio || fechaFin) {
+            filter['fechaRegistro'] = {};
+            if (fechaInicio) {
+                filter['fechaRegistro'].$gte = moment(fechaInicio, 'DD-MM-YYYY').startOf('day').toDate();
+            }
+            if (fechaFin) {
+                filter['fechaRegistro'].$lte = moment(fechaFin, 'DD-MM-YYYY').endOf('day').toDate();
+            }
+        } else {
+            // Default: último mes hasta hoy si no se especifican fechas
+            filter['fechaRegistro'] = {
+                $gte: moment().subtract(1, 'months').startOf('day').toDate(),
+                $lte: moment().endOf('day').toDate()
+            };
+        }
+
+        // Filtro por estado aplicado tanto a receta como a dispensa
+        if (estadoParam) {
+            const estadosRaw = String(estadoParam).replace(/ /g, '').split(',').filter(Boolean);
+            const incluyeTodas = estadosRaw.some(e => e.toLowerCase() === 'todas');
+            // Si llega "todas" (solo o incluido), no aplicar filtro de estado
+            if (!incluyeTodas) {
+                const estados = estadosRaw; // ya normalizado
+                if (estados.length) {
+                    const or: any[] = [];
+                    if (estados.length === 1) {
+                        const val = estados[0];
+                        or.push({ 'estadoActual.tipo': val });
+                        or.push({ 'estadoDispensaActual.tipo': val });
+                    } else {
+                        estados.forEach(val => {
+                            or.push({ 'estadoActual.tipo': val });
+                            or.push({ 'estadoDispensaActual.tipo': val });
+                        });
+                    }
+                    filter['$or'] = or;
+                }
+            } else {
+                // Forzar que se tome cualquier estadoActual.tipo
+                filter['estadoActual.tipo'] = { $exists: true };
+            }
+        }
+
+        // Filtros por datos del paciente
+        if (documento) {
+            filter['paciente.documento'] = documento;
+        }
+        if (sexo) {
+            filter['paciente.sexo'] = sexo;
+        }
+
+        const recetas = await Receta.find(filter);
+        return recetas;
+    } catch (err) {
+        await informarLog.error('buscarRecetasConFiltros', { query: req.query }, err, req);
         return err;
     }
 }
@@ -558,6 +653,11 @@ export async function create(req) {
             if (!pacienteAndes) {
                 throw new ParamsIncorrect('Paciente no encontrado');
             } else {
+                const fechaNacimientoReceta = pacienteRecetar.fechaNacimiento ? new Date(pacienteRecetar.fechaNacimiento) : null;
+                if (!pacienteAndes.fechaNacimiento && fechaNacimientoReceta && !Number.isNaN(fechaNacimientoReceta.getTime())) {
+                    pacienteAndes.fechaNacimiento = fechaNacimientoReceta;
+                    await pacienteAndes.save();
+                }
                 pacienteAndes.obraSocial = (!pacienteRecetar.obraSocial) ? null :
                     {
                         origen: pacienteRecetar.obraSocial.otraOS ? 'RECETAR' : 'PUCO',
@@ -682,8 +782,12 @@ export async function buscarRecetasPorProfesional(req) {
             filter['origenExterno.app'] = origenExternoApp;
         }
         if (excluirEstado) {
-            filter['estadoActual.tipo'] = { $nin: excluirEstado };
+            const estados = typeof excluirEstado === 'string'
+                ? excluirEstado.split(',').map((e: string) => e.trim())
+                : Array.isArray(excluirEstado) ? excluirEstado : [excluirEstado];
+            filter['estadoActual.tipo'] = { $nin: estados };
         }
+
         const recetas = await Receta.find(filter);
         return recetas;
     } catch (err) {
@@ -829,3 +933,48 @@ export async function actualizarEstadosDispensa() {
         await informarLog.error('actualizarEstadosDispensa', {}, error);
     }
 }
+
+/**
+ * Verifica si existe una receta vigente o pendiente para un paciente y un medicamento (por conceptId SNOMED)
+ * al momento en que se realiza la consulta.
+ *
+ * @param documento   - DNI del paciente (identificador común entre sistemas)
+ * @param sexo        - Sexo del paciente ('masculino' | 'femenino' | 'otro')
+ * @param conceptId   - conceptId SNOMED del medicamento
+ * @returns { existe: boolean, receta?: any }
+ */
+export async function verificarRecetaExistente(documento: string, sexo: string, conceptId: string) {
+    if (!documento) {
+        throw new ParamsIncorrect('Se requiere el documento (DNI) del paciente');
+    }
+    if (!sexo) {
+        throw new ParamsIncorrect('Se requiere el sexo del paciente');
+    }
+    if (!conceptId) {
+        throw new ParamsIncorrect('Se requiere el conceptId del medicamento');
+    }
+
+    const ahora = moment().toDate();
+    const parametro: any = await RecetasParametros.findOne({ key: 'fechaLimite' });
+    const days = (parametro && parametro.value) ? Number(parametro.value) : 30;
+    const fechaLimiteVigentes = moment().subtract(days, 'days').startOf('day').toDate();
+
+    const receta = await Receta.findOne({
+        'paciente.documento': documento,
+        'paciente.sexo': sexo,
+        'medicamento.concepto.conceptId': conceptId,
+        'estadoActual.tipo': { $in: ['vigente', 'pendiente'] },
+        'estadoDispensaActual.tipo': { $nin: ['dispensada'] },
+        $or: [
+            // Vigentes: que no hayan superado el límite de días desde su registro
+            { 'estadoActual.tipo': 'vigente', fechaRegistro: { $gte: fechaLimiteVigentes, $lte: ahora } },
+            // Pendientes: fechaRegistro futura (aún no activa pero pertenece al tratamiento)
+            { 'estadoActual.tipo': 'pendiente', fechaRegistro: { $lte: moment().add(10, 'days').endOf('day').toDate() } }
+        ]
+    }).sort({ fechaRegistro: -1 });
+
+    return {
+        existe: !!receta,
+        receta: receta || null
+    };
+}

modules/recetas/recetasInsumos/index.ts

@@ -0,0 +1,2 @@
+import './receta-insumo.events';
+export { RecetaInsumoRouter } from './receta-insumo.routes';

modules/recetas/recetasInsumos/receta-insumo.events.ts

@@ -0,0 +1,55 @@
+import { EventCore } from '@andes/event-bus';
+import { crearRecetaInsumo } from '../../recetas/recetasInsumos/recetaInsumosController';
+import { getProfesionActualizada } from '../../recetas/recetasController';
+import * as moment from 'moment';
+import { RecetaInsumo } from './receta-insumo.schema';
+import { createLog } from './../recetaLogs';
+
+EventCore.on('prestacion:recetaInsumo:create', async ({ prestacion, registro }) => {
+    const idRegistro = registro._id;
+    const profPrestacion = prestacion.solicitud.profesional;
+    const { profesionGrado, matriculaGrado, especialidades } = await getProfesionActualizada(profPrestacion.id);
+    const profesional = {
+        id: profPrestacion.id,
+        nombre: profPrestacion.nombre,
+        apellido: profPrestacion.apellido,
+        documento: profPrestacion.documento,
+        profesion: profesionGrado,
+        especialidad: especialidades,
+        matricula: matriculaGrado
+    };
+
+    const organizacion = {
+        id: prestacion.ejecucion.organizacion.id,
+        nombre: prestacion.ejecucion.organizacion.nombre
+    };
+
+    const dataReceta = {
+        idPrestacion: prestacion.id,
+        idRegistro,
+        fechaRegistro: prestacion.ejecucion.fecha || moment().toDate(),
+        fechaPrestacion: prestacion.ejecucion.fecha,
+        paciente: prestacion.paciente,
+        profesional,
+        organizacion,
+        insumo: null,
+        diagnostico: null,
+    };
+    try {
+        for (const insumo of registro.valor.insumos) {
+            const receta: any = await RecetaInsumo.findOne({
+                'insumo.id': insumo.generico.id,
+                'insumo.nombre': insumo.generico.nombre,
+                idRegistro
+            });
+            if (!receta) {
+                dataReceta.insumo = insumo;
+                await crearRecetaInsumo(dataReceta, prestacion.createdBy); // falta return
+            }
+
+        }
+    } catch (err) {
+        createLog.error('create', { dataReceta, prestacion, profesional }, err, { prestacion, registro });
+        return err;
+    }
+});

modules/recetas/recetasInsumos/receta-insumo.routes.ts

@@ -0,0 +1,48 @@
+import { MongoQuery, ResourceBase } from '@andes/core';
+import { Auth } from '../../../auth/auth.class';
+import { RecetaInsumo } from './receta-insumo.schema';
+import { asyncHandler, Request, Response } from '@andes/api-tool';
+import { create, buscarRecetasInsumos } from './recetaInsumosController';
+
+class RecetaInsumoResource extends ResourceBase {
+    Model = RecetaInsumo;
+    resourceName = 'recetaInsumos';
+    routesEnable = ['get, post'];
+    middlewares = [Auth.authenticate()];
+    searchFileds = {
+        paciente: {
+            field: 'paciente.id',
+            fn: MongoQuery.equalMatch
+        },
+        documento: {
+            field: 'paciente.documento',
+            fn: MongoQuery.equalMatch
+        }
+    };
+}
+
+export const post = async (req, res) => {
+    const resp = await create(req);
+    const status = resp?.status || resp?.errors || 200;
+    res.status(status).json(resp);
+};
+export const get = async (req, res) => {
+    const result = await buscarRecetasInsumos(req);
+    res.json(result);
+};
+export const RecetaInsumoCtr = new RecetaInsumoResource({});
+export const RecetaInsumoRouter = RecetaInsumoCtr.makeRoutes();
+
+const authorizeByToken = async (req: Request, res: Response, next) =>
+    Auth.authorizeByToken(req, res, next, [
+        'huds:visualizacionHuds',
+        'huds:visualizacionParcialHuds:laboratorio',
+        'huds:visualizacionParcialHuds:vacuna',
+        'huds:visualizacionParcialHuds:receta',
+        'huds:visualizacionParcialHuds:*',
+        'recetas:read'
+    ]);
+
+RecetaInsumoRouter.use(Auth.authenticate());
+RecetaInsumoRouter.get('/recetasInsumos', authorizeByToken, asyncHandler(get));
+RecetaInsumoRouter.post('/recetasInsumos', authorizeByToken, asyncHandler(post));