fix: se ajusta enpoint de bulk-create-pedimento_desk para scrapear el archivo de validacion.

Reviewed-on: #20

api/customs/views.py

@@ -1215,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_app=pedimento_app,
+                            # pedimento=int(pedimento_num),
+                            pedimento_app=pedimento_app,
                             organizacion=organizacion
                         ).first()
 
@@ -1251,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),
-                                    aduana=int(aduana),
-                                    patente=int(patente),
+                                    pedimento=str(pedimento_num),
+                                    aduana=str(aduana),
+                                    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,
@@ -1364,37 +1364,39 @@ class ViewSetPedimento(LoggingMixin, viewsets.ModelViewSet, OrganizacionFiltrada
                             with open(file_path, 'rb') as f:
                                 file_content = f.read()
                             
+                            # Verificar si el archivo tiene la nomenclatura especial M8988852.300
+                            file_name_lower = file_name.lower()
+                            tiene_nomenclatura_especial = False
+                            info_extraida = {}
+
+                            # Patrón: 7 dígitos, punto, 3 dígitos (ej: M8988852.300)
+                            patron_nomenclatura = re.compile(r'^[m|M]\d{7}\.\d{3}$', re.IGNORECASE)
+
+                            # Separar nombre base y extensión
+                            nombre_base, extension = os.path.splitext(file_name)
+                 
+                            if patron_nomenclatura.match(file_name_lower):
+                                tiene_nomenclatura_especial = True
+
+                                 # Procesar el archivo con el método auxiliar
+                                info_extraida = procesar_archivo_m_con_nomenclatura(file_content, pedimento )
+                                                   
+                                if info_extraida.get('tiene_nomenclatura_especial', False):
+                                     # Agregar información de procesamiento a los datos de respuesta
+                                     if 'procesamiento_archivos' not in locals():
+                                         procesamiento_archivos = []
+
+                                     procesamiento_archivos.append({
+                                         'archivo': file_name,
+                                         'nomenclatura_especial': True,
+                                         'registros_encontrados': info_extraida.get('registros_encontrados', []),
+                                         'actualizaciones': info_extraida.get('actualizaciones_aplicadas', [])
+                                     })
+
                             # print(f"📄 Archivo leído: {len(file_content)} bytes")
                             # Crear ContentFile que Django puede manejar correctamente
                             django_file = ContentFile(file_content, name=file_name)
                             
-                            # # Verificar si el documento ya existe para este pedimento y archivo
-                            # print("🔍 Verificando existencia previa del documento...")
-
-                            # # Reemplazar múltiples caracteres
-                            # normalized_file_name = file_name.replace(" ", "_")
-
-                            # file_name_without_extension = normalized_file_name.rsplit('.', 1)[0]
-                            # extension_file = os.path.splitext(normalized_file_name)[1].lower().lstrip('.')
-
-                            # 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
-
-                            # try:
-                            #     fuente = Fuente.objects.get(nombre="APP-EFC")
-                            # except Fuente.DoesNotExist:
-                            #     fuente = Fuente.objects.create(
-                            #         nombre="APP-EFC",
-                            #         descripcion='Transmitido por la app de escritorio'
-                            #     )
-
                             fuente, created  = Fuente.objects.get_or_create(
                                nombre="APP-EFC",
                                descripcion='Transmitido por la app de escritorio'
@@ -1425,7 +1427,11 @@ class ViewSetPedimento(LoggingMixin, viewsets.ModelViewSet, OrganizacionFiltrada
                                 "error": f"Error al crear documento: {str(e)}"
                             })
                             continue
-                
+
+            if documents_created > 0 and existing_pedimento:            
+                existing_pedimento.existe_expediente = True
+                existing_pedimento.save()
+
                 # print(f"🏁 Procesamiento completado. Archivos procesados en este directorio.")
         except Exception as e:
             return Response(
@@ -1916,4 +1922,283 @@ def get_clean_base_filename(filename):
     
     base_name = re.sub(r'(_copy|_copia|_-_copia|_-_copy)(_\d+)?$', '', base_name)
     
-    return base_name.lower().strip('_')
+    return base_name.lower().strip('_')
+
+def procesar_archivo_m_con_nomenclatura(content, pedimento_instance):
+    """
+    Procesa archivos con nomenclatura M8988852.300 (7 dígitos, punto, 3 dígitos)
+    y extrae información de registros específicos para actualizar el pedimento.
+    
+    Args:
+        content: bytes del contenido del archivo
+        pedimento_instance: instancia del modelo Pedimento
+    
+    Returns:
+        dict: Diccionario con información extraída
+    """
+    try:
+        # Decodificar el contenido como texto
+        content_text = content.decode('utf-8', errors='ignore')
+        
+        # Buscar todas las líneas que empiezan con los registros solicitados
+        registros = {}
+        
+        for line in content_text.splitlines():
+            line = line.strip()
+            if not line:
+                continue
+                
+            # Dividir por pipe
+            parts = line.split('|')
+            if len(parts) < 2:
+                continue
+                
+            tipo_registro = parts[0]
+            
+            # Guardar todos los registros encontrados
+            if tipo_registro not in registros:
+                registros[tipo_registro] = []
+            registros[tipo_registro].append(parts)
+        
+        # Procesar información específica
+        info_extraida = {
+            'tiene_nomenclatura_especial': False,
+            'registros_encontrados': list(registros.keys()),
+            'detalles_registro_500': [],
+            'detalles_registro_506': [],
+            'detalles_registro_501': [],
+            'detalles_registro_551': [],
+            'detalles_registro_800': [],
+            'detalles_registro_801': [],
+            'actualizaciones_aplicadas': []
+        }
+        
+        # Verificar si hay registros del tipo 500 (indicador de archivo válido)
+        if '500' in registros:
+            info_extraida['tiene_nomenclatura_especial'] = True
+            
+            # Procesar registro 500: Información básica del pedimento
+            for reg_500 in registros['500']:
+                if len(reg_500) >= 1:
+                    info_extraida['detalles_registro_500'].append({
+                        'tipo_movimiento': reg_500[1] if len(reg_500) > 1 else None,
+                        'patente': reg_500[2] if len(reg_500) > 1 else None,
+                        'numero_pedimento': reg_500[3] if len(reg_500) > 1 else None,
+                        'aduana_seccion': reg_500[4] if len(reg_500) > 1 else None,
+                        'acuse_electronico': reg_500[5] if len(reg_500) > 1 else None,
+                    })
+            
+            # Procesar registro 506: Fechas importantes
+            for reg_506 in registros.get('506', []):
+                if len(reg_506) >= 1:
+                    info_extraida['detalles_registro_506'].append({
+                        'numero_pedimento': reg_506[1] if len(reg_506) > 1 else None,
+                        'tipo_fecha': reg_506[2] if len(reg_506) > 1 else None,
+                        'fecha': reg_506[3] if len(reg_506) > 1 else None
+                    })
+            
+            # Procesar registro 501: Información del importador/exportador
+            for reg_501 in registros.get('501', []):
+                if len(reg_501) >= 1:
+                    info_extraida['detalles_registro_501'].append({
+                        'patente': reg_501[1] if len(reg_501) > 1 else None,
+                        'numero_pedimento': reg_501[2] if len(reg_501) > 1 else None,
+                        'aduana_seccion': reg_501[3] if len(reg_501) > 1 else None,
+                        'rfc': reg_501[8] if len(reg_501) > 1 else None,
+                        'curp': reg_501[9] if len(reg_501) > 1 else None
+                    })
+            
+            # Procesar registro 551: Información de partidas
+            for reg_551 in registros.get('551', []):
+                if len(reg_551) >= 1:
+                    info_extraida['detalles_registro_551'].append({
+                        'numero_pedimento': reg_501[1] if len(reg_501) > 1 else None,
+                        'fraccion_arancelaria': reg_551[2] if len(reg_551) > 1 else None,
+                        'partida': reg_551[3] if len(reg_551) > 1 else None,
+                        'subfraccion': reg_551[4] if len(reg_551) > 1 else None
+                    })
+            
+            # Electrónica de Pedimento
+            for reg_801 in registros.get('800', []):
+                if len(reg_801) >= 1:
+                    info_extraida['detalles_registro_800'].append({
+                        'numero_pedimento': reg_801[1] if len(reg_801) > 1 else None
+                    })
+
+            # Fin de Archivo
+            for reg_801 in registros.get('801', []):
+                if len(reg_801) >= 1:
+                    info_extraida['detalles_registro_801'].append({
+                        'total_partidas': reg_801[1] if len(reg_801) > 1 else None
+                    })
+            
+            # Intentar actualizar campos del pedimento con la información extraída
+            actualizaciones = actualizar_pedimento_con_registros(pedimento_instance, registros)
+            info_extraida['actualizaciones_aplicadas'] = actualizaciones
+            
+        return info_extraida
+        
+    except Exception as e:
+        print(f"Error al procesar archivo con nomenclatura especial: {str(e)}")
+        return {
+            'tiene_nomenclatura_especial': False,
+            'error': str(e),
+            'registros_encontrados': []
+        }
+
+
+def actualizar_pedimento_con_registros(pedimento_instance, registros):
+    """
+    Actualiza el pedimento con información extraída de los registros.
+    
+    Args:
+        pedimento_instance: Instancia del pedimento a actualizar
+        registros: Diccionario con registros parseados
+    
+    Returns:
+        list: Lista de actualizaciones aplicadas
+    """
+    actualizaciones = []
+    
+    try:
+        # Extraer información del registro 500 (si existe)
+        if '500' in registros and registros['500']:
+            for reg_500 in registros['500']:
+                if len(reg_500) >= 1:
+                    # Actualizar número de pedimento si está vacío
+                    if pedimento_instance.pedimento == reg_500[3]:
+                        try:
+                            pedimento_instance.aduana = reg_500[4]
+                            actualizaciones.append(f"aduana actualizada a {reg_500[4]}")
+                        except ValueError:
+                            pass
+        
+        # Extraer información del registro 501 (importador/exportador)
+        if '501' in registros and registros['501']:
+            for reg_501 in registros['501']:
+                if len(reg_501) >= 1:
+                    rfc = reg_501[8] if len(reg_501) > 1 else None
+                    
+                    # Actualizar importador si hay RFC y no existe
+                    if rfc and not pedimento_instance.contribuyente and pedimento_instance.pedimento == reg_501[2]:
+                        try:
+                            from api.customs.models import Importador
+                            importador, created = Importador.objects.get_or_create(
+                                rfc=rfc,
+                                defaults={
+                                    'nombre': f"Importador {rfc}",
+                                    'organizacion': pedimento_instance.organizacion
+                                }
+                            )
+                            pedimento_instance.contribuyente = importador
+                            if created:
+                                actualizaciones.append(f"importador creado con RFC {rfc}")
+                            else:
+                                actualizaciones.append(f"importador asociado con RFC {rfc}")
+                        except Exception as e:
+                            print(f"Error al crear/obtener importador: {str(e)}")
+        
+        # Extraer CURP del registro 501
+        if '501' in registros and registros['501']:
+            for reg_501 in registros['501']:
+                if len(reg_501) >= 1:
+                    curp = reg_501[9] if len(reg_501) > 1 else None
+                    # Actualizar CURP del apoderado si está vacío
+                    if curp and not pedimento_instance.curp_apoderado and pedimento_instance.pedimento == reg_501[2]:
+                        pedimento_instance.curp_apoderado = curp
+                        actualizaciones.append(f"curp_apoderado actualizado a {curp}")
+
+        # Extraer Tipo Operacion del registro 501
+        if '501' in registros and registros['501']:
+            for reg_501 in registros['501']:
+                if len(reg_501) >= 1:
+                    tipo_operacion = reg_501[4] if len(reg_501) > 1 else None
+                    # Actualizar tipo de operación si no existe
+                    if tipo_operacion and pedimento_instance.pedimento == reg_501[2]:
+
+                        if tipo_operacion=='1':
+                            nombre_tipo_op = "Importacion"
+                        elif tipo_operacion=='2':
+                            nombre_tipo_op = "Exportacion"
+                        else:
+                            nombre_tipo_op = f"Tipo {tipo_operacion}"
+
+                        try:
+                            from api.customs.models import TipoOperacion
+                            tipo_op_obj, created = TipoOperacion.objects.get_or_create(
+                                id=tipo_operacion,
+                                tipo=nombre_tipo_op,
+                                defaults={'descripcion': f"Tipo de Operación {tipo_operacion}"}
+                            )
+                            pedimento_instance.tipo_operacion = tipo_op_obj
+                            if created:
+                                actualizaciones.append(f"tipo_operacion creado con tipo {tipo_operacion}")
+                            else:
+                                actualizaciones.append(f"tipo_operacion asociado con tipo {tipo_operacion}")
+                        except Exception as e:
+                            print(f"Error al crear/obtener tipo de operación: {str(e)}")
+        
+        # Extraer Clave Pedimento
+        if '501' in registros and registros['501']:
+            for reg_501 in registros['501']:
+                if len(reg_501) >= 1:
+                    clave = reg_501[5] if len(reg_501) > 1 else None
+                    # Actualizar clave si no existe
+                    if clave and pedimento_instance.pedimento == reg_501[2]:
+                        pedimento_instance.clave_pedimento = clave
+                        actualizaciones.append(f"clave pedimento actualizada a {clave}")
+
+        # Extraer fechas del registro 506
+        if '506' in registros and registros['506']:
+            for reg_506 in registros['506']:
+
+                if not pedimento_instance.pedimento == reg_506[1]:
+                    continue
+
+                if len(reg_506) >= 1:
+                    tipo_fecha = reg_506[2] if len(reg_506) > 1 else None
+                    fecha_str = reg_506[3] if len(reg_506) > 1 else None
+                    
+                    if not tipo_fecha == '2':
+                        continue
+
+                    # Procesar fecha según formato (DDMMYYYY o DDMMYY)
+                    if fecha_str:
+                        try:
+                            # Intentar diferentes formatos de fecha
+                            if len(fecha_str) == 8:  # DDMMYYYY
+                                fecha = datetime.strptime(fecha_str, '%d%m%Y').date()
+                            elif len(fecha_str) == 6:  # DDMMYY
+                                fecha = datetime.strptime(fecha_str, '%d%m%y').date()
+                            else:
+                                continue
+                            
+                            # Asignar como fecha de pago si no existe
+                            # if not pedimento_instance.fecha_pago:
+                            #     pedimento_instance.fecha_pago = fecha
+                            #     actualizaciones.append(f"fecha_pago actualizada a {fecha}")
+                            pedimento_instance.fecha_pago = fecha
+                            actualizaciones.append(f"fecha_pago actualizada a {fecha}")
+                        except (ValueError, TypeError):
+                            pass
+                        
+        num_partidas = 0
+        if '551' in registros and registros['551']:
+            for reg_551 in registros['551']:
+                if not pedimento_instance.pedimento == reg_551[1]:
+                    continue
+
+                num_partidas += 1 
+                pedimento_instance.numero_partidas = num_partidas
+                actualizaciones.append(f"numero_partidas actualizado a {num_partidas}")
+                
+        
+        # Guardar los cambios si hubo actualizaciones
+        if actualizaciones:
+            pedimento_instance.save()
+            
+    except Exception as e:
+        print(f"Error al actualizar pedimento con registros: {str(e)}")
+        actualizaciones.append(f"error: {str(e)}")
+    
+    return actualizaciones

api/reports/views.py

@@ -194,7 +194,7 @@ class ExportDataStageView(APIView):
         
         if export_type == 'excel':
             # Siempre usar el método particionado inteligente para Excel
-            return self.export_datastage_multiple_partitioned_excel(request, models_data, global_filters, related_keys)
+            return self.export_datastage_multiple_partitioned_excel_agrupados(request, models_data, global_filters, related_keys)
         else:
             # Para CSV, podemos mantener la lógica actual o mejorarla
             total_estimated_records = self.estimate_total_records(models_data, global_filters, related_keys, request.user)
@@ -278,6 +278,868 @@ class ExportDataStageView(APIView):
         )
         response['Content-Disposition'] = 'attachment; filename="datastage_related_report.xlsx"'
         return response
+    
+    def export_datastage_multiple_partitioned_excel_agrupados(self, request, models_data, global_filters, related_keys):
+        """Exporta múltiples modelos de DataStage agrupados en la misma hoja de Excel, con particionado por límite de registros"""
+        try:
+            zip_buffer = io.BytesIO()
+
+            # 🔥 PRECARGAR ORGANIZACIONES para mapeo rápido
+            from api.organization.models import Organizacion
+            organizaciones = Organizacion.objects.all()
+            org_mapping = {str(org.id): org.nombre for org in organizaciones}
+
+            with zipfile.ZipFile(zip_buffer, 'w', zipfile.ZIP_DEFLATED) as zip_file:
+
+                # 1. Recopilar todos los datos de cada modelo
+                all_models_data = {}  # Ahora será una lista por clave
+                model_field_mappings = {}
+
+                for model_data in models_data:
+                    model_name = model_data.get('model')
+                    fields = model_data.get('fields', [])
+
+                    if not model_name or not fields:
+                        continue
+                    
+                    # Normalizar nombres de campo entrantes: si se pasó "Organizacion"
+                    # (cualquier capitalización), usar el campo real de la BD `organizacion_id`.
+                    normalized_fields = []
+                    for f in fields:
+                        try:
+                            key = f.strip() if isinstance(f, str) else f
+                        except Exception:
+                            key = f
+
+                        if isinstance(key, str) and key.lower() == 'organizacion':
+                            if 'organizacion_id' not in normalized_fields:
+                                normalized_fields.append('organizacion_id')
+                        else:
+                            if key not in normalized_fields:
+                                normalized_fields.append(key)
+
+                    fields = normalized_fields
+
+                    # Asegurar que tenemos los campos de relación
+                    required_fields = ['seccion_aduanera', 'patente', 'pedimento']
+                    for field in required_fields:
+                        if field not in fields:
+                            fields.append(field)
+
+                    # 🔥 Añadir organizacion_id a los campos si no está y existe en el modelo
+                    if 'organizacion_id' not in fields and 'organizacion_id' in [f.name for f in apps.get_model('datastage', model_name)._meta.get_fields()]:
+                        fields.append('organizacion_id')
+
+                    try:
+                        model = apps.get_model('datastage', model_name)
+                        filters = self.apply_related_filters(global_filters, model, related_keys, request.user)
+
+                        if filters:
+                            queryset = model.objects.filter(**filters).values(*fields)
+                        else:
+                            queryset = model.objects.none()
+
+                        total_records = queryset.count()
+
+                        if total_records == 0:
+                            continue
+                        
+                        # Determinar campos de relación disponibles en este modelo
+                        relation_fields = []
+                        for field_name in ['seccion_aduanera', 'patente', 'pedimento']:
+                            if field_name in fields:
+                                relation_fields.append(field_name)
+
+                        if not relation_fields:
+                            # Si no hay campos de relación, usar un identificador único
+                            relation_fields = ['datastage_id'] if 'datastage_id' in fields else [fields[0]]
+
+                        # Guardar mapeo de campos para este modelo
+                        if model_name not in model_field_mappings:
+                            model_field_mappings[model_name] = fields
+
+                        # Procesar cada registro
+                        for record in queryset:
+                            # Crear clave de relación
+                            key_parts = []
+                            for rel_field in relation_fields:
+                                if rel_field in record and record[rel_field] is not None:
+                                    key_parts.append(str(record[rel_field]))
+
+                            if not key_parts:
+                                # Si no hay campos de relación, usar un hash del registro
+                                import hashlib
+                                record_str = str(sorted(record.items()))
+                                key = hashlib.md5(record_str.encode()).hexdigest()[:10]
+                            else:
+                                key = "_".join(key_parts)
+
+                            # 🔥 PROCESAR CAMPO organizacion_id para convertirlo a nombre
+                            processed_record = {}
+                            for field_name, value in record.items():
+                                # Convertir organizacion_id a nombre
+                                if field_name == 'organizacion_id' and value:
+                                    org_id_str = str(value)
+                                    # Usar el nombre de la organización si está en el mapeo
+                                    if org_id_str in org_mapping:
+                                        processed_value = org_mapping[org_id_str]
+                                    else:
+                                        # Si no se encuentra, intentar obtener de la base de datos
+                                        try:
+                                            org = Organizacion.objects.filter(id=value).first()
+                                            processed_value = org.nombre if org else str(value)
+                                            # Actualizar mapeo para futuras referencias
+                                            org_mapping[org_id_str] = processed_value
+                                        except:
+                                            processed_value = str(value)
+                                else:
+                                    processed_value = value
+
+                                # Agregar prefijo del modelo a los campos para evitar colisiones
+                                if field_name in relation_fields:
+                                    prefixed_field_name = field_name
+                                else:
+                                    prefixed_field_name = f"{model_name}_{field_name}"
+
+                                # 🔥 RENOMBRAR organizacion_id a organizacion_nombre
+                                if field_name == 'organizacion_id':
+                                    prefixed_field_name = prefixed_field_name.replace('organizacion_id', 'organizacion_nombre')
+
+                                processed_record[prefixed_field_name] = self.safe_excel_value(processed_value)
+
+                            # 🔥 CORRECIÓN: Ahora almacenamos una LISTA de registros por clave
+                            if key not in all_models_data:
+                                all_models_data[key] = {
+                                    'relation_fields': {},  # Campos de relación compartidos
+                                    'model_records': {}     # Diccionario de listas por modelo
+                                }
+
+                            # Guardar campos de relación (solo una vez, ya que son los mismos)
+                            for rel_field in relation_fields:
+                                if rel_field in record:
+                                    all_models_data[key]['relation_fields'][rel_field] = record[rel_field]
+
+                            # 🔥 GUARDAR COMO LISTA: Crear lista si no existe
+                            if model_name not in all_models_data[key]['model_records']:
+                                all_models_data[key]['model_records'][model_name] = []
+
+                            # Agregar este registro a la lista del modelo
+                            all_models_data[key]['model_records'][model_name].append(processed_record)
+
+                    except LookupError:
+                        continue
+                    
+                # Si no hay datos, retornar error
+                if not all_models_data:
+                    return Response({'error': 'No se encontraron datos para exportar'}, status=status.HTTP_404_NOT_FOUND)
+
+                # 2. Crear estructura de filas combinadas
+                # Ahora necesitamos expandir las filas cuando hay múltiples registros con la misma clave
+                combined_rows = []
+
+                for key, data in all_models_data.items():
+                    relation_fields = data['relation_fields']
+                    model_records = data['model_records']
+
+                    # 🔥 NUEVO: Calcular cuántas filas necesitamos para esta clave
+                    # Encontrar el modelo con más registros para esta clave
+                    max_records_per_key = 1
+                    for model_name, records in model_records.items():
+                        if len(records) > max_records_per_key:
+                            max_records_per_key = len(records)
+
+                    # 🔗 CREAR UNA FILA POR CADA COMBINACIÓN
+                    for i in range(max_records_per_key):
+                        row_data = {}
+
+                        # Campos de relación (mismos para todas las filas con esta clave)
+                        for rel_field, rel_value in relation_fields.items():
+                            row_data[rel_field] = self.safe_excel_value(rel_value)
+
+                        # Datos de cada modelo
+                        for model_name, records in model_records.items():
+                            # Si hay un registro en esta posición i
+                            if i < len(records):
+                                record = records[i]
+                                for field_name, value in record.items():
+                                    row_data[field_name] = value
+                            else:
+                                # Si no hay más registros para este modelo, poner campos vacíos
+                                for field_name in model_field_mappings.get(model_name, []):
+                                    if field_name in ['seccion_aduanera', 'patente', 'pedimento', 'organizacion_id']:
+                                        # Los campos de relación ya están llenados o transformados
+                                        continue
+                                    prefixed_field_name = f"{model_name}_{field_name}"
+                                    # 🔥 RENOMBRAR organizacion_id a organizacion_nombre
+                                    if field_name == 'organizacion_id':
+                                        prefixed_field_name = prefixed_field_name.replace('organizacion_id', 'organizacion_nombre')
+                                    row_data[prefixed_field_name] = ''
+
+                        combined_rows.append(row_data)
+
+                # 3. Determinar todos los campos únicos para los encabezados
+                all_fields_set = set()
+
+                # Campos de relación primero
+                common_relation_fields = ['seccion_aduanera', 'patente', 'pedimento']
+
+                # Agregar todos los campos de todas las filas
+                for row in combined_rows:
+                    all_fields_set.update(row.keys())
+
+                # Ordenar campos: relación primero, luego alfabéticamente
+                all_fields = []
+                for rel_field in common_relation_fields:
+                    if rel_field in all_fields_set:
+                        all_fields.append(rel_field)
+                        all_fields_set.remove(rel_field)
+
+                # 🔥 Mover organizacion_nombre cerca de los campos de relación
+                org_fields = [f for f in all_fields_set if 'organizacion' in f.lower()]
+                for org_field in sorted(org_fields):
+                    all_fields.append(org_field)
+                    all_fields_set.remove(org_field)
+
+                # Agregar el resto de campos ordenados alfabéticamente
+                all_fields.extend(sorted(all_fields_set))
+
+                total_records = len(combined_rows)
+
+                # 4. Manejar particionado
+                from django.core.paginator import Paginator
+                paginator = Paginator(combined_rows, self.MAX_RECORDS_PER_FILE)
+
+                for page_num in paginator.page_range:
+                    page = paginator.page(page_num)
+
+                    # Crear nuevo workbook para cada partición
+                    current_wb = openpyxl.Workbook()
+                    current_ws = current_wb.active
+
+                    # Nombre de hoja limitado a 31 caracteres
+                    sheet_name = f"Datastage_p{page_num}"
+                    if len(sheet_name) > 31:
+                        sheet_name = sheet_name[:31]
+                    current_ws.title = sheet_name
+
+                    # Escribir encabezados
+                    current_ws.append(all_fields)
+
+                    # Escribir datos de esta página
+                    for row_data in page.object_list:
+                        row_values = [row_data.get(field, '') for field in all_fields]
+                        current_ws.append(row_values)
+
+                    # Autoajustar anchos de columna
+                    for column in current_ws.columns:
+                        max_length = 0
+                        column_letter = column[0].column_letter
+
+                        for cell in column:
+                            try:
+                                if len(str(cell.value)) > max_length:
+                                    max_length = len(str(cell.value))
+                            except:
+                                pass
+                            
+                        adjusted_width = min(max_length + 2, 50)
+                        current_ws.column_dimensions[column_letter].width = adjusted_width
+
+                    # Guardar archivo en ZIP
+                    part_buffer = io.BytesIO()
+                    current_wb.save(part_buffer)
+                    part_buffer.seek(0)
+                    zip_file.writestr(f"datastage_part{page_num}.xlsx", part_buffer.getvalue())
+
+                    # Información de depuración
+                    print(f"Creada partición {page_num} con {len(page.object_list)} registros combinados")
+                    print(f"Total de claves únicas: {len(all_models_data)}")
+                    print(f"Total de filas expandidas: {total_records}")
+
+            zip_buffer.seek(0)
+
+            response = HttpResponse(zip_buffer.read(), content_type='application/zip')
+            response['Content-Disposition'] = 'attachment; filename="datastage_combinado.zip"'
+            return response
+
+        except Exception as e:
+            import traceback
+            error_details = traceback.format_exc()
+            print(f"Error en exportación: {error_details}")
+            return Response({'error': f'Error en exportación combinada: {str(e)}'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
+        
+
+    def export_datastage_multiple_partitioned_excel_test_3(self, request, models_data, global_filters, related_keys):
+        """Exporta múltiples modelos de DataStage agrupados en la misma hoja de Excel, con particionado por límite de registros"""
+        try:
+            zip_buffer = io.BytesIO()
+
+            with zipfile.ZipFile(zip_buffer, 'w', zipfile.ZIP_DEFLATED) as zip_file:
+                
+                # 1. Recopilar todos los datos de cada modelo
+                all_models_data = {}  # Ahora será una lista por clave
+                model_field_mappings = {}
+
+                for model_data in models_data:
+                    model_name = model_data.get('model')
+                    fields = model_data.get('fields', [])
+
+                    if not model_name or not fields:
+                        continue
+                    
+                    # Asegurar que tenemos los campos de relación
+                    required_fields = ['seccion_aduanera', 'patente', 'pedimento']
+                    for field in required_fields:
+                        if field not in fields:
+                            fields.append(field)
+
+                    try:
+                        model = apps.get_model('datastage', model_name)
+                        filters = self.apply_related_filters(global_filters, model, related_keys, request.user)
+
+                        if filters:
+                            queryset = model.objects.filter(**filters).values(*fields)
+                        else:
+                            queryset = model.objects.none()
+
+                        total_records = queryset.count()
+
+                        if total_records == 0:
+                            continue
+                        
+                        # Determinar campos de relación disponibles en este modelo
+                        relation_fields = []
+                        for field_name in ['seccion_aduanera', 'patente', 'pedimento']:
+                            if field_name in fields:
+                                relation_fields.append(field_name)
+
+                        if not relation_fields:
+                            # Si no hay campos de relación, usar un identificador único
+                            relation_fields = ['datastage_id'] if 'datastage_id' in fields else [fields[0]]
+
+                        # Guardar mapeo de campos para este modelo
+                        if model_name not in model_field_mappings:
+                            model_field_mappings[model_name] = fields
+
+                        # Procesar cada registro
+                        for record in queryset:
+                            # Crear clave de relación
+                            key_parts = []
+                            for rel_field in relation_fields:
+                                if rel_field in record and record[rel_field] is not None:
+                                    key_parts.append(str(record[rel_field]))
+
+                            if not key_parts:
+                                # Si no hay campos de relación, usar un hash del registro
+                                import hashlib
+                                record_str = str(sorted(record.items()))
+                                key = hashlib.md5(record_str.encode()).hexdigest()[:10]
+                            else:
+                                key = "_".join(key_parts)
+
+                            # Agregar prefijo del modelo a los campos para evitar colisiones
+                            prefixed_fields = {}
+                            for field_name, value in record.items():
+                                # Solo agregar prefijo si no es un campo de relación
+                                if field_name in relation_fields:
+                                    prefixed_field_name = field_name
+                                else:
+                                    prefixed_field_name = f"{model_name}_{field_name}"
+                                prefixed_fields[prefixed_field_name] = self.safe_excel_value(value)
+
+                            # 🔥 CORRECIÓN: Ahora almacenamos una LISTA de registros por clave
+                            if key not in all_models_data:
+                                all_models_data[key] = {
+                                    'relation_fields': {},  # Campos de relación compartidos
+                                    'model_records': {}     # Diccionario de listas por modelo
+                                }
+
+                            # Guardar campos de relación (solo una vez, ya que son los mismos)
+                            for rel_field in relation_fields:
+                                if rel_field in record:
+                                    all_models_data[key]['relation_fields'][rel_field] = record[rel_field]
+
+                            # 🔥 GUARDAR COMO LISTA: Crear lista si no existe
+                            if model_name not in all_models_data[key]['model_records']:
+                                all_models_data[key]['model_records'][model_name] = []
+
+                            # Agregar este registro a la lista del modelo
+                            all_models_data[key]['model_records'][model_name].append(prefixed_fields)
+
+                    except LookupError:
+                        continue
+                    
+                # Si no hay datos, retornar error
+                if not all_models_data:
+                    return Response({'error': 'No se encontraron datos para exportar'}, status=status.HTTP_404_NOT_FOUND)
+
+                # 2. Crear estructura de filas combinadas
+                # Ahora necesitamos expandir las filas cuando hay múltiples registros con la misma clave
+                combined_rows = []
+
+                for key, data in all_models_data.items():
+                    relation_fields = data['relation_fields']
+                    model_records = data['model_records']
+
+                    # 🔥 NUEVO: Calcular cuántas filas necesitamos para esta clave
+                    # Encontrar el modelo con más registros para esta clave
+                    max_records_per_key = 1
+                    for model_name, records in model_records.items():
+                        if len(records) > max_records_per_key:
+                            max_records_per_key = len(records)
+
+                    # 🔗 CREAR UNA FILA POR CADA COMBINACIÓN
+                    for i in range(max_records_per_key):
+                        row_data = {}
+
+                        # Campos de relación (mismos para todas las filas con esta clave)
+                        for rel_field, rel_value in relation_fields.items():
+                            row_data[rel_field] = self.safe_excel_value(rel_value)
+
+                        # Datos de cada modelo
+                        for model_name, records in model_records.items():
+                            # Si hay un registro en esta posición i
+                            if i < len(records):
+                                record = records[i]
+                                for field_name, value in record.items():
+                                    row_data[field_name] = value
+                            else:
+                                # Si no hay más registros para este modelo, poner campos vacíos
+                                for field_name in model_field_mappings.get(model_name, []):
+                                    if field_name in ['seccion_aduanera', 'patente', 'pedimento']:
+                                        # Los campos de relación ya están llenados
+                                        continue
+                                    prefixed_field_name = f"{model_name}_{field_name}"
+                                    row_data[prefixed_field_name] = ''
+
+                        combined_rows.append(row_data)
+
+                # 3. Determinar todos los campos únicos para los encabezados
+                all_fields_set = set()
+
+                # Campos de relación primero
+                common_relation_fields = ['seccion_aduanera', 'patente', 'pedimento']
+
+                # Agregar todos los campos de todas las filas
+                for row in combined_rows:
+                    all_fields_set.update(row.keys())
+
+                # Ordenar campos: relación primero, luego alfabéticamente
+                all_fields = []
+                for rel_field in common_relation_fields:
+                    if rel_field in all_fields_set:
+                        all_fields.append(rel_field)
+                        all_fields_set.remove(rel_field)
+
+                # Agregar el resto de campos ordenados alfabéticamente
+                all_fields.extend(sorted(all_fields_set))
+
+                total_records = len(combined_rows)
+
+                # 4. Manejar particionado
+                from django.core.paginator import Paginator
+                paginator = Paginator(combined_rows, self.MAX_RECORDS_PER_FILE)
+
+                for page_num in paginator.page_range:
+                    page = paginator.page(page_num)
+
+                    # Crear nuevo workbook para cada partición
+                    current_wb = openpyxl.Workbook()
+                    current_ws = current_wb.active
+
+                    # Nombre de hoja limitado a 31 caracteres
+                    sheet_name = f"Datastage_p{page_num}"
+                    if len(sheet_name) > 31:
+                        sheet_name = sheet_name[:31]
+                    current_ws.title = sheet_name
+
+                    # Escribir encabezados
+                    current_ws.append(all_fields)
+
+                    # Escribir datos de esta página
+                    for row_data in page.object_list:
+                        row_values = [row_data.get(field, '') for field in all_fields]
+                        current_ws.append(row_values)
+
+                    # Autoajustar anchos de columna
+                    for column in current_ws.columns:
+                        max_length = 0
+                        column_letter = column[0].column_letter
+
+                        for cell in column:
+                            try:
+                                if len(str(cell.value)) > max_length:
+                                    max_length = len(str(cell.value))
+                            except:
+                                pass
+                            
+                        adjusted_width = min(max_length + 2, 50)
+                        current_ws.column_dimensions[column_letter].width = adjusted_width
+
+                    # Guardar archivo en ZIP
+                    part_buffer = io.BytesIO()
+                    current_wb.save(part_buffer)
+                    part_buffer.seek(0)
+                    zip_file.writestr(f"datastage_part{page_num}.xlsx", part_buffer.getvalue())
+
+                    # Información de depuración
+                    print(f"Creada partición {page_num} con {len(page.object_list)} registros combinados")
+                    print(f"Total de claves únicas: {len(all_models_data)}")
+                    print(f"Total de filas expandidas: {total_records}")
+
+            zip_buffer.seek(0)
+
+            response = HttpResponse(zip_buffer.read(), content_type='application/zip')
+            response['Content-Disposition'] = 'attachment; filename="datastage_combinado.zip"'
+            return response
+
+        except Exception as e:
+            import traceback
+            error_details = traceback.format_exc()
+            print(f"Error en exportación: {error_details}")
+            return Response({'error': f'Error en exportación combinada: {str(e)}'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
+
+
+
+    def export_datastage_multiple_partitioned_excel_test_2(self, request, models_data, global_filters, related_keys):
+        """Exporta múltiples modelos de DataStage agrupados en la misma hoja de Excel, con particionado por límite de registros"""
+        try:
+            zip_buffer = io.BytesIO()
+
+            with zipfile.ZipFile(zip_buffer, 'w', zipfile.ZIP_DEFLATED) as zip_file:
+
+                # 1. Recopilar todos los datos de cada modelo por clave (aduana, patente, pedimento)
+                all_models_data = {}
+                model_field_mappings = {}
+
+                for model_data in models_data:
+                    model_name = model_data.get('model')
+                    fields = model_data.get('fields', [])
+
+                    if not model_name or not fields:
+                        continue
+                    
+                    required_fields = ['seccion_aduanera', 'patente', 'pedimento']
+
+                    for field in required_fields:
+                        if field not in fields:
+                            fields.append(field)
+
+                    try:
+                        model = apps.get_model('datastage', model_name)
+                        filters = self.apply_related_filters(global_filters, model, related_keys, request.user)
+
+                        if filters:
+                            queryset = model.objects.filter(**filters).values(*fields)
+                        else:
+                            queryset = model.objects.none()
+
+                        total_records = queryset.count()
+
+                        if total_records == 0:
+                            continue
+                        
+                        # Determinar campos de relación disponibles en este modelo
+                        relation_fields = []
+                        for field_name in ['seccion_aduanera', 'patente', 'pedimento']:
+                            if field_name in fields:
+                                relation_fields.append(field_name)
+
+                        if not relation_fields:
+                            # Si no hay campos de relación, usar un identificador único
+                            relation_fields = ['datastage_id'] if 'datastage_id' in fields else [fields[0]]
+
+                        # Procesar cada registro
+                        for record in queryset:
+                            # Crear clave de relación
+                            key_parts = []
+                            for rel_field in relation_fields:
+                                if rel_field in record and record[rel_field] is not None:
+                                    key_parts.append(str(record[rel_field]))
+
+                            if not key_parts:
+                                # Si no hay campos de relación, usar un hash del registro
+                                import hashlib
+                                record_str = str(sorted(record.items()))
+                                key = hashlib.md5(record_str.encode()).hexdigest()[:10]
+                            else:
+                                key = "_".join(key_parts)
+
+                            # Agregar prefijo del modelo a los campos para evitar colisiones
+                            prefixed_fields = {}
+                            for field_name, value in record.items():
+                                prefixed_field_name = f"{model_name}_{field_name}"
+                                prefixed_fields[prefixed_field_name] = self.safe_excel_value(value)
+                                # Registrar mapeo de campos
+                                if model_name not in model_field_mappings:
+                                    model_field_mappings[model_name] = []
+                                if field_name not in model_field_mappings[model_name]:
+                                    model_field_mappings[model_name].append(field_name)
+
+                            # Guardar datos bajo la clave
+                            if key not in all_models_data:
+                                all_models_data[key] = {
+                                    'relation_fields': {},
+                                    'model_data': {}
+                                }
+
+                            # Guardar campos de relación
+                            for rel_field in relation_fields:
+                                if rel_field in record:
+                                    all_models_data[key]['relation_fields'][rel_field] = record[rel_field]
+
+                            # Guardar datos del modelo
+                            all_models_data[key]['model_data'][model_name] = prefixed_fields
+
+                    except LookupError:
+                        continue
+                    
+                # Si no hay datos, retornar error
+                if not all_models_data:
+                    return Response({'error': 'No se encontraron datos para exportar'}, status=status.HTTP_404_NOT_FOUND)
+
+                # 2. Determinar todos los campos únicos que necesitaremos
+                all_fields_set = set()
+
+                # Primero agregar campos de relación comunes
+                common_relation_fields = ['seccion_aduanera', 'patente', 'pedimento']
+
+                for key, data in all_models_data.items():
+                    # Agregar campos de relación
+                    for rel_field in common_relation_fields:
+                        if rel_field in data['relation_fields']:
+                            all_fields_set.add(rel_field)
+
+                    # Agregar campos de todos los modelos para esta clave
+                    for model_name, model_fields in data['model_data'].items():
+                        for field_name in model_fields.keys():
+                            all_fields_set.add(field_name)
+
+                # Convertir a lista ordenada (campos de relación primero)
+                all_fields = []
+                for rel_field in common_relation_fields:
+                    if rel_field in all_fields_set:
+                        all_fields.append(rel_field)
+                        all_fields_set.remove(rel_field)
+
+                # Luego agregar el resto de campos ordenados alfabéticamente
+                all_fields.extend(sorted(all_fields_set))
+
+                # 3. Crear datos combinados por fila
+                combined_rows = []
+
+                for key, data in all_models_data.items():
+                    row_data = {}
+
+                    # Campos de relación
+                    for rel_field in common_relation_fields:
+                        if rel_field in data['relation_fields']:
+                            row_data[rel_field] = self.safe_excel_value(data['relation_fields'][rel_field])
+                        else:
+                            row_data[rel_field] = ''
+
+                    # Datos de cada modelo
+                    for model_name, model_fields in data['model_data'].items():
+                        for field_name, value in model_fields.items():
+                            row_data[field_name] = value
+
+                    # Rellenar campos faltantes con vacío
+                    for field in all_fields:
+                        if field not in row_data:
+                            row_data[field] = ''
+
+                    combined_rows.append(row_data)
+
+                total_records = len(combined_rows)
+
+                # 4. Manejar particionado
+                from django.core.paginator import Paginator
+                paginator = Paginator(combined_rows, self.MAX_RECORDS_PER_FILE)
+
+                for page_num in paginator.page_range:
+                    page = paginator.page(page_num)
+
+                    # Crear nuevo workbook para cada partición
+                    current_wb = openpyxl.Workbook()
+                    current_ws = current_wb.active
+
+                    # Nombre de hoja limitado a 31 caracteres
+                    sheet_name = f"Datastage_p{page_num}"
+                    if len(sheet_name) > 31:
+                        sheet_name = sheet_name[:31]
+                    current_ws.title = sheet_name
+
+                    # Escribir encabezados
+                    current_ws.append(all_fields)
+
+                    # Escribir datos de esta página
+                    for row_data in page.object_list:
+                        row_values = [row_data.get(field, '') for field in all_fields]
+                        current_ws.append(row_values)
+
+                    # Autoajustar anchos de columna (opcional)
+                    for column in current_ws.columns:
+                        max_length = 0
+                        column_letter = column[0].column_letter
+
+                        for cell in column:
+                            try:
+                                if len(str(cell.value)) > max_length:
+                                    max_length = len(str(cell.value))
+                            except:
+                                pass
+                            
+                        adjusted_width = min(max_length + 2, 50)  # Máximo 50 caracteres
+                        current_ws.column_dimensions[column_letter].width = adjusted_width
+
+                    # Guardar archivo en ZIP
+                    part_buffer = io.BytesIO()
+                    current_wb.save(part_buffer)
+                    part_buffer.seek(0)
+                    zip_file.writestr(f"datastage_part{page_num}.xlsx", part_buffer.getvalue())
+
+                    # Información de depuración
+                    print(f"Creada partición {page_num} con {len(page.object_list)} registros combinados")
+
+            zip_buffer.seek(0)
+
+            response = HttpResponse(zip_buffer.read(), content_type='application/zip')
+            response['Content-Disposition'] = 'attachment; filename="datastage_combinado.zip"'
+            return response
+
+        except Exception as e:
+            import traceback
+            error_details = traceback.format_exc()
+            print(f"Error en exportación: {error_details}")
+            return Response({'error': f'Error en exportación combinada: {str(e)}'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR) 
+
+
+    def export_datastage_multiple_partitioned_excel_test(self, request, models_data, global_filters, related_keys):
+        """Exporta múltiples modelos de DataStage agrupados en la misma hoja de Excel, con particionado por límite de registros"""
+        try:
+            zip_buffer = io.BytesIO()
+
+            with zipfile.ZipFile(zip_buffer, 'w', zipfile.ZIP_DEFLATED) as zip_file:
+                file_counter = 1
+                current_wb = None
+                current_ws = None
+                current_record_count = 0
+                combined_fields = []  # Almacenar todos los campos únicos
+                combined_data = []    # Almacenar todos los datos
+
+                # 1. Primero recopilar todos los campos y datos
+                all_models_data = {}
+
+                for model_data in models_data:
+                    model_name = model_data.get('model')
+                    fields = model_data.get('fields', [])
+
+                    if not model_name or not fields:
+                        continue
+
+                    try:
+                        model = apps.get_model('datastage', model_name)
+                        filters = self.apply_related_filters(global_filters, model, related_keys, request.user)
+
+                        if filters:
+                            queryset = model.objects.filter(**filters).values(*fields)
+                        else:
+                            queryset = model.objects.none()
+
+                        total_records = queryset.count()
+
+                        if total_records == 0:
+                            continue
+                        
+                        # Almacenar los datos de este modelo
+                        all_models_data[model_name] = {
+                            'fields': fields,
+                            'data': list(queryset),
+                            'total_records': total_records
+                        }
+
+                        # Agregar campos únicos a la lista combinada
+                        for field in fields:
+                            if field not in combined_fields:
+                                combined_fields.append(field)
+
+                    except LookupError:
+                        continue
+                    
+                # Si no hay datos, retornar error
+                if not all_models_data:
+                    return Response({'error': 'No se encontraron datos para exportar'}, status=status.HTTP_404_NOT_FOUND)
+
+                # 2. Crear estructura de datos combinada
+                # Primero, preparar los datos combinados
+                for model_name, model_info in all_models_data.items():
+                    fields = model_info['fields']
+                    data = model_info['data']
+
+                    for record in data:
+                        combined_record = {}
+
+                        # Para cada campo en la lista combinada
+                        for combined_field in combined_fields:
+                            if combined_field in fields:
+                                # Si el campo existe en este modelo, usar su valor
+                                value = record.get(combined_field)
+                                combined_record[combined_field] = self.safe_excel_value(value)
+                            else:
+                                # Si no existe, poner vacío
+                                combined_record[combined_field] = ''
+
+                        # Agregar columna para identificar el modelo origen
+                        combined_record['_modelo_origen'] = model_name
+
+                        combined_data.append(combined_record)
+
+                # Agregar campo de modelo origen a la lista de campos si no está ya
+                if '_modelo_origen' not in combined_fields:
+                    combined_fields.append('_modelo_origen')
+
+                total_combined_records = len(combined_data)
+
+                # 3. Manejar particionado
+                from django.core.paginator import Paginator
+                paginator = Paginator(combined_data, self.MAX_RECORDS_PER_FILE)
+
+                for page_num in paginator.page_range:
+                    page = paginator.page(page_num)
+
+                    # Crear nuevo workbook para cada partición
+                    current_wb = openpyxl.Workbook()
+                    current_ws = current_wb.active
+                    current_ws.title = f"Todos_Modelos_p{page_num}"[:31]
+
+                    # Escribir encabezados
+                    current_ws.append(combined_fields)
+
+                    # Escribir datos de esta página
+                    for record in page.object_list:
+                        row_values = [record.get(field, '') for field in combined_fields]
+                        current_ws.append(row_values)
+
+                    # Guardar archivo en ZIP
+                    part_buffer = io.BytesIO()
+                    current_wb.save(part_buffer)
+                    part_buffer.seek(0)
+                    zip_file.writestr(f"datastage_combinado_part{page_num}.xlsx", part_buffer.getvalue())
+
+                    # Información de depuración (opcional)
+                    print(f"Creada partición {page_num} con {len(page.object_list)} registros")
+
+            zip_buffer.seek(0)
+
+            response = HttpResponse(zip_buffer.read(), content_type='application/zip')
+            response['Content-Disposition'] = 'attachment; filename="datastage_combinado.zip"'
+            return response
+
+        except Exception as e:
+            import traceback
+            error_details = traceback.format_exc()
+            print(f"Error en exportación: {error_details}")
+            return Response({'error': f'Error en exportación combinada: {str(e)}'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR) 
 
     def export_datastage_multiple_partitioned_excel(self, request, models_data, global_filters, related_keys):
         """Exporta múltiples modelos de DataStage a múltiples archivos Excel particionados inteligentemente"""