File size: 4,662 Bytes
5f12c93
8defa71
f485d1b
8defa71
 
0e75654
8defa71
 
 
 
5f12c93
a440d33
f485d1b
 
0e75654
 
5f12c93
9f05894
5f12c93
8defa71
5f12c93
a440d33
 
5f12c93
4a2396c
0e75654
4a2396c
 
 
0e75654
4a2396c
 
 
0e75654
 
 
f485d1b
8defa71
 
f485d1b
4a2396c
 
 
 
8defa71
f485d1b
 
9f05894
bff144c
 
 
 
 
f485d1b
5f12c93
 
8defa71
a440d33
 
 
 
 
 
 
 
 
8defa71
 
 
 
5f12c93
f485d1b
0e75654
bff144c
4a2396c
5f12c93
8defa71
4a2396c
 
 
8defa71
 
 
 
bff144c
 
4a2396c
 
8defa71
4a2396c
8defa71
5ffed1d
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
"""
M7 Facturación — notificación de cierre de internación para facturar.

Dos canales, con payloads DISTINTOS (ver `notify_cama_lista`):
- REST directo (`POST /api/v1/webhooks/internacion/cama-lista`): fallback/testing manual
  según M7 (`documentation/integrations/M7_integration.md`) — payload mínimo.
- Evento del Core (`facturacion.internacion.cama-lista.requested`, `event_type_id=19`):
  la integración final confirmada por M7 — payload rico (`CIERRE_INTERNACION`), con datos
  del episodio que M6 empezó a persistir en la propia fila de `Cama` (ver
  `app/models/cama.py`) precisamente para poder armar este evento.
"""
import logging
from datetime import date, datetime, timezone

from supabase import Client

from app.config import settings
from app.integrations import core_events
from app.integrations._base import _post
from app.models.cama import Cama

logger = logging.getLogger(__name__)


def _iso_z(dt: datetime | None) -> str | None:
    """
    ISO 8601 UTC con sufijo `Z`, como documenta M7 (`M7_integration.md`) y como se usa en
    el resto del proyecto — `datetime.isoformat()` sobre un aware UTC produce `+00:00`, no
    `Z`, y M7 puede no parsearlo igual (típico si su DTO usa `Instant`).
    """
    if dt is None:
        return None
    return dt.astimezone(timezone.utc).isoformat().replace("+00:00", "Z")


def notify_cama_lista(cama: Cama, db: Client) -> bool:
    """
    Avisa a M7 que una cama quedó lista tras un alta — cierra la internación del lado de
    facturación.

    `db` no se usa dentro de la función (se dejó de reconstruir `camasUtilizadas` vía
    auditoría, campo que no forma parte del contrato real de M7 — ver `M6_DISEÑO.md` §7.2);
    se mantiene en la firma para no tocar el call site (`solicitud_service.procesar_alta_medica`).

    `idEventoExterno` es la clave de idempotencia que usa M7: se deriva de forma estable
    (cama + paciente + fecha del alta) para que un reintento del mismo evento no genere un
    alta duplicada en facturación.

    `idEpisodioExterno` viaja como `cama.episodio_id` (entero) cuando está poblado, o `None`
    si no: M1 todavía no provee ese dato en `AltaMedicaWebhook` (pendiente de coordinar — ver
    `M6_DISEÑO.md` §14 y `documentation/M6_INTEGRACION_M1_HCE.md`), así que hoy siempre es
    `None` en la práctica. M7 confirmó que sin ese dato el evento queda pendiente de completar
    del lado de ellos, no se rechaza.
    """
    if settings.mock_external_services:
        return True

    if not settings.facturacion_cierre_habilitado:
        # Pausa manual (2026-07): por ahora no se le manda a M7 el cierre de internación,
        # ni por evento ni por REST — fire-and-forget, no frena el alta.
        logger.info(
            "Cierre de facturación (M7) desactivado — no se envía CIERRE_INTERNACION (cama=%s)",
            cama.id,
        )
        return True

    paciente_id = cama.paciente_id or 0
    id_evento_externo = f"M6-CIERRE-INT-{cama.id}-{paciente_id}-{date.today().isoformat()}"

    payload_rest = {
        "evento": "CAMA_LISTA",
        "idEventoExterno": id_evento_externo,
        "camaId": str(cama.id),
        "idPacienteExterno": paciente_id,
        "timestampEvento": _iso_z(datetime.now(timezone.utc)),
    }

    # Payload del evento del Core: exactamente el contrato que confirmó M7 por escrito
    # (`M7_integration.md`) y que documenta `M6_DISEÑO.md` §7.2 — sin campos extra
    # (`camaId`/`camasUtilizadas` no forman parte de ese contrato).
    payload_evento = {
        "evento": "CIERRE_INTERNACION",
        "idEventoExterno": id_evento_externo,
        "idInternacionExterna": cama.solicitud_hce_id,
        "idEpisodioExterno": int(cama.episodio_id) if cama.episodio_id is not None else None,
        "idPacienteExterno": paciente_id,
        "fechaIngreso": _iso_z(cama.fecha_ingreso),
        "fechaAlta": _iso_z(cama.alta_timestamp),
        "tipoAlta": cama.alta_tipo,
        "timestampEvento": _iso_z(datetime.now(timezone.utc)),
    }

    # Canal primario: evento via M10 Core (si el event_type_id está configurado).
    # Solo se cae al backup HTTP si el evento falla o no está configurado.
    event_type_id = settings.facturacion_cama_lista_event_type_id
    if event_type_id is not None:
        ok_event = core_events.publish_event(event_type_id, payload_evento, publisher_module="modulo_6")
        if ok_event:
            return True

    # Backup: REST directo a M7 (fallback/testing manual según M7_integration.md)
    return _post(
        f"{settings.m7_facturacion_url}/api/v1/webhooks/internacion/cama-lista", payload_rest
    ) is not None