rips_manager/app/routes/transaccion.py

import json as json_lib
import httpx
from datetime import datetime
from fastapi import APIRouter, Request, Form, Depends
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_rda_paciente, agrupar_por_recepcion

router = APIRouter(prefix="/transaccion", tags=["transaccion"])


@router.get("")
async def transaccion_page(request: Request, user: dict = Depends(get_current_user)):
    conn = get_connection()
    envios = conn.execute("""
        SELECT * FROM envios WHERE tipo = 'transaccion'
        ORDER BY created_at DESC LIMIT 20
    """).fetchall()
    queries = conn.execute(
        "SELECT * FROM queries WHERE query_type = 'transaccion' ORDER BY name"
    ).fetchall()
    configs = {row["key"]: row["value"] for row in conn.execute("SELECT * FROM config").fetchall()}
    conn.close()

    return request.app.state.templates.TemplateResponse("transaccion.html", {
        "request": request, "user": user,
        "envios": envios, "queries": queries,
        "configs": configs,
    })


@router.post("/preview")
async def preview_transaccion(
    request: Request,
    user: dict = Depends(get_current_user),
    query_id: int = Form(...),
    factura: str = Form(""),
    fecha_inicio: str = Form(...),
    fecha_fin: str = Form(...),
):
    conn = get_connection()
    q = conn.execute("SELECT * FROM queries WHERE id = ?", (query_id,)).fetchone()
    configs = {row["key"]: row["value"] for row in conn.execute("SELECT * FROM config").fetchall()}
    conn.close()

    if not q:
        return JSONResponse({"success": False, "message": "Consulta no encontrada"})

    fb, ok, msg = get_firebird_from_config(configs)
    if not ok:
        return JSONResponse({"success": False, "message": f"Error Firebird: {msg}"})

    params = {"fecha_ini": fecha_inicio, "fecha_fin": fecha_fin}
    if ":num_factura" in q["query_text"] and 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()

    if not success:
        return JSONResponse({"success": False, "message": error})

    grupos = agrupar_por_recepcion(rows)
    json_result = [generar_rda_paciente(grupo) for grupo in grupos.values()]

    return JSONResponse({
        "success": True,
        "rows_count": len(rows),
        "grupos_count": len(grupos),
        "columns": list(rows[0].keys()) if rows else [],
        "preview": rows[:5],
        "generated_json": json_result[0] if json_result else None,
        "total_json": len(json_result),
    })


@router.post("/send")
async def send_transaccion(
    request: Request,
    user: dict = Depends(get_current_user),
    query_id: int = Form(...),
    factura: str = Form(""),
    fecha_inicio: str = Form(...),
    fecha_fin: str = Form(...),
):
    conn = get_connection()
    q = conn.execute("SELECT * FROM queries WHERE id = ?", (query_id,)).fetchone()
    configs = {row["key"]: row["value"] for row in conn.execute("SELECT * FROM config").fetchall()}
    conn.close()

    if not q:
        return JSONResponse({"success": False, "message": "Consulta no encontrada"})

    fb, ok, msg = get_firebird_from_config(configs)
    if not ok:
        return JSONResponse({"success": False, "message": f"Error Firebird: {msg}"})

    params = {"fecha_ini": fecha_inicio, "fecha_fin": fecha_fin}
    if ":num_factura" in q["query_text"] and 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()

    if not success:
        return JSONResponse({"success": False, "message": error})
    if not rows:
        return JSONResponse({"success": False, "message": "No se encontraron datos"})

    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", "")
    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 id_recepcion, grupo_rows in grupos.items():
            trans_json = generar_rda_paciente(grupo_rows)

            status_ok = False
            response_text = ""
            try:
                resp = await client.post(endpoint, json=trans_json, headers=headers)
                status_ok = resp.is_success
                response_text = resp.text[:1000]
            except Exception as e:
                response_text = str(e)

            if status_ok:
                total_enviados += 1
            else:
                total_errores += 1

            fact = str(grupo_rows[0].get("NUM_FACTURA", id_recepcion))
            resultados.append({"factura": fact, "success": status_ok})

            conn = get_connection()
            conn.execute("""
                INSERT INTO envios (user_id, tipo, factura, fecha_inicio, fecha_fin,
                    pacientes_count, servicios_count, status, json_enviado, respuesta_api, created_at)
                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
            """, (
                user["user_id"], "transaccion", fact,
                fecha_inicio, fecha_fin,
                1, len(grupo_rows),
                "success" if status_ok else "error",
                json_lib.dumps(trans_json, indent=2, ensure_ascii=False)[:5000],
                response_text,
                datetime.now().isoformat(),
            ))
            conn.commit()
            conn.close()

    return JSONResponse({
        "success": total_errores == 0,
        "total_enviados": total_enviados,
        "total_errores": total_errores,
        "resultados": resultados,
        "message": f"Enviados: {total_enviados}, Errores: {total_errores}",
    })