feat: queries reales Firebird y generadores JSON para API ERP

- json_generator: nuevas funciones generar_tercero_api y generar_rda_paciente
  mapeando PACIENTE/RECEPCION/RELACION al formato de los endpoints
  Tercero/Crear y RdaPaciente/Insertar
- queries: reemplaza placeholders por consultas reales sobre PACIENTE,
  RECEPCION, RELACION, MEDICO y CIUDAD
- config: agrega api_version y api_sucursal; actualiza url y credenciales Firebird
- terceros/transaccion routes: usan nuevos generadores y endpoints correctos

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

app/routes/config.py

@@ -11,10 +11,12 @@ DEFAULT_KEYS = [
     ("firebird_database", "/path/to/database.fdb"),
     ("firebird_user", "SYSDBA"),
     ("firebird_password", "masterkey"),
-    ("api_url", "https://api.example.com/rips"),
+    ("api_url", "http://192.168.0.125"),
     ("api_method", "POST"),
     ("api_key", ""),
     ("api_timeout", "30"),
+    ("api_version", "1"),
+    ("api_sucursal", ""),
     ("num_documento_obligado", ""),
     ("cod_prestador", ""),
 ]

app/routes/queries.py

@@ -8,73 +8,85 @@ router = APIRouter(prefix="/queries", tags=["queries"])
 
 QUERY_DEFAULTS = [
     {
-        "name": "Terceros - Datos del paciente",
+        "name": "Tercero - Datos del paciente",
         "query_type": "terceros",
         "query_text": """SELECT
-    p.TIPO_DOCUMENTO as tipo_documento,
+    p.CODIGO,
-    p.NUMERO_DOCUMENTO as numero_documento,
+    p.TIPOIDENT,
-    p.PRIMER_NOMBRE as primer_nombre,
+    p.DOCIDENT,
-    p.SEGUNDO_NOMBRE as segundo_nombre,
+    p.NOMBRES,
-    p.PRIMER_APELLIDO as primer_apellido,
+    p.APELLIDOS,
-    p.SEGUNDO_APELLIDO as segundo_apellido,
+    p.DIRECCION,
-    p.FECHA_NACIMIENTO as fecha_nacimiento,
+    p.CIUDAD        AS COD_CIUDAD,
-    p.SEXO as cod_sexo,
+    c.NOMBRE        AS NOM_CIUDAD,
-    p.COD_ENTIDAD as cod_entidad,
+    p.TELEFONOS,
-    p.TIPO_USUARIO as tipo_usuario,
+    p.EMAIL,
-    p.COD_MUNICIPIO as cod_municipio,
+    p.F_NACIMIENTO,
-    p.ZONA as cod_zona,
+    p.SEXO,
-    p.DIRECCION as direccion
+    p.TIPORES,
-FROM USUAHOS p
+    p.CODETNIA
-WHERE p.NUMERO_DOCUMENTO = :doc_num""",
+FROM PACIENTE p
-        "description": "Consulta datos maestros del paciente por documento"
+LEFT JOIN CIUDAD c ON c.CODIGO = p.CIUDAD
+WHERE p.DOCIDENT = :doc_num""",
+        "description": "Datos del paciente por número de documento (para Tercero/Crear)"
     },
     {
-        "name": "Procedimientos por factura",
+        "name": "RDA Paciente por factura",
         "query_type": "transaccion",
         "query_text": """SELECT
-    s.CODIGO_CUP as cod_procedimiento,
+    r.IDRECEPCION,
-    s.FECHA_ATENCION as fecha_atencion,
+    r.PREFIJO,
-    s.COD_DIAGNOSTICO as cod_diagnostico,
+    r.NUM_FACTURA,
-    s.FINALIDAD as finalidad,
+    r.FECHA_RECEPCION,
-    s.VIA_INGRESO as via_ingreso,
+    r.COD_PACIENTE,
-    s.MODALIDAD as modalidad,
+    r.NIT_EMPRESA,
-    s.GRUPO_SERVICIO as grupo_servicio,
+    r.DIAG_PPAL,
-    s.COD_SERVICIO as cod_servicio,
+    r.TIPOUSU,
-    s.COD_PRESTADOR as cod_prestador,
+    r.TIPOUSUSISPRO,
-    s.TIPO_DOC_PROFESIONAL as tipo_doc_profesional,
+    r.AUTORIZACION,
-    s.NUM_DOC_PROFESIONAL as num_doc_profesional,
+    r.CLASEPROC,
-    s.VR_SERVICIO as vr_servicio,
+    r.HORAINICIORECEPCION,
-    s.VALOR_PAGO_MODERADOR as valor_pago_moderador,
+    r.VALORTOTAL,
-    s.CONCEPTO_RECAUDO as concepto_recaudo,
+    rel.COD_EXAMEN,
-    s.NUM_AUTORIZACION as num_autorizacion
+    rel.PRECIO,
-FROM SERVICIOS s
+    rel.FECHA_REPORTADO,
-WHERE s.NUM_FACTURA = :factura
+    m.COD_ESPECIALIDAD,
-  AND s.FECHA_ATENCION BETWEEN :fecha_ini AND :fecha_fin""",
+    r.USUARIO       AS profesional
-        "description": "Consulta procedimientos por factura y rango de fechas"
+FROM RECEPCION r
+JOIN RELACION rel ON rel.IDRECEPCION = r.IDRECEPCION
+LEFT JOIN MEDICO m ON m.CODIGO = r.COD_MEDICO
+WHERE r.NUM_FACTURA = :num_factura
+  AND r.PREFIJO     = :prefijo""",
+        "description": "Servicios de una recepción por número de factura y prefijo"
     },
     {
-        "name": "Procedimientos por fecha",
+        "name": "RDA Paciente por fecha",
         "query_type": "transaccion",
         "query_text": """SELECT
-    s.FACTURA as num_factura,
+    r.IDRECEPCION,
-    s.CODIGO_CUP as cod_procedimiento,
+    r.PREFIJO,
-    s.FECHA_ATENCION as fecha_atencion,
+    r.NUM_FACTURA,
-    s.COD_DIAGNOSTICO as cod_diagnostico,
+    r.FECHA_RECEPCION,
-    s.FINALIDAD as finalidad,
+    r.COD_PACIENTE,
-    s.VIA_INGRESO as via_ingreso,
+    r.NIT_EMPRESA,
-    s.MODALIDAD as modalidad,
+    r.DIAG_PPAL,
-    s.GRUPO_SERVICIO as grupo_servicio,
+    r.TIPOUSU,
-    s.COD_SERVICIO as cod_servicio,
+    r.TIPOUSUSISPRO,
-    s.COD_PRESTADOR as cod_prestador,
+    r.AUTORIZACION,
-    s.TIPO_DOC_PROFESIONAL as tipo_doc_profesional,
+    r.CLASEPROC,
-    s.NUM_DOC_PROFESIONAL as num_doc_profesional,
+    r.HORAINICIORECEPCION,
-    s.VR_SERVICIO as vr_servicio,
+    r.VALORTOTAL,
-    p.TIPO_DOCUMENTO as tipo_doc_paciente,
+    rel.COD_EXAMEN,
-    p.NUMERO_DOCUMENTO as num_doc_paciente
+    rel.PRECIO,
-FROM SERVICIOS s
+    rel.FECHA_REPORTADO,
-JOIN USUAHOS p ON s.COD_PACIENTE = p.COD_PACIENTE
+    m.COD_ESPECIALIDAD,
-WHERE s.FECHA_ATENCION BETWEEN :fecha_ini AND :fecha_fin""",
+    r.USUARIO       AS profesional
-        "description": "Consulta todos los procedimientos en rango de fechas"
+FROM RECEPCION r
+JOIN RELACION rel ON rel.IDRECEPCION = r.IDRECEPCION
+LEFT JOIN MEDICO m ON m.CODIGO = r.COD_MEDICO
+WHERE r.FECHA_RECEPCION BETWEEN :fecha_ini AND :fecha_fin
+ORDER BY r.IDRECEPCION""",
+        "description": "Servicios en un rango de fechas (para RdaPaciente/Insertar)"
     },
 ]
 

app/routes/terceros.py

@@ -6,7 +6,7 @@ from fastapi.responses import JSONResponse
 from app.database import get_connection
 from app.auth import get_current_user
 from app.services.firebird_service import get_firebird_from_config
-from app.services.json_generator import generar_terceros
+from app.services.json_generator import generar_tercero_api
 
 router = APIRouter(prefix="/terceros", tags=["terceros"])
 
@@ -93,7 +93,7 @@ async def preview_query(
     if not success:
         return JSONResponse({"success": False, "message": error})
 
-    json_result = generar_terceros(rows[0]) if rows else None
+    json_result = generar_tercero_api(rows[0]) if rows else None
 
     return JSONResponse({
         "success": True,
@@ -135,26 +135,25 @@ async def send_terceros(
     if not rows:
         return JSONResponse({"success": False, "message": "No se encontraron datos"})
 
-    tercero_json = generar_terceros(rows[0])
+    tercero_json = generar_tercero_api(rows[0])
 
     api_url = configs.get("api_url", "")
+    api_version = configs.get("api_version", "1")
     api_key = configs.get("api_key", "")
-    api_method = configs.get("api_method", "POST")
     headers = {"Content-Type": "application/json"}
     if api_key:
         headers["Authorization"] = f"Bearer {api_key}"
 
+    endpoint = f"{api_url}/v{api_version}/tablas/Tercero/Crear"
+
     resp_ok = False
     resp_text = ""
     resp_code = 0
     try:
         async with httpx.AsyncClient(timeout=int(configs.get("api_timeout", 30))) as client:
-            if api_method == "POST":
+            resp = await client.post(endpoint, json=tercero_json, headers=headers)
-                resp = await client.post(api_url + "/terceros", json=tercero_json, headers=headers)
-            else:
-                resp = await client.put(api_url + "/terceros", json=tercero_json, headers=headers)
         resp_ok = resp.is_success
-        resp_text = resp.text
+        resp_text = resp.text[:2000]
         resp_code = resp.status_code
     except Exception as e:
         resp_text = str(e)

app/routes/transaccion.py

@@ -6,7 +6,7 @@ from fastapi.responses import JSONResponse
 from app.database import get_connection
 from app.auth import get_current_user
 from app.services.firebird_service import get_firebird_from_config
-from app.services.json_generator import generar_transaccion, agrupar_por_factura
+from app.services.json_generator import generar_rda_paciente, agrupar_por_recepcion
 
 router = APIRouter(prefix="/transaccion", tags=["transaccion"])
 
@@ -53,8 +53,11 @@ async def preview_transaccion(
         return JSONResponse({"success": False, "message": f"Error Firebird: {msg}"})
 
     params = {"fecha_ini": fecha_inicio, "fecha_fin": fecha_fin}
-    if ":factura" in q["query_text"] and factura:
+    if ":num_factura" in q["query_text"] and factura:
-        params["factura"] = factura
+        params["num_factura"] = factura
+        prefijo = configs.get("api_prefijo", "")
+        if prefijo:
+            params["prefijo"] = prefijo
 
     success, error, rows = fb.execute_query(q["query_text"], params)
     fb.disconnect()
@@ -62,14 +65,8 @@ async def preview_transaccion(
     if not success:
         return JSONResponse({"success": False, "message": error})
 
-    grupos = agrupar_por_factura(rows, factura)
+    grupos = agrupar_por_recepcion(rows)
-    json_result = []
+    json_result = [generar_rda_paciente(grupo) for grupo in grupos.values()]
-    for (fact, doc_key), grupo in grupos.items():
-        paciente_data = {"tipoDocumentoIdentificacion": doc_key[0], "numDocumentoIdentificacion": doc_key[1]}
-        json_result.append(generar_transaccion(
-            fact, configs.get("num_documento_obligado", ""),
-            paciente_data, grupo["procedimientos"],
-        ))
 
     return JSONResponse({
         "success": True,
@@ -104,8 +101,11 @@ async def send_transaccion(
         return JSONResponse({"success": False, "message": f"Error Firebird: {msg}"})
 
     params = {"fecha_ini": fecha_inicio, "fecha_fin": fecha_fin}
-    if ":factura" in q["query_text"] and factura:
+    if ":num_factura" in q["query_text"] and factura:
-        params["factura"] = factura
+        params["num_factura"] = factura
+        prefijo = configs.get("api_prefijo", "")
+        if prefijo:
+            params["prefijo"] = prefijo
 
     success, error, rows = fb.execute_query(q["query_text"], params)
     fb.disconnect()
@@ -115,33 +115,31 @@ async def send_transaccion(
     if not rows:
         return JSONResponse({"success": False, "message": "No se encontraron datos"})
 
-    grupos = agrupar_por_factura(rows, factura)
+    grupos = agrupar_por_recepcion(rows)
     api_url = configs.get("api_url", "")
+    api_version = configs.get("api_version", "1")
+    api_sucursal = configs.get("api_sucursal", "")
     api_key = configs.get("api_key", "")
-    api_method = configs.get("api_method", "POST")
     headers = {"Content-Type": "application/json"}
     if api_key:
         headers["Authorization"] = f"Bearer {api_key}"
 
+    endpoint = f"{api_url}/v{api_version}/rda/RdaPaciente/Insertar"
+    if api_sucursal:
+        endpoint += f"?codigosucursal={api_sucursal}"
+
     total_enviados = 0
     total_errores = 0
     resultados = []
 
     async with httpx.AsyncClient(timeout=int(configs.get("api_timeout", 30))) as client:
-        for (fact, doc_key), grupo in grupos.items():
+        for id_recepcion, grupo_rows in grupos.items():
-            paciente_data = {"tipoDocumentoIdentificacion": doc_key[0], "numDocumentoIdentificacion": doc_key[1]}
+            trans_json = generar_rda_paciente(grupo_rows)
-            trans_json = generar_transaccion(
-                fact, configs.get("num_documento_obligado", ""),
-                paciente_data, grupo["procedimientos"],
-            )
 
             status_ok = False
             response_text = ""
             try:
-                if api_method == "POST":
+                resp = await client.post(endpoint, json=trans_json, headers=headers)
-                    resp = await client.post(api_url + "/transaccion", json=trans_json, headers=headers)
-                else:
-                    resp = await client.put(api_url + "/transaccion", json=trans_json, headers=headers)
                 status_ok = resp.is_success
                 response_text = resp.text[:1000]
             except Exception as e:
@@ -152,6 +150,7 @@ async def send_transaccion(
             else:
                 total_errores += 1
 
+            fact = str(grupo_rows[0].get("NUM_FACTURA", id_recepcion))
             resultados.append({"factura": fact, "success": status_ok})
 
             conn = get_connection()
@@ -162,7 +161,7 @@ async def send_transaccion(
             """, (
                 user["user_id"], "transaccion", fact,
                 fecha_inicio, fecha_fin,
-                1, len(grupo["procedimientos"]),
+                1, len(grupo_rows),
                 "success" if status_ok else "error",
                 json_lib.dumps(trans_json, indent=2, ensure_ascii=False)[:5000],
                 response_text,

app/services/json_generator.py

@@ -3,6 +3,161 @@ from datetime import datetime
 from typing import Optional
 
 
+# ── helpers de formato de fecha ──────────────────────────────────────────────
+
+def _fmt_fecha(val) -> str:
+    if not val:
+        return ""
+    if hasattr(val, "strftime"):
+        return val.strftime("%d/%m/%Y")
+    s = str(val)[:10]
+    parts = s.split("-")
+    if len(parts) == 3:
+        return f"{parts[2]}/{parts[1]}/{parts[0]}"
+    return s
+
+
+def _fmt_datetime(val) -> str:
+    if not val:
+        return ""
+    if hasattr(val, "strftime"):
+        return val.strftime("%d/%m/%Y %H:%M:%S")
+    s = str(val)[:19].replace("T", " ")
+    parts = s.split(" ")
+    if len(parts) == 2:
+        dp = parts[0].split("-")
+        if len(dp) == 3:
+            return f"{dp[2]}/{dp[1]}/{dp[0]} {parts[1]}"
+    return s
+
+
+# ── Tercero/Crear ─────────────────────────────────────────────────────────────
+
+_TIPO_DOC_MAP = {
+    "CC": "C", "TI": "T", "RC": "R", "CE": "E",
+    "PA": "P", "AS": "A", "MS": "M", "NU": "U",
+    "SC": "S", "PE": "PE", "PT": "PT", "SI": "A",
+    "CN": "C", "DE": "E", "CD": "P",
+}
+
+_ZONA_MAP = {"U": "01", "R": "02"}
+
+
+def generar_tercero_api(row: dict) -> dict:
+    nombres = (row.get("NOMBRES") or "").strip().upper().split()
+    apellidos = (row.get("APELLIDOS") or "").strip().upper().split()
+
+    nombre_completo = f"{row.get('NOMBRES', '')} {row.get('APELLIDOS', '')}".strip().upper()
+    tipo_doc = _TIPO_DOC_MAP.get(str(row.get("TIPOIDENT") or "CC").strip(), "C")
+    zona = _ZONA_MAP.get(str(row.get("TIPORES") or "U").strip(), "01")
+
+    return {
+        "Codigo": str(row.get("CODIGO") or "").strip(),
+        "NatJuridica": "N",
+        "TipoDocumento": tipo_doc,
+        "Nit": str(row.get("DOCIDENT") or "").strip(),
+        "Nombre": nombre_completo,
+        "Nombre1": nombres[0] if nombres else "",
+        "Nombre2": nombres[1] if len(nombres) > 1 else "",
+        "Apellido1": apellidos[0] if apellidos else "",
+        "Apellido2": apellidos[1] if len(apellidos) > 1 else "",
+        "Direccion": (row.get("DIRECCION") or "").strip(),
+        "CodigoCiudad": str(row.get("COD_CIUDAD") or "00").strip(),
+        "NombreCiudad": (row.get("NOM_CIUDAD") or "SIN CIUDAD").strip().upper(),
+        "Zona1": "00",
+        "Clasificacion": "00",
+        "Telefono": str(row.get("TELEFONOS") or "").strip(),
+        "Email": (row.get("EMAIL") or "").strip(),
+        "Inactivo": False,
+        "Privada": "N",
+        "Mixta": "N",
+        "CodigoBarrio": "00",
+        "Comision": 0,
+        "FechaNacimiento": _fmt_fecha(row.get("F_NACIMIENTO")),
+        "Sexo": str(row.get("SEXO") or "M").strip(),
+        "Zona": zona,
+        "Etnia": str(row.get("CODETNIA") or "99").strip(),
+        "Cliente": "S",
+        "EnfermedadCronica": False,
+        "NoEnviarMinSalud": False,
+    }
+
+
+# ── RdaPaciente/Insertar ──────────────────────────────────────────────────────
+
+def agrupar_por_recepcion(rows: list) -> dict:
+    grupos = defaultdict(list)
+    for row in rows:
+        key = row.get("IDRECEPCION")
+        grupos[key].append(dict(row))
+    return grupos
+
+
+def generar_rda_paciente(rows: list) -> dict:
+    if not rows:
+        return {}
+    h = rows[0]
+
+    fecha = _fmt_fecha(h.get("FECHA_RECEPCION"))
+    ingreso = _fmt_datetime(h.get("HORAINICIORECEPCION") or h.get("FECHA_RECEPCION"))
+    egreso = _fmt_datetime(h.get("FECHA_RECEPCION"))
+
+    detalle_pedido = []
+    for row in rows:
+        fecha_real = _fmt_datetime(
+            row.get("FECHA_REPORTADO") if str(row.get("FECHA_REPORTADO") or "")[:4] != "1900"
+            else h.get("FECHA_RECEPCION")
+        )
+        detalle_pedido.append({
+            "CodigoMaterial": str(row.get("COD_EXAMEN") or "").strip(),
+            "CodigoBodega": "00",
+            "Cantidad": 1,
+            "TipoUnidad": "D",
+            "Valor": float(row.get("PRECIO") or 0),
+            "Descuento": 0,
+            "PorcentajeIva": 0,
+            "ImpConsumo": 0,
+            "Observacion": "",
+            "profesional": str(h.get("profesional") or "").strip(),
+            "especialidad": str(row.get("COD_ESPECIALIDAD") or "").strip(),
+            "diagnosticoprincipal": str(h.get("DIAG_PPAL") or "").strip(),
+            "fechaHoraRealizacion": fecha_real or egreso,
+        })
+
+    autorizacion = str(h.get("AUTORIZACION") or "").strip() or None
+
+    return {
+        "CodigoPrefijo": str(h.get("PREFIJO") or "00").strip(),
+        "Numero": "",
+        "Fecha": fecha,
+        "CodTercero": str(h.get("COD_PACIENTE") or "").strip(),
+        "CodVendedor": "00",
+        "CodFormaPago": "CO",
+        "CodBanco": "00",
+        "CodigoCentroCosto": "00",
+        "tipoIngreso": str(h.get("CLASEPROC") or "1").strip() or "1",
+        "fechaHoraIngreso": ingreso,
+        "fechaHoraEgreso": egreso,
+        "modalidadAtencion": "01",
+        "numeroContrato": str(h.get("NIT_EMPRESA") or "").strip(),
+        "diagnosticoprincipal": str(h.get("DIAG_PPAL") or "").strip(),
+        "tipousuario": str(h.get("TIPOUSUSISPRO") or "12").strip(),
+        "viaIngreso": "01",
+        "esTerapia": False,
+        "esProcedimiento": False,
+        "numeroAutorizacion": autorizacion,
+        "DetallePedido": detalle_pedido,
+        "DetalleFormaPago": [{
+            "CodigoFormaPago": "CO",
+            "PlazoDias": "0",
+            "FechaVencimiento": fecha,
+            "Valor": str(int(float(h.get("VALORTOTAL") or 0))),
+        }],
+    }
+
+
+# ── funciones legacy RIPS 2.0 (se mantienen) ─────────────────────────────────
+
 def generar_terceros(row: dict) -> dict:
     return {
         "tipoDocumentoIdentificacion": row.get("tipo_documento", "CC"),