EFC/microservice
5
0
Fork 0
Code Issues 1 Pull Requests Actions Packages Projects Releases Wiki Activity

se estan creando el registro de las tareas sin problemas

Browse Source
This commit is contained in:
Kevin Rosales
2025-10-08 21:15:03 -06:00
parent 48db0d72d8
commit 770e0a4d13
15 changed files with 858 additions and 258 deletions
Download Patch File Download Diff File Expand all files Collapse all files

80
api/api_v2/modules/coves/routers.py
View File

@@ -1,58 +1,106 @@
from fastapi import APIRouter, HTTPException
from .schemas import CoveListSchema, CoveRequestSchema
from typing import List
from typing import List, Dict, Any
from uuid import UUID
from .tasks import process_cove_request, process_acuse_cove_request
from ..tasks.services import register_task
router = APIRouter()
# Aquí puedes definir tus endpoints relacionados con COVES usando el esquema CoveBaseSchema
@router.post("/services/cove/", response_model=dict)
@router.post("/services/cove/", response_model=Dict[str, Any])
async def get_cove(cove: CoveRequestSchema):
# Lógica para obtener un COVE
task = process_cove_request.delay(cove.model_dump())
"""Endpoint para obtener un COVE específico."""
cove_dict = cove.model_dump()
task = process_cove_request.delay(cove_dict)
# Registrar la tarea en el servicio de seguimiento
await register_task(
task_id=task.id,
message=f"Procesando COVE para pedimento {cove_dict.get('pedimento', {}).get('pedimento_app', 'N/A')}",
status="submitted",
pedimento_id=cove_dict.get('pedimento', {}).get('id'),
organizacion_id=cove_dict.get('pedimento', {}).get('organizacion'),
servicio=8 # 8 corresponde a "Cove"
)
return {"task_id": task.id, "status": "submitted"}
@router.post("/services/all/coves", response_model=dict)
@router.post("/services/all/coves", response_model=Dict[str, Any])
async def get_coves(coves_request: CoveListSchema):
# Lógica para obtener un COVE
"""Endpoint para obtener múltiples COVEs asociados a un pedimento."""
task_ids = []
coves_dict = coves_request.model_dump()
pedimento = coves_dict.get('pedimento', {})
for cove in coves_dict.get('coves', []):
cove_dict = {
"cove": cove,
"pedimento": coves_dict.get('pedimento'),
"pedimento": pedimento,
"credencial": coves_dict.get('credencial')
}
task = process_cove_request.delay(cove_dict)
task_ids.append(task.id)
# Registrar cada tarea en el servicio de seguimiento
await register_task(
task_id=task.id,
message=f"Procesando COVE masivo para pedimento {pedimento.get('pedimento_app', 'N/A')}",
status="submitted",
pedimento_id=pedimento.get('id'),
organizacion_id=pedimento.get('organizacion'),
servicio=8 # 8 corresponde a "Cove"
)
return {"task_ids": task_ids, "status": "submitted", "total": len(task_ids)}
return {"task_id": task.id, "coves_tasks_ids": task_ids, "status": "submitted"}
@router.post("/services/acuse/cove/", response_model=dict)
@router.post("/services/acuse/cove/", response_model=Dict[str, Any])
async def get_acuse_cove(cove: CoveRequestSchema):
# Lógica para obtener un COVE
task = process_acuse_cove_request.delay(cove.model_dump())
"""Endpoint para obtener el acuse de un COVE específico."""
cove_dict = cove.model_dump()
task = process_acuse_cove_request.delay(cove_dict)
# Registrar la tarea en el servicio de seguimiento
await register_task(
task_id=task.id,
message=f"Procesando acuse de COVE para pedimento {cove_dict.get('pedimento', {}).get('pedimento_app', 'N/A')}",
status="submitted",
pedimento_id=cove_dict.get('pedimento', {}).get('id'),
organizacion_id=cove_dict.get('pedimento', {}).get('organizacion'),
servicio=9 # 9 corresponde a "Acuse Cove"
)
return {"task_id": task.id, "status": "submitted"}
@router.post("/services/all/acuse/cove/")
@router.post("/services/all/acuse/cove/", response_model=Dict[str, Any])
async def get_acuses_cove(coves_request: CoveListSchema):
# Lógica para obtener un COVE
"""Endpoint para obtener los acuses de múltiples COVEs asociados a un pedimento."""
task_ids = []
coves_dict = coves_request.model_dump()
pedimento = coves_dict.get('pedimento', {})
for cove in coves_dict.get('coves', []):
acuse_dict = {
"cove": cove,
"pedimento": coves_dict.get('pedimento'),
"pedimento": pedimento,
"credencial": coves_dict.get('credencial')
}
task = process_acuse_cove_request.delay(acuse_dict)
task_ids.append(task.id)
# Registrar cada tarea en el servicio de seguimiento
await register_task(
task_id=task.id,
message=f"Procesando acuse masivo de COVE para pedimento {pedimento.get('pedimento_app', 'N/A')}",
status="submitted",
pedimento_id=pedimento.get('id'),
organizacion_id=pedimento.get('organizacion'),
servicio=9 # 9 corresponde a "Acuse Cove"
)
return {"task_ids": task_ids, "status": "submitted", "total": len(task_ids)}

163
api/api_v2/modules/coves/services.py
View File

@@ -2,17 +2,20 @@ import base64
import os
import logging
import re
import tempfile
from typing import Any, Dict, List, Optional
import xml.etree.ElementTree as ET
from fastapi import HTTPException
from controllers.RESTController import rest_controller
from controllers.SOAPController import soap_controller
from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.primitives.asymmetric import padding
from cryptography.hazmat.primitives.serialization import load_der_private_key
import tempfile
from utils.helpers import soap_error
from .controllers import coves_vu_controller, coves_rest_controller
from ..common import create_service_response, create_error_response
# Logger para el módulo
logger = logging.getLogger(__name__)
@@ -42,8 +45,26 @@ async def consume_ws_get_cove(**kwargs):
cove = kwargs['cove'].get('cove', None)
if not credenciales or not username or not cove:
raise Exception(
"Credenciales o COVE no proporcionados correctamente")
missing = []
if not credenciales:
missing.append("credenciales")
if not username:
missing.append("nombre de usuario")
if not cove:
missing.append("número de COVE")
raise HTTPException(
status_code=400,
detail=create_error_response(
message="Datos incompletos para procesar COVE",
errors=[f"Falta: {', '.join(missing)}"],
metadata={"provided_data": {
"has_credentials": bool(credenciales),
"has_username": bool(username),
"has_cove": bool(cove)
}}
)
)
logger.info(f"Procesando COVE: {cove} para usuario: {username}")
@@ -120,18 +141,38 @@ async def consume_ws_get_cove(**kwargs):
logger.info(f"COVE {cove} procesado exitosamente")
# Asegurar que la respuesta sea serializable
result = {
"documento": document_response if document_response else None,
"cove_update_response": cove_status_response if cove_status_response else None
}
return result
return create_service_response(
message=f"COVE {cove} procesado exitosamente",
data={
"documento": document_response if document_response else None,
"cove_update_response": cove_status_response if cove_status_response else None
},
metadata={
"cove_number": cove,
"file_name": _file_name,
"document_type": 8,
"pedimento_app": pedimento_app,
"username": username,
"organizacion": kwargs.get('pedimento', {}).get('organizacion')
}
)
except HTTPException as he:
raise he
except Exception as e:
logger.error(f"Error procesando COVE: {str(e)}", exc_info=True)
# Asegurar que no se retornen datos binarios en el error
raise Exception(f"Error interno al procesar COVE: {str(e)}")
raise HTTPException(
status_code=500,
detail=create_error_response(
message="Error interno al procesar COVE",
errors=[str(e)],
metadata={
"cove_number": cove,
"username": username,
"pedimento_app": pedimento_app
}
)
)
async def consume_ws_get_acuse_cove(**kwargs):
@@ -155,20 +196,57 @@ async def consume_ws_get_acuse_cove(**kwargs):
)
if response is None:
raise Exception("No se obtuvo respuesta del servicio SOAP.")
raise HTTPException(
status_code=500,
detail=create_error_response(
message="Error al contactar el servicio SOAP",
errors=["No se obtuvo respuesta del servicio SOAP"],
metadata={
"cove_number": kwargs['cove'].get('cove'),
"pedimento_app": kwargs.get('pedimento', {}).get('pedimento_app')
}
)
)
if response.status_code != 200:
raise Exception(f"Error en la solicitud SOAP: {response.status}")
raise HTTPException(
status_code=response.status_code,
detail=create_error_response(
message="Error en la solicitud SOAP",
errors=[f"Código de estado: {response.status_code}"],
data={"soap_response": response.text[:500]},
metadata={
"status_code": response.status_code,
"cove_number": kwargs['cove'].get('cove')
}
)
)
if soap_error(response):
rest_response = await coves_rest_controller.post_document(
soap_response=response,
organizacion=kwargs.get('pedimento').get('organizacion'),
pedimento=kwargs.get('pedimento').get('id'),
file_name=f"vu_AC_COVE_{kwargs.get('pedimento', {}).get('pedimento_app', 'N/A')}_{kwargs['cove'].get('cove', 'N/A')}_ERROR.xml",
document_type=10,
error_file_name = f"vu_AC_COVE_{kwargs.get('pedimento', {}).get('pedimento_app', 'N/A')}_{kwargs['cove'].get('cove', 'N/A')}_ERROR.xml"
try:
rest_response = await coves_rest_controller.post_document(
soap_response=response,
organizacion=kwargs.get('pedimento').get('organizacion'),
pedimento=kwargs.get('pedimento').get('id'),
file_name=error_file_name,
document_type=10,
)
except Exception as e:
logger.error(f"Error al guardar respuesta SOAP errónea: {e}")
raise HTTPException(
status_code=500,
detail=create_error_response(
message="Error en la respuesta del servicio SOAP",
errors=["Se detectó un error en la respuesta SOAP"],
data={"error_file": error_file_name} if 'rest_response' in locals() else None,
metadata={
"cove_number": kwargs['cove'].get('cove'),
"document_type": 10
}
)
)
raise Exception("Error detectado en la respuesta SOAP.")
if (response) and (not soap_error(response)):
logger.debug(f"Respuesta SOAP recibida, extrayendo acuse...")
acuse_base64 = _extract_acuse_data(response.text)
@@ -224,12 +302,22 @@ async def consume_ws_get_acuse_cove(**kwargs):
pedimento=kwargs.get('pedimento')
)
return {
"document_response": rest_response,
"file_name": _file_name,
"pedimento": pedimento_num,
"acuse_update": acuse_status
}
return create_service_response(
message="Acuse de COVE procesado exitosamente",
data={
"document_response": rest_response,
"file_name": _file_name,
"pedimento": pedimento_num,
"acuse_update": acuse_status
},
metadata={
"document_type": 7,
"pedimento_app": pedimento.get('pedimento_app'),
"organizacion": organizacion,
"cove_number": kwargs['cove'].get('cove'),
"content_type": "application/pdf"
}
)
def _decode_acuse_base64_content(base64_content): # Testeado
@@ -462,15 +550,26 @@ async def fetch_sign_and_cer(cadena_original: str, username: str, credenciales:
return firma, certificado, tmp_key_path
except Exception as e:
logger.error(
f"Error obteniendo certificado/llave o generando firma: {e}")
logger.error(f"Error obteniendo certificado/llave o generando firma: {e}")
# Limpiar archivo temporal si existe
if 'tmp_key_path' in locals() and os.path.exists(tmp_key_path):
try:
os.remove(tmp_key_path)
except:
pass
raise Exception(f"Error en fetch_sign_and_cer: {str(e)}")
except Exception as cleanup_error:
logger.warning(f"Error al limpiar archivo temporal: {cleanup_error}")
raise HTTPException(
status_code=500,
detail=create_error_response(
message="Error al procesar certificado y firma",
errors=[str(e)],
metadata={
"username": username,
"has_key": bool(key_bytes) if 'key_bytes' in locals() else False,
"has_cert": bool(cer) if 'cer' in locals() else False
}
)
)
def sign_chain_original(key_path: str, password: str, cadena_original: str) -> str: