from fastapi import APIRouter, HTTPException from schemas.pedimentoSchema import PedimentoRequest from schemas.serviceSchema import ServiceBaseSchema, ServiceRemesaSchema import asyncio import logging logger = logging.getLogger("app.api") import traceback from typing import Dict, Any, List, Optional from contextlib import asynccontextmanager from controllers.RESTController import rest_controller from controllers.SOAPController import soap_controller from utils.peticiones import get_soap_acuseCOVE, get_soap_cove, get_soap_pedimento_completo, get_soap_remesas, get_soap_partidas, get_soap_acuse, get_soap_edocument from fastapi.responses import JSONResponse from utils.servicios import ( _validate_request_data, _get_pedimento_service, _update_service_status, _get_vucem_credentials, _create_response, _post_edocuments, _schedule_follow_up_services, _post_coves ) from core.config import settings from utils.servicios import * # Estados del servicio ESTADO_CREADO = 1 ESTADO_EN_PROCESO = 2 ESTADO_FINALIZADO = 3 ESTADO_ERROR = 4 router = APIRouter() logger = logging.getLogger(__name__) @router.post("/services/pedimento") async def get_pedimento(request: ServiceBaseSchema): """ Obtiene el pedimento completo de VUCEM y procesa todos los documentos asociados. Este endpoint: 1. Crea un servicio de pedimento completo 2. Obtiene credenciales VUCEM 3. Realiza petición SOAP para pedimento completo 4. Actualiza datos del pedimento 5. Procesa documentos digitalizados (e-documents) 6. Crea servicios adicionales automáticamente Args: request: ServiceBaseSchema con pedimento y organización Returns: JSONResponse con datos del pedimento completo y servicios creados Raises: HTTPException: En caso de errores de validación o procesamiento """ service_id = None operation_name = "pedimento" try: # Validar datos de entrada request_data = request.model_dump() await _validate_request_data(request_data) # Crear servicio de pedimento completo logger.info("Creando servicio de pedimento completo...") try: response_service = await rest_controller.post_pedimento_service(request_data) if not response_service: raise HTTPException(status_code=500, detail="No se pudo crear el servicio de pedimento completo") service_id = response_service['id'] logger.info(f"Servicio creado exitosamente con ID: {service_id}") except Exception as e: logger.error(f"Error al crear servicio de pedimento completo: {e}") raise HTTPException(status_code=500, detail="Error al crear el servicio de pedimento") except HTTPException: # Re-lanzar HTTPExceptions sin modificar raise return JSONResponse(content={"message": "Se creo el servicio para pedimento completo."}, status_code=202) @router.post("/services/pedimento_completo") async def get_pedimento_completo(request: ServiceRemesaSchema): """ Reintenta obtener el pedimento completo de VUCEM y procesa todos los documentos asociados. Utiliza la lógica de get_pedimento_completo, pero con manejo de errores y respuesta como get_remesas. """ operation_name = "pedimento_completo_retry" operation_name = "pedimento_completo" service_data = None try: # Validar datos de entrada request_data = request.model_dump() await _validate_request_data(request_data) logger.info(f"Iniciando procesamiento de pedimento completo - Pedimento: {request_data['pedimento']}") # Obtener servicio service_data = await _get_pedimento_service( pedimento_id=request_data['pedimento'], service_type=3, operation_name=operation_name ) # Actualizar estado a "En proceso" update_success = await _update_service_status( service_data['id'], ESTADO_EN_PROCESO, service_data, operation_name ) if not update_success: raise HTTPException(status_code=500, detail="Error al actualizar estado del servicio") # Obtener credenciales VUCEM contribuyente_id = service_data.get('pedimento', {}).get('contribuyente', '') if not contribuyente_id: logger.error("No se encontró ID de contribuyente en los datos del servicio") await _update_service_status(service_data['id'], ESTADO_ERROR, service_data, operation_name) raise HTTPException(status_code=400, detail="ID de contribuyente no encontrado") credentials = await _get_vucem_credentials(contribuyente_id, operation_name) # Procesar petición SOAP para remesas logger.info("Realizando petición SOAP para remesas...") try: soap_response = await get_soap_pedimento_completo( credenciales=credentials, response_service=service_data, soap_controller=soap_controller ) if not soap_response: raise HTTPException(status_code=500, detail="Error en la petición SOAP para remesas") logger.info("Petición SOAP para remesas completada exitosamente") except HTTPException: await _update_service_status(service_data['id'], ESTADO_ERROR, service_data, operation_name) raise except Exception as e: logger.error(f"Error en petición SOAP para remesas: {e}") await _update_service_status(service_data['id'], ESTADO_ERROR, service_data, operation_name) raise HTTPException(status_code=500, detail="Error en la petición SOAP al servicio VUCEM") # Actualizar datos del pedimento con información del XML logger.info("Actualizando datos del pedimento...") try: xml_content = soap_response.get('xml_content', {}) if xml_content: # Excluir 'identificadores_ed' del contenido a enviar update_content = {k: v for k, v in xml_content.items() if k != 'identificadores_ed'} update_content['existe_expediente'] = True pedimento_response = await rest_controller.put_pedimento( service_data['pedimento']['id'], update_content ) logger.info("Pedimento actualizado exitosamente") else: logger.warning("No se recibió contenido XML para actualizar el pedimento") except Exception as e: logger.warning(f"No se pudo actualizar el pedimento (continuando proceso): {e}") # No fallar todo el proceso por este error # Procesar documentos digitalizados (e-documents) edocuments_result = [] edocuments_error = None # agregando edocuments try: identificadores_ed = xml_content.get('identificadores_ed', []) if identificadores_ed: logger.info(f"Procesando {len(identificadores_ed)} documentos digitalizados...") edocuments_result = await _post_edocuments( response_service=service_data, identificadores_ed=identificadores_ed ) logger.info(f"Se procesaron exitosamente {len(edocuments_result)} documentos digitalizados") else: logger.info("No se encontraron documentos digitalizados (identificadores ED)") except Exception as e: logger.error(f"Error al procesar documentos digitalizados: {e}") edocuments_error = str(e) # No fallar todo el proceso por este error # Agregando coves try: coves = xml_content.get('coves', []) logger.warning(f"COVEs encontrados: {coves}") # Aquí podrías guardar el COVE en la base de datos o hacer algo con él for cove in coves: logger.warning(f"Procesando COVE: {cove}") # Aquí podrías guardar el COVE en la base de datos o hacer algo con él # Por ejemplo, podrías crear un servicio específico para manejar los coves cove_result = await _post_coves( response_service=service_data, coves=coves ) except Exception as e: logger.error(f"Error al procesar COVEs: {e}") # No fallar todo el proceso por este error cove_result = None # Finalizar servicio exitosamente await _update_service_status(service_data['id'], ESTADO_FINALIZADO, service_data, operation_name) # Crear respuesta estandarizada response_data = await _create_response( service_data=service_data, additional_data={ "remesas": soap_response, "documento": soap_response.get('documento', {}) }, success_message="Documento completo procesado exitosamente" ) logger.info(f"Documento completo procesado exitosamente- Servicio: {service_data['id']}") return JSONResponse(content=response_data, status_code=200) except HTTPException: # Re-lanzar HTTPExceptions sin modificar raise except Exception as e: logger.error(f"Error inesperado en {operation_name}: {e}") logger.error(f"Traceback: {traceback.format_exc()}") # Actualizar estado a error si tenemos service_data if service_data: try: await _update_service_status(service_data['id'], ESTADO_ERROR, service_data, operation_name) except Exception as update_error: logger.error(f"Error al actualizar estado del servicio tras fallo: {update_error}") raise HTTPException(status_code=500, detail=f"Error interno en {operation_name}: {str(e)}") @router.post("/services/partidas") async def get_partidas(request: ServiceRemesaSchema): """ Obtiene todas las partidas de un pedimento mediante peticiones SOAP a VUCEM. Este endpoint: 1. Obtiene el servicio de partidas existente 2. Actualiza estado a "en proceso" 3. Obtiene credenciales VUCEM 4. Procesa cada partida individualmente 5. Guarda documentos XML de cada partida Args: request: ServiceRemesaSchema con pedimento y organización Returns: JSONResponse con lista de partidas procesadas Raises: HTTPException: En caso de errores de validación o procesamiento """ operation_name = "partidas" service_data = None try: # Validar datos de entrada request_data = request.model_dump() await _validate_request_data(request_data) logger.info(f"Iniciando procesamiento de partidas - Pedimento: {request_data['pedimento']}") # Obtener servicio de partidas existente service_data = await _get_pedimento_service( pedimento_id=request_data['pedimento'], service_type=4, operation_name=operation_name ) # Actualizar estado a "En proceso" update_success = await _update_service_status( service_data['id'], ESTADO_EN_PROCESO, service_data, operation_name ) if not update_success: raise HTTPException(status_code=500, detail="Error al actualizar estado del servicio") # Obtener credenciales VUCEM contribuyente_id = service_data.get('pedimento', {}).get('contribuyente', '') if not contribuyente_id: logger.error("No se encontró ID de contribuyente en los datos del servicio") await _update_service_status(service_data['id'], ESTADO_ERROR, service_data, operation_name) raise HTTPException(status_code=400, detail="ID de contribuyente no encontrado") credentials = await _get_vucem_credentials(contribuyente_id, operation_name) # Procesar partidas partidas_procesadas = [] numero_partidas = service_data['pedimento'].get('numero_partidas', 0) logger.info(f"Procesando {numero_partidas} partidas...") if numero_partidas <= 0: logger.warning("El pedimento no tiene partidas para procesar") await _update_service_status(service_data['id'], ESTADO_ERROR, service_data, operation_name) raise HTTPException(status_code=404, detail="No se encontraron partidas para el pedimento") # Procesar cada partida individualmente for partida_num in range(1, numero_partidas + 1): try: logger.info(f"Procesando partida {partida_num}/{numero_partidas}") # Aqui obtiene el xml soap_response = await get_soap_partidas( credenciales=credentials, response_service=service_data, soap_controller=soap_controller, partida=str(partida_num) ) if soap_response: partidas_procesadas.append({ "numero": partida_num, "procesada": True, "documento": soap_response.get('documento', {}) }) logger.info(f"Partida {partida_num} procesada exitosamente") else: logger.warning(f"No se pudo procesar la partida {partida_num}") partidas_procesadas.append({ "numero": partida_num, "procesada": False, "error": "Error en petición SOAP" }) except Exception as e: logger.error(f"Error al procesar partida {partida_num}: {e}") partidas_procesadas.append({ "numero": partida_num, "procesada": False, "error": str(e) }) # Continuar con las siguientes partidas continue # Verificar si se procesó al menos una partida partidas_exitosas = [p for p in partidas_procesadas if p.get('procesada', False)] if not partidas_exitosas: logger.error("No se pudo procesar ninguna partida") await _update_service_status(service_data['id'], ESTADO_ERROR, service_data, operation_name) raise HTTPException(status_code=500, detail="No se pudo procesar ninguna partida") # Finalizar servicio exitosamente await _update_service_status(service_data['id'], ESTADO_FINALIZADO, service_data, operation_name) # Crear respuesta estandarizada response_data = await _create_response( service_data=service_data, additional_data={ "partidas": partidas_procesadas, "total_partidas": numero_partidas, "partidas_exitosas": len(partidas_exitosas), "partidas_fallidas": len(partidas_procesadas) - len(partidas_exitosas) }, success_message=f"Se procesaron {len(partidas_exitosas)}/{numero_partidas} partidas exitosamente" ) # Agregar advertencias si hubo partidas fallidas if len(partidas_exitosas) < numero_partidas: response_data["warnings"] = [ f"Se procesaron solo {len(partidas_exitosas)} de {numero_partidas} partidas" ] logger.info(f"Procesamiento de partidas completado - Exitosas: {len(partidas_exitosas)}/{numero_partidas}") return JSONResponse(content=response_data, status_code=200) except HTTPException: # Re-lanzar HTTPExceptions sin modificar raise except Exception as e: logger.error(f"Error inesperado en {operation_name}: {e}") logger.error(f"Traceback: {traceback.format_exc()}") # Actualizar estado a error si tenemos service_data if service_data: try: await _update_service_status(service_data['id'], ESTADO_ERROR, service_data, operation_name) except Exception as update_error: logger.error(f"Error al actualizar estado del servicio tras fallo: {update_error}") raise HTTPException(status_code=500, detail=f"Error interno en {operation_name}: {str(e)}") @router.post("/services/remesas") async def get_remesas(request: ServiceRemesaSchema): """ Obtiene las remesas de un pedimento mediante petición SOAP a VUCEM. Este endpoint: 1. Obtiene el servicio de remesas existente 2. Actualiza estado a "en proceso" 3. Obtiene credenciales VUCEM 4. Realiza petición SOAP para remesas 5. Guarda documento XML de remesas Args: request: ServiceRemesaSchema con pedimento y organización Returns: JSONResponse con datos de remesas procesadas Raises: HTTPException: En caso de errores de validación o procesamiento """ operation_name = "remesas" service_data = None try: # Validar datos de entrada request_data = request.model_dump() await _validate_request_data(request_data) logger.info(f"Iniciando procesamiento de remesas - Pedimento: {request_data['pedimento']}") # Obtener servicio de remesas existente service_data = await _get_pedimento_service( pedimento_id=request_data['pedimento'], service_type=5, operation_name=operation_name ) # Actualizar estado a "En proceso" update_success = await _update_service_status( service_data['id'], ESTADO_EN_PROCESO, service_data, operation_name ) if not update_success: raise HTTPException(status_code=500, detail="Error al actualizar estado del servicio") # Obtener credenciales VUCEM contribuyente_id = service_data.get('pedimento', {}).get('contribuyente', '') if not contribuyente_id: logger.error("No se encontró ID de contribuyente en los datos del servicio") await _update_service_status(service_data['id'], ESTADO_ERROR, service_data, operation_name) raise HTTPException(status_code=400, detail="ID de contribuyente no encontrado") credentials = await _get_vucem_credentials(contribuyente_id, operation_name) # Procesar petición SOAP para remesas logger.info("Realizando petición SOAP para remesas...") try: soap_response = await get_soap_remesas( credenciales=credentials, response_service=service_data, soap_controller=soap_controller ) if not soap_response: raise HTTPException(status_code=500, detail="Error en la petición SOAP para remesas") logger.info("Petición SOAP para remesas completada exitosamente") except HTTPException: await _update_service_status(service_data['id'], ESTADO_ERROR, service_data, operation_name) raise except Exception as e: logger.error(f"Error en petición SOAP para remesas: {e}") await _update_service_status(service_data['id'], ESTADO_ERROR, service_data, operation_name) raise HTTPException(status_code=500, detail="Error en la petición SOAP al servicio VUCEM") # Finalizar servicio exitosamente await _update_service_status(service_data['id'], ESTADO_FINALIZADO, service_data, operation_name) # Crear respuesta estandarizada response_data = await _create_response( service_data=service_data, additional_data={ "remesas": soap_response, "documento": soap_response.get('documento', {}) }, success_message="Remesas procesadas exitosamente" ) logger.info(f"Procesamiento de remesas completado exitosamente - Servicio: {service_data['id']}") return JSONResponse(content=response_data, status_code=200) except HTTPException: # Re-lanzar HTTPExceptions sin modificar raise except Exception as e: logger.error(f"Error inesperado en {operation_name}: {e}") logger.error(f"Traceback: {traceback.format_exc()}") # Actualizar estado a error si tenemos service_data if service_data: try: await _update_service_status(service_data['id'], ESTADO_ERROR, service_data, operation_name) except Exception as update_error: logger.error(f"Error al actualizar estado del servicio tras fallo: {update_error}") raise HTTPException(status_code=500, detail=f"Error interno en {operation_name}: {str(e)}") @router.post("/services/acuse") async def get_acuse(request: ServiceRemesaSchema): """ Obtiene los acuses de documentos digitalizados de un pedimento mediante peticiones SOAP a VUCEM. Este endpoint: 1. Obtiene el servicio de acuse existente 2. Actualiza estado a "en proceso" 3. Obtiene credenciales VUCEM 4. Obtiene lista de documentos digitalizados (e-documents) 5. Procesa cada documento para obtener su acuse en PDF 6. Guarda cada PDF procesado Args: request: ServiceRemesaSchema con pedimento y organización Returns: JSONResponse con lista de documentos digitalizados procesados Raises: HTTPException: En caso de errores de validación o procesamiento """ operation_name = "acuse" service_data = None try: # Validar datos de entrada request_data = request.model_dump() await _validate_request_data(request_data) logger.info(f"Iniciando procesamiento de acuses - Pedimento: {request_data['pedimento']}") # Obtener servicio de acuse existente service_data = await _get_pedimento_service( pedimento_id=request_data['pedimento'], service_type=6, operation_name=operation_name ) # Actualizar estado a "En proceso" update_success = await _update_service_status( service_data['id'], ESTADO_EN_PROCESO, service_data, operation_name ) if not update_success: raise HTTPException(status_code=500, detail="Error al actualizar estado del servicio") # Obtener credenciales VUCEM contribuyente_id = service_data.get('pedimento', {}).get('contribuyente', '') if not contribuyente_id: logger.error("No se encontró ID de contribuyente en los datos del servicio") await _update_service_status(service_data['id'], ESTADO_ERROR, service_data, operation_name) raise HTTPException(status_code=400, detail="ID de contribuyente no encontrado") credentials = await _get_vucem_credentials(contribuyente_id, operation_name) # Obtener documentos digitalizados (e-documents) logger.info("Obteniendo documentos digitalizados...") try: edocs = await rest_controller.get_edocs(service_data['pedimento']['id']) if not edocs: logger.warning("No se encontraron documentos digitalizados para el pedimento") await _update_service_status(service_data['id'], ESTADO_ERROR, service_data, operation_name) raise HTTPException(status_code=404, detail="No se encontraron documentos digitalizados para el pedimento") logger.info(f"Se encontraron {len(edocs)} documentos digitalizados") except HTTPException: raise except Exception as e: logger.error(f"Error al obtener documentos digitalizados: {e}") await _update_service_status(service_data['id'], ESTADO_ERROR, service_data, operation_name) raise HTTPException(status_code=500, detail="Error al obtener documentos digitalizados") # Procesar acuses de documentos digitalizados documentos_procesados = [] documentos_exitosos = 0 logger.info(f"Procesando acuses para {len(edocs)} documentos...") for idx, edoc in enumerate(edocs): documento_info = { "clave": edoc.get('clave', 'N/A'), "descripcion": edoc.get('descripcion', 'N/A'), "numero_edocument": edoc.get('numero_edocument', 'N/A'), "procesado": False, "error": None } # Verificar que el documento tenga número de e-document if not edoc.get('numero_edocument'): logger.warning(f"Documento {idx + 1} no tiene numero_edocument, saltando...") documento_info["error"] = "Sin número de e-document" documentos_procesados.append(documento_info) continue try: logger.info(f"Procesando acuse para documento {idx + 1}: {edoc['numero_edocument']}") soap_response = await get_soap_acuse( credenciales=credentials, response_service=service_data, soap_controller=soap_controller, edocument=edoc, idx=idx + 1 ) if soap_response: documento_info["procesado"] = True documento_info["documento"] = soap_response.get('documento', {}) documentos_exitosos += 1 logger.info(f"Acuse del documento {idx + 1} procesado exitosamente") else: documento_info["error"] = "Error en petición SOAP" logger.warning(f"No se pudo procesar el acuse del documento {idx + 1}") except Exception as e: logger.error(f"Error al procesar acuse del documento {idx + 1}: {e}") documento_info["error"] = str(e) # Continuar con los siguientes documentos documentos_procesados.append(documento_info) # Verificar si se procesó al menos un documento if documentos_exitosos == 0: logger.error("No se pudo procesar ningún acuse de documento digitalizado") await _update_service_status(service_data['id'], ESTADO_ERROR, service_data, operation_name) raise HTTPException(status_code=500, detail="No se pudo procesar ningún acuse de documento digitalizado") # Finalizar servicio exitosamente await _update_service_status(service_data['id'], ESTADO_FINALIZADO, service_data, operation_name) # Crear respuesta estandarizada response_data = await _create_response( service_data=service_data, additional_data={ "edocumentos": documentos_procesados, "total_documentos": len(edocs), "documentos_exitosos": documentos_exitosos, "documentos_fallidos": len(edocs) - documentos_exitosos }, success_message=f"Se procesaron {documentos_exitosos}/{len(edocs)} acuses de documentos exitosamente" ) # Agregar advertencias si hubo documentos fallidos if documentos_exitosos < len(edocs): response_data["warnings"] = [ f"Se procesaron solo {documentos_exitosos} de {len(edocs)} documentos digitalizados" ] logger.info(f"Procesamiento de acuses completado - Exitosos: {documentos_exitosos}/{len(edocs)}") return JSONResponse(content=response_data, status_code=200) except HTTPException: # Re-lanzar HTTPExceptions sin modificar raise except Exception as e: logger.error(f"Error inesperado en {operation_name}: {e}") logger.error(f"Traceback: {traceback.format_exc()}") # Actualizar estado a error si tenemos service_data if service_data: try: await _update_service_status(service_data['id'], ESTADO_ERROR, service_data, operation_name) except Exception as update_error: logger.error(f"Error al actualizar estado del servicio tras fallo: {update_error}") raise HTTPException(status_code=500, detail=f"Error interno en {operation_name}: {str(e)}") @router.post("/services/edocument") async def get_edocument(request: ServiceRemesaSchema): """ Obtiene y procesa todos los documentos digitalizados (e-documents) de un pedimento. Este endpoint: 1. Obtiene el servicio de documentos digitalizados existente 2. Actualiza estado a "en proceso" 3. Obtiene credenciales VUCEM 4. Obtiene lista de documentos digitalizados 5. Procesa cada documento para obtener su edocument 6. Retorna lista de documentos procesados Args: request: PedimentoRequest con pedimento y organización Returns: JSONResponse con lista de documentos digitalizados procesados Raises: HTTPException: En caso de errores de validación o procesamiento """ operation_name = "edocument" service_data = None try: # Validar datos de entrada request_data = request.model_dump() await _validate_request_data(request_data) logger.info(f"Iniciando procesamiento de e-documents - Pedimento: {request_data['pedimento']}") # Obtener servicio de documentos digitalizados existente service_data = await _get_pedimento_service( pedimento_id=request_data['pedimento'], service_type=7, operation_name=operation_name ) # Actualizar estado a "En proceso" update_success = await _update_service_status( service_data['id'], ESTADO_EN_PROCESO, service_data, operation_name ) if not update_success: raise HTTPException(status_code=500, detail="Error al actualizar estado del servicio") # Obtener credenciales VUCEM contribuyente_id = service_data.get('pedimento', {}).get('contribuyente', '') if not contribuyente_id: logger.error("No se encontró ID de contribuyente en los datos del servicio") await _update_service_status(service_data['id'], ESTADO_ERROR, service_data, operation_name) raise HTTPException(status_code=400, detail="ID de contribuyente no encontrado") credentials = await _get_vucem_credentials(contribuyente_id, operation_name) # Obtener documentos digitalizados logger.info("Obteniendo documentos digitalizados...") try: edocs = await rest_controller.get_edocs(service_data['pedimento']['id']) if not edocs: logger.warning("No se encontraron documentos digitalizados para el pedimento") await _update_service_status(service_data['id'], ESTADO_ERROR, service_data, operation_name) raise HTTPException(status_code=404, detail="No se encontraron documentos digitalizados para el pedimento") logger.info(f"Se encontraron {len(edocs)} documentos digitalizados") except HTTPException: raise except Exception as e: logger.error(f"Error al obtener documentos digitalizados: {e}") await _update_service_status(service_data['id'], ESTADO_ERROR, service_data, operation_name) raise HTTPException(status_code=500, detail="Error al obtener documentos digitalizados") # Procesar documentos digitalizados documentos_procesados = [] documentos_exitosos = 0 logger.info(f"Procesando {len(edocs)} documentos digitalizados...") for idx, edoc in enumerate(edocs): documento_info = { "clave": edoc.get('clave', 'N/A'), "descripcion": edoc.get('descripcion', 'N/A'), "numero_edocument": edoc.get('numero_edocument', 'N/A'), "procesado": False, "error": None } # Verificar que el documento tenga número de e-document if not edoc.get('numero_edocument'): logger.warning(f"Documento {idx + 1} no tiene numero_edocument, saltando...") documento_info["error"] = "Sin número de e-document" documentos_procesados.append(documento_info) continue try: logger.info(f"Procesando e-document {idx + 1}: {edoc['numero_edocument']}") # Procesar acuse del documento soap_response = await get_soap_edocument( credenciales=credentials, response_service=service_data, soap_controller=soap_controller, edocument=edoc, idx=idx + 1 ) if soap_response: documento_info["procesado"] = True documento_info["documento"] = soap_response.get('documento', {}) documentos_exitosos += 1 logger.info(f"E-document {idx + 1} procesado exitosamente") else: documento_info["error"] = "Error en petición SOAP" logger.warning(f"No se pudo procesar el e-document {idx + 1}") except Exception as e: logger.error(f"Error al procesar e-document {idx + 1}: {e}") documento_info["error"] = str(e) # Continuar con los siguientes documentos documentos_procesados.append(documento_info) # Verificar si se procesó al menos un documento if documentos_exitosos == 0: logger.error("No se pudo procesar ningún documento digitalizado") await _update_service_status(service_data['id'], ESTADO_ERROR, service_data, operation_name) raise HTTPException(status_code=500, detail="No se pudo procesar ningún documento digitalizado") # Finalizar servicio exitosamente await _update_service_status(service_data['id'], ESTADO_FINALIZADO, service_data, operation_name) # Crear respuesta estandarizada response_data = await _create_response( service_data=service_data, additional_data={ "edocumentos": documentos_procesados, "total_documentos": len(edocs), "documentos_exitosos": documentos_exitosos, "documentos_fallidos": len(edocs) - documentos_exitosos }, success_message=f"Se procesaron {documentos_exitosos}/{len(edocs)} documentos digitalizados exitosamente" ) # Agregar advertencias si hubo documentos fallidos if documentos_exitosos < len(edocs): response_data["warnings"] = [ f"Se procesaron solo {documentos_exitosos} de {len(edocs)} documentos digitalizados" ] logger.info(f"Procesamiento de e-documents completado - Exitosos: {documentos_exitosos}/{len(edocs)}") return JSONResponse(content=response_data, status_code=200) except HTTPException: # Re-lanzar HTTPExceptions sin modificar raise except Exception as e: logger.error(f"Error inesperado en {operation_name}: {e}") logger.error(f"Traceback: {traceback.format_exc()}") # Actualizar estado a error si tenemos service_data if service_data: try: await _update_service_status(service_data['id'], ESTADO_ERROR, service_data, operation_name) except Exception as update_error: logger.error(f"Error al actualizar estado del servicio tras fallo: {update_error}") raise HTTPException(status_code=500, detail=f"Error interno en {operation_name}: {str(e)}") @router.post("/services/coves") async def get_cove(request: ServiceRemesaSchema): """ Obtiene las COVES de un pedimento mediante petición SOAP a VUCEM. Este endpoint: 1. Obtiene el servicio de COVES existente 2. Actualiza estado a "en proceso" 3. Obtiene credenciales VUCEM 4. Realiza petición SOAP para COVES 5. Guarda documento XML de COVES Args: request: ServiceRemesaSchema con pedimento y organización Returns: JSONResponse con datos de COVES procesadas Raises: HTTPException: En caso de errores de validación o procesamiento """ operation_name = "COVES" service_data = None try: # Validar datos de entrada request_data = request.model_dump() await _validate_request_data(request_data) logger.info(f"Iniciando procesamiento de COVES - Pedimento: {request_data['pedimento']}") # Obtener servicio de remesas existente service_data = await _get_pedimento_service( pedimento_id=request_data['pedimento'], service_type=8, operation_name=operation_name ) # Actualizar estado a "En proceso" update_success = await _update_service_status( service_data['id'], ESTADO_EN_PROCESO, service_data, operation_name ) if not update_success: raise HTTPException(status_code=500, detail="Error al actualizar estado del servicio") # Obtener credenciales VUCEM contribuyente_id = service_data.get('pedimento', {}).get('contribuyente', '') if not contribuyente_id: logger.error("No se encontró ID de contribuyente en los datos del servicio") await _update_service_status(service_data['id'], ESTADO_ERROR, service_data, operation_name) raise HTTPException(status_code=400, detail="ID de contribuyente no encontrado") credentials = await _get_vucem_credentials(contribuyente_id, operation_name) # Obtener COVES logger.info("Obteniendo COVES...") try: coves = await rest_controller.get_coves(service_data['pedimento']['id']) if not coves: logger.warning("No se encontraron COVES para el pedimento") await _update_service_status(service_data['id'], ESTADO_ERROR, service_data, operation_name) raise HTTPException(status_code=404, detail="No se encontraron COVES para el pedimento") logger.info(f"Se encontraron {len(coves)} COVES") except HTTPException: raise except Exception as e: logger.error(f"Error al obtener COVES: {e}") await _update_service_status(service_data['id'], ESTADO_ERROR, service_data, operation_name) raise HTTPException(status_code=500, detail="Error al obtener COVES") # Procesar acuses de documentos digitalizados documentos_procesados = [] documentos_exitosos = 0 logger.info(f"Procesando COVE para {len(coves)} documentos...") for idx, cove in enumerate(coves): documento_info = { #"clave": cove.get('clave', 'N/A'), #"descripcion": cove.get('descripcion', 'N/A'), "numero_cove": cove.get('numero_cove', 'N/A'), "procesado": False, "error": None } # Verificar que el documento tenga número de cove if not cove.get('numero_cove'): logger.warning(f"Documento {idx + 1} no tiene numero_cove, saltando...") documento_info["error"] = "Sin número de cove" documentos_procesados.append(documento_info) continue try: logger.info(f"Procesando cove para documento {idx + 1}: {cove['numero_cove']}") # Procesar cove del documento soap_response = await get_soap_cove( credenciales=credentials, response_service=service_data, soap_controller=soap_controller, cove=cove, idx=idx + 1 ) if soap_response: documento_info["procesado"] = True documento_info["documento"] = soap_response.get('documento', {}) documentos_exitosos += 1 logger.info(f"cove del documento {idx + 1} procesado exitosamente") else: documento_info["error"] = "Error en petición SOAP" logger.warning(f"No se pudo procesar el cove del documento {idx + 1}") except Exception as e: logger.error(f"Error al procesar cove del documento {idx + 1}: {e}") documento_info["error"] = str(e) # Continuar con los siguientes documentos documentos_procesados.append(documento_info) # Verificar si se procesó al menos un documento if documentos_exitosos == 0: logger.error("No se pudo procesar ningún cove de documento digitalizado") await _update_service_status(service_data['id'], ESTADO_ERROR, service_data, operation_name) raise HTTPException(status_code=500, detail="No se pudo procesar ningún acuse cove de documento digitalizado") # Finalizar servicio exitosamente await _update_service_status(service_data['id'], ESTADO_FINALIZADO, service_data, operation_name) # Crear respuesta estandarizada response_data = await _create_response( service_data=service_data, additional_data={ "covesDocs": documentos_procesados, "total_documentos": len(coves), "documentos_exitosos": documentos_exitosos, "documentos_fallidos": len(coves) - documentos_exitosos }, success_message=f"Se procesaron {documentos_exitosos}/{len(coves)} cove de documentos exitosamente" ) # Agregar advertencias si hubo documentos fallidos if documentos_exitosos < len(coves): response_data["warnings"] = [ f"Se procesaron solo {documentos_exitosos} de {len(coves)} coves" ] logger.info(f"Procesamiento de acuses cove completado - Exitosos: {documentos_exitosos}/{len(coves)}") return JSONResponse(content=response_data, status_code=200) except HTTPException: # Re-lanzar HTTPExceptions sin modificar raise except Exception as e: logger.error(f"Error inesperado en {operation_name}: {e}") logger.error(f"Traceback: {traceback.format_exc()}") # Actualizar estado a error si tenemos service_data if service_data: try: await _update_service_status(service_data['id'], ESTADO_ERROR, service_data, operation_name) except Exception as update_error: logger.error(f"Error al actualizar estado del servicio tras fallo: {update_error}") raise HTTPException(status_code=500, detail=f"Error interno en {operation_name}: {str(e)}") @router.post("/services/acuseCove") async def get_Acusecove(request: ServiceRemesaSchema): """ Obtiene los acuses de COVE de un pedimento mediante peticiones SOAP a VUCEM. Este endpoint: 1. Obtiene el servicio de acuse existente 2. Actualiza estado a "en proceso" 3. Obtiene credenciales VUCEM 4. Obtiene lista de COVE 5. Procesa cada documento para obtener su acuse en PDF 6. Guarda cada PDF procesado Args: request: ServiceRemesaSchema con pedimento y organización Returns: JSONResponse con lista de COVE procesados Raises: HTTPException: En caso de errores de validación o procesamiento """ operation_name = "ACUSE_COVES" service_data = None try: # Validar datos de entrada request_data = request.model_dump() await _validate_request_data(request_data) logger.info(f"Iniciando procesamiento de acuse COVES - Pedimento: {request_data['pedimento']}") # Obtener servicio de remesas existente service_data = await _get_pedimento_service( pedimento_id=request_data['pedimento'], service_type=9, operation_name=operation_name ) # Actualizar estado a "En proceso" update_success = await _update_service_status( service_data['id'], ESTADO_EN_PROCESO, service_data, operation_name ) if not update_success: raise HTTPException(status_code=500, detail="Error al actualizar estado del servicio") # Obtener credenciales VUCEM contribuyente_id = service_data.get('pedimento', {}).get('contribuyente', '') if not contribuyente_id: logger.error("No se encontró ID de contribuyente en los datos del servicio") await _update_service_status(service_data['id'], ESTADO_ERROR, service_data, operation_name) raise HTTPException(status_code=400, detail="ID de contribuyente no encontrado") credentials = await _get_vucem_credentials(contribuyente_id, operation_name) # Obtener COVES logger.info("Obteniendo COVES...") try: coves = await rest_controller.get_coves(service_data['pedimento']['id']) if not coves: logger.warning("No se encontraron COVES para el pedimento") await _update_service_status(service_data['id'], ESTADO_ERROR, service_data, operation_name) raise HTTPException(status_code=404, detail="No se encontraron COVES para el pedimento") logger.info(f"Se encontraron {len(coves)} COVES") except HTTPException: raise except Exception as e: logger.error(f"Error al obtener COVES: {e}") await _update_service_status(service_data['id'], ESTADO_ERROR, service_data, operation_name) raise HTTPException(status_code=500, detail="Error al obtener COVES") # Procesar acuses de documentos digitalizados documentos_procesados = [] documentos_exitosos = 0 logger.info(f"Procesando acuses COVE para {len(coves)} documentos...") for idx, cove in enumerate(coves): documento_info = { #"clave": cove.get('clave', 'N/A'), #"descripcion": cove.get('descripcion', 'N/A'), "numero_cove": cove.get('numero_cove', 'N/A'), "procesado": False, "error": None } # Verificar que el documento tenga número de cove if not cove.get('numero_cove'): logger.warning(f"Documento {idx + 1} no tiene numero_cove, saltando...") documento_info["error"] = "Sin número de cove" documentos_procesados.append(documento_info) continue try: logger.info(f"Procesando acuse para documento {idx + 1}: {cove['numero_cove']}") soap_response = await get_soap_acuseCOVE( credenciales=credentials, response_service=service_data, soap_controller=soap_controller, cove=cove, idx=idx + 1 ) if soap_response: documento_info["procesado"] = True documento_info["documento"] = soap_response.get('documento', {}) documentos_exitosos += 1 logger.info(f"Acuse cove del documento {idx + 1} procesado exitosamente") else: documento_info["error"] = "Error en petición SOAP" logger.warning(f"No se pudo procesar el acuse cove del documento {idx + 1}") except Exception as e: logger.error(f"Error al procesar acuse cove del documento {idx + 1}: {e}") documento_info["error"] = str(e) # Continuar con los siguientes documentos documentos_procesados.append(documento_info) # Verificar si se procesó al menos un documento if documentos_exitosos == 0: logger.error("No se pudo procesar ningún acuse cove de documento digitalizado") await _update_service_status(service_data['id'], ESTADO_ERROR, service_data, operation_name) raise HTTPException(status_code=500, detail="No se pudo procesar ningún acuse cove de documento digitalizado") # Finalizar servicio exitosamente await _update_service_status(service_data['id'], ESTADO_FINALIZADO, service_data, operation_name) # Crear respuesta estandarizada response_data = await _create_response( service_data=service_data, additional_data={ "covesDocs": documentos_procesados, "total_documentos": len(coves), "documentos_exitosos": documentos_exitosos, "documentos_fallidos": len(coves) - documentos_exitosos }, success_message=f"Se procesaron {documentos_exitosos}/{len(coves)} acuses cove de documentos exitosamente" ) # Agregar advertencias si hubo documentos fallidos if documentos_exitosos < len(coves): response_data["warnings"] = [ f"Se procesaron solo {documentos_exitosos} de {len(coves)} coves" ] logger.info(f"Procesamiento de acuses cove completado - Exitosos: {documentos_exitosos}/{len(coves)}") return JSONResponse(content=response_data, status_code=200) except HTTPException: # Re-lanzar HTTPExceptions sin modificar raise except Exception as e: logger.error(f"Error inesperado en {operation_name}: {e}") logger.error(f"Traceback: {traceback.format_exc()}") # Actualizar estado a error si tenemos service_data if service_data: try: await _update_service_status(service_data['id'], ESTADO_ERROR, service_data, operation_name) except Exception as update_error: logger.error(f"Error al actualizar estado del servicio tras fallo: {update_error}") raise HTTPException(status_code=500, detail=f"Error interno en {operation_name}: {str(e)}")