Se ajusta validacion de existencia de pedimento asi como el registro correcto de la aduana, patente y pedimento

Reviewed-on: #17

api/customs/apps.py

@@ -6,4 +6,5 @@ class CustomsConfig(AppConfig):
     name = 'api.customs'
 
     def ready(self):
-        import api.customs.signals
+        # corregir el import aqui
+        import api.customs.signals.procesamiento

api/customs/management/commands/microservicios.py

@@ -36,7 +36,8 @@ class Command(BaseCommand):
         
         if organizacion_id:
             if procesamiento:
-                microservice_v2.ejecutar_procesamiento_por_organizacion(organizacion_id, procesamiento)
+                # microservice_v2.ejecutar_procesamiento_por_organizacion(organizacion_id, procesamiento)
+                microservice_v2.ejecutar_por_organizacion_y_procesamiento(organizacion_id, procesamiento)
                 self.stdout.write(self.style.SUCCESS(f'Se ejecutó el procesamiento {procesamiento} para la organización {organizacion_id}.'))
             else:
                 microservice_v2.ejecutar_todos_por_organizacion(organizacion_id)

api/customs/models.py

@@ -61,7 +61,7 @@ class Pedimento(models.Model):
         db_table = 'pedimento'
         ordering = ['pedimento']
         unique_together = [
-            ['organizacion', 'pedimento'],
+           # ['organizacion', 'pedimento'],
             ['organizacion', 'pedimento_app']
         ]
 

api/customs/signals/procesamiento.py

@@ -3,7 +3,7 @@ from django.dispatch import receiver
 from django.db import transaction
 from time import sleep
 
-from api.customs.models import Pedimento, ProcesamientoPedimento, Cove, EDocument
+from api.customs.models import EstadoDeProcesamiento, Pedimento, ProcesamientoPedimento, Cove, EDocument
 from api.customs.tasks.internal_services import (
     crear_procesamiento_remesa, 
     crear_procesamiento_partida, 
@@ -20,8 +20,49 @@ from api.customs.tasks.microservice import (
 
 @receiver(post_save, sender=Pedimento)
 def trigger_celery_task_on_create(sender, instance, created, **kwargs):
-    if created:
+ 
+    if not created:
+        import logging
+        logger = logging.getLogger('api.customs.async_operations')
+        logger.info("NO es creación de pedimento, no se crea procesamiento.")
+        return
+ 
+    def crear_procesamiento():
+        import logging
+        logger = logging.getLogger('api.customs.async_operations')
+        logger.info(f"Pedimento confirmado en BD: {instance.id}, creando procesamiento...")
+ 
+        try:
+            estado, _ = EstadoDeProcesamiento.objects.get_or_create(
+                    estado='En Espera'
+                    )
+        except Exception:
+            estado = EstadoDeProcesamiento.objects.first()
+ 
+        try:
+            ProcesamientoPedimento.objects.get_or_create(
+                pedimento=instance,
+                organizacion=instance.organizacion,
+                defaults={
+                    'estado': estado,
+                    'servicio_id': 3,
+                    'tipo_procesamiento_id': 2,
+                }
+            )
+        except Exception as e:
+            logger.exception(
+                f"No se pudo crear ProcesamientoPedimento "
+                f"para pedimento {instance.id}: {e}"
+            )
+ 
+        # Disparar la tarea asíncrona existente
+        try:
             procesar_pedimento_completo_individual.apply_async(args=[instance.id, instance.organizacion.id])
+        except Exception as e:
+            logger.exception(f"Error al encolar procesar_pedimento_completo_individual: {e}")
+ 
+    transaction.on_commit(crear_procesamiento)
+
 
 @receiver(post_save, sender=Pedimento)
 def trigger_celery_task_on_update(sender, instance, created,**kwargs):

api/customs/tasks/microservice.py

@@ -11,6 +11,9 @@ from datetime import datetime
 # ===================
 @shared_task
 def procesar_pedimento_completo_individual(pedimento_id, organizacion_id):
+    import logging
+    logger = logging.getLogger('api.customs.async_operations')
+    logger.info(f"Pedimento a monitorear: {pedimento_id}, org:: {organizacion_id}, verificando servicios a crear...")
     response = requests.post(
         f"{SERVICE_API_URL}/async/services/pedimento_completo",
         json={"pedimento": str(pedimento_id), "organizacion": str(organizacion_id)}

api/customs/tasks/microservice_v2.py

@@ -222,14 +222,15 @@ def procesar_pedimentos_completos(organizacion_id):
             pedimento_dict = pedimento_to_dict(pedimento)
             credenciales = Vucem.objects.filter(id=CredencialesImportador.objects.filter(rfc=pedimento.contribuyente).first().vucem.id).first()
 
-            credenciales_dict = credenciales_to_dict(credenciales)
+            if not credenciales:
+                print(f"No se encontraron credenciales para el pedimento {pedimento.pedimento_app}")
+                continue
 
+            credenciales_dict = credenciales_to_dict(credenciales)
             payload = {
                 "pedimento": pedimento_dict,
                 "credencial": credenciales_dict
             }
-            
-            
             response = requests.post(
                 f"{SERVICE_API_URL_V2}/services/pedimento_completo", 
                 data=json.dumps(payload),
@@ -428,6 +429,34 @@ def documentos_con_errores(organizacion_id):
             # Aquí puedes agregar lógica adicional para manejar documentos con errores
             # como enviar notificaciones, registrar en un log, etc.
             
+@shared_task
+def procesar_procesamiento_pedimento(organizacion_id):
+    # print("Creando procesamientos de pedimentos para organización:", organizacion_id)
+
+    pedimentos = Pedimento.objects.filter(organizacion_id=organizacion_id)
+    # pedimentos = Pedimento.objects.filter(id='1c061182-ac68-45b0-b3d7-35bf2264982b')
+    if not pedimentos.exists():
+        print("No se encontraron pedimentos para la organización:", organizacion_id)
+        return
+    for pedimento in pedimentos:
+        if not pedimento.documents.filter(document_type=2).exists():  # Tipo 2: Pedimento Completo
+            
+            procesamiento_pedimento = ProcesamientoPedimento.objects.filter(
+                    pedimento_id=pedimento.id,
+                    servicio_id=3,  # servicio 3: Pedimento Completo
+                )
+            
+            if not procesamiento_pedimento.exists():
+                ProcesamientoPedimento.objects.create(
+                    pedimento_id=pedimento.id
+                    , organizacion_id=pedimento.organizacion_id
+                    , estado_id =1
+                    , servicio_id=3
+                    , tipo_procesamiento_id=2)  # servicio 3: Pedimento Completo
+                
+               # print("Procesamiento creado para pedimento:", pedimento.pedimento_app)
+        
+    procesar_pedimentos_completos.delay(organizacion_id)
 
 def ejecutar_por_organizacion_y_procesamiento(organizacion_id, procesamiento):
     if procesamiento == 'coves':
@@ -444,9 +473,11 @@ def ejecutar_por_organizacion_y_procesamiento(organizacion_id, procesamiento):
         procesar_pedimentos_completos.delay(organizacion_id)
     elif procesamiento == 'remesas':
         procesar_remesas.delay(organizacion_id)
-
+    elif procesamiento == 'procesamiento_pedimento':
+        procesar_procesamiento_pedimento.delay(organizacion_id)
     else:
         # Procesamiento no reconocido
+        # print(f"Procesamiento no reconocido: {procesamiento}")
         pass
 
 def ejecutar_todos_por_organizacion(organizacion_id):
@@ -459,3 +490,5 @@ def ejecutar_todos_por_organizacion(organizacion_id):
     procesar_remesas.delay(organizacion_id)
 
 
+
+

api/customs/urls.py

@@ -10,7 +10,8 @@ from .views import (
     ViewSetEDocument,
     ViewSetCove,
     ImportadorViewSet, 
-    PartidaViewSet
+    PartidaViewSet,
+    EjecutarComandoView
 )
 # from .views import YourViewSet  # Import your viewsets here
 
@@ -95,4 +96,7 @@ urlpatterns = [
     path('auditor/obtener-respuesta/acuse-cove-vu/', auditor_obtener_respuesta_acuse_cove_vu, name='obtener-respuesta-acuse-cove-vu'),
     path('auditor/obtener-peticion/edocument-vu/', auditor_obtener_peticion_edocument_vu, name='obtener-peticion-edocument-vu'),
     path('auditor/obtener-respuesta/edocument-vu/', auditor_obtener_respuesta_edocument_vu, name='obtener-respuesta-edocument-vu'),
+
+    path('procesamientopedimentos-ejecutar-comando/', EjecutarComandoView.as_view(), name='procesamientopedimentos-ejecutar-comando'),
+
 ]

api/customs/views.py

@@ -49,7 +49,9 @@ from django.core.files.base import ContentFile
 from django.db import transaction
 from rest_framework.parsers import MultiPartParser, FormParser
 from api.record.models import Document, DocumentType, Fuente
-
+from unicodedata import normalize 
+from datetime import datetime
+from django.utils import timezone
 # Importar rarfile de manera opcional
 try:
     import rarfile
@@ -511,7 +513,8 @@ class ViewSetPedimento(LoggingMixin, viewsets.ModelViewSet, OrganizacionFiltrada
             "processed_files": 3,
             "summary": "Procesados 3 archivo(s): 5 pedimento(s) creado(s), 15 documento(s) asociado(s)",
             "failed_files": [],
-            "errors": []
+            "errors": [],
+            "already_existing": []  # Nuevo campo para pedimentos que ya existían
         }
         """
         print(request.data)
@@ -545,6 +548,7 @@ class ViewSetPedimento(LoggingMixin, viewsets.ModelViewSet, OrganizacionFiltrada
         nomenclatura_pattern_sin_anio = re.compile(r'^(\d{2,3})-(\d{4})-(\d{7})$')
         
         created_pedimentos = []
+        already_existing_pedimentos = []  # Para trackear pedimentos que ya existen
         failed_files = []
         errors = []
         documents_created = 0
@@ -597,140 +601,41 @@ class ViewSetPedimento(LoggingMixin, viewsets.ModelViewSet, OrganizacionFiltrada
                     archivo_name = archivo.name.lower()
                     print(f"Procesando archivo {idx + 1}/{len(archivos)}: {archivo_name}")
                     
-                    # Crear subdirectorio para cada archivo usando el nombre del archivo sin extensión
+                    # Extraer nombre base sin extensión para validación
                     archivo_name_sin_extension = os.path.splitext(archivo.name)[0]
-                    sub_dir = os.path.join(temp_dir, archivo_name_sin_extension)
-                    os.makedirs(sub_dir, exist_ok=True)
-                    print(f"Subdirectorio creado: {sub_dir}")
                     
-                    if archivo_name.endswith('.zip'):
+                    # Validar nomenclatura del nombre del archivo/folder
-                        # Manejar archivo ZIP
+                    match = nomenclatura_pattern.match(archivo_name_sin_extension)
-                        print("Es un archivo ZIP")
+                    match_sin_anio = nomenclatura_pattern_sin_anio.match(archivo_name_sin_extension)
-                        try:
-                            with zipfile.ZipFile(archivo, 'r') as zip_ref:
-                                zip_ref.extractall(sub_dir)
-                            print("Archivo ZIP extraído exitosamente")
-                        except zipfile.BadZipFile as e:
-                            return Response(
-                                {"error": f"Archivo ZIP corrupto o inválido: {archivo.name} - {str(e)}"},
-                                status=status.HTTP_400_BAD_REQUEST
-                            )
-                        except Exception as e:
-                            return Response(
-                                {"error": f"Error al extraer ZIP {archivo.name}: {str(e)}"},
-                                status=status.HTTP_400_BAD_REQUEST
-                            )
-                    elif archivo_name.endswith('.rar'):
-                        # Manejar archivo RAR: guardar el archivo en disco y usar helper con fallbacks
-                        # Guardar el archivo subido en un path temporal dentro del sub_dir
-                        archivo_temp_path = os.path.join(sub_dir, archivo.name)
-                        with open(archivo_temp_path, 'wb') as f:
-                            for chunk in archivo.chunks():
-                                f.write(chunk)
-                        try:
-                            extract_rar_to_dir(archivo_temp_path, sub_dir)
-                            print(f"Archivo RAR {archivo.name} extraído en {sub_dir}")
-                        except Exception as e:
-                            error_msg = str(e)
-                            help_msg = "Instale 'unrar' o 'p7zip' (7z) y asegúrese de que estén en PATH, o instale y configure 'rarfile' con un backend."
-                            return Response(
-                                {"error": f"Error al extraer archivo RAR {archivo.name}: {error_msg}. {help_msg}"},
-                                status=status.HTTP_400_BAD_REQUEST
-                            )
-
-                        # if not RAR_SUPPORT:
-                        #     return Response(
-                        #         {"error": "Soporte para archivos RAR no disponible. Instalar rarfile: pip install rarfile"},
-                        #         status=status.HTTP_400_BAD_REQUEST
-                        #     )
-                        # try:
-                        #     with rarfile.RarFile(archivo, 'r') as rar_ref:
-                        #         rar_ref.extractall(sub_dir)
-                        #     print(f"Archivo RAR {archivo.name} extraído en sub_dir")
-                        # except rarfile.Error as e:
-                        #     return Response(
-                        #         {"error": f"Error al extraer archivo RAR {archivo.name}: {str(e)}"},
-                        #         status=status.HTTP_400_BAD_REQUEST
-                        #     )
-
-                    else:
-                        # Asumir que es un archivo individual
-                        # Crear el archivo en el subdirectorio
-                        archivo_path = os.path.join(sub_dir, archivo.name)
-                        with open(archivo_path, 'wb') as f:
-                            for chunk in archivo.chunks():
-                                f.write(chunk)
-                        print(f"Archivo individual {archivo.name} guardado en sub_dir:", archivo_path)
-                
-                # Recorrer todos los archivos extraídos o el directorio
-                print("Iniciando recorrido de archivos...")
-                for root, dirs, files in os.walk(temp_dir):
-                    print(f"Revisando directorio: {root}")
-                    print(f"Archivos encontrados: {files}")
-                    
-                    for file_name in files:
-                        print(f"Procesando archivo: {file_name}")
-                        file_path = os.path.join(root, file_name)
-                        
-                        # Obtener la ruta relativa para determinar la estructura de carpetas
-                        relative_path = os.path.relpath(file_path, temp_dir)
-                        print(f"Ruta relativa: {relative_path}")
-                        
-                        # Determinar si el archivo está en una carpeta que sigue la nomenclatura
-                        folder_name = None
-                        if os.path.dirname(relative_path):
-                            # El archivo está dentro de una carpeta
-                            folder_parts = relative_path.split(os.sep)
-                            folder_name = folder_parts[0]  # Primera carpeta (nombre del archivo ZIP/RAR sin extensión)
-                        else:
-                            # El archivo está en la raíz, usar el nombre del archivo sin extensión
-                            folder_name = os.path.splitext(file_name)[0]
-                        
-                        print(f"Folder name para validación: {folder_name}")
-                        
-                        # Validar nomenclatura
-                        match = nomenclatura_pattern.match(folder_name)
-                        match_sin_anio = nomenclatura_pattern_sin_anio.match(folder_name)
                     
                     if not match and not match_sin_anio:
-                            print(f"Nomenclatura inválida: {folder_name}")
+                        print(f"Nomenclatura inválida en nombre de archivo: {archivo_name_sin_extension}")
-                            # Determinar el archivo original basado en el subdirectorio
-                            archivo_original = folder_name + ('.zip' if any(f.endswith('.zip') for f in [a.name for a in archivos]) else '.rar')
                         failed_files.append({
-                                "file": relative_path,
+                            "archivo_original": archivo.name,
-                                "archivo_original": archivo_original,
+                            "error": f"Nomenclatura inválida: {archivo_name_sin_extension}. Esperado: anio-aduana-patente-pedimento"
-                                "error": f"Nomenclatura inválida: {folder_name}. Esperado: anio-aduana-patente-pedimento"
                         })
                         continue
                     
+                    # Extraer información del pedimento desde el nombre del archivo
                     if match:
-
-                            print(f"Nomenclatura válida: {folder_name}")
                         anio, aduana, patente, pedimento_num = match.groups()
-                            print(f"Extraído - Año: {anio}, Aduana: {aduana}, Patente: {patente}, Pedimento: {pedimento_num}")
+                        print(f"Extraído del nombre del archivo - Año: {anio}, Aduana: {aduana}, Patente: {patente}, Pedimento: {pedimento_num}")
-                            # Formato original: anio-aduana-patente-pedimento
+                        
-                            # Crear fecha_pago basada en el año
                         try:
                             # Convertir año de 2 dígitos a 4 dígitos
                             anio_completo = 2000 + int(anio) if int(anio) < 50 else 1900 + int(anio)
                             fecha_pago = datetime(anio_completo, 1, 1).date()
                             print(f"Fecha de pago calculada: {fecha_pago}")
                         except ValueError:
-                                archivo_original = folder_name + ('.zip' if any(f.endswith('.zip') for f in [a.name for a in archivos]) else '.rar')
                             failed_files.append({
-                                    "file": relative_path,
+                                "archivo_original": archivo.name,
-                                    "archivo_original": archivo_original,
                                 "error": f"Año inválido: {anio}"
                             })
                             continue
                             
                     elif match_sin_anio:
-
-                            print(f"Nomenclatura válida sin año: {folder_name}")
-                        
-                            # Formato sin año: aduana-patente-pedimento
                         aduana, patente, pedimento_num = match_sin_anio.groups()
-                            print(f"Extraído - Aduana: {aduana}, Patente: {patente}, Pedimento: {pedimento_num}")
+                        print(f"Extraído del nombre del archivo - Aduana: {aduana}, Patente: {patente}, Pedimento: {pedimento_num}")
                         
                         # Obtener el primer dígito del pedimento
                         primer_digito_pedimento = int(pedimento_num[0]) if pedimento_num else 0
@@ -743,10 +648,8 @@ class ViewSetPedimento(LoggingMixin, viewsets.ModelViewSet, OrganizacionFiltrada
                         
                         # Aplicar lógica de comparación
                         if año_con_digito <= año_actual:
-                                # Si el año con dígito es menor o igual al año actual
                             año_final = año_con_digito
                         else:
-                                # Si el año con dígito es mayor al año actual, restar 10
                             año_final = año_con_digito - 10
                         
                         # Tomar los últimos 2 dígitos del año final
@@ -754,24 +657,84 @@ class ViewSetPedimento(LoggingMixin, viewsets.ModelViewSet, OrganizacionFiltrada
                         
                         # Crear fecha de pago (primer día del año)
                         fecha_pago = datetime(año_final, 1, 1).date()
-
                         print(f"Fecha de pago (año actual) calculada: {fecha_pago}")
                     
                     # Generar pedimento_app
                     pedimento_app = f"{anio}-{aduana.zfill(2)}-{patente}-{pedimento_num}"
                     print(f"Pedimento_app generado: {pedimento_app}")
+                    
+                    # VERIFICAR SI EL PEDIMENTO YA EXISTE ANTES DE PROCESAR EL ARCHIVO
                     print(f"Buscando pedimento existente con pedimento_app: {pedimento_app} y organización ID: {organizacion.id}")
-                        # Verificar si el pedimento ya existe
                     existing_pedimento = Pedimento.objects.filter(
                         pedimento_app=pedimento_app,
-                           # organizacion=organizacion
+                        organizacion=organizacion
                     ).first()
                     
-                        print(f"Pedimento existente: {existing_pedimento is not None}")
+                    if existing_pedimento:
+                        print(f"⚠️ Pedimento ya existe: ID {existing_pedimento.id}, pedimento_app: {pedimento_app}")
+                        already_existing_pedimentos.append({
+                            "id": str(existing_pedimento.id),
+                            "pedimento_app": pedimento_app,
+                            "contribuyente": existing_pedimento.contribuyente.rfc if existing_pedimento.contribuyente else None,
+                            "archivo_original": archivo.name
+                        })
+                        # NO procesamos este archivo, pasamos al siguiente
+                        continue
                     
-                        if not existing_pedimento:
+                    # Si el pedimento no existe, continuar con el procesamiento normal
-                            print("📝 Pedimento no existe, creando nuevo...")
+                    print("📝 Pedimento no existe, continuando con procesamiento...")
-                            # Crear nuevo pedimento
+                    
+                    # Crear subdirectorio para cada archivo usando el nombre del archivo sin extensión
+                    sub_dir = os.path.join(temp_dir, archivo_name_sin_extension)
+                    os.makedirs(sub_dir, exist_ok=True)
+                    print(f"Subdirectorio creado: {sub_dir}")
+                    
+                    if archivo_name.endswith('.zip'):
+                        # Manejar archivo ZIP
+                        print("Es un archivo ZIP")
+                        try:
+                            with zipfile.ZipFile(archivo, 'r') as zip_ref:
+                                zip_ref.extractall(sub_dir)
+                            print("Archivo ZIP extraído exitosamente")
+                        except zipfile.BadZipFile as e:
+                            failed_files.append({
+                                "archivo_original": archivo.name,
+                                "error": f"Archivo ZIP corrupto o inválido: {str(e)}"
+                            })
+                            continue
+                        except Exception as e:
+                            failed_files.append({
+                                "archivo_original": archivo.name,
+                                "error": f"Error al extraer ZIP: {str(e)}"
+                            })
+                            continue
+                            
+                    elif archivo_name.endswith('.rar'):
+                        # Manejar archivo RAR: guardar el archivo en disco y usar helper con fallbacks
+                        archivo_temp_path = os.path.join(sub_dir, archivo.name)
+                        with open(archivo_temp_path, 'wb') as f:
+                            for chunk in archivo.chunks():
+                                f.write(chunk)
+                        try:
+                            extract_rar_to_dir(archivo_temp_path, sub_dir)
+                            print(f"Archivo RAR {archivo.name} extraído en {sub_dir}")
+                        except Exception as e:
+                            error_msg = str(e)
+                            help_msg = "Instale 'unrar' o 'p7zip' (7z) y asegúrese de que estén en PATH, o instale y configure 'rarfile' con un backend."
+                            failed_files.append({
+                                "archivo_original": archivo.name,
+                                "error": f"Error al extraer archivo RAR: {error_msg}"
+                            })
+                            continue
+                    else:
+                        # Asumir que es un archivo individual
+                        archivo_path = os.path.join(sub_dir, archivo.name)
+                        with open(archivo_path, 'wb') as f:
+                            for chunk in archivo.chunks():
+                                f.write(chunk)
+                        print(f"Archivo individual {archivo.name} guardado en sub_dir:", archivo_path)
+                    
+                    # Ahora crear el pedimento (ya verificamos que no existe)
                     try:
                         print("🔄 Iniciando creación de pedimento...")
                         
@@ -792,9 +755,12 @@ class ViewSetPedimento(LoggingMixin, viewsets.ModelViewSet, OrganizacionFiltrada
                         pedimento = Pedimento.objects.create(
                             organizacion=organizacion,
                             contribuyente=importador,
-                                    pedimento=int(pedimento_num),
+                            # pedimento=int(pedimento_num),
-                                    aduana=int(aduana),
+                            pedimento=pedimento_num,
-                                    patente=int(patente),
+                            aduana=aduana,
+                            # aduana=int(aduana),
+                            # patente=int(patente),
+                            patente=patente,
                             fecha_pago=fecha_pago,
                             pedimento_app=pedimento_app,
                             agente_aduanal=f"Agente {patente}",  # Valor por defecto
@@ -807,81 +773,102 @@ class ViewSetPedimento(LoggingMixin, viewsets.ModelViewSet, OrganizacionFiltrada
                             "id": str(pedimento.id),
                             "pedimento_app": pedimento_app,
                             "contribuyente": importador.rfc,
-                                    "contribuyente_nombre": importador.nombre
+                            "contribuyente_nombre": importador.nombre,
+                            "archivo_original": archivo.name
                         })
                         
                     except Exception as e:
                         print(f"❌ Error al crear pedimento: {str(e)}")
-                                archivo_original = folder_name + ('.zip' if any(f.endswith('.zip') for f in [a.name for a in archivos]) else '.rar')
                         failed_files.append({
-                                    "file": relative_path,
+                            "archivo_original": archivo.name,
-                                    "archivo_original": archivo_original,
                             "error": f"Error al crear pedimento: {str(e)}"
                         })
                         continue
-                        else:
-                            print(f"♻️ Usando pedimento existente: ID {existing_pedimento.id}")
-                            # Usar pedimento existente
-                            pedimento = existing_pedimento
                     
-                        print(f"🔄 Iniciando creación de documento para pedimento ID: {pedimento.id}")
+                    # Procesar documentos dentro del directorio
-                        # Crear documento asociado al pedimento
+                    print("Procesando documentos del directorio...")
+                    for root, dirs, files in os.walk(sub_dir):
+                        for file_name in files:
+                            file_path = os.path.join(root, file_name)
+                            print(f"Procesando documento: {file_name}")
+                            
                             try:
-                            print("📖 Leyendo archivo desde directorio temporal...")
                                 # Leer el archivo desde el directorio temporal
                                 with open(file_path, 'rb') as f:
                                     file_content = f.read()
+                                    from api.utils.helpers import extraer_info_pedimento_xml
                                 
-                            print(f"📄 Archivo leído: {len(file_content)} bytes")
+                                # Extraer info del pedimento desde XML si es aplicable
-                            # Crear ContentFile que Django puede manejar correctamente
+                                if file_name.lower().endswith('.xml'):
+                                    try:
+                                        xml_info = extraer_info_pedimento_xml(file_content)
+                                        if xml_info:
+                                            if 'numero_operacion' in xml_info:
+                                                if 'numero_pedimento' in xml_info:
+                                                    if xml_info['numero_pedimento'] == str(pedimento.pedimento):
+                                                        Pedimento.objects.filter(id=pedimento.id).update(
+                                                            aduana=xml_info.get('aduana_clave', pedimento.aduana)
+                                                        )
+                                                        print(f"Información extraída del XML: {xml_info}")
+                                    except Exception as e:
+                                        print(f"No se pudo extraer información del XML {file_name}: {str(e)}")
+
+                                # Obtener información del archivo
+                                extension = os.path.splitext(file_name)[1].lower().lstrip('.')
+                                
+                                # Buscar si ya existe un documento con el mismo nombre para este pedimento
+                                existing_documents = Document.objects.filter(
+                                    pedimento_id=pedimento.id,
+                                    organizacion=organizacion
+                                )
+                                
+                                existing_document = None
+                                for doc in existing_documents:
+                                    if is_same_document(doc, file_name):
+                                        existing_document = doc
+                                        print(f"✅ Encontrado documento existente: ID {doc.id}")
+                                        break
+                                
+                                # Crear ContentFile
                                 django_file = ContentFile(file_content, name=file_name)
                                 
-                            # # Verificar si el documento ya existe para este pedimento y archivo
+                                if existing_document:
-                            # print("🔍 Verificando existencia previa del documento...")
+                                    # Opcional: Eliminar el archivo físico anterior
+                                    try:
+                                        if existing_document.archivo and os.path.exists(existing_document.archivo.path):
+                                            os.remove(existing_document.archivo.path)
+                                    except (ValueError, OSError) as e:
+                                        print(f"No se pudo eliminar archivo físico anterior: {str(e)}")
                                     
-                            # # Reemplazar múltiples caracteres
+                                    # Actualizar el documento existente
-                            # normalized_file_name = file_name.replace(" ", "_")
+                                    existing_document.archivo = django_file
+                                    existing_document.size = len(file_content)
+                                    existing_document.extension = extension
+                                    existing_document.updated_at = timezone.now()  # Si tienes este campo
+                                    existing_document.save()
+                                    documents_created += 1
+                                    print(f"📄 Documento actualizado: {file_name}")
                                     
-                            # file_name_without_extension = normalized_file_name.rsplit('.', 1)[0]
+                                else:
-                            # extension_file = os.path.splitext(normalized_file_name)[1].lower().lstrip('.')
+                                    # Crear nuevo documento
-
-                            # existing_document = Document.objects.filter(
-                            #     pedimento_id=pedimento.id,
-                            #     archivo__contains=file_name_without_extension,
-                            #     extension=extension_file
-                            # ).first()
-
-                            # if existing_document:
-                            #     print(f"Documento existente encontrado, omitiendo creación: ID {existing_document.id}")
-                            #     continue
-
-                            print(f"Creando documento para archivo: {file_name}")
-                            # Crear documento - Django automáticamente guardará el archivo en media/documents/
                                     document = Document.objects.create(
                                         organizacion=organizacion,
                                         pedimento_id=pedimento.id,
                                         document_type=document_type,
-                                fuente_id=4,  # Fuente: Carga Plataforma
+                                        fuente_id=4,
                                         archivo=django_file,
                                         size=len(file_content),
-                                extension=os.path.splitext(file_name)[1].lower().lstrip('.')
+                                        extension=extension
                                     )
-                            print(f"Documento creado exitosamente: {document.id}")
-                            
                                     documents_created += 1
-                            print(f"📊 Total documentos creados hasta ahora: {documents_created}")
+                                    print(f"📄 Nuevo documento creado: {file_name}")
                                     
                             except Exception as e:
-                            print(f"❌ Error al crear documento: {str(e)}")
+                                print(f"❌ Error al procesar documento {file_name}: {str(e)}")
-                            archivo_original = folder_name + ('.zip' if any(f.endswith('.zip') for f in [a.name for a in archivos]) else '.rar')
+                                # Continuar con otros documentos
-                            failed_files.append({
-                                "file": relative_path,
-                                "archivo_original": archivo_original,
-                                "error": f"Error al crear documento: {str(e)}"
-                            })
-                            continue
                 
                 print(f"🏁 Procesamiento completado. Archivos procesados en este directorio.")
+                
         except Exception as e:
             return Response(
                 {"error": f"Error durante el procesamiento: {str(e)}"},
@@ -896,22 +883,38 @@ class ViewSetPedimento(LoggingMixin, viewsets.ModelViewSet, OrganizacionFiltrada
         response_data = {
             "created_count": len(created_pedimentos),
             "created_pedimentos": created_pedimentos,
+            "already_existing_count": len(already_existing_pedimentos),
+            "already_existing": already_existing_pedimentos,
             "documents_created": documents_created,
             "failed_files": failed_files,
             "processed_files": len(archivos),
-            "summary": f"Procesados {len(archivos)} archivo(s): {len(created_pedimentos)} pedimento(s) creado(s), {documents_created} documento(s) asociado(s)"
+            "summary": f"Procesados {len(archivos)} archivo(s): {len(created_pedimentos)} pedimento(s) creado(s), {len(already_existing_pedimentos)} ya existían, {documents_created} documento(s) asociado(s)"
         }
 
-        if failed_files:
+        try:
+
+            # Determinar el mensaje apropiado
+            if already_existing_pedimentos and not created_pedimentos and not failed_files:
+                response_data["message"] = "Todos los pedimentos ya existen. No se crearon nuevos pedimentos."
+                response_status = status.HTTP_200_OK
+            elif already_existing_pedimentos or failed_files:
                 response_data.update({
-                "message": "Procesamiento completado con algunos errores",
+                    "message": "Procesamiento completado con advertencias",
-                "errors": [item["error"] for item in failed_files]
                 })
+                if failed_files:
+                    response_data["errors"] = [item["error"] for item in failed_files]
                 response_status = status.HTTP_207_MULTI_STATUS
             else:
                 response_data["message"] = "Pedimentos creados exitosamente"
                 response_status = status.HTTP_201_CREATED
 
+        except Exception as e:
+            return Response(
+                {"error": f"Error durante el procesamiento: {str(e)}"},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR
+            )
+
+        
         return Response(response_data, status=response_status)
 
     @action(detail=False, methods=['post'], url_path='bulk-create-pedimento_desk', parser_classes=[MultiPartParser, FormParser])
@@ -1212,8 +1215,8 @@ class ViewSetPedimento(LoggingMixin, viewsets.ModelViewSet, OrganizacionFiltrada
                         # print(f"Buscando pedimento existente con pedimento_app: {pedimento_app} y organización ID: {organizacion.id}")
                         # Verificar si el pedimento ya existe
                         existing_pedimento = Pedimento.objects.filter(
-                            pedimento=int(pedimento_num),
+                            # pedimento=int(pedimento_num),
-                           # pedimento_app=pedimento_app,
+                            pedimento_app=pedimento_app,
                             organizacion=organizacion
                         ).first()
 
@@ -1248,9 +1251,9 @@ class ViewSetPedimento(LoggingMixin, viewsets.ModelViewSet, OrganizacionFiltrada
                                 pedimento = Pedimento.objects.create(
                                     organizacion=organizacion,
                                     contribuyente=importador if importador else None,
-                                    pedimento=int(pedimento_num),
+                                    pedimento=str(pedimento_num),
-                                    aduana=int(aduana),
+                                    aduana=str(aduana),
-                                    patente=int(patente),
+                                    patente=str(patente),
                                     fecha_pago=fecha_pago_input if fecha_pago_input else fecha_pago,
                                     curp_apoderado=curp_apoderado_input if curp_apoderado_input else "",
                                     numero_partidas=partidas_input if partidas_input else 0,
@@ -1773,3 +1776,144 @@ class ImportadorViewSet(viewsets.ModelViewSet, OrganizacionFiltradaMixin):
         raise ValueError("Usuario no autenticado o sin permisos para actualizar Importador")
 
     my_tags = ['Importadores']
+
+class EjecutarComandoView(APIView):
+    permission_classes = [IsAuthenticated &  (IsSameOrganization | IsSameOrganizationAndAdmin | IsSameOrganizationDeveloper | IsSuperUser)]
+    """
+    View para ejecutar el comando de microservicios desde una petición HTTP.
+    """
+    def post(self, request):
+
+        # Obtener organizacion_id del request (si se envía)
+        organizacion_id_request = request.data.get('organizacionid', None)
+        procesamiento = request.data.get('procesamiento', None)
+        todos = request.data.get('todos', False)
+
+        if not self.request.user.is_authenticated or not hasattr(self.request.user, 'organizacion'):
+            raise ValueError("Usuario no autenticado o sin organización")
+        
+        if organizacion_id_request is None:
+            return Response(
+                {"error": 'No se proporcionó la organización a ejecutar el proceso.'},
+                status=status.HTTP_400_BAD_REQUEST
+                )
+
+        # organizacion_id = self.request.user.organizacion.id
+        organizacion_id = organizacion_id_request
+        nombre_organizacion = self.request.user.organizacion.nombre
+
+        if procesamiento is None and todos == False:
+            return Response(
+                {"message": 'No se detectó el tipo de ejecución de procesamiento.'},
+                status=status.HTTP_400_BAD_REQUEST
+                )
+
+        procesamiento = str(procesamiento)
+
+        from api.customs.tasks import microservice_v2
+
+        if todos:
+
+            microservice_v2.ejecutar_todos_por_organizacion(organizacion_id)
+
+            return Response(
+                    {"message": f'Se estarán ejecutando todos los procesos para la organización {nombre_organizacion} en segundo plano.'},
+                    status=status.HTTP_200_OK
+                )
+        
+        elif organizacion_id:
+
+            if procesamiento:
+                microservice_v2.ejecutar_por_organizacion_y_procesamiento(organizacion_id, procesamiento)
+                return Response(
+                    {"message": f'Se estará ejecutando el procesamiento {procesamiento} para la organización {nombre_organizacion} en segundo plano.'},
+                    status=status.HTTP_200_OK
+                )
+
+        return Response(
+            {"error": "Parámetros insuficientes. Proporcione 'organizacion' y 'procesamiento', o seleccione 'todos'."},
+            status=status.HTTP_400_BAD_REQUEST
+        )
+
+    my_tags = ['Procesamientos_Pedimentos']
+
+# helper | reglas para formato de docuemnto antes de cargarlo
+def normalize_filename(filename):
+    """
+    Normaliza el nombre del archivo removiendo caracteres especiales,
+    espacios y asegurando consistencia.
+    """
+    filename = normalize('NFKD', filename).encode('ASCII', 'ignore').decode('ASCII')
+    
+    filename = re.sub(r'[^\w\s.-]', '_', filename)  # Remover caracteres no alfanuméricos
+    filename = re.sub(r'[\s()]+', '_', filename)  # Reemplazar espacios y paréntesis
+    filename = re.sub(r'_+', '_', filename)  # Consolidar múltiples _
+    filename = filename.strip('_')  # Remover _ al inicio/final
+    
+    return filename
+
+def get_clean_base_filename(filename):
+    """
+    Obtiene el nombre base limpio sin el sufijo de Django.
+    """
+    normalized = normalize_filename(filename)
+    name_without_ext, ext = os.path.splitext(normalized)
+    
+    django_suffix = extract_django_suffix(name_without_ext)
+    if django_suffix:
+        base_name = name_without_ext[:-8] 
+    else:
+        base_name = name_without_ext
+    
+    base_name = re.sub(r'(_copy|_copia|_-_copia|_-_copy)(_\d+)?$', '', base_name)
+    
+    return base_name.lower().strip('_')
+
+def is_same_document(existing_doc, new_filename):
+    """
+    Compara si un documento existente y un nuevo archivo son el mismo documento.
+    
+    Args:
+        existing_doc: Objeto Document existente
+        new_filename: Nombre del nuevo archivo a subir
+    
+    Returns:
+        bool: True si son el mismo documento
+    """
+    existing_basename = os.path.basename(existing_doc.archivo.name)
+    existing_base = get_clean_base_filename(existing_basename)
+    
+    new_base = get_clean_base_filename(new_filename)
+    
+    existing_ext = existing_doc.extension.lower()
+    new_ext = os.path.splitext(new_filename)[1].lower().lstrip('.')
+    
+    return existing_base == new_base and existing_ext == new_ext
+
+def extract_django_suffix(filename):
+    """
+    Extrae el sufijo único que Django añade a los archivos.
+    """
+    name_without_ext = os.path.splitext(filename)[0]
+    
+    match = re.search(r'_([a-zA-Z0-9]{7})$', name_without_ext)
+    if match:
+        return match.group(1)
+    return None
+
+def get_clean_base_filename(filename):
+    """
+    Obtiene el nombre base limpio sin el sufijo de Django.
+    """
+    normalized = normalize_filename(filename)
+    name_without_ext, ext = os.path.splitext(normalized)
+    
+    django_suffix = extract_django_suffix(name_without_ext)
+    if django_suffix:
+        base_name = name_without_ext[:-8]  
+    else:
+        base_name = name_without_ext
+    
+    base_name = re.sub(r'(_copy|_copia|_-_copia|_-_copy)(_\d+)?$', '', base_name)
+    
+    return base_name.lower().strip('_')

api/customs/views_auditor.py

@@ -667,28 +667,36 @@ def auditar_peticion_respuesta_pedimento_completo(request):
     pedimento_app = pedimento.pedimento_app
     tipo_documento_peticion = None
     tipo_documento_respuesta = None
+    vista = 'desconocido'
 
     if vista_auditar == 'pc':
         tipo_documento_peticion = 13
         tipo_documento_respuesta = 14
+        vista = 'Pedimento Completo'
     elif vista_auditar == 'rm':
         tipo_documento_peticion = 15
         tipo_documento_respuesta = 16
+        vista = 'Remesa'
     elif vista_auditar == 'pt':
         tipo_documento_peticion = 17
         tipo_documento_respuesta = 18
+        vista = 'Partidas'
     elif vista_auditar == 'cove':
         tipo_documento_peticion = 19
         tipo_documento_respuesta = 20
+        vista = 'COVEs'
     elif vista_auditar == 'edoc':
         tipo_documento_peticion = 21
         tipo_documento_respuesta = 22
+        vista = 'Edocuments'
     elif vista_auditar == 'ac_cove':
         tipo_documento_peticion = 23
         tipo_documento_respuesta = 24
+        vista = 'Acuses COVEs'
     elif vista_auditar == 'ac':
         tipo_documento_peticion = 25
         tipo_documento_respuesta = 26
+        vista = 'Acuses'
     
     if not tipo_documento_peticion and not tipo_documento_respuesta:
         return Response(
@@ -712,7 +720,7 @@ def auditar_peticion_respuesta_pedimento_completo(request):
 
     if not documentos_peticion and not documentos_respuesta:
         return Response(
-                {'error': 'Registro de documentos de petición y respuesta de partidas no encontrado'},
+                {'error': f'Registro de documentos de petición y respuesta de {vista} no encontrado(s)'},
                 status=status.HTTP_404_NOT_FOUND
             )
     

api/datastage/tasks/report_document.py

@@ -0,0 +1,85 @@
+from celery import shared_task
+from django.core.files.base import ContentFile
+from django.utils import timezone
+from api.reports.models import ReportDocument
+from api.customs.models import Pedimento, Cove, EDocument, Partida
+from django.db.models import Q
+import csv
+import os
+from django.conf import settings
+import logging
+
+logger = logging.getLogger()
+
+@shared_task
+def generate_report_document(report_id):
+    try:
+        report = ReportDocument.objects.get(id=report_id)
+        report.status = 'processing'
+        report.save(update_fields=['status'])
+        filters = report.filters or {}
+        pedimentos_filters = Q()
+        if filters.get('organizacion_id'):
+            pedimentos_filters &= Q(organizacion_id=filters['organizacion_id'])
+        if filters.get('fecha_pago__gte'):
+            pedimentos_filters &= Q(fecha_pago__gte=filters['fecha_pago__gte'])
+        if filters.get('fecha_pago__lte'):
+            pedimentos_filters &= Q(fecha_pago__lte=filters['fecha_pago__lte'])
+        if filters.get('contribuyente__rfc'):
+            pedimentos_filters &= Q(contribuyente__rfc=filters['contribuyente__rfc'])
+        if filters.get('patente'):
+            pedimentos_filters &= Q(patente=filters['patente'])
+        if filters.get('aduana'):
+            pedimentos_filters &= Q(aduana=filters['aduana'])
+        if filters.get('pedimento'):
+            pedimentos_filters &= Q(pedimento=filters['pedimento'])
+        if filters.get('pedimento_app'):
+            pedimentos_filters &= Q(pedimento_app=filters['pedimento_app'])
+        if filters.get('regimen'):
+            pedimentos_filters &= Q(regimen=filters['regimen'])
+        if filters.get('tipo_operacion'):
+            pedimentos_filters &= Q(tipo_operacion_id=filters['tipo_operacion'])
+        pedimentos = Pedimento.objects.filter(pedimentos_filters)
+        filename = filters.get('filename')
+        if filename:
+            filename = f"{filename}.csv" if not filename.endswith('.csv') else filename
+        else:
+            filename = f"report_{report.id}_{timezone.now().strftime('%Y%m%d%H%M%S')}.csv"
+        file_path = os.path.join(settings.MEDIA_ROOT, 'reports', filename)
+        os.makedirs(os.path.dirname(file_path), exist_ok=True)
+        with open(file_path, 'w', newline='', encoding='utf-8') as f:
+            writer = csv.writer(f)
+            headers = [
+                'aduana', 'patente', 'regimen', 'pedimento', 'pedimento_app', 'clave_pedimento',
+                'tipo_operacion_id', 'contribuyente_id', 'tipo_documento', 'numero_documento', 'estado', 'acuse_estado'
+            ]
+            writer.writerow(headers)
+            for ped in pedimentos:
+                for cove in Cove.objects.filter(pedimento=ped):
+                    writer.writerow([
+                        ped.aduana, ped.patente, ped.regimen, ped.pedimento, ped.pedimento_app,
+                        ped.clave_pedimento, ped.tipo_operacion_id, ped.contribuyente_id,
+                        'COVE', cove.numero_cove, cove.cove_descargado, cove.acuse_cove_descargado
+                    ])
+                for edoc in EDocument.objects.filter(pedimento=ped):
+                    writer.writerow([
+                        ped.aduana, ped.patente, ped.regimen, ped.pedimento, ped.pedimento_app,
+                        ped.clave_pedimento, ped.tipo_operacion_id, ped.contribuyente_id,
+                        'EDOC', edoc.numero_edocument, edoc.edocument_descargado, edoc.acuse_descargado
+                    ])
+                for partida in Partida.objects.filter(pedimento=ped):
+                    writer.writerow([
+                        ped.aduana, ped.patente, ped.regimen, ped.pedimento, ped.pedimento_app,
+                        ped.clave_pedimento, ped.tipo_operacion_id, ped.contribuyente_id,
+                        'PARTIDA', partida.numero_partida, partida.descargado, ''
+                    ])
+        with open(file_path, 'rb') as f:
+            report.file.save(filename, ContentFile(f.read()), save=True)
+        report.status = 'ready'
+        report.finished_at = timezone.now()
+        report.save(update_fields=['status', 'file', 'finished_at'])
+    except Exception as e:
+        report.status = 'error'
+        report.error_message = str(e)
+        report.finished_at = timezone.now()
+        report.save(update_fields=['status', 'error_message', 'finished_at'])

api/datastage/views.py

@@ -61,18 +61,35 @@ class DataStageViewSet(LoggingMixin, viewsets.ModelViewSet, OrganizacionFiltrada
 
         if self.request.user.is_superuser:
             # Permitir que el superusuario cree sin organización o la especifique
-            serializer.save()
+            datastage = serializer.save()
+            self._trigger_processing(datastage)
             return
 
         if (self.request.user.groups.filter(name='developer').exists() or self.request.user.groups.filter(name='admin').exists() or self.request.user.groups.filter(name='user').exists()) and self.request.user.groups.filter(name='Agente Aduanal').exists():
             if not organizacion:
-                serializer.save(organizacion=self.request.user.organizacion)
+                datastage = serializer.save(organizacion=self.request.user.organizacion)
             else:
-                serializer.save()
+                datastage = serializer.save()
+            
+            self._trigger_processing(datastage)
+            
             return
 
         raise ValueError("No cuentas con los permisos necesarios para crear un DataStage")
     
+    def _trigger_processing(self, datastage):
+        """
+        Método helper para disparar el procesamiento.
+        """
+        from api.datastage.tasks import procesar_datastage_task
+        user_organizacion = getattr(self.request.user, 'organizacion', None)
+        user_organizacion_id = user_organizacion.id if user_organizacion else None
+        
+        datastage.procesado = True
+        datastage.save()
+        
+        task = procesar_datastage_task.delay(datastage.id, user_organizacion_id)
+        
     def perform_update(self, serializer):
         """
         Override to ensure organization is set on update.
@@ -113,6 +130,7 @@ class DataStageViewSet(LoggingMixin, viewsets.ModelViewSet, OrganizacionFiltrada
         """
         Endpoint para procesar el DataStage de forma asíncrona usando Celery.
         """
+        # ojo aqui
         from api.datastage.tasks import procesar_datastage_task
         datastage = self.get_object()
         user_organizacion = getattr(self.request.user, 'organizacion', None)

api/organization/views.py

@@ -27,7 +27,7 @@ class ViewSetOrganizacion(LoggingMixin, viewsets.ModelViewSet, OrganizacionFiltr
 
     queryset = Organizacion.objects.all()
     serializer_class = OrganizacionSerializer
-    filterset_fields = ['nombre', 'descripcion']
+    filterset_fields = ['nombre']
     
     my_tags = ['Organizaciones']
 

api/record/models.py

@@ -15,6 +15,7 @@ class Document(models.Model):
     extension = models.CharField(max_length=60, blank=True, null=True)
     size = models.PositiveIntegerField()
     fuente = models.ForeignKey('Fuente', on_delete=models.CASCADE, related_name='documents', blank=True, null=True)
+    vu = models.BooleanField(default=False)
 
     created_at = models.DateTimeField(auto_now_add=True)
     updated_at = models.DateTimeField(auto_now=True)
@@ -22,6 +23,13 @@ class Document(models.Model):
     def save(self, *args, **kwargs):
         is_new = self._state.adding
         
+        # Calcular automáticamente el campo vu
+        if self.document_type_id:
+            # rango de IDs que indican documentos VU
+            self.vu = 13 <= self.document_type_id <= 26
+        else:
+            self.vu = False
+
         # Usar get_or_create en lugar de get para manejar el caso cuando no existe
         uso_almacenamiento, created = UsoAlmacenamiento.objects.get_or_create(
             organizacion=self.organizacion,

api/record/serializers.py

@@ -13,7 +13,7 @@ class DocumentSerializer(serializers.ModelSerializer):
     fuente = serializers.PrimaryKeyRelatedField(queryset=Fuente.objects.all())
     class Meta:
         model = Document
-        fields = ('id', 'organizacion', 'pedimento', 'pedimento_numero', 'archivo', 'document_type', 'size', 'extension', 'fuente','fuente_nombre','created_at', 'updated_at')
+        fields = ('id', 'organizacion', 'pedimento', 'pedimento_numero', 'archivo', 'document_type', 'size', 'extension', 'fuente','fuente_nombre','created_at', 'updated_at','vu')
         read_only_fields = ('id', 'size', 'extension', 'created_at', 'updated_at', 'pedimento_numero')
 
     def get_pedimento_numero(self, obj):

api/reports/models.py

@@ -9,10 +9,15 @@ class ReportDocument(models.Model):
 		('ready', 'Listo'),
 		('error', 'Error'),
 	]
+	TYPE_REPORT = [
+		('cumplimiento', 'cumplimiento'),
+		('control_pedimento', 'control_pedimento'),
+	]
 	user = models.ForeignKey(get_user_model(), on_delete=models.CASCADE, related_name='report_documents')
 	filters = models.JSONField(blank=True, null=True)
 	status = models.CharField(max_length=20, choices=STATUS_CHOICES, default='pending')
 	file = models.FileField(upload_to='reports/', blank=True, null=True)
+	report_type = models.CharField(max_length=30, choices=TYPE_REPORT, default='cumplimiento')
 	error_message = models.TextField(blank=True, null=True)
 	created_at = models.DateTimeField(auto_now_add=True)
 	finished_at = models.DateTimeField(blank=True, null=True)

api/reports/tasks/report_document.py

@@ -1,9 +1,12 @@
 from celery import shared_task
+from api.organization.models import Organizacion
 from django.core.files.base import ContentFile
 from django.utils import timezone
 from api.reports.models import ReportDocument
 from api.customs.models import Pedimento, Cove, EDocument, Partida
-from django.db.models import Q
+from django.db.models import Q, Exists, OuterRef
+# from django.db.models import Q, 
+from api.record.models import Document
 import csv
 import os
 from django.conf import settings
@@ -15,7 +18,6 @@ def generate_report_document(report_id):
         report.status = 'processing'
         report.save(update_fields=['status'])
         filters = report.filters or {}
-        # Construir Q para filtros complejos
         pedimentos_filters = Q()
         if filters.get('organizacion_id'):
             pedimentos_filters &= Q(organizacion_id=filters['organizacion_id'])
@@ -83,3 +85,199 @@ def generate_report_document(report_id):
         report.error_message = str(e)
         report.finished_at = timezone.now()
         report.save(update_fields=['status', 'error_message', 'finished_at'])
+
+@shared_task
+def generate_report_control_pedimento(report_id):
+    try:
+        
+        report = ReportDocument.objects.get(id=report_id)
+        report.status = 'processing'
+        report.save(update_fields=['status'])
+        filters = report.filters or {}
+
+        
+        # Construir filtros
+        pedimentos_filters = {}
+        if filters.get('organizacion_id'):
+            pedimentos_filters['organizacion_id'] = filters['organizacion_id']
+        if filters.get('fecha_pago__gte'):
+            pedimentos_filters['fecha_pago__gte'] = filters['fecha_pago__gte']
+        if filters.get('fecha_pago__lte'):
+            pedimentos_filters['fecha_pago__lte'] = filters['fecha_pago__lte']
+        if filters.get('pedimento_app'):
+            pedimentos_filters['pedimento_app'] = filters['pedimento_app']
+
+        # pedimentos por organizacion
+        pedimentos_qs = Pedimento.objects.filter(**pedimentos_filters)
+        pedimentos_total = pedimentos_qs.count()
+
+        
+        pedimento_ids = list(pedimentos_qs.values_list('id', flat=True))
+        rfcs_raw = list(pedimentos_qs.values_list('agente_aduanal', flat=True))
+
+        # inicializar totales
+        pedimentos_completos = 0
+        total_documentos = 0
+        documentos_sin_descargar = 0
+
+        nombre_organizacion = ''
+        if filters.get('organizacion_id'):
+            try:
+                # Asumo que tienes un modelo Organizacion - ajusta según tu modelo real
+                organizacion = Organizacion.objects.get(id=filters['organizacion_id'])
+                nombre_organizacion = organizacion.nombre  # ajusta el campo según tu modelo
+            except Organizacion.DoesNotExist:
+                nombre_organizacion = f"ID: {filters['organizacion_id']}"
+            except Exception as e:
+                nombre_organizacion = f"Error: {str(e)}"
+        
+        # lista de rfc
+        rfc_list = ', '.join(sorted(set([rfc for rfc in rfcs_raw if rfc])))
+        
+        fecha_inicio = ''
+        fecha_fin = ''
+
+        if pedimentos_qs.exists():
+            primer_pedimento = pedimentos_qs.order_by('fecha_pago').first()
+            if primer_pedimento and primer_pedimento.fecha_pago:
+                fecha_inicio = primer_pedimento.fecha_pago.strftime('%Y-%m-%d')
+            
+            ultimo_pedimento = pedimentos_qs.order_by('-fecha_pago').first()
+            if ultimo_pedimento and ultimo_pedimento.fecha_pago:
+                fecha_fin = ultimo_pedimento.fecha_pago.strftime('%Y-%m-%d')
+
+        # Para cada pedimento, verificar si está completo
+        for pedimento in pedimentos_qs:
+            # Contar documentos de este pedimento
+            docs_pedimento = 0
+            docs_pendientes_pedimento = 0
+            
+            # COVES
+            coves_count = Cove.objects.filter(pedimento_id=pedimento.id).count()
+            coves_pendientes = Cove.objects.filter(pedimento_id=pedimento.id, cove_descargado=False).count()
+            docs_pedimento += coves_count
+            docs_pendientes_pedimento += coves_pendientes
+            
+            # PARTIDAS
+            partidas_count = Partida.objects.filter(pedimento_id=pedimento.id).count()
+            partidas_pendientes = Partida.objects.filter(pedimento_id=pedimento.id, descargado=False).count()
+            docs_pedimento += partidas_count
+            docs_pendientes_pedimento += partidas_pendientes
+            
+            # EDOCUMENTS
+            edocs_count = EDocument.objects.filter(pedimento_id=pedimento.id).count()
+            edocs_pendientes = EDocument.objects.filter(pedimento_id=pedimento.id, edocument_descargado=False).count()
+            docs_pedimento += edocs_count
+            docs_pendientes_pedimento += edocs_pendientes
+            
+            # Acumular totales
+            total_documentos += docs_pedimento
+            documentos_sin_descargar += docs_pendientes_pedimento
+            
+            # Si no tiene documentos pendientes, está completo
+            if docs_pendientes_pedimento == 0 and docs_pedimento > 0:
+                pedimentos_completos += 1
+
+        # 3. PORCENTAJE
+        porcentaje_faltantes = (documentos_sin_descargar / total_documentos * 100) if total_documentos > 0 else 0
+
+        # 4. GENERAR CSV CON DETALLES
+        filename = f"report_{report.id}_{timezone.now().strftime('%Y%m%d%H%M%S')}.csv"
+        file_path = os.path.join(settings.MEDIA_ROOT, 'reports', filename)
+        os.makedirs(os.path.dirname(file_path), exist_ok=True)
+        
+        todas_las_filas = []
+        
+        # Recopilar datos detallados - UNA FILA POR CADA DOCUMENTO
+        for pedimento in pedimentos_qs:
+            # DATOS BASE DEL PEDIMENTO (se repiten en cada fila)
+            datos_base_pedimento = [
+                pedimento.aduana or '',
+                pedimento.patente or '',
+                pedimento.regimen or '',
+                pedimento.pedimento or '',  # No. Pedimento (7 dígitos)
+                pedimento.pedimento_app or '',  # No. Pedimento App completo
+                pedimento.clave_pedimento or '',
+                pedimento.tipo_operacion.tipo if pedimento.tipo_operacion else '',
+                str(pedimento.contribuyente_id) if pedimento.contribuyente_id else ''
+            ]
+            
+            # COVES - Una fila por cada COVE
+            coves = Cove.objects.filter(pedimento_id=pedimento.id)
+            for cove in coves:
+                estado = 'VERDADERO' if cove.cove_descargado else 'FALSO'
+                fila = datos_base_pedimento + [
+                    # str(cove.id),  # Identificador de documento
+                    cove.numero_cove,  
+                    'COVE',  # Tipo de documento
+                    estado
+                ]
+                todas_las_filas.append(fila)
+            
+            # PARTIDAS - Una fila por cada Partida
+            partidas = Partida.objects.filter(pedimento_id=pedimento.id)
+            for partida in partidas:
+                estado = 'VERDADERO' if partida.descargado else 'FALSO'
+                fila = datos_base_pedimento + [
+                    # str(partida.id), 
+                    partida.numero_partida, 
+                    'PARTIDA',  # Tipo de documento
+                    estado
+                ]
+                todas_las_filas.append(fila)
+            
+            # EDOCUMENTS - Una fila por cada EDocument
+            edocuments = EDocument.objects.filter(pedimento_id=pedimento.id)
+            for edoc in edocuments:
+                estado = 'VERDADERO' if edoc.edocument_descargado else 'FALSO'
+                fila = datos_base_pedimento + [
+                    # str(edoc.id), 
+                    edoc.numero_edocument,
+                    'EDOCUMENT',  # Tipo de documento
+                    estado
+                ]
+                todas_las_filas.append(fila)
+
+        # 5. ESCRIBIR ARCHIVO CSV
+        with open(file_path, 'w', newline='', encoding='utf-8') as f:
+            writer = csv.writer(f)
+            
+            # SECCIÓN DE TOTALES
+            writer.writerow(['RESUMEN DEL REPORTE - CONTROL DE PEDIMENTOS'])
+            writer.writerow(['ORGANIZACION:', nombre_organizacion])
+            writer.writerow([])
+            writer.writerow(['TOTAL DE EXPEDIENTES:', pedimentos_total])
+            writer.writerow(['TOTAL DE EXPEDIENTES COMPLETOS:', pedimentos_completos])
+            writer.writerow(['TOTAL DE DOCUMENTOS:', total_documentos])
+            writer.writerow(['DOCUMENTOS SIN DESCARGAR:', documentos_sin_descargar])
+            writer.writerow(['PORCENTAJE DE DOCUMENTOS FALTANTES (%):', f"{porcentaje_faltantes:.2f}%"])
+            writer.writerow(['DESDE: ', fecha_inicio, ' HASTA: ', fecha_fin])
+            writer.writerow(['LISTA RFC:', rfc_list])
+            writer.writerow([])
+            writer.writerow([])
+            
+            # ENCABEZADOS DE DATOS (según requerimiento)
+            headers = [
+                'ADUANA', 'PATENTE', 'REGIMEN', 'NO. PEDIMENTO', 'PEDIMENTO_APP', 
+                'CLAVE_PEDIMENTO', 'TIPO_OPERACION', 'CONTRIBUYENTE_ID', 
+                'IDENTIFICADOR_DOCUMENTO', 'TIPO_DOCUMENTO', 'ESTADO'
+            ]
+            writer.writerow(headers)
+            
+            # DATOS DETALLADOS
+            for fila in todas_las_filas:
+                writer.writerow(fila)
+
+
+        with open(file_path, 'rb') as f:
+            report.file.save(filename, ContentFile(f.read()), save=True)
+        
+        report.status = 'ready'
+        report.finished_at = timezone.now()
+        report.save(update_fields=['status', 'file', 'finished_at'])    
+        
+    except Exception as e:
+        report.status = 'error'
+        report.error_message = str(e)
+        report.finished_at = timezone.now()
+        report.save(update_fields=['status', 'error_message', 'finished_at'])

api/reports/urls.py

@@ -1,10 +1,12 @@
 from django.urls import path, include
-from .views import ExportModelView, dashboard_summary
+from .views import ExportModelView, ExportDataStageView, dashboard_summary
 # from .views_stats import documentos_por_fecha
-from .views_table import table_summary, report_document_status, report_document_list, report_document_download
+from .views_table import table_summary, report_document_status, report_document_list, report_document_download, control_pedimento
 
 urlpatterns = [
     path('exportmodel/', ExportModelView.as_view(), name='export-model'),
+    path('exportmodel/datastage/', ExportDataStageView.as_view(), name='export-datastage-model'),
+    path('control-pedimento/', control_pedimento, name='control_pedimento'),
     path('dashboard/summary/', dashboard_summary, name='dashboard-summary'),
     #path('documentos-por-fecha/', documentos_por_fecha, name='documentos-por-fecha'),
     path('table-summary/', table_summary, name='table-summary'),

api/reports/views_table.py

@@ -1,5 +1,5 @@
 from api.reports.models import ReportDocument
-from api.reports.tasks.report_document import generate_report_document
+from api.reports.tasks.report_document import generate_report_document, generate_report_control_pedimento
 from django.http import FileResponse
 from rest_framework.decorators import api_view, permission_classes
 from rest_framework.permissions import IsAuthenticated
@@ -11,7 +11,10 @@ def table_summary(request):
     """
     Solo dispara la tarea asíncrona para generar el reporte CSV. No consulta ni procesa datos.
     """
+
     org_id = request.query_params.get('organizacion_id')
+    # hasta aqui si llega y crea el registro en la base de datos 
+    print(f'🖼️🖼️🖼️🖼️🖼️🖼️🖼️ table_summary organizacion id = {org_id}')
     if not org_id:
         return Response({"error": "organizacion_id es requerido"}, status=400)
     # Obtener filtros de query params
@@ -60,7 +63,8 @@ def table_summary(request):
     report = ReportDocument.objects.create(
         user=request.user,
         filters=filtros,
-        status='pending'
+        status='pending',
+        report_type='cumplimiento'
     )
     generate_report_document.delay(report.id)
     return Response({
@@ -94,6 +98,7 @@ def report_document_list(request):
     data = [
         {
             "report_id": r.id,
+            "report_type": r.report_type,
             "status": r.status,
             "created_at": r.created_at,
             "finished_at": r.finished_at,
@@ -115,3 +120,49 @@ def report_document_download(request, report_id):
         return response
     except ReportDocument.DoesNotExist:
         return Response({"error": "Reporte no encontrado"}, status=404)
+
+@api_view(['GET'])
+@permission_classes([IsAuthenticated])
+def control_pedimento(request):
+    """
+    Dispara la tarea asíncrona para generar el reporte CSV de control de Pedimentos. 
+    """
+    org_id = request.query_params.get('organizacion_id')
+
+    if not org_id:
+        return Response({"error": "organizacion_id es requerido"}, status=400)
+    
+    # Simplificar la lógica de fechas
+    fecha_pago_gte = request.query_params.get('fecha_pago__gte')
+    fecha_pago_lte = request.query_params.get('fecha_pago__lte')
+    pedimento_app = request.query_params.get('pedimento_app')
+    
+    # Si las fechas vienen como string, mantenerlas como están
+    fecha_pago_gte_str = fecha_pago_gte if fecha_pago_gte else None
+    fecha_pago_lte_str = fecha_pago_lte if fecha_pago_lte else None
+    
+    filtros = {
+        "pedimento_app": pedimento_app,
+        "organizacion_id": org_id,
+        "fecha_pago__gte": fecha_pago_gte_str,
+        "fecha_pago__lte": fecha_pago_lte_str,
+    }
+    
+    # Crear el reporte
+    report = ReportDocument.objects.create(
+        user=request.user,
+        filters=filtros,
+        status='pending',
+        report_type='control_pedimento'
+    )
+    
+    # Disparar la tarea asíncrona
+    generate_report_control_pedimento.delay(report.id)
+    
+    return Response({
+        "report_id": report.id,
+        "status": report.status,
+        "created_at": report.created_at,
+        "message": "Reporte en proceso de generación",
+        "download_url": report.file.url if report.file else None
+    }, status=202)

api/tasks/filters.py

@@ -8,7 +8,8 @@ class TaskFilter(filters.FilterSet):
     timestamp_gte = filters.DateTimeFilter(field_name='timestamp', lookup_expr='gte')
     timestamp_lte = filters.DateTimeFilter(field_name='timestamp', lookup_expr='lte')
     status = filters.CharFilter(field_name='status')
+    organizacion = filters.UUIDFilter(field_name='organizacion__id')  # Cambiado a relación directa
 
     class Meta:
         model = Task
-        fields = ['servicio', 'pedimento_app', 'pedimento', 'timestamp_gte', 'timestamp_lte', 'status']
+        fields = ['servicio', 'pedimento_app', 'pedimento', 'timestamp_gte', 'timestamp_lte', 'status', 'organizacion']

api/tasks/views.py

@@ -4,6 +4,7 @@ from django_filters.rest_framework import DjangoFilterBackend
 from rest_framework.pagination import PageNumberPagination
 
 from api.logger.mixins import LoggingMixin
+from mixins.filtrado_organizacion import OrganizacionFiltradaMixin, ProcesosPorOrganizacionMixin
 from .models import Task
 from .serializers import TaskSerializer
 from .filters import TaskFilter
@@ -22,7 +23,7 @@ class TaskPagination(PageNumberPagination):
     page_size_query_param = 'page_size'
     max_page_size = 100
 
-class TaskViewSet(LoggingMixin,viewsets.ModelViewSet):
+class TaskViewSet(LoggingMixin,viewsets.ModelViewSet,OrganizacionFiltradaMixin):
     permission_classes = [IsAuthenticated &  (IsSameOrganization | IsSameOrganizationAndAdmin | IsSameOrganizationDeveloper | IsSuperUser)]
     queryset = Task.objects.select_related('pedimento', 'servicio').all()
     serializer_class = TaskSerializer
@@ -33,3 +34,18 @@ class TaskViewSet(LoggingMixin,viewsets.ModelViewSet):
     ordering = ['-timestamp']  # ordenamiento por defecto, más reciente primero
     
     my_tags = ['tasks']
+
+    def get_queryset(self):
+
+        """
+        Filtra las tareas según la organización del usuario.
+        Superusuarios pueden ver todas las tareas.
+        """
+        queryset = self.get_queryset_filtrado_por_organizacion() # Tambien filtra por importador
+        # if user.is_superuser:
+        #     return self.queryset
+        #     # return self.queryset.filter(organizacion_id=user.organizacion.id)
+        # else:
+        #     return self.queryset.filter(organizacion_id=user.organizacion.id)
+        return queryset
+        

api/utils/helpers.py

@@ -0,0 +1,194 @@
+# auditoria_xml.py
+import xml.etree.ElementTree as ET
+from datetime import datetime
+
+def extraer_info_pedimento_xml(xml_content):
+    """
+    Extrae información específica de un XML de pedimento.
+    """
+    try:
+        # Parsear el XML
+        root = ET.fromstring(xml_content)
+        
+        # Buscar el namespace (puede variar)
+        namespaces = {
+            'S': 'http://schemas.xmlsoap.org/soap/envelope/',
+            'ns2': 'http://www.ventanillaunica.gob.mx/pedimentos/ws/oxml/consultarpedimentocompleto',
+            'ns3': 'http://www.ventanillaunica.gob.mx/common/ws/oxml/respuesta'
+        }
+        
+        resultado = {}
+        
+        # Extraer número de operación
+        num_op = root.find('.//ns2:numeroOperacion', namespaces)
+        if num_op is not None and num_op.text:
+            resultado['numero_operacion'] = num_op.text
+        
+        # Extraer información del pedimento
+        pedimento_elem = root.find('.//ns2:pedimento', namespaces)
+        if pedimento_elem is not None:
+            # Número de pedimento
+            ped_num = pedimento_elem.find('ns2:pedimento', namespaces)
+            if ped_num is not None and ped_num.text:
+                resultado['numero_pedimento'] = ped_num.text
+            
+            # Número de partidas
+            partidas = pedimento_elem.find('ns2:partidas', namespaces)
+            if partidas is not None and partidas.text:
+                try:
+                    resultado['numero_partidas'] = int(partidas.text)
+                except (ValueError, TypeError):
+                    pass
+            
+            # Tipo de operación clave
+            tipo_op_clave = pedimento_elem.find('.//ns2:tipoOperacion/ns2:clave', namespaces)
+            if tipo_op_clave is not None and tipo_op_clave.text:
+                if tipo_op_clave.text.strip() == '1':
+
+                    resultado['tipo_operacion'] = 'Importacion'
+                    resultado['tipo_operacion_descripcion'] = 'Indica operacion como Importaciones'
+
+                elif tipo_op_clave.text.strip() == '2':
+                    
+                    resultado['tipo_operacion'] = 'Exportacion'
+                    resultado['tipo_operacion_descripcion'] = 'Indica operacion de exportacion' 
+
+
+             # Clave del documento (clave_pedimento)
+            clave_doc = pedimento_elem.find('.//ns2:claveDocumento/ns2:clave', namespaces)
+            if clave_doc is not None and clave_doc.text:
+                resultado['clave_pedimento'] = clave_doc.text.strip()
+
+            # Aduana (patente)
+            aduana = pedimento_elem.find('.//ns2:aduanaEntradaSalida/ns2:clave', namespaces)
+            if aduana is not None and aduana.text:
+                resultado['aduana_clave'] = aduana.text.strip()
+
+            # Importador/Exportador
+            importador = pedimento_elem.find('.//ns2:importadorExportador', namespaces)
+            if importador is not None:
+                rfc = importador.find('ns2:rfc', namespaces)
+                if rfc is not None and rfc.text:
+                    resultado['contribuyente_rfc'] = rfc.text.strip()
+                
+                razon_social = importador.find('ns2:razonSocial', namespaces)
+                if razon_social is not None and razon_social.text:
+                    resultado['contribuyente_nombre'] = razon_social.text.strip()
+                
+                # Valor en dólares
+                valor_dolares = importador.find('ns2:valorDolares', namespaces)
+                if valor_dolares is not None and valor_dolares.text:
+                    try:
+                        resultado['valor_dolares'] = float(valor_dolares.text)
+                    except (ValueError, TypeError):
+                        pass
+
+                # Aduana de despacho
+                aduana_despacho = importador.find('ns2:aaduanaDespacho/ns2:clave', namespaces)
+                if aduana_despacho is not None and aduana_despacho.text:
+                    resultado['aduana_despacho'] = aduana_despacho.text.strip()
+            
+            # Encabezado del pedimento
+            encabezado = pedimento_elem.find('ns2:encabezado', namespaces)
+            if encabezado is not None:
+                # Aduana
+                aduana = encabezado.find('ns2:aduanaEntradaSalida/ns2:clave', namespaces)
+                if aduana is not None and aduana.text:
+                    resultado['aduana_clave'] = aduana.text.strip()
+                
+                # Tipo de cambio
+                tipo_cambio = encabezado.find('ns2:tipoCambio', namespaces)
+                if tipo_cambio is not None and tipo_cambio.text:
+                    try:
+                        resultado['tipo_cambio'] = float(tipo_cambio.text)
+                    except (ValueError, TypeError):
+                        pass
+                
+                # RFC Agente Aduanal
+                rfc_agente = encabezado.find('ns2:rfcAgenteAduanalSocFactura', namespaces)
+                if rfc_agente is not None and rfc_agente.text:
+                    resultado['rfc_agente_aduanal'] = rfc_agente.text.strip()
+
+                # CURP Apoderado
+                curp_apoderado = encabezado.find('ns2:curpApoderadomandatario', namespaces)
+                if curp_apoderado is not None and curp_apoderado.text:
+                    resultado['curp_apoderado'] = curp_apoderado.text.strip()
+
+                # Valor Aduanal Total
+                valor_aduanal = encabezado.find('ns2:valorAduanalTotal', namespaces)
+                if valor_aduanal is not None and valor_aduanal.text:
+                    try:
+                        resultado['valor_aduanal_total'] = float(valor_aduanal.text)
+                    except (ValueError, TypeError):
+                        pass
+
+                # Valor Comercial Total
+                valor_comercial = encabezado.find('ns2:valorComercialTotal', namespaces)
+                if valor_comercial is not None and valor_comercial.text:
+                    try:
+                        resultado['valor_comercial_total'] = float(valor_comercial.text)
+                    except (ValueError, TypeError):
+                        pass
+                    
+            # Fechas
+            fechas = pedimento_elem.findall('.//ns2:fechas', namespaces)
+            for fecha_elem in fechas:
+                fecha = fecha_elem.find('ns2:fecha', namespaces)
+                clave_fecha = fecha_elem.find('ns2:tipo/ns2:clave', namespaces)
+
+                if fecha is not None and fecha.text and clave_fecha is not None and clave_fecha.text:
+
+                    fecha_texto = fecha.text.strip()
+                    clave_fecha_texto = clave_fecha.text.strip()
+
+                    # Mapeo de claves según especificación
+                    if clave_fecha_texto == '1':  # Entrada
+                        resultado['fecha_entrada'] = fecha_texto
+                    elif clave_fecha_texto == '2':  # Pago
+                        resultado['fecha_pago'] = fecha_texto
+                    elif clave_fecha_texto == '3':  # Extracción
+                        resultado['fecha_extraccion'] = fecha_texto
+                    elif clave_fecha_texto == '5':  # Presentación
+                        resultado['fecha_presentacion'] = fecha_texto
+                    elif clave_fecha_texto == '6':  # Importación
+                        resultado['fecha_importacion'] = fecha_texto
+                    elif clave_fecha_texto == '7':  # Original
+                        resultado['fecha_original'] = fecha_texto
+                    else:
+                        resultado[f'fecha_clave_{clave_fecha_texto}'] = fecha_texto
+
+            # Facturas (para COVEs)
+            facturas = pedimento_elem.findall('.//ns2:facturas', namespaces)
+            coves_encontrados = []
+            for factura in facturas:
+                numero = factura.find('ns2:numero', namespaces)
+                if numero is not None and numero.text:
+                    coves_encontrados.append(numero.text.strip())
+            
+            if coves_encontrados:
+                resultado['coves_en_xml'] = coves_encontrados
+            
+            # E-Documents
+            identificadores = pedimento_elem.findall('.//ns2:identificadores/ns2:identificadores', namespaces)
+            edocs_encontrados = []
+            for ident in identificadores:
+                clave = ident.find('claveIdentificador/descripcion', namespaces)
+                complemento = ident.find('complemento1', namespaces)
+                if clave is not None and clave.text and 'E_DOCUMENT' in clave.text:
+                    if complemento is not None and complemento.text:
+                        edocs_encontrados.append(complemento.text.strip())
+            
+            if edocs_encontrados:
+                resultado['edocuments_en_xml'] = edocs_encontrados
+        
+        # Verificar si hay error en la respuesta
+        tiene_error = root.find('.//ns3:tieneError', namespaces)
+        if tiene_error is not None:
+            resultado['tiene_error'] = tiene_error.text.lower() == 'true'
+        
+        return resultado
+        
+    except ET.ParseError as e:
+        return {'error_parse': str(e)}
+    except Exception as e:
+        return {'error': str(e)}

api/vucem/views.py

@@ -1,4 +1,5 @@
 from django.shortcuts import render
+from ..organization.models import Organizacion
 from rest_framework import viewsets
 from rest_framework.pagination import PageNumberPagination
 from django_filters.rest_framework import DjangoFilterBackend
@@ -93,7 +94,23 @@ class VucemView(viewsets.ModelViewSet):
         if not self.request.user.is_authenticated or not hasattr(self.request.user, 'organizacion'):
             raise ValueError("El usuario debe estar autenticado y tener una organización asignada.")
         if self.request.user.is_superuser:
-            serializer.save(created_by=self.request.user, updated_by=self.request.user)
+            organizacion_id = self.request.data.get('organizacion_id')
+
+            if not organizacion_id:
+                raise ValueError("Los superusuarios deben especificar una organización")
+            
+            try:
+                # Importa el modelo Organizacion
+                # from ..organization.models import Organizacion
+                organizacion = Organizacion.objects.get(id=organizacion_id)
+            except Organizacion.DoesNotExist:
+                raise ValueError({"organizacion": "Organización no encontrada"})
+            
+            serializer.save(
+                organizacion=organizacion,
+                created_by=self.request.user, 
+                updated_by=self.request.user
+            )
             return        
         else:
             serializer.save(