se estan creando el registro de las tareas sin problemas

api/api_v2/modules/coves/services.py

@@ -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: