jpsoron commited on
Commit
abb3752
·
unverified ·
2 Parent(s): 88d524e9f05894

Merge pull request #8 from MateFerreyra/jps/impl-eventos

Browse files

Implementacion cola de eventos para informacion entrante de otros modulos

.env.example CHANGED
@@ -43,3 +43,21 @@ M2_TURNOS_URL=http://modulo2:8002
43
  M7_FACTURACION_URL=http://modulo7:8007
44
  M9_MONITOREO_URL=http://modulo9:8009
45
  M10_CORE_URL=http://modulo10:8010
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
43
  M7_FACTURACION_URL=http://modulo7:8007
44
  M9_MONITOREO_URL=http://modulo9:8009
45
  M10_CORE_URL=http://modulo10:8010
46
+
47
+ # ─── Bus de eventos del Core (M10) ─────────────────────────────────────────
48
+ # RABBITMQ_CONSUMER_ENABLED=true levanta el consumer de internacion.requests
49
+ # (cola + 5 event types ya dados de alta en el Core, ver M6_DISEÑO.md §7).
50
+ # Las credenciales del broker son CORE_SERVICE_EMAIL/CORE_SERVICE_PASSWORD.
51
+ RABBITMQ_CONSUMER_ENABLED=false
52
+ RABBITMQ_HOST=localhost
53
+ RABBITMQ_PORT=5672
54
+ RABBITMQ_VHOST=/
55
+ INTERNACION_REQUESTS_QUEUE=internacion.requests
56
+
57
+ # event_type_id de las notificaciones salientes de M6. Cada uno lo crea y
58
+ # comparte el módulo receptor (M1/M9/M7). Dejar comentado hasta tener el ID
59
+ # real: pydantic-settings no trata "KEY=" vacío como None, tira ValidationError.
60
+ # HCE_SOLICITUD_RESUELTA_EVENT_TYPE_ID=
61
+ # MONITOREO_ALTA_EVENT_TYPE_ID=
62
+ # MONITOREO_BAJA_EVENT_TYPE_ID=
63
+ # FACTURACION_CAMA_LISTA_EVENT_TYPE_ID=
app/config.py CHANGED
@@ -52,5 +52,33 @@ class Settings(BaseSettings):
52
  # Si True, no llama a módulos externos (útil para desarrollo local sin stack completo)
53
  mock_external_services: bool = True
54
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
55
 
56
  settings = Settings()
 
52
  # Si True, no llama a módulos externos (útil para desarrollo local sin stack completo)
53
  mock_external_services: bool = True
54
 
55
+ # ─── Bus de eventos del Core (M10): entrante ────────────────────────────
56
+ # M6 consume su propia cola de requests (`app/integrations/rabbit_consumer.py`),
57
+ # creada una vez en el Core (`POST /rabbit/queues`) — ver `M6_DISEÑO.md` §7.
58
+ # Las credenciales son las mismas que la cuenta de servicio ya usa contra el
59
+ # Core (`core_service_email`/`core_service_password`): ese email ya está
60
+ # provisionado como usuario de RabbitMQ. Host/puerto/vhost del broker
61
+ # compartido quedan pendientes de conseguir con el equipo de Core.
62
+ rabbitmq_host: str = "localhost"
63
+ rabbitmq_port: int = 5672
64
+ rabbitmq_vhost: str = "/"
65
+ internacion_requests_queue: str = "internacion.requests"
66
+
67
+ # Apaga el consumer por default: sin esto, dev/tests intentarían conectar contra
68
+ # `rabbitmq_host` (default "localhost") en cada arranque de la app, sin necesidad.
69
+ # Activar cuando se tenga el host/puerto/vhost real del broker compartido.
70
+ rabbitmq_consumer_enabled: bool = False
71
+
72
+ # ─── Bus de eventos del Core (M10): saliente ────────────────────────────
73
+ # `event_type_id` de las notificaciones que M6 publica hacia M1/M9/M7
74
+ # (`app/integrations/core_events.py::publish_event`). Cada uno lo crea y
75
+ # posee el módulo receptor, no M6 — quedan en `None` hasta que compartan el
76
+ # ID real. Mientras sea `None`, `publish_event` no dispara ningún request;
77
+ # la notificación sigue saliendo solo por el webhook REST directo actual.
78
+ hce_solicitud_resuelta_event_type_id: int | None = None
79
+ monitoreo_alta_event_type_id: int | None = None
80
+ monitoreo_baja_event_type_id: int | None = None
81
+ facturacion_cama_lista_event_type_id: int | None = None
82
+
83
 
84
  settings = Settings()
app/integrations/core_events.py ADDED
@@ -0,0 +1,33 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ """
2
+ Publicación de eventos salientes al bus del Core (M10): `POST /events/log`.
3
+
4
+ Cada notificación saliente de M6 (SOLICITUD_RESUELTA a M1, ALTA_MONITOREO/
5
+ BAJA_MONITOREO a M9, CAMA_LISTA a M7) apunta a un `event_type_id` que crea y
6
+ posee el módulo receptor, no M6 (ver `M6_DISEÑO.md` §7). Hasta que cada equipo
7
+ comparta su ID real, la settings correspondiente queda en `None` y
8
+ `publish_event` es un no-op explícito — no bloquea el flujo de negocio ni
9
+ genera tráfico contra el Core. El día que llegue el ID real, alcanza con
10
+ cargarlo en config: el código no cambia.
11
+ """
12
+ import json
13
+ import logging
14
+
15
+ from app.config import settings
16
+ from app.integrations._base import _post
17
+
18
+ logger = logging.getLogger(__name__)
19
+
20
+
21
+ def publish_event(event_type_id: int | None, payload: dict) -> bool:
22
+ if event_type_id is None:
23
+ logger.info(
24
+ "Evento no publicado (event_type_id todavía no configurado): %s", payload
25
+ )
26
+ return True
27
+
28
+ body = {
29
+ "event_type_id": event_type_id,
30
+ "publisher_module": "internacion",
31
+ "payload": json.dumps(payload),
32
+ }
33
+ return _post(f"{settings.m10_core_url}/events/log", body) is not None
app/integrations/facturacion.py CHANGED
@@ -8,6 +8,7 @@ M7 directamente de M1/HCE. M6 no actúa de intermediario de esa información.
8
  from datetime import date, datetime, timezone
9
 
10
  from app.config import settings
 
11
  from app.integrations._base import _post
12
 
13
 
@@ -18,6 +19,11 @@ def notify_cama_lista(cama_id: int, paciente_id: int) -> bool:
18
  `idEventoExterno` es la clave de idempotencia que usa M7: la derivamos de forma estable
19
  (cama + paciente + fecha del alta) para que un reintento del mismo evento no genere un
20
  alta duplicada en facturación.
 
 
 
 
 
21
  """
22
  if settings.mock_external_services:
23
  return True
@@ -29,32 +35,8 @@ def notify_cama_lista(cama_id: int, paciente_id: int) -> bool:
29
  "paciente_id": paciente_id,
30
  "timestamp_evento": datetime.now(timezone.utc).isoformat(),
31
  }
32
- return _post(
33
  f"{settings.m7_facturacion_url}/api/v1/webhooks/internacion/cama-lista", payload
34
  ) is not None
35
-
36
-
37
- def notify_cierre_cama(cama_id: int, paciente_id: int) -> bool:
38
- """
39
- Avisa a M7 que debe cerrar la facturación de la cama tras un alta médica.
40
-
41
- Se invoca ANTES del cambio de estado de la cama: el alta depende de que M7 confirme
42
- el cierre. `idEventoExterno` es la clave de idempotencia (cama + paciente + fecha).
43
- """
44
- if settings.mock_external_services:
45
- print(
46
- f"[SIMULACION] Request a M7 Facturación → cierre de cama "
47
- f"{cama_id} (paciente {paciente_id})"
48
- )
49
- return True
50
- id_evento_externo = f"M6-CIERRE-CAMA-{cama_id}-{paciente_id}-{date.today().isoformat()}"
51
- payload = {
52
- "evento": "CIERRE_CAMA",
53
- "idEventoExterno": id_evento_externo,
54
- "cama_id": cama_id,
55
- "paciente_id": paciente_id,
56
- "timestamp_evento": datetime.now(timezone.utc).isoformat(),
57
- }
58
- return _post(
59
- f"{settings.m7_facturacion_url}/api/v1/webhooks/internacion/cierre-cama", payload
60
- ) is not None
 
8
  from datetime import date, datetime, timezone
9
 
10
  from app.config import settings
11
+ from app.integrations import core_events
12
  from app.integrations._base import _post
13
 
14
 
 
19
  `idEventoExterno` es la clave de idempotencia que usa M7: la derivamos de forma estable
20
  (cama + paciente + fecha del alta) para que un reintento del mismo evento no genere un
21
  alta duplicada en facturación.
22
+
23
+ Además del webhook REST directo (sin cambios), publica el mismo evento al bus del Core
24
+ (CAMA_LISTA) vía `core_events.publish_event`. Es un no-op mientras
25
+ `facturacion_cama_lista_event_type_id` no esté configurado — M7 todavía no compartió
26
+ su `event_type_id` real (ver `M6_DISEÑO.md` §7).
27
  """
28
  if settings.mock_external_services:
29
  return True
 
35
  "paciente_id": paciente_id,
36
  "timestamp_evento": datetime.now(timezone.utc).isoformat(),
37
  }
38
+ ok_rest = _post(
39
  f"{settings.m7_facturacion_url}/api/v1/webhooks/internacion/cama-lista", payload
40
  ) is not None
41
+ core_events.publish_event(settings.facturacion_cama_lista_event_type_id, payload)
42
+ return ok_rest
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
app/integrations/hce.py CHANGED
@@ -3,6 +3,7 @@ M1 HCE — contraindicaciones y movimientos de pacientes.
3
  """
4
  from datetime import datetime, timezone
5
  from app.config import settings
 
6
  from app.integrations._base import _get, _post
7
 
8
 
@@ -42,7 +43,14 @@ def notify_resultado_solicitud(
42
  resultado: str,
43
  motivo: str | None = None,
44
  ) -> bool:
45
- """Notifica a M1 el resultado (APROBADA / RECHAZADA) de una solicitud. Retorna True si OK."""
 
 
 
 
 
 
 
46
  if settings.mock_external_services:
47
  return True
48
  payload = {
@@ -50,9 +58,16 @@ def notify_resultado_solicitud(
50
  "motivo": motivo,
51
  "timestamp": datetime.now(timezone.utc).isoformat(),
52
  }
53
- return _post(
54
  f"{settings.m1_hce_url}/api/v1/hce/solicitudes/{solicitud_hce_id}/resultado", payload
55
  ) is not None
 
 
 
 
 
 
 
56
 
57
 
58
  def notify_movimiento(
 
3
  """
4
  from datetime import datetime, timezone
5
  from app.config import settings
6
+ from app.integrations import core_events
7
  from app.integrations._base import _get, _post
8
 
9
 
 
43
  resultado: str,
44
  motivo: str | None = None,
45
  ) -> bool:
46
+ """
47
+ Notifica a M1 el resultado (APROBADA / RECHAZADA) de una solicitud. Retorna True si OK.
48
+
49
+ Además del webhook REST directo (sin cambios), publica el mismo evento al bus del Core
50
+ (SOLICITUD_RESUELTA) vía `core_events.publish_event`. Es un no-op mientras
51
+ `hce_solicitud_resuelta_event_type_id` no esté configurado — M1 todavía no compartió
52
+ su `event_type_id` real (ver `M6_DISEÑO.md` §7).
53
+ """
54
  if settings.mock_external_services:
55
  return True
56
  payload = {
 
58
  "motivo": motivo,
59
  "timestamp": datetime.now(timezone.utc).isoformat(),
60
  }
61
+ ok_rest = _post(
62
  f"{settings.m1_hce_url}/api/v1/hce/solicitudes/{solicitud_hce_id}/resultado", payload
63
  ) is not None
64
+ # El body REST no lleva solicitud_hce_id (va en el path); el evento del bus sí lo
65
+ # necesita, porque no hay URL que lo transporte implícitamente.
66
+ core_events.publish_event(
67
+ settings.hce_solicitud_resuelta_event_type_id,
68
+ {**payload, "solicitud_hce_id": solicitud_hce_id},
69
+ )
70
+ return ok_rest
71
 
72
 
73
  def notify_movimiento(
app/integrations/monitoreo.py CHANGED
@@ -3,10 +3,17 @@ M9 Monitoreo — altas y bajas de pacientes en monitoreo.
3
  """
4
  from datetime import datetime, timezone
5
  from app.config import settings
 
6
  from app.integrations._base import _post
7
 
8
 
9
  def notify_alta(paciente_id: int) -> bool:
 
 
 
 
 
 
10
  if settings.mock_external_services:
11
  return True
12
  payload = {
@@ -14,12 +21,15 @@ def notify_alta(paciente_id: int) -> bool:
14
  "paciente_id": paciente_id,
15
  "timestamp": datetime.now(timezone.utc).isoformat(),
16
  }
17
- return _post(
18
  f"{settings.m9_monitoreo_url}/api/v1/webhooks/internacion/alta-monitoreo", payload
19
  ) is not None
 
 
20
 
21
 
22
  def notify_baja(paciente_id: int) -> bool:
 
23
  if settings.mock_external_services:
24
  print(f"[SIMULACION] Request a M9 Monitoreo → baja de paciente {paciente_id}")
25
  return True
@@ -28,6 +38,8 @@ def notify_baja(paciente_id: int) -> bool:
28
  "paciente_id": paciente_id,
29
  "timestamp": datetime.now(timezone.utc).isoformat(),
30
  }
31
- return _post(
32
  f"{settings.m9_monitoreo_url}/api/v1/webhooks/internacion/baja-monitoreo", payload
33
  ) is not None
 
 
 
3
  """
4
  from datetime import datetime, timezone
5
  from app.config import settings
6
+ from app.integrations import core_events
7
  from app.integrations._base import _post
8
 
9
 
10
  def notify_alta(paciente_id: int) -> bool:
11
+ """
12
+ Además del webhook REST directo (sin cambios), publica el mismo evento al bus del
13
+ Core (ALTA_MONITOREO) vía `core_events.publish_event`. Es un no-op mientras
14
+ `monitoreo_alta_event_type_id` no esté configurado — M9 todavía no compartió su
15
+ `event_type_id` real (ver `M6_DISEÑO.md` §7).
16
+ """
17
  if settings.mock_external_services:
18
  return True
19
  payload = {
 
21
  "paciente_id": paciente_id,
22
  "timestamp": datetime.now(timezone.utc).isoformat(),
23
  }
24
+ ok_rest = _post(
25
  f"{settings.m9_monitoreo_url}/api/v1/webhooks/internacion/alta-monitoreo", payload
26
  ) is not None
27
+ core_events.publish_event(settings.monitoreo_alta_event_type_id, payload)
28
+ return ok_rest
29
 
30
 
31
  def notify_baja(paciente_id: int) -> bool:
32
+ """Mismo esquema que `notify_alta`, para BAJA_MONITOREO."""
33
  if settings.mock_external_services:
34
  print(f"[SIMULACION] Request a M9 Monitoreo → baja de paciente {paciente_id}")
35
  return True
 
38
  "paciente_id": paciente_id,
39
  "timestamp": datetime.now(timezone.utc).isoformat(),
40
  }
41
+ ok_rest = _post(
42
  f"{settings.m9_monitoreo_url}/api/v1/webhooks/internacion/baja-monitoreo", payload
43
  ) is not None
44
+ core_events.publish_event(settings.monitoreo_baja_event_type_id, payload)
45
+ return ok_rest
app/integrations/rabbit_consumer.py ADDED
@@ -0,0 +1,134 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ """
2
+ Consumer de `internacion.requests`: recibe por el bus del Core (M10) los mismos eventos
3
+ que hoy llegan como webhooks REST directos de M1/M9/M2 (`app/routers/webhooks.py`).
4
+
5
+ La cola y los 5 event types (`internacion.solicitud.creada`,
6
+ `internacion.alta-medica.registrada`, `internacion.alerta-emergencia.detectada`,
7
+ `internacion.alerta-resuelta.notificada`, `internacion.turno.cancelado`) ya están dados de
8
+ alta y bindeados en el Core — ver `M6_DISEÑO.md` §7. Este módulo solo consume: cada
9
+ mensaje se despacha a la misma función de servicio que usa el router REST equivalente, sin
10
+ lógica de negocio nueva. Cirugía urgente queda fuera (excluida de esta migración, ver
11
+ `M6_DISEÑO.md` §7): sigue siendo solo REST.
12
+
13
+ Los endpoints REST entrantes siguen activos sin cambios durante la transición — cada
14
+ equipo (M1/M9/M2) migra su emisor a su propio ritmo.
15
+ """
16
+ import asyncio
17
+ import json
18
+ import logging
19
+
20
+ import aio_pika
21
+ from supabase import Client
22
+
23
+ from app.config import settings
24
+ from app.dependencies import get_db
25
+ from app.schemas.reserva import CancelacionQuirofanoRequest
26
+ from app.schemas.solicitud import (
27
+ AlertaEmergenciaRequest,
28
+ AlertaResueltaRequest,
29
+ AltaMedicaWebhook,
30
+ SolicitudHceWebhook,
31
+ )
32
+ from app.services import solicitud_service
33
+
34
+ logger = logging.getLogger(__name__)
35
+
36
+
37
+ def _handle_solicitud(db: Client, payload: dict) -> None:
38
+ data = SolicitudHceWebhook.model_validate(payload)
39
+ solicitud_service.recibir_solicitud(db, data)
40
+
41
+
42
+ def _handle_alta_medica(db: Client, payload: dict) -> None:
43
+ data = AltaMedicaWebhook.model_validate(payload)
44
+ solicitud_service.procesar_alta_medica(db, data.paciente_id)
45
+
46
+
47
+ def _handle_alerta_emergencia(db: Client, payload: dict) -> None:
48
+ data = AlertaEmergenciaRequest.model_validate(payload)
49
+ solicitud_service.procesar_alerta_emergencia(db, data.paciente_id)
50
+
51
+
52
+ def _handle_alerta_resuelta(db: Client, payload: dict) -> None:
53
+ data = AlertaResueltaRequest.model_validate(payload)
54
+ solicitud_service.procesar_alerta_resuelta(db, data.paciente_id)
55
+
56
+
57
+ def _handle_turno_cancelado(db: Client, payload: dict) -> None:
58
+ # turno_id viaja en el payload del evento (en el webhook REST equivalente viene en el
59
+ # path: POST /turnos/{turno_id}/cancelacion). CancelacionQuirofanoRequest ignora los
60
+ # campos extra, así que se puede validar el resto del payload tal cual.
61
+ turno_id = payload["turno_id"]
62
+ data = CancelacionQuirofanoRequest.model_validate(payload)
63
+ solicitud_service.cancelar_reserva_por_turno(db, turno_id, data.motivo)
64
+
65
+
66
+ _HANDLERS = {
67
+ "internacion.solicitud.creada": _handle_solicitud,
68
+ "internacion.alta-medica.registrada": _handle_alta_medica,
69
+ "internacion.alerta-emergencia.detectada": _handle_alerta_emergencia,
70
+ "internacion.alerta-resuelta.notificada": _handle_alerta_resuelta,
71
+ "internacion.turno.cancelado": _handle_turno_cancelado,
72
+ }
73
+
74
+
75
+ def dispatch(event_type_name: str, payload: dict) -> None:
76
+ """
77
+ Despacha un mensaje ya parseado a la función de servicio correspondiente.
78
+ Lanza `KeyError` si `event_type_name` no está mapeado, o lo que levante el servicio de
79
+ negocio (`ValueError`, `HTTPException`, etc.) — `_on_message` decide ack/reject según
80
+ el resultado.
81
+ """
82
+ handler = _HANDLERS.get(event_type_name)
83
+ if handler is None:
84
+ raise KeyError(f"event_type_name no reconocido: {event_type_name!r}")
85
+ db = get_db()
86
+ handler(db, payload)
87
+
88
+
89
+ async def _on_message(message: aio_pika.abc.AbstractIncomingMessage) -> None:
90
+ try:
91
+ envelope = json.loads(message.body)
92
+ event_type_name = envelope["event_type_name"]
93
+ payload = json.loads(envelope["payload"])
94
+ except (json.JSONDecodeError, KeyError, TypeError) as e:
95
+ logger.error(
96
+ "Mensaje malformado en %s, se descarta: %s", settings.internacion_requests_queue, e
97
+ )
98
+ await message.reject(requeue=False)
99
+ return
100
+
101
+ try:
102
+ dispatch(event_type_name, payload)
103
+ except Exception:
104
+ logger.exception(
105
+ "Error procesando %s (log_id=%s) de %s",
106
+ event_type_name, envelope.get("log_id"), settings.internacion_requests_queue,
107
+ )
108
+ await message.reject(requeue=False)
109
+ return
110
+
111
+ await message.ack()
112
+
113
+
114
+ async def run_consumer() -> None:
115
+ """
116
+ Conecta a RabbitMQ y consume `internacion.requests` indefinidamente. Pensado para
117
+ correr como task de asyncio en el lifespan de FastAPI (`app/main.py`), gateado por
118
+ `settings.rabbitmq_consumer_enabled`.
119
+ """
120
+ connection = await aio_pika.connect_robust(
121
+ host=settings.rabbitmq_host,
122
+ port=settings.rabbitmq_port,
123
+ login=settings.core_service_email,
124
+ password=settings.core_service_password,
125
+ virtualhost=settings.rabbitmq_vhost,
126
+ )
127
+ async with connection:
128
+ channel = await connection.channel()
129
+ await channel.set_qos(prefetch_count=10)
130
+ # passive=True: la cola ya existe (creada vía POST /rabbit/queues del Core, con
131
+ # su propia DLQ) — no la redeclaramos con propiedades propias.
132
+ queue = await channel.declare_queue(settings.internacion_requests_queue, passive=True)
133
+ await queue.consume(_on_message)
134
+ await asyncio.Future()
app/main.py CHANGED
@@ -3,6 +3,8 @@ Health Grid - Módulo 6: Internación y Gestión de Camas
3
  API REST: http://localhost:8006/api/v1
4
  """
5
 
 
 
6
  import logging
7
  from contextlib import asynccontextmanager
8
  from fastapi import FastAPI, Request, status
@@ -11,6 +13,7 @@ from fastapi.responses import JSONResponse
11
 
12
  from app.config import settings
13
  from app.dependencies import create_access_token
 
14
 
15
  from app.routers import auth, camas, quirofanos, solicitudes, webhooks, auditoria
16
  from app.routers.webhooks import router_turnos
@@ -29,8 +32,19 @@ logging.basicConfig(
29
  @asynccontextmanager
30
  async def lifespan(app: FastAPI):
31
  logger.info("Conectado a Supabase — listo para operar")
 
 
 
 
 
 
32
  yield
33
 
 
 
 
 
 
34
 
35
  # ─── App ───────────────────────────────────────────────────────────────────
36
 
 
3
  API REST: http://localhost:8006/api/v1
4
  """
5
 
6
+ import asyncio
7
+ import contextlib
8
  import logging
9
  from contextlib import asynccontextmanager
10
  from fastapi import FastAPI, Request, status
 
13
 
14
  from app.config import settings
15
  from app.dependencies import create_access_token
16
+ from app.integrations import rabbit_consumer
17
 
18
  from app.routers import auth, camas, quirofanos, solicitudes, webhooks, auditoria
19
  from app.routers.webhooks import router_turnos
 
32
  @asynccontextmanager
33
  async def lifespan(app: FastAPI):
34
  logger.info("Conectado a Supabase — listo para operar")
35
+
36
+ consumer_task = None
37
+ if settings.rabbitmq_consumer_enabled:
38
+ logger.info("Iniciando consumer de %s", settings.internacion_requests_queue)
39
+ consumer_task = asyncio.create_task(rabbit_consumer.run_consumer())
40
+
41
  yield
42
 
43
+ if consumer_task is not None:
44
+ consumer_task.cancel()
45
+ with contextlib.suppress(asyncio.CancelledError):
46
+ await consumer_task
47
+
48
 
49
  # ─── App ───────────────────────────────────────────────────────────────────
50
 
app/services/solicitud_service.py CHANGED
@@ -15,7 +15,7 @@ from app.crud import solicitud as solicitud_crud
15
  from app.crud import cama as cama_crud
16
  from app.crud import reserva as reserva_crud
17
  from app.crud import auditoria as auditoria_crud
18
- from app.integrations import hce, monitoreo, core, facturacion
19
  from app.schemas.enums import (
20
  EntidadAuditoriaEnum,
21
  TipoEventoAuditoriaEnum,
@@ -323,18 +323,11 @@ def procesar_alta_medica(db: Client, paciente_id: int) -> Cama:
323
  status_code=404,
324
  detail={"codigo": "RECURSO_NO_ENCONTRADO", "mensaje": "No se encontró cama asignada al paciente"},
325
  )
326
- # El cierre de facturación y la baja de monitoreo deben completarse ANTES de cambiar
327
- # el estado de la cama: el alta depende de que ambos terceros confirmen.
328
- if not facturacion.notify_cierre_cama(cama_id=cama.id, paciente_id=paciente_id):
329
- raise HTTPException(
330
- status_code=502,
331
- detail={"codigo": "SERVICIO_EXTERNO_NO_DISPONIBLE", "mensaje": "No se pudo cerrar la cama en Facturación (M7)"},
332
- )
333
- if not monitoreo.notify_baja(paciente_id):
334
- raise HTTPException(
335
- status_code=502,
336
- detail={"codigo": "SERVICIO_EXTERNO_NO_DISPONIBLE", "mensaje": "No se pudo dar de baja el monitoreo (M9)"},
337
- )
338
 
339
  estado_previo = cama.estado
340
  cama.estado = EstadoCamaEnum.EN_LIMPIEZA.value
 
15
  from app.crud import cama as cama_crud
16
  from app.crud import reserva as reserva_crud
17
  from app.crud import auditoria as auditoria_crud
18
+ from app.integrations import hce, monitoreo, core
19
  from app.schemas.enums import (
20
  EntidadAuditoriaEnum,
21
  TipoEventoAuditoriaEnum,
 
323
  status_code=404,
324
  detail={"codigo": "RECURSO_NO_ENCONTRADO", "mensaje": "No se encontró cama asignada al paciente"},
325
  )
326
+ # Notificación asincrónica (fire-and-forget, M6_DISEÑO.md §2): M6 informa a M9 que
327
+ # el paciente sale de monitoreo, pero que M9 esté caído no debe revertir el alta.
328
+ # La notificación real a M7 (CAMA_LISTA) ocurre más adelante, al completar la
329
+ # limpieza (cama_service.py), también fire-and-forget.
330
+ monitoreo.notify_baja(paciente_id)
 
 
 
 
 
 
 
331
 
332
  estado_previo = cama.estado
333
  cama.estado = EstadoCamaEnum.EN_LIMPIEZA.value
documentation/M6_DISEÑO.md CHANGED
@@ -248,7 +248,6 @@ Si `origen = CIRUGIA_PROGRAMADA`, antes de aprobar se valida el turno quirúrgic
248
 
249
  | Módulo | Endpoint | Cuándo |
250
  |--------|----------|--------|
251
- | M10 Core | `POST /auth/validate-token` | En cada request (middleware JWT) |
252
  | M10 Core | `GET /usuarios/{pacienteId}` | Al aprobar una internación (datos del paciente) |
253
  | M1 HCE | `GET /hce/pacientes/{pacienteId}/contraindicaciones` | Al aprobar una internación |
254
  | M1 HCE | `GET /hce/pacientes/{pacienteId}` | Al mostrar el detalle del paciente internado en una cama |
@@ -261,6 +260,64 @@ Si `origen = CIRUGIA_PROGRAMADA`, antes de aprobar se valida el turno quirúrgic
261
 
262
  Todos los endpoints `[EXT]` (los que expone otro módulo) se mockean localmente para la 2da entrega. El mock vive en la capa de clientes HTTP: la misma interfaz que en producción, pero devolviendo respuestas canned. Esto permite que la 3ra entrega solo cambie la URL base del cliente, sin tocar la lógica de servicios.
263
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
264
  ---
265
 
266
  ## 8. Contrato de API (recursos propios)
@@ -434,3 +491,16 @@ No hay lookup aparte (`GET /roles`, `GET /users/{id}`) ni verificación de JWT d
434
  26. **Nuevo endpoint `POST /auth/sso-exchange`.** Canjea un ticket SSO de un solo uso del Core (`app/routers/auth.py`, activo con `SSO_ENABLED=true`) por una sesión propia de M6: JWT HS256 con el rol ya resuelto. Request `{ticket}`; response `{token, user, rol}`; errores `401` (ticket inválido/usado/expirado), `403` (roles del usuario sin mapeo a M6), `404` (SSO deshabilitado), `502` (Core inalcanzable). Actualizar `M6_openapi.json` con este endpoint.
435
  27. **Eliminado el lookup `GET /roles` y la verificación de JWT del Core por-request.** El rol ya no se resuelve con una llamada aparte cacheada: viene directo en `user.roles[]` de la respuesta del canje SSO (`models.AuthResponse` → `models.User` → `models.Role`). Se retiraron `core_auth.resolve_user_roles`, `_fetch_roles_index`, `verify_core_token`, `get_signing_key` y sus caches (`_roles_index_cache`, `_jwks_cache`); con ellos, las settings `jwks_cache_ttl_seconds`/`core_roles_cache_ttl_seconds`. Se conserva `map_core_roles_to_internal` (§11), que ahora traduce `user.roles[].name` en vez de un índice cacheado.
436
  28. **`app/config.py::auth_mode` reemplazado por `sso_enabled`.** Ya no existe un modo de validación por-request alternativo — la sesión de M6 es siempre HS256 propia. `sso_enabled` (default `False`) solo habilita/deshabilita el endpoint de canje.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
248
 
249
  | Módulo | Endpoint | Cuándo |
250
  |--------|----------|--------|
 
251
  | M10 Core | `GET /usuarios/{pacienteId}` | Al aprobar una internación (datos del paciente) |
252
  | M1 HCE | `GET /hce/pacientes/{pacienteId}/contraindicaciones` | Al aprobar una internación |
253
  | M1 HCE | `GET /hce/pacientes/{pacienteId}` | Al mostrar el detalle del paciente internado en una cama |
 
260
 
261
  Todos los endpoints `[EXT]` (los que expone otro módulo) se mockean localmente para la 2da entrega. El mock vive en la capa de clientes HTTP: la misma interfaz que en producción, pero devolviendo respuestas canned. Esto permite que la 3ra entrega solo cambie la URL base del cliente, sin tocar la lógica de servicios.
262
 
263
+ ### 7.5 Bus de eventos del Core (M10): migración en curso
264
+
265
+ Los webhooks REST de §7.1 tienen dos problemas: (1) exigen `get_current_user` (JWT de
266
+ usuario) pero M1/M9/M2 no tienen un usuario humano detrás de un webhook — no hay forma
267
+ legítima de que llamen hoy sin credenciales que no deberían tener; (2) son integraciones
268
+ point-to-point ad hoc, cuando el Core ya expone un bus de eventos pensado para esto
269
+ (`documentation/integrations/M10_integration.md`, "Tutorial: Comunicación entre
270
+ microservicios"): *"RabbitMQ para escuchar; Core para configurar y publicar."* Migrar a
271
+ la cola resuelve el problema de auth (se consume con credenciales RabbitMQ propias, no un
272
+ JWT de usuario) y suma at-least-once delivery + DLQ que hoy no existen.
273
+
274
+ **Lado entrante — ya migrado, en paralelo con REST.** Cola propia `internacion.requests`
275
+ (+ `internacion.requests.dlq`) y 5 event types bindeados, dados de alta en el Core real:
276
+
277
+ | Evento | Id | Reemplaza (REST) | Emisor | Payload |
278
+ |---|---|---|---|---|
279
+ | `internacion.solicitud.creada` | 14 | `POST /webhooks/hce/solicitud` | M1 | `SolicitudHceWebhook` |
280
+ | `internacion.alta-medica.registrada` | 15 | `POST /webhooks/hce/alta-medica` | M1 | `AltaMedicaWebhook` |
281
+ | `internacion.alerta-emergencia.detectada` | 16 | `POST /webhooks/monitoreo/alerta-emergencia` | M9 | `AlertaEmergenciaRequest` |
282
+ | `internacion.alerta-resuelta.notificada` | 17 | `POST /webhooks/monitoreo/alerta-resuelta` | M9 | `AlertaResueltaRequest` |
283
+ | `internacion.turno.cancelado` | 18 | `POST /turnos/{turnoId}/cancelacion` | M2 | `CancelacionQuirofanoRequest` + `turno_id` (viaja en el payload; en el REST equivalente viene del path) |
284
+
285
+ Los 5 son notificaciones fire-and-forget (sin `correlation_id`/`response_event_id`), y
286
+ reusan tal cual los schemas Pydantic del webhook REST equivalente. El consumer
287
+ (`app/integrations/rabbit_consumer.py`) despacha por `event_type_name` a la misma función
288
+ de servicio que ya usa el router REST (`solicitud_service.recibir_solicitud`,
289
+ `procesar_alta_medica`, `procesar_alerta_emergencia`, `procesar_alerta_resuelta`,
290
+ `cancelar_reserva_por_turno`) — cero lógica de negocio nueva, incluida la deduplicación
291
+ por id de origen (§6). Gateado por `settings.rabbitmq_consumer_enabled` (default `False`:
292
+ falta el host/puerto/vhost real del broker compartido — las credenciales sí son las
293
+ mismas `core_service_email`/`core_service_password` de siempre).
294
+
295
+ **Los endpoints REST de §7.1 se mantienen activos sin cambios** durante la transición —
296
+ cada equipo (M1/M9/M2) migra su emisor a su propio ritmo; se retiran recién cuando los
297
+ tres confirmen que publican por la cola.
298
+
299
+ **Cirugía urgente queda excluida** de esta migración: `POST /webhooks/hce/cirugia-urgente`
300
+ devuelve sincrónicamente qué quirófano/reserva se asignó y qué reservas se desplazaron —
301
+ no hay hoy un canal async equivalente. Migrarla requiere antes acordar con M1 un evento de
302
+ respuesta (`correlation_id` + `response_event_id`). Sigue siendo solo REST.
303
+
304
+ **Lado saliente — código listo, apagado hasta tener los `event_type_id` reales.** Las 4
305
+ notificaciones de §7.2 (`SOLICITUD_RESUELTA`, `ALTA_MONITOREO`, `BAJA_MONITOREO`,
306
+ `CAMA_LISTA`) siguen el mismo bus, pero el evento y la cola los crea y posee **el
307
+ receptor** (M1/M9/M7), no M6 — por la misma regla del tutorial que aplica al revés en
308
+ §7.1. M6 todavía no tiene esos `event_type_id` porque los equipos no respondieron.
309
+
310
+ En vez de crear infraestructura mock en el Core (tráfico real sin nadie consumiéndolo),
311
+ `app/integrations/core_events.py::publish_event(event_type_id, payload)` es un no-op
312
+ explícito mientras `event_type_id is None` (settings `hce_solicitud_resuelta_event_type_id`,
313
+ `monitoreo_alta_event_type_id`, `monitoreo_baja_event_type_id`,
314
+ `facturacion_cama_lista_event_type_id`, todas `None` por default). Las 4 funciones
315
+ `notify_*` (`hce.notify_resultado_solicitud`, `monitoreo.notify_alta`/`notify_baja`,
316
+ `facturacion.notify_cama_lista`) hacen **dual-write**: siguen llamando al webhook REST
317
+ directo exactamente como hoy (sin cambios observables) y además llaman a `publish_event`,
318
+ que hoy no dispara nada. El día que cada equipo comparta su ID, se carga en config — sin
319
+ tocar código — y empieza a salir por las dos vías hasta coordinar cuándo retirar la REST.
320
+
321
  ---
322
 
323
  ## 8. Contrato de API (recursos propios)
 
491
  26. **Nuevo endpoint `POST /auth/sso-exchange`.** Canjea un ticket SSO de un solo uso del Core (`app/routers/auth.py`, activo con `SSO_ENABLED=true`) por una sesión propia de M6: JWT HS256 con el rol ya resuelto. Request `{ticket}`; response `{token, user, rol}`; errores `401` (ticket inválido/usado/expirado), `403` (roles del usuario sin mapeo a M6), `404` (SSO deshabilitado), `502` (Core inalcanzable). Actualizar `M6_openapi.json` con este endpoint.
492
  27. **Eliminado el lookup `GET /roles` y la verificación de JWT del Core por-request.** El rol ya no se resuelve con una llamada aparte cacheada: viene directo en `user.roles[]` de la respuesta del canje SSO (`models.AuthResponse` → `models.User` → `models.Role`). Se retiraron `core_auth.resolve_user_roles`, `_fetch_roles_index`, `verify_core_token`, `get_signing_key` y sus caches (`_roles_index_cache`, `_jwks_cache`); con ellos, las settings `jwks_cache_ttl_seconds`/`core_roles_cache_ttl_seconds`. Se conserva `map_core_roles_to_internal` (§11), que ahora traduce `user.roles[].name` en vez de un índice cacheado.
493
  28. **`app/config.py::auth_mode` reemplazado por `sso_enabled`.** Ya no existe un modo de validación por-request alternativo — la sesión de M6 es siempre HS256 propia. `sso_enabled` (default `False`) solo habilita/deshabilita el endpoint de canje.
494
+
495
+ ### 14.6 Migración de webhooks entrantes al bus de eventos del Core (2026-07)
496
+
497
+ 29. **Cola `internacion.requests` + 5 event types dados de alta en el Core real** (ids 14–18: `internacion.solicitud.creada`, `internacion.alta-medica.registrada`, `internacion.alerta-emergencia.detectada`, `internacion.alerta-resuelta.notificada`, `internacion.turno.cancelado`), bindeados a esa cola. Reemplazan, en paralelo con REST durante la transición, a los webhooks entrantes de §7.1 (excepto cirugía urgente, excluida — ver §7.5).
498
+ 30. **Nuevo consumer `app/integrations/rabbit_consumer.py`** (`aio-pika`, gateado por `settings.rabbitmq_consumer_enabled`, default `False` hasta tener host/puerto/vhost real del broker). Despacha por `event_type_name` a las mismas funciones de servicio que ya usa el router REST — sin lógica de negocio nueva.
499
+ 31. **Nuevo publisher `app/integrations/core_events.py::publish_event`** para las 4 notificaciones salientes de §7.2. No-op explícito mientras el `event_type_id` correspondiente sea `None` (default hasta que M1/M9/M7 compartan el suyo — cada uno crea y posee su propio evento, no M6). Las 4 funciones `notify_*` (`hce.notify_resultado_solicitud`, `monitoreo.notify_alta`/`notify_baja`, `facturacion.notify_cama_lista`) quedan en dual-write: REST sin cambios + `publish_event` adicional.
500
+ 32. **Sin infraestructura mock creada en el Core para el lado saliente.** Se descartó explícitamente crear event types/colas placeholder en el Core compartido para simular a M1/M9/M7 — hubiera generado tráfico real sin receptor. El código queda listo y probado; activar la publicación real es cambiar 4 valores de config, sin tocar código.
501
+
502
+ ### 14.7 Eliminación de código zombie en la integración con M7/M9 (2026-07)
503
+
504
+ 33. **Eliminado `facturacion.notify_cierre_cama`.** Apuntaba a `POST /api/v1/webhooks/internacion/cierre-cama`, un endpoint que nunca estuvo en la tabla de webhooks salientes (§7.2) ni pasó por la revisión contra el backend real de M7 que sí tuvo `notify_cama_lista` (changelog #14). Estaba activamente cableada en `procesar_alta_medica` y era **bloqueante**: `if not facturacion.notify_cierre_cama(...): raise 502` — con `mock_external_services=False` en producción, cualquier alta médica real hubiera fallado con `502` contra un endpoint que M7 nunca implementó. Sin test para el camino real (pasaba siempre por el atajo de `mock_external_services=True`).
505
+ 34. **Corregido el gating bloqueante de `monitoreo.notify_baja` en `procesar_alta_medica`.** Era el único de los 5 call sites de `notify_alta`/`notify_baja` en todo el código que trataba la llamada como bloqueante (`if not ...: raise 502`); los otros 4 (`cama_service.py` ingreso/traslado, `solicitud_service.py` aprobar internación/traslado) ya la tratan fire-and-forget. Alineado con el resto del código y con el principio de §2 ("que el receptor esté caído no debe revertir el alta del paciente"): ahora es `monitoreo.notify_baja(paciente_id)` sin gate.
506
+ 35. **El alta médica ya no depende de M7 ni M9 para completarse.** La notificación real a M7 (`CAMA_LISTA`) sigue ocurriendo, fire-and-forget, más adelante en el flujo (al completar la limpieza, `cama_service.py`). Blindado con tests: `test_alta_medica_ok_aunque_monitoreo_falle` y `test_alta_medica_no_llama_a_facturacion` (`tests/test_webhooks.py`).
documentation/M6_EVENTOS_RABBITMQ.md ADDED
@@ -0,0 +1,209 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # Bus de eventos del Core (M10): cola y eventos de M6
2
+
3
+ **Health Grid · Módulo 6 (Internación y Gestión de Camas)**
4
+
5
+ > Referencia completa de la infraestructura de RabbitMQ/eventos que M6 tiene dada de alta en el Core y de cómo se conecta con el código. Para el contrato genérico del bus (cómo crear colas/eventos/bindings, formato del envelope) ver [`integrations/M10_integration.md`](integrations/M10_integration.md). Para el porqué de la migración y su alcance, ver [`M6_DISEÑO.md`](M6_DISEÑO.md) §7.5.
6
+
7
+ ---
8
+
9
+ ## 1. Resumen
10
+
11
+ M6 recibe notificaciones de M1 (HCE), M9 (Monitoreo) y M2 (Turnos) por dos vías en paralelo durante la transición:
12
+
13
+ - **REST directo** (`app/routers/webhooks.py`) — el mecanismo original, sigue activo sin cambios.
14
+ - **Bus de eventos del Core** (RabbitMQ, configurado y creado vía la API del Core) — el mecanismo nuevo, hacia el que se está migrando.
15
+
16
+ Del lado saliente (M6 → M1/M9/M7), el código de publicación al bus ya está escrito y conectado, pero **apagado**: no hay tráfico real hasta que cada equipo receptor comparta su `event_type_id`.
17
+
18
+ Cirugía urgente (`POST /webhooks/hce/cirugia-urgente`) queda fuera de esta migración — sigue siendo solo REST (ver §5).
19
+
20
+ ---
21
+
22
+ ## 2. Infraestructura creada en el Core (real, ya ejecutada)
23
+
24
+ ### 2.1 Cola
25
+
26
+ | Cola | Tipo | DLQ |
27
+ |---|---|---|
28
+ | `internacion.requests` | `requests` | `internacion.requests.dlq` |
29
+
30
+ Creada con:
31
+
32
+ ```http
33
+ POST /rabbit/queues
34
+ Authorization: Bearer <token cuenta de servicio>
35
+ Content-Type: application/json
36
+
37
+ { "queue_name": "internacion", "queue_type": "requests" }
38
+ ```
39
+
40
+ M6 es un único consumer sobre esta cola; distingue el tipo de mensaje por `event_type_name` del envelope (ver §4), igual que antes distinguía por el path del webhook REST.
41
+
42
+ ### 2.2 Event types entrantes (M1/M9/M2 → M6)
43
+
44
+ Los 5 eventos que otros módulos usan para mandarle "requests" a M6, todos bindeados a `internacion.requests`:
45
+
46
+ | `event_type_id` | `name` | Emisor | Reemplaza (REST) | Payload (schema Pydantic) |
47
+ |---|---|---|---|---|
48
+ | **14** | `internacion.solicitud.creada` | M1 HCE | `POST /webhooks/hce/solicitud` | `SolicitudHceWebhook` |
49
+ | **15** | `internacion.alta-medica.registrada` | M1 HCE | `POST /webhooks/hce/alta-medica` | `AltaMedicaWebhook` |
50
+ | **16** | `internacion.alerta-emergencia.detectada` | M9 Monitoreo | `POST /webhooks/monitoreo/alerta-emergencia` | `AlertaEmergenciaRequest` |
51
+ | **17** | `internacion.alerta-resuelta.notificada` | M9 Monitoreo | `POST /webhooks/monitoreo/alerta-resuelta` | `AlertaResueltaRequest` |
52
+ | **18** | `internacion.turno.cancelado` | M2 Turnos | `POST /turnos/{turnoId}/cancelacion` | `CancelacionQuirofanoRequest` + `turno_id` |
53
+
54
+ Todos `source_module: "internacion"`. Ninguno lleva `correlation_id`/`response_event_id`: son notificaciones fire-and-forget, no esperan respuesta.
55
+
56
+ **Nota sobre `internacion.turno.cancelado` (id 18):** en el REST equivalente, `turno_id` viaja en el path (`/turnos/{turnoId}/cancelacion`). Como el bus no tiene "path", el payload del evento **debe incluir** `turno_id` explícitamente junto al resto de los campos de `CancelacionQuirofanoRequest` (`motivo`, `tipo_cancelacion`, `timestamp`).
57
+
58
+ Creados con (uno por fila):
59
+
60
+ ```http
61
+ POST /events/types
62
+ Authorization: Bearer <token cuenta de servicio>
63
+ Content-Type: application/json
64
+
65
+ { "name": "internacion.solicitud.creada", "description": "...", "source_module": "internacion" }
66
+ ```
67
+
68
+ ### 2.3 Bindings
69
+
70
+ Los 5 event types de arriba están bindeados a `internacion.requests`:
71
+
72
+ ```http
73
+ POST /rabbit/bindings
74
+ Authorization: Bearer <token cuenta de servicio>
75
+ Content-Type: application/json
76
+
77
+ { "event_id": 14, "queue_name": "internacion.requests" }
78
+ ```
79
+
80
+ (repetido para los ids 15, 16, 17 y 18)
81
+
82
+ ### 2.4 Lo que NO se creó
83
+
84
+ No hay ninguna cola ni event type mock/placeholder para el lado saliente (§5). Se decidió explícitamente no generar infraestructura ni tráfico contra el Core compartido para simular a M1/M9/M7 — ver `M6_DISEÑO.md` §14.6, punto 32.
85
+
86
+ ---
87
+
88
+ ## 3. Credenciales y conexión
89
+
90
+ - **API REST del Core** (alta de colas/eventos/bindings, `POST /events/log`): cuenta de servicio de M6, `CORE_SERVICE_EMAIL`/`CORE_SERVICE_PASSWORD` (`.env`). Es la misma cuenta que M6 ya usa para las llamadas salientes a M1/M2/M7/M10 (`app/integrations/core_auth.py::get_service_token`).
91
+ - **Broker RabbitMQ** (consumo directo de la cola): **las mismas credenciales** — el email de la cuenta de servicio ya está provisionado como usuario de RabbitMQ (confirmado: `POST /rabbit/queues` y `POST /rabbit/bindings` exigen que el usuario autenticado exista como usuario de RabbitMQ, y ambas llamadas funcionaron).
92
+ - **Host/puerto/vhost del broker:** pendiente de conseguir con el equipo de Core — hoy son placeholders (`localhost:5672`, vhost `/`). Sin este dato, el consumer no puede conectar de verdad (ver §6).
93
+
94
+ ---
95
+
96
+ ## 4. Formato de los mensajes
97
+
98
+ El mensaje que llega por RabbitMQ tiene un envelope externo (lo arma el Core), y adentro un `payload` que viaja **como string JSON**:
99
+
100
+ ```json
101
+ {
102
+ "event_type_id": 15,
103
+ "event_type_name": "internacion.alta-medica.registrada",
104
+ "source_module": "internacion",
105
+ "publisher_module": "hce",
106
+ "log_id": 89,
107
+ "payload": "{\"paciente_id\": 999, \"medico_firmante_id\": 1, \"tipo_alta\": \"ALTA_MEDICA\", \"timestamp\": \"2026-07-09T12:00:00Z\"}",
108
+ "published_at": "2026-07-10T01:24:06Z"
109
+ }
110
+ ```
111
+
112
+ El consumer de M6 (§6) parsea primero el envelope, después el `payload` interno, y recién ahí valida contra el schema Pydantic correspondiente.
113
+
114
+ ---
115
+
116
+ ## 5. Qué queda fuera de esta migración
117
+
118
+ **Cirugía urgente** (`POST /webhooks/hce/cirugia-urgente`) no tiene evento en el bus. El webhook REST devuelve sincrónicamente qué quirófano/reserva se asignó y qué reservas se desplazaron; no existe hoy un canal de respuesta asíncrono equivalente. Migrarla requeriría acordar con M1 un evento de respuesta (`correlation_id` + `response_event_id`, como el patrón `billing`/`appointments` de `M10_integration.md`). Sigue siendo solo REST.
119
+
120
+ **Los 5 endpoints REST de `app/routers/webhooks.py` (equivalentes a los eventos de §2.2) se mantienen activos sin cambios** mientras dura la transición. No hay fecha de corte: se retiran cuando M1, M9 y M2 confirmen que ya publican por la cola.
121
+
122
+ ---
123
+
124
+ ## 6. Lado entrante: el consumer (`app/integrations/rabbit_consumer.py`)
125
+
126
+ Cliente async sobre `aio-pika`. Por cada mensaje de `internacion.requests`:
127
+
128
+ 1. Parsea el envelope externo y extrae `event_type_name` y `payload` (como string).
129
+ 2. Parsea `payload` con `json.loads`.
130
+ 3. Despacha por `event_type_name` (`dispatch()`) a la **misma función de servicio** que usa el router REST — sin lógica de negocio nueva:
131
+
132
+ | `event_type_name` | Función de servicio |
133
+ |---|---|
134
+ | `internacion.solicitud.creada` | `solicitud_service.recibir_solicitud` |
135
+ | `internacion.alta-medica.registrada` | `solicitud_service.procesar_alta_medica` |
136
+ | `internacion.alerta-emergencia.detectada` | `solicitud_service.procesar_alerta_emergencia` |
137
+ | `internacion.alerta-resuelta.notificada` | `solicitud_service.procesar_alerta_resuelta` |
138
+ | `internacion.turno.cancelado` | `solicitud_service.cancelar_reserva_por_turno` |
139
+
140
+ 4. Si el procesamiento fue exitoso, hace `ack`. Si el JSON es malformado, el `event_type_name` no está mapeado, o el servicio de negocio lanza una excepción, hace `reject(requeue=False)` — el mensaje cae a `internacion.requests.dlq` en vez de reintentarse en loop.
141
+
142
+ La deduplicación por id de origen (`solicitud_hce_id`, etc., exigida en `M6_DISEÑO.md` §6) sigue viviendo dentro de esas mismas funciones de servicio — no se reimplementó nada.
143
+
144
+ **Wiring:** `app/main.py` arranca `rabbit_consumer.run_consumer()` como task de `asyncio` en el `lifespan`, solo si `settings.rabbitmq_consumer_enabled` es `True` (default `False` — ver §3, falta el broker real). Al apagar la app, la task se cancela prolijamente.
145
+
146
+ **Verificado en vivo (2026-07):** se publicó un evento real contra el id 15 (`POST /events/log`) y se confirmó que `dispatch()` lo procesa de punta a punta: parseo → validación Pydantic → `procesar_alta_medica` → la cama pasa a `EN_LIMPIEZA` → `ack`. Esto prueba la lógica de consumo; falta conectar contra el broker real para que corra en producción.
147
+
148
+ ---
149
+
150
+ ## 7. Lado saliente: el publisher (`app/integrations/core_events.py`)
151
+
152
+ `publish_event(event_type_id: int | None, payload: dict) -> bool`:
153
+
154
+ - Si `event_type_id is None` → **no-op**: loguea a nivel `info` y devuelve `True`, sin ningún request HTTP.
155
+ - Si hay un id configurado → `POST /events/log` real contra el Core (`{"event_type_id", "publisher_module": "internacion", "payload": json.dumps(payload)}`).
156
+
157
+ Los 4 puntos de notificación saliente de M6 (`M6_DISEÑO.md` §7.2) hacen **dual-write**: siguen llamando al webhook REST directo exactamente como antes, y además llaman a `publish_event`:
158
+
159
+ | Función | Notificación | Receptor | Config del `event_type_id` |
160
+ |---|---|---|---|
161
+ | `hce.notify_resultado_solicitud` | `SOLICITUD_RESUELTA` | M1 HCE | `hce_solicitud_resuelta_event_type_id` |
162
+ | `monitoreo.notify_alta` | `ALTA_MONITOREO` | M9 Monitoreo | `monitoreo_alta_event_type_id` |
163
+ | `monitoreo.notify_baja` | `BAJA_MONITOREO` | M9 Monitoreo | `monitoreo_baja_event_type_id` |
164
+ | `facturacion.notify_cama_lista` | `CAMA_LISTA` | M7 Facturación | `facturacion_cama_lista_event_type_id` |
165
+
166
+ Las 4 settings de la tercera columna arrancan en `None` (default) — **el evento y la cola de cada uno los crea y comparte el módulo receptor**, no M6 (misma regla que aplica al revés en §2.2). Hoy ninguno de los tres equipos compartió su id.
167
+
168
+ **Cómo activar cuando llegue el id real:** cargar el valor en `.env` (o `.env.example` según el entorno) — cero cambios de código. A partir de ahí, la notificación sale por las dos vías (REST + bus) hasta que se coordine con ese equipo cuándo retirar la llamada REST directa.
169
+
170
+ ---
171
+
172
+ ## 8. Configuración (`app/config.py` / `.env`)
173
+
174
+ ```bash
175
+ # Consumer entrante
176
+ RABBITMQ_CONSUMER_ENABLED=false # true cuando se tenga el broker real
177
+ RABBITMQ_HOST=localhost # placeholder — pendiente el dato real del broker compartido
178
+ RABBITMQ_PORT=5672
179
+ RABBITMQ_VHOST=/
180
+ INTERNACION_REQUESTS_QUEUE=internacion.requests
181
+
182
+ # Publisher saliente — dejar comentado hasta tener el id real (pydantic-settings
183
+ # no trata "KEY=" vacío como None, tira ValidationError si se descomenta sin valor)
184
+ # HCE_SOLICITUD_RESUELTA_EVENT_TYPE_ID=
185
+ # MONITOREO_ALTA_EVENT_TYPE_ID=
186
+ # MONITOREO_BAJA_EVENT_TYPE_ID=
187
+ # FACTURACION_CAMA_LISTA_EVENT_TYPE_ID=
188
+ ```
189
+
190
+ Las credenciales del broker (`login`/`password` en `aio_pika.connect_robust`) son `CORE_SERVICE_EMAIL`/`CORE_SERVICE_PASSWORD`, ya definidas para el resto de la integración con el Core — no hay settings de usuario/password nuevas para RabbitMQ.
191
+
192
+ ---
193
+
194
+ ## 9. Pendientes
195
+
196
+ - **Host/puerto/vhost reales del broker RabbitMQ compartido** — sin esto, `RABBITMQ_CONSUMER_ENABLED=true` no puede conectar. Único bloqueante para que el consumer corra contra el broker de verdad.
197
+ - **`event_type_id` de M1** (`SOLICITUD_RESUELTA`) — compartir con M6 el id de un evento que M1 debe crear y bindear a su propia cola.
198
+ - **`event_type_id` de M9** (`ALTA_MONITOREO`, `BAJA_MONITOREO`) — ídem, dos eventos que M9 debe crear.
199
+ - **`event_type_id` de M7** (`CAMA_LISTA`) — ídem, un evento que M7 debe crear.
200
+ - **Coordinar con M1/M9/M2 la migración de sus emisores** hacia los 5 eventos entrantes de §2.2, y una fecha de retiro de los webhooks REST equivalentes una vez confirmada.
201
+ - **Cirugía urgente** (§5): decisión pendiente de si migrar a un patrón request/response por eventos, condicionada a acordar el evento de respuesta con M1.
202
+
203
+ ---
204
+
205
+ ## 10. Tests
206
+
207
+ - `tests/test_rabbit_consumer.py` — despacho por `event_type_name`, manejo de payload malformado, ack/reject.
208
+ - `tests/test_core_events.py` — `publish_event` no-op sin id / publica con id; los 4 `notify_*` siguen haciendo el mismo request REST de siempre y además llaman a `publish_event` (hoy inerte).
209
+ - `tests/test_webhooks.py` — la vía REST entrante, sin cambios.
documentation/M6_INTEGRACION_M1_HCE.md ADDED
@@ -0,0 +1,202 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # Guía de integración: publicar eventos a Internación (M6) desde HCE (M1)
2
+
3
+ **Health Grid · Módulo 6 (Internación y Gestión de Camas) — para el equipo de Módulo 1**
4
+
5
+ > Esta guía es para el equipo de **HCE (M1)**: explica cómo publicar los eventos que le corresponden a M1 en el bus del Core (M10) para que M6 los procese. La cola y los eventos **ya están creados** en el Core — no hace falta dar de alta nada, solo publicar. Para el contrato genérico del bus (login, formato de mensajes) ver [`M10_integration.md`](integrations/M10_integration.md).
6
+
7
+ ---
8
+
9
+ ## 1. Qué le corresponde a M1
10
+
11
+ M1 tiene **dos** eventos hacia M6:
12
+
13
+ | `event_type_id` | `name` | Cuándo se dispara |
14
+ |---|---|---|
15
+ | **14** | `internacion.solicitud.creada` | Un médico solicita internar o trasladar un paciente |
16
+ | **15** | `internacion.alta-medica.registrada` | Un médico da el alta de un paciente internado |
17
+
18
+ Estos eventos reemplazan, en paralelo durante la transición, a los webhooks REST que M1 llama hoy: `POST /api/v1/webhooks/hce/solicitud` y `POST /api/v1/webhooks/hce/alta-medica`. **Esos endpoints REST siguen activos** — no hace falta migrar de un día para el otro; M1 puede seguir usándolos mientras integra la publicación por bus, y ambos caminos conviven hasta que se coordine el retiro del REST.
19
+
20
+ M6 ya tiene la cola `internacion.requests` creada y ambos eventos dados de alta y bindeados a esa cola. **M1 no necesita crear ninguna cola ni evento propio para esto** — solo necesita publicar.
21
+
22
+ ### ⚠️ Cirugía urgente: queda fuera, sigue siendo solo REST
23
+
24
+ M1 tiene un tercer webhook hacia M6, `POST /api/v1/webhooks/hce/cirugia-urgente`, que **no tiene evento equivalente en el bus** y no lo va a tener por ahora. Ese endpoint responde sincrónicamente qué quirófano y reserva se asignaron (y qué reservas se desplazaron), algo que un mensaje fire-and-forget no puede resolver sin un canal de respuesta aparte. Migrarlo requeriría acordar con M6 un evento de respuesta (`correlation_id` + `response_event_id`, patrón `billing`/`appointments` de `M10_integration.md`), lo cual no está planificado todavía. **Seguí usando el REST directo para cirugía urgente.**
25
+
26
+ ---
27
+
28
+ ## 2. Prerrequisito: tu propia cuenta de servicio en el Core
29
+
30
+ M1 necesita su propia cuenta en el Core (M10) con permiso `events:log:publish`. Se loguea como cualquier otro cliente:
31
+
32
+ ```http
33
+ POST /auth/login
34
+ Content-Type: application/json
35
+
36
+ { "email": "<cuenta-servicio-m1@...>", "password": "<...>" }
37
+ ```
38
+
39
+ Respuesta `200`:
40
+
41
+ ```json
42
+ { "token": "eyJhbGciOiJSUzI1NiIs...", "user": { "id": 8, "email": "...", ... } }
43
+ ```
44
+
45
+ Guardar el `token` y usarlo como `Authorization: Bearer <token>` en la publicación (§3). El token del Core dura 24 h — renovar el login cuando expire.
46
+
47
+ ---
48
+
49
+ ## 3. Cómo publicar cada evento
50
+
51
+ ### 3.1 Solicitud creada (`event_type_id: 14`)
52
+
53
+ Ejemplo de **internación**:
54
+
55
+ ```http
56
+ POST /events/log
57
+ Authorization: Bearer <token de tu cuenta de servicio>
58
+ Content-Type: application/json
59
+
60
+ {
61
+ "event_type_id": 14,
62
+ "publisher_module": "hce",
63
+ "payload": "{\"tipo\":\"INTERNACION\",\"solicitud_hce_id\":\"HCE-SOL-00123\",\"paciente_id\":123,\"medico_solicitante_id\":10,\"origen\":\"GUARDIA\",\"diagnostico_ingreso\":\"Neumonía\",\"prioridad\":\"ALTA\",\"hospital_id\":\"HOSP-1\",\"timestamp\":\"2026-07-10T14:00:00Z\"}"
64
+ }
65
+ ```
66
+
67
+ Ejemplo de **traslado**:
68
+
69
+ ```http
70
+ POST /events/log
71
+ Authorization: Bearer <token de tu cuenta de servicio>
72
+ Content-Type: application/json
73
+
74
+ {
75
+ "event_type_id": 14,
76
+ "publisher_module": "hce",
77
+ "payload": "{\"tipo\":\"TRASLADO\",\"solicitud_hce_id\":\"HCE-SOL-00124\",\"paciente_id\":123,\"medico_solicitante_id\":10,\"cama_origen_id\":204,\"cama_destino_solicitada_id\":315,\"motivo_traslado\":\"Requiere UTI\",\"hospital_id\":\"HOSP-1\",\"timestamp\":\"2026-07-10T15:00:00Z\"}"
78
+ }
79
+ ```
80
+
81
+ ### 3.2 Alta médica registrada (`event_type_id: 15`)
82
+
83
+ ```http
84
+ POST /events/log
85
+ Authorization: Bearer <token de tu cuenta de servicio>
86
+ Content-Type: application/json
87
+
88
+ {
89
+ "event_type_id": 15,
90
+ "publisher_module": "hce",
91
+ "payload": "{\"paciente_id\":123,\"medico_firmante_id\":10,\"tipo_alta\":\"ALTA_MEDICA\",\"timestamp\":\"2026-07-10T16:00:00Z\"}"
92
+ }
93
+ ```
94
+
95
+ Notar: `payload` va **como string JSON** (no como objeto anidado) — es el formato que exige el Core para todo `POST /events/log`, no algo específico de M6.
96
+
97
+ Respuesta `201` en ambos casos:
98
+
99
+ ```json
100
+ {
101
+ "id": 89,
102
+ "event_type_id": 15,
103
+ "publisher_module": "hce",
104
+ "payload": "...",
105
+ "status": "pending",
106
+ ...
107
+ }
108
+ ```
109
+
110
+ Con eso, el Core enruta el mensaje a `internacion.requests` (ya bindeado) y M6 lo procesa de forma asíncrona. No hay respuesta síncrona sobre el resultado del procesamiento — es fire-and-forget, igual que hoy son los webhooks REST.
111
+
112
+ ---
113
+
114
+ ## 4. Contrato de payload
115
+
116
+ ### 4.1 `internacion.solicitud.creada` (id 14)
117
+
118
+ | Campo | Tipo | Obligatorio | Descripción |
119
+ |---|---|---|---|
120
+ | `tipo` | `INTERNACION` \| `TRASLADO` | **sí** | Determina qué otros campos importan (ver abajo). |
121
+ | `solicitud_hce_id` | string | **sí** | Id de la solicitud en M1. Es la clave de idempotencia — ver §5. |
122
+ | `paciente_id` | integer | **sí** | Id del paciente en el Core. |
123
+ | `medico_solicitante_id` | integer | **sí** | Id del médico que solicita. |
124
+ | `hospital_id` | string | no | Sede del hospital. |
125
+ | `observaciones` | string | no | Texto libre. |
126
+ | `timestamp` | string (ISO 8601, UTC) | **sí** | Momento de la solicitud. |
127
+
128
+ Campos específicos de `tipo=INTERNACION`:
129
+
130
+ | Campo | Tipo | Descripción |
131
+ |---|---|---|
132
+ | `cama_solicitada_id` | integer, opcional | Si el médico ya sugiere una cama puntual. |
133
+ | `origen` | `GUARDIA` \| `CIRUGIA_PROGRAMADA` | Origen del ingreso. Si es `CIRUGIA_PROGRAMADA`, M6 valida el turno contra M2 antes de aprobar — enviar también `turno_id`. |
134
+ | `turno_id` | integer, opcional | Requerido si `origen=CIRUGIA_PROGRAMADA`. |
135
+ | `diagnostico_ingreso` | string, opcional | |
136
+ | `obra_social_id` / `numero_afiliado` | string, opcional | |
137
+ | `prioridad` | `MUY_BAJA`\|`BAJA`\|`MEDIA`\|`ALTA`\|`MUY_ALTA`\|`URGENTE` | |
138
+
139
+ Campos específicos de `tipo=TRASLADO`:
140
+
141
+ | Campo | Tipo | Descripción |
142
+ |---|---|---|
143
+ | `cama_origen_id` | integer | Cama actual del paciente. |
144
+ | `cama_destino_solicitada_id` | integer, opcional | Cama sugerida como destino, si aplica. |
145
+ | `motivo_traslado` | string, opcional | |
146
+
147
+ El schema no rechaza combinaciones cruzadas (por ejemplo, mandar campos de `TRASLADO` con `tipo=INTERNACION` no da error) — enviar solo los campos relevantes al `tipo` real, los demás quedan en `null`.
148
+
149
+ ### 4.2 `internacion.alta-medica.registrada` (id 15)
150
+
151
+ | Campo | Tipo | Obligatorio | Descripción |
152
+ |---|---|---|---|
153
+ | `paciente_id` | integer | **sí** | Paciente que recibe el alta. Tiene que tener una cama `OCUPADA` o `CODIGO_ROJO` asignada en M6. |
154
+ | `medico_firmante_id` | integer | **sí** | Médico que firma el alta. |
155
+ | `tipo_alta` | `ALTA_MEDICA`\|`ALTA_VOLUNTARIA`\|`TRASLADO_EXTERNO`\|`DEFUNCION` | **sí** | |
156
+ | `timestamp` | string (ISO 8601, UTC) | **sí** | Momento del alta. |
157
+
158
+ ---
159
+
160
+ ## 5. Qué hace M6 al recibir cada evento
161
+
162
+ **Solicitud creada (14):**
163
+ 1. Busca si ya existe una solicitud con ese `solicitud_hce_id`. Si existe, **no crea una nueva** — devuelve/usa la existente (idempotente: reintentar el mismo `solicitud_hce_id` es seguro, no duplica solicitudes).
164
+ 2. Si no existe, crea la solicitud en estado `PENDIENTE`. Queda visible para un administrativo, que la resuelve (`APROBAR`/`APROBAR_CON_CAMBIO`/`RECHAZAR`) desde el frontend de M6 — este evento no dispara ninguna asignación de cama por sí solo.
165
+ 3. Al resolverse (fuera de este flujo, por acción del administrativo), M6 le notifica el resultado a M1 vía `SOLICITUD_RESUELTA` — ese es un evento **saliente** de M6 hacia M1 (dual-write REST + bus, hoy con el lado bus todavía apagado porque M1 no compartió su `event_type_id` — ver `M6_EVENTOS_RABBITMQ.md` §7 si tu equipo quiere habilitar también ese canal).
166
+
167
+ **Alta médica (15):**
168
+ 1. Busca la cama `OCUPADA`/`CODIGO_ROJO` del paciente. Si no tiene cama asignada, el mensaje se descarta (equivalente al `404` que hoy devuelve el REST) — no hay retry automático de M6 hacia M1.
169
+ 2. La cama pasa a `EN_LIMPIEZA` y M6 notifica la baja a Monitoreo (M9), fire-and-forget.
170
+ 3. Cuando el personal de limpieza marca la cama como `DISPONIBLE`, M6 dispara la notificación a Facturación (M7) — no depende de M1 en ese punto.
171
+
172
+ ---
173
+
174
+ ## 6. Errores comunes
175
+
176
+ | Síntoma | Causa probable |
177
+ |---|---|
178
+ | `401` al publicar | Token vencido o cuenta sin permiso `events:log:publish` |
179
+ | `400` al publicar | Falta `event_type_id` o `publisher_module` en el body de `POST /events/log` |
180
+ | Se publican dos solicitudes para el mismo caso | No debería pasar — si ambas tienen el mismo `solicitud_hce_id`, M6 es idempotente. Si usaste ids distintos para el mismo evento real, revisar cómo generás `solicitud_hce_id` de tu lado |
181
+ | El alta médica se publica (`201`) pero M6 nunca actúa | Verificar que el paciente tenga una cama `OCUPADA`/`CODIGO_ROJO` real en M6 — si la solicitud de internación original nunca se aprobó (o se resolvió por otra vía), no hay cama que dar de alta |
182
+ | Necesito la cirugía urgente por el bus | No está disponible — seguir usando `POST /api/v1/webhooks/hce/cirugia-urgente` (ver §1) |
183
+
184
+ ---
185
+
186
+ ## 7. Checklist de integración
187
+
188
+ - [ ] Cuenta de servicio de M1 en el Core, con permiso `events:log:publish`.
189
+ - [ ] Login (`POST /auth/login`) y manejo de renovación del token (24 h).
190
+ - [ ] Publicar `POST /events/log` con `event_type_id: 14` al crear una solicitud de internación o traslado, con `solicitud_hce_id` estable y único por solicitud.
191
+ - [ ] Enviar solo los campos relevantes al `tipo` (`INTERNACION` vs `TRASLADO`) en el payload de la solicitud.
192
+ - [ ] Publicar `POST /events/log` con `event_type_id: 15` al registrar un alta médica.
193
+ - [ ] Seguir usando el REST directo para cirugía urgente — no migra a este bus.
194
+ - [ ] Coordinar con el equipo de M6 cuándo dejar de llamar también a los REST directos (`/webhooks/hce/solicitud`, `/webhooks/hce/alta-medica`) — mientras tanto, no hay problema en llamar a ambos.
195
+
196
+ ---
197
+
198
+ ## 8. Referencias
199
+
200
+ - [`M6_EVENTOS_RABBITMQ.md`](M6_EVENTOS_RABBITMQ.md) — infraestructura completa de M6 en el bus (los 5 eventos entrantes, no solo los de M1).
201
+ - [`integrations/M10_integration.md`](integrations/M10_integration.md) — tutorial genérico del bus de eventos del Core.
202
+ - [`M6_DISEÑO.md`](M6_DISEÑO.md) §5.1/§5.2/§5.3 — flujos de negocio de internación, traslado y alta médica; §7.5 — contexto de la migración de webhooks REST a eventos.
documentation/M6_INTEGRACION_M2_TURNOS.md ADDED
@@ -0,0 +1,135 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # Guía de integración: publicar eventos a Internación (M6) desde Turnos (M2)
2
+
3
+ **Health Grid · Módulo 6 (Internación y Gestión de Camas) — para el equipo de Módulo 2**
4
+
5
+ > Esta guía es para el equipo de **Turnos (M2)**: explica cómo publicar el evento que le corresponde a M2 en el bus del Core (M10) para que M6 lo procese. La cola y el evento **ya están creados** en el Core — no hace falta dar de alta nada, solo publicar. Para el contrato genérico del bus (login, formato de mensajes) ver [`M10_integration.md`](integrations/M10_integration.md).
6
+
7
+ ---
8
+
9
+ ## 1. Qué le corresponde a M2
10
+
11
+ M2 solo tiene **un** evento hacia M6:
12
+
13
+ | `event_type_id` | `name` | Cuándo se dispara |
14
+ |---|---|---|
15
+ | **18** | `internacion.turno.cancelado` | Se cancela o reprograma un turno quirúrgico que M6 tiene reservado |
16
+
17
+ Este evento reemplaza, en paralelo durante la transición, al webhook REST que M2 llama hoy: `POST /api/v1/turnos/{turnoId}/cancelacion`. **Ese endpoint REST sigue activo** — no hace falta migrar de un día para el otro; M2 puede seguir usándolo mientras integra la publicación por bus, y ambos caminos conviven hasta que se coordine el retiro del REST.
18
+
19
+ M6 ya tiene la cola `internacion.requests` creada, el evento `internacion.turno.cancelado` (id 18) dado de alta y bindeado a esa cola. **M2 no necesita crear ninguna cola ni evento propio para esto** — solo necesita publicar.
20
+
21
+ ---
22
+
23
+ ## 2. Prerrequisito: tu propia cuenta de servicio en el Core
24
+
25
+ M2 necesita su propia cuenta en el Core (M10) con permiso `events:log:publish`. Se loguea como cualquier otro cliente:
26
+
27
+ ```http
28
+ POST /auth/login
29
+ Content-Type: application/json
30
+
31
+ { "email": "<cuenta-servicio-m2@...>", "password": "<...>" }
32
+ ```
33
+
34
+ Respuesta `200`:
35
+
36
+ ```json
37
+ { "token": "eyJhbGciOiJSUzI1NiIs...", "user": { "id": 12, "email": "...", ... } }
38
+ ```
39
+
40
+ Guardar el `token` y usarlo como `Authorization: Bearer <token>` en la publicación (§3). El token del Core dura 24 h — renovar el login cuando expire (mismo patrón que ya usás para tus otras integraciones contra M10).
41
+
42
+ ---
43
+
44
+ ## 3. Cómo publicar el evento
45
+
46
+ ```http
47
+ POST /events/log
48
+ Authorization: Bearer <token de tu cuenta de servicio>
49
+ Content-Type: application/json
50
+
51
+ {
52
+ "event_type_id": 18,
53
+ "publisher_module": "turnos",
54
+ "payload": "{\"turno_id\":5501,\"motivo\":\"Paciente cancela el turno\",\"tipo_cancelacion\":\"CANCELACION_PACIENTE\",\"timestamp\":\"2026-07-10T14:00:00Z\"}"
55
+ }
56
+ ```
57
+
58
+ Notar: `payload` va **como string JSON** (no como objeto anidado) — es el formato que exige el Core para todo `POST /events/log`, no algo específico de M6.
59
+
60
+ Respuesta `201`:
61
+
62
+ ```json
63
+ {
64
+ "id": 90,
65
+ "event_type_id": 18,
66
+ "publisher_module": "turnos",
67
+ "payload": "...",
68
+ "status": "pending",
69
+ ...
70
+ }
71
+ ```
72
+
73
+ Con eso, el Core enruta el mensaje a `internacion.requests` (ya bindeado) y M6 lo procesa de forma asíncrona. No hay respuesta síncrona sobre el resultado del procesamiento — es fire-and-forget, igual que hoy es el webhook REST.
74
+
75
+ ---
76
+
77
+ ## 4. Contrato del payload (`internacion.turno.cancelado`)
78
+
79
+ | Campo | Tipo | Obligatorio | Descripción |
80
+ |---|---|---|---|
81
+ | `turno_id` | integer | **sí** | Id del turno cancelado en M2. **Importante:** en el webhook REST este valor viaja en la URL (`/turnos/{turnoId}/cancelacion`); acá no hay "URL", así que **tiene que ir en el payload** — es el campo que M6 usa para encontrar la reserva de quirófano asociada. |
82
+ | `motivo` | string | sí | Motivo de la cancelación. Texto libre. |
83
+ | `tipo_cancelacion` | string | no | Opcional, texto libre (ej. `CANCELACION_PACIENTE`, `REPROGRAMACION`). |
84
+ | `timestamp` | string (ISO 8601, UTC) | sí | Momento de la cancelación en M2. |
85
+
86
+ Ejemplo completo (el JSON interno, antes de serializarlo a string para el campo `payload`):
87
+
88
+ ```json
89
+ {
90
+ "turno_id": 5501,
91
+ "motivo": "Paciente cancela el turno",
92
+ "tipo_cancelacion": "CANCELACION_PACIENTE",
93
+ "timestamp": "2026-07-10T14:00:00Z"
94
+ }
95
+ ```
96
+
97
+ ---
98
+
99
+ ## 5. Qué hace M6 al recibir el evento
100
+
101
+ 1. Busca la reserva de quirófano **programada** (`origen=PROGRAMADA`) asociada a `turno_id`. Si no existe, el mensaje se descarta (va a la DLQ) — no hay respuesta de error hacia M2, es la misma limitación que ya tiene el webhook REST hoy (`404` sin retry automático de M6 hacia M2).
102
+ 2. Si la reserva ya está `CANCELADA`, **no hace nada** (idempotente) — reintentar el mismo evento (por ejemplo, ante un timeout de tu lado) es seguro.
103
+ 3. Si la reserva está `EN_CURSO` o `COMPLETADA`, no se puede cancelar — el mensaje se descarta (equivalente al `409` que hoy devuelve el REST).
104
+ 4. Si todo está bien, la reserva pasa a `CANCELADA` y se libera el quirófano.
105
+
106
+ **Idempotencia de tu lado:** no hace falta ningún id de correlación adicional — `turno_id` ya es la clave. Reintentar el mismo `turno_id` con el mismo `motivo` es seguro, no duplica nada.
107
+
108
+ ---
109
+
110
+ ## 6. Errores comunes
111
+
112
+ | Síntoma | Causa probable |
113
+ |---|---|
114
+ | `401` al publicar | Token vencido o cuenta sin permiso `events:log:publish` |
115
+ | `400` al publicar | Falta `event_type_id` o `publisher_module` en el body de `POST /events/log` |
116
+ | El evento se publica (`201`) pero M6 nunca actúa | Revisar que `turno_id` corresponda a una reserva `PROGRAMADA` real en M6; si el turno nunca tuvo reserva de quirófano asociada, no hay nada que cancelar del lado de M6 |
117
+ | Necesito saber si M6 proceso bien el evento | Hoy no hay canal de respuesta — es fire-and-forget. Si tu flujo necesita confirmación, seguir usando el REST directo mientras tanto |
118
+
119
+ ---
120
+
121
+ ## 7. Checklist de integración
122
+
123
+ - [ ] Cuenta de servicio de M2 en el Core, con permiso `events:log:publish`.
124
+ - [ ] Login (`POST /auth/login`) y manejo de renovación del token (24 h).
125
+ - [ ] Publicar `POST /events/log` con `event_type_id: 18` cuando se cancele/reprograme un turno quirúrgico.
126
+ - [ ] `payload` (string JSON) con `turno_id`, `motivo`, `tipo_cancelacion` (opcional) y `timestamp`.
127
+ - [ ] Coordinar con el equipo de M6 cuándo dejar de llamar también al REST directo (`POST /api/v1/turnos/{turnoId}/cancelacion`) — mientras tanto, no hay problema en llamar a ambos.
128
+
129
+ ---
130
+
131
+ ## 8. Referencias
132
+
133
+ - [`M6_EVENTOS_RABBITMQ.md`](M6_EVENTOS_RABBITMQ.md) — infraestructura completa de M6 en el bus (los 5 eventos entrantes, no solo el de M2).
134
+ - [`integrations/M10_integration.md`](integrations/M10_integration.md) — tutorial genérico del bus de eventos del Core.
135
+ - [`M6_DISEÑO.md`](M6_DISEÑO.md) §7.5 — contexto de la migración de webhooks REST a eventos.
documentation/M6_INTEGRACION_M9_MONITOREO.md ADDED
@@ -0,0 +1,170 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # Guía de integración: publicar eventos a Internación (M6) desde Monitoreo (M9)
2
+
3
+ **Health Grid · Módulo 6 (Internación y Gestión de Camas) — para el equipo de Módulo 9**
4
+
5
+ > Esta guía es para el equipo de **Monitoreo (M9)**: explica cómo publicar los eventos que le corresponden a M9 en el bus del Core (M10) para que M6 los procese. La cola y los eventos **ya están creados** en el Core — no hace falta dar de alta nada, solo publicar. Para el contrato genérico del bus (login, formato de mensajes) ver [`M10_integration.md`](integrations/M10_integration.md).
6
+
7
+ ---
8
+
9
+ ## 1. Qué le corresponde a M9
10
+
11
+ M9 tiene **dos** eventos hacia M6, ambos relacionados al código rojo:
12
+
13
+ | `event_type_id` | `name` | Cuándo se dispara |
14
+ |---|---|---|
15
+ | **16** | `internacion.alerta-emergencia.detectada` | Un sensor/regla de monitoreo detecta una emergencia en un paciente internado |
16
+ | **17** | `internacion.alerta-resuelta.notificada` | La emergencia se estabiliza |
17
+
18
+ Estos eventos reemplazan, en paralelo durante la transición, a los webhooks REST que M9 llama hoy: `POST /api/v1/webhooks/monitoreo/alerta-emergencia` y `POST /api/v1/webhooks/monitoreo/alerta-resuelta`. **Esos endpoints REST siguen activos** — no hace falta migrar de un día para el otro; M9 puede seguir usándolos mientras integra la publicación por bus, y ambos caminos conviven hasta que se coordine el retiro del REST.
19
+
20
+ M6 ya tiene la cola `internacion.requests` creada y ambos eventos dados de alta y bindeados a esa cola. **M9 no necesita crear ninguna cola ni evento propio para esto** — solo necesita publicar.
21
+
22
+ ---
23
+
24
+ ## 2. Prerrequisito: tu propia cuenta de servicio en el Core
25
+
26
+ M9 necesita su propia cuenta en el Core (M10) con permiso `events:log:publish`. Se loguea como cualquier otro cliente:
27
+
28
+ ```http
29
+ POST /auth/login
30
+ Content-Type: application/json
31
+
32
+ { "email": "<cuenta-servicio-m9@...>", "password": "<...>" }
33
+ ```
34
+
35
+ Respuesta `200`:
36
+
37
+ ```json
38
+ { "token": "eyJhbGciOiJSUzI1NiIs...", "user": { "id": 15, "email": "...", ... } }
39
+ ```
40
+
41
+ Guardar el `token` y usarlo como `Authorization: Bearer <token>` en la publicación (§3). El token del Core dura 24 h — renovar el login cuando expire.
42
+
43
+ ---
44
+
45
+ ## 3. Cómo publicar cada evento
46
+
47
+ ### 3.1 Alerta de emergencia detectada (`event_type_id: 16`)
48
+
49
+ ```http
50
+ POST /events/log
51
+ Authorization: Bearer <token de tu cuenta de servicio>
52
+ Content-Type: application/json
53
+
54
+ {
55
+ "event_type_id": 16,
56
+ "publisher_module": "monitoreo",
57
+ "payload": "{\"paciente_id\":123,\"observaciones\":\"Frecuencia cardíaca sostenida > 120 por 2 minutos\",\"timestamp\":\"2026-07-10T14:00:00Z\"}"
58
+ }
59
+ ```
60
+
61
+ ### 3.2 Alerta resuelta (`event_type_id: 17`)
62
+
63
+ ```http
64
+ POST /events/log
65
+ Authorization: Bearer <token de tu cuenta de servicio>
66
+ Content-Type: application/json
67
+
68
+ {
69
+ "event_type_id": 17,
70
+ "publisher_module": "monitoreo",
71
+ "payload": "{\"paciente_id\":123,\"motivo_resolucion\":\"Paciente estabilizado\",\"timestamp\":\"2026-07-10T14:05:00Z\"}"
72
+ }
73
+ ```
74
+
75
+ Notar: `payload` va **como string JSON** (no como objeto anidado) — es el formato que exige el Core para todo `POST /events/log`, no algo específico de M6.
76
+
77
+ Respuesta `201` en ambos casos:
78
+
79
+ ```json
80
+ {
81
+ "id": 91,
82
+ "event_type_id": 16,
83
+ "publisher_module": "monitoreo",
84
+ "payload": "...",
85
+ "status": "pending",
86
+ ...
87
+ }
88
+ ```
89
+
90
+ Con eso, el Core enruta el mensaje a `internacion.requests` (ya bindeado) y M6 lo procesa de forma asíncrona. No hay respuesta síncrona sobre el resultado del procesamiento — es fire-and-forget, igual que hoy son los webhooks REST.
91
+
92
+ ---
93
+
94
+ ## 4. Contrato de payload
95
+
96
+ ### 4.1 `internacion.alerta-emergencia.detectada` (id 16)
97
+
98
+ | Campo | Tipo | Obligatorio | Descripción |
99
+ |---|---|---|---|
100
+ | `paciente_id` | integer | **sí** | Id del paciente en el Core. M6 lo usa para localizar la cama actual del paciente. |
101
+ | `observaciones` | string | no | Texto libre, contexto de la alerta (opcional). |
102
+ | `timestamp` | string (ISO 8601, UTC) | sí | Momento de detección de la emergencia. |
103
+
104
+ ```json
105
+ {
106
+ "paciente_id": 123,
107
+ "observaciones": "Frecuencia cardíaca sostenida > 120 por 2 minutos",
108
+ "timestamp": "2026-07-10T14:00:00Z"
109
+ }
110
+ ```
111
+
112
+ ### 4.2 `internacion.alerta-resuelta.notificada` (id 17)
113
+
114
+ | Campo | Tipo | Obligatorio | Descripción |
115
+ |---|---|---|---|
116
+ | `paciente_id` | integer | **sí** | Mismo paciente de la alerta de emergencia. |
117
+ | `motivo_resolucion` | string | no | Texto libre (opcional). |
118
+ | `timestamp` | string (ISO 8601, UTC) | sí | Momento de resolución. |
119
+
120
+ ```json
121
+ {
122
+ "paciente_id": 123,
123
+ "motivo_resolucion": "Paciente estabilizado",
124
+ "timestamp": "2026-07-10T14:05:00Z"
125
+ }
126
+ ```
127
+
128
+ ---
129
+
130
+ ## 5. Qué hace M6 al recibir cada evento
131
+
132
+ **Alerta de emergencia (16):**
133
+ 1. Busca la cama `OCUPADA` del paciente (`paciente_id`). Si no tiene cama asignada, el mensaje se descarta (equivalente al `404` que hoy devuelve el REST) — no hay retry automático de M6 hacia M9.
134
+ 2. La marca en estado `CODIGO_ROJO` y registra el evento en la historia clínica del paciente (M1).
135
+
136
+ **Alerta resuelta (17):**
137
+ 1. Busca la cama en `CODIGO_ROJO` del paciente. Si no encuentra ninguna (por ejemplo, la alerta ya se resolvió antes), el mensaje se descarta — no hay error visible del lado de M9.
138
+ 2. La cama vuelve a `OCUPADA`.
139
+
140
+ **Orden de los eventos:** publicar primero `alerta-emergencia.detectada` y, cuando corresponda, `alerta-resuelta.notificada` para el mismo `paciente_id`. Si `alerta-resuelta` llega sin que exista una cama en `CODIGO_ROJO` (por ejemplo, por un reordenamiento de mensajes en el bus), M6 no encuentra qué resolver y descarta el mensaje — no hay reconciliación automática. Publicar en orden evita este caso.
141
+
142
+ ---
143
+
144
+ ## 6. Errores comunes
145
+
146
+ | Síntoma | Causa probable |
147
+ |---|---|
148
+ | `401` al publicar | Token vencido o cuenta sin permiso `events:log:publish` |
149
+ | `400` al publicar | Falta `event_type_id` o `publisher_module` en el body de `POST /events/log` |
150
+ | El evento se publica (`201`) pero M6 nunca actúa | Para `alerta-emergencia`: verificar que el paciente tenga una cama `OCUPADA` real en M6. Para `alerta-resuelta`: verificar que exista una cama en `CODIGO_ROJO` para ese paciente (puede que la alerta de emergencia no haya llegado, o haya llegado después) |
151
+ | Necesito saber si M6 procesó bien el evento | Hoy no hay canal de respuesta — es fire-and-forget. Si tu flujo necesita confirmación, seguir usando el REST directo mientras tanto |
152
+
153
+ ---
154
+
155
+ ## 7. Checklist de integración
156
+
157
+ - [ ] Cuenta de servicio de M9 en el Core, con permiso `events:log:publish`.
158
+ - [ ] Login (`POST /auth/login`) y manejo de renovación del token (24 h).
159
+ - [ ] Publicar `POST /events/log` con `event_type_id: 16` al detectar una emergencia.
160
+ - [ ] Publicar `POST /events/log` con `event_type_id: 17` al resolverse la emergencia, para el mismo `paciente_id`.
161
+ - [ ] Publicar los eventos en orden (emergencia antes que resuelta) para el mismo paciente.
162
+ - [ ] Coordinar con el equipo de M6 cuándo dejar de llamar también a los REST directos (`/webhooks/monitoreo/alerta-emergencia`, `/webhooks/monitoreo/alerta-resuelta`) — mientras tanto, no hay problema en llamar a ambos.
163
+
164
+ ---
165
+
166
+ ## 8. Referencias
167
+
168
+ - [`M6_EVENTOS_RABBITMQ.md`](M6_EVENTOS_RABBITMQ.md) — infraestructura completa de M6 en el bus (los 5 eventos entrantes, no solo los de M9).
169
+ - [`integrations/M10_integration.md`](integrations/M10_integration.md) — tutorial genérico del bus de eventos del Core.
170
+ - [`M6_DISEÑO.md`](M6_DISEÑO.md) §5.7 — flujo de negocio de código rojo; §7.5 — contexto de la migración de webhooks REST a eventos.
requirements.txt CHANGED
@@ -9,3 +9,4 @@ python-jose[cryptography]==3.3.0
9
  httpx==0.27.2
10
  sqlalchemy==2.0.36
11
  psycopg2-binary==2.9.10
 
 
9
  httpx==0.27.2
10
  sqlalchemy==2.0.36
11
  psycopg2-binary==2.9.10
12
+ aio-pika==9.5.8
tests/test_core_events.py ADDED
@@ -0,0 +1,145 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ """
2
+ Tests de la publicación saliente al bus del Core (`app/integrations/core_events.py`) y
3
+ de que los 4 puntos de notificación (`hce.notify_resultado_solicitud`,
4
+ `monitoreo.notify_alta`/`notify_baja`, `facturacion.notify_cama_lista`) sigan haciendo el
5
+ mismo request REST que hoy, sin cambios observables, mientras el `event_type_id`
6
+ correspondiente esté en `None` (default actual — ver `M6_DISEÑO.md` §7).
7
+ """
8
+ from app.config import settings
9
+ from app.integrations import core_events, facturacion, hce, monitoreo
10
+
11
+
12
+ # ─── publish_event: no-op mientras no haya event_type_id ──────────────────
13
+
14
+
15
+ def test_publish_event_sin_id_no_hace_ningun_request(monkeypatch):
16
+ called = []
17
+ monkeypatch.setattr("app.integrations.core_events._post", lambda *a, **k: called.append((a, k)))
18
+
19
+ result = core_events.publish_event(None, {"foo": "bar"})
20
+
21
+ assert result is True
22
+ assert called == []
23
+
24
+
25
+ def test_publish_event_con_id_publica_al_core(monkeypatch):
26
+ calls = []
27
+
28
+ def _fake_post(url, body):
29
+ calls.append((url, body))
30
+ return {"id": 999}
31
+
32
+ monkeypatch.setattr(core_events, "_post", _fake_post)
33
+
34
+ result = core_events.publish_event(14, {"foo": "bar"})
35
+
36
+ assert result is True
37
+ assert len(calls) == 1
38
+ url, body = calls[0]
39
+ assert url == f"{settings.m10_core_url}/events/log"
40
+ assert body["event_type_id"] == 14
41
+ assert body["publisher_module"] == "internacion"
42
+ assert body["payload"] == '{"foo": "bar"}'
43
+
44
+
45
+ def test_publish_event_con_id_pero_post_falla_devuelve_false(monkeypatch):
46
+ monkeypatch.setattr(core_events, "_post", lambda *a, **k: None)
47
+
48
+ assert core_events.publish_event(14, {"foo": "bar"}) is False
49
+
50
+
51
+ # ─── notify_* : REST sin cambios + publish_event adicional (hoy no-op) ─────
52
+
53
+
54
+ def test_notify_resultado_solicitud_sigue_llamando_rest_igual_que_antes(monkeypatch):
55
+ monkeypatch.setattr(settings, "mock_external_services", False)
56
+ monkeypatch.setattr(settings, "hce_solicitud_resuelta_event_type_id", None)
57
+ rest_calls = []
58
+ publish_calls = []
59
+ monkeypatch.setattr(
60
+ "app.integrations.hce._post",
61
+ lambda url, payload: rest_calls.append((url, payload)) or {"ok": True},
62
+ )
63
+ monkeypatch.setattr(
64
+ "app.integrations.core_events.publish_event",
65
+ lambda event_type_id, payload: publish_calls.append((event_type_id, payload)) or True,
66
+ )
67
+
68
+ ok = hce.notify_resultado_solicitud("HCE-SOL-1", "APROBADA", motivo=None)
69
+
70
+ assert ok is True
71
+ assert len(rest_calls) == 1
72
+ url, rest_payload = rest_calls[0]
73
+ assert url == f"{settings.m1_hce_url}/api/v1/hce/solicitudes/HCE-SOL-1/resultado"
74
+ assert "solicitud_hce_id" not in rest_payload # el body REST no cambia
75
+ assert len(publish_calls) == 1
76
+ event_type_id, event_payload = publish_calls[0]
77
+ assert event_type_id is None # no configurado todavía
78
+ assert event_payload["solicitud_hce_id"] == "HCE-SOL-1"
79
+
80
+
81
+ def test_notify_alta_sigue_llamando_rest_igual_que_antes(monkeypatch):
82
+ monkeypatch.setattr(settings, "mock_external_services", False)
83
+ monkeypatch.setattr(settings, "monitoreo_alta_event_type_id", None)
84
+ rest_calls = []
85
+ publish_calls = []
86
+ monkeypatch.setattr(
87
+ "app.integrations.monitoreo._post",
88
+ lambda url, payload: rest_calls.append((url, payload)) or {"ok": True},
89
+ )
90
+ monkeypatch.setattr(
91
+ "app.integrations.core_events.publish_event",
92
+ lambda event_type_id, payload: publish_calls.append((event_type_id, payload)) or True,
93
+ )
94
+
95
+ ok = monitoreo.notify_alta(7)
96
+
97
+ assert ok is True
98
+ assert len(rest_calls) == 1
99
+ assert len(publish_calls) == 1
100
+ assert publish_calls[0][0] is None
101
+
102
+
103
+ def test_notify_baja_sigue_llamando_rest_igual_que_antes(monkeypatch):
104
+ monkeypatch.setattr(settings, "mock_external_services", False)
105
+ monkeypatch.setattr(settings, "monitoreo_baja_event_type_id", None)
106
+ rest_calls = []
107
+ publish_calls = []
108
+ monkeypatch.setattr(
109
+ "app.integrations.monitoreo._post",
110
+ lambda url, payload: rest_calls.append((url, payload)) or {"ok": True},
111
+ )
112
+ monkeypatch.setattr(
113
+ "app.integrations.core_events.publish_event",
114
+ lambda event_type_id, payload: publish_calls.append((event_type_id, payload)) or True,
115
+ )
116
+
117
+ ok = monitoreo.notify_baja(7)
118
+
119
+ assert ok is True
120
+ assert len(rest_calls) == 1
121
+ assert len(publish_calls) == 1
122
+ assert publish_calls[0][0] is None
123
+
124
+
125
+ def test_notify_cama_lista_sigue_llamando_rest_igual_que_antes(monkeypatch):
126
+ monkeypatch.setattr(settings, "mock_external_services", False)
127
+ monkeypatch.setattr(settings, "facturacion_cama_lista_event_type_id", None)
128
+ rest_calls = []
129
+ publish_calls = []
130
+ monkeypatch.setattr(
131
+ "app.integrations.facturacion._post",
132
+ lambda url, payload: rest_calls.append((url, payload)) or {"ok": True},
133
+ )
134
+ monkeypatch.setattr(
135
+ "app.integrations.core_events.publish_event",
136
+ lambda event_type_id, payload: publish_calls.append((event_type_id, payload)) or True,
137
+ )
138
+
139
+ ok = facturacion.notify_cama_lista(cama_id=315, paciente_id=7)
140
+
141
+ assert ok is True
142
+ assert len(rest_calls) == 1
143
+ assert len(publish_calls) == 1
144
+ assert publish_calls[0][0] is None
145
+ assert publish_calls[0][1]["cama_id"] == 315
tests/test_rabbit_consumer.py ADDED
@@ -0,0 +1,180 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ """
2
+ Tests del consumer de `internacion.requests` (`app/integrations/rabbit_consumer.py`).
3
+
4
+ No abren conexión real a RabbitMQ: `dispatch()` se prueba monkeypatcheando las
5
+ funciones de servicio (misma lógica de negocio que ya cubre `tests/test_webhooks.py`
6
+ para la vía REST); `_on_message` se prueba con un mensaje fake (sin `aio_pika` real),
7
+ corriendo la coroutine con `asyncio.run` — no hace falta pytest-asyncio para esto.
8
+ """
9
+ import asyncio
10
+ import json
11
+ from datetime import datetime, timezone
12
+
13
+ import pytest
14
+
15
+ from app.integrations import rabbit_consumer
16
+ from app.services import solicitud_service
17
+
18
+ _NOW_ISO = datetime.now(timezone.utc).isoformat()
19
+
20
+
21
+ class _FakeMessage:
22
+ def __init__(self, body: bytes):
23
+ self.body = body
24
+ self.acked = False
25
+ self.rejected_requeue = None
26
+
27
+ async def ack(self):
28
+ self.acked = True
29
+
30
+ async def reject(self, requeue=False):
31
+ self.rejected_requeue = requeue
32
+
33
+
34
+ def _envelope(event_type_name: str, payload: dict, log_id: int = 1) -> bytes:
35
+ return json.dumps(
36
+ {
37
+ "event_type_id": 1,
38
+ "event_type_name": event_type_name,
39
+ "source_module": "test",
40
+ "publisher_module": "test",
41
+ "log_id": log_id,
42
+ "payload": json.dumps(payload),
43
+ "published_at": _NOW_ISO,
44
+ }
45
+ ).encode()
46
+
47
+
48
+ # ─── dispatch(): despacho por event_type_name ──────────────────────────────
49
+
50
+
51
+ def test_dispatch_solicitud_creada(monkeypatch):
52
+ calls = []
53
+ monkeypatch.setattr(rabbit_consumer, "get_db", lambda: "FAKE_DB")
54
+ monkeypatch.setattr(
55
+ solicitud_service, "recibir_solicitud", lambda db, data: calls.append((db, data))
56
+ )
57
+ payload = {
58
+ "tipo": "INTERNACION",
59
+ "solicitud_hce_id": "HCE-SOL-1",
60
+ "paciente_id": 7,
61
+ "medico_solicitante_id": 10,
62
+ "timestamp": _NOW_ISO,
63
+ }
64
+ rabbit_consumer.dispatch("internacion.solicitud.creada", payload)
65
+ assert len(calls) == 1
66
+ db, data = calls[0]
67
+ assert db == "FAKE_DB"
68
+ assert data.solicitud_hce_id == "HCE-SOL-1"
69
+
70
+
71
+ def test_dispatch_alta_medica(monkeypatch):
72
+ calls = []
73
+ monkeypatch.setattr(rabbit_consumer, "get_db", lambda: "FAKE_DB")
74
+ monkeypatch.setattr(
75
+ solicitud_service, "procesar_alta_medica", lambda db, paciente_id: calls.append(paciente_id)
76
+ )
77
+ payload = {
78
+ "paciente_id": 7,
79
+ "medico_firmante_id": 10,
80
+ "tipo_alta": "ALTA_MEDICA",
81
+ "timestamp": _NOW_ISO,
82
+ }
83
+ rabbit_consumer.dispatch("internacion.alta-medica.registrada", payload)
84
+ assert calls == [7]
85
+
86
+
87
+ def test_dispatch_alerta_emergencia(monkeypatch):
88
+ calls = []
89
+ monkeypatch.setattr(rabbit_consumer, "get_db", lambda: "FAKE_DB")
90
+ monkeypatch.setattr(
91
+ solicitud_service, "procesar_alerta_emergencia", lambda db, paciente_id: calls.append(paciente_id)
92
+ )
93
+ payload = {"paciente_id": 7, "timestamp": _NOW_ISO}
94
+ rabbit_consumer.dispatch("internacion.alerta-emergencia.detectada", payload)
95
+ assert calls == [7]
96
+
97
+
98
+ def test_dispatch_alerta_resuelta(monkeypatch):
99
+ calls = []
100
+ monkeypatch.setattr(rabbit_consumer, "get_db", lambda: "FAKE_DB")
101
+ monkeypatch.setattr(
102
+ solicitud_service, "procesar_alerta_resuelta", lambda db, paciente_id: calls.append(paciente_id)
103
+ )
104
+ payload = {"paciente_id": 7, "timestamp": _NOW_ISO}
105
+ rabbit_consumer.dispatch("internacion.alerta-resuelta.notificada", payload)
106
+ assert calls == [7]
107
+
108
+
109
+ def test_dispatch_turno_cancelado(monkeypatch):
110
+ calls = []
111
+ monkeypatch.setattr(rabbit_consumer, "get_db", lambda: "FAKE_DB")
112
+ monkeypatch.setattr(
113
+ solicitud_service,
114
+ "cancelar_reserva_por_turno",
115
+ lambda db, turno_id, motivo: calls.append((turno_id, motivo)),
116
+ )
117
+ # turno_id viaja en el payload del evento (en el REST equivalente viene del path).
118
+ payload = {"turno_id": 5501, "motivo": "paciente cancela", "timestamp": _NOW_ISO}
119
+ rabbit_consumer.dispatch("internacion.turno.cancelado", payload)
120
+ assert calls == [(5501, "paciente cancela")]
121
+
122
+
123
+ def test_dispatch_event_type_name_no_reconocido():
124
+ with pytest.raises(KeyError):
125
+ rabbit_consumer.dispatch("algo.que.no.existe", {})
126
+
127
+
128
+ # ─── _on_message(): ack/reject según el resultado del dispatch ────────────
129
+
130
+
131
+ def test_on_message_ack_tras_procesar_ok(monkeypatch):
132
+ calls = []
133
+ monkeypatch.setattr(rabbit_consumer, "dispatch", lambda name, payload: calls.append((name, payload)))
134
+ msg = _FakeMessage(_envelope("internacion.alta-medica.registrada", {"paciente_id": 7}))
135
+
136
+ asyncio.run(rabbit_consumer._on_message(msg))
137
+
138
+ assert msg.acked
139
+ assert msg.rejected_requeue is None
140
+ assert calls == [("internacion.alta-medica.registrada", {"paciente_id": 7})]
141
+
142
+
143
+ def test_on_message_json_malformado_reject_sin_requeue():
144
+ msg = _FakeMessage(b"esto no es json")
145
+
146
+ asyncio.run(rabbit_consumer._on_message(msg))
147
+
148
+ assert not msg.acked
149
+ assert msg.rejected_requeue is False
150
+
151
+
152
+ def test_on_message_envelope_sin_event_type_name_reject():
153
+ msg = _FakeMessage(json.dumps({"payload": "{}"}).encode())
154
+
155
+ asyncio.run(rabbit_consumer._on_message(msg))
156
+
157
+ assert not msg.acked
158
+ assert msg.rejected_requeue is False
159
+
160
+
161
+ def test_on_message_dispatch_lanza_excepcion_reject_sin_crashear(monkeypatch):
162
+ def _raise(name, payload):
163
+ raise RuntimeError("fallo de negocio")
164
+
165
+ monkeypatch.setattr(rabbit_consumer, "dispatch", _raise)
166
+ msg = _FakeMessage(_envelope("internacion.alta-medica.registrada", {"paciente_id": 7}))
167
+
168
+ asyncio.run(rabbit_consumer._on_message(msg)) # no debe propagar la excepción
169
+
170
+ assert not msg.acked
171
+ assert msg.rejected_requeue is False
172
+
173
+
174
+ def test_on_message_event_type_name_no_mapeado_reject(monkeypatch):
175
+ msg = _FakeMessage(_envelope("algo.no.mapeado", {}))
176
+
177
+ asyncio.run(rabbit_consumer._on_message(msg))
178
+
179
+ assert not msg.acked
180
+ assert msg.rejected_requeue is False
tests/test_webhooks.py CHANGED
@@ -34,6 +34,52 @@ def test_alta_medica_ok(client: TestClient, admin_headers, monkeypatch):
34
  assert "cama_id" in data
35
 
36
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
37
  def test_alta_medica_404(client: TestClient, admin_headers, monkeypatch):
38
  monkeypatch.setattr("app.crud.cama.get_by_paciente", lambda db, pid, estados: None)
39
  payload = {
 
34
  assert "cama_id" in data
35
 
36
 
37
+ def test_alta_medica_ok_aunque_monitoreo_falle(client: TestClient, admin_headers, monkeypatch):
38
+ """
39
+ notify_baja (M9) es fire-and-forget (M6_DISEÑO.md §2): que M9 esté caído no debe
40
+ revertir el alta. Antes de la limpieza de código zombie, esto bloqueaba con 502.
41
+ """
42
+ cama = make_cama(estado="OCUPADA", paciente_id=7)
43
+ monkeypatch.setattr("app.crud.cama.get_by_paciente", lambda db, pid, estados: cama)
44
+ monkeypatch.setattr("app.crud.cama.save", lambda db, c: c)
45
+ monkeypatch.setattr("app.integrations.monitoreo.notify_baja", lambda *a, **k: False)
46
+ payload = {
47
+ "paciente_id": 7,
48
+ "medico_firmante_id": 10,
49
+ "tipo_alta": "ALTA_MEDICA",
50
+ "timestamp": _NOW_ISO,
51
+ }
52
+ resp = client.post(f"{WEBHOOKS_PREFIX}/hce/alta-medica", json=payload, headers=admin_headers)
53
+ assert resp.status_code == 200
54
+ assert resp.json()["estado_cama"] == "EN_LIMPIEZA"
55
+
56
+
57
+ def test_alta_medica_no_llama_a_facturacion(client: TestClient, admin_headers, monkeypatch):
58
+ """
59
+ El alta médica ya no depende de M7 (notify_cierre_cama se eliminó por ser código
60
+ zombie: endpoint sin spec real, que bloqueaba el alta con 502 si fallaba). Blindaje
61
+ contra reintroducir esa dependencia: cualquier llamada a facturacion.* debe fallar el
62
+ test.
63
+ """
64
+ cama = make_cama(estado="OCUPADA", paciente_id=7)
65
+ monkeypatch.setattr("app.crud.cama.get_by_paciente", lambda db, pid, estados: cama)
66
+ monkeypatch.setattr("app.crud.cama.save", lambda db, c: c)
67
+ monkeypatch.setattr("app.integrations.monitoreo.notify_baja", lambda *a, **k: True)
68
+
69
+ def _fail(*a, **k):
70
+ raise AssertionError("procesar_alta_medica no debe llamar a facturacion.*")
71
+
72
+ monkeypatch.setattr("app.integrations.facturacion.notify_cama_lista", _fail)
73
+ payload = {
74
+ "paciente_id": 7,
75
+ "medico_firmante_id": 10,
76
+ "tipo_alta": "ALTA_MEDICA",
77
+ "timestamp": _NOW_ISO,
78
+ }
79
+ resp = client.post(f"{WEBHOOKS_PREFIX}/hce/alta-medica", json=payload, headers=admin_headers)
80
+ assert resp.status_code == 200
81
+
82
+
83
  def test_alta_medica_404(client: TestClient, admin_headers, monkeypatch):
84
  monkeypatch.setattr("app.crud.cama.get_by_paciente", lambda db, pid, estados: None)
85
  payload = {