Merge pull request 'fix/de los tickets T2026-05-027, T2025-09-004 y T2025-09-056' (#35) from fix/T2026-05-027-and-T2025-09-004-and-T2025-09-056 into main

Reviewed-on: #35

api/cards/views.py

@@ -11,6 +11,7 @@ from core.permissions import (
     get_org_context,
     require_permission,
     user_has_permission,
+    user_has_role,
 )
 
 from api.organization.models import UsoAlmacenamiento, Organizacion
@@ -136,20 +137,28 @@ class ViewPedimentoServicesUtilInformation(LoggingMixin, APIView, FiltroPorOrgan
     )
 
     def get_queryset(self):
-        if not self.request.user.is_authenticated or not hasattr(self.request.user, 'organizacion'):
+        user = self.request.user
+        if not user.is_authenticated or not hasattr(user, 'organizacion'):
             return None
-        
-        org = get_org_context(self.request.user)
+
+        org = get_org_context(user)
         if not org:
             return ProcesamientoPedimento.objects.none()
 
-        if self.request.user.is_importador:
-            return ProcesamientoPedimento.objects.filter(
-                pedimento__organizacion=org,
-                pedimento__contribuyente__in=self.request.user.rfc.all(),
-            )
-
-        return ProcesamientoPedimento.objects.filter(pedimento__organizacion=org)
+        qs = ProcesamientoPedimento.objects.filter(pedimento__organizacion=org)
+        # Misma precedencia que los mixins de filtrado: superuser y roles
+        # operativos ven todo lo de su org; is_importador no los degrada.
+        if (
+            user.is_superuser or
+            user_has_role(user, 'admin') or
+            user_has_role(user, 'developer') or
+            user_has_role(user, 'Agente Aduanal') or
+            user_has_role(user, 'user')
+        ):
+            return qs
+        if user.is_importador:
+            return qs.filter(pedimento__contribuyente__in=user.rfc.all())
+        return ProcesamientoPedimento.objects.none()
 
     def get(self, request):
         queryset = self.get_queryset()

api/cuser/hub_auth.py

@@ -0,0 +1,239 @@
+"""
+Autenticación vía Hub de Aduanasoft (Keycloak).
+Tokens locales HS256 (~700 bytes) se emiten tras el exchange con el Hub
+para no exceder el límite de 4096 bytes de cookies del browser.
+
+ORDEN CRÍTICO en verify_hub_token:
+  cache → local HS256 → Hub /auth/me
+Si el token local se manda al Hub primero, Hub responde 401 y rompe la
+sesión SSO silenciosamente.
+"""
+import logging
+import time
+from typing import Optional
+
+import jwt
+import requests
+from django.conf import settings
+from rest_framework.authentication import BaseAuthentication
+from rest_framework.exceptions import AuthenticationFailed
+
+logger = logging.getLogger(__name__)
+
+# Cache en memoria: {token: (payload, expires_at)}
+_token_cache: dict = {}
+_CACHE_TTL = 60  # segundos
+
+
+def _cache_get(token: str) -> Optional[dict]:
+    entry = _token_cache.get(token)
+    if entry and entry[1] > time.time():
+        return entry[0]
+    _token_cache.pop(token, None)
+    return None
+
+
+def _cache_set(token: str, payload: dict):
+    _token_cache[token] = (payload, time.time() + _CACHE_TTL)
+
+
+# ---------------------------------------------------------------------------
+# Tokens locales
+# ---------------------------------------------------------------------------
+
+def create_local_tokens(user_data: dict) -> dict:
+    """Emite tokens locales compactos HS256. Caben en cookies del browser."""
+    import uuid
+    from datetime import datetime, timedelta, timezone
+
+    now = datetime.now(timezone.utc)
+    base = {
+        "sub":                str(user_data.get("id") or user_data.get("username", "")),
+        "preferred_username": user_data.get("username", ""),
+        "email":              user_data.get("email", ""),
+        "name":               user_data.get("name", ""),
+        "given_name":         user_data.get("first_name", ""),
+        "family_name":        user_data.get("last_name", ""),
+        "is_hub_admin":       user_data.get("is_hub_admin", False),
+        "tenant_id":          user_data.get("tenant_id"),
+        "tenant_slug":        user_data.get("tenant_slug") or getattr(settings, "HUB_TENANT_SLUG", ""),
+        "source":             "local",
+        "iat":                int(now.timestamp()),
+    }
+    access_payload  = {**base, "exp": int((now + timedelta(hours=8)).timestamp())}
+    refresh_payload = {**base, "exp": int((now + timedelta(days=30)).timestamp())}
+    secret = settings.SECRET_KEY
+
+    return {
+        "access_token":  jwt.encode(access_payload,  secret, algorithm="HS256"),
+        "refresh_token": jwt.encode(refresh_payload, secret, algorithm="HS256"),
+        "expires_in":    1800,
+        "source":        "local",
+    }
+
+
+def _verify_local_token(token: str) -> Optional[dict]:
+    """Decodifica token local HS256. Retorna payload o None si no es local."""
+    try:
+        payload = jwt.decode(token, settings.SECRET_KEY, algorithms=["HS256"])
+        if payload.get("source") == "local":
+            return payload
+        return None
+    except jwt.ExpiredSignatureError:
+        raise AuthenticationFailed("Token expirado — inicia sesión de nuevo")
+    except jwt.InvalidTokenError:
+        return None
+
+
+# ---------------------------------------------------------------------------
+# Verificación contra Hub
+# ---------------------------------------------------------------------------
+
+def verify_hub_token(token: str) -> dict:
+    """ORDEN: cache → local HS256 → Hub /auth/me."""
+    cached = _cache_get(token)
+    if cached:
+        return cached
+
+    # 1. Token local primero (evita 401 del Hub para tokens locales)
+    local = _verify_local_token(token)
+    if local:
+        _cache_set(token, local)
+        return local
+
+    # 2. Validar contra Hub
+    hub_url = getattr(settings, "HUB_URL", "https://workspace.aduanasoft.com")
+    me_url  = f"{hub_url.rstrip('/')}/api/v1/auth/me"
+    try:
+        r = requests.get(me_url, headers={"Authorization": f"Bearer {token}"}, timeout=5)
+    except requests.exceptions.RequestException as exc:
+        # Fallback: si hay token local válido lo usamos
+        local = _verify_local_token(token)
+        if local:
+            _cache_set(token, local)
+            return local
+        logger.error("Hub no disponible: %s", exc)
+        raise AuthenticationFailed("Servicio de autenticación no disponible")
+
+    if r.status_code == 200:
+        info = r.json()
+        _cache_set(token, info)
+        return info
+
+    if r.status_code in (401, 403):
+        raise AuthenticationFailed("Token inválido o sesión expirada")
+
+    logger.error("Hub respondió %s al verificar token", r.status_code)
+    raise AuthenticationFailed("No se pudo verificar el token")
+
+
+def _get_django_user(hub_data: dict):
+    """Resuelve el CustomUser de Django a partir de los datos del Hub."""
+    from api.cuser.models import CustomUser
+
+    # Token local: sub puede ser Django UUID (login directo) o KC UUID (SSO exchange)
+    if hub_data.get("source") == "local":
+        from django.db.models import Q
+        sub = hub_data.get("sub", "")
+        if not sub:
+            return None
+        # Una sola query: busca por Django UUID o KC UUID simultáneamente
+        try:
+            return CustomUser.objects.filter(
+                Q(id=sub) | Q(keycloak_user_id=sub)
+            ).first()
+        except Exception:
+            # sub malformado (no es UUID válido)
+            return CustomUser.objects.filter(keycloak_user_id=sub).first()
+
+    # Token Hub: buscar por keycloak_user_id → email
+    kc_id = hub_data.get("keycloak_user_id") or hub_data.get("sub")
+    email = hub_data.get("email")
+
+    if kc_id:
+        user = CustomUser.objects.filter(keycloak_user_id=kc_id).first()
+        if user:
+            return user
+
+    if email:
+        return CustomUser.objects.filter(email=email).first()
+
+    return None
+
+
+# ---------------------------------------------------------------------------
+# DRF Authentication Backend
+# ---------------------------------------------------------------------------
+
+class HubAuthBackend(BaseAuthentication):
+    """
+    Drop-in para reemplazar JWTAuthentication.
+    Acepta tokens locales (HS256) y tokens del Hub indistintamente.
+    Se añade JUNTO a JWTAuthentication para compatibilidad durante la migración.
+    """
+
+    def authenticate(self, request):
+        token = self._extract_token(request)
+        if not token:
+            return None
+
+        # Detectar tokens SimpleJWT sin llamar al Hub.
+        # Decodificamos sin verificar firma solo para leer claims.
+        # Si el token no tiene source="local" ni claims de KC (realm_access, azp)
+        # es un token SimpleJWT legacy → dejar que JWTAuthentication lo maneje.
+        try:
+            unverified = jwt.decode(
+                token,
+                options={"verify_signature": False},
+                algorithms=["HS256", "RS256"],
+            )
+            is_hub_token = (
+                unverified.get("source") == "local"          # token local HS256
+                or "realm_access" in unverified               # token KC directo
+                or "azp" in unverified                        # token KC (authorized party)
+            )
+            if not is_hub_token:
+                return None  # SimpleJWT — pasar al siguiente backend sin tocar el Hub
+        except Exception:
+            return None  # JWT malformado — no es nuestro
+
+        try:
+            hub_data = verify_hub_token(token)
+        except AuthenticationFailed:
+            return None
+        except Exception as exc:
+            logger.error("Error inesperado en HubAuthBackend: %s", exc)
+            return None
+
+        user = _get_django_user(hub_data)
+        if not user:
+            # Retornar None permite que endpoints AllowAny pasen sin bloquear.
+            # Los endpoints IsAuthenticated quedarán como "no autenticado" (sin 401 engañoso).
+            return None
+
+        return (user, token)
+
+    @staticmethod
+    def _extract_token(request) -> Optional[str]:
+        auth_header = request.META.get("HTTP_AUTHORIZATION", "")
+        if auth_header.lower().startswith("bearer "):
+            return auth_header[7:].strip() or None
+        # Fallback: cookie (flujo SSO con cookies)
+        return request.COOKIES.get("access_token")
+
+    def authenticate_header(self, request):
+        return "Bearer"
+
+
+# ---------------------------------------------------------------------------
+# Helper cookies
+# ---------------------------------------------------------------------------
+
+def set_session_cookies(response, tokens: dict):
+    """Escribe las cookies de sesión HTTP-only."""
+    secure = getattr(settings, "COOKIE_SECURE", not settings.DEBUG)
+    kw = dict(httponly=True, secure=secure, samesite="Lax")
+    response.set_cookie("access_token",  tokens["access_token"],  max_age=1800,       **kw)
+    response.set_cookie("refresh_token", tokens["refresh_token"], max_age=60*60*24*7, **kw)
+    response.set_cookie("token_type",    "bearer",                max_age=60*60*24*7,
+                        httponly=False, secure=secure, samesite="Lax")

api/cuser/migrations/0007_customuser_keycloak_user_id.py

@@ -0,0 +1,18 @@
+# Generated by Django 5.2.3 on 2026-05-28 18:46
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('cuser', '0006_customuser_active_organization'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='customuser',
+            name='keycloak_user_id',
+            field=models.CharField(blank=True, help_text='UUID del usuario en Keycloak/Hub', max_length=36, null=True, unique=True),
+        ),
+    ]

api/cuser/models.py

@@ -25,6 +25,9 @@ class CustomUser(AbstractUser):
     is_importador = models.BooleanField(default=False, help_text="Indicates if the user is an importer")
     rfc = models.ManyToManyField('customs.Importador', blank=True, related_name='users', help_text="RFCs de importadores asociados al usuario")
 
+    # Identidad Keycloak — se llena con el script de migración masiva
+    keycloak_user_id = models.CharField(max_length=36, null=True, blank=True, unique=True, help_text="UUID del usuario en Keycloak/Hub")
+
     def __str__(self):
         return self.username
 

api/cuser/sso_urls.py

@@ -0,0 +1,11 @@
+from django.urls import path
+from .sso_views import login_view, sso_exchange_view, me_view, logout_view, refresh_view, session_refresh_view
+
+urlpatterns = [
+    path("login/",            login_view,            name="hub-login"),
+    path("sso/exchange/",     sso_exchange_view,     name="hub-sso-exchange"),
+    path("me/",               me_view,               name="hub-me"),
+    path("logout/",           logout_view,           name="hub-logout"),
+    path("login/refresh/",    refresh_view,          name="hub-refresh"),          # legacy
+    path("session/refresh/",  session_refresh_view,  name="hub-session-refresh"),  # cookie-based
+]

api/cuser/sso_views.py

@@ -0,0 +1,564 @@
+"""
+Vistas SSO para integración con Hub de Aduanasoft.
+Cuatro endpoints:
+  POST /api/v1/auth/login/          — login directo email/password (proxy Hub)
+  POST /api/v1/auth/sso/exchange/   — canjea relay token por sesión local
+  GET  /api/v1/auth/me/             — usuario autenticado actual
+  POST /api/v1/auth/logout/         — cierra sesión (limpia cookies)
+"""
+import logging
+import re
+from typing import Optional
+
+import requests as http
+from django.conf import settings
+from rest_framework import status
+from rest_framework.decorators import api_view, permission_classes
+from rest_framework.permissions import AllowAny
+from rest_framework.response import Response
+
+from .hub_auth import (
+    create_local_tokens,
+    set_session_cookies,
+    verify_hub_token,
+    _get_django_user,
+)
+
+logger = logging.getLogger(__name__)
+
+HUB_URL = lambda: getattr(settings, "HUB_URL", "https://workspace.aduanasoft.com").rstrip("/")
+
+
+def _slug_from_nombre(nombre: str) -> str:
+    """Deriva un slug válido del nombre de la organización: "TEMEX S.A." → "temex"."""
+    return re.sub(r'[^a-z0-9]+', '-', nombre.lower()).strip('-')[:100]
+
+
+def _provision_user_in_hub(username: str, password: str) -> bool:
+    """
+    Crea/sincroniza el usuario en KC vía Hub /auth/provision-user.
+    Solo se llama cuando el usuario no tiene keycloak_user_id (first login).
+
+    Envía new_tenant=True: el Hub crea el tenant (y su licencia por defecto) si
+    aún no existe, usando el slug de la organización de EFC.
+    Flujo:
+      1. Obtener org del usuario → derivar/usar hub_tenant_slug
+      2. Provisionar al usuario; el Hub resuelve/crea el tenant y le asigna acceso
+    """
+    from django.db.models import Q
+    from api.cuser.models import CustomUser
+
+    user = CustomUser.objects.select_related('organizacion').filter(
+        Q(username=username) | Q(email=username),
+        is_active=True,
+    ).first()
+
+    if not user:
+        return False
+
+    org = user.organizacion
+    if not org:
+        logger.warning("[provision] Usuario %s sin organización asignada — omitiendo provisión", username)
+        return False
+
+    # Determinar slug del tenant: usar el guardado o derivarlo del nombre
+    tenant_slug = org.hub_tenant_slug
+    if not tenant_slug:
+        tenant_slug = _slug_from_nombre(org.nombre)
+        # Persistir para no recalcular en futuros logins
+        type(org).objects.filter(pk=org.pk).update(hub_tenant_slug=tenant_slug)
+        logger.info("[provision] Slug derivado para org '%s' → '%s'", org.nombre, tenant_slug)
+
+    provision_secret = getattr(settings, "HUB_PROVISION_SECRET", "")
+
+    # Rol del usuario en el tenant: si tiene el rol admin de su organización lo
+    # provisionamos como admin del tenant en Hub; de lo contrario, como operador.
+    from api.rbac.models import UserRole
+    is_org_admin = UserRole.objects.filter(user=user, role__is_admin_role=True).exists()
+    role = "admin" if is_org_admin else "operador"
+
+    try:
+        r = http.post(
+            f"{HUB_URL()}/api/v1/auth/provision-user",
+            # new_tenant=True → el Hub crea el tenant y su licencia si no existe.
+            json={
+                "username":     user.username,
+                "email":        user.email or f"{user.username}@efc.local",
+                "password":     password,
+                "first_name":   user.first_name or "",
+                "last_name":    user.last_name or "",
+                "tenant_slug":  tenant_slug,
+                "tenant_name":  org.nombre,
+                "product_slug": "efc",
+                "role":         role,
+                "new_tenant":   True,
+            },
+            headers={"X-Provision-Secret": provision_secret},
+            timeout=15,
+        )
+
+        if r.status_code == 200:
+            data = r.json()
+            # Hub devuelve access_token (JWT KC) — extraer sub = KC user UUID
+            kc_id = data.get("user_id") or data.get("keycloak_user_id")
+            if not kc_id:
+                try:
+                    import jwt as _jwt
+                    payload = _jwt.decode(
+                        data["access_token"],
+                        options={"verify_signature": False},
+                        algorithms=["RS256", "HS256"],
+                    )
+                    kc_id = payload.get("sub")
+                except Exception:
+                    pass
+
+            if kc_id:
+                CustomUser.objects.filter(pk=user.pk).update(keycloak_user_id=kc_id)
+                logger.info("[provision] Usuario %s → tenant '%s' — KC id: %s",
+                            user.username, tenant_slug, kc_id)
+            else:
+                logger.warning("[provision] No se pudo extraer KC UUID para %s", user.username)
+            return True
+
+        logger.error("[provision] Hub %s al provisionar %s: %s",
+                     r.status_code, username, r.text[:200])
+        return False
+
+    except http.exceptions.RequestException as exc:
+        logger.error("[provision] Error de red provisionando %s: %s", username, exc)
+        return False
+
+
+def _verify_password_against_hub(username: str, password: str) -> bool:
+    """
+    Verifica credenciales contra el Hub (KC vía /auth/login).
+    Se usa cuando el login local falla para usuarios traídos del Hub vía SSO,
+    que no tienen contraseña local usable. Retorna True solo si el Hub responde 200.
+    """
+    try:
+        r = http.post(
+            f"{HUB_URL()}/api/v1/auth/login",
+            json={"username": username, "password": password},
+            timeout=15,
+        )
+    except http.exceptions.RequestException as exc:
+        logger.error("[login] Error de red verificando credenciales en Hub para %s: %s", username, exc)
+        return False
+    # 200 = credenciales válidas (tokens o selector de tenant). 401 = inválidas.
+    return r.status_code == 200
+
+
+def _extract_token(request) -> Optional[str]:
+    auth = request.META.get("HTTP_AUTHORIZATION", "")
+    if auth.lower().startswith("bearer "):
+        t = auth[7:].strip()
+        if t:
+            return t
+    return request.COOKIES.get("access_token")
+
+
+# ---------------------------------------------------------------------------
+# Helpers SSO: auto-provisión Hub → EFC
+# ---------------------------------------------------------------------------
+
+def _ensure_efc_organization(tenant_slug: str, tenant_name: str = None):
+    """
+    Devuelve (org, created). Si no existe, la crea con datos mínimos.
+    El nombre viene del Hub (tenant_name); si no llega, se deriva del slug.
+    El admin completa RFC, etc. desde el panel de Django.
+    """
+    from api.organization.models import Organizacion
+    from api.licence.models import Licencia
+
+    org = Organizacion.objects.filter(hub_tenant_slug=tenant_slug).first()
+    if org:
+        return org, False
+
+    licencia, _ = Licencia.objects.get_or_create(
+        nombre='Hub SSO Default',
+        defaults={'almacenamiento': 0},
+    )
+    org = Organizacion.objects.create(
+        hub_tenant_slug=tenant_slug,
+        nombre=(tenant_name or '').strip() or tenant_slug.upper().replace('-', ' '),
+        licencia=licencia,
+        rfc='XAXX010101000',
+        titular='',
+        email='',
+        telefono='',
+        estado='',
+        ciudad='',
+        is_active=True,
+    )
+    logger.info("[sso] Organizacion creada para tenant Hub '%s'", tenant_slug)
+    return org, True
+
+
+def _ensure_efc_user(hub_data: dict, org):
+    """
+    Devuelve (user, created). Si no existe, lo crea vinculado a la organización.
+    Si ya existe pero le falta el KC id o la org, los completa.
+    """
+    from django.db.models import Q
+    from api.cuser.models import CustomUser
+
+    kc_id    = hub_data.get('user_id')
+    email    = hub_data.get('email', '')
+    username = (hub_data.get('preferred_username') or email or '').strip()
+
+    user = None
+    if kc_id:
+        user = CustomUser.objects.filter(keycloak_user_id=kc_id).first()
+    if not user and (email or username):
+        user = CustomUser.objects.filter(
+            Q(email=email) | Q(username=username)
+        ).first()
+
+    if user:
+        updates = {}
+        if kc_id and not user.keycloak_user_id:
+            updates['keycloak_user_id'] = kc_id
+        if org and not user.organizacion_id:
+            updates['organizacion'] = org
+        if updates:
+            CustomUser.objects.filter(pk=user.pk).update(**updates)
+        return user, False
+
+    # Usuario nuevo — contraseña inutilizable (solo SSO)
+    name   = (hub_data.get('name') or '').strip()
+    parts  = name.split(' ', 1) if name else []
+    first  = parts[0] if parts else ''
+    last   = parts[1] if len(parts) > 1 else ''
+
+    user = CustomUser.objects.create_user(
+        username=username,
+        email=email,
+        first_name=first,
+        last_name=last,
+        password=None,
+        is_active=True,
+        keycloak_user_id=kc_id,
+        organizacion=org,
+    )
+    logger.info("[sso] Usuario '%s' creado desde Hub SSO → org '%s'",
+                username, org.nombre if org else 'sin org')
+    return user, True
+
+
+def _assign_admin_role(user, org):
+    """Asigna el rol admin de la org al usuario. No-op si ya lo tiene."""
+    from api.rbac.models import OrganizationRole, UserRole
+    try:
+        admin_role = OrganizationRole.objects.get(organizacion=org, nombre='admin')
+        _, assigned = UserRole.objects.get_or_create(user=user, role=admin_role)
+        if assigned:
+            logger.info("[sso] Rol admin asignado a '%s' en org '%s'", user.username, org.nombre)
+    except OrganizationRole.DoesNotExist:
+        logger.warning("[sso] Rol admin no encontrado para org '%s' — ¿signals ejecutados?", org.nombre)
+
+
+# ---------------------------------------------------------------------------
+# POST /api/v1/auth/login/
+# ---------------------------------------------------------------------------
+
+@api_view(["POST"])
+@permission_classes([AllowAny])
+def login_view(request):
+    """
+    Login directo con Django auth + SimpleJWT.
+    No llama al Hub en cada login — solo la primera vez si el usuario
+    no tiene keycloak_user_id (provisión one-shot transparente).
+    """
+    from django.contrib.auth import authenticate as django_auth
+    from django.db.models import Q
+    from api.cuser.models import CustomUser
+    from rest_framework_simplejwt.tokens import RefreshToken
+
+    username = request.data.get("username", "").strip()
+    password = request.data.get("password", "")
+
+    if not username or not password:
+        return Response({"detail": "username y password son requeridos"},
+                        status=status.HTTP_400_BAD_REQUEST)
+
+    user = django_auth(request, username=username, password=password)
+
+    if not user:
+        user_by_email = CustomUser.objects.filter(
+            Q(email=username), is_active=True
+        ).first()
+        if user_by_email:
+            user = django_auth(request, username=user_by_email.username, password=password)
+
+    # Fallback Hub: los usuarios traídos del Hub vía SSO se crean sin contraseña local
+    # usable (set_unusable_password), así que django_auth falla. Si el usuario está
+    # vinculado al Hub (keycloak_user_id), verificamos la contraseña contra el Hub y, si
+    # es válida, la "localizamos" en EFC para que los próximos logins sean directos.
+    if not user:
+        hub_user = CustomUser.objects.filter(
+            Q(username=username) | Q(email=username), is_active=True
+        ).first()
+        if hub_user and hub_user.keycloak_user_id and _verify_password_against_hub(hub_user.username, password):
+            hub_user.set_password(password)
+            hub_user.save(update_fields=["password"])
+            user = hub_user
+            logger.info("[login] Contraseña localizada en EFC para usuario Hub '%s'", hub_user.username)
+
+    if not user or not user.is_active:
+        return Response({"detail": "Credenciales inválidas"}, status=401)
+
+    first_login = not bool(user.keycloak_user_id)
+    if first_login:
+        import threading
+
+        def _provision_async():
+            try:
+                _provision_user_in_hub(user.username, password)
+            except Exception as exc:
+                logger.warning("[login] Provisión async fallida para %s: %s", user.username, exc)
+
+        threading.Thread(target=_provision_async, daemon=True).start()
+        logger.info("[login] Provisión iniciada en background para %s", user.username)
+
+    refresh = RefreshToken.for_user(user)
+
+    return Response({
+        "access":        str(refresh.access_token),
+        "refresh":       str(refresh),
+        "access_token":  str(refresh.access_token),
+        "refresh_token": str(refresh),
+        "first_login":   first_login,
+        "user_id":       str(user.id),
+        "username":      user.username,
+        "email":         user.email,
+    })
+
+
+
+# ---------------------------------------------------------------------------
+# POST /api/v1/auth/sso/exchange/
+# ---------------------------------------------------------------------------
+
+@api_view(["POST"])
+@permission_classes([AllowAny])
+def sso_exchange_view(request):
+    """
+    Canjea relay token del Hub por sesión local.
+    Además de emitir tokens, auto-provisiona la organización y el usuario
+    en la BD de EFC si aún no existen (flujo Hub → EFC).
+    """
+    relay_token = request.data.get("relay_token", "").strip()
+    if not relay_token:
+        return Response({"detail": "relay_token requerido"}, status=400)
+
+    try:
+        r = http.post(
+            f"{HUB_URL()}/api/v1/auth/sso-exchange",
+            json={"relay_token": relay_token},
+            timeout=10,
+        )
+    except http.exceptions.RequestException as exc:
+        logger.error("Hub no disponible en SSO exchange: %s", exc)
+        return Response({"detail": "Servicio de autenticación no disponible"}, status=503)
+
+    if r.status_code == 404:
+        return Response({"detail": "Relay token inválido o expirado"}, status=401)
+    if r.status_code != 200:
+        logger.error("Hub %s en SSO exchange: %s", r.status_code, r.text[:200])
+        return Response({"detail": "No se pudo completar el inicio de sesión"}, status=401)
+
+    data        = r.json()
+    tenant_slug = data.get("tenant_slug")
+
+    try:
+        org, org_created = _ensure_efc_organization(tenant_slug, data.get("tenant_name")) if tenant_slug else (None, False)
+        user, user_created = _ensure_efc_user(data, org)
+        # Primer usuario de una org nueva → admin automático
+        if org_created and user_created and org and user:
+            _assign_admin_role(user, org)
+    except Exception as exc:
+        logger.error("[sso] Error en auto-provisión EFC para tenant '%s': %s", tenant_slug, exc)
+
+    local_tokens = create_local_tokens({
+        "id":           data.get("user_id"),
+        "username":     data.get("preferred_username") or data.get("email", ""),
+        "email":        data.get("email", ""),
+        "name":         data.get("name", ""),
+        "first_name":   "",
+        "last_name":    "",
+        "is_hub_admin": data.get("is_hub_admin", False),
+        "tenant_id":    data.get("tenant_id"),
+        "tenant_slug":  tenant_slug,
+    })
+
+    response = Response({
+        "user_id":      data.get("user_id"),
+        "email":        data.get("email"),
+        "name":         data.get("name"),
+        "username":     data.get("preferred_username"),
+        "tenant_id":    data.get("tenant_id"),
+        "tenant_slug":  tenant_slug,
+        "is_hub_admin": data.get("is_hub_admin", False),
+        "avatar_url":   data.get("avatar_url"),
+        "access_token": local_tokens["access_token"],
+        "refresh_token": local_tokens["refresh_token"],
+    })
+    set_session_cookies(response, local_tokens)
+    logger.info("SSO exchange OK — usuario %s tenant %s", data.get("user_id"), tenant_slug)
+    return response
+
+
+# ---------------------------------------------------------------------------
+# GET /api/v1/auth/me/
+# ---------------------------------------------------------------------------
+
+@api_view(["GET"])
+@permission_classes([AllowAny])
+def me_view(request):
+    """Retorna el usuario autenticado actual desde token o cookie."""
+    token = _extract_token(request)
+    if not token:
+        return Response({"detail": "No autenticado"}, status=401)
+
+    try:
+        hub_data = verify_hub_token(token)
+    except Exception as exc:
+        return Response({"detail": str(exc)}, status=401)
+
+    # Intentar enriquecer con datos Django si el usuario existe
+    user = _get_django_user(hub_data)
+
+    if user:
+        return Response({
+            "id":           str(user.id),
+            "username":     user.username,
+            "email":        user.email,
+            "name":         f"{user.first_name} {user.last_name}".strip() or hub_data.get("name", ""),
+            "first_name":   user.first_name,
+            "last_name":    user.last_name,
+            "is_superuser": user.is_superuser,
+            "is_hub_admin": hub_data.get("is_hub_admin", False),
+            "tenant_id":    hub_data.get("tenant_id"),
+            "tenant_slug":  hub_data.get("tenant_slug"),
+            "avatar_url":   hub_data.get("avatar_url"),
+            "organizacion_id": str(user.organizacion_id) if user.organizacion_id else None,
+        })
+
+    return Response({
+        "id":           hub_data.get("sub"),
+        "username":     hub_data.get("preferred_username") or hub_data.get("email", ""),
+        "email":        hub_data.get("email"),
+        "name":         hub_data.get("name", ""),
+        "first_name":   hub_data.get("given_name", ""),
+        "last_name":    hub_data.get("family_name", ""),
+        "is_superuser": hub_data.get("is_hub_admin", False),
+        "is_hub_admin": hub_data.get("is_hub_admin", False),
+        "tenant_id":    hub_data.get("tenant_id"),
+        "tenant_slug":  hub_data.get("tenant_slug"),
+        "avatar_url":   hub_data.get("avatar_url"),
+        "organizacion_id": None,
+    })
+
+
+# ---------------------------------------------------------------------------
+# POST /api/v1/auth/logout/
+# ---------------------------------------------------------------------------
+
+@api_view(["POST"])
+@permission_classes([AllowAny])
+def logout_view(request):
+    """Limpia cookies de sesión. El frontend redirige al Hub para cerrar KC."""
+    response = Response({"detail": "Sesión cerrada"})
+    for cookie in ("access_token", "refresh_token", "token_type"):
+        response.delete_cookie(cookie, samesite="Lax")
+    return response
+
+
+# ---------------------------------------------------------------------------
+# POST /api/v1/auth/login/refresh/
+# ---------------------------------------------------------------------------
+
+@api_view(["POST"])
+@permission_classes([AllowAny])
+def refresh_view(request):
+    """Renueva el access token usando el refresh token local."""
+    refresh_token = (
+        request.data.get("refresh_token")
+        or request.COOKIES.get("refresh_token")
+    )
+    if not refresh_token:
+        return Response({"detail": "refresh_token requerido"}, status=400)
+
+    try:
+        import jwt as pyjwt
+        payload = pyjwt.decode(refresh_token, settings.SECRET_KEY, algorithms=["HS256"])
+        if payload.get("source") != "local":
+            return Response({"detail": "Token de refresco inválido"}, status=401)
+    except pyjwt.ExpiredSignatureError:
+        return Response({"detail": "Refresh token expirado"}, status=401)
+    except pyjwt.InvalidTokenError:
+        return Response({"detail": "Refresh token inválido"}, status=401)
+
+    new_tokens = create_local_tokens({
+        "id":           payload.get("sub"),
+        "username":     payload.get("preferred_username", ""),
+        "email":        payload.get("email", ""),
+        "name":         payload.get("name", ""),
+        "first_name":   payload.get("given_name", ""),
+        "last_name":    payload.get("family_name", ""),
+        "is_hub_admin": payload.get("is_hub_admin", False),
+        "tenant_id":    payload.get("tenant_id"),
+        "tenant_slug":  payload.get("tenant_slug"),
+    })
+
+    response = Response({"access_token": new_tokens["access_token"]})
+    set_session_cookies(response, new_tokens)
+    return response
+
+
+# ---------------------------------------------------------------------------
+# POST /api/v1/auth/session/refresh/
+# ---------------------------------------------------------------------------
+
+@api_view(["POST"])
+@permission_classes([AllowAny])
+def session_refresh_view(request):
+    """
+    Renueva la sesión usando SOLO la cookie HTTP-only refresh_token.
+    No requiere body. Diseñado para el flujo SSO donde el refresh_token
+    no vive en localStorage sino en cookie.
+    """
+    refresh_token = request.COOKIES.get("refresh_token")
+    if not refresh_token:
+        return Response({"detail": "No hay sesión activa"}, status=401)
+
+    try:
+        import jwt as pyjwt
+        payload = pyjwt.decode(refresh_token, settings.SECRET_KEY, algorithms=["HS256"])
+        if payload.get("source") != "local":
+            return Response({"detail": "Token de refresco inválido"}, status=401)
+    except pyjwt.ExpiredSignatureError:
+        return Response({"detail": "Sesión expirada — inicia sesión de nuevo"}, status=401)
+    except pyjwt.InvalidTokenError:
+        return Response({"detail": "Token de refresco inválido"}, status=401)
+
+    new_tokens = create_local_tokens({
+        "id":           payload.get("sub"),
+        "username":     payload.get("preferred_username", ""),
+        "email":        payload.get("email", ""),
+        "name":         payload.get("name", ""),
+        "first_name":   payload.get("given_name", ""),
+        "last_name":    payload.get("family_name", ""),
+        "is_hub_admin": payload.get("is_hub_admin", False),
+        "tenant_id":    payload.get("tenant_id"),
+        "tenant_slug":  payload.get("tenant_slug"),
+    })
+
+    access = new_tokens["access_token"]
+    response = Response({
+        "access_token": access,
+        "access":       access,
+    })
+    set_session_cookies(response, new_tokens)
+    return response

api/customs/management/commands/fix_partidas_error.py

@@ -1,31 +1,52 @@
 """
-Diagnóstico y corrección de partidas con descargado=True cuyos documentos
-de respuesta VUCEM contienen <tieneError>true</tieneError>.
+Diagnóstico y corrección de partidas con descargado=True que NO tienen un XML
+de respuesta de partida válido.
+
+Una partida cuenta como realmente descargada solo si alguno de sus documentos
+contiene el nodo <consultarPartidaRespuesta> sin <tieneError>true</tieneError>.
+
+Clasificación por contenido de cada documento candidato (excluye types 17/18,
+que ya están identificados como REQUEST/ERROR):
+  - valida         : consultarPartidaRespuesta sin tieneError=true
+  - error          : tieneError=true             → renombra a _ERROR,  type 18
+  - request        : consultarPartidaPeticion    → renombra a _REQUEST, type 17
+                     (eco de la petición guardado como si fuera respuesta)
+  - desconocido    : contenido no identificable  → solo reporte
+  - ausente        : registro en BD cuyo archivo no existe en storage
+  - no_verificable : storage inaccesible (excepción al consultar/leer)
+
+Veredicto por partida con descargado=True:
+  - ≥1 valida                        → conserva descargado=True
+  - 0 validas y ≥1 no_verificable    → sin cambios (storage inaccesible)
+  - 0 validas, ≥1 ausente y NINGÚN archivo del pedimento existe en storage
+                                     → sin cambios (canario: probablemente se
+                                       está corriendo contra un storage que no
+                                       es el de esta BD, p. ej. dev)
+  - en cualquier otro caso           → descargado=False  (incluye partidas que
+                                       solo tienen el REQUEST, ningún doc, o
+                                       registros fantasma con el storage real)
+
+Canario de storage: si al menos un archivo vu_PT_ del pedimento (REQUEST,
+ERROR o respuesta) sí existe en storage, el storage es el correcto y los
+documentos ausentes son registros fantasma reales (BD sin archivo).
 
 Convenciones de nomenclatura del microservicio:
   - REQUEST  (type 17): vu_PT_{pedimento_app}_{partida}_REQUEST.xml
   - ERROR    (type 18): vu_PT_{pedimento_app}_{partida}_ERROR.xml
   - Éxito    (type  1): vu_PT_{pedimento_app}_{partida}.xml
-
-Acciones por cada documento con error VUCEM encontrado:
-  - document_type_id: actual → 18 (PT ERROR)
-  - archivo: renombrado a vu_PT_{pedimento_app}_{partida}_ERROR.xml
-  - Partida.descargado: True → False
-
-Criterio de pedimento malformado (cualquiera de):
-  - aduana: nulo/vacío o len < 3
-  - numero_operacion: nulo o vacío
-  - patente: nulo/vacío o len < 4
-  - pedimento (campo): nulo/vacío o len < 7
+    (el storage puede agregar sufijos de unicidad: vu_PT_{...}_{partida}_Ab12xQ.xml)
+  - Legacy            : vu_PT_..._{partida}.xml (número de partida al final)
 
 Uso:
   python manage.py fix_partidas_error --pedimento <UUID> --dry-run
   python manage.py fix_partidas_error --organizacion <UUID> --dry-run
   python manage.py fix_partidas_error --organizacion <UUID>
+  python manage.py fix_partidas_error --solo-malformados --dry-run
   python manage.py fix_partidas_error --dry-run   # todas las orgs
 """
 import io
 import posixpath
+import re
 
 from django.core.management.base import BaseCommand, CommandError
 from django.db import transaction
@@ -39,9 +60,23 @@ from api.utils.minio_client import minio_client
 _PT_REQUEST = 17
 _PT_ERROR = 18
 
+# Clasificaciones por contenido del XML
+_VALIDA = "valida"
+_ERROR_VU = "error"
+_REQUEST_ECO = "request"
+_DESCONOCIDO = "desconocido"
+_AUSENTE = "ausente"
+_NO_VERIFICABLE = "no_verificable"
+
+# clase → (sufijo de archivo, document_type destino)
+_RECLASIFICACION = {
+    _ERROR_VU: ("ERROR", _PT_ERROR),
+    _REQUEST_ECO: ("REQUEST", _PT_REQUEST),
+}
+
 
 class Command(BaseCommand):
-    help = "Corrección de partidas descargado=True con respuestas de error VUCEM."
+    help = "Corrige partidas descargado=True sin XML de respuesta de partida válido."
 
     def add_arguments(self, parser):
         parser.add_argument(
@@ -61,10 +96,14 @@ class Command(BaseCommand):
             "--fecha-hasta", metavar="YYYY-MM-DD",
             help="Procesar pedimentos con fecha_pago <= esta fecha.",
         )
+        parser.add_argument(
+            "--solo-malformados", action="store_true",
+            help="Limitar a pedimentos con aduana/patente/pedimento/numero_operacion inválidos (comportamiento anterior).",
+        )
         # Control de lote
         parser.add_argument(
             "--offset", type=int, default=0,
-            help="Saltar los primeros N pedimentos malformados (default: 0).",
+            help="Saltar los primeros N pedimentos (default: 0).",
         )
         parser.add_argument(
             "--limit", type=int, default=0,
@@ -97,7 +136,12 @@ class Command(BaseCommand):
             self._handle_single(ped_id, dry_run)
             return
 
-        ped_qs = self._malformed_qs()
+        # Universo: pedimentos con al menos una partida descargado=True
+        ped_ids = Partida.objects.filter(descargado=True).values_list(
+            "pedimento_id", flat=True
+        ).distinct()
+        base_qs = self._malformed_qs() if options["solo_malformados"] else Pedimento.objects.all()
+        ped_qs = base_qs.filter(id__in=ped_ids)
 
         if org_id:
             ped_qs = ped_qs.filter(organizacion_id=org_id)
@@ -115,29 +159,32 @@ class Command(BaseCommand):
         if limit:
             ped_qs = ped_qs[:limit]
 
-        total = ped_qs.count() if not (offset or limit) else min(
+        total = total_sin_filtro if not (offset or limit) else min(
             limit or total_sin_filtro, max(0, total_sin_filtro - offset)
         )
 
         self.stdout.write(
-            f"Pedimentos malformados (total): {total_sin_filtro}\n"
-            f"Procesando este lote          : {total}"
+            f"Pedimentos con partidas descargadas (total): {total_sin_filtro}\n"
+            f"Procesando este lote                       : {total}"
             + (f"  [offset={offset}]" if offset else "")
             + (f"  [limit={limit}]" if limit else "")
+            + (f"  [solo malformados]" if options["solo_malformados"] else "")
             + "\n"
         )
 
         if total == 0:
-            self.stdout.write(self.style.SUCCESS("Nada que corregir en este lote."))
+            self.stdout.write(self.style.SUCCESS("Nada que revisar en este lote."))
             return
 
-        total_partidas = total_docs = 0
+        stats = self._stats_vacios()
+        n_peds = 0
         for ped in ped_qs:
-            p, d = self._process_pedimento(ped, dry_run)
-            total_partidas += p
-            total_docs += d
+            parciales = self._process_pedimento(ped, dry_run)
+            n_peds += 1
+            for k in stats:
+                stats[k] += parciales[k]
 
-        self._print_summary(total, total_partidas, total_docs, dry_run)
+        self._print_summary(n_peds, stats, dry_run)
 
     # ------------------------------------------------------------------ #
     # Flujo --pedimento
@@ -149,11 +196,10 @@ class Command(BaseCommand):
         except Pedimento.DoesNotExist:
             raise CommandError(f"Pedimento {ped_id!r} no encontrado.")
 
-        checks = self._field_checks(ped)
-        self._print_ped_diagnosis(ped, checks)
-        if not any(checks.values()):
-            return
-        self._process_pedimento(ped, dry_run)
+        # Diagnóstico de campos: informativo, ya no excluye pedimentos válidos
+        self._print_ped_diagnosis(ped, self._field_checks(ped))
+        stats = self._process_pedimento(ped, dry_run)
+        self._print_summary(1, stats, dry_run)
 
     # ------------------------------------------------------------------ #
     # Queryset de pedimentos malformados
@@ -199,139 +245,247 @@ class Command(BaseCommand):
         self.stdout.write("")
 
     # ------------------------------------------------------------------ #
-    # Procesamiento de un pedimento malformado
+    # Procesamiento de un pedimento
     # ------------------------------------------------------------------ #
 
+    def _stats_vacios(self):
+        return {
+            "partidas": 0,        # partidas descargado=True revisadas
+            "corregidas": 0,      # partidas marcadas descargado=False
+            "bloqueadas": 0,      # partidas sin cambios (storage inaccesible/equivocado)
+            "docs_error": 0,      # docs renombrados a _ERROR (type 18)
+            "docs_request": 0,    # docs reclasificados a _REQUEST (type 17)
+            "desconocidos": 0,    # docs con contenido no identificable
+            "fantasmas": 0,       # registros en BD sin archivo en storage (no se borran)
+        }
+
     def _process_pedimento(self, ped, dry_run):
+        es_malformado = any(self._field_checks(ped).values())
         self.stdout.write(
             f"Pedimento: {ped.pedimento_app}  |  "
             f"aduana={ped.aduana!r}  patente={ped.patente!r}  num_op={ped.numero_operacion!r}"
+            + ("  [MALFORMADO]" if es_malformado else "")
         )
+        stats = self._stats_vacios()
+
         partidas = Partida.objects.filter(pedimento=ped, descargado=True)
         n_partidas = partidas.count()
-
         if n_partidas == 0:
             self.stdout.write("  → Sin partidas con descargado=True\n")
-            return 0, 0
+            return stats
 
         self.stdout.write(f"  Partidas con descargado=True: {n_partidas}")
-        total_docs_error = 0
+
+        # Una sola consulta por pedimento; la asignación por partida es en memoria
+        docs_pedimento = list(
+            Document.objects.filter(pedimento=ped, archivo__icontains="vu_PT_")
+        )
+
+        # Canario perezoso: ¿existe en storage al menos un archivo del pedimento?
+        # Distingue "registro fantasma con storage real" de "storage equivocado".
+        canario = {"valor": None}
+
+        def storage_es_correcto():
+            if canario["valor"] is None:
+                canario["valor"] = self._storage_tiene_archivos(docs_pedimento)
+            return canario["valor"]
 
         for partida in partidas:
-            # Documentos de respuesta: excluir REQUEST (17) y los ya marcados ERROR (18)
-            patron = f"vu_PT_{ped.pedimento_app}_{partida.numero_partida}_"
-            candidatos = list(
-                Document.objects.filter(
-                    pedimento=ped,
-                    archivo__icontains=patron,
-                ).exclude(document_type_id__in=[_PT_REQUEST, _PT_ERROR])
-            )
-
-            self.stdout.write(
-                f"\n  Partida {partida.numero_partida}: {len(candidatos)} doc(s) candidatos a revisar"
-            )
-
-            docs_con_error = []
-            for doc in candidatos:
-                # estado: "error" | "ok" | "no_verificable"
-                estado, motivo = self._check_vucem_error(doc)
-                if estado == "error":
-                    icono = self.style.ERROR("✗ ERROR VUCEM")
-                elif estado == "ok":
-                    icono = self.style.SUCCESS("✓ ok")
-                else:
-                    icono = self.style.WARNING("⚠ sin archivo en storage")
-
-                self.stdout.write(f"    [{icono}] type={doc.document_type_id} | {doc.archivo.name}")
-
-                if estado == "error":
-                    self.stdout.write(f"      motivo   : {motivo}")
-                    new_name = self._build_error_filename(
-                        doc.archivo.name, ped.pedimento_app, partida.numero_partida, len(docs_con_error)
-                    )
-                    self.stdout.write(f"      → {new_name}")
-                    docs_con_error.append(doc)
-                elif estado == "no_verificable":
-                    self.stdout.write(f"      {motivo} — ejecuta en producción para verificar")
-
-            total_docs_error += len(docs_con_error)
-
-            if not dry_run and docs_con_error:
-                self._apply_fix(partida, docs_con_error, ped.pedimento_app)
+            self._process_partida(ped, partida, docs_pedimento, storage_es_correcto, dry_run, stats)
 
         self.stdout.write("")
-        return n_partidas, total_docs_error
+        return stats
+
+    def _storage_tiene_archivos(self, docs):
+        """True si al menos un archivo vu_PT_ del pedimento existe en storage."""
+        for doc in docs:
+            try:
+                if minio_client.file_exists(doc.archivo.name):
+                    return True
+            except Exception:
+                return False  # storage inaccesible: modo conservador
+        return False
 
     # ------------------------------------------------------------------ #
-    # Detección de error VUCEM en el XML
+    # Procesamiento de una partida
     # ------------------------------------------------------------------ #
 
-    def _check_vucem_error(self, doc):
+    def _process_partida(self, ped, partida, docs_pedimento, storage_es_correcto, dry_run, stats):
+        stats["partidas"] += 1
+        docs = self._docs_de_partida(docs_pedimento, ped.pedimento_app, partida.numero_partida)
+        candidatos = [d for d in docs if d.document_type_id not in (_PT_REQUEST, _PT_ERROR)]
+        n_requests = sum(1 for d in docs if d.document_type_id == _PT_REQUEST)
+        n_errores = sum(1 for d in docs if d.document_type_id == _PT_ERROR)
+
+        self.stdout.write(
+            f"\n  Partida {partida.numero_partida}: {len(candidatos)} doc(s) de respuesta a revisar"
+            f"  (REQUEST: {n_requests}, ERROR previos: {n_errores})"
+        )
+
+        clasificados = []
+        for doc in candidatos:
+            clase, motivo = self._classify_document(doc)
+            iconos = {
+                _VALIDA: self.style.SUCCESS("✓ partida válida"),
+                _ERROR_VU: self.style.ERROR("✗ ERROR VUCEM"),
+                _REQUEST_ECO: self.style.WARNING("↺ es REQUEST, no respuesta"),
+                _DESCONOCIDO: self.style.WARNING("? contenido desconocido"),
+                _AUSENTE: self.style.WARNING("✗ registro sin archivo en storage"),
+                _NO_VERIFICABLE: self.style.WARNING("⚠ storage inaccesible"),
+            }
+            self.stdout.write(f"    [{iconos[clase]}] type={doc.document_type_id} | {doc.archivo.name}")
+            if motivo:
+                self.stdout.write(f"      motivo: {motivo}")
+            clasificados.append((doc, clase))
+
+        validas = [d for d, c in clasificados if c == _VALIDA]
+        no_verificables = [d for d, c in clasificados if c == _NO_VERIFICABLE]
+        ausentes = [d for d, c in clasificados if c == _AUSENTE]
+        corregibles = [(d, c) for d, c in clasificados if c in _RECLASIFICACION]
+        stats["desconocidos"] += sum(1 for _, c in clasificados if c == _DESCONOCIDO)
+
+        # Veredicto: solo una consultarPartidaRespuesta sin error mantiene la
+        # partida como descargada. Storage inaccesible bloquea el cambio; un
+        # archivo ausente solo bloquea cuando NINGÚN archivo del pedimento
+        # existe en storage (canario: posible storage equivocado, p. ej. dev).
+        if validas:
+            marcar_no_descargada = False
+            veredicto = self.style.SUCCESS("OK: tiene respuesta de partida válida")
+        elif no_verificables:
+            marcar_no_descargada = False
+            stats["bloqueadas"] += 1
+            veredicto = self.style.WARNING(
+                "SIN CAMBIOS: storage inaccesible — ejecutar donde el storage sea accesible"
+            )
+        elif ausentes and not storage_es_correcto():
+            marcar_no_descargada = False
+            stats["bloqueadas"] += 1
+            veredicto = self.style.WARNING(
+                "SIN CAMBIOS: ningún archivo del pedimento existe en storage — "
+                "¿se está corriendo contra el storage correcto?"
+            )
+        else:
+            marcar_no_descargada = True
+            stats["corregidas"] += 1
+            stats["fantasmas"] += len(ausentes)
+            veredicto = self.style.ERROR("descargado → False (sin XML de partida válido)")
+        self.stdout.write(f"    Veredicto: {veredicto}")
+
+        for _, clase in corregibles:
+            clave = "docs_error" if clase == _ERROR_VU else "docs_request"
+            stats[clave] += 1
+
+        if not dry_run and (corregibles or marcar_no_descargada):
+            self._apply_fix(partida, corregibles, marcar_no_descargada, ped.pedimento_app)
+
+    # ------------------------------------------------------------------ #
+    # Asignación de documentos a una partida por nombre de archivo
+    # ------------------------------------------------------------------ #
+
+    def _docs_de_partida(self, docs, pedimento_app, numero_partida):
         """
-        Lee el XML desde MinIO y verifica si VUCEM devolvió un error.
-        Retorna ("error" | "ok" | "no_verificable", motivo: str | None).
+        Naming actual : vu_PT_{pedimento_app}_{numero} seguido de "_" o "."
+                        (cubre éxito canónico, sufijos de unicidad del storage,
+                        REQUEST y ERROR; "_" evita confundir partida 1 con 11)
+        Naming legacy : vu_PT_..._{numero}.xml (número de partida al final)
         """
+        prefijo = f"vu_pt_{pedimento_app}_{numero_partida}".lower()
+        legacy_re = re.compile(
+            rf"^vu_pt_.+_{re.escape(str(numero_partida))}\.xml$", re.IGNORECASE
+        )
+        asignados = {}
+        for doc in docs:
+            base = posixpath.basename(doc.archivo.name or "").lower()
+            es_actual = (
+                base.startswith(prefijo)
+                and len(base) > len(prefijo)
+                and base[len(prefijo)] in "_."
+            )
+            if es_actual or legacy_re.match(base):
+                asignados[doc.id] = doc
+        return list(asignados.values())
+
+    # ------------------------------------------------------------------ #
+    # Clasificación del contenido XML
+    # ------------------------------------------------------------------ #
+
+    def _classify_document(self, doc):
+        """
+        Lee el XML desde MinIO y clasifica su contenido.
+        Retorna (clase, motivo: str | None).
+        """
+        name = doc.archivo.name
         try:
-            name = doc.archivo.name
             if not minio_client.file_exists(name):
-                return "no_verificable", "archivo no encontrado en storage"
+                return _AUSENTE, "archivo no encontrado en storage"
             response = minio_client._client.get_object(minio_client._bucket_name, name)
             try:
                 content = response.read()
             finally:
                 response.close()
                 response.release_conn()
-            text = content.decode("utf-8", errors="replace")
-            if "tieneError>true<" in text:
-                return "error", "tieneError=true detectado en XML"
-            return "ok", None
+            text = content.decode("utf-8", errors="replace").lower()
         except Exception as e:
-            return "no_verificable", f"excepción al leer archivo: {e}"
+            return _NO_VERIFICABLE, f"excepción al leer archivo: {e}"
 
-    # ------------------------------------------------------------------ #
-    # Construcción del nombre de archivo de error
-    # ------------------------------------------------------------------ #
-
-    def _build_error_filename(self, old_name, pedimento_app, numero_partida, index=0):
-        """
-        Retorna la ruta con nomenclatura de error:
-          index=0 → {dir}/vu_PT_{pedimento_app}_{numero_partida}_ERROR.xml
-          index>0 → {dir}/vu_PT_{pedimento_app}_{numero_partida}_ERROR_{index}.xml
-        El índice evita colisión cuando una partida tiene más de un doc con error.
-        """
-        dir_part = posixpath.dirname(old_name)
-        suffix = f"_{index}" if index > 0 else ""
-        new_filename = f"vu_PT_{pedimento_app}_{numero_partida}_ERROR{suffix}.xml"
-        return posixpath.join(dir_part, new_filename)
+        if "tieneerror>true<" in text:
+            return _ERROR_VU, "tieneError=true detectado en XML"
+        if "consultarpartidarespuesta" in text:
+            return _VALIDA, None
+        if "consultarpartidapeticion" in text:
+            return _REQUEST_ECO, "es la petición SOAP, no la respuesta"
+        return _DESCONOCIDO, "sin consultarPartidaRespuesta, sin consultarPartidaPeticion y sin tieneError"
 
     # ------------------------------------------------------------------ #
     # Aplicación de correcciones
     # ------------------------------------------------------------------ #
 
     @transaction.atomic
-    def _apply_fix(self, partida, docs, pedimento_app):
+    def _apply_fix(self, partida, corregibles, marcar_no_descargada, pedimento_app):
         """
-        Renombra archivos en storage y actualiza BD dentro de una transacción.
-        Nota: si la transacción revierte, los cambios en storage NO se deshacen.
+        Renombra/reclasifica documentos y actualiza la partida en una transacción.
+        Nota: si la transacción revierte, los cambios en storage NO se deshacen;
+        re-ejecutar el comando converge (ver _rename_in_storage).
         """
-        for idx, doc in enumerate(docs):
-            new_name = self._build_error_filename(
-                doc.archivo.name, pedimento_app, partida.numero_partida, idx
-            )
+        for doc, clase in corregibles:
+            suffix, doc_type = _RECLASIFICACION[clase]
+            new_name = self._pick_target_name(doc, pedimento_app, partida.numero_partida, suffix)
             final_name = self._rename_in_storage(doc.archivo.name, new_name)
             doc.archivo = final_name
-            doc.document_type_id = _PT_ERROR
+            doc.document_type_id = doc_type
             doc.vu = True
             doc.save(update_fields=["archivo", "document_type_id", "vu"])
             self.stdout.write(self.style.SUCCESS(
-                f"      ✓ Doc {doc.id}: type=18 | {final_name}"
+                f"      ✓ Doc {doc.id}: type={doc_type} | {final_name}"
             ))
 
-        partida.descargado = False
-        partida.save(update_fields=["descargado"])
-        self.stdout.write(self.style.SUCCESS(
-            f"      ✓ Partida {partida.numero_partida}: descargado=False"
-        ))
+        if marcar_no_descargada:
+            partida.descargado = False
+            partida.save(update_fields=["descargado"])
+            self.stdout.write(self.style.SUCCESS(
+                f"      ✓ Partida {partida.numero_partida}: descargado=False"
+            ))
+
+    def _pick_target_name(self, doc, pedimento_app, numero_partida, suffix):
+        """
+        Primer nombre libre con nomenclatura
+          {dir}/vu_PT_{pedimento_app}_{numero_partida}_{SUFFIX}[_{n}].xml
+        verificado contra BD (excluyendo el propio doc) para que dos Documents
+        nunca terminen apuntando al mismo archivo (p. ej. contra el REQUEST
+        real type 17 que ya usa el nombre sin índice).
+        """
+        dir_part = posixpath.dirname(doc.archivo.name)
+        index = 0
+        while True:
+            tail = f"_{index}" if index else ""
+            candidate = posixpath.join(
+                dir_part, f"vu_PT_{pedimento_app}_{numero_partida}_{suffix}{tail}.xml"
+            )
+            if candidate == doc.archivo.name:
+                return candidate
+            if not Document.objects.filter(archivo=candidate).exclude(id=doc.id).exists():
+                return candidate
+            index += 1
 
     def _rename_in_storage(self, old_name, new_name):
         if old_name == new_name:
@@ -340,7 +494,7 @@ class Command(BaseCommand):
         if minio_client.file_exists(new_name):
             # Rename ya ocurrió en ejecución previa parcial
             self.stderr.write(self.style.WARNING(
-                f"      ⚠ ERROR ya existe en storage, usando: {new_name}"
+                f"      ⚠ Destino ya existe en storage, usando: {new_name}"
             ))
             if minio_client.file_exists(old_name):
                 minio_client.delete_file(old_name)
@@ -367,12 +521,17 @@ class Command(BaseCommand):
     # Resumen final
     # ------------------------------------------------------------------ #
 
-    def _print_summary(self, total_peds, total_partidas, total_docs, dry_run):
+    def _print_summary(self, total_peds, stats, dry_run):
         self.stdout.write(
             f"\n{'─' * 60}\nRESUMEN\n"
-            f"  Pedimentos malformados       : {total_peds}\n"
-            f"  Partidas con descargado=True : {total_partidas}\n"
-            f"  Documentos con error VUCEM   : {total_docs}\n"
+            f"  Pedimentos procesados                  : {total_peds}\n"
+            f"  Partidas revisadas (descargado=True)   : {stats['partidas']}\n"
+            f"  Partidas corregidas (descargado=False) : {stats['corregidas']}\n"
+            f"  Partidas sin cambios (no verificables) : {stats['bloqueadas']}\n"
+            f"  Docs renombrados a ERROR (type 18)     : {stats['docs_error']}\n"
+            f"  Docs reclasificados a REQUEST (type 17): {stats['docs_request']}\n"
+            f"  Docs con contenido desconocido         : {stats['desconocidos']}\n"
+            f"  Registros en BD sin archivo en storage : {stats['fantasmas']}  (no se borran)\n"
         )
         if dry_run:
             self.stdout.write(self.style.WARNING(

api/customs/management/commands/reconciliar_descargas.py

@@ -0,0 +1,110 @@
+from django.core.management.base import BaseCommand
+from django.db import transaction
+
+from api.customs.models import EDocument, Cove, EstadoDescarga
+from api.record.models import Document
+from api.utils.storage_service import storage_service
+
+
+class Command(BaseCommand):
+    """
+    Reconciliación de estatus de descarga VUCEM (T2026-05-027).
+
+    Detecta registros marcados como 'descargado' cuyo documento no existe en BD
+    o cuyo archivo falta físicamente en storage (MinIO), y los transiciona a
+    estado 'error' para que sean visibles y reprocesables. Sin --apply solo
+    reporta (dry-run).
+
+    Uso:
+        python manage.py reconciliar_descargas                  # reporte
+        python manage.py reconciliar_descargas --apply          # corrige
+        python manage.py reconciliar_descargas --organizacion <uuid>
+    """
+
+    help = "Reconcilia estatus de descarga de EDocs/COVEs contra documentos reales (BD + storage)"
+
+    # Catálogo confirmado de document_type:
+    # 4 = acuse EDoc, 7 = acuse COVE, 19/23 = request COVE, 21/25 = request EDoc,
+    # 20 = error COVE, 22 = error EDoc, 24 = error acuse COVE, 26 = error acuse EDoc
+    EXCLUIR_EDOC_GENERAL = [4, 21, 22, 25, 26]
+    EXCLUIR_COVE_GENERAL = [7, 19, 20, 23, 24]
+
+    def add_arguments(self, parser):
+        parser.add_argument(
+            '--apply', action='store_true',
+            help='Aplica las correcciones; sin esta bandera solo reporta (dry-run)'
+        )
+        parser.add_argument(
+            '--organizacion', type=str, default=None,
+            help='Limitar la reconciliación a una organización (UUID)'
+        )
+        parser.add_argument(
+            '--pedimento', type=str, default=None,
+            help='Limitar la reconciliación a un pedimento (UUID)'
+        )
+
+    def handle(self, *args, **opts):
+        apply_changes = opts['apply']
+        detectados = []
+
+        flujos = [
+            # (modelo, campo_estado, campo_intentos, etiqueta, fn_documentos)
+            (EDocument, 'acuse_estado', 'acuse_intentos', 'edoc.acuse',
+             lambda r: Document.objects.filter(
+                 pedimento=r.pedimento,
+                 archivo__icontains=r.numero_edocument,
+                 document_type_id=4)),
+            (EDocument, 'edocument_estado', 'edocument_intentos', 'edoc.general',
+             lambda r: Document.objects.filter(
+                 pedimento=r.pedimento,
+                 archivo__icontains=r.numero_edocument,
+             ).exclude(document_type_id__in=self.EXCLUIR_EDOC_GENERAL)),
+            (Cove, 'acuse_cove_estado', 'acuse_cove_intentos', 'cove.acuse',
+             lambda r: Document.objects.filter(
+                 pedimento=r.pedimento,
+                 archivo__icontains=r.numero_cove,
+                 document_type_id=7)),
+            (Cove, 'cove_estado', 'cove_intentos', 'cove.general',
+             lambda r: Document.objects.filter(
+                 pedimento=r.pedimento,
+                 archivo__icontains=r.numero_cove,
+             ).exclude(document_type_id__in=self.EXCLUIR_COVE_GENERAL)),
+        ]
+
+        for modelo, campo_estado, campo_intentos, etiqueta, fn_documentos in flujos:
+            qs = modelo.objects.filter(**{campo_estado: EstadoDescarga.DESCARGADO})
+            if opts['organizacion']:
+                qs = qs.filter(organizacion_id=opts['organizacion'])
+            if opts['pedimento']:
+                qs = qs.filter(pedimento_id=opts['pedimento'])
+
+            for registro in qs.select_related('pedimento').iterator():
+                numero = getattr(registro, 'numero_edocument', None) or registro.numero_cove
+                docs = fn_documentos(registro)
+                # Disponible = al menos un documento con fila en BD, tamaño > 0
+                # y archivo físicamente presente en storage
+                disponible = any(
+                    doc.size and storage_service.file_exists(doc.archivo.name)
+                    for doc in docs
+                )
+                if disponible:
+                    continue
+
+                detectados.append((etiqueta, str(registro.id), numero, str(registro.pedimento_id)))
+                if apply_changes:
+                    with transaction.atomic():
+                        setattr(registro, campo_estado, EstadoDescarga.ERROR)
+                        registro.ultimo_error = (
+                            f"Reconciliación: {etiqueta} marcado como descargado "
+                            f"sin archivo disponible en BD/storage"
+                        )
+                        # save() del modelo sincroniza el booleano legado
+                        registro.save(update_fields=[campo_estado, 'ultimo_error'])
+
+        modo = 'CORREGIDOS' if apply_changes else 'DETECTADOS (dry-run, usa --apply para corregir)'
+        self.stdout.write(self.style.WARNING(f"{modo}: {len(detectados)}"))
+        for etiqueta, registro_id, numero, pedimento_id in detectados:
+            self.stdout.write(f"  [{etiqueta}] id={registro_id} numero={numero} pedimento={pedimento_id}")
+
+        if not detectados:
+            self.stdout.write(self.style.SUCCESS("Sin inconsistencias: todos los 'descargado' tienen archivo disponible"))

api/customs/migrations/0020_estados_descarga_t2026_05_027.py

@@ -0,0 +1,99 @@
+# Migración T2026-05-027: estados de descarga de 3 valores (pendiente/descargado/error)
+# y contador de intentos automáticos para EDocument y Cove.
+#
+# NO aplicar en automático. Después de aplicarla, ejecutar el backfill:
+#   backend/scripts/t2026_05_027/02_backfill_estados.sql
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('customs', '0019_pedimento_consultar_vucem'),
+    ]
+
+    operations = [
+        # --- EDocument ---
+        migrations.AddField(
+            model_name='edocument',
+            name='edocument_estado',
+            field=models.CharField(choices=[('pendiente', 'Pendiente'), ('descargado', 'Descargado'), ('error', 'Error')], default='pendiente', help_text='Estado de descarga del e-documento: pendiente, descargado o error', max_length=12),
+        ),
+        migrations.AddField(
+            model_name='edocument',
+            name='acuse_estado',
+            field=models.CharField(choices=[('pendiente', 'Pendiente'), ('descargado', 'Descargado'), ('error', 'Error')], default='pendiente', help_text='Estado de descarga del acuse: pendiente, descargado o error', max_length=12),
+        ),
+        migrations.AddField(
+            model_name='edocument',
+            name='edocument_intentos',
+            field=models.PositiveSmallIntegerField(default=0, help_text='Intentos automáticos de descarga del e-documento (un ciclo de orquestación = un intento)'),
+        ),
+        migrations.AddField(
+            model_name='edocument',
+            name='acuse_intentos',
+            field=models.PositiveSmallIntegerField(default=0, help_text='Intentos automáticos de descarga del acuse (un ciclo de orquestación = un intento)'),
+        ),
+        migrations.AddField(
+            model_name='edocument',
+            name='ultimo_intento_at',
+            field=models.DateTimeField(blank=True, help_text='Fecha del último intento automático de descarga', null=True),
+        ),
+        migrations.AddField(
+            model_name='edocument',
+            name='ultimo_error',
+            field=models.TextField(blank=True, help_text='Detalle del último error de descarga', null=True),
+        ),
+        migrations.AlterField(
+            model_name='edocument',
+            name='edocument_descargado',
+            field=models.BooleanField(default=False, help_text='Indica si el e-documento ha sido descargado (legado, derivado de edocument_estado)'),
+        ),
+        migrations.AlterField(
+            model_name='edocument',
+            name='acuse_descargado',
+            field=models.BooleanField(default=False, help_text='Indica si el acuse del e-documento ha sido descargado (legado, derivado de acuse_estado)'),
+        ),
+        # --- Cove ---
+        migrations.AddField(
+            model_name='cove',
+            name='cove_estado',
+            field=models.CharField(choices=[('pendiente', 'Pendiente'), ('descargado', 'Descargado'), ('error', 'Error')], default='pendiente', help_text='Estado de descarga de la cove: pendiente, descargado o error', max_length=12),
+        ),
+        migrations.AddField(
+            model_name='cove',
+            name='acuse_cove_estado',
+            field=models.CharField(choices=[('pendiente', 'Pendiente'), ('descargado', 'Descargado'), ('error', 'Error')], default='pendiente', help_text='Estado de descarga del acuse de la cove: pendiente, descargado o error', max_length=12),
+        ),
+        migrations.AddField(
+            model_name='cove',
+            name='cove_intentos',
+            field=models.PositiveSmallIntegerField(default=0, help_text='Intentos automáticos de descarga de la cove (un ciclo de orquestación = un intento)'),
+        ),
+        migrations.AddField(
+            model_name='cove',
+            name='acuse_cove_intentos',
+            field=models.PositiveSmallIntegerField(default=0, help_text='Intentos automáticos de descarga del acuse de la cove (un ciclo de orquestación = un intento)'),
+        ),
+        migrations.AddField(
+            model_name='cove',
+            name='ultimo_intento_at',
+            field=models.DateTimeField(blank=True, help_text='Fecha del último intento automático de descarga', null=True),
+        ),
+        migrations.AddField(
+            model_name='cove',
+            name='ultimo_error',
+            field=models.TextField(blank=True, help_text='Detalle del último error de descarga', null=True),
+        ),
+        migrations.AlterField(
+            model_name='cove',
+            name='cove_descargado',
+            field=models.BooleanField(default=False, help_text='Indica si la cove ha sido descargada (legado, derivado de cove_estado)'),
+        ),
+        migrations.AlterField(
+            model_name='cove',
+            name='acuse_cove_descargado',
+            field=models.BooleanField(default=False, help_text='Indica si el acuse de la cove ha sido descargado (legado, derivado de acuse_cove_estado)'),
+        ),
+    ]

api/customs/models.py

@@ -66,6 +66,13 @@ class Pedimento(models.Model):
             ['organizacion', 'pedimento_app']
         ]
 
+class EstadoDescarga(models.TextChoices):
+    """Estado de descarga de documentos VUCEM (requerimiento T2026-05-027):
+    'error' indica que la descarga no pudo completarse y requiere atención."""
+    PENDIENTE = 'pendiente', 'Pendiente'
+    DESCARGADO = 'descargado', 'Descargado'
+    ERROR = 'error', 'Error'
+
 class Partida(models.Model):
     pedimento = models.ForeignKey(Pedimento, on_delete=models.CASCADE, related_name='partidas', help_text="Pedimento asociado a la partida")
     organizacion = models.ForeignKey('organization.Organizacion', on_delete=models.CASCADE, related_name='partidas', help_text="Organización a la que pertenece la partida")
@@ -94,8 +101,28 @@ class EDocument(models.Model):
     descripcion = models.CharField(max_length=200, blank=True, null=True, help_text="Descripción del documento")
     created_at = models.DateTimeField(auto_now_add=True, help_text="Fecha de creación del documento")   
     updated_at = models.DateTimeField(auto_now=True, help_text="Fecha de última actualización del documento")
-    edocument_descargado = models.BooleanField(default=False, help_text="Indica si el e-documento ha sido descargado")
-    acuse_descargado = models.BooleanField(default=False, help_text="Indica si el acuse del e-documento ha sido descargado")
+    edocument_descargado = models.BooleanField(default=False, help_text="Indica si el e-documento ha sido descargado (legado, derivado de edocument_estado)")
+    acuse_descargado = models.BooleanField(default=False, help_text="Indica si el acuse del e-documento ha sido descargado (legado, derivado de acuse_estado)")
+    edocument_estado = models.CharField(max_length=12, choices=EstadoDescarga.choices, default=EstadoDescarga.PENDIENTE, help_text="Estado de descarga del e-documento: pendiente, descargado o error")
+    acuse_estado = models.CharField(max_length=12, choices=EstadoDescarga.choices, default=EstadoDescarga.PENDIENTE, help_text="Estado de descarga del acuse: pendiente, descargado o error")
+    edocument_intentos = models.PositiveSmallIntegerField(default=0, help_text="Intentos automáticos de descarga del e-documento (un ciclo de orquestación = un intento)")
+    acuse_intentos = models.PositiveSmallIntegerField(default=0, help_text="Intentos automáticos de descarga del acuse (un ciclo de orquestación = un intento)")
+    ultimo_intento_at = models.DateTimeField(null=True, blank=True, help_text="Fecha del último intento automático de descarga")
+    ultimo_error = models.TextField(null=True, blank=True, help_text="Detalle del último error de descarga")
+
+    def save(self, *args, **kwargs):
+        # El estado de 3 valores es la fuente de verdad; los booleanos legados se derivan
+        self.edocument_descargado = self.edocument_estado == EstadoDescarga.DESCARGADO
+        self.acuse_descargado = self.acuse_estado == EstadoDescarga.DESCARGADO
+        update_fields = kwargs.get('update_fields')
+        if update_fields is not None:
+            update_fields = set(update_fields)
+            if 'edocument_estado' in update_fields:
+                update_fields.add('edocument_descargado')
+            if 'acuse_estado' in update_fields:
+                update_fields.add('acuse_descargado')
+            kwargs['update_fields'] = list(update_fields)
+        super().save(*args, **kwargs)
 
     def __str__(self):
         return f"{self.descripcion} - {self.pedimento.pedimento}"
@@ -112,8 +139,28 @@ class Cove(models.Model):
     numero_cove = models.CharField(max_length=20, unique=True, help_text="Número único de la cove")
     created_at = models.DateTimeField(auto_now_add=True, help_text="Fecha de creación de la cove")
     updated_at = models.DateTimeField(auto_now=True, help_text="Fecha de última actualización de la cove")
-    cove_descargado = models.BooleanField(default=False, help_text="Indica si la cove ha sido descargada")
-    acuse_cove_descargado = models.BooleanField(default=False, help_text="Indica si el acuse de la cove ha sido descargado")
+    cove_descargado = models.BooleanField(default=False, help_text="Indica si la cove ha sido descargada (legado, derivado de cove_estado)")
+    acuse_cove_descargado = models.BooleanField(default=False, help_text="Indica si el acuse de la cove ha sido descargado (legado, derivado de acuse_cove_estado)")
+    cove_estado = models.CharField(max_length=12, choices=EstadoDescarga.choices, default=EstadoDescarga.PENDIENTE, help_text="Estado de descarga de la cove: pendiente, descargado o error")
+    acuse_cove_estado = models.CharField(max_length=12, choices=EstadoDescarga.choices, default=EstadoDescarga.PENDIENTE, help_text="Estado de descarga del acuse de la cove: pendiente, descargado o error")
+    cove_intentos = models.PositiveSmallIntegerField(default=0, help_text="Intentos automáticos de descarga de la cove (un ciclo de orquestación = un intento)")
+    acuse_cove_intentos = models.PositiveSmallIntegerField(default=0, help_text="Intentos automáticos de descarga del acuse de la cove (un ciclo de orquestación = un intento)")
+    ultimo_intento_at = models.DateTimeField(null=True, blank=True, help_text="Fecha del último intento automático de descarga")
+    ultimo_error = models.TextField(null=True, blank=True, help_text="Detalle del último error de descarga")
+
+    def save(self, *args, **kwargs):
+        # El estado de 3 valores es la fuente de verdad; los booleanos legados se derivan
+        self.cove_descargado = self.cove_estado == EstadoDescarga.DESCARGADO
+        self.acuse_cove_descargado = self.acuse_cove_estado == EstadoDescarga.DESCARGADO
+        update_fields = kwargs.get('update_fields')
+        if update_fields is not None:
+            update_fields = set(update_fields)
+            if 'cove_estado' in update_fields:
+                update_fields.add('cove_descargado')
+            if 'acuse_cove_estado' in update_fields:
+                update_fields.add('acuse_cove_descargado')
+            kwargs['update_fields'] = list(update_fields)
+        super().save(*args, **kwargs)
 
     def __str__(self):
         return f"{self.numero_cove} - {self.pedimento.pedimento}"

api/customs/serializers.py

@@ -1,12 +1,13 @@
 from rest_framework import serializers
 from api.customs.models import (
-    Pedimento, 
-    TipoOperacion, 
-    ProcesamientoPedimento, 
+    Pedimento,
+    TipoOperacion,
+    ProcesamientoPedimento,
     EDocument,
     Cove,
     Importador,
-    Partida
+    Partida,
+    EstadoDescarga
 )
 from django.db import models
 from django.db.models import Q
@@ -205,7 +206,23 @@ class EDocumentSerializer(serializers.ModelSerializer):
         model = EDocument
         fields = '__all__'
         read_only_fields = ('created_at', 'updated_at')
-    
+
+    def validate(self, attrs):
+        # Compatibilidad: payloads legados que solo mandan los booleanos se traducen
+        # al estado de 3 valores (fuente de verdad en el modelo). Un False legado no
+        # degrada un estado 'error' ya asignado.
+        if 'edocument_descargado' in attrs and 'edocument_estado' not in attrs:
+            if attrs['edocument_descargado']:
+                attrs['edocument_estado'] = EstadoDescarga.DESCARGADO
+            elif not (self.instance and self.instance.edocument_estado == EstadoDescarga.ERROR):
+                attrs['edocument_estado'] = EstadoDescarga.PENDIENTE
+        if 'acuse_descargado' in attrs and 'acuse_estado' not in attrs:
+            if attrs['acuse_descargado']:
+                attrs['acuse_estado'] = EstadoDescarga.DESCARGADO
+            elif not (self.instance and self.instance.acuse_estado == EstadoDescarga.ERROR):
+                attrs['acuse_estado'] = EstadoDescarga.PENDIENTE
+        return attrs
+
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         # Si no es superusuario, hacer organizacion read_only
@@ -221,6 +238,22 @@ class CoveSerializer(serializers.ModelSerializer):
         fields = '__all__'
         read_only_fields = ('created_at', 'updated_at')
 
+    def validate(self, attrs):
+        # Compatibilidad: payloads legados que solo mandan los booleanos se traducen
+        # al estado de 3 valores (fuente de verdad en el modelo). Un False legado no
+        # degrada un estado 'error' ya asignado.
+        if 'cove_descargado' in attrs and 'cove_estado' not in attrs:
+            if attrs['cove_descargado']:
+                attrs['cove_estado'] = EstadoDescarga.DESCARGADO
+            elif not (self.instance and self.instance.cove_estado == EstadoDescarga.ERROR):
+                attrs['cove_estado'] = EstadoDescarga.PENDIENTE
+        if 'acuse_cove_descargado' in attrs and 'acuse_cove_estado' not in attrs:
+            if attrs['acuse_cove_descargado']:
+                attrs['acuse_cove_estado'] = EstadoDescarga.DESCARGADO
+            elif not (self.instance and self.instance.acuse_cove_estado == EstadoDescarga.ERROR):
+                attrs['acuse_cove_estado'] = EstadoDescarga.PENDIENTE
+        return attrs
+
     def get_documentos(self, obj):
         """
         Busca documentos en la tabla `document` que coincidan con el

api/customs/tasks/auditoria.py

@@ -1,4 +1,5 @@
 import os
+import tempfile
 from datetime import datetime
 from django.db import models
 from celery import shared_task, group
@@ -7,6 +8,7 @@ from core.utils import xml_controller
 import requests
 from core.utils import xml_remesas_controller
 from core.redis_events import publish_task_event
+from api.utils.storage_service import storage_service
 import logging
 
 logger = logging.getLogger(__name__)
@@ -144,7 +146,7 @@ def auditar_procesamiento_remesa_por_pedimento(pedimento_id):
             xml_data = extraer_coves(pedimento)
             if xml_data:
                 for remesa in xml_data:
-                    numero_cove = remesa.get('remesaSA')
+                    numero_cove = remesa.get('comprobanteVE')
                     cove, creado = Cove.objects.get_or_create(
                         pedimento=pedimento,
                         numero_cove=numero_cove,
@@ -533,6 +535,939 @@ def auditar_acuse_por_pedimento(pedimento_id):
     except Exception as e:
         return {'success': False, 'error': str(e), 'pedimento_id': str(pedimento_id)}
 
+def _leer_xml_documento(documento):
+    """Lee el contenido de un documento desde MinIO (o filesystem de fallback)."""
+    ruta = str(documento.archivo)
+    with tempfile.NamedTemporaryFile(delete=False, suffix='.xml') as tmp:
+        tmp_path = tmp.name
+    try:
+        success = storage_service.download_file(ruta, tmp_path)
+        if not success:
+            logger.error(f"storage_service.download_file falló para {ruta}")
+            return None
+        with open(tmp_path, 'r', encoding='utf-8', errors='ignore') as f:
+            return f.read()
+    except Exception as exc:
+        logger.error(f"Error leyendo documento {ruta}: {exc}")
+        return None
+    finally:
+        if os.path.exists(tmp_path):
+            os.unlink(tmp_path)
+
+
+def _leer_xml_pedimento_completo(pedimento):
+    """Lee el XML del pedimento completo (document_type=2) vía storage_service."""
+    pc = pedimento.documents.filter(document_type__id=2).first()
+    if not pc:
+        return None
+    return _leer_xml_documento(pc)
+
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Auditorías de integridad: comprueban que los registros en DB coincidan con
+# lo que declara el XML del pedimento completo o la remesa.
+# Son de solo lectura — no crean ni modifican registros de negocio.
+# ──────────────────────────────────────────────────────────────────────────────
+
+@shared_task(bind=True)
+def auditar_integridad_partidas(self, organizacion_id, user_id=None):
+    """
+    Compara pedimento.numero_partidas (extraído del XML) vs partidas.count() en DB.
+    Detecta pedimentos donde faltan registros de Partida sin crear ninguno.
+    """
+    task_id = self.request.id
+    pedimentos = obtener_pedimentos(organizacion_id)
+    total_pedimentos = pedimentos.count()
+
+    publish_task_event(task_id, "processing", f"Auditando integridad de partidas: {total_pedimentos} pedimentos", progress=0)
+
+    completados = []
+    sin_datos_xml = []
+    con_faltantes = []
+    errores = []
+
+    for idx, pedimento in enumerate(pedimentos):
+        try:
+            num_esperadas = pedimento.numero_partidas
+            num_en_db = pedimento.partidas.count()
+
+            if not num_esperadas or num_esperadas <= 0:
+                sin_datos_xml.append({
+                    'pedimento_id': str(pedimento.id),
+                    'pedimento': pedimento.pedimento,
+                    'razon': f'numero_partidas no definido ({num_esperadas})',
+                })
+                continue
+
+            if num_en_db >= num_esperadas:
+                modificar_estado_procesamiento(pedimento, servicio_id=4, nuevo_estado=3)
+                completados.append(str(pedimento.id))
+            else:
+                modificar_estado_procesamiento(pedimento, servicio_id=4, nuevo_estado=4)
+                con_faltantes.append({
+                    'pedimento_id': str(pedimento.id),
+                    'pedimento': pedimento.pedimento,
+                    'esperadas': num_esperadas,
+                    'en_db': num_en_db,
+                    'faltantes': num_esperadas - num_en_db,
+                })
+
+        except Exception as exc:
+            errores.append({'pedimento_id': str(pedimento.id), 'pedimento': pedimento.pedimento, 'error': str(exc)})
+            logger.error(f"Error auditando integridad de partidas para pedimento {pedimento.id}: {exc}")
+
+        if total_pedimentos > 0 and (idx + 1) % 10 == 0:
+            pct = int(((idx + 1) / total_pedimentos) * 100)
+            publish_task_event(task_id, "processing", f"Auditando partidas: {idx + 1}/{total_pedimentos}", progress=pct)
+
+    resultado = {
+        'organizacion_id': str(organizacion_id),
+        'auditoria': 'integridad_partidas',
+        'total_pedimentos': total_pedimentos,
+        'completados': len(completados),
+        'sin_datos_xml': len(sin_datos_xml),
+        'con_faltantes': len(con_faltantes),
+        'con_errores': len(errores),
+        'detalle_faltantes': con_faltantes,
+        'detalle_sin_datos': sin_datos_xml,
+        'detalle_errores': errores,
+    }
+
+    publish_task_event(task_id, "completed", "Auditoría de integridad de partidas completada", resultado=resultado, progress=100)
+    if user_id:
+        _crear_notificacion_auditoria(user_id, task_id, "Integridad de Partidas", resultado)
+
+    return resultado
+
+
+@shared_task
+def auditar_integridad_partidas_por_pedimento(pedimento_id):
+    """Versión por pedimento de auditar_integridad_partidas."""
+    try:
+        pedimento = Pedimento.objects.get(id=pedimento_id)
+        num_esperadas = pedimento.numero_partidas
+        num_en_db = pedimento.partidas.count()
+
+        if not num_esperadas or num_esperadas <= 0:
+            return {
+                'pedimento_id': str(pedimento_id),
+                'pedimento': pedimento.pedimento,
+                'estado': 'sin_datos_xml',
+                'mensaje': f'numero_partidas no definido ({num_esperadas})',
+            }
+
+        if num_en_db >= num_esperadas:
+            modificar_estado_procesamiento(pedimento, servicio_id=4, nuevo_estado=3)
+            return {
+                'pedimento_id': str(pedimento_id),
+                'pedimento': pedimento.pedimento,
+                'estado': 'completado',
+                'esperadas': num_esperadas,
+                'en_db': num_en_db,
+            }
+
+        modificar_estado_procesamiento(pedimento, servicio_id=4, nuevo_estado=4)
+        return {
+            'pedimento_id': str(pedimento_id),
+            'pedimento': pedimento.pedimento,
+            'estado': 'incompleto',
+            'esperadas': num_esperadas,
+            'en_db': num_en_db,
+            'faltantes': num_esperadas - num_en_db,
+        }
+
+    except Pedimento.DoesNotExist:
+        return {'error': f'Pedimento {pedimento_id} no encontrado'}
+    except Exception as exc:
+        return {'error': str(exc), 'pedimento_id': str(pedimento_id)}
+
+
+@shared_task(bind=True)
+def auditar_integridad_edocuments(self, organizacion_id, user_id=None):
+    """
+    Compara la lista de e-documentos (identificadores_ed) del XML del pedimento completo
+    vs los EDocuments registrados en DB. Detecta registros faltantes sin crear nada.
+    """
+    task_id = self.request.id
+    pedimentos = obtener_pedimentos(organizacion_id)
+    total_pedimentos = pedimentos.count()
+
+    publish_task_event(task_id, "processing", f"Auditando integridad de edocuments: {total_pedimentos} pedimentos", progress=0)
+
+    completados = []
+    sin_xml = []
+    con_faltantes = []
+    errores = []
+
+    for idx, pedimento in enumerate(pedimentos):
+        try:
+            xml_content = _leer_xml_pedimento_completo(pedimento)
+            if not xml_content:
+                sin_xml.append({'pedimento_id': str(pedimento.id), 'pedimento': pedimento.pedimento})
+                continue
+
+            xml_data = xml_controller.extract_data(xml_content)
+            edocs_xml = xml_data.get('identificadores_ed', []) or []
+
+            numeros_xml = {e.get('complemento1') for e in edocs_xml if e.get('complemento1')}
+            numeros_db = set(pedimento.documentos.values_list('numero_edocument', flat=True))
+
+            faltantes_en_db = numeros_xml - numeros_db
+
+            if not faltantes_en_db:
+                modificar_estado_procesamiento(pedimento, servicio_id=7, nuevo_estado=3)
+                completados.append(str(pedimento.id))
+            else:
+                modificar_estado_procesamiento(pedimento, servicio_id=7, nuevo_estado=4)
+                con_faltantes.append({
+                    'pedimento_id': str(pedimento.id),
+                    'pedimento': pedimento.pedimento,
+                    'esperados_xml': len(numeros_xml),
+                    'en_db': len(numeros_db),
+                    'faltantes_en_db': sorted(faltantes_en_db),
+                })
+
+        except Exception as exc:
+            errores.append({'pedimento_id': str(pedimento.id), 'pedimento': pedimento.pedimento, 'error': str(exc)})
+            logger.error(f"Error auditando integridad de edocuments para pedimento {pedimento.id}: {exc}")
+
+        if total_pedimentos > 0 and (idx + 1) % 10 == 0:
+            pct = int(((idx + 1) / total_pedimentos) * 100)
+            publish_task_event(task_id, "processing", f"Auditando edocuments: {idx + 1}/{total_pedimentos}", progress=pct)
+
+    resultado = {
+        'organizacion_id': str(organizacion_id),
+        'auditoria': 'integridad_edocuments',
+        'total_pedimentos': total_pedimentos,
+        'completados': len(completados),
+        'sin_xml': len(sin_xml),
+        'con_faltantes': len(con_faltantes),
+        'con_errores': len(errores),
+        'detalle_faltantes': con_faltantes,
+        'detalle_sin_xml': sin_xml,
+        'detalle_errores': errores,
+    }
+
+    publish_task_event(task_id, "completed", "Auditoría de integridad de edocuments completada", resultado=resultado, progress=100)
+    if user_id:
+        _crear_notificacion_auditoria(user_id, task_id, "Integridad de EDocuments", resultado)
+
+    return resultado
+
+
+@shared_task
+def auditar_integridad_edocuments_por_pedimento(pedimento_id):
+    """Versión por pedimento de auditar_integridad_edocuments."""
+    try:
+        pedimento = Pedimento.objects.get(id=pedimento_id)
+        xml_content = _leer_xml_pedimento_completo(pedimento)
+        if not xml_content:
+            return {
+                'pedimento_id': str(pedimento_id),
+                'pedimento': pedimento.pedimento,
+                'estado': 'sin_xml',
+                'mensaje': 'No hay pedimento completo (document_type=2) descargado',
+            }
+
+        xml_data = xml_controller.extract_data(xml_content)
+        edocs_xml = xml_data.get('identificadores_ed', []) or []
+
+        numeros_xml = {e.get('complemento1') for e in edocs_xml if e.get('complemento1')}
+        numeros_db = set(pedimento.documentos.values_list('numero_edocument', flat=True))
+        faltantes_en_db = numeros_xml - numeros_db
+
+        if not faltantes_en_db:
+            modificar_estado_procesamiento(pedimento, servicio_id=7, nuevo_estado=3)
+            return {
+                'pedimento_id': str(pedimento_id),
+                'pedimento': pedimento.pedimento,
+                'estado': 'completado',
+                'esperados_xml': len(numeros_xml),
+                'en_db': len(numeros_db),
+            }
+
+        modificar_estado_procesamiento(pedimento, servicio_id=7, nuevo_estado=4)
+        return {
+            'pedimento_id': str(pedimento_id),
+            'pedimento': pedimento.pedimento,
+            'estado': 'incompleto',
+            'esperados_xml': len(numeros_xml),
+            'en_db': len(numeros_db),
+            'faltantes_en_db': sorted(faltantes_en_db),
+        }
+
+    except Pedimento.DoesNotExist:
+        return {'error': f'Pedimento {pedimento_id} no encontrado'}
+    except Exception as exc:
+        return {'error': str(exc), 'pedimento_id': str(pedimento_id)}
+
+
+@shared_task(bind=True)
+def auditar_integridad_coves(self, organizacion_id, user_id=None):
+    """Verifica que los COVEs listados en el XML del pedimento completo existan en DB (nivel org)."""
+    task_id = self.request.id
+    pedimentos = obtener_pedimentos(organizacion_id)
+    total_pedimentos = pedimentos.count()
+
+    publish_task_event(task_id, "processing", f"Auditando integridad de COVEs (PC XML): {total_pedimentos} pedimentos", progress=0)
+
+    completados = []
+    sin_xml = []
+    con_faltantes = []
+    errores = []
+
+    for idx, pedimento in enumerate(pedimentos):
+        try:
+            xml_content = _leer_xml_pedimento_completo(pedimento)
+            if not xml_content:
+                sin_xml.append({'pedimento_id': str(pedimento.id), 'pedimento': pedimento.pedimento})
+                continue
+
+            xml_data = xml_controller.extract_data(xml_content)
+            coves_xml = set(xml_data.get('coves', []) or [])
+            coves_db = set(pedimento.coves.values_list('numero_cove', flat=True))
+
+            faltantes = coves_xml - coves_db
+            if faltantes:
+                modificar_estado_procesamiento(pedimento, servicio_id=8, nuevo_estado=4)
+                con_faltantes.append({
+                    'pedimento_id': str(pedimento.id),
+                    'pedimento': pedimento.pedimento,
+                    'coves_xml': len(coves_xml),
+                    'coves_db': len(coves_db),
+                    'faltantes': sorted(faltantes),
+                })
+            else:
+                modificar_estado_procesamiento(pedimento, servicio_id=8, nuevo_estado=3)
+                completados.append(str(pedimento.id))
+
+        except Exception as exc:
+            errores.append({'pedimento_id': str(pedimento.id), 'pedimento': pedimento.pedimento, 'error': str(exc)})
+            logger.error(f"Error auditando integridad de COVEs para pedimento {pedimento.id}: {exc}")
+
+        if total_pedimentos > 0 and (idx + 1) % 10 == 0:
+            pct = int(((idx + 1) / total_pedimentos) * 100)
+            publish_task_event(task_id, "processing", f"Auditando COVEs: {idx + 1}/{total_pedimentos}", progress=pct)
+
+    resultado = {
+        'organizacion_id': str(organizacion_id),
+        'auditoria': 'integridad_coves',
+        'total_pedimentos': total_pedimentos,
+        'completados': len(completados),
+        'sin_xml': len(sin_xml),
+        'con_faltantes': len(con_faltantes),
+        'con_errores': len(errores),
+        'detalle_faltantes': con_faltantes,
+        'detalle_sin_xml': sin_xml,
+        'detalle_errores': errores,
+    }
+
+    publish_task_event(task_id, "completed", "Auditoría de integridad de COVEs completada", resultado=resultado, progress=100)
+    if user_id:
+        _crear_notificacion_auditoria(user_id, task_id, "Integridad de COVEs", resultado)
+
+    return resultado
+
+
+@shared_task(bind=True)
+def auditar_integridad_remesa(self, organizacion_id, user_id=None):
+    """Verifica que los COVEs declarados en el XML de remesa existan en DB (nivel org)."""
+    task_id = self.request.id
+    pedimentos = obtener_pedimentos(organizacion_id).filter(remesas=True)
+    total_pedimentos = pedimentos.count()
+
+    publish_task_event(task_id, "processing", f"Auditando integridad de remesas: {total_pedimentos} pedimentos con remesas", progress=0)
+
+    completados = []
+    sin_xml = []
+    con_faltantes = []
+    errores = []
+
+    for idx, pedimento in enumerate(pedimentos):
+        try:
+            doc_remesa = pedimento.documents.filter(document_type=3).first()
+            if not doc_remesa:
+                sin_xml.append({'pedimento_id': str(pedimento.id), 'pedimento': pedimento.pedimento, 'razon': 'Sin documento remesa (type=3)'})
+                continue
+
+            remesa_xml = _leer_xml_documento(doc_remesa)
+            if not remesa_xml:
+                sin_xml.append({'pedimento_id': str(pedimento.id), 'pedimento': pedimento.pedimento, 'razon': 'No se pudo leer el XML de remesa'})
+                continue
+
+            remesa_data = xml_remesas_controller.extract_remesas(remesa_xml)
+            coves_de_remesa = {r.get('comprobanteVE') for r in remesa_data if r.get('comprobanteVE')}
+            coves_db = set(pedimento.coves.values_list('numero_cove', flat=True))
+
+            faltantes = coves_de_remesa - coves_db
+            if faltantes:
+                modificar_estado_procesamiento(pedimento, servicio_id=8, nuevo_estado=4)
+                con_faltantes.append({
+                    'pedimento_id': str(pedimento.id),
+                    'pedimento': pedimento.pedimento,
+                    'total_en_remesa': len(coves_de_remesa),
+                    'en_db': len(coves_db),
+                    'faltantes': sorted(faltantes),
+                })
+            else:
+                completados.append(str(pedimento.id))
+
+        except Exception as exc:
+            errores.append({'pedimento_id': str(pedimento.id), 'pedimento': pedimento.pedimento, 'error': str(exc)})
+            logger.error(f"Error auditando integridad de remesa para pedimento {pedimento.id}: {exc}")
+
+        if total_pedimentos > 0 and (idx + 1) % 10 == 0:
+            pct = int(((idx + 1) / total_pedimentos) * 100)
+            publish_task_event(task_id, "processing", f"Auditando remesas: {idx + 1}/{total_pedimentos}", progress=pct)
+
+    resultado = {
+        'organizacion_id': str(organizacion_id),
+        'auditoria': 'integridad_remesa',
+        'total_pedimentos': total_pedimentos,
+        'completados': len(completados),
+        'sin_xml': len(sin_xml),
+        'con_faltantes': len(con_faltantes),
+        'con_errores': len(errores),
+        'detalle_faltantes': con_faltantes,
+        'detalle_sin_xml': sin_xml,
+        'detalle_errores': errores,
+    }
+
+    publish_task_event(task_id, "completed", "Auditoría de integridad de remesas completada", resultado=resultado, progress=100)
+    if user_id:
+        _crear_notificacion_auditoria(user_id, task_id, "Integridad de Remesas", resultado)
+
+    return resultado
+
+
+@shared_task
+def auditar_integridad_coves_por_pedimento(pedimento_id):
+    """Verifica que los COVEs del PC XML existan en DB para un pedimento específico."""
+    try:
+        pedimento = Pedimento.objects.get(id=pedimento_id)
+
+        xml_content = _leer_xml_pedimento_completo(pedimento)
+        if not xml_content:
+            return {
+                'pedimento_id': str(pedimento_id),
+                'pedimento': pedimento.pedimento,
+                'estado': 'sin_xml',
+                'mensaje': 'No hay pedimento completo (document_type=2) descargado',
+            }
+
+        xml_data = xml_controller.extract_data(xml_content)
+        coves_xml = set(xml_data.get('coves', []) or [])
+        coves_db = set(pedimento.coves.values_list('numero_cove', flat=True))
+
+        faltantes = coves_xml - coves_db
+        if not faltantes:
+            modificar_estado_procesamiento(pedimento, servicio_id=8, nuevo_estado=3)
+            return {
+                'pedimento_id': str(pedimento_id),
+                'pedimento': pedimento.pedimento,
+                'estado': 'completado',
+                'coves_xml': len(coves_xml),
+                'coves_db': len(coves_db),
+            }
+
+        modificar_estado_procesamiento(pedimento, servicio_id=8, nuevo_estado=4)
+        return {
+            'pedimento_id': str(pedimento_id),
+            'pedimento': pedimento.pedimento,
+            'estado': 'incompleto',
+            'coves_xml': len(coves_xml),
+            'coves_db': len(coves_db),
+            'faltantes': sorted(faltantes),
+        }
+
+    except Pedimento.DoesNotExist:
+        return {'error': f'Pedimento {pedimento_id} no encontrado'}
+    except Exception as exc:
+        return {'error': str(exc), 'pedimento_id': str(pedimento_id)}
+
+
+@shared_task
+def auditar_integridad_remesa_por_pedimento(pedimento_id):
+    """Verifica que los COVEs del XML de remesa existan en DB para un pedimento específico.
+
+    Deduce si el pedimento es consolidado desde el identificador PC del XML del
+    pedimento completo (fuente de verdad) en lugar del flag `remesas`. Si es
+    consolidado y no hay documento de remesa descargado, dispara la consulta a VUCEM.
+    """
+    # Import local para evitar import circular (internal_services importa de auditoria)
+    from api.customs.tasks.internal_services import crear_procesamiento_remesa
+
+    try:
+        pedimento = Pedimento.objects.get(id=pedimento_id)
+
+        xml_pc = _leer_xml_pedimento_completo(pedimento)
+        if not xml_pc:
+            return {
+                'pedimento_id': str(pedimento_id),
+                'pedimento': pedimento.pedimento,
+                'estado': 'sin_xml_pc',
+                'mensaje': 'No hay pedimento completo (document_type=2) descargado',
+            }
+
+        xml_data = xml_controller.extract_data(xml_pc)
+        if not xml_data:
+            return {
+                'pedimento_id': str(pedimento_id),
+                'pedimento': pedimento.pedimento,
+                'estado': 'error',
+                'mensaje': 'No se pudieron extraer datos del XML del pedimento completo',
+            }
+
+        tiene_remesas = bool(xml_data.get('remesas'))
+
+        # Sincronizar el flag con queryset.update() para no disparar el signal
+        # post_save; la consulta a VUCEM se dispara explícitamente abajo
+        if tiene_remesas != pedimento.remesas:
+            Pedimento.objects.filter(id=pedimento.id).update(remesas=tiene_remesas)
+            pedimento.remesas = tiene_remesas
+
+        if not tiene_remesas:
+            return {
+                'pedimento_id': str(pedimento_id),
+                'pedimento': pedimento.pedimento,
+                'estado': 'sin_remesas',
+                'mensaje': 'El pedimento completo no declara identificador PC (consolidado)',
+            }
+
+        doc_remesa = pedimento.documents.filter(document_type=3).first()
+        if not doc_remesa:
+            # Consolidado sin XML de remesa: solicitar la descarga a VUCEM
+            crear_procesamiento_remesa.apply_async(args=[str(pedimento.id)])
+            return {
+                'pedimento_id': str(pedimento_id),
+                'pedimento': pedimento.pedimento,
+                'estado': 'descarga_solicitada',
+                'mensaje': 'Pedimento consolidado sin documento de remesa; se solicitó la consulta a VUCEM',
+            }
+
+        remesa_xml = _leer_xml_documento(doc_remesa)
+        if not remesa_xml:
+            return {
+                'pedimento_id': str(pedimento_id),
+                'pedimento': pedimento.pedimento,
+                'estado': 'sin_xml',
+                'mensaje': 'No se pudo leer el archivo de remesa',
+            }
+
+        remesa_data = xml_remesas_controller.extract_remesas(remesa_xml)
+        coves_de_remesa = {r.get('comprobanteVE') for r in remesa_data if r.get('comprobanteVE')}
+        coves_db = set(pedimento.coves.values_list('numero_cove', flat=True))
+
+        faltantes = coves_de_remesa - coves_db
+        if not faltantes:
+            return {
+                'pedimento_id': str(pedimento_id),
+                'pedimento': pedimento.pedimento,
+                'estado': 'completado',
+                'total_en_remesa': len(coves_de_remesa),
+                'coves_db': len(coves_db),
+            }
+
+        modificar_estado_procesamiento(pedimento, servicio_id=8, nuevo_estado=4)
+        return {
+            'pedimento_id': str(pedimento_id),
+            'pedimento': pedimento.pedimento,
+            'estado': 'incompleto',
+            'total_en_remesa': len(coves_de_remesa),
+            'coves_db': len(coves_db),
+            'faltantes': sorted(faltantes),
+        }
+
+    except Pedimento.DoesNotExist:
+        return {'error': f'Pedimento {pedimento_id} no encontrado'}
+    except Exception as exc:
+        return {'error': str(exc), 'pedimento_id': str(pedimento_id)}
+
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Correcciones de integridad: crean registros faltantes en DB y disparan
+# procesamiento VUCEM. Helpers sincrónicos + tasks Celery para nivel org.
+# ──────────────────────────────────────────────────────────────────────────────
+
+def _corregir_integridad_partidas_pedimento(pedimento):
+    """Crea Partida records faltantes y dispara procesar_partida_individual."""
+    from api.customs.models import Partida
+    from api.customs.tasks.microservice import procesar_partida_individual
+
+    num_esperadas = pedimento.numero_partidas
+    if not num_esperadas or num_esperadas <= 0:
+        return {
+            'pedimento_id': str(pedimento.id),
+            'pedimento': pedimento.pedimento,
+            'estado': 'sin_datos',
+            'razon': f'numero_partidas no definido ({num_esperadas})',
+        }
+
+    num_en_db = pedimento.partidas.count()
+    creadas = 0
+    for i in range(1, num_esperadas + 1):
+        _, created = Partida.objects.get_or_create(
+            pedimento=pedimento,
+            numero_partida=i,
+            defaults={'organizacion_id': pedimento.organizacion_id},
+        )
+        if created:
+            creadas += 1
+
+    if creadas > 0:
+        procesar_partida_individual.apply_async(args=[str(pedimento.id), str(pedimento.organizacion.id)])
+
+    return {
+        'pedimento_id': str(pedimento.id),
+        'pedimento': pedimento.pedimento,
+        'estado': 'corregido',
+        'partidas_en_db_antes': num_en_db,
+        'esperadas': num_esperadas,
+        'creadas': creadas,
+        'procesamiento_iniciado': creadas > 0,
+    }
+
+
+def _corregir_integridad_edocuments_pedimento(pedimento):
+    """Crea EDocument records faltantes desde el XML del pedimento completo y dispara procesamiento."""
+    from api.customs.tasks.microservice import procesar_edoc_individual
+
+    xml_content = _leer_xml_pedimento_completo(pedimento)
+    if not xml_content:
+        return {
+            'pedimento_id': str(pedimento.id),
+            'pedimento': pedimento.pedimento,
+            'estado': 'sin_xml',
+        }
+
+    xml_data = xml_controller.extract_data(xml_content)
+    edocs_xml = xml_data.get('identificadores_ed', []) or []
+
+    creados = []
+    for edoc in edocs_xml:
+        numero = edoc.get('complemento1')
+        if not numero:
+            continue
+        try:
+            _, created = EDocument.objects.get_or_create(
+                pedimento=pedimento,
+                organizacion=pedimento.organizacion,
+                numero_edocument=numero,
+                defaults={
+                    'clave': edoc.get('clave', ''),
+                    'descripcion': edoc.get('descripcion', ''),
+                },
+            )
+            if created:
+                creados.append(numero)
+        except Exception as exc:
+            logger.error(f"Error creando EDocument {numero} para pedimento {pedimento.id}: {exc}")
+
+    if pedimento.documentos.exists():
+        procesar_edoc_individual.apply_async(args=[str(pedimento.id), str(pedimento.organizacion.id)])
+
+    return {
+        'pedimento_id': str(pedimento.id),
+        'pedimento': pedimento.pedimento,
+        'estado': 'corregido',
+        'edocuments_creados': creados,
+        'procesamiento_iniciado': pedimento.documentos.exists(),
+    }
+
+
+def _corregir_integridad_coves_pedimento(pedimento):
+    """Crea COVE records faltantes del PC XML y dispara procesar_cove_individual."""
+    from api.customs.tasks.microservice import procesar_cove_individual
+
+    xml_content = _leer_xml_pedimento_completo(pedimento)
+    if not xml_content:
+        return {
+            'pedimento_id': str(pedimento.id),
+            'pedimento': pedimento.pedimento,
+            'estado': 'sin_xml',
+        }
+
+    xml_data = xml_controller.extract_data(xml_content)
+    coves_xml = xml_data.get('coves', []) or []
+
+    creados = []
+    for numero_cove in coves_xml:
+        try:
+            _, created = Cove.objects.get_or_create(
+                pedimento=pedimento,
+                organizacion=pedimento.organizacion,
+                numero_cove=numero_cove,
+            )
+            if created:
+                creados.append(numero_cove)
+        except Exception:
+            pass
+
+    coves_procesados = False
+    if pedimento.coves.exists():
+        procesar_cove_individual.apply_async(args=[str(pedimento.id), str(pedimento.organizacion.id)])
+        coves_procesados = True
+
+    return {
+        'pedimento_id': str(pedimento.id),
+        'pedimento': pedimento.pedimento,
+        'estado': 'corregido',
+        'coves_creados': creados,
+        'procesamiento_iniciado': coves_procesados,
+    }
+
+
+def _corregir_integridad_remesa_pedimento(pedimento):
+    """
+    Crea COVE records faltantes del XML de remesa y dispara procesamiento.
+    Si no hay XML de remesa, dispara procesar_remesa_individual para descargarlo.
+    """
+    from api.customs.tasks.microservice import procesar_cove_individual, procesar_remesa_individual
+
+    if not pedimento.remesas:
+        return {
+            'pedimento_id': str(pedimento.id),
+            'pedimento': pedimento.pedimento,
+            'estado': 'sin_remesas',
+            'mensaje': 'Este pedimento no tiene remesas',
+        }
+
+    doc_remesa = pedimento.documents.filter(document_type=3).first()
+    if not doc_remesa:
+        procesar_remesa_individual.apply_async(args=[str(pedimento.id), str(pedimento.organizacion.id)])
+        return {
+            'pedimento_id': str(pedimento.id),
+            'pedimento': pedimento.pedimento,
+            'estado': 'remesa_iniciada',
+            'mensaje': 'XML de remesa no disponible — se inició la búsqueda en VUCEM',
+            'procesamiento_remesa_iniciado': True,
+        }
+
+    remesa_xml = _leer_xml_documento(doc_remesa)
+    if not remesa_xml:
+        procesar_remesa_individual.apply_async(args=[str(pedimento.id), str(pedimento.organizacion.id)])
+        return {
+            'pedimento_id': str(pedimento.id),
+            'pedimento': pedimento.pedimento,
+            'estado': 'remesa_iniciada',
+            'mensaje': 'No se pudo leer el XML de remesa — se reintentará la búsqueda en VUCEM',
+            'procesamiento_remesa_iniciado': True,
+        }
+
+    remesa_data = xml_remesas_controller.extract_remesas(remesa_xml)
+    creados = []
+    for r in remesa_data:
+        numero_cove = r.get('comprobanteVE')
+        if numero_cove:
+            try:
+                _, created = Cove.objects.get_or_create(
+                    pedimento=pedimento,
+                    organizacion=pedimento.organizacion,
+                    numero_cove=numero_cove,
+                )
+                if created:
+                    creados.append(numero_cove)
+            except Exception:
+                pass
+
+    coves_procesados = False
+    if pedimento.coves.exists():
+        procesar_cove_individual.apply_async(args=[str(pedimento.id), str(pedimento.organizacion.id)])
+        coves_procesados = True
+
+    return {
+        'pedimento_id': str(pedimento.id),
+        'pedimento': pedimento.pedimento,
+        'estado': 'corregido',
+        'coves_creados': creados,
+        'procesamiento_coves_iniciado': coves_procesados,
+    }
+
+
+@shared_task(bind=True)
+def corregir_integridad_partidas(self, organizacion_id, user_id=None):
+    """Crea Partida records faltantes en todos los pedimentos de la org y dispara procesamiento."""
+    task_id = self.request.id
+    pedimentos = obtener_pedimentos(organizacion_id)
+    total = pedimentos.count()
+
+    publish_task_event(task_id, "processing", f"Corrigiendo integridad de partidas: {total} pedimentos", progress=0)
+
+    corregidos = []
+    sin_datos = []
+    errores = []
+
+    for idx, pedimento in enumerate(pedimentos):
+        try:
+            res = _corregir_integridad_partidas_pedimento(pedimento)
+            if res['estado'] == 'sin_datos':
+                sin_datos.append({'pedimento': pedimento.pedimento, 'razon': res.get('razon')})
+            elif res.get('creadas', 0) > 0:
+                corregidos.append({'pedimento': pedimento.pedimento, 'creadas': res['creadas']})
+        except Exception as exc:
+            errores.append({'pedimento': pedimento.pedimento, 'error': str(exc)})
+            logger.error(f"Error corrigiendo partidas de pedimento {pedimento.id}: {exc}")
+
+        if total > 0 and (idx + 1) % 10 == 0:
+            pct = int(((idx + 1) / total) * 100)
+            publish_task_event(task_id, "processing", f"Corrigiendo partidas: {idx + 1}/{total}", progress=pct)
+
+    resultado = {
+        'organizacion_id': str(organizacion_id),
+        'auditoria': 'correccion_partidas',
+        'total_pedimentos': total,
+        'con_nuevas_partidas': len(corregidos),
+        'sin_datos': len(sin_datos),
+        'con_errores': len(errores),
+        'detalle_corregidos': corregidos,
+        'detalle_errores': errores,
+    }
+
+    publish_task_event(task_id, "completed", "Corrección de integridad de partidas completada", resultado=resultado, progress=100)
+    if user_id:
+        _crear_notificacion_auditoria(user_id, task_id, "Corrección de Partidas", resultado)
+
+    return resultado
+
+
+@shared_task(bind=True)
+def corregir_integridad_edocuments(self, organizacion_id, user_id=None):
+    """Crea EDocument records faltantes en todos los pedimentos de la org y dispara procesamiento."""
+    task_id = self.request.id
+    pedimentos = obtener_pedimentos(organizacion_id)
+    total = pedimentos.count()
+
+    publish_task_event(task_id, "processing", f"Corrigiendo integridad de edocuments: {total} pedimentos", progress=0)
+
+    corregidos = []
+    sin_xml = []
+    errores = []
+
+    for idx, pedimento in enumerate(pedimentos):
+        try:
+            res = _corregir_integridad_edocuments_pedimento(pedimento)
+            if res['estado'] == 'sin_xml':
+                sin_xml.append({'pedimento': pedimento.pedimento})
+            elif res.get('edocuments_creados'):
+                corregidos.append({'pedimento': pedimento.pedimento, 'creados': res['edocuments_creados']})
+        except Exception as exc:
+            errores.append({'pedimento': pedimento.pedimento, 'error': str(exc)})
+            logger.error(f"Error corrigiendo edocuments de pedimento {pedimento.id}: {exc}")
+
+        if total > 0 and (idx + 1) % 10 == 0:
+            pct = int(((idx + 1) / total) * 100)
+            publish_task_event(task_id, "processing", f"Corrigiendo edocuments: {idx + 1}/{total}", progress=pct)
+
+    resultado = {
+        'organizacion_id': str(organizacion_id),
+        'auditoria': 'correccion_edocuments',
+        'total_pedimentos': total,
+        'con_nuevos_edocuments': len(corregidos),
+        'sin_xml': len(sin_xml),
+        'con_errores': len(errores),
+        'detalle_corregidos': corregidos,
+        'detalle_errores': errores,
+    }
+
+    publish_task_event(task_id, "completed", "Corrección de integridad de edocuments completada", resultado=resultado, progress=100)
+    if user_id:
+        _crear_notificacion_auditoria(user_id, task_id, "Corrección de EDocuments", resultado)
+
+    return resultado
+
+
+@shared_task(bind=True)
+def corregir_integridad_coves(self, organizacion_id, user_id=None):
+    """Crea COVE records faltantes (PC XML) en todos los pedimentos de la org y dispara procesamiento."""
+    task_id = self.request.id
+    pedimentos = obtener_pedimentos(organizacion_id)
+    total = pedimentos.count()
+
+    publish_task_event(task_id, "processing", f"Corrigiendo integridad de COVEs: {total} pedimentos", progress=0)
+
+    corregidos = []
+    sin_xml = []
+    errores = []
+
+    for idx, pedimento in enumerate(pedimentos):
+        try:
+            res = _corregir_integridad_coves_pedimento(pedimento)
+            if res['estado'] == 'sin_xml':
+                sin_xml.append({'pedimento': pedimento.pedimento})
+            elif res.get('coves_creados'):
+                corregidos.append({'pedimento': pedimento.pedimento, 'creados': res['coves_creados']})
+        except Exception as exc:
+            errores.append({'pedimento': pedimento.pedimento, 'error': str(exc)})
+            logger.error(f"Error corrigiendo COVEs de pedimento {pedimento.id}: {exc}")
+
+        if total > 0 and (idx + 1) % 10 == 0:
+            pct = int(((idx + 1) / total) * 100)
+            publish_task_event(task_id, "processing", f"Corrigiendo COVEs: {idx + 1}/{total}", progress=pct)
+
+    resultado = {
+        'organizacion_id': str(organizacion_id),
+        'auditoria': 'correccion_coves',
+        'total_pedimentos': total,
+        'con_nuevos_coves': len(corregidos),
+        'sin_xml': len(sin_xml),
+        'con_errores': len(errores),
+        'detalle_corregidos': corregidos,
+        'detalle_errores': errores,
+    }
+
+    publish_task_event(task_id, "completed", "Corrección de integridad de COVEs completada", resultado=resultado, progress=100)
+    if user_id:
+        _crear_notificacion_auditoria(user_id, task_id, "Corrección de COVEs", resultado)
+
+    return resultado
+
+
+@shared_task(bind=True)
+def corregir_integridad_remesa(self, organizacion_id, user_id=None):
+    """Crea COVE records faltantes (remesa XML) en pedimentos con remesas y dispara procesamiento."""
+    task_id = self.request.id
+    pedimentos = obtener_pedimentos(organizacion_id).filter(remesas=True)
+    total = pedimentos.count()
+
+    publish_task_event(task_id, "processing", f"Corrigiendo integridad de remesas: {total} pedimentos con remesas", progress=0)
+
+    corregidos = []
+    sin_xml = []
+    errores = []
+
+    for idx, pedimento in enumerate(pedimentos):
+        try:
+            res = _corregir_integridad_remesa_pedimento(pedimento)
+            if res['estado'] in ('sin_xml', 'remesa_iniciada'):
+                sin_xml.append({'pedimento': pedimento.pedimento, 'estado': res['estado']})
+            elif res.get('coves_creados'):
+                corregidos.append({'pedimento': pedimento.pedimento, 'creados': res['coves_creados']})
+        except Exception as exc:
+            errores.append({'pedimento': pedimento.pedimento, 'error': str(exc)})
+            logger.error(f"Error corrigiendo remesa de pedimento {pedimento.id}: {exc}")
+
+        if total > 0 and (idx + 1) % 10 == 0:
+            pct = int(((idx + 1) / total) * 100)
+            publish_task_event(task_id, "processing", f"Corrigiendo remesas: {idx + 1}/{total}", progress=pct)
+
+    resultado = {
+        'organizacion_id': str(organizacion_id),
+        'auditoria': 'correccion_remesa',
+        'total_pedimentos': total,
+        'con_nuevos_coves': len(corregidos),
+        'sin_xml': len(sin_xml),
+        'con_errores': len(errores),
+        'detalle_corregidos': corregidos,
+        'detalle_errores': errores,
+    }
+
+    publish_task_event(task_id, "completed", "Corrección de integridad de remesas completada", resultado=resultado, progress=100)
+    if user_id:
+        _crear_notificacion_auditoria(user_id, task_id, "Corrección de Remesas", resultado)
+
+    return resultado
+
+
 @shared_task
 def auditar_pedimento_por_id(pedimento_id):
     """

api/customs/tasks/internal_services.py

@@ -215,7 +215,7 @@ def auditar_pedimentos(self, organizacion_id, user_id=None):
                 pedimento.fecha_pago = xml_data.get('fecha_pago')
                 pedimento.pedimento_app = xml_data.get('fecha_pago')[2:4] + "-" + pedimento.aduana[:2] + "-" + pedimento.patente + "-" + pedimento.pedimentodd
 
-                for edoc in xml_data.get('edocuments', []):
+                for edoc in xml_data.get('identificadores_ed', []):
                     EDocument.objects.get_or_create(
                         pedimento=pedimento,
                         organizacion=pedimento.organizacion,

api/customs/tasks/microservice_v2.py

@@ -5,8 +5,10 @@ from api.customs.models import *
 from api.record.models import *
 from api.customs.serializers import PedimentoSerializer
 from api.vucem.models import *
+from django.db.models import F
+from django.utils import timezone
 import requests
-from config.settings import SERVICE_API_URL_V2
+from config.settings import SERVICE_API_URL_V2, MAX_INTENTOS_AUTO
 from datetime import datetime
 import json
 import logging
@@ -77,16 +79,18 @@ def partida_to_dict(partida):
 
 @shared_task
 def procesar_coves_pedimento(pedimento_id):
+    # Flujo manual: incluye registros en 'error' y no aplica tope ni contador de intentos
     pedimento = Pedimento.objects.get(id=pedimento_id)
-    if pedimento.coves.filter(cove_descargado=False).exists():
+    estados_reprocesables = [EstadoDescarga.PENDIENTE, EstadoDescarga.ERROR]
+    if pedimento.coves.filter(cove_estado__in=estados_reprocesables).exists():
         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)
-        
+
         payload = {
-            "coves": [cove_to_dict(cove) for cove in pedimento.coves.filter(cove_descargado=False)],
+            "coves": [cove_to_dict(cove) for cove in pedimento.coves.filter(cove_estado__in=estados_reprocesables)],
             "pedimento": pedimento_dict,
             "credencial": credenciales_dict
         }
@@ -106,8 +110,10 @@ def procesar_coves_pedimento(pedimento_id):
 
 @shared_task
 def procesar_acuse_coves_pedimento(pedimento_id):
+    # Flujo manual: incluye registros en 'error' y no aplica tope ni contador de intentos
     pedimento = Pedimento.objects.get(id=pedimento_id)
-    if pedimento.coves.filter(acuse_cove_descargado=False).exists():
+    estados_reprocesables = [EstadoDescarga.PENDIENTE, EstadoDescarga.ERROR]
+    if pedimento.coves.filter(acuse_cove_estado__in=estados_reprocesables).exists():
         pedimento_dict = pedimento_to_dict(pedimento)
         credenciales = Vucem.objects.filter(
             id=CredencialesImportador.objects.filter(rfc=pedimento.contribuyente).first().vucem.id
@@ -115,7 +121,7 @@ def procesar_acuse_coves_pedimento(pedimento_id):
         credenciales_dict = credenciales_to_dict(credenciales)
 
         payload = {
-            "coves": [cove_to_dict(cove) for cove in pedimento.coves.filter(acuse_cove_descargado=False)],
+            "coves": [cove_to_dict(cove) for cove in pedimento.coves.filter(acuse_cove_estado__in=estados_reprocesables)],
             "pedimento": pedimento_dict,
             "credencial": credenciales_dict
         }
@@ -135,8 +141,10 @@ def procesar_acuse_coves_pedimento(pedimento_id):
 
 @shared_task
 def procesar_edocs_pedimento(pedimento_id):
+    # Flujo manual: incluye registros en 'error' y no aplica tope ni contador de intentos
     pedimento = Pedimento.objects.get(id=pedimento_id)
-    if pedimento.documentos.filter(edocument_descargado=False).exists():
+    estados_reprocesables = [EstadoDescarga.PENDIENTE, EstadoDescarga.ERROR]
+    if pedimento.documentos.filter(edocument_estado__in=estados_reprocesables).exists():
         pedimento_dict = pedimento_to_dict(pedimento)
         credenciales = Vucem.objects.filter(
             id=CredencialesImportador.objects.filter(rfc=pedimento.contribuyente).first().vucem.id
@@ -144,7 +152,7 @@ def procesar_edocs_pedimento(pedimento_id):
         credenciales_dict = credenciales_to_dict(credenciales)
 
         payload = {
-            "edocs": [edoc_to_dict(edoc) for edoc in pedimento.documentos.filter(edocument_descargado=False)],
+            "edocs": [edoc_to_dict(edoc) for edoc in pedimento.documentos.filter(edocument_estado__in=estados_reprocesables)],
             "pedimento": pedimento_dict,
             "credencial": credenciales_dict
         }
@@ -164,8 +172,10 @@ def procesar_edocs_pedimento(pedimento_id):
 
 @shared_task
 def procesar_acuses_pedimento(pedimento_id):
+    # Flujo manual: incluye registros en 'error' y no aplica tope ni contador de intentos
     pedimento = Pedimento.objects.get(id=pedimento_id)
-    if pedimento.documentos.filter(acuse_descargado=False).exists():
+    estados_reprocesables = [EstadoDescarga.PENDIENTE, EstadoDescarga.ERROR]
+    if pedimento.documentos.filter(acuse_estado__in=estados_reprocesables).exists():
         pedimento_dict = pedimento_to_dict(pedimento)
         credenciales = Vucem.objects.filter(
             id=CredencialesImportador.objects.filter(rfc=pedimento.contribuyente).first().vucem.id
@@ -173,7 +183,7 @@ def procesar_acuses_pedimento(pedimento_id):
         credenciales_dict = credenciales_to_dict(credenciales)
 
         payload = {
-            "edocs": [edoc_to_dict(edoc) for edoc in pedimento.documentos.filter(acuse_descargado=False)],
+            "edocs": [edoc_to_dict(edoc) for edoc in pedimento.documentos.filter(acuse_estado__in=estados_reprocesables)],
             "pedimento": pedimento_dict,
             "credencial": credenciales_dict
         }
@@ -381,20 +391,31 @@ def procesar_coves(organizacion_id):
         coves__isnull=False
     ).distinct()
     for pedimento in pedimentos:
-        if pedimento.coves.filter(cove_descargado=False).exists():  # Tipo 3: Remesa
+        # Compuerta del automático (T2026-05-027): solo 'pendiente' con intentos disponibles;
+        # registros en 'error' o con tope agotado solo se relanzan de forma manual
+        pendientes = pedimento.coves.filter(
+            cove_estado=EstadoDescarga.PENDIENTE,
+            cove_intentos__lt=MAX_INTENTOS_AUTO,
+        )
+        coves_batch = list(pendientes)
+        if coves_batch:
 
             # Convertir el pedimento a JSON usando el serializer
             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)
-            
+
             payload = {
-                "coves": [cove_to_dict(cove) for cove in pedimento.coves.filter(cove_descargado=False)],
+                "coves": [cove_to_dict(cove) for cove in coves_batch],
                 "pedimento": pedimento_dict,
                 "credencial": credenciales_dict
             }
-            
+
+            # Un ciclo de orquestación = un intento; los reintentos internos
+            # del worker (Celery/SOAP) pertenecen a este mismo intento
+            pendientes.update(cove_intentos=F('cove_intentos') + 1, ultimo_intento_at=timezone.now())
+
             try:
                 response = requests.post(
                     f"{SERVICE_API_URL_V2}/services/all/coves",
@@ -416,20 +437,29 @@ def procesar_acuse_coves(organizacion_id):
     ).distinct()
     
     for pedimento in pedimentos:
-        if pedimento.coves.filter(acuse_cove_descargado=False).exists():  # Tipo 3: Remesa
+        # Compuerta del automático (T2026-05-027): solo 'pendiente' con intentos disponibles
+        pendientes = pedimento.coves.filter(
+            acuse_cove_estado=EstadoDescarga.PENDIENTE,
+            acuse_cove_intentos__lt=MAX_INTENTOS_AUTO,
+        )
+        coves_batch = list(pendientes)
+        if coves_batch:
 
             # Convertir el pedimento a JSON usando el serializer
             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)
-            
+
             payload = {
-                "coves": [cove_to_dict(cove) for cove in pedimento.coves.filter(acuse_cove_descargado=False)],
+                "coves": [cove_to_dict(cove) for cove in coves_batch],
                 "pedimento": pedimento_dict,
                 "credencial": credenciales_dict
             }
-            
+
+            # Un ciclo de orquestación = un intento
+            pendientes.update(acuse_cove_intentos=F('acuse_cove_intentos') + 1, ultimo_intento_at=timezone.now())
+
             try:
                 response = requests.post(
                     f"{SERVICE_API_URL_V2}/services/all/acuse/cove/",
@@ -451,20 +481,29 @@ def procesar_acuses(organizacion_id):
     ).distinct()
 
     for pedimento in pedimentos:
-        if pedimento.documentos.filter(acuse_descargado=False).exists():  # Tipo 3: Remesa
+        # Compuerta del automático (T2026-05-027): solo 'pendiente' con intentos disponibles
+        pendientes = pedimento.documentos.filter(
+            acuse_estado=EstadoDescarga.PENDIENTE,
+            acuse_intentos__lt=MAX_INTENTOS_AUTO,
+        )
+        edocs_batch = list(pendientes)
+        if edocs_batch:
 
             # Convertir el pedimento a JSON usando el serializer
             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)
-            
+
             payload = {
-                "edocs": [edoc_to_dict(edoc) for edoc in pedimento.documentos.filter(acuse_descargado=False)],
+                "edocs": [edoc_to_dict(edoc) for edoc in edocs_batch],
                 "pedimento": pedimento_dict,
                 "credencial": credenciales_dict
             }
 
+            # Un ciclo de orquestación = un intento
+            pendientes.update(acuse_intentos=F('acuse_intentos') + 1, ultimo_intento_at=timezone.now())
+
             try:
                 response = requests.post(
                     f"{SERVICE_API_URL_V2}/services/all/acuse/pedimento/",
@@ -486,20 +525,29 @@ def procesar_edocs(organizacion_id):
     ).distinct()
     
     for pedimento in pedimentos:
-        if pedimento.documentos.filter(edocument_descargado=False).exists():  # Tipo 3: Remesa
+        # Compuerta del automático (T2026-05-027): solo 'pendiente' con intentos disponibles
+        pendientes = pedimento.documentos.filter(
+            edocument_estado=EstadoDescarga.PENDIENTE,
+            edocument_intentos__lt=MAX_INTENTOS_AUTO,
+        )
+        edocs_batch = list(pendientes)
+        if edocs_batch:
 
             # Convertir el pedimento a JSON usando el serializer
             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)
-            
+
             payload = {
-                "edocs": [edoc_to_dict(edoc) for edoc in pedimento.documentos.filter(edocument_descargado=False)],
+                "edocs": [edoc_to_dict(edoc) for edoc in edocs_batch],
                 "pedimento": pedimento_dict,
                 "credencial": credenciales_dict
             }
 
+            # Un ciclo de orquestación = un intento
+            pendientes.update(edocument_intentos=F('edocument_intentos') + 1, ultimo_intento_at=timezone.now())
+
             try:
                 response = requests.post(
                     f"{SERVICE_API_URL_V2}/services/download/all/edocs/",
@@ -660,3 +708,59 @@ def process_all_organizations():
         )
     return f"Dispatched {active_orgs.count()} organizations"
 
+@shared_task
+def reintentar_descargas_pendientes():
+    """
+    Reintento recurrente de descargas VUCEM (T2026-05-027): transiciona a 'error'
+    los registros que agotaron MAX_INTENTOS_AUTO y relanza los pendientes por
+    organización. El incremento del contador vive en las tareas procesar_*
+    (puerta común de todos los flujos automáticos), por lo que aquí solo se orquesta.
+    """
+    ahora = timezone.now()
+    mensaje_tope = (
+        f"Se agotaron {MAX_INTENTOS_AUTO} intentos automáticos de descarga; "
+        f"requiere reproceso manual"
+    )
+
+    # 1) Transicionar a 'error' lo que agotó el tope automático.
+    # update() no pasa por save(): sincronizar también el booleano legado y updated_at.
+    edocs_err = EDocument.objects.filter(
+        edocument_estado=EstadoDescarga.PENDIENTE,
+        edocument_intentos__gte=MAX_INTENTOS_AUTO,
+    ).update(edocument_estado=EstadoDescarga.ERROR, edocument_descargado=False,
+             ultimo_error=mensaje_tope, updated_at=ahora)
+    acuses_err = EDocument.objects.filter(
+        acuse_estado=EstadoDescarga.PENDIENTE,
+        acuse_intentos__gte=MAX_INTENTOS_AUTO,
+    ).update(acuse_estado=EstadoDescarga.ERROR, acuse_descargado=False,
+             ultimo_error=mensaje_tope, updated_at=ahora)
+    coves_err = Cove.objects.filter(
+        cove_estado=EstadoDescarga.PENDIENTE,
+        cove_intentos__gte=MAX_INTENTOS_AUTO,
+    ).update(cove_estado=EstadoDescarga.ERROR, cove_descargado=False,
+             ultimo_error=mensaje_tope, updated_at=ahora)
+    acuse_coves_err = Cove.objects.filter(
+        acuse_cove_estado=EstadoDescarga.PENDIENTE,
+        acuse_cove_intentos__gte=MAX_INTENTOS_AUTO,
+    ).update(acuse_cove_estado=EstadoDescarga.ERROR, acuse_cove_descargado=False,
+             ultimo_error=mensaje_tope, updated_at=ahora)
+
+    if edocs_err or acuses_err or coves_err or acuse_coves_err:
+        logger.info(
+            f"Tope de intentos agotado -> error: edocs={edocs_err}, acuses={acuses_err}, "
+            f"coves={coves_err}, acuse_coves={acuse_coves_err}"
+        )
+
+    # 2) Relanzar por organización (procesar_* aplica la compuerta e incrementa el contador)
+    active_orgs = Organizacion.objects.filter(
+        is_active=True,
+        is_verified=True,
+        apply_auto_download=True,
+    )
+    for org in active_orgs:
+        process_organization_batch.apply_async(
+            args=[str(org.id)],
+            queue='org_processing'
+        )
+    return f"Reintentos despachados para {active_orgs.count()} organizaciones"
+

api/customs/tests.py

@@ -224,3 +224,275 @@ class BulkCreateDocumentReplaceTests(APITestCase):
         self.assertIn(response.status_code, [status.HTTP_200_OK, status.HTTP_207_MULTI_STATUS, status.HTTP_201_CREATED])
         data = response.json()
         self.assertGreaterEqual(data.get("already_existing_count", 0), 1)
+
+
+# ---------------------------------------------------------------------------
+# Tests del comando fix_partidas_error
+# Una partida descargado=True solo es válida si alguno de sus documentos
+# contiene consultarPartidaRespuesta sin tieneError=true. Partidas que solo
+# tienen el REQUEST (o errores) deben volver a descargado=False.
+# ---------------------------------------------------------------------------
+
+from io import StringIO
+from types import SimpleNamespace
+from django.core.management import call_command
+from django.test import TestCase
+
+
+XML_RESPUESTA_VALIDA = (
+    "<?xml version='1.0' encoding='UTF-8'?>"
+    '<S:Envelope xmlns:S="http://schemas.xmlsoap.org/soap/envelope/"><S:Body>'
+    '<ns9:consultarPartidaRespuesta xmlns:ns9="http://www.ventanillaunica.gob.mx/pedimentos/ws/oxml/consultarpartida">'
+    "<tieneError>false</tieneError><ns9:partida/></ns9:consultarPartidaRespuesta>"
+    "</S:Body></S:Envelope>"
+)
+
+XML_ERROR_VUCEM = (
+    "<?xml version='1.0' encoding='UTF-8'?>"
+    '<S:Envelope xmlns:S="http://schemas.xmlsoap.org/soap/envelope/"><S:Body>'
+    '<ns9:consultarPartidaRespuesta xmlns:ns9="http://www.ventanillaunica.gob.mx/pedimentos/ws/oxml/consultarpartida">'
+    "<tieneError>true</tieneError></ns9:consultarPartidaRespuesta>"
+    "</S:Body></S:Envelope>"
+)
+
+XML_ECO_REQUEST = (
+    "<?xml version='1.0' encoding='UTF-8'?>"
+    '<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/"'
+    ' xmlns:con="http://www.ventanillaunica.gob.mx/pedimentos/ws/oxml/consultarpartida"><soapenv:Body>'
+    "<con:consultarPartidaPeticion><con:peticion/></con:consultarPartidaPeticion>"
+    "</soapenv:Body></soapenv:Envelope>"
+)
+
+
+class _FakeMinioObject:
+    """Simula el objeto retornado por minio get_object."""
+
+    def __init__(self, content):
+        self._content = content
+
+    def read(self):
+        return self._content
+
+    def close(self):
+        pass
+
+    def release_conn(self):
+        pass
+
+
+class FixPartidasErrorCommandTests(TestCase):
+    PED_APP = "24-01-3420-1234567"
+
+    def setUp(self):
+        from api.customs.models import Partida
+        from api.record.models import DocumentType
+
+        self.licencia = Licencia.objects.create(nombre="LicFixPartidas", almacenamiento=100)
+        self.org = Organizacion.objects.create(
+            nombre="OrgFixPartidas", licencia=self.licencia, is_active=True, is_verified=True
+        )
+        # Pedimento VÁLIDO (no malformado): el comando ya no se limita a malformados
+        self.pedimento = Pedimento.objects.create(
+            organizacion=self.org,
+            pedimento="1234567",
+            pedimento_app=self.PED_APP,
+            aduana="034",
+            patente="3420",
+            numero_operacion="12345678",
+        )
+        self.partida = Partida.objects.create(
+            pedimento=self.pedimento,
+            organizacion=self.org,
+            numero_partida=1,
+            descargado=True,
+        )
+        self.type_resp = DocumentType.objects.get_or_create(id=1, defaults={"nombre": "XML"})[0]
+        self.type_req = DocumentType.objects.get_or_create(id=17, defaults={"nombre": "PT Request"})[0]
+        self.type_err = DocumentType.objects.get_or_create(id=18, defaults={"nombre": "PT Error"})[0]
+
+        # Storage simulado: dict path -> bytes
+        self.storage = {}
+        patcher = patch("api.customs.management.commands.fix_partidas_error.minio_client")
+        self.minio = patcher.start()
+        self.addCleanup(patcher.stop)
+        self.minio._bucket_name = "test-bucket"
+        self.minio.file_exists.side_effect = lambda name: name in self.storage
+        self.minio._client.get_object.side_effect = (
+            lambda bucket, name: _FakeMinioObject(self.storage[name])
+        )
+        self.minio.upload_file.side_effect = (
+            lambda name, file_data=None, content_type=None: self.storage.__setitem__(
+                name, file_data.read()
+            )
+        )
+        self.minio.delete_file.side_effect = lambda name: self.storage.pop(name, None)
+
+    def _doc(self, filename, doc_type, content=None):
+        from api.record.models import Document
+
+        path = f"org/{self.PED_APP}/{filename}"
+        doc = Document.objects.create(
+            organizacion=self.org,
+            pedimento=self.pedimento,
+            document_type=doc_type,
+            archivo=path,
+            size=100,
+            extension="xml",
+        )
+        if content is not None:
+            self.storage[path] = content.encode("utf-8")
+        return doc
+
+    def _run(self, **kwargs):
+        out = StringIO()
+        call_command("fix_partidas_error", stdout=out, stderr=StringIO(), **kwargs)
+        return out.getvalue()
+
+    def test_partida_solo_request_se_marca_no_descargada(self):
+        """El caso reportado: descargado=True pero solo existe el XML del REQUEST."""
+        self._doc(f"vu_PT_{self.PED_APP}_1_REQUEST.xml", self.type_req, XML_ECO_REQUEST)
+
+        self._run(pedimento=str(self.pedimento.id))
+
+        self.partida.refresh_from_db()
+        self.assertFalse(self.partida.descargado)
+
+    def test_partida_sin_documentos_se_marca_no_descargada(self):
+        """descargado=True sin ningún documento tampoco es una descarga real."""
+        self._run(pedimento=str(self.pedimento.id))
+
+        self.partida.refresh_from_db()
+        self.assertFalse(self.partida.descargado)
+
+    def test_partida_con_respuesta_valida_permanece_descargada(self):
+        """Con consultarPartidaRespuesta sin error la partida no se toca."""
+        self._doc(f"vu_PT_{self.PED_APP}_1_REQUEST.xml", self.type_req, XML_ECO_REQUEST)
+        self._doc(f"vu_PT_{self.PED_APP}_1.xml", self.type_resp, XML_RESPUESTA_VALIDA)
+
+        self._run(pedimento=str(self.pedimento.id))
+
+        self.partida.refresh_from_db()
+        self.assertTrue(self.partida.descargado)
+
+    def test_doc_con_error_vucem_se_renombra_y_marca_no_descargada(self):
+        """tieneError=true: doc → type 18 con sufijo _ERROR y partida → False."""
+        doc = self._doc(f"vu_PT_{self.PED_APP}_1.xml", self.type_resp, XML_ERROR_VUCEM)
+        old_path = doc.archivo.name
+
+        self._run(pedimento=str(self.pedimento.id))
+
+        self.partida.refresh_from_db()
+        doc.refresh_from_db()
+        self.assertFalse(self.partida.descargado)
+        self.assertEqual(doc.document_type_id, 18)
+        self.assertTrue(doc.archivo.name.endswith(f"vu_PT_{self.PED_APP}_1_ERROR.xml"))
+        self.assertTrue(doc.vu)
+        self.assertNotIn(old_path, self.storage)
+        self.assertIn(doc.archivo.name, self.storage)
+
+    def test_eco_de_request_guardado_como_respuesta_se_reclasifica(self):
+        """Un eco de consultarPartidaPeticion guardado como respuesta se
+        reclasifica a type 17 sin chocar con el REQUEST real existente."""
+        self._doc(f"vu_PT_{self.PED_APP}_1_REQUEST.xml", self.type_req, XML_ECO_REQUEST)
+        doc = self._doc(f"vu_PT_{self.PED_APP}_1.xml", self.type_resp, XML_ECO_REQUEST)
+
+        self._run(pedimento=str(self.pedimento.id))
+
+        self.partida.refresh_from_db()
+        doc.refresh_from_db()
+        self.assertFalse(self.partida.descargado)
+        self.assertEqual(doc.document_type_id, 17)
+        # El nombre sin índice ya lo usa el REQUEST real → debe ir con _1
+        self.assertTrue(doc.archivo.name.endswith(f"vu_PT_{self.PED_APP}_1_REQUEST_1.xml"))
+
+    def test_doc_ausente_sin_canario_no_cambia_partida(self):
+        """Archivo ausente y NINGÚN archivo del pedimento en storage: posible
+        storage equivocado (p. ej. dev) → sin cambios."""
+        self._doc(f"vu_PT_{self.PED_APP}_1.xml", self.type_resp, content=None)
+
+        self._run(pedimento=str(self.pedimento.id))
+
+        self.partida.refresh_from_db()
+        self.assertTrue(self.partida.descargado)
+
+    def test_registro_fantasma_con_storage_real_se_marca_no_descargada(self):
+        """Document type 1 en BD sin archivo en storage, pero el REQUEST sí
+        existe físicamente (canario): el storage es el correcto, el registro es
+        fantasma → la partida no tiene XML de partida → descargado=False."""
+        self._doc(f"vu_PT_{self.PED_APP}_1_REQUEST.xml", self.type_req, XML_ECO_REQUEST)
+        fantasma = self._doc(f"vu_PT_{self.PED_APP}_1.xml", self.type_resp, content=None)
+
+        self._run(pedimento=str(self.pedimento.id))
+
+        self.partida.refresh_from_db()
+        fantasma.refresh_from_db()
+        self.assertFalse(self.partida.descargado)
+        # El registro fantasma se reporta pero no se modifica ni se borra
+        self.assertEqual(fantasma.document_type_id, 1)
+
+    def test_storage_inaccesible_no_cambia_partida(self):
+        """Excepción al consultar storage (conexión caída): sin cambios."""
+        self._doc(f"vu_PT_{self.PED_APP}_1.xml", self.type_resp, XML_ERROR_VUCEM)
+        self.minio.file_exists.side_effect = Exception("connection refused")
+
+        self._run(pedimento=str(self.pedimento.id))
+
+        self.partida.refresh_from_db()
+        self.assertTrue(self.partida.descargado)
+
+    def test_naming_legacy_valida_partida(self):
+        """Documentos con nomenclatura legacy (partida al final) también validan."""
+        self._doc("vu_PT_010Imp_034_3420_1234567_1.xml", self.type_resp, XML_RESPUESTA_VALIDA)
+
+        self._run(pedimento=str(self.pedimento.id))
+
+        self.partida.refresh_from_db()
+        self.assertTrue(self.partida.descargado)
+
+    def test_dry_run_no_modifica(self):
+        """--dry-run reporta pero no toca BD ni storage."""
+        doc = self._doc(f"vu_PT_{self.PED_APP}_1.xml", self.type_resp, XML_ERROR_VUCEM)
+
+        self._run(pedimento=str(self.pedimento.id), dry_run=True)
+
+        self.partida.refresh_from_db()
+        doc.refresh_from_db()
+        self.assertTrue(self.partida.descargado)
+        self.assertEqual(doc.document_type_id, 1)
+        self.assertIn(doc.archivo.name, self.storage)
+
+    def test_universo_general_incluye_pedimentos_validos(self):
+        """Sin --pedimento ni --solo-malformados también procesa pedimentos bien formados."""
+        self._doc(f"vu_PT_{self.PED_APP}_1_REQUEST.xml", self.type_req, XML_ECO_REQUEST)
+
+        self._run()
+
+        self.partida.refresh_from_db()
+        self.assertFalse(self.partida.descargado)
+
+    def test_solo_malformados_excluye_pedimentos_validos(self):
+        """Con --solo-malformados un pedimento bien formado no se procesa."""
+        self._doc(f"vu_PT_{self.PED_APP}_1_REQUEST.xml", self.type_req, XML_ECO_REQUEST)
+
+        self._run(solo_malformados=True)
+
+        self.partida.refresh_from_db()
+        self.assertTrue(self.partida.descargado)
+
+    def test_no_confunde_partida_1_con_11(self):
+        """La asignación por nombre no debe mezclar partida 1 con partida 11."""
+        from api.customs.management.commands.fix_partidas_error import Command
+
+        docs = [
+            SimpleNamespace(id=1, document_type_id=1, archivo=SimpleNamespace(name=f"org/x/vu_PT_{self.PED_APP}_1.xml")),
+            SimpleNamespace(id=2, document_type_id=17, archivo=SimpleNamespace(name=f"org/x/vu_PT_{self.PED_APP}_1_REQUEST.xml")),
+            SimpleNamespace(id=3, document_type_id=1, archivo=SimpleNamespace(name=f"org/x/vu_PT_{self.PED_APP}_11.xml")),
+            SimpleNamespace(id=4, document_type_id=17, archivo=SimpleNamespace(name=f"org/x/vu_PT_{self.PED_APP}_11_REQUEST.xml")),
+        ]
+        cmd = Command()
+
+        ids_p1 = {d.id for d in cmd._docs_de_partida(docs, self.PED_APP, 1)}
+        ids_p11 = {d.id for d in cmd._docs_de_partida(docs, self.PED_APP, 11)}
+
+        self.assertEqual(ids_p1, {1, 2})
+        self.assertEqual(ids_p11, {3, 4})

api/customs/urls.py

@@ -67,6 +67,22 @@ from .views_auditor import (
     auditar_pedamentos_incompletos_endpoint,
     auditar_pedamento_incompleto_endpoint,
     auto_corregir_pedamento_endpoint,
+    auditar_integridad_partidas_endpoint,
+    auditar_integridad_partidas_pedimento_endpoint,
+    auditar_integridad_edocuments_endpoint,
+    auditar_integridad_edocuments_pedimento_endpoint,
+    auditar_integridad_coves_endpoint,
+    auditar_integridad_coves_pedimento_endpoint,
+    auditar_integridad_remesa_endpoint,
+    auditar_integridad_remesa_pedimento_endpoint,
+    corregir_integridad_partidas_endpoint,
+    corregir_integridad_partidas_pedimento_endpoint,
+    corregir_integridad_edocuments_endpoint,
+    corregir_integridad_edocuments_pedimento_endpoint,
+    corregir_integridad_coves_endpoint,
+    corregir_integridad_coves_pedimento_endpoint,
+    corregir_integridad_remesa_endpoint,
+    corregir_integridad_remesa_pedimento_endpoint,
 )
 
 urlpatterns = [
@@ -111,4 +127,22 @@ urlpatterns = [
 
     path('procesamientopedimentos-ejecutar-comando/', EjecutarComandoView.as_view(), name='procesamientopedimentos-ejecutar-comando'),
 
+    path('auditor/auditar-integridad-partidas/', auditar_integridad_partidas_endpoint, name='auditar-integridad-partidas'),
+    path('auditor/auditar-integridad-partidas/pedimento/', auditar_integridad_partidas_pedimento_endpoint, name='auditar-integridad-partidas-pedimento'),
+    path('auditor/auditar-integridad-edocuments/', auditar_integridad_edocuments_endpoint, name='auditar-integridad-edocuments'),
+    path('auditor/auditar-integridad-edocuments/pedimento/', auditar_integridad_edocuments_pedimento_endpoint, name='auditar-integridad-edocuments-pedimento'),
+    path('auditor/auditar-integridad-coves/', auditar_integridad_coves_endpoint, name='auditar-integridad-coves'),
+    path('auditor/auditar-integridad-coves/pedimento/', auditar_integridad_coves_pedimento_endpoint, name='auditar-integridad-coves-pedimento'),
+    path('auditor/auditar-integridad-remesa/', auditar_integridad_remesa_endpoint, name='auditar-integridad-remesa'),
+    path('auditor/auditar-integridad-remesa/pedimento/', auditar_integridad_remesa_pedimento_endpoint, name='auditar-integridad-remesa-pedimento'),
+
+    path('auditor/corregir-integridad-partidas/', corregir_integridad_partidas_endpoint, name='corregir-integridad-partidas'),
+    path('auditor/corregir-integridad-partidas/pedimento/', corregir_integridad_partidas_pedimento_endpoint, name='corregir-integridad-partidas-pedimento'),
+    path('auditor/corregir-integridad-edocuments/', corregir_integridad_edocuments_endpoint, name='corregir-integridad-edocuments'),
+    path('auditor/corregir-integridad-edocuments/pedimento/', corregir_integridad_edocuments_pedimento_endpoint, name='corregir-integridad-edocuments-pedimento'),
+    path('auditor/corregir-integridad-coves/', corregir_integridad_coves_endpoint, name='corregir-integridad-coves'),
+    path('auditor/corregir-integridad-coves/pedimento/', corregir_integridad_coves_pedimento_endpoint, name='corregir-integridad-coves-pedimento'),
+    path('auditor/corregir-integridad-remesa/', corregir_integridad_remesa_endpoint, name='corregir-integridad-remesa'),
+    path('auditor/corregir-integridad-remesa/pedimento/', corregir_integridad_remesa_pedimento_endpoint, name='corregir-integridad-remesa-pedimento'),
+
 ]

api/customs/views.py

@@ -23,6 +23,7 @@ from core.permissions import (
     get_org_context,
     require_permission,
     user_has_permission,
+    user_has_role,
     is_internal_service_request,
 )
 from api.customs.models import (
@@ -33,6 +34,7 @@ from api.customs.models import (
     Cove,
     Importador,
     Partida,
+    EstadoDescarga,
 )
 from api.customs.serializers import (
     PedimentoSerializer,
@@ -257,12 +259,16 @@ class PedimentoFilter(django_filters.FilterSet):
     # Rango de fecha de pago: ?fecha_pago_desde=YYYY-MM-DD&fecha_pago_hasta=YYYY-MM-DD
     fecha_pago_desde = django_filters.DateFilter(field_name='fecha_pago', lookup_expr='gte')
     fecha_pago_hasta = django_filters.DateFilter(field_name='fecha_pago', lookup_expr='lte')
+    # CharFilter directo sobre contribuyente_id (RFC). ModelChoiceFilter silenciosamente
+    # omite el filtro cuando el RFC no existe, lo que causa fuga de pedimentos de otros
+    # importadores. Con CharFilter+exact: RFC inválido → cero resultados, nunca fuga.
+    contribuyente = django_filters.CharFilter(field_name='contribuyente', lookup_expr='exact')
 
     class Meta:
         model = Pedimento
         fields = [
             'patente', 'aduana', 'tipo_operacion', 'clave_pedimento',
-            'pedimento', 'existe_expediente', 'contribuyente',
+            'pedimento', 'existe_expediente',
             'curp_apoderado', 'fecha_pago', 'pedimento_app',
         ]
 class ViewSetPedimento(LoggingMixin, viewsets.ModelViewSet, OrganizacionFiltradaMixin): # Pendiente de permisos de creacion
@@ -1198,18 +1204,18 @@ class ViewSetPedimento(LoggingMixin, viewsets.ModelViewSet, OrganizacionFiltrada
                 status=status.HTTP_400_BAD_REQUEST
             )
         
-        # Validar organización del usuario
-        if not request.user.is_authenticated or not hasattr(request.user, 'organizacion'):
+        # Validar organización del usuario (superuser usa active_organization)
+        from core.permissions import get_org_context
+        organizacion = get_org_context(request.user) if request.user.is_authenticated else None
+        if not organizacion:
             return Response(
                 {
                     "tieneError": True,
-                    "error": "Usuario no autenticado o sin organización"
-                    },
+                    "error": "Usuario no autenticado o sin organización asignada"
+                },
                 status=status.HTTP_400_BAD_REQUEST
             )
         
-        organizacion = request.user.organizacion
-        
         # Regex para validar nomenclatura: anio-aduana-patente-pedimento
         nomenclatura_pattern = re.compile(r'^(\d{2})-(\d{2,3})-(\d{4})-(\d{7})$')
         nomenclatura_pattern_sin_anio = re.compile(r'^(\d{2,3})-(\d{4})-(\d{7})$')
@@ -1744,17 +1750,17 @@ class ViewSetPedimento(LoggingMixin, viewsets.ModelViewSet, OrganizacionFiltrada
         partidas_input = request.data.get('partidas')
         fuente_archivos = request.data.get('partidas')
         
-        # Validar organización del usuario
-        if not request.user.is_authenticated or not hasattr(request.user, 'organizacion'):
+        # Validar organización del usuario (superuser usa active_organization)
+        from core.permissions import get_org_context
+        organizacion = get_org_context(request.user) if request.user.is_authenticated else None
+        if not organizacion:
             return Response(
                 {
                     "tieneError": True,
-                    "error": "Usuario no autenticado o sin organización"
-                    },
+                    "error": "Usuario no autenticado o sin organización asignada"
+                },
                 status=status.HTTP_400_BAD_REQUEST
             )
-        
-        organizacion = request.user.organizacion
 
         # Regex para validar nomenclatura: anio-aduana-patente-pedimento
         nomenclatura_pattern = re.compile(r'^(\d{2})-(\d{2,3})-(\d{4})-(\d{7})$')
@@ -2210,16 +2216,16 @@ class ViewSetPedimento(LoggingMixin, viewsets.ModelViewSet, OrganizacionFiltrada
                 status=status.HTTP_400_BAD_REQUEST
             )
         
-        # Validar organización del usuario
-        if not request.user.is_authenticated or not hasattr(request.user, 'organizacion'):
+        # Validar organización del usuario (superuser usa active_organization)
+        from core.permissions import get_org_context
+        organizacion = get_org_context(request.user) if request.user.is_authenticated else None
+        if not organizacion:
             return Response(
                 {'tieneError': True,
-                 "mensaje": "Usuario no autenticado o sin organización"},
+                 "mensaje": "Usuario no autenticado o sin organización asignada"},
                 status=status.HTTP_400_BAD_REQUEST
             )
         
-        organizacion = request.user.organizacion
-        
         # Preparar parámetros
         parametros = {
             'contribuyente': request.data.get('contribuyente'),
@@ -2334,9 +2340,19 @@ class PartidaViewSet(viewsets.ModelViewSet):
         if not org:
             return Partida.objects.none()
         qs = Partida.objects.filter(pedimento__organizacion=org)
+        # Misma precedencia que los mixins de filtrado: superuser y roles
+        # operativos ven todo lo de su org; is_importador no los degrada.
+        if (
+            user.is_superuser or
+            user_has_role(user, 'admin') or
+            user_has_role(user, 'developer') or
+            user_has_role(user, 'Agente Aduanal') or
+            user_has_role(user, 'user')
+        ):
+            return qs
         if user.is_importador:
-            qs = qs.filter(pedimento__contribuyente__in=user.rfc.all())
-        return qs
+            return qs.filter(pedimento__contribuyente__in=user.rfc.all())
+        return Partida.objects.none()
 
     def perform_create(self, serializer):
         if is_internal_service_request(self.request):
@@ -2452,12 +2468,20 @@ class ViewSetProcesamientoPedimento(viewsets.ModelViewSet, ProcesosPorOrganizaci
         org = get_org_context(user)
         if not org:
             return ProcesamientoPedimento.objects.none()
+        qs = ProcesamientoPedimento.objects.filter(organizacion=org)
+        # Misma precedencia que los mixins de filtrado: superuser y roles
+        # operativos ven todo lo de su org; is_importador no los degrada.
+        if (
+            user.is_superuser or
+            user_has_role(user, 'admin') or
+            user_has_role(user, 'developer') or
+            user_has_role(user, 'Agente Aduanal') or
+            user_has_role(user, 'user')
+        ):
+            return qs
         if user.is_importador:
-            return ProcesamientoPedimento.objects.filter(
-                organizacion=org,
-                pedimento__contribuyente__in=user.rfc.all()
-            )
-        return ProcesamientoPedimento.objects.filter(organizacion=org)
+            return qs.filter(pedimento__contribuyente__in=user.rfc.all())
+        return ProcesamientoPedimento.objects.none()
 
     def perform_create(self, serializer):
         if is_internal_service_request(self.request):
@@ -2481,6 +2505,53 @@ class ViewSetProcesamientoPedimento(viewsets.ModelViewSet, ProcesosPorOrganizaci
 
     my_tags = ['Procesamientos_Pedimentos']
 
+def _crear_documento_error_vu(registro, numero, doc_type_error_id, mensaje, file_prefix='error_vu'):
+    """
+    Crea un Document de error VU (tipos 20/22/24/26) para dejar evidencia en la
+    pestaña Errores VU cuando se detecta una inconsistencia de descarga.
+    `registro` debe tener pedimento y organizacion. El nombre del archivo incluye
+    el número del registro para que el frontend lo asocie (archivo__icontains).
+    """
+    import logging
+    logger = logging.getLogger('api.customs.views')
+
+    doc_type_error = DocumentType.objects.filter(id=doc_type_error_id).first()
+    if not doc_type_error:
+        return
+
+    error_content = mensaje.encode('utf-8')
+    tmp_path = None
+    try:
+        with tempfile.NamedTemporaryFile(mode='wb', suffix='.txt', delete=False) as f:
+            f.write(error_content)
+            tmp_path = f.name
+
+        pedimento_app = getattr(registro.pedimento, 'pedimento_app', str(registro.pedimento.pedimento))
+        file_name = f"{file_prefix}_{numero}.txt"
+
+        saved_path = storage_service.save_document_from_path(
+            file_path=tmp_path,
+            file_name=file_name,
+            organizacion_id=registro.organizacion_id,
+            pedimento_app=pedimento_app
+        )
+
+        if saved_path:
+            Document.objects.create(
+                organizacion=registro.organizacion,
+                pedimento=registro.pedimento,
+                archivo=saved_path,
+                document_type=doc_type_error,
+                extension='TXT',
+                size=len(error_content),
+                fuente=None,
+            )
+    except Exception as e:
+        logger.error(f"Error creando documento de error VU para {numero}: {e}")
+    finally:
+        if tmp_path and os.path.exists(tmp_path):
+            os.unlink(tmp_path)
+
 class ViewSetEDocument(LoggingMixin, viewsets.ModelViewSet, OrganizacionFiltradaMixin):
     """
     ViewSet for EDocument model.
@@ -2488,7 +2559,18 @@ class ViewSetEDocument(LoggingMixin, viewsets.ModelViewSet, OrganizacionFiltrada
     serializer_class = EDocumentSerializer
     pagination_class = CustomPagination
     filter_backends = [DjangoFilterBackend, SearchFilter, OrderingFilter]
-    filterset_fields = ['pedimento', 'numero_edocument', 'organizacion']
+    filterset_fields = {
+        'pedimento': ['exact'],
+        'numero_edocument': ['exact', 'icontains'],
+        'organizacion': ['exact'],
+        'clave': ['exact', 'icontains'],
+        'descripcion': ['icontains'],
+        'edocument_descargado': ['exact'],
+        'acuse_descargado': ['exact'],
+        'edocument_estado': ['exact'],
+        'acuse_estado': ['exact'],
+        'created_at': ['gte', 'lte'],
+    }
     search_fields = ['numero_edocument', 'descripcion', 'organizacion']
     ordering_fields = ['created_at', 'updated_at', 'numero_edocument']
     ordering = ['-created_at']
@@ -2506,6 +2588,7 @@ class ViewSetEDocument(LoggingMixin, viewsets.ModelViewSet, OrganizacionFiltrada
             'destroy':        'edocuments.delete',
             'bulk_delete_edocs_vu': 'edocuments.delete',
             'reset_acuse':    'edocuments.edit',
+            'reset_edocument': 'edocuments.edit',
         }
         codename = perms.get(self.action, 'edocuments.view')
         return [IsAuthenticated(), require_permission(codename)()]
@@ -2535,28 +2618,30 @@ class ViewSetEDocument(LoggingMixin, viewsets.ModelViewSet, OrganizacionFiltrada
     @action(detail=True, methods=['post'], url_path='reset-acuse')
     def reset_acuse(self, request, pk=None):
         """
-        Detecta inconsistencia cuando acuse_descargado=True pero no existe el documento
-        de acuse (tipo 4). Crea un registro de error tipo 26 para Errores VU y
-        restablece acuse_descargado=False para permitir reintentar.
+        Detecta inconsistencia cuando el acuse está marcado como descargado pero el
+        documento de acuse (tipo 4) no existe en BD o el archivo falta en storage.
+        Crea un registro de error tipo 26 para Errores VU y restablece
+        acuse_estado='pendiente' con contador de intentos en 0 — única vía que
+        re-habilita el reintento automático (T2026-05-027).
         """
-        from api.record.models import Document, DocumentType
-        import logging
-        logger = logging.getLogger('api.customs.views')
-
         edoc = self.get_object()
 
-        if not edoc.acuse_descargado:
+        if edoc.acuse_estado != EstadoDescarga.DESCARGADO:
             return Response(
                 {"error": "El acuse no está marcado como descargado"},
                 status=status.HTTP_400_BAD_REQUEST
             )
 
-        # Verificar si el acuse PDF (tipo 4 = Pedimento Acuse) existe realmente
-        acuse_disponible = Document.objects.filter(
+        # Verificar el acuse (tipo 4 = Pedimento Acuse) en BD y físicamente en storage
+        acuse_docs = Document.objects.filter(
             pedimento=edoc.pedimento,
             archivo__icontains=edoc.numero_edocument,
             document_type_id=4
-        ).exists()
+        )
+        acuse_disponible = any(
+            doc.size and storage_service.file_exists(doc.archivo.name)
+            for doc in acuse_docs
+        )
 
         if acuse_disponible:
             return Response(
@@ -2564,51 +2649,74 @@ class ViewSetEDocument(LoggingMixin, viewsets.ModelViewSet, OrganizacionFiltrada
                 status=status.HTTP_200_OK
             )
 
-        # Inconsistencia confirmada: crear documento de error tipo 26 para Errores VU
-        doc_type_error = DocumentType.objects.filter(id=26).first()
-        if doc_type_error:
-            error_content = (
+        # Inconsistencia confirmada: dejar evidencia en Errores VU (tipo 26)
+        _crear_documento_error_vu(
+            registro=edoc,
+            numero=edoc.numero_edocument,
+            doc_type_error_id=26,
+            mensaje=(
                 f"Inconsistencia detectada: el acuse del EDocument {edoc.numero_edocument} "
                 f"fue marcado como descargado pero el documento no se encuentra disponible. "
                 f"El estado fue restablecido para permitir reprocesamiento."
-            ).encode('utf-8')
+            ),
+            file_prefix='error_acuse',
+        )
 
-            try:
-                with tempfile.NamedTemporaryFile(
-                    mode='wb', suffix='.txt', delete=False
-                ) as f:
-                    f.write(error_content)
-                    tmp_path = f.name
+        edoc.acuse_estado = EstadoDescarga.PENDIENTE
+        edoc.acuse_intentos = 0
+        edoc.ultimo_error = None
+        edoc.save()
 
-                pedimento_app = getattr(edoc.pedimento, 'pedimento_app', str(edoc.pedimento.pedimento))
-                file_name = f"error_acuse_{edoc.numero_edocument}.txt"
+        serializer = self.get_serializer(edoc)
+        return Response(serializer.data, status=status.HTTP_200_OK)
 
-                saved_path = storage_service.save_document_from_path(
-                    file_path=tmp_path,
-                    file_name=file_name,
-                    organizacion_id=edoc.organizacion_id,
-                    pedimento_app=pedimento_app
-                )
+    @action(detail=True, methods=['post'], url_path='reset-edocument')
+    def reset_edocument(self, request, pk=None):
+        """
+        Igual que reset-acuse pero para el documento general del EDocument: si está
+        marcado como descargado sin documento disponible (BD o storage), crea error
+        tipo 22 y restablece edocument_estado='pendiente' con contador en 0.
+        """
+        edoc = self.get_object()
 
-                if saved_path:
-                    Document.objects.create(
-                        organizacion=edoc.organizacion,
-                        pedimento=edoc.pedimento,
-                        archivo=saved_path,
-                        document_type=doc_type_error,
-                        extension='TXT',
-                        size=len(error_content),
-                        fuente=None,
-                    )
-            except Exception as e:
-                logger.error(
-                    f"Error creando documento de error para acuse {edoc.numero_edocument}: {e}"
-                )
-            finally:
-                if os.path.exists(tmp_path):
-                    os.unlink(tmp_path)
+        if edoc.edocument_estado != EstadoDescarga.DESCARGADO:
+            return Response(
+                {"error": "El e-documento no está marcado como descargado"},
+                status=status.HTTP_400_BAD_REQUEST
+            )
 
-        edoc.acuse_descargado = False
+        # Documentos generales del EDocument: se excluyen acuse (4), requests (21, 25)
+        # y errores (22, 26) del catálogo document_type
+        edoc_docs = Document.objects.filter(
+            pedimento=edoc.pedimento,
+            archivo__icontains=edoc.numero_edocument,
+        ).exclude(document_type_id__in=[4, 21, 22, 25, 26])
+        edoc_disponible = any(
+            doc.size and storage_service.file_exists(doc.archivo.name)
+            for doc in edoc_docs
+        )
+
+        if edoc_disponible:
+            return Response(
+                {"status": "El e-documento está disponible correctamente", "edocument_disponible": True},
+                status=status.HTTP_200_OK
+            )
+
+        _crear_documento_error_vu(
+            registro=edoc,
+            numero=edoc.numero_edocument,
+            doc_type_error_id=22,
+            mensaje=(
+                f"Inconsistencia detectada: el EDocument {edoc.numero_edocument} fue marcado "
+                f"como descargado pero el documento no se encuentra disponible. "
+                f"El estado fue restablecido para permitir reprocesamiento."
+            ),
+            file_prefix='error_edocument',
+        )
+
+        edoc.edocument_estado = EstadoDescarga.PENDIENTE
+        edoc.edocument_intentos = 0
+        edoc.ultimo_error = None
         edoc.save()
 
         serializer = self.get_serializer(edoc)
@@ -2621,7 +2729,16 @@ class ViewSetCove(viewsets.ModelViewSet, OrganizacionFiltradaMixin):
     serializer_class = CoveSerializer
     pagination_class = CustomPagination
     filter_backends = [DjangoFilterBackend, SearchFilter, OrderingFilter]
-    filterset_fields = ['pedimento', 'numero_cove', 'organizacion']
+    filterset_fields = {
+        'pedimento': ['exact'],
+        'numero_cove': ['exact', 'icontains'],
+        'organizacion': ['exact'],
+        'cove_descargado': ['exact'],
+        'acuse_cove_descargado': ['exact'],
+        'cove_estado': ['exact'],
+        'acuse_cove_estado': ['exact'],
+        'created_at': ['gte', 'lte'],
+    }
     search_fields = ['numero_cove', 'descripcion', 'organizacion']
     ordering_fields = ['created_at', 'updated_at', 'numero_cove']
     ordering = ['-created_at']
@@ -2638,6 +2755,8 @@ class ViewSetCove(viewsets.ModelViewSet, OrganizacionFiltradaMixin):
             'partial_update': 'coves.edit',
             'destroy':        'coves.delete',
             'bulk_delete_coves_vu': 'coves.delete',
+            'reset_cove':       'coves.edit',
+            'reset_acuse_cove': 'coves.edit',
         }
         codename = perms.get(self.action, 'coves.view')
         return [IsAuthenticated(), require_permission(codename)()]
@@ -2664,6 +2783,110 @@ class ViewSetCove(viewsets.ModelViewSet, OrganizacionFiltradaMixin):
     def perform_destroy(self, instance):
         instance.delete()
 
+    @action(detail=True, methods=['post'], url_path='reset-cove')
+    def reset_cove(self, request, pk=None):
+        """
+        Detecta inconsistencia cuando la COVE está marcada como descargada pero el
+        documento no existe en BD o el archivo falta en storage. Crea error tipo 20
+        para Errores VU y restablece cove_estado='pendiente' con contador en 0.
+        """
+        cove = self.get_object()
+
+        if cove.cove_estado != EstadoDescarga.DESCARGADO:
+            return Response(
+                {"error": "La COVE no está marcada como descargada"},
+                status=status.HTTP_400_BAD_REQUEST
+            )
+
+        # Documentos generales de la COVE: se excluyen acuse (7), requests (19, 23)
+        # y errores (20, 24) del catálogo document_type
+        cove_docs = Document.objects.filter(
+            pedimento=cove.pedimento,
+            archivo__icontains=cove.numero_cove,
+        ).exclude(document_type_id__in=[7, 19, 20, 23, 24])
+        cove_disponible = any(
+            doc.size and storage_service.file_exists(doc.archivo.name)
+            for doc in cove_docs
+        )
+
+        if cove_disponible:
+            return Response(
+                {"status": "La COVE está disponible correctamente", "cove_disponible": True},
+                status=status.HTTP_200_OK
+            )
+
+        _crear_documento_error_vu(
+            registro=cove,
+            numero=cove.numero_cove,
+            doc_type_error_id=20,
+            mensaje=(
+                f"Inconsistencia detectada: la COVE {cove.numero_cove} fue marcada "
+                f"como descargada pero el documento no se encuentra disponible. "
+                f"El estado fue restablecido para permitir reprocesamiento."
+            ),
+            file_prefix='error_cove',
+        )
+
+        cove.cove_estado = EstadoDescarga.PENDIENTE
+        cove.cove_intentos = 0
+        cove.ultimo_error = None
+        cove.save()
+
+        serializer = self.get_serializer(cove)
+        return Response(serializer.data, status=status.HTTP_200_OK)
+
+    @action(detail=True, methods=['post'], url_path='reset-acuse-cove')
+    def reset_acuse_cove(self, request, pk=None):
+        """
+        Detecta inconsistencia cuando el acuse de la COVE (tipo 7) está marcado como
+        descargado pero no existe en BD o el archivo falta en storage. Crea error
+        tipo 24 para Errores VU y restablece acuse_cove_estado='pendiente' con
+        contador en 0.
+        """
+        cove = self.get_object()
+
+        if cove.acuse_cove_estado != EstadoDescarga.DESCARGADO:
+            return Response(
+                {"error": "El acuse de la COVE no está marcado como descargado"},
+                status=status.HTTP_400_BAD_REQUEST
+            )
+
+        acuse_docs = Document.objects.filter(
+            pedimento=cove.pedimento,
+            archivo__icontains=cove.numero_cove,
+            document_type_id=7
+        )
+        acuse_disponible = any(
+            doc.size and storage_service.file_exists(doc.archivo.name)
+            for doc in acuse_docs
+        )
+
+        if acuse_disponible:
+            return Response(
+                {"status": "El acuse está disponible correctamente", "acuse_disponible": True},
+                status=status.HTTP_200_OK
+            )
+
+        _crear_documento_error_vu(
+            registro=cove,
+            numero=cove.numero_cove,
+            doc_type_error_id=24,
+            mensaje=(
+                f"Inconsistencia detectada: el acuse de la COVE {cove.numero_cove} "
+                f"fue marcado como descargado pero el documento no se encuentra disponible. "
+                f"El estado fue restablecido para permitir reprocesamiento."
+            ),
+            file_prefix='error_acuse_cove',
+        )
+
+        cove.acuse_cove_estado = EstadoDescarga.PENDIENTE
+        cove.acuse_cove_intentos = 0
+        cove.ultimo_error = None
+        cove.save()
+
+        serializer = self.get_serializer(cove)
+        return Response(serializer.data, status=status.HTTP_200_OK)
+
 class ImportadorViewSet(viewsets.ModelViewSet):
     """
     ViewSet for Importador model.

api/customs/views_auditor.py

@@ -13,6 +13,22 @@ from .tasks.auditoria import (
     auditar_edocuments,
     auditar_acuse,
     auditar_remesas,
+    auditar_integridad_partidas,
+    auditar_integridad_partidas_por_pedimento,
+    auditar_integridad_edocuments,
+    auditar_integridad_edocuments_por_pedimento,
+    auditar_integridad_coves,
+    auditar_integridad_coves_por_pedimento,
+    auditar_integridad_remesa,
+    auditar_integridad_remesa_por_pedimento,
+    corregir_integridad_partidas,
+    corregir_integridad_edocuments,
+    corregir_integridad_coves,
+    corregir_integridad_remesa,
+    _corregir_integridad_partidas_pedimento,
+    _corregir_integridad_edocuments_pedimento,
+    _corregir_integridad_coves_pedimento,
+    _corregir_integridad_remesa_pedimento,
 )
 from .tasks.internal_services import auditar_pedimentos
 from .tasks.microservice_v2 import procesar_pedimentos_completos, procesar_pedimento_completo_individual
@@ -2316,4 +2332,380 @@ def auto_corregir_pedamento_endpoint(request):
             'mensaje': 'Corrección individual encolada.',
         },
         status=status.HTTP_202_ACCEPTED,
-    )
+    )
+
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Endpoints de auditorías de integridad
+# ──────────────────────────────────────────────────────────────────────────────
+
+@swagger_auto_schema(
+    method='post',
+    operation_description="Audita integridad de partidas: compara numero_partidas del XML vs partidas registradas en DB (solo lectura, no crea registros)",
+    request_body=openapi.Schema(
+        type=openapi.TYPE_OBJECT,
+        properties={'organizacion_id': openapi.Schema(type=openapi.TYPE_STRING)},
+        required=['organizacion_id']
+    ),
+    responses={
+        202: openapi.Response('Tarea iniciada — usar task_id para consultar resultado'),
+        400: openapi.Response('Error en los parámetros'),
+        403: openapi.Response('No tiene permisos suficientes'),
+    }
+)
+@api_view(['POST'])
+@permission_classes([IsAuthenticated, require_permission('auditoria.process')])
+def auditar_integridad_partidas_endpoint(request):
+    return _lanzar_auditoria_organizacion(request, auditar_integridad_partidas, 'integridad de partidas')
+
+
+@swagger_auto_schema(
+    method='post',
+    operation_description="Audita integridad de partidas para un pedimento específico",
+    request_body=openapi.Schema(
+        type=openapi.TYPE_OBJECT,
+        properties={'pedimento_id': openapi.Schema(type=openapi.TYPE_STRING)},
+        required=['pedimento_id']
+    ),
+    responses={
+        200: openapi.Response('Resultado de integridad de partidas del pedimento'),
+        400: openapi.Response('Error en los parámetros'),
+        403: openapi.Response('No tiene permisos suficientes'),
+        404: openapi.Response('Pedimento no encontrado'),
+    }
+)
+@api_view(['POST'])
+@permission_classes([IsAuthenticated, require_permission('auditoria.view')])
+def auditar_integridad_partidas_pedimento_endpoint(request):
+    pedimento_id = request.data.get('pedimento_id')
+    if not pedimento_id:
+        return Response({'error': 'Debe proporcionar pedimento_id'}, status=status.HTTP_400_BAD_REQUEST)
+
+    try:
+        pedimento = Pedimento.objects.select_related('organizacion').get(id=pedimento_id)
+    except Pedimento.DoesNotExist:
+        return Response({'error': 'Pedimento no encontrado'}, status=status.HTTP_404_NOT_FOUND)
+
+    user = request.user
+    if not user.is_superuser and str(pedimento.organizacion.id) != str(user.organizacion.id):
+        return Response({'error': 'No tiene permisos para este pedimento'}, status=status.HTTP_403_FORBIDDEN)
+
+    resultado = auditar_integridad_partidas_por_pedimento(pedimento_id)
+    return Response(resultado, status=status.HTTP_200_OK)
+
+
+@swagger_auto_schema(
+    method='post',
+    operation_description="Audita integridad de edocuments: compara lista del XML del pedimento completo vs EDocuments registrados en DB",
+    request_body=openapi.Schema(
+        type=openapi.TYPE_OBJECT,
+        properties={'organizacion_id': openapi.Schema(type=openapi.TYPE_STRING)},
+        required=['organizacion_id']
+    ),
+    responses={
+        202: openapi.Response('Tarea iniciada — usar task_id para consultar resultado'),
+        400: openapi.Response('Error en los parámetros'),
+        403: openapi.Response('No tiene permisos suficientes'),
+    }
+)
+@api_view(['POST'])
+@permission_classes([IsAuthenticated, require_permission('auditoria.process')])
+def auditar_integridad_edocuments_endpoint(request):
+    return _lanzar_auditoria_organizacion(request, auditar_integridad_edocuments, 'integridad de edocuments')
+
+
+@swagger_auto_schema(
+    method='post',
+    operation_description="Audita integridad de edocuments para un pedimento específico",
+    request_body=openapi.Schema(
+        type=openapi.TYPE_OBJECT,
+        properties={'pedimento_id': openapi.Schema(type=openapi.TYPE_STRING)},
+        required=['pedimento_id']
+    ),
+    responses={
+        200: openapi.Response('Resultado de integridad de edocuments del pedimento'),
+        400: openapi.Response('Error en los parámetros'),
+        403: openapi.Response('No tiene permisos suficientes'),
+        404: openapi.Response('Pedimento no encontrado'),
+    }
+)
+@api_view(['POST'])
+@permission_classes([IsAuthenticated, require_permission('auditoria.view')])
+def auditar_integridad_edocuments_pedimento_endpoint(request):
+    pedimento_id = request.data.get('pedimento_id')
+    if not pedimento_id:
+        return Response({'error': 'Debe proporcionar pedimento_id'}, status=status.HTTP_400_BAD_REQUEST)
+
+    try:
+        pedimento = Pedimento.objects.select_related('organizacion').get(id=pedimento_id)
+    except Pedimento.DoesNotExist:
+        return Response({'error': 'Pedimento no encontrado'}, status=status.HTTP_404_NOT_FOUND)
+
+    user = request.user
+    if not user.is_superuser and str(pedimento.organizacion.id) != str(user.organizacion.id):
+        return Response({'error': 'No tiene permisos para este pedimento'}, status=status.HTTP_403_FORBIDDEN)
+
+    resultado = auditar_integridad_edocuments_por_pedimento(pedimento_id)
+    return Response(resultado, status=status.HTTP_200_OK)
+
+
+@swagger_auto_schema(
+    method='post',
+    operation_description="Audita integridad de COVEs del PC XML contra los registrados en DB (nivel organización)",
+    request_body=openapi.Schema(
+        type=openapi.TYPE_OBJECT,
+        properties={'organizacion_id': openapi.Schema(type=openapi.TYPE_STRING)},
+        required=['organizacion_id']
+    ),
+    responses={202: openapi.Response('Tarea iniciada'), 400: 'Error en parámetros', 403: 'Sin permisos'},
+)
+@api_view(['POST'])
+@permission_classes([IsAuthenticated, require_permission('auditoria.process')])
+def auditar_integridad_coves_endpoint(request):
+    return _lanzar_auditoria_organizacion(request, auditar_integridad_coves, 'integridad de COVEs')
+
+
+@swagger_auto_schema(
+    method='post',
+    operation_description="Audita integridad de COVEs del PC XML para un pedimento específico",
+    request_body=openapi.Schema(
+        type=openapi.TYPE_OBJECT,
+        properties={'pedimento_id': openapi.Schema(type=openapi.TYPE_STRING)},
+        required=['pedimento_id']
+    ),
+    responses={200: 'Resultado', 400: 'Error en parámetros', 403: 'Sin permisos', 404: 'No encontrado'},
+)
+@api_view(['POST'])
+@permission_classes([IsAuthenticated, require_permission('auditoria.view')])
+def auditar_integridad_coves_pedimento_endpoint(request):
+    pedimento_id = request.data.get('pedimento_id')
+    if not pedimento_id:
+        return Response({'error': 'Debe proporcionar pedimento_id'}, status=status.HTTP_400_BAD_REQUEST)
+    try:
+        pedimento = Pedimento.objects.select_related('organizacion').get(id=pedimento_id)
+    except Pedimento.DoesNotExist:
+        return Response({'error': 'Pedimento no encontrado'}, status=status.HTTP_404_NOT_FOUND)
+    user = request.user
+    if not user.is_superuser and str(pedimento.organizacion.id) != str(user.organizacion.id):
+        return Response({'error': 'No tiene permisos para este pedimento'}, status=status.HTTP_403_FORBIDDEN)
+    resultado = auditar_integridad_coves_por_pedimento(pedimento_id)
+    return Response(resultado, status=status.HTTP_200_OK)
+
+
+@swagger_auto_schema(
+    method='post',
+    operation_description="Audita integridad de COVEs del XML de remesa contra los registrados en DB (nivel organización)",
+    request_body=openapi.Schema(
+        type=openapi.TYPE_OBJECT,
+        properties={'organizacion_id': openapi.Schema(type=openapi.TYPE_STRING)},
+        required=['organizacion_id']
+    ),
+    responses={202: openapi.Response('Tarea iniciada'), 400: 'Error en parámetros', 403: 'Sin permisos'},
+)
+@api_view(['POST'])
+@permission_classes([IsAuthenticated, require_permission('auditoria.process')])
+def auditar_integridad_remesa_endpoint(request):
+    return _lanzar_auditoria_organizacion(request, auditar_integridad_remesa, 'integridad de remesas')
+
+
+@swagger_auto_schema(
+    method='post',
+    operation_description="Audita integridad de COVEs del XML de remesa para un pedimento específico. Deduce si es consolidado desde el identificador PC del pedimento completo; si falta el documento de remesa, dispara la consulta a VUCEM",
+    request_body=openapi.Schema(
+        type=openapi.TYPE_OBJECT,
+        properties={'pedimento_id': openapi.Schema(type=openapi.TYPE_STRING)},
+        required=['pedimento_id']
+    ),
+    responses={200: 'Resultado', 400: 'Error en parámetros', 403: 'Sin permisos', 404: 'No encontrado'},
+)
+@api_view(['POST'])
+@permission_classes([IsAuthenticated, require_permission('auditoria.view')])
+def auditar_integridad_remesa_pedimento_endpoint(request):
+    pedimento_id = request.data.get('pedimento_id')
+    if not pedimento_id:
+        return Response({'error': 'Debe proporcionar pedimento_id'}, status=status.HTTP_400_BAD_REQUEST)
+    try:
+        pedimento = Pedimento.objects.select_related('organizacion').get(id=pedimento_id)
+    except Pedimento.DoesNotExist:
+        return Response({'error': 'Pedimento no encontrado'}, status=status.HTTP_404_NOT_FOUND)
+    user = request.user
+    if not user.is_superuser and str(pedimento.organizacion.id) != str(user.organizacion.id):
+        return Response({'error': 'No tiene permisos para este pedimento'}, status=status.HTTP_403_FORBIDDEN)
+    resultado = auditar_integridad_remesa_por_pedimento(pedimento_id)
+    return Response(resultado, status=status.HTTP_200_OK)
+
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Endpoints de CORRECCIÓN de integridad
+# ──────────────────────────────────────────────────────────────────────────────
+
+@swagger_auto_schema(
+    method='post',
+    operation_description="Crea Partidas faltantes en toda la organización y dispara procesamiento VUCEM",
+    request_body=openapi.Schema(
+        type=openapi.TYPE_OBJECT,
+        properties={'organizacion_id': openapi.Schema(type=openapi.TYPE_STRING)},
+        required=['organizacion_id']
+    ),
+    responses={202: openapi.Response('Tarea iniciada'), 400: 'Error en parámetros', 403: 'Sin permisos'},
+)
+@api_view(['POST'])
+@permission_classes([IsAuthenticated, require_permission('auditoria.process')])
+def corregir_integridad_partidas_endpoint(request):
+    return _lanzar_auditoria_organizacion(request, corregir_integridad_partidas, 'corrección de partidas')
+
+
+@swagger_auto_schema(
+    method='post',
+    operation_description="Crea Partidas faltantes para un pedimento específico y dispara procesamiento VUCEM",
+    request_body=openapi.Schema(
+        type=openapi.TYPE_OBJECT,
+        properties={'pedimento_id': openapi.Schema(type=openapi.TYPE_STRING)},
+        required=['pedimento_id']
+    ),
+    responses={200: 'Resultado', 400: 'Error en parámetros', 403: 'Sin permisos', 404: 'No encontrado'},
+)
+@api_view(['POST'])
+@permission_classes([IsAuthenticated, require_permission('auditoria.process')])
+def corregir_integridad_partidas_pedimento_endpoint(request):
+    pedimento_id = request.data.get('pedimento_id')
+    if not pedimento_id:
+        return Response({'error': 'Debe proporcionar pedimento_id'}, status=status.HTTP_400_BAD_REQUEST)
+    try:
+        pedimento = Pedimento.objects.select_related('organizacion').get(id=pedimento_id)
+    except Pedimento.DoesNotExist:
+        return Response({'error': 'Pedimento no encontrado'}, status=status.HTTP_404_NOT_FOUND)
+    user = request.user
+    if not user.is_superuser and str(pedimento.organizacion.id) != str(user.organizacion.id):
+        return Response({'error': 'No tiene permisos para este pedimento'}, status=status.HTTP_403_FORBIDDEN)
+    resultado = _corregir_integridad_partidas_pedimento(pedimento)
+    return Response(resultado, status=status.HTTP_200_OK)
+
+
+@swagger_auto_schema(
+    method='post',
+    operation_description="Crea EDocuments faltantes en toda la organización desde el XML del pedimento completo y dispara procesamiento VUCEM",
+    request_body=openapi.Schema(
+        type=openapi.TYPE_OBJECT,
+        properties={'organizacion_id': openapi.Schema(type=openapi.TYPE_STRING)},
+        required=['organizacion_id']
+    ),
+    responses={202: openapi.Response('Tarea iniciada'), 400: 'Error en parámetros', 403: 'Sin permisos'},
+)
+@api_view(['POST'])
+@permission_classes([IsAuthenticated, require_permission('auditoria.process')])
+def corregir_integridad_edocuments_endpoint(request):
+    return _lanzar_auditoria_organizacion(request, corregir_integridad_edocuments, 'corrección de edocuments')
+
+
+@swagger_auto_schema(
+    method='post',
+    operation_description="Crea EDocuments faltantes para un pedimento específico y dispara procesamiento VUCEM",
+    request_body=openapi.Schema(
+        type=openapi.TYPE_OBJECT,
+        properties={'pedimento_id': openapi.Schema(type=openapi.TYPE_STRING)},
+        required=['pedimento_id']
+    ),
+    responses={200: 'Resultado', 400: 'Error en parámetros', 403: 'Sin permisos', 404: 'No encontrado'},
+)
+@api_view(['POST'])
+@permission_classes([IsAuthenticated, require_permission('auditoria.process')])
+def corregir_integridad_edocuments_pedimento_endpoint(request):
+    pedimento_id = request.data.get('pedimento_id')
+    if not pedimento_id:
+        return Response({'error': 'Debe proporcionar pedimento_id'}, status=status.HTTP_400_BAD_REQUEST)
+    try:
+        pedimento = Pedimento.objects.select_related('organizacion').get(id=pedimento_id)
+    except Pedimento.DoesNotExist:
+        return Response({'error': 'Pedimento no encontrado'}, status=status.HTTP_404_NOT_FOUND)
+    user = request.user
+    if not user.is_superuser and str(pedimento.organizacion.id) != str(user.organizacion.id):
+        return Response({'error': 'No tiene permisos para este pedimento'}, status=status.HTTP_403_FORBIDDEN)
+    resultado = _corregir_integridad_edocuments_pedimento(pedimento)
+    return Response(resultado, status=status.HTTP_200_OK)
+
+
+@swagger_auto_schema(
+    method='post',
+    operation_description="Crea COVEs faltantes del PC XML en toda la organización y dispara procesamiento VUCEM",
+    request_body=openapi.Schema(
+        type=openapi.TYPE_OBJECT,
+        properties={'organizacion_id': openapi.Schema(type=openapi.TYPE_STRING)},
+        required=['organizacion_id']
+    ),
+    responses={202: openapi.Response('Tarea iniciada'), 400: 'Error en parámetros', 403: 'Sin permisos'},
+)
+@api_view(['POST'])
+@permission_classes([IsAuthenticated, require_permission('auditoria.process')])
+def corregir_integridad_coves_endpoint(request):
+    return _lanzar_auditoria_organizacion(request, corregir_integridad_coves, 'corrección de COVEs')
+
+
+@swagger_auto_schema(
+    method='post',
+    operation_description="Crea COVEs faltantes del PC XML para un pedimento específico y dispara procesamiento VUCEM",
+    request_body=openapi.Schema(
+        type=openapi.TYPE_OBJECT,
+        properties={'pedimento_id': openapi.Schema(type=openapi.TYPE_STRING)},
+        required=['pedimento_id']
+    ),
+    responses={200: 'Resultado', 400: 'Error en parámetros', 403: 'Sin permisos', 404: 'No encontrado'},
+)
+@api_view(['POST'])
+@permission_classes([IsAuthenticated, require_permission('auditoria.process')])
+def corregir_integridad_coves_pedimento_endpoint(request):
+    pedimento_id = request.data.get('pedimento_id')
+    if not pedimento_id:
+        return Response({'error': 'Debe proporcionar pedimento_id'}, status=status.HTTP_400_BAD_REQUEST)
+    try:
+        pedimento = Pedimento.objects.select_related('organizacion').get(id=pedimento_id)
+    except Pedimento.DoesNotExist:
+        return Response({'error': 'Pedimento no encontrado'}, status=status.HTTP_404_NOT_FOUND)
+    user = request.user
+    if not user.is_superuser and str(pedimento.organizacion.id) != str(user.organizacion.id):
+        return Response({'error': 'No tiene permisos para este pedimento'}, status=status.HTTP_403_FORBIDDEN)
+    resultado = _corregir_integridad_coves_pedimento(pedimento)
+    return Response(resultado, status=status.HTTP_200_OK)
+
+
+@swagger_auto_schema(
+    method='post',
+    operation_description="Crea COVEs faltantes del XML de remesa en toda la organización y dispara procesamiento VUCEM",
+    request_body=openapi.Schema(
+        type=openapi.TYPE_OBJECT,
+        properties={'organizacion_id': openapi.Schema(type=openapi.TYPE_STRING)},
+        required=['organizacion_id']
+    ),
+    responses={202: openapi.Response('Tarea iniciada'), 400: 'Error en parámetros', 403: 'Sin permisos'},
+)
+@api_view(['POST'])
+@permission_classes([IsAuthenticated, require_permission('auditoria.process')])
+def corregir_integridad_remesa_endpoint(request):
+    return _lanzar_auditoria_organizacion(request, corregir_integridad_remesa, 'corrección de remesas')
+
+
+@swagger_auto_schema(
+    method='post',
+    operation_description="Crea COVEs faltantes del XML de remesa para un pedimento específico y dispara procesamiento VUCEM",
+    request_body=openapi.Schema(
+        type=openapi.TYPE_OBJECT,
+        properties={'pedimento_id': openapi.Schema(type=openapi.TYPE_STRING)},
+        required=['pedimento_id']
+    ),
+    responses={200: 'Resultado', 400: 'Error en parámetros', 403: 'Sin permisos', 404: 'No encontrado'},
+)
+@api_view(['POST'])
+@permission_classes([IsAuthenticated, require_permission('auditoria.process')])
+def corregir_integridad_remesa_pedimento_endpoint(request):
+    pedimento_id = request.data.get('pedimento_id')
+    if not pedimento_id:
+        return Response({'error': 'Debe proporcionar pedimento_id'}, status=status.HTTP_400_BAD_REQUEST)
+    try:
+        pedimento = Pedimento.objects.select_related('organizacion').get(id=pedimento_id)
+    except Pedimento.DoesNotExist:
+        return Response({'error': 'Pedimento no encontrado'}, status=status.HTTP_404_NOT_FOUND)
+    user = request.user
+    if not user.is_superuser and str(pedimento.organizacion.id) != str(user.organizacion.id):
+        return Response({'error': 'No tiene permisos para este pedimento'}, status=status.HTTP_403_FORBIDDEN)
+    resultado = _corregir_integridad_remesa_pedimento(pedimento)
+    return Response(resultado, status=status.HTTP_200_OK)

api/datastage/management/commands/reprocesar_datastages.py

@@ -0,0 +1,195 @@
+"""
+Reprocesa datastages ya cargados: elimina los Registro* existentes del datastage
+y reprocesa los archivos .asc de forma SINCRÓNICA (sin Celery).
+
+Casos de uso:
+  - Los registros quedaron vacíos por un bug y ya fue corregido.
+  - Se quiere refrescar los datos sin que el usuario vuelva a subir el archivo.
+
+Los Pedimentos existentes NO se tocan (el create en la task falla silenciosamente
+por unique_together si ya existen).
+
+Uso:
+  python manage.py reprocesar_datastages                          # todos los datastages
+  python manage.py reprocesar_datastages --organizacion <UUID>   # solo una org
+  python manage.py reprocesar_datastages --datastage 4 7 12      # IDs específicos
+  python manage.py reprocesar_datastages --organizacion <UUID> --datastage 4
+  python manage.py reprocesar_datastages --dry-run               # sin cambios
+"""
+
+import os
+import tempfile
+import zipfile
+
+from django.core.management.base import BaseCommand, CommandError
+
+from api.datastage.models import (
+    DataStage,
+    Registro500, Registro501, Registro502, Registro503, Registro504,
+    Registro505, Registro506, Registro507, Registro508, Registro509,
+    Registro510, Registro511, Registro512, Registro520,
+    Registro551, Registro552, Registro553, Registro554, Registro555,
+    Registro556, Registro557, Registro558,
+    RegistroSel,
+    Registro701, Registro702,
+)
+
+REGISTRO_MODELS = [
+    Registro500, Registro501, Registro502, Registro503, Registro504,
+    Registro505, Registro506, Registro507, Registro508, Registro509,
+    Registro510, Registro511, Registro512, Registro520,
+    Registro551, Registro552, Registro553, Registro554, Registro555,
+    Registro556, Registro557, Registro558,
+    RegistroSel,
+    Registro701, Registro702,
+]
+
+
+class Command(BaseCommand):
+    help = "Elimina los Registro* de datastages procesados y vuelve a procesarlos de forma sincrónica."
+
+    def add_arguments(self, parser):
+        parser.add_argument(
+            "--organizacion", metavar="UUID",
+            help="UUID de la organización. Sin este arg: todas las orgs.",
+        )
+        parser.add_argument(
+            "--datastage", metavar="ID", nargs="+", type=int,
+            help="Uno o más IDs de DataStage a reprocesar.",
+        )
+        parser.add_argument(
+            "--dry-run", action="store_true",
+            help="Solo muestra lo que haría, sin borrar ni insertar.",
+        )
+
+    def handle(self, *args, **options):
+        org_id  = options.get("organizacion")
+        ds_ids  = options.get("datastage")
+        dry_run = options["dry_run"]
+
+        if dry_run:
+            self.stdout.write(self.style.WARNING(
+                "=== MODO PRUEBA (--dry-run): sin cambios en BD ===\n"
+            ))
+
+        qs = DataStage.objects.select_related("organizacion").order_by("id")
+        if org_id:
+            qs = qs.filter(organizacion_id=org_id)
+        if ds_ids:
+            qs = qs.filter(id__in=ds_ids)
+
+        total = qs.count()
+        if total == 0:
+            self.stdout.write(self.style.WARNING("No se encontraron datastages con los filtros indicados."))
+            return
+
+        self.stdout.write(f"Datastages a reprocesar: {total}\n")
+
+        ok = err = 0
+        for ds in qs:
+            exito = self._reprocesar(ds, dry_run)
+            if exito:
+                ok += 1
+            else:
+                err += 1
+
+        self._print_summary(ok, err, dry_run)
+
+    # ------------------------------------------------------------------ #
+
+    def _reprocesar(self, ds, dry_run):
+        org_nombre = ds.organizacion.nombre if ds.organizacion else "sin organización"
+        self.stdout.write(
+            f"\nDataStage ID={ds.id} | org={org_nombre} | archivo={ds.archivo or '—'}"
+        )
+
+        if not ds.archivo:
+            self.stdout.write(self.style.ERROR("  → Sin archivo asociado, se omite."))
+            return False
+
+        # 1. Eliminar Registro* existentes
+        total_borrados = 0
+        for Model in REGISTRO_MODELS:
+            qs_modelo = Model.objects.filter(datastage=ds)
+            count = qs_modelo.count()
+            if count == 0:
+                continue
+            if not dry_run:
+                qs_modelo.delete()
+            estado = "[dry-run]" if dry_run else "borrados"
+            self.stdout.write(f"  {Model.__name__}: {count} {estado}")
+            total_borrados += count
+
+        if total_borrados == 0:
+            self.stdout.write("  → Sin registros existentes en ninguna tabla.")
+        else:
+            self.stdout.write(f"  Total eliminados: {total_borrados}")
+
+        if dry_run:
+            self.stdout.write(self.style.WARNING(
+                "  → [dry-run] Se procesarían los archivos .asc del datastage."
+            ))
+            return True
+
+        # 2. Descargar ZIP una vez para obtener la lista de .asc
+        from api.utils.storage_service import storage_service
+
+        ruta = str(ds.archivo)
+        if not storage_service.file_exists(ruta):
+            self.stdout.write(self.style.ERROR(
+                f"  El archivo no existe en storage: {ruta}"
+            ))
+            return False
+
+        tmp_path = None
+        try:
+            with tempfile.NamedTemporaryFile(delete=False, suffix=".zip") as tmp:
+                tmp_path = tmp.name
+
+            if not storage_service.download_file(ruta, tmp_path):
+                self.stdout.write(self.style.ERROR(
+                    f"  No se pudo descargar '{ruta}' — verifica conectividad con MinIO."
+                ))
+                return False
+
+            with zipfile.ZipFile(tmp_path, "r") as zf:
+                asc_files = [n for n in zf.namelist() if n.endswith(".asc")]
+
+        finally:
+            if tmp_path and os.path.exists(tmp_path):
+                os.unlink(tmp_path)
+
+        if not asc_files:
+            self.stdout.write(self.style.WARNING("  → No se encontraron archivos .asc en el ZIP."))
+            return True
+
+        self.stdout.write(f"  Archivos .asc encontrados: {len(asc_files)}")
+
+        # 3. Procesar cada .asc de forma sincrónica (sin Celery)
+        from api.datastage.tasks import procesar_archivo_asc_task
+
+        total_insertados = 0
+        for asc_name in asc_files:
+            self.stdout.write(f"    {asc_name} ... ", ending="")
+            result = procesar_archivo_asc_task(ds.id, ds.organizacion_id, asc_name)
+            if "error" in result:
+                self.stdout.write(self.style.ERROR(f"ERROR: {result['error']}"))
+            else:
+                insertados = result.get("insertados", 0)
+                total_insertados += insertados
+                self.stdout.write(self.style.SUCCESS(f"{insertados} registros"))
+
+        self.stdout.write(f"  Total insertados: {total_insertados}")
+        return True
+
+    # ------------------------------------------------------------------ #
+
+    def _print_summary(self, ok, err, dry_run):
+        self.stdout.write(f"\n{'─' * 60}")
+        self.stdout.write(f"RESUMEN: {ok} exitosos, {err} con error.")
+        if dry_run:
+            self.stdout.write(self.style.WARNING(
+                "MODO PRUEBA: ejecuta sin --dry-run para aplicar los cambios."
+            ))
+        else:
+            self.stdout.write(self.style.SUCCESS("Reprocesado completado."))

api/organization/admin.py

@@ -5,14 +5,18 @@ from .models import Organizacion
 
 @admin.register(Organizacion)
 class OrganizacionAdmin(admin.ModelAdmin):
-    list_display = ('nombre', 'rfc', 'email', 'telefono', 'owner', 'is_active', 'is_verified', 'inicio', 'vencimiento')
-    search_fields = ('nombre', 'rfc', 'email')
+    list_display = ('nombre', 'rfc', 'hub_tenant_slug', 'email', 'owner', 'is_active', 'is_verified', 'inicio', 'vencimiento')
+    search_fields = ('nombre', 'rfc', 'email', 'hub_tenant_slug')
     list_filter = ('is_active', 'is_verified', 'is_agente_aduanal')
     ordering = ('nombre',)
     autocomplete_fields = ('owner',)
     readonly_fields = ('created_at', 'updated_at')
     fieldsets = (
         (None, {'fields': ('nombre', 'rfc', 'titular', 'licencia')}),
+        ('Integración Hub', {
+            'fields': ('hub_tenant_slug',),
+            'description': 'Slug único del tenant en Aduanasoft Hub. Debe coincidir exactamente con el slug creado en el panel del Hub.',
+        }),
         ('Contacto', {'fields': ('email', 'telefono', 'estado', 'ciudad')}),
         ('Administrador maestro', {'fields': ('owner',)}),
         ('Estado', {'fields': ('is_active', 'is_verified', 'is_agente_aduanal', 'apply_auto_download')}),

api/organization/migrations/0005_organizacion_hub_tenant_slug.py

@@ -0,0 +1,16 @@
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('organization', '0004_organizacion_owner'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='organizacion',
+            name='hub_tenant_slug',
+            field=models.CharField(blank=True, default='', max_length=100),
+        ),
+    ]

api/organization/models.py

@@ -61,7 +61,10 @@ class Organizacion(models.Model):
     updated_at = models.DateTimeField(auto_now=True)
 
     observaciones = models.TextField(null=True, blank=True)
-    
+
+    # Slug del tenant en Hub — "temex", "empresa-abc", etc.
+    hub_tenant_slug = models.CharField(max_length=100, blank=True, default='')
+
 
     @property
     def espacio_utilizado(self):

api/reports/migrations/0004_alter_reportdocument_report_type.py

@@ -0,0 +1,18 @@
+# Generated by Django 5.2.3 on 2026-06-11 14:42
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('reports', '0003_alter_reportdocument_file'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='reportdocument',
+            name='report_type',
+            field=models.CharField(choices=[('cumplimiento', 'cumplimiento'), ('control_pedimento', 'control_pedimento'), ('datastage', 'datastage')], default='cumplimiento', max_length=30),
+        ),
+    ]

api/reports/models.py

@@ -12,6 +12,7 @@ class ReportDocument(models.Model):
 	TYPE_REPORT = [
 		('cumplimiento', 'cumplimiento'),
 		('control_pedimento', 'control_pedimento'),
+		('datastage', 'datastage'),
 	]
 	user = models.ForeignKey(get_user_model(), on_delete=models.CASCADE, related_name='report_documents')
 	filters = models.JSONField(blank=True, null=True)

api/reports/services/datastage_export.py

@@ -0,0 +1,557 @@
+"""
+Lógica de exportación de reportes DataStage, extraída de ExportDataStageView
+para poder ejecutarse dentro de una task Celery (sin request/HttpResponse).
+
+Cada builder devuelve una tupla (content_bytes, filename, content_type, total_rows).
+El aislamiento multi-tenant viene resuelto en global_filters['organizacion']
+(la vista lo resuelve con get_org_context antes de encolar).
+"""
+import csv
+import datetime
+import hashlib
+import io
+import uuid
+import zipfile
+
+import openpyxl
+from django.apps import apps
+from django.core.paginator import Paginator
+
+from api.organization.models import Organizacion
+
+MAX_RECORDS_PER_FILE = 500000  # Límite por archivo Excel antes de particionar en ZIP
+
+XLSX_CONTENT_TYPE = 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'
+CSV_CONTENT_TYPE = 'text/csv; charset=utf-8'
+ZIP_CONTENT_TYPE = 'application/zip'
+
+RELATION_FIELDS = ['seccion_aduanera', 'patente', 'pedimento']
+
+
+def safe_excel_value(value):
+    """Convierte cualquier valor a un formato seguro para Excel/CSV."""
+    if value is None:
+        return ''
+    elif isinstance(value, (uuid.UUID,)):
+        return str(value)
+    elif hasattr(value, 'uuid'):
+        return str(value.uuid)
+    elif hasattr(value, 'id'):
+        return str(value.id)
+    elif isinstance(value, (datetime.datetime, datetime.date)):
+        return value.isoformat()
+    elif isinstance(value, (dict, list)):
+        return str(value)
+    else:
+        return str(value)
+
+
+def apply_global_filters_to_model(global_filters, model):
+    """Traduce los filtros globales a filtros ORM según los campos del modelo."""
+    filters = {}
+    model_fields = [f.name for f in model._meta.get_fields()]
+
+    # Organización — FK usa UUID, CharField usa el string tal cual
+    org_value = global_filters.get('organizacion')
+    if org_value and org_value != '' and 'organizacion' in model_fields:
+        field = model._meta.get_field('organizacion')
+        if hasattr(field, 'related_model'):
+            try:
+                filters['organizacion_id'] = uuid.UUID(org_value)
+            except Exception:
+                filters['organizacion_id'] = org_value
+        else:
+            filters['organizacion'] = org_value
+
+    rfc_value = global_filters.get('rfc')
+    if rfc_value and rfc_value != '' and 'rfc' in model_fields:
+        filters['rfc'] = rfc_value
+
+    if global_filters.get('patente'):
+        filters['patente'] = global_filters['patente']
+
+    if global_filters.get('pedimento'):
+        filters['pedimento'] = global_filters['pedimento']
+
+    if 'fecha_pago_real' in model_fields:
+        if global_filters.get('fecha_pago_desde'):
+            filters['fecha_pago_real__gte'] = global_filters['fecha_pago_desde']
+        if global_filters.get('fecha_pago_hasta'):
+            filters['fecha_pago_real__lte'] = global_filters['fecha_pago_hasta']
+
+    return filters
+
+
+def apply_related_filters(global_filters, model, related_keys):
+    """Filtros para modo múltiple: globales + llaves de cruce entre modelos."""
+    filters = {}
+    model_fields = [f.name for f in model._meta.get_fields()]
+
+    if 'organizacion' in model_fields and global_filters.get('organizacion'):
+        org_value = global_filters['organizacion']
+        try:
+            field = model._meta.get_field('organizacion')
+            if hasattr(field, 'related_model'):
+                filters['organizacion_id'] = uuid.UUID(org_value)
+            else:
+                filters['organizacion'] = org_value
+        except Exception:
+            filters['organizacion_id'] = org_value
+
+    if 'rfc' in model_fields and global_filters.get('rfc'):
+        filters['rfc'] = global_filters['rfc']
+
+    if 'fecha_pago_real' in model_fields:
+        if global_filters.get('fecha_pago_desde'):
+            filters['fecha_pago_real__gte'] = global_filters['fecha_pago_desde']
+        if global_filters.get('fecha_pago_hasta'):
+            filters['fecha_pago_real__lte'] = global_filters['fecha_pago_hasta']
+
+    if any(related_keys.values()):
+        if related_keys.get('patentes') and 'patente' in model_fields:
+            filters['patente__in'] = related_keys['patentes']
+        if related_keys.get('pedimentos') and 'pedimento' in model_fields:
+            filters['pedimento__in'] = related_keys['pedimentos']
+        if related_keys.get('datastage_ids') and 'datastage_id' in model_fields:
+            filters['datastage_id__in'] = related_keys['datastage_ids']
+    else:
+        if 'patente' in model_fields and global_filters.get('patente'):
+            filters['patente'] = global_filters['patente']
+        if 'pedimento' in model_fields and global_filters.get('pedimento'):
+            filters['pedimento'] = global_filters['pedimento']
+
+    return filters
+
+
+def get_related_keys_from_filters(global_filters, models_data):
+    """
+    Construye el conjunto de (patente, pedimento, datastage_id) que servirá como
+    llave de cruce entre modelos.
+
+    Regla clave: si el filtro RFC está activo, solo los modelos que tienen el campo
+    'rfc' pueden contribuir a related_keys. Los modelos sin 'rfc' (ej. 505, 506)
+    no se usan como semilla — solo se filtrarán más tarde usando las claves ya
+    construidas, evitando que contaminen el resultado con pedimentos de otros RFC.
+    """
+    related_keys = {
+        'patentes': set(),
+        'pedimentos': set(),
+        'datastage_ids': set()
+    }
+
+    # Sin filtros significativos → sin cruce
+    if not any(v for v in global_filters.values() if v not in [None, '']):
+        return {}
+
+    rfc_filter_active = bool(global_filters.get('rfc'))
+    date_filter_active = bool(global_filters.get('fecha_pago_desde') or global_filters.get('fecha_pago_hasta'))
+    all_records_with_filters = []
+
+    for model_data in models_data:
+        model_name = model_data.get('model')
+        try:
+            model = apps.get_model('datastage', model_name)
+            model_field_names = {f.name for f in model._meta.get_fields() if hasattr(f, 'name')}
+
+            # Un modelo puede ser semilla de related_keys SOLO si tiene campos
+            # para aplicar TODOS los filtros activos
+            if rfc_filter_active and 'rfc' not in model_field_names:
+                continue
+            if date_filter_active and 'fecha_pago_real' not in model_field_names:
+                continue
+
+            filters = apply_global_filters_to_model(global_filters, model)
+            if not filters:
+                continue
+
+            records = model.objects.filter(**filters).values('patente', 'pedimento', 'datastage_id')
+            all_records_with_filters.extend(list(records))
+
+        except LookupError:
+            continue
+
+    if not all_records_with_filters:
+        return {'patentes': set(), 'pedimentos': set(), 'datastage_ids': set()}
+
+    for record in all_records_with_filters:
+        if record.get('patente'):
+            related_keys['patentes'].add(record['patente'])
+        if record.get('pedimento'):
+            related_keys['pedimentos'].add(record['pedimento'])
+        if record.get('datastage_id'):
+            related_keys['datastage_ids'].add(record['datastage_id'])
+
+    return {k: list(v) for k, v in related_keys.items() if v}
+
+
+# ---------------------------------------------------------------------------
+# Exportación simple (un solo modelo)
+# ---------------------------------------------------------------------------
+
+def build_simple_export(model_name, fields, global_filters, export_format, progress_cb=None):
+    progress_cb = progress_cb or (lambda p, m: None)
+
+    try:
+        model = apps.get_model('datastage', model_name)
+    except LookupError:
+        raise ValueError(f'Modelo {model_name} no encontrado')
+
+    filters = apply_global_filters_to_model(global_filters, model)
+    queryset = model.objects.filter(**filters).values(*fields)
+    total_records = queryset.count()
+    progress_cb(20, f'{model_name}: {total_records} registros encontrados')
+
+    if export_format == 'excel':
+        if total_records > MAX_RECORDS_PER_FILE:
+            content, filename, content_type = _simple_excel_partitioned(model_name, fields, queryset, progress_cb)
+        else:
+            content, filename, content_type = _simple_excel(model_name, fields, queryset, progress_cb)
+    else:
+        # CSV no tiene límite de filas — siempre un solo archivo
+        content, filename, content_type = _simple_csv(model_name, fields, queryset, progress_cb)
+
+    return content, filename, content_type, total_records
+
+
+def _simple_excel(model_name, fields, queryset, progress_cb):
+    progress_cb(40, f'Escribiendo Excel de {model_name}...')
+    wb = openpyxl.Workbook()
+    ws = wb.active
+    ws.append(fields)
+    for row in queryset:
+        ws.append([safe_excel_value(row[field]) for field in fields])
+    progress_cb(88, 'Serializando archivo...')
+    output = io.BytesIO()
+    wb.save(output)
+    return output.getvalue(), f'{model_name}.xlsx', XLSX_CONTENT_TYPE
+
+
+def _simple_csv(model_name, fields, queryset, progress_cb):
+    progress_cb(40, f'Escribiendo CSV de {model_name}...')
+    buf = io.StringIO()
+    writer = csv.DictWriter(buf, fieldnames=fields)
+    writer.writeheader()
+    for row in queryset:
+        writer.writerow(row)
+    progress_cb(88, 'Serializando archivo...')
+    return buf.getvalue().encode('utf-8'), f'{model_name}.csv', CSV_CONTENT_TYPE
+
+
+def _simple_excel_partitioned(model_name, fields, queryset, progress_cb):
+    zip_buffer = io.BytesIO()
+    with zipfile.ZipFile(zip_buffer, 'w', zipfile.ZIP_DEFLATED) as zip_file:
+        paginator = Paginator(queryset, MAX_RECORDS_PER_FILE)
+        for page_num in paginator.page_range:
+            pct = 25 + int((page_num / paginator.num_pages) * 55)
+            progress_cb(pct, f'Particionando {model_name}: parte {page_num}/{paginator.num_pages}')
+            page = paginator.page(page_num)
+
+            wb = openpyxl.Workbook()
+            ws = wb.active
+            ws.title = f'Parte_{page_num}'[:31]
+            ws.append(fields)
+            for row in page.object_list:
+                ws.append([safe_excel_value(row[field]) for field in fields])
+
+            part_buffer = io.BytesIO()
+            wb.save(part_buffer)
+            zip_file.writestr(f'{model_name}_part{page_num}.xlsx', part_buffer.getvalue())
+
+    progress_cb(88, 'Serializando archivo...')
+    return zip_buffer.getvalue(), f'{model_name}_particionado.zip', ZIP_CONTENT_TYPE
+
+
+def _simple_csv_partitioned(model_name, fields, queryset, progress_cb):
+    zip_buffer = io.BytesIO()
+    with zipfile.ZipFile(zip_buffer, 'w', zipfile.ZIP_DEFLATED) as zip_file:
+        paginator = Paginator(queryset, MAX_RECORDS_PER_FILE)
+        for page_num in paginator.page_range:
+            pct = 25 + int((page_num / paginator.num_pages) * 55)
+            progress_cb(pct, f'Particionando {model_name}: parte {page_num}/{paginator.num_pages}')
+            page = paginator.page(page_num)
+
+            csv_buffer = io.StringIO()
+            writer = csv.writer(csv_buffer)
+            writer.writerow(fields)
+            for row in page.object_list:
+                writer.writerow([safe_excel_value(row[field]) for field in fields])
+
+            zip_file.writestr(f'{model_name}_part{page_num}.csv', csv_buffer.getvalue())
+
+    progress_cb(88, 'Serializando archivo...')
+    return zip_buffer.getvalue(), f'{model_name}_particionado.zip', ZIP_CONTENT_TYPE
+
+
+# ---------------------------------------------------------------------------
+# Exportación múltiple (varios modelos agrupados por llaves de cruce)
+# ---------------------------------------------------------------------------
+
+def _collect_multiple_data(models_data, global_filters, related_keys, progress_cb):
+    """
+    Recolecta y agrupa los registros de todos los modelos por la llave
+    seccion_aduanera + patente + pedimento. Mapea organizacion_id → nombre.
+    """
+    org_mapping = {str(org.id): org.nombre for org in Organizacion.objects.all()}
+    all_models_data = {}
+    total_models = len(models_data) or 1
+
+    for idx, model_data in enumerate(models_data):
+        model_name = model_data.get('model')
+        fields = model_data.get('fields', [])
+
+        if not model_name or not fields:
+            continue
+
+        # Normalizar campos: 'organizacion' → 'organizacion_id', sin duplicados
+        normalized_fields = []
+        for f in fields:
+            key = f.strip() if isinstance(f, str) else 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
+
+        for req_field in RELATION_FIELDS:
+            if req_field not in fields:
+                fields.append(req_field)
+
+        try:
+            model = apps.get_model('datastage', model_name)
+            model_field_names = [f.name for f in model._meta.get_fields() if hasattr(f, 'name')]
+            if 'organizacion_id' not in fields and 'organizacion_id' in model_field_names:
+                fields.append('organizacion_id')
+
+            filters = apply_related_filters(global_filters, model, related_keys)
+            queryset = model.objects.filter(**filters).values(*fields) if filters else model.objects.none()
+
+            count = queryset.count()
+            pct = 20 + int((idx / total_models) * 55)
+            progress_cb(pct, f'Modelo {idx + 1}/{total_models}: {model_name} ({count} registros)')
+            if count == 0:
+                continue
+
+            relation_fields = [fn for fn in RELATION_FIELDS if fn in fields]
+            if not relation_fields:
+                relation_fields = ['datastage_id'] if 'datastage_id' in fields else [fields[0]]
+
+            for record in queryset:
+                key_parts = [str(record[rf]) for rf in relation_fields if rf in record and record[rf] is not None]
+                if not key_parts:
+                    key = hashlib.md5(str(sorted(record.items())).encode()).hexdigest()[:10]
+                else:
+                    key = "_".join(key_parts)
+
+                processed_record = {}
+                for field_name, value in record.items():
+                    if field_name == 'organizacion_id' and value:
+                        org_id_str = str(value)
+                        if org_id_str in org_mapping:
+                            processed_value = org_mapping[org_id_str]
+                        else:
+                            try:
+                                org = Organizacion.objects.filter(id=value).first()
+                                processed_value = org.nombre if org else org_id_str
+                                org_mapping[org_id_str] = processed_value
+                            except Exception:
+                                processed_value = org_id_str
+                    else:
+                        processed_value = value
+
+                    if field_name in relation_fields:
+                        prefixed_field_name = field_name
+                    else:
+                        prefixed_field_name = f"{model_name}_{field_name}"
+
+                    if field_name == 'organizacion_id':
+                        prefixed_field_name = prefixed_field_name.replace('organizacion_id', 'organizacion_nombre')
+
+                    processed_record[prefixed_field_name] = safe_excel_value(processed_value)
+
+                if key not in all_models_data:
+                    all_models_data[key] = {'relation_fields': {}, 'model_records': {}}
+
+                for rel_field in relation_fields:
+                    if rel_field in record:
+                        all_models_data[key]['relation_fields'][rel_field] = record[rel_field]
+
+                if model_name not in all_models_data[key]['model_records']:
+                    all_models_data[key]['model_records'][model_name] = []
+
+                all_models_data[key]['model_records'][model_name].append(processed_record)
+
+        except LookupError:
+            continue
+
+    return all_models_data
+
+
+def _build_combined_rows(all_models_data):
+    """Construye filas combinadas — repite el último registro en lugar de dejar vacíos."""
+    combined_rows = []
+    for key, data in all_models_data.items():
+        relation_fields_data = data['relation_fields']
+        model_records = data['model_records']
+
+        max_records_per_key = max((len(recs) for recs in model_records.values()), default=1)
+
+        for i in range(max_records_per_key):
+            row_data = {}
+            for rel_field, rel_value in relation_fields_data.items():
+                row_data[rel_field] = safe_excel_value(rel_value)
+            for model_name, records in model_records.items():
+                # Usar posición i o el último registro disponible
+                record = records[i] if i < len(records) else records[-1]
+                for field_name, value in record.items():
+                    row_data[field_name] = value
+            combined_rows.append(row_data)
+
+    return combined_rows
+
+
+def _ordered_fields(combined_rows):
+    """Encabezados: campos de relación primero, luego organización, luego el resto."""
+    all_fields_set = set()
+    for row in combined_rows:
+        all_fields_set.update(row.keys())
+
+    all_fields = []
+    for rel_field in RELATION_FIELDS:
+        if rel_field in all_fields_set:
+            all_fields.append(rel_field)
+            all_fields_set.discard(rel_field)
+
+    org_fields = sorted(f for f in all_fields_set if 'organizacion' in f.lower())
+    for org_field in org_fields:
+        all_fields.append(org_field)
+        all_fields_set.discard(org_field)
+
+    all_fields.extend(sorted(all_fields_set))
+    return all_fields
+
+
+def build_multiple_export(models_data, global_filters, export_format, progress_cb=None):
+    progress_cb = progress_cb or (lambda p, m: None)
+
+    progress_cb(15, 'Resolviendo llaves de cruce entre modelos...')
+    related_keys = get_related_keys_from_filters(global_filters, models_data)
+
+    all_models_data = _collect_multiple_data(models_data, global_filters, related_keys, progress_cb)
+
+    # Sin datos → archivo con mensaje, no error (el frontend espera un archivo)
+    if not all_models_data:
+        if export_format == 'excel':
+            wb = openpyxl.Workbook()
+            ws = wb.active
+            ws.title = "Sin datos"
+            ws.append(["No se encontraron datos para los filtros especificados"])
+            output = io.BytesIO()
+            wb.save(output)
+            return output.getvalue(), 'datastage_sin_datos.xlsx', XLSX_CONTENT_TYPE, 0
+        else:
+            buf = io.StringIO()
+            csv.writer(buf).writerow(['No se encontraron datos para los filtros especificados'])
+            return buf.getvalue().encode('utf-8'), 'datastage_sin_datos.csv', CSV_CONTENT_TYPE, 0
+
+    progress_cb(80, 'Combinando filas...')
+    combined_rows = _build_combined_rows(all_models_data)
+    all_fields = _ordered_fields(combined_rows)
+    total_rows = len(combined_rows)
+
+    if export_format == 'excel':
+        content, filename, content_type = _multiple_excel(combined_rows, all_fields, progress_cb)
+    else:
+        content, filename, content_type = _multiple_csv(combined_rows, all_fields, progress_cb)
+
+    return content, filename, content_type, total_rows
+
+
+def _multiple_excel(combined_rows, all_fields, progress_cb):
+    now_str = datetime.datetime.now().strftime('%d/%m/%Y %H:%M:%S')
+    title_row = ["Reporte Datastage"]
+    date_row = [f"Generado: {now_str}"]
+
+    def _write_sheet(ws, sheet_name, page_rows):
+        ws.title = sheet_name[:31]
+        ws.append(title_row)
+        ws.append(date_row)
+        ws.append([])
+        ws.append(all_fields)
+        for row_data in page_rows:
+            ws.append([row_data.get(field, '') for field in all_fields])
+        for column in ws.columns:
+            max_length = 0
+            col_letter = column[0].column_letter
+            for cell in column:
+                try:
+                    if len(str(cell.value)) > max_length:
+                        max_length = len(str(cell.value))
+                except Exception:
+                    pass
+            ws.column_dimensions[col_letter].width = min(max_length + 2, 50)
+
+    # Excel directo si cabe en un archivo; ZIP solo si se necesita particionar
+    paginator = Paginator(combined_rows, MAX_RECORDS_PER_FILE)
+
+    if paginator.num_pages == 1:
+        progress_cb(88, 'Serializando archivo...')
+        wb = openpyxl.Workbook()
+        _write_sheet(wb.active, "Datastage", paginator.page(1).object_list)
+        output = io.BytesIO()
+        wb.save(output)
+        return output.getvalue(), 'datastage_reporte.xlsx', XLSX_CONTENT_TYPE
+
+    zip_buffer = io.BytesIO()
+    with zipfile.ZipFile(zip_buffer, 'w', zipfile.ZIP_DEFLATED) as zip_file:
+        for page_num in paginator.page_range:
+            progress_cb(80 + int((page_num / paginator.num_pages) * 8),
+                        f'Particionando: parte {page_num}/{paginator.num_pages}')
+            page = paginator.page(page_num)
+            current_wb = openpyxl.Workbook()
+            _write_sheet(current_wb.active, f"Datastage_p{page_num}", page.object_list)
+            part_buffer = io.BytesIO()
+            current_wb.save(part_buffer)
+            zip_file.writestr(f"datastage_part{page_num}.xlsx", part_buffer.getvalue())
+
+    progress_cb(88, 'Serializando archivo...')
+    return zip_buffer.getvalue(), 'datastage_combinado.zip', ZIP_CONTENT_TYPE
+
+
+def _multiple_csv(combined_rows, all_fields, progress_cb):
+    progress_cb(88, 'Serializando archivo...')
+    buf = io.StringIO()
+    writer = csv.writer(buf)
+    writer.writerow(all_fields)
+    for row_data in combined_rows:
+        writer.writerow([row_data.get(field, '') for field in all_fields])
+    return buf.getvalue().encode('utf-8'), 'datastage_reporte.csv', CSV_CONTENT_TYPE
+
+
+# ---------------------------------------------------------------------------
+# Dispatcher
+# ---------------------------------------------------------------------------
+
+def build_datastage_export(payload, progress_cb=None):
+    """
+    Genera el reporte DataStage a partir del payload persistido en
+    ReportDocument.filters. Lanza ValueError si el payload es inválido.
+
+    Retorna (content_bytes, filename, content_type, total_rows).
+    """
+    modo = payload.get('modo', 'simple')
+    export_format = payload.get('format', 'csv')
+    global_filters = payload.get('globalFilters') or {}
+
+    if modo == 'multiple':
+        models_data = payload.get('models') or []
+        if not models_data:
+            raise ValueError('models es requerido para exportación múltiple')
+        return build_multiple_export(models_data, global_filters, export_format, progress_cb)
+
+    model_name = payload.get('model')
+    fields = payload.get('fields')
+    if not model_name or not fields:
+        raise ValueError('model y fields son requeridos para exportación simple')
+    return build_simple_export(model_name, fields, global_filters, export_format, progress_cb)

api/reports/tasks/__init__.py

@@ -0,0 +1,3 @@
+# Importa los módulos de tasks para que autodiscover_tasks() los registre en el worker
+from .report_document import generate_report_document, generate_report_control_pedimento
+from .report_datastage import generate_report_datastage

api/reports/tasks/report_datastage.py

@@ -0,0 +1,105 @@
+import logging
+import traceback
+
+from celery import shared_task
+from celery.exceptions import SoftTimeLimitExceeded
+from django.core.files.uploadedfile import SimpleUploadedFile
+from django.utils import timezone
+
+from api.reports.models import ReportDocument
+from api.reports.services.datastage_export import build_datastage_export
+from api.utils.storage_service import storage_service
+from core.redis_events import publish_task_event
+
+logger = logging.getLogger('api.reports.tasks')
+
+
+@shared_task(bind=True, queue='reports', soft_time_limit=1800, time_limit=1860)
+def generate_report_datastage(self, report_id):
+    task_id = self.request.id
+    report = None
+
+    def _fail(msg, exc=None):
+        """Marca el reporte como error, notifica al frontend y loguea. Sin re-raise."""
+        tb = traceback.format_exc() if exc else ''
+        full_msg = f"{msg}\n\n{tb}".strip() if tb else msg
+        logger.error('[reporte_datastage] report=%s FALLO: %s', report_id, full_msg)
+        if report:
+            report.status = 'error'
+            report.error_message = full_msg
+            report.finished_at = timezone.now()
+            report.save(update_fields=['status', 'error_message', 'finished_at'])
+        publish_task_event(task_id, 'failed', msg, progress=0)
+
+    # ── 1. Obtener reporte ────────────────────────────────────────────────────
+    try:
+        report = ReportDocument.objects.get(id=report_id)
+    except ReportDocument.DoesNotExist:
+        logger.error('[reporte_datastage] ReportDocument %s no existe', report_id)
+        publish_task_event(task_id, 'failed', f'Reporte {report_id} no encontrado', progress=0)
+        return
+
+    logger.info('[reporte_datastage] Iniciando report=%s user=%s', report_id, report.user_id)
+    report.status = 'processing'
+    report.save(update_fields=['status'])
+    publish_task_event(task_id, 'processing', 'Iniciando generación de reporte...', progress=5)
+
+    try:
+        # La organización ya viene resuelta en el payload (la vista la fija antes de encolar)
+        payload = report.filters or {}
+        org_id = payload.get('organizacion_id')
+
+        def _progress(pct, msg):
+            publish_task_event(task_id, 'processing', msg, progress=pct)
+
+        # ── 2. Generar archivo (xlsx / csv / zip según modo, formato y volumen) ──
+        content, filename, content_type, total_rows = build_datastage_export(payload, _progress)
+
+        # ── 3. Subir a almacenamiento ─────────────────────────────────────────
+        logger.info('[reporte_datastage] report=%s archivo=%s size=%.1fKB filas=%d',
+                    report_id, filename, len(content) / 1024, total_rows)
+        publish_task_event(task_id, 'processing', 'Subiendo a almacenamiento...', progress=93)
+
+        final_name = f"datastage_{report.id}_{timezone.now().strftime('%Y%m%d%H%M%S')}_{filename}"
+        ruta = storage_service.save_report(
+            file=SimpleUploadedFile(
+                name=final_name,
+                content=content,
+                content_type=content_type,
+            ),
+            organizacion_id=org_id,
+            metadata={
+                'report_id': str(report.id),
+                'report_type': 'datastage',
+                'user_id': str(report.user.id) if report.user else None,
+            },
+        )
+
+        if ruta:
+            logger.info('[reporte_datastage] report=%s guardado en storage=%s', report_id, ruta)
+            report.file = ruta
+            report.status = 'ready'
+        else:
+            _fail('Error al guardar el archivo en almacenamiento (storage retornó None)')
+            return
+
+        report.finished_at = timezone.now()
+        report.save(update_fields=['status', 'file', 'finished_at', 'error_message'])
+
+        resultado = {
+            'report_id': str(report.id),
+            'total_registros': total_rows,
+            'archivo': final_name,
+        }
+        publish_task_event(task_id, 'completed', 'Reporte generado exitosamente.', progress=100, resultado=resultado)
+        logger.info('[reporte_datastage] report=%s COMPLETADO filas=%d', report_id, total_rows)
+        return resultado
+
+    except SoftTimeLimitExceeded:
+        _fail('El reporte tardó más de 30 minutos y fue cancelado. Intenta con filtros más acotados.')
+
+    except ValueError as exc:
+        _fail(str(exc))
+
+    except Exception as exc:
+        _fail(str(exc), exc=exc)

api/reports/tasks/report_document.py

@@ -1,128 +1,373 @@
-import tempfile
-
-from api.utils.storage_service import storage_service
-from celery import shared_task
-from api.organization.models import Organizacion
-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, Exists, OuterRef
-# from django.db.models import Q, 
-from api.record.models import Document
-import csv
+import io
+import logging
 import os
-from django.conf import settings
-from django.core.files.uploadedfile import SimpleUploadedFile
+import tempfile
+import traceback
+from collections import defaultdict
 
-@shared_task
-def generate_report_document(report_id):
+import openpyxl
+from openpyxl.styles import Alignment, Font, PatternFill
+
+from celery import shared_task
+from celery.exceptions import SoftTimeLimitExceeded
+from django.core.files.uploadedfile import SimpleUploadedFile
+from django.db.models import Q
+from django.utils import timezone
+
+from api.customs.models import Cove, EDocument, Partida, Pedimento
+from api.organization.models import Organizacion
+from api.record.models import Document
+from api.reports.models import ReportDocument
+from api.utils.storage_service import storage_service
+from core.redis_events import publish_task_event
+
+logger = logging.getLogger('api.reports.tasks')
+
+
+# ── helpers ───────────────────────────────────────────────────────────────────
+
+def _estado(flag: bool) -> str:
+    return 'RECUPERADO' if flag else 'PENDIENTE'
+
+
+def _build_pedimento_filters(filters: dict) -> Q:
+    q = Q()
+    if filters.get('organizacion_id'):
+        q &= Q(organizacion_id=filters['organizacion_id'])
+    if filters.get('fecha_pago__gte'):
+        q &= Q(fecha_pago__gte=filters['fecha_pago__gte'])
+    if filters.get('fecha_pago__lte'):
+        q &= Q(fecha_pago__lte=filters['fecha_pago__lte'])
+    if filters.get('patente'):
+        q &= Q(patente=filters['patente'])
+    if filters.get('aduana'):
+        q &= Q(aduana=filters['aduana'])
+    if filters.get('pedimento'):
+        q &= Q(pedimento=filters['pedimento'])
+    if filters.get('pedimento_app'):
+        q &= Q(pedimento_app=filters['pedimento_app'])
+    if filters.get('regimen'):
+        q &= Q(regimen=filters['regimen'])
+    if filters.get('tipo_operacion'):
+        q &= Q(tipo_operacion_id=filters['tipo_operacion'])
+    rfc_val = filters.get('contribuyente__rfc')
+    if rfc_val:
+        if rfc_val == 'SIN_RFC':
+            q &= Q(contribuyente__isnull=True)
+        else:
+            q &= Q(contribuyente__rfc=rfc_val)
+    return q
+
+
+def _apply_user_rfc_filter(q: Q, user, requested_rfc: str | None) -> Q:
+    """Restringe el queryset a los importadores visibles del usuario."""
+    # SIN_RFC ya fue aplicado en _build_pedimento_filters como contribuyente__isnull=True
+    if requested_rfc == 'SIN_RFC':
+        return q
+    user_rfcs = user.rfc.all()
+    if not user_rfcs.exists():
+        if requested_rfc:
+            q &= Q(contribuyente__rfc=requested_rfc)
+        return q
+    if requested_rfc:
+        if user_rfcs.filter(rfc=requested_rfc).exists():
+            q &= Q(contribuyente__rfc=requested_rfc)
+        else:
+            q &= Q(contribuyente__in=user_rfcs)
+    else:
+        q &= Q(contribuyente__in=user_rfcs)
+    return q
+
+
+# ── tarea principal ───────────────────────────────────────────────────────────
+
+@shared_task(bind=True, queue='reports', soft_time_limit=600, time_limit=660)
+def generate_report_document(self, report_id):
+    task_id = self.request.id
+    report = None
+
+    def _fail(msg, exc=None):
+        """Marca el reporte como error, notifica al frontend y loguea. Sin re-raise."""
+        tb = traceback.format_exc() if exc else ''
+        full_msg = f"{msg}\n\n{tb}".strip() if tb else msg
+        logger.error('[reporte_cumplimiento] report=%s FALLO: %s', report_id, full_msg)
+        if report:
+            report.status = 'error'
+            report.error_message = full_msg
+            report.finished_at = timezone.now()
+            report.save(update_fields=['status', 'error_message', 'finished_at'])
+        publish_task_event(task_id, 'failed', msg, progress=0)
+
+    # ── 1. Obtener reporte ────────────────────────────────────────────────────
     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'])
-        # Consulta asíncrona de los modelos
-        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"
+    except ReportDocument.DoesNotExist:
+        logger.error('[reporte_cumplimiento] ReportDocument %s no existe', report_id)
+        publish_task_event(task_id, 'failed', f'Reporte {report_id} no encontrado', progress=0)
+        return
 
-        with tempfile.NamedTemporaryFile(mode='w', delete=False, suffix='.csv', encoding='utf-8', newline='') as f:
-            tmp_path = f.name
-        
-        # Escribir CSV en archivo temporal
-        with open(tmp_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, ''
-                    ])
-        
-        # ============ NUEVO: Guardar en MinIO ============
-        # Leer archivo temporal
-        with open(tmp_path, 'rb') as f:
-            file_content = f.read()
-        
-        # Crear UploadedFile
-        uploaded_file = SimpleUploadedFile(
-            name=filename,
-            content=file_content,
-            content_type='text/csv'
+    logger.info('[reporte_cumplimiento] Iniciando report=%s user=%s', report_id, report.user_id)
+    report.status = 'processing'
+    report.save(update_fields=['status'])
+    publish_task_event(task_id, 'processing', 'Iniciando generación de reporte...', progress=5)
+
+    try:
+        filters = report.filters or {}
+        org_id  = filters.get('organizacion_id')
+
+        # ── 2. Filtros y organización ─────────────────────────────────────────
+        q = _build_pedimento_filters(filters)
+        q = _apply_user_rfc_filter(q, report.user, filters.get('contribuyente__rfc'))
+
+        nombre_org = ''
+        if org_id:
+            try:
+                nombre_org = Organizacion.objects.get(id=org_id).nombre
+            except Organizacion.DoesNotExist:
+                pass
+
+        logger.info('[reporte_cumplimiento] report=%s org=%s filtros=%s', report_id, nombre_org, filters)
+        publish_task_event(task_id, 'processing', f'Consultando RFCs de {nombre_org}...', progress=10)
+
+        # ── 3. Listar RFCs (consulta liviana) ────────────────────────────────
+        rfcs_list = list(
+            Pedimento.objects.filter(q)
+            .exclude(contribuyente__isnull=True)
+            .values_list('contribuyente__rfc', flat=True)
+            .distinct()
+            .order_by('contribuyente__rfc')
         )
-        
-        # Guardar en storage
+        if Pedimento.objects.filter(q, contribuyente__isnull=True).exists():
+            rfcs_list.append('SIN_RFC')
+
+        total_rfcs   = len(rfcs_list)
+        total_pedimentos = Pedimento.objects.filter(q).count()
+
+        logger.info('[reporte_cumplimiento] report=%s total_rfcs=%d total_pedimentos=%d',
+                    report_id, total_rfcs, total_pedimentos)
+
+        if total_rfcs == 0:
+            logger.warning('[reporte_cumplimiento] report=%s sin pedimentos para los filtros dados', report_id)
+
+        publish_task_event(
+            task_id, 'processing',
+            f'{total_rfcs} RFC(s) — {total_pedimentos} pedimentos', progress=15,
+        )
+
+        # ── 4. Crear workbook ─────────────────────────────────────────────────
+        wb = openpyxl.Workbook()
+        ws = wb.active
+        ws.title = 'Reporte Cumplimiento'
+
+        title_fill  = PatternFill(start_color='1F4E79', end_color='1F4E79', fill_type='solid')
+        title_font  = Font(color='FFFFFF', bold=True, size=12)
+        sub_fill    = PatternFill(start_color='2E75B6', end_color='2E75B6', fill_type='solid')
+        sub_font    = Font(color='FFFFFF', bold=True, size=10)
+        col_h_fill  = PatternFill(start_color='D6E4F0', end_color='D6E4F0', fill_type='solid')
+        col_h_font  = Font(bold=True, size=10)
+        footer_fill = PatternFill(start_color='E2EFDA', end_color='E2EFDA', fill_type='solid')
+        center      = Alignment(horizontal='center', vertical='center', wrap_text=True)
+        top_left    = Alignment(horizontal='left', vertical='top', wrap_text=True)
+
+        COL_HEADERS = [
+            'Año', 'Aduana', 'Patente', 'Pedimento',
+            'Nomenclatura Completo Pedimento', 'Clav', 'Tipo Operación',
+            'Expediente Sí', 'Documento', 'Estatus',
+        ]
+        TOTAL_COLS  = len(COL_HEADERS)
+        current_row = 1
+        safe_total  = max(total_rfcs, 1)
+
+        # ── 5. Procesar RFC por RFC ───────────────────────────────────────────
+        for rfc_idx, rfc in enumerate(rfcs_list):
+            pct = 20 + int((rfc_idx / safe_total) * 65)
+            publish_task_event(
+                task_id, 'processing',
+                f'RFC {rfc_idx + 1}/{total_rfcs}: {rfc}', progress=pct,
+            )
+
+            rfc_q = (
+                q & Q(contribuyente__isnull=True) if rfc == 'SIN_RFC'
+                else q & Q(contribuyente__rfc=rfc)
+            )
+
+            peds = list(
+                Pedimento.objects.filter(rfc_q)
+                .select_related('contribuyente', 'tipo_operacion')
+                .order_by('fecha_pago')
+            )
+            if not peds:
+                logger.warning('[reporte_cumplimiento] report=%s rfc=%s sin pedimentos, omitido', report_id, rfc)
+                continue
+
+            ped_ids      = [p.id for p in peds]
+            razon_social = nombre_org or 'Desconocido'
+
+            logger.info('[reporte_cumplimiento] report=%s rfc=%s pedimentos=%d',
+                        report_id, rfc, len(peds))
+
+            # documentos de este RFC solamente
+            coves_map: dict = defaultdict(list)
+            for c in Cove.objects.filter(pedimento_id__in=ped_ids):
+                coves_map[c.pedimento_id].append(c)
+
+            edocs_map: dict = defaultdict(list)
+            for e in EDocument.objects.filter(pedimento_id__in=ped_ids):
+                edocs_map[e.pedimento_id].append(e)
+
+            partidas_map: dict = defaultdict(list)
+            for p in Partida.objects.filter(pedimento_id__in=ped_ids).order_by('numero_partida'):
+                partidas_map[p.pedimento_id].append(p)
+
+            remesa_ped_ids: set = set(
+                Document.objects.filter(pedimento_id__in=ped_ids, document_type_id=15)
+                .values_list('pedimento_id', flat=True)
+            )
+
+            total_coves    = sum(len(v) for v in coves_map.values())
+            total_edocs    = sum(len(v) for v in edocs_map.values())
+            total_partidas = sum(len(v) for v in partidas_map.values())
+            est_rows       = len(peds) + total_partidas + total_coves * 2 + total_edocs * 2 + len(remesa_ped_ids)
+            logger.info('[reporte_cumplimiento] report=%s rfc=%s docs coves=%d edocs=%d partidas=%d remesas=%d filas_estimadas=%d',
+                        report_id, rfc, total_coves, total_edocs, total_partidas, len(remesa_ped_ids), est_rows)
+
+            # encabezado sección
+            ws.merge_cells(start_row=current_row, start_column=1, end_row=current_row, end_column=TOTAL_COLS)
+            cell = ws.cell(row=current_row, column=1, value='Reporte Integración de Expedientes.')
+            cell.fill, cell.font, cell.alignment = title_fill, title_font, center
+            current_row += 1
+
+            ws.merge_cells(start_row=current_row, start_column=1, end_row=current_row, end_column=TOTAL_COLS)
+            cell = ws.cell(row=current_row, column=1, value=f'Razón Social Importador: {razon_social}')
+            cell.fill, cell.font = sub_fill, sub_font
+            current_row += 1
+
+            ws.merge_cells(start_row=current_row, start_column=1, end_row=current_row, end_column=TOTAL_COLS)
+            cell = ws.cell(row=current_row, column=1, value=f'RFC: {rfc}')
+            cell.fill, cell.font = sub_fill, sub_font
+            current_row += 1
+
+            for col_i, header in enumerate(COL_HEADERS, 1):
+                cell = ws.cell(row=current_row, column=col_i, value=header)
+                cell.fill, cell.font, cell.alignment = col_h_fill, col_h_font, center
+            current_row += 1
+
+            total_exp = len(peds)
+            exp_con_docs = exp_completos = 0
+
+            for ped in peds:
+                doc_rows = [('PEDIMENTO COMPLETO', _estado(ped.existe_expediente))]
+
+                for partida in partidas_map[ped.id]:
+                    doc_rows.append((f'PARTIDA{partida.numero_partida}', _estado(partida.descargado)))
+                if ped.remesas:
+                    doc_rows.append(('REMESA', _estado(ped.id in remesa_ped_ids)))
+                for cove in coves_map[ped.id]:
+                    doc_rows.append((f'COVE{cove.numero_cove}', _estado(cove.cove_descargado)))
+                    doc_rows.append((f'ACUSE COVE{cove.numero_cove}', _estado(cove.acuse_cove_descargado)))
+                for edoc in edocs_map[ped.id]:
+                    doc_rows.append((f'EDOCUMENTO{edoc.numero_edocument}', _estado(edoc.edocument_descargado)))
+                    doc_rows.append((f'ACUSE EDOCUMENTO{edoc.numero_edocument}', _estado(edoc.acuse_descargado)))
+
+                if len(doc_rows) > 1:
+                    exp_con_docs += 1
+                if all(e == 'RECUPERADO' for _, e in doc_rows):
+                    exp_completos += 1
+
+                n_rows    = len(doc_rows)
+                start_row = current_row
+                anio      = ped.fecha_pago.year % 100 if ped.fecha_pago else ''
+                base_vals = [
+                    anio, ped.aduana or '', ped.patente or '', ped.pedimento or '',
+                    ped.pedimento_app or '', ped.clave_pedimento or '',
+                    ped.tipo_operacion.tipo if ped.tipo_operacion else '',
+                    'SI' if ped.existe_expediente else 'NO',
+                ]
+
+                # Sin merge_cells — para datasets grandes merge es O(n^2) y cuelga el proceso.
+                # Los datos base solo se escriben en la primera fila; el resto queda vacío,
+                # visualmente equivalente al merge pero sin el costo de memoria/CPU.
+                for offset, (doc_nombre, doc_est) in enumerate(doc_rows):
+                    r = start_row + offset
+                    if offset == 0:
+                        for col, val in enumerate(base_vals, 1):
+                            ws.cell(row=r, column=col, value=val)
+                    ws.cell(row=r, column=9, value=doc_nombre)
+                    ws.cell(row=r, column=10, value=doc_est)
+
+                current_row += n_rows
+
+            ws.merge_cells(start_row=current_row, start_column=1, end_row=current_row, end_column=TOTAL_COLS)
+            cell = ws.cell(
+                row=current_row, column=1,
+                value=(f'Total de Expedientes= {total_exp}   '
+                       f'Total De Expedientes Con Documentos= {exp_con_docs}   '
+                       f'Total De Expedientes Completos= {exp_completos}'),
+            )
+            cell.fill = footer_fill
+            cell.font = Font(bold=True)
+            current_row += 2
+
+            del peds, ped_ids, coves_map, edocs_map, partidas_map, remesa_ped_ids
+
+        for i, w in enumerate([6, 8, 8, 12, 32, 8, 16, 12, 32, 14], 1):
+            ws.column_dimensions[openpyxl.utils.get_column_letter(i)].width = w
+
+        # ── 6. Serializar y subir ─────────────────────────────────────────────
+        logger.info('[reporte_cumplimiento] report=%s serializando Excel...', report_id)
+        publish_task_event(task_id, 'processing', 'Serializando Excel...', progress=88)
+
+        filename = f"reporte_cumplimiento_{report.id}_{timezone.now().strftime('%Y%m%d%H%M%S')}.xlsx"
+        buf = io.BytesIO()
+        wb.save(buf)
+        excel_bytes = buf.getvalue()
+        logger.info('[reporte_cumplimiento] report=%s Excel size=%.1fKB', report_id, len(excel_bytes) / 1024)
+
+        publish_task_event(task_id, 'processing', 'Subiendo a almacenamiento...', progress=93)
+
         ruta = storage_service.save_report(
-            file=uploaded_file,
-            organizacion_id=filters.get('organizacion_id'),
+            file=SimpleUploadedFile(
+                name=filename,
+                content=excel_bytes,
+                content_type='application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+            ),
+            organizacion_id=org_id,
             metadata={
                 'report_id': str(report.id),
                 'report_type': 'cumplimiento',
-                'user_id': str(report.user.id) if report.user else None
-            }
+                'user_id': str(report.user.id) if report.user else None,
+            },
         )
-        
+
         if ruta:
-            report.file = ruta
+            logger.info('[reporte_cumplimiento] report=%s guardado en storage=%s', report_id, ruta)
+            report.file   = ruta
             report.status = 'ready'
         else:
-            report.status = 'error'
-            report.error_message = 'Error al guardar el archivo en storage'
-        
-        # Limpiar temporal
-        os.unlink(tmp_path)
-        
+            _fail('Error al guardar el archivo en almacenamiento (storage retornó None)')
+            return
+
         report.finished_at = timezone.now()
         report.save(update_fields=['status', 'file', 'finished_at', 'error_message'])
-        
-    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'])
+
+        resultado = {
+            'report_id':        str(report.id),
+            'total_rfcs':       total_rfcs,
+            'total_pedimentos': total_pedimentos,
+        }
+        publish_task_event(task_id, 'completed', 'Reporte generado exitosamente.', progress=100, resultado=resultado)
+        logger.info('[reporte_cumplimiento] report=%s COMPLETADO rfcs=%d pedimentos=%d',
+                    report_id, total_rfcs, total_pedimentos)
+        return resultado
+
+    except SoftTimeLimitExceeded:
+        _fail('El reporte tardó más de 10 minutos y fue cancelado. Intenta con un rango de fechas más acotado.')
+
+    except Exception as exc:
+        _fail(str(exc), exc=exc)
+
+
+# ── reporte de control de pedimentos (sin cambios) ────────────────────────────
 
 @shared_task
 def generate_report_control_pedimento(report_id):
@@ -133,8 +378,6 @@ def generate_report_control_pedimento(report_id):
         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']
@@ -145,15 +388,12 @@ def generate_report_control_pedimento(report_id):
         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
@@ -161,17 +401,15 @@ def generate_report_control_pedimento(report_id):
         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
+                nombre_organizacion = organizacion.nombre
             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 = ''
 
@@ -179,109 +417,78 @@ def generate_report_control_pedimento(report_id):
             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"
 
         with tempfile.NamedTemporaryFile(mode='w', delete=False, suffix='.csv', encoding='utf-8', newline='') as tmp:
             tmp_path = tmp.name
-        
+
         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.pedimento or '',
+                pedimento.pedimento_app or '',
                 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
-                ]
+                fila = datos_base_pedimento + [cove.numero_cove, 'COVE', 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
-                ]
+                fila = datos_base_pedimento + [partida.numero_partida, 'PARTIDA', 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
-                ]
+                fila = datos_base_pedimento + [edoc.numero_edocument, 'EDOCUMENT', estado]
                 todas_las_filas.append(fila)
 
-        # 5. ESCRIBIR ARCHIVO CSV
+        import csv
         with open(tmp_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([])
@@ -294,20 +501,15 @@ def generate_report_control_pedimento(report_id):
             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', 
+                '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(tmp_path, 'rb') as f:
             file_content = f.read()
 
@@ -344,4 +546,4 @@ def generate_report_control_pedimento(report_id):
             report.status = 'error'
             report.error_message = str(e)
             report.finished_at = timezone.now()
-            report.save(update_fields=['status', 'error_message', 'finished_at'])
+            report.save(update_fields=['status', 'error_message', 'finished_at'])

api/reports/tests.py

@@ -1,3 +1,446 @@
+"""
+Tests para generate_report_document (T2026-04-001).
+
+Ejecución:
+    python manage.py test api.reports.tests
+    python manage.py test api.reports.tests.TestEstadoHelper
+"""
+import io
+import uuid
+from unittest.mock import MagicMock, call, patch
+
+import openpyxl
+from django.contrib.auth import get_user_model
+from django.db.models import Q
 from django.test import TestCase
 
-# Create your tests here.
+from api.customs.models import Cove, EDocument, Importador, Partida, Pedimento
+from api.licence.models import Licencia
+from api.organization.models import Organizacion
+from api.reports.models import ReportDocument
+from api.reports.tasks.report_document import (
+    _apply_user_rfc_filter,
+    _estado,
+    generate_report_document,
+)
+
+User = get_user_model()
+
+FAKE_PATH = 'reports/test/reporte.xlsx'
+
+# ── fixtures ──────────────────────────────────────────────────────────────────
+
+def _licencia(nombre='Plan Test'):
+    return Licencia.objects.create(nombre=nombre, almacenamiento=10)
+
+
+def _org(nombre='Org Test'):
+    lic = _licencia(f'Lic {nombre}')
+    return Organizacion.objects.create(nombre=nombre, is_active=True, is_verified=True, licencia=lic)
+
+
+def _user(org, username='tuser', rfcs=None):
+    u = User.objects.create_user(username=username, password='pass', organizacion=org)
+    if rfcs:
+        u.rfc.set(rfcs)
+    return u
+
+
+def _imp(org, rfc='RFC000000001', nombre='Importador Test'):
+    return Importador.objects.create(rfc=rfc, nombre=nombre, organizacion=org)
+
+
+def _ped(org, imp=None, num='0000001'):
+    return Pedimento.objects.create(
+        pedimento=num,
+        pedimento_app=f'25-160-3910-{num}',
+        organizacion=org,
+        contribuyente=imp,
+        aduana='160',
+        patente='3910',
+        regimen='ITE',
+        clave_pedimento='A1',
+    )
+
+
+def _reporte(user, org_id, extra=None):
+    filtros = {'organizacion_id': str(org_id)}
+    if extra:
+        filtros.update(extra)
+    return ReportDocument.objects.create(
+        user=user, filters=filtros, status='pending', report_type='cumplimiento'
+    )
+
+
+def _excel_desde_mock(mock_save):
+    """Parsea el workbook que recibió storage_service.save_report."""
+    uf = mock_save.call_args[1]['file']
+    return openpyxl.load_workbook(io.BytesIO(uf.read()))
+
+
+def _docs_col(ws):
+    """Devuelve {documento: estatus} leyendo columnas 9 y 10 del worksheet."""
+    return {
+        ws.cell(row=r, column=9).value: ws.cell(row=r, column=10).value
+        for r in range(1, ws.max_row + 1)
+        if ws.cell(row=r, column=9).value
+    }
+
+
+def _col1_values(ws):
+    """Devuelve todos los valores no vacíos de la columna 1."""
+    return [
+        str(ws.cell(row=r, column=1).value)
+        for r in range(1, ws.max_row + 1)
+        if ws.cell(row=r, column=1).value
+    ]
+
+
+# ── 1. Helpers ────────────────────────────────────────────────────────────────
+
+class TestEstadoHelper(TestCase):
+    def test_true_retorna_recuperado(self):
+        self.assertEqual(_estado(True), 'RECUPERADO')
+
+    def test_false_retorna_pendiente(self):
+        self.assertEqual(_estado(False), 'PENDIENTE')
+
+
+# ── 2. Filtro de RFC por usuario ──────────────────────────────────────────────
+
+class TestApplyUserRfcFilter(TestCase):
+    @classmethod
+    def setUpTestData(cls):
+        cls.org = _org()
+        cls.imp1 = _imp(cls.org, rfc='RFC000000001')
+        cls.imp2 = _imp(cls.org, rfc='RFC000000002')
+
+    def test_sin_rfcs_asignados_sin_filtro_retorna_q_vacio(self):
+        user = _user(self.org, username='u_admin')
+        q = _apply_user_rfc_filter(Q(), user, None)
+        self.assertEqual(str(q), str(Q()))
+
+    def test_sin_rfcs_asignados_con_filtro_explicito_aplica_filtro(self):
+        user = _user(self.org, username='u_admin2')
+        q = _apply_user_rfc_filter(Q(), user, 'RFC000000001')
+        self.assertIn('RFC000000001', str(q))
+
+    def test_con_rfcs_sin_filtro_restringe_a_sus_importadores(self):
+        user = _user(self.org, username='u_imp1', rfcs=[self.imp1])
+        q = _apply_user_rfc_filter(Q(), user, None)
+        self.assertIn('contribuyente', str(q))
+
+    def test_con_rfcs_pide_el_suyo_se_filtra_por_ese_rfc(self):
+        user = _user(self.org, username='u_imp2', rfcs=[self.imp1])
+        q = _apply_user_rfc_filter(Q(), user, 'RFC000000001')
+        self.assertIn('RFC000000001', str(q))
+
+    def test_con_rfcs_pide_ajeno_se_usa_el_suyo_no_el_solicitado(self):
+        user = _user(self.org, username='u_imp3', rfcs=[self.imp1])
+        q = _apply_user_rfc_filter(Q(), user, 'RFC000000002')
+        self.assertNotIn('RFC000000002', str(q))
+        self.assertIn('contribuyente', str(q))
+
+
+# ── 3. Tarea completa ─────────────────────────────────────────────────────────
+# Todos los tests en esta clase mockean Redis (publish_task_event) y MinIO
+# (storage_service.save_report) para no depender de infraestructura externa.
+
+@patch('api.reports.tasks.report_document.publish_task_event')
+@patch('api.reports.tasks.report_document.storage_service.save_report',
+       return_value=FAKE_PATH)
+class TestGenerateReportDocument(TestCase):
+    @classmethod
+    def setUpTestData(cls):
+        cls.org = _org('Org Reporte')
+        cls.imp = _imp(cls.org, rfc='MTK8610143000', nombre='Servicios TETAKAWI')
+        cls.user = _user(cls.org, username='rep_user')
+
+    def _run(self, report):
+        generate_report_document.apply(args=[str(report.id)])
+        report.refresh_from_db()
+
+    # ── 3.1 Sin pedimentos ────────────────────────────────────────────────────
+
+    def test_sin_pedimentos_genera_excel_vacio_y_status_ready(self, mock_save, mock_pub):
+        report = _reporte(self.user, self.org.id)
+        self._run(report)
+
+        self.assertEqual(report.status, 'ready')
+        self.assertEqual(report.file, FAKE_PATH)
+        mock_save.assert_called_once()
+
+        # El workbook no debe tener datos de RFCs
+        wb = _excel_desde_mock(mock_save)
+        ws = wb.active
+        col1 = _col1_values(ws)
+        self.assertFalse(col1, 'Excel vacío no debe tener contenido en col 1')
+
+    # ── 3.2 RFC aparece en encabezado ─────────────────────────────────────────
+
+    def test_rfc_del_importador_aparece_en_excel(self, mock_save, mock_pub):
+        _ped(self.org, self.imp, '1000001')
+        report = _reporte(self.user, self.org.id)
+        self._run(report)
+
+        self.assertEqual(report.status, 'ready')
+        wb = _excel_desde_mock(mock_save)
+        ws = wb.active
+        col1 = ' '.join(_col1_values(ws))
+        self.assertIn('MTK8610143000', col1)
+
+    # ── 3.3 PEDIMENTO COMPLETO ────────────────────────────────────────────────
+
+    def test_pedimento_completo_recuperado_cuando_existe_expediente(self, mock_save, mock_pub):
+        ped = _ped(self.org, self.imp, '1000002')
+        ped.existe_expediente = True
+        ped.save(update_fields=['existe_expediente'])
+
+        report = _reporte(self.user, self.org.id)
+        self._run(report)
+
+        docs = _docs_col(_excel_desde_mock(mock_save).active)
+        self.assertEqual(docs.get('PEDIMENTO COMPLETO'), 'RECUPERADO')
+
+    def test_pedimento_completo_pendiente_cuando_no_tiene_expediente(self, mock_save, mock_pub):
+        _ped(self.org, self.imp, '1000003')  # existe_expediente=False por default
+
+        report = _reporte(self.user, self.org.id)
+        self._run(report)
+
+        docs = _docs_col(_excel_desde_mock(mock_save).active)
+        self.assertEqual(docs.get('PEDIMENTO COMPLETO'), 'PENDIENTE')
+
+    # ── 3.4 Partidas ──────────────────────────────────────────────────────────
+
+    def test_partidas_con_estado_correcto(self, mock_save, mock_pub):
+        ped = _ped(self.org, self.imp, '1000004')
+        Partida.objects.create(
+            pedimento=ped, organizacion=self.org, numero_partida=1, descargado=True
+        )
+        Partida.objects.create(
+            pedimento=ped, organizacion=self.org, numero_partida=2, descargado=False
+        )
+
+        report = _reporte(self.user, self.org.id)
+        self._run(report)
+
+        docs = _docs_col(_excel_desde_mock(mock_save).active)
+        self.assertEqual(docs.get('PARTIDA1'), 'RECUPERADO')
+        self.assertEqual(docs.get('PARTIDA2'), 'PENDIENTE')
+
+    # ── 3.5 COVEs y acuses ────────────────────────────────────────────────────
+
+    def test_cove_y_acuse_con_estados_distintos(self, mock_save, mock_pub):
+        ped = _ped(self.org, self.imp, '1000005')
+        Cove.objects.create(
+            pedimento=ped, organizacion=self.org,
+            numero_cove='654001',
+            cove_descargado=True,
+            acuse_cove_descargado=False,
+        )
+
+        report = _reporte(self.user, self.org.id)
+        self._run(report)
+
+        docs = _docs_col(_excel_desde_mock(mock_save).active)
+        self.assertEqual(docs.get('COVE654001'), 'RECUPERADO')
+        self.assertEqual(docs.get('ACUSE COVE654001'), 'PENDIENTE')
+
+    # ── 3.6 EDocumentos y acuses ──────────────────────────────────────────────
+
+    def test_edocumento_y_acuse_con_estados_distintos(self, mock_save, mock_pub):
+        ped = _ped(self.org, self.imp, '1000006')
+        EDocument.objects.create(
+            pedimento=ped, organizacion=self.org,
+            numero_edocument='EDOC001',
+            edocument_descargado=False,
+            acuse_descargado=True,
+        )
+
+        report = _reporte(self.user, self.org.id)
+        self._run(report)
+
+        docs = _docs_col(_excel_desde_mock(mock_save).active)
+        self.assertEqual(docs.get('EDOCUMENTOEDOC001'), 'PENDIENTE')
+        self.assertEqual(docs.get('ACUSE EDOCUMENTOEDOC001'), 'RECUPERADO')
+
+    # ── 3.7 Remesa ────────────────────────────────────────────────────────────
+
+    def test_remesa_recuperada_cuando_document_tipo_15_existe(self, mock_save, mock_pub):
+        """Pedimento.remesas=True y el query de Document devuelve el pedimento_id."""
+        ped = Pedimento.objects.create(
+            pedimento='1000007', pedimento_app='25-160-3910-1000007',
+            organizacion=self.org, contribuyente=self.imp,
+            aduana='160', patente='3910', remesas=True,
+        )
+
+        report = _reporte(self.user, self.org.id)
+        # Patch solo el query de Document dentro del task
+        with patch('api.reports.tasks.report_document.Document') as MockDoc:
+            mock_qs = MagicMock()
+            mock_qs.values_list.return_value = [ped.id]
+            MockDoc.objects.filter.return_value = mock_qs
+            self._run(report)
+
+        docs = _docs_col(_excel_desde_mock(mock_save).active)
+        self.assertEqual(docs.get('REMESA'), 'RECUPERADO')
+
+    def test_remesa_pendiente_cuando_no_hay_document(self, mock_save, mock_pub):
+        """Pedimento.remesas=True pero el query de Document devuelve lista vacía."""
+        Pedimento.objects.create(
+            pedimento='1000008', pedimento_app='25-160-3910-1000008',
+            organizacion=self.org, contribuyente=self.imp,
+            aduana='160', patente='3910', remesas=True,
+        )
+
+        report = _reporte(self.user, self.org.id)
+        with patch('api.reports.tasks.report_document.Document') as MockDoc:
+            mock_qs = MagicMock()
+            mock_qs.values_list.return_value = []
+            MockDoc.objects.filter.return_value = mock_qs
+            self._run(report)
+
+        docs = _docs_col(_excel_desde_mock(mock_save).active)
+        self.assertEqual(docs.get('REMESA'), 'PENDIENTE')
+
+    def test_sin_remesa_no_aparece_fila_remesa(self, mock_save, mock_pub):
+        """Pedimento.remesas=False → no debe aparecer fila REMESA."""
+        _ped(self.org, self.imp, '1000009')  # remesas=False por default
+
+        report = _reporte(self.user, self.org.id)
+        self._run(report)
+
+        docs = _docs_col(_excel_desde_mock(mock_save).active)
+        self.assertNotIn('REMESA', docs)
+
+    # ── 3.8 Múltiples RFCs ───────────────────────────────────────────────────
+
+    def test_multiples_rfcs_generan_secciones_separadas(self, mock_save, mock_pub):
+        imp2 = _imp(self.org, rfc='TEC140624802', nombre='TEC Importaciones')
+        _ped(self.org, self.imp, '1000010')
+        _ped(self.org, imp2,     '1000011')
+
+        report = _reporte(self.user, self.org.id)
+        self._run(report)
+
+        self.assertEqual(report.status, 'ready')
+        contenido = ' '.join(_col1_values(_excel_desde_mock(mock_save).active))
+        self.assertIn('MTK8610143000', contenido)
+        self.assertIn('TEC140624802', contenido)
+
+    # ── 3.9 Restricción por RFC de usuario ───────────────────────────────────
+
+    def test_importador_solo_ve_sus_pedimentos(self, mock_save, mock_pub):
+        imp2 = _imp(self.org, rfc='XYZ999999999', nombre='Externo')
+        _ped(self.org, self.imp, '1000012')
+        _ped(self.org, imp2,     '1000013')
+
+        user_restr = _user(self.org, username='u_restr', rfcs=[self.imp])
+        report = _reporte(user_restr, self.org.id)
+        self._run(report)
+
+        self.assertEqual(report.status, 'ready')
+        contenido = ' '.join(_col1_values(_excel_desde_mock(mock_save).active))
+        self.assertIn('MTK8610143000', contenido)
+        self.assertNotIn('XYZ999999999', contenido)
+
+    # ── 3.10 Formato del archivo ──────────────────────────────────────────────
+
+    def test_archivo_descargado_es_xlsx_valido(self, mock_save, mock_pub):
+        _ped(self.org, self.imp, '1000014')
+        report = _reporte(self.user, self.org.id)
+        self._run(report)
+
+        uf = mock_save.call_args[1]['file']
+        self.assertTrue(uf.name.endswith('.xlsx'), f'Esperado .xlsx, recibido: {uf.name}')
+        try:
+            wb = openpyxl.load_workbook(io.BytesIO(uf.read()))
+            self.assertIsNotNone(wb)
+        except Exception as exc:
+            self.fail(f'Excel no es válido: {exc}')
+
+    def test_cabeceras_de_columna_presentes(self, mock_save, mock_pub):
+        _ped(self.org, self.imp, '1000015')
+        report = _reporte(self.user, self.org.id)
+        self._run(report)
+
+        ws = _excel_desde_mock(mock_save).active
+        cabeceras = None
+        for r in range(1, ws.max_row + 1):
+            if ws.cell(row=r, column=1).value == 'Año':
+                cabeceras = [ws.cell(row=r, column=c).value for c in range(1, 11)]
+                break
+
+        self.assertIsNotNone(cabeceras, 'No se encontró la fila de cabeceras')
+        for col in ('Año', 'Aduana', 'Patente', 'Pedimento', 'Documento', 'Estatus'):
+            self.assertIn(col, cabeceras, f'Cabecera "{col}" no encontrada')
+
+    # ── 3.11 Progreso en Redis ────────────────────────────────────────────────
+
+    def test_se_publican_eventos_de_progreso(self, mock_save, mock_pub):
+        _ped(self.org, self.imp, '1000016')
+        report = _reporte(self.user, self.org.id)
+        self._run(report)
+
+        self.assertGreaterEqual(mock_pub.call_count, 4, 'Se esperan mínimo 4 eventos')
+
+    def test_ultimo_evento_es_completed_con_100(self, mock_save, mock_pub):
+        _ped(self.org, self.imp, '1000017')
+        report = _reporte(self.user, self.org.id)
+        self._run(report)
+
+        ultimo = mock_pub.call_args_list[-1]
+        self.assertEqual(ultimo[0][1], 'completed')
+        self.assertEqual(ultimo[1].get('progress'), 100)
+
+    # ── 3.12 Manejo de errores ────────────────────────────────────────────────
+
+    def test_storage_none_deja_status_error(self, mock_save, mock_pub):
+        """storage_service.save_report retorna None → report queda en error."""
+        mock_save.return_value = None
+        _ped(self.org, self.imp, '1000018')
+        report = _reporte(self.user, self.org.id)
+        self._run(report)
+
+        self.assertEqual(report.status, 'error')
+        self.assertIn('almacenamiento', report.error_message)
+
+    def test_storage_none_publica_evento_failed(self, mock_save, mock_pub):
+        mock_save.return_value = None
+        _ped(self.org, self.imp, '1000019')
+        report = _reporte(self.user, self.org.id)
+        self._run(report)
+
+        statuses = [c[0][1] for c in mock_pub.call_args_list]
+        self.assertIn('failed', statuses)
+        self.assertNotIn('completed', statuses)
+
+    def test_excepcion_guarda_traceback_en_error_message(self, mock_save, mock_pub):
+        """Una excepción inesperada debe incluir traceback en error_message."""
+        mock_save.side_effect = RuntimeError('Fallo simulado de MinIO')
+        _ped(self.org, self.imp, '1000020')
+        report = _reporte(self.user, self.org.id)
+
+        try:
+            generate_report_document.apply(args=[str(report.id)])
+        except RuntimeError:
+            pass  # apply() re-raise la excepción
+
+        report.refresh_from_db()
+        self.assertEqual(report.status, 'error')
+        self.assertIn('Fallo simulado de MinIO', report.error_message)
+        self.assertIn('Traceback', report.error_message)
+
+    def test_excepcion_publica_evento_failed(self, mock_save, mock_pub):
+        mock_save.side_effect = RuntimeError('Error MinIO')
+        _ped(self.org, self.imp, '1000021')
+        report = _reporte(self.user, self.org.id)
+
+        try:
+            generate_report_document.apply(args=[str(report.id)])
+        except RuntimeError:
+            pass
+
+        statuses = [c[0][1] for c in mock_pub.call_args_list]
+        self.assertIn('failed', statuses)

api/reports/tests_datastage.py

@@ -0,0 +1,348 @@
+"""
+Tests para el reporte DataStage asíncrono (Celery + SSE).
+
+Ejecución:
+    python manage.py test api.reports.tests_datastage
+"""
+import csv
+import io
+from unittest.mock import MagicMock, patch
+
+import openpyxl
+from django.apps import apps
+from django.contrib.auth import get_user_model
+from django.db import connection
+from django.test import TestCase
+from rest_framework.test import APIClient
+
+from api.licence.models import Licencia
+from api.organization.models import Organizacion
+from api.reports.models import ReportDocument
+from api.reports.tasks.report_datastage import generate_report_datastage
+
+User = get_user_model()
+
+FAKE_PATH = 'org_x/reports/datastage_test.xlsx'
+
+
+# ── fixtures ──────────────────────────────────────────────────────────────────
+
+def _ensure_registro_created_at():
+    """Las migraciones 0013/0014 de datastage agregan created_at solo en estado
+    (SeparateDatabaseAndState) porque la columna ya existía en la BD real; en la
+    BD de test hay que crearla explícitamente para poder insertar registros."""
+    with connection.cursor() as cur:
+        cur.execute('ALTER TABLE registro501 ADD COLUMN IF NOT EXISTS created_at timestamptz')
+        cur.execute('ALTER TABLE registro502 ADD COLUMN IF NOT EXISTS created_at timestamptz')
+
+
+def _org(nombre='Org DataStage'):
+    lic = Licencia.objects.create(nombre=f'Lic {nombre}', almacenamiento=10)
+    return Organizacion.objects.create(nombre=nombre, is_active=True, is_verified=True, licencia=lic)
+
+
+def _user(org, username='ds_user', superuser=False):
+    if superuser:
+        u = User.objects.create_superuser(username=username, password='pass', email=f'{username}@test.mx')
+        # Superuser JWT requiere active_organization (OrgScopedPermission)
+        u.active_organization = org
+        u.save(update_fields=['active_organization'])
+        return u
+    return User.objects.create_user(username=username, password='pass', organizacion=org)
+
+
+def _registro501(org, pedimento='1000001', rfc='XAXX010101000', patente='3910'):
+    Registro501 = apps.get_model('datastage', 'Registro501')
+    return Registro501.objects.create(
+        organizacion=org, patente=patente, pedimento=pedimento,
+        seccion_aduanera='160', rfc=rfc,
+    )
+
+
+def _registro502(org, pedimento='1000001', patente='3910', transportista='Transportes Test'):
+    Registro502 = apps.get_model('datastage', 'Registro502')
+    return Registro502.objects.create(
+        organizacion=org, patente=patente, pedimento=pedimento,
+        seccion_aduanera='160', nombre_transportista=transportista,
+    )
+
+
+def _reporte(user, payload):
+    return ReportDocument.objects.create(
+        user=user, filters=payload, status='pending', report_type='datastage'
+    )
+
+
+def _payload_simple(org, fmt='excel', model='Registro501', fields=None):
+    return {
+        'modo': 'simple',
+        'format': fmt,
+        'globalFilters': {'organizacion': str(org.id)},
+        'organizacion_id': str(org.id),
+        'model': model,
+        'fields': fields or ['patente', 'pedimento', 'rfc'],
+    }
+
+
+def _payload_multiple(org, fmt='excel'):
+    return {
+        'modo': 'multiple',
+        'format': fmt,
+        'globalFilters': {'organizacion': str(org.id)},
+        'organizacion_id': str(org.id),
+        'models': [
+            {'model': 'Registro501', 'name': 'Datos generales', 'fields': ['rfc', 'patente', 'pedimento']},
+            {'model': 'Registro502', 'name': 'Transporte', 'fields': ['nombre_transportista']},
+        ],
+    }
+
+
+def _archivo_desde_mock(mock_save):
+    """Devuelve (nombre, bytes) del archivo que recibió storage_service.save_report."""
+    uf = mock_save.call_args[1]['file']
+    return uf.name, uf.read()
+
+
+# ── 1. Task Celery ────────────────────────────────────────────────────────────
+# Se mockean Redis (publish_task_event) y MinIO (storage_service.save_report).
+
+@patch('api.reports.tasks.report_datastage.publish_task_event')
+@patch('api.reports.tasks.report_datastage.storage_service.save_report',
+       return_value=FAKE_PATH)
+class TestGenerateReportDatastage(TestCase):
+    @classmethod
+    def setUpTestData(cls):
+        _ensure_registro_created_at()
+        cls.org = _org()
+        cls.user = _user(cls.org)
+
+    def _run(self, report):
+        generate_report_datastage.apply(args=[str(report.id)])
+        report.refresh_from_db()
+
+    # ── 1.1 Simple / Excel ────────────────────────────────────────────────────
+
+    def test_simple_excel_status_ready_y_archivo_xlsx(self, mock_save, mock_pub):
+        _registro501(self.org)
+        report = _reporte(self.user, _payload_simple(self.org, fmt='excel'))
+        self._run(report)
+
+        self.assertEqual(report.status, 'ready')
+        self.assertEqual(report.file, FAKE_PATH)
+        self.assertIsNotNone(report.finished_at)
+
+        nombre, contenido = _archivo_desde_mock(mock_save)
+        self.assertTrue(nombre.endswith('.xlsx'), f'Esperado .xlsx, recibido: {nombre}')
+        wb = openpyxl.load_workbook(io.BytesIO(contenido))
+        valores = [str(c.value) for row in wb.active.iter_rows() for c in row if c.value]
+        self.assertIn('XAXX010101000', valores)
+
+    # ── 1.2 Simple / CSV ──────────────────────────────────────────────────────
+
+    def test_simple_csv_status_ready_y_archivo_csv(self, mock_save, mock_pub):
+        _registro501(self.org)
+        report = _reporte(self.user, _payload_simple(self.org, fmt='csv'))
+        self._run(report)
+
+        self.assertEqual(report.status, 'ready')
+        nombre, contenido = _archivo_desde_mock(mock_save)
+        self.assertTrue(nombre.endswith('.csv'), f'Esperado .csv, recibido: {nombre}')
+
+        rows = list(csv.reader(io.StringIO(contenido.decode('utf-8'))))
+        self.assertEqual(rows[0], ['patente', 'pedimento', 'rfc'])
+        self.assertIn('XAXX010101000', rows[1])
+
+    # ── 1.3 Aislamiento por organización ──────────────────────────────────────
+
+    def test_simple_no_incluye_datos_de_otra_organizacion(self, mock_save, mock_pub):
+        _registro501(self.org, rfc='XAXX010101000')
+        otra_org = _org('Otra Org')
+        _registro501(otra_org, pedimento='9999999', rfc='XEXX010101000')
+
+        report = _reporte(self.user, _payload_simple(self.org, fmt='csv'))
+        self._run(report)
+
+        _, contenido = _archivo_desde_mock(mock_save)
+        texto = contenido.decode('utf-8')
+        self.assertIn('XAXX010101000', texto)
+        self.assertNotIn('XEXX010101000', texto)
+
+    # ── 1.4 Múltiple / Excel ──────────────────────────────────────────────────
+
+    def test_multiple_excel_combina_modelos_por_llave(self, mock_save, mock_pub):
+        _registro501(self.org)
+        _registro502(self.org)
+        report = _reporte(self.user, _payload_multiple(self.org, fmt='excel'))
+        self._run(report)
+
+        self.assertEqual(report.status, 'ready')
+        nombre, contenido = _archivo_desde_mock(mock_save)
+        self.assertTrue(nombre.endswith('datastage_reporte.xlsx'), f'Nombre inesperado: {nombre}')
+
+        wb = openpyxl.load_workbook(io.BytesIO(contenido))
+        valores = [str(c.value) for row in wb.active.iter_rows() for c in row if c.value]
+        # Campos de ambos modelos en la misma hoja (prefijados por modelo)
+        self.assertIn('Registro501_rfc', valores)
+        self.assertIn('Registro502_nombre_transportista', valores)
+        self.assertIn('XAXX010101000', valores)
+        self.assertIn('Transportes Test', valores)
+
+    # ── 1.5 Múltiple / CSV ────────────────────────────────────────────────────
+
+    def test_multiple_csv_combina_modelos(self, mock_save, mock_pub):
+        _registro501(self.org)
+        _registro502(self.org)
+        report = _reporte(self.user, _payload_multiple(self.org, fmt='csv'))
+        self._run(report)
+
+        self.assertEqual(report.status, 'ready')
+        nombre, contenido = _archivo_desde_mock(mock_save)
+        self.assertTrue(nombre.endswith('datastage_reporte.csv'), f'Nombre inesperado: {nombre}')
+        texto = contenido.decode('utf-8')
+        self.assertIn('Registro501_rfc', texto)
+        self.assertIn('Transportes Test', texto)
+
+    # ── 1.6 Sin datos ─────────────────────────────────────────────────────────
+
+    def test_multiple_sin_datos_genera_archivo_sin_datos_y_ready(self, mock_save, mock_pub):
+        report = _reporte(self.user, _payload_multiple(self.org, fmt='excel'))
+        self._run(report)
+
+        self.assertEqual(report.status, 'ready')
+        nombre, _ = _archivo_desde_mock(mock_save)
+        self.assertIn('sin_datos', nombre)
+
+    # ── 1.7 Payload inválido ──────────────────────────────────────────────────
+
+    def test_modelo_inexistente_marca_error_y_publica_failed(self, mock_save, mock_pub):
+        report = _reporte(self.user, _payload_simple(self.org, model='NoExiste'))
+        self._run(report)
+
+        self.assertEqual(report.status, 'error')
+        self.assertIn('NoExiste', report.error_message)
+        statuses = [c[0][1] for c in mock_pub.call_args_list]
+        self.assertIn('failed', statuses)
+        self.assertNotIn('completed', statuses)
+
+    def test_payload_sin_model_marca_error(self, mock_save, mock_pub):
+        payload = _payload_simple(self.org)
+        del payload['model']
+        report = _reporte(self.user, payload)
+        self._run(report)
+
+        self.assertEqual(report.status, 'error')
+        mock_save.assert_not_called()
+
+    # ── 1.8 Eventos de progreso ───────────────────────────────────────────────
+
+    def test_ultimo_evento_es_completed_con_100_y_resultado(self, mock_save, mock_pub):
+        _registro501(self.org)
+        report = _reporte(self.user, _payload_simple(self.org))
+        self._run(report)
+
+        ultimo = mock_pub.call_args_list[-1]
+        self.assertEqual(ultimo[0][1], 'completed')
+        self.assertEqual(ultimo[1].get('progress'), 100)
+        resultado = ultimo[1].get('resultado')
+        self.assertEqual(resultado['report_id'], str(report.id))
+        self.assertEqual(resultado['total_registros'], 1)
+
+    def test_se_publican_eventos_de_progreso(self, mock_save, mock_pub):
+        _registro501(self.org)
+        report = _reporte(self.user, _payload_simple(self.org))
+        self._run(report)
+
+        self.assertGreaterEqual(mock_pub.call_count, 4, 'Se esperan mínimo 4 eventos')
+
+    # ── 1.9 Storage falla ─────────────────────────────────────────────────────
+
+    def test_storage_none_deja_status_error_y_failed(self, mock_save, mock_pub):
+        mock_save.return_value = None
+        _registro501(self.org)
+        report = _reporte(self.user, _payload_simple(self.org))
+        self._run(report)
+
+        self.assertEqual(report.status, 'error')
+        self.assertIn('almacenamiento', report.error_message)
+        statuses = [c[0][1] for c in mock_pub.call_args_list]
+        self.assertIn('failed', statuses)
+
+
+# ── 2. Vista (encolado 202) ───────────────────────────────────────────────────
+
+class TestExportDataStageView202(TestCase):
+    @classmethod
+    def setUpTestData(cls):
+        cls.org = _org('Org Vista')
+        cls.user = _user(cls.org, username='vista_admin', superuser=True)
+
+    def setUp(self):
+        self.client = APIClient()
+        self.client.force_authenticate(user=self.user)
+
+    def _post(self, body):
+        with patch('api.reports.views.generate_report_datastage.delay',
+                   return_value=MagicMock(id='fake-task-id')) as mock_delay:
+            res = self.client.post('/api/v1/reports/exportmodel/datastage/', body, format='json')
+        return res, mock_delay
+
+    def test_post_simple_responde_202_con_task_y_report(self):
+        body = {
+            'modo': 'simple', 'format': 'excel',
+            'globalFilters': {'organizacion': str(self.org.id)},
+            'model': 'Registro501', 'fields': ['patente', 'pedimento'],
+        }
+        res, mock_delay = self._post(body)
+
+        self.assertEqual(res.status_code, 202)
+        self.assertEqual(res.data['task_id'], 'fake-task-id')
+        self.assertEqual(res.data['status'], 'pending')
+
+        report = ReportDocument.objects.get(id=res.data['report_id'])
+        self.assertEqual(report.report_type, 'datastage')
+        self.assertEqual(report.user_id, self.user.id)
+        self.assertEqual(report.filters['organizacion_id'], str(self.org.id))
+        mock_delay.assert_called_once_with(report.id)
+
+    def test_post_multiple_persiste_models_en_filters(self):
+        body = {
+            'modo': 'multiple', 'format': 'csv',
+            'globalFilters': {'organizacion': str(self.org.id)},
+            'models': [{'model': 'Registro501', 'fields': ['rfc']}],
+        }
+        res, _ = self._post(body)
+
+        self.assertEqual(res.status_code, 202)
+        report = ReportDocument.objects.get(id=res.data['report_id'])
+        self.assertEqual(report.filters['modo'], 'multiple')
+        self.assertEqual(report.filters['models'][0]['model'], 'Registro501')
+
+    def test_post_simple_sin_fields_responde_400(self):
+        body = {
+            'modo': 'simple', 'format': 'excel',
+            'globalFilters': {'organizacion': str(self.org.id)},
+            'model': 'Registro501',
+        }
+        res, mock_delay = self._post(body)
+        self.assertEqual(res.status_code, 400)
+        mock_delay.assert_not_called()
+        self.assertFalse(ReportDocument.objects.filter(report_type='datastage').exists())
+
+    def test_post_multiple_sin_models_responde_400(self):
+        body = {
+            'modo': 'multiple', 'format': 'excel',
+            'globalFilters': {'organizacion': str(self.org.id)},
+        }
+        res, mock_delay = self._post(body)
+        self.assertEqual(res.status_code, 400)
+        mock_delay.assert_not_called()
+
+    def test_post_modelo_inexistente_responde_404(self):
+        body = {
+            'modo': 'simple', 'format': 'excel',
+            'globalFilters': {'organizacion': str(self.org.id)},
+            'model': 'NoExiste', 'fields': ['x'],
+        }
+        res, mock_delay = self._post(body)
+        self.assertEqual(res.status_code, 404)
+        mock_delay.assert_not_called()

api/reports/views.py

@@ -25,7 +25,10 @@ from core.permissions import (
     require_permission,
     user_has_permission,
 )
+from .models import ReportDocument
 from .serializers import ExportModelSerializer
+from .services import datastage_export
+from .tasks.report_datastage import generate_report_datastage
 
 def export_model_to_csv(request, model_name, fields, module='datastage', filters=None):
     model = apps.get_model(module, model_name)
@@ -90,28 +93,13 @@ class ExportDataStageView(APIView):
             return [IsAuthenticated(), require_permission('reportes.view')()]
         return [IsAuthenticated(), require_permission('reportes.export')()]
 
-    # Constantes para partición
-    # MAX_RECORDS_PER_FILE = 100  # Límite seguro por archivo
-    MAX_RECORDS_PER_FILE = 120000  # Límite seguro por archivo
+    # La lógica de exportación vive en services/datastage_export.py (la usa la
+    # task Celery generate_report_datastage); estos delegados conservan la
+    # interfaz para los métodos legacy de esta clase.
+    MAX_RECORDS_PER_FILE = datastage_export.MAX_RECORDS_PER_FILE
 
     def safe_excel_value(self, value):
-        """
-        Convierte cualquier valor a un formato seguro para Excel
-        """
-        if value is None:
-            return ''
-        elif isinstance(value, (uuid.UUID,)):
-            return str(value)
-        elif hasattr(value, 'uuid'):
-            return str(value.uuid)
-        elif hasattr(value, 'id'):
-            return str(value.id)
-        elif isinstance(value, (datetime.datetime, datetime.date)):
-            return value.isoformat()
-        elif isinstance(value, (dict, list)):
-            return str(value)
-        else:
-            return str(value)
+        return datastage_export.safe_excel_value(value)
 
     def get(self, request, *args, **kwargs):
         """Retorna RFCs distintos de Registro501 para la organización activa del usuario."""
@@ -134,19 +122,67 @@ class ExportDataStageView(APIView):
         except LookupError:
             return Response({'rfcs': []})
 
-    @swagger_auto_schema(request_body=ExportModelSerializer, responses={200: 'Archivo generado (Excel o CSV)'})
+    @swagger_auto_schema(request_body=ExportModelSerializer, responses={202: 'Reporte encolado (Celery)'})
     def post(self, request, *args, **kwargs):
         """
-        Endpoint específico para exportación de DataStage con soporte múltiple
+        Encola la generación asíncrona del reporte DataStage (Celery + SSE).
+        Responde 202 con report_id y task_id; el progreso se sigue por SSE
+        (/stream/tasks/{task_id}) y el archivo se descarga después vía
+        /reports/report-document-download/{report_id}/.
         """
-        # Verificar si es modo múltiple
         modo = request.data.get('modo', 'simple')
-        
+        export_format = request.data.get('format', 'csv')
+        global_filters = request.data.get('globalFilters', {})
+
+        # Validar payload antes de encolar (mismos errores que el flujo síncrono)
         if modo == 'multiple':
-            return self.handle_multiple_export(request)
+            models_data = request.data.get('models', [])
+            if not models_data:
+                return Response({'error': 'models are required for multiple export'}, status=status.HTTP_400_BAD_REQUEST)
         else:
-            return self.handle_simple_export(request)
-    
+            model_name = request.data.get('model')
+            fields = request.data.get('fields')
+            if not model_name or not fields:
+                return Response({'error': 'model and fields are required'}, status=status.HTTP_400_BAD_REQUEST)
+            try:
+                apps.get_model('datastage', model_name)
+            except LookupError:
+                return Response({'error': f'Model {model_name} not found'}, status=status.HTTP_404_NOT_FOUND)
+
+        global_filters, err = self._resolve_org_filter(global_filters, request.user)
+        if err:
+            return err
+
+        # La org ya resuelta viaja en el payload: la task no tiene request.user
+        payload = {
+            'modo': modo,
+            'format': export_format,
+            'globalFilters': global_filters,
+            'organizacion_id': global_filters.get('organizacion'),
+        }
+        if modo == 'multiple':
+            payload['models'] = models_data
+        else:
+            payload['model'] = model_name
+            payload['fields'] = fields
+
+        report = ReportDocument.objects.create(
+            user=request.user,
+            filters=payload,
+            status='pending',
+            report_type='datastage',
+        )
+        task = generate_report_datastage.delay(report.id)
+
+        return Response({
+            'report_id': report.id,
+            'task_id': task.id,
+            'status': report.status,
+            'created_at': report.created_at,
+            'download_url': None,
+        }, status=status.HTTP_202_ACCEPTED)
+
+
     def _resolve_org_filter(self, global_filters, user):
         """
         Devuelve los global_filters asegurando que siempre haya una organización.
@@ -164,63 +200,6 @@ class ExportDataStageView(APIView):
             filters['organizacion'] = str(org.id)
         return filters, None
 
-    def handle_simple_export(self, request):
-        """Maneja exportación simple de DataStage (un solo modelo)"""
-        model_name = request.data.get('model')
-        fields = request.data.get('fields')
-        global_filters = request.data.get('globalFilters', {})
-        export_type = request.data.get('format', 'csv')
-        module = 'datastage'
-
-        if not model_name or not fields:
-            return Response({'error': 'model and fields are required'}, status=status.HTTP_400_BAD_REQUEST)
-
-        global_filters, err = self._resolve_org_filter(global_filters, request.user)
-        if err:
-            return err
-
-        try:
-            model = apps.get_model(module, model_name)
-            filters = self.apply_global_filters_to_model(global_filters, model, request.user)
-            
-            queryset = model.objects.filter(**filters).values(*fields)
-            total_records = queryset.count()
-            
-            if export_type == 'excel':
-                # Verificar si necesita partición
-                if total_records > self.MAX_RECORDS_PER_FILE:
-                    return self.export_single_model_partitioned(request, model_name, fields, filters, total_records)
-                else:
-                    return export_model_to_excel(request, model_name, fields, module, filters)
-            else:
-                if total_records > self.MAX_RECORDS_PER_FILE:
-                    return self.export_single_model_csv_partitioned(request, model_name, fields, filters, total_records)
-                else:
-                    return export_model_to_csv(request, model_name, fields, module, filters)
-                
-        except LookupError:
-            return Response({'error': f'Model {model_name} not found'}, status=status.HTTP_404_NOT_FOUND)
-
-    def handle_multiple_export(self, request):
-        """Maneja exportación múltiple de DataStage (varios modelos)"""
-        models_data = request.data.get('models', [])
-        export_type = request.data.get('format', 'csv')
-        global_filters = request.data.get('globalFilters', {})
-
-        if not models_data:
-            return Response({'error': 'models are required for multiple export'}, status=status.HTTP_400_BAD_REQUEST)
-
-        global_filters, err = self._resolve_org_filter(global_filters, request.user)
-        if err:
-            return err
-
-        related_keys = self.get_related_keys_from_filters(global_filters, models_data, request.user)
-        
-        if export_type == 'excel':
-            return self.export_datastage_multiple_partitioned_excel_agrupados(request, models_data, global_filters, related_keys)
-        else:
-            return self.export_datastage_multiple_to_csv_combined(request, models_data, global_filters, related_keys)
-
     def estimate_total_records(self, models_data, global_filters, related_keys, user):
         """Estima el total de registros para todos los modelos"""
         total = 0
@@ -297,235 +276,6 @@ 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:
-            from api.organization.models import Organizacion
-            org_mapping = {str(org.id): org.nombre for org in Organizacion.objects.all()}
-
-            # 1. Recopilar todos los datos FUERA del contexto ZIP
-            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
-
-                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
-
-                required_fields = ['seccion_aduanera', 'patente', 'pedimento']
-                for field in required_fields:
-                    if field not in fields:
-                        fields.append(field)
-
-                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()
-
-                    if queryset.count() == 0:
-                        continue
-
-                    relation_fields = [fn for fn in ['seccion_aduanera', 'patente', 'pedimento'] if fn in fields]
-                    if not relation_fields:
-                        relation_fields = ['datastage_id'] if 'datastage_id' in fields else [fields[0]]
-
-                    if model_name not in model_field_mappings:
-                        model_field_mappings[model_name] = fields
-
-                    for record in queryset:
-                        key_parts = [str(record[rf]) for rf in relation_fields if rf in record and record[rf] is not None]
-                        if not key_parts:
-                            import hashlib
-                            key = hashlib.md5(str(sorted(record.items())).encode()).hexdigest()[:10]
-                        else:
-                            key = "_".join(key_parts)
-
-                        processed_record = {}
-                        for field_name, value in record.items():
-                            if field_name == 'organizacion_id' and value:
-                                org_id_str = str(value)
-                                if org_id_str in org_mapping:
-                                    processed_value = org_mapping[org_id_str]
-                                else:
-                                    try:
-                                        org = Organizacion.objects.filter(id=value).first()
-                                        processed_value = org.nombre if org else org_id_str
-                                        org_mapping[org_id_str] = processed_value
-                                    except Exception:
-                                        processed_value = org_id_str
-                            else:
-                                processed_value = value
-
-                            if field_name in relation_fields:
-                                prefixed_field_name = field_name
-                            else:
-                                prefixed_field_name = f"{model_name}_{field_name}"
-
-                            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)
-
-                        if key not in all_models_data:
-                            all_models_data[key] = {'relation_fields': {}, 'model_records': {}}
-
-                        for rel_field in relation_fields:
-                            if rel_field in record:
-                                all_models_data[key]['relation_fields'][rel_field] = record[rel_field]
-
-                        if model_name not in all_models_data[key]['model_records']:
-                            all_models_data[key]['model_records'][model_name] = []
-
-                        all_models_data[key]['model_records'][model_name].append(processed_record)
-
-                except LookupError:
-                    continue
-
-            # 2. Sin datos → Excel vacío (no JSON 404 que rompe la descarga en el frontend)
-            if not all_models_data:
-                wb = openpyxl.Workbook()
-                ws = wb.active
-                ws.title = "Sin datos"
-                ws.append(["No se encontraron datos para los filtros especificados"])
-                output = io.BytesIO()
-                wb.save(output)
-                output.seek(0)
-                resp = HttpResponse(
-                    output.read(),
-                    content_type='application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'
-                )
-                resp['Content-Disposition'] = 'attachment; filename="datastage_sin_datos.xlsx"'
-                return resp
-
-            # 3. Construir filas combinadas — repetir el último registro en lugar de dejar vacíos
-            combined_rows = []
-            for key, data in all_models_data.items():
-                relation_fields_data = data['relation_fields']
-                model_records = data['model_records']
-
-                max_records_per_key = max((len(recs) for recs in model_records.values()), default=1)
-
-                for i in range(max_records_per_key):
-                    row_data = {}
-
-                    for rel_field, rel_value in relation_fields_data.items():
-                        row_data[rel_field] = self.safe_excel_value(rel_value)
-
-                    for model_name, records in model_records.items():
-                        # Usar posición i o el último registro disponible
-                        record = records[i] if i < len(records) else records[-1]
-                        for field_name, value in record.items():
-                            row_data[field_name] = value
-
-                    combined_rows.append(row_data)
-
-            # 4. Encabezados ordenados
-            all_fields_set = set()
-            for row in combined_rows:
-                all_fields_set.update(row.keys())
-
-            all_fields = []
-            for rel_field in ['seccion_aduanera', 'patente', 'pedimento']:
-                if rel_field in all_fields_set:
-                    all_fields.append(rel_field)
-                    all_fields_set.discard(rel_field)
-
-            org_fields = sorted(f for f in all_fields_set if 'organizacion' in f.lower())
-            for org_field in org_fields:
-                all_fields.append(org_field)
-                all_fields_set.discard(org_field)
-
-            all_fields.extend(sorted(all_fields_set))
-
-            # 5. Filas de título y fecha de generación
-            now_str = datetime.datetime.now().strftime('%d/%m/%Y %H:%M:%S')
-            title_row = ["Reporte Datastage"]
-            date_row = [f"Generado: {now_str}"]
-
-            def _write_sheet(ws, sheet_name, page_rows):
-                ws.title = sheet_name[:31]
-                ws.append(title_row)
-                ws.append(date_row)
-                ws.append([])
-                ws.append(all_fields)
-                for row_data in page_rows:
-                    ws.append([row_data.get(field, '') for field in all_fields])
-                for column in ws.columns:
-                    max_length = 0
-                    col_letter = column[0].column_letter
-                    for cell in column:
-                        try:
-                            if len(str(cell.value)) > max_length:
-                                max_length = len(str(cell.value))
-                        except Exception:
-                            pass
-                    ws.column_dimensions[col_letter].width = min(max_length + 2, 50)
-
-            # 6. Excel directo si cabe en un archivo; ZIP solo si se necesita particionar
-            from django.core.paginator import Paginator
-            paginator = Paginator(combined_rows, self.MAX_RECORDS_PER_FILE)
-
-            if paginator.num_pages == 1:
-                wb = openpyxl.Workbook()
-                _write_sheet(wb.active, "Datastage", paginator.page(1).object_list)
-                output = io.BytesIO()
-                wb.save(output)
-                output.seek(0)
-                resp = HttpResponse(
-                    output.read(),
-                    content_type='application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'
-                )
-                resp['Content-Disposition'] = 'attachment; filename="datastage_reporte.xlsx"'
-                return resp
-
-            zip_buffer = io.BytesIO()
-            with zipfile.ZipFile(zip_buffer, 'w', zipfile.ZIP_DEFLATED) as zip_file:
-                for page_num in paginator.page_range:
-                    page = paginator.page(page_num)
-                    current_wb = openpyxl.Workbook()
-                    _write_sheet(current_wb.active, f"Datastage_p{page_num}", page.object_list)
-                    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())
-
-            zip_buffer.seek(0)
-            resp = HttpResponse(zip_buffer.read(), content_type='application/zip')
-            resp['Content-Disposition'] = 'attachment; filename="datastage_combinado.zip"'
-            return resp
-
-        except Exception as e:
-            import traceback
-            import logging
-            logging.getLogger(__name__).error("Error en exportación combinada: %s", traceback.format_exc())
-            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:
@@ -1215,144 +965,6 @@ class ExportDataStageView(APIView):
         except Exception as e:
             return Response({'error': f'Error en exportación particionada: {str(e)}'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
         
-    def export_datastage_multiple_to_csv_combined(self, request, models_data, global_filters, related_keys):
-        """Exporta múltiples modelos combinados en un único CSV plano (misma lógica de agrupación que el Excel)."""
-        import hashlib
-        import logging
-        import traceback
-        logger = logging.getLogger(__name__)
-        try:
-            from api.organization.models import Organizacion
-            org_mapping = {str(org.id): org.nombre for org in Organizacion.objects.all()}
-
-            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
-
-                normalized_fields = []
-                for f in fields:
-                    key = f.strip() if isinstance(f, str) else 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
-
-                for req_field in ['seccion_aduanera', 'patente', 'pedimento']:
-                    if req_field not in fields:
-                        fields.append(req_field)
-
-                try:
-                    model = apps.get_model('datastage', model_name)
-                    model_field_names = [f.name for f in model._meta.get_fields() if hasattr(f, 'name')]
-                    if 'organizacion_id' not in fields and 'organizacion_id' in model_field_names:
-                        fields.append('organizacion_id')
-
-                    filters = self.apply_related_filters(global_filters, model, related_keys, request.user)
-                    queryset = model.objects.filter(**filters).values(*fields) if filters else model.objects.none()
-                    if queryset.count() == 0:
-                        continue
-
-                    relation_fields = [fn for fn in ['seccion_aduanera', 'patente', 'pedimento'] if fn in fields]
-                    if not relation_fields:
-                        relation_fields = ['datastage_id'] if 'datastage_id' in fields else [fields[0]]
-
-                    if model_name not in model_field_mappings:
-                        model_field_mappings[model_name] = fields
-
-                    for record in queryset:
-                        key_parts = [str(record[rf]) for rf in relation_fields if rf in record and record[rf] is not None]
-                        key = "_".join(key_parts) if key_parts else hashlib.md5(str(sorted(record.items())).encode()).hexdigest()[:10]
-
-                        processed_record = {}
-                        for field_name, value in record.items():
-                            if field_name == 'organizacion_id' and value:
-                                org_id_str = str(value)
-                                processed_value = org_mapping.get(org_id_str, org_id_str)
-                            else:
-                                processed_value = value
-
-                            if field_name in relation_fields:
-                                prefixed = field_name
-                            else:
-                                prefixed = f"{model_name}_{field_name}"
-                            if field_name == 'organizacion_id':
-                                prefixed = prefixed.replace('organizacion_id', 'organizacion_nombre')
-                            processed_record[prefixed] = self.safe_excel_value(processed_value)
-
-                        if key not in all_models_data:
-                            all_models_data[key] = {'relation_fields': {}, 'model_records': {}}
-                        for rel_field in relation_fields:
-                            if rel_field in record:
-                                all_models_data[key]['relation_fields'][rel_field] = record[rel_field]
-                        if model_name not in all_models_data[key]['model_records']:
-                            all_models_data[key]['model_records'][model_name] = []
-                        all_models_data[key]['model_records'][model_name].append(processed_record)
-
-                except LookupError:
-                    continue
-
-            # Sin datos → CSV con mensaje, no error HTTP
-            if not all_models_data:
-                buf = io.StringIO()
-                csv.writer(buf).writerow(['No se encontraron datos para los filtros especificados'])
-                resp = HttpResponse(buf.getvalue(), content_type='text/csv; charset=utf-8')
-                resp['Content-Disposition'] = 'attachment; filename="datastage_sin_datos.csv"'
-                return resp
-
-            # Construir filas planas
-            combined_rows = []
-            for key, data in all_models_data.items():
-                relation_fields_data = data['relation_fields']
-                model_records = data['model_records']
-                max_records = max((len(recs) for recs in model_records.values()), default=1)
-                for i in range(max_records):
-                    row_data = {}
-                    for rel_field, rel_value in relation_fields_data.items():
-                        row_data[rel_field] = self.safe_excel_value(rel_value)
-                    for mn, records in model_records.items():
-                        record = records[i] if i < len(records) else records[-1]
-                        for field_name, value in record.items():
-                            row_data[field_name] = value
-                    combined_rows.append(row_data)
-
-            # Encabezados: campos de relación primero, luego org, luego el resto
-            all_fields_set = set()
-            for row in combined_rows:
-                all_fields_set.update(row.keys())
-
-            all_fields = []
-            for rel_field in ['seccion_aduanera', 'patente', 'pedimento']:
-                if rel_field in all_fields_set:
-                    all_fields.append(rel_field)
-                    all_fields_set.discard(rel_field)
-            org_fields = sorted(f for f in all_fields_set if 'organizacion' in f.lower())
-            for org_field in org_fields:
-                all_fields.append(org_field)
-                all_fields_set.discard(org_field)
-            all_fields.extend(sorted(all_fields_set))
-
-            buf = io.StringIO()
-            writer = csv.writer(buf)
-            writer.writerow(all_fields)
-            for row_data in combined_rows:
-                writer.writerow([row_data.get(field, '') for field in all_fields])
-
-            resp = HttpResponse(buf.getvalue(), content_type='text/csv; charset=utf-8')
-            resp['Content-Disposition'] = 'attachment; filename="datastage_reporte.csv"'
-            return resp
-
-        except Exception as e:
-            logger.error("Error en exportación CSV combinada: %s", traceback.format_exc())
-            return Response({'error': f'Error en exportación CSV combinada: {str(e)}'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
-
     def export_datastage_multiple_to_csv(self, request, models_data, global_filters, related_keys):
         """Exporta múltiples modelos de DataStage a múltiples archivos CSV en ZIP"""
         zip_buffer = io.BytesIO()
@@ -1472,254 +1084,14 @@ class ExportDataStageView(APIView):
         except Exception as e:
             return Response({'error': f'Error en exportación CSV particionada: {str(e)}'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
     
-    def export_single_model_partitioned(self, request, model_name, fields, filters, total_records):
-        """Exporta un solo modelo particionado a ZIP"""
-        try:
-            zip_buffer = io.BytesIO()
-            module = 'datastage'
-            
-            model = apps.get_model(module, model_name)
-            queryset = model.objects.filter(**filters).values(*fields)
-            
-            with zipfile.ZipFile(zip_buffer, 'w', zipfile.ZIP_DEFLATED) as zip_file:
-                from django.core.paginator import Paginator
-                paginator = Paginator(queryset, self.MAX_RECORDS_PER_FILE)
-                
-                for page_num in paginator.page_range:
-                    page = paginator.page(page_num)
-                    
-                    # Crear Excel para esta parte
-                    wb = openpyxl.Workbook()
-                    ws = wb.active
-                    ws.title = f"Parte_{page_num}"[:31]
-                    ws.append(fields)
-                    
-                    for row in page.object_list:
-                        row_values = [self.safe_excel_value(row[field]) for field in fields]
-                        ws.append(row_values)
-                    
-                    part_buffer = io.BytesIO()
-                    wb.save(part_buffer)
-                    part_buffer.seek(0)
-                    
-                    filename = f"{model_name}_part{page_num}.xlsx"
-                    zip_file.writestr(filename, part_buffer.getvalue())
-
-            zip_buffer.seek(0)
-            zip_content = zip_buffer.getvalue()
-            
-            response = HttpResponse(zip_content, content_type='application/zip')
-            response['Content-Disposition'] = f'attachment; filename="{model_name}_particionado.zip"'
-            response['Content-Length'] = len(zip_content)
-            
-            return response
-            
-        except Exception as e:
-            return Response({'error': f'Error exportando modelo: {str(e)}'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
-        
-    def export_single_model_csv_partitioned(self, request, model_name, fields, filters, total_records):
-        """Exporta un solo modelo CSV particionado a ZIP"""
-        try:
-            zip_buffer = io.BytesIO()
-            module = 'datastage'
-            
-            model = apps.get_model(module, model_name)
-            queryset = model.objects.filter(**filters).values(*fields)
-            
-            with zipfile.ZipFile(zip_buffer, 'w', zipfile.ZIP_DEFLATED) as zip_file:
-                from django.core.paginator import Paginator
-                paginator = Paginator(queryset, self.MAX_RECORDS_PER_FILE)
-                
-                for page_num in paginator.page_range:
-                    page = paginator.page(page_num)
-                    
-                    csv_buffer = io.StringIO()
-                    writer = csv.writer(csv_buffer)
-                    writer.writerow(fields)
-                    
-                    for row in page.object_list:
-                        row_values = [self.safe_excel_value(row[field]) for field in fields]
-                        writer.writerow(row_values)
-                    
-                    # Agregar al ZIP
-                    filename = f"{model_name}_part{page_num}.csv"
-                    zip_file.writestr(filename, csv_buffer.getvalue())
-
-            zip_buffer.seek(0)
-            
-            zip_content = zip_buffer.getvalue()
-            
-            response = HttpResponse(zip_content, content_type='application/zip')
-            response['Content-Disposition'] = f'attachment; filename="{model_name}_particionado.zip"'
-            response['Content-Length'] = len(zip_content)
-            
-            return response
-            
-        except Exception as e:
-            return Response({'error': f'Error exportando modelo CSV: {str(e)}'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
-        
     def get_related_keys_from_filters(self, global_filters, models_data, user):
-        """
-        Construye el conjunto de (patente, pedimento, datastage_id) que servirá como
-        llave de cruce entre modelos.
+        return datastage_export.get_related_keys_from_filters(global_filters, models_data)
 
-        Regla clave: si el filtro RFC está activo, solo los modelos que tienen el campo
-        'rfc' pueden contribuir a related_keys. Los modelos sin 'rfc' (ej. 505, 506)
-        no se usan como semilla — solo se filtrarán más tarde usando las claves ya
-        construidas, evitando que contaminen el resultado con pedimentos de otros RFC.
-        """
-        related_keys = {
-            'patentes': set(),
-            'pedimentos': set(),
-            'datastage_ids': set()
-        }
-
-        # Sin filtros significativos → sin cruce
-        if not any(v for v in global_filters.values() if v not in [None, '']):
-            return {}
-
-        rfc_filter_active = bool(global_filters.get('rfc'))
-        date_filter_active = bool(global_filters.get('fecha_pago_desde') or global_filters.get('fecha_pago_hasta'))
-        all_records_with_filters = []
-
-        for model_data in models_data:
-            model_name = model_data.get('model')
-            try:
-                model = apps.get_model('datastage', model_name)
-                model_field_names = {f.name for f in model._meta.get_fields() if hasattr(f, 'name')}
-
-                # Un modelo puede ser semilla de related_keys SOLO si tiene campos
-                # para aplicar TODOS los filtros activos. Un modelo sin 'rfc' no puede
-                # ser semilla cuando hay filtro de RFC (contaminaría con pedimentos de
-                # otros RFCs). Igual para fecha_pago_real cuando hay filtro de fechas.
-                if rfc_filter_active and 'rfc' not in model_field_names:
-                    continue
-                if date_filter_active and 'fecha_pago_real' not in model_field_names:
-                    continue
-
-                filters = self.apply_global_filters_to_model(global_filters, model, user)
-                if not filters:
-                    continue
-
-                records = model.objects.filter(**filters).values('patente', 'pedimento', 'datastage_id')
-                all_records_with_filters.extend(list(records))
-
-            except LookupError:
-                continue
-
-        if not all_records_with_filters:
-            return {'patentes': set(), 'pedimentos': set(), 'datastage_ids': set()}
-
-        for record in all_records_with_filters:
-            if record.get('patente'):
-                related_keys['patentes'].add(record['patente'])
-            if record.get('pedimento'):
-                related_keys['pedimentos'].add(record['pedimento'])
-            if record.get('datastage_id'):
-                related_keys['datastage_ids'].add(record['datastage_id'])
-
-        return {k: list(v) for k, v in related_keys.items() if v}
-    
     def apply_global_filters_to_model(self, global_filters, model, user):
-        """
-        Aplica filtros globales - VERSIÓN CORREGIDA CON UUID
-        """
-        
-        filters = {}
-        model_fields = [f.name for f in model._meta.get_fields()]
-        
-        # ORGANIZACIÓN - Manejar como UUID
-        org_value = global_filters.get('organizacion')
-        if org_value and org_value != '' and 'organizacion' in model_fields:
-            field = model._meta.get_field('organizacion')
-            
-            if hasattr(field, 'related_model'):  # Es ForeignKey
-                # Convertir string a UUID
-                try:
-                    import uuid
-                    org_uuid = uuid.UUID(org_value)
-                    filters['organizacion_id'] = org_uuid
-                except Exception as e:
-                    # Fallback: dejar como string (puede no funcionar)
-                    filters['organizacion_id'] = org_value
-            else:  # Es CharField
-                filters['organizacion'] = org_value
-        
-        # RFC - Manejar normalmente
-        rfc_value = global_filters.get('rfc')
-        if rfc_value and rfc_value != '' and 'rfc' in model_fields:
-            filters['rfc'] = rfc_value
-        
-        # PATENTE
-        if global_filters.get('patente'):
-            filters['patente'] = global_filters['patente']
-        
-        # PEDIMENTO
-        if global_filters.get('pedimento'):
-            filters['pedimento'] = global_filters['pedimento']
-        
-        # FECHAS
-        if 'fecha_pago_real' in model_fields:
-            if global_filters.get('fecha_pago_desde'):
-                filters['fecha_pago_real__gte'] = global_filters['fecha_pago_desde']
-            
-            if global_filters.get('fecha_pago_hasta'):
-                filters['fecha_pago_real__lte'] = global_filters['fecha_pago_hasta']
-        
-        return filters
-    
+        return datastage_export.apply_global_filters_to_model(global_filters, model)
+
     def apply_related_filters(self, global_filters, model, related_keys, user):
-        filters = {}
-        model_fields = [f.name for f in model._meta.get_fields()]
-        
-        # 1. Organización — convertir a UUID igual que apply_global_filters_to_model
-        if 'organizacion' in model_fields and global_filters.get('organizacion'):
-            org_value = global_filters['organizacion']
-            try:
-                field = model._meta.get_field('organizacion')
-                if hasattr(field, 'related_model'):
-                    filters['organizacion_id'] = uuid.UUID(org_value)
-                else:
-                    filters['organizacion'] = org_value
-            except Exception:
-                filters['organizacion_id'] = org_value
-        
-        # 2. RFC (¡ESTO ES LO QUE FALTA!)
-        if 'rfc' in model_fields and global_filters.get('rfc'):
-            filters['rfc'] = global_filters['rfc']
-        
-        # 3. Fechas (SIEMPRE se aplican)
-        if 'fecha_pago_real' in model_fields:
-            if global_filters.get('fecha_pago_desde'):
-                filters['fecha_pago_real__gte'] = global_filters['fecha_pago_desde']
-            
-            if global_filters.get('fecha_pago_hasta'):
-                filters['fecha_pago_real__lte'] = global_filters['fecha_pago_hasta']
-        
-        # 🔥 SEGUNDO: Si hay related_keys, AÑADIRLAS a los filtros existentes
-        if any(related_keys.values()):
-            
-            # Añadir patentes si existen
-            if related_keys.get('patentes') and 'patente' in model_fields:
-                filters['patente__in'] = related_keys['patentes']
-            
-            # Añadir pedimentos si existen
-            if related_keys.get('pedimentos') and 'pedimento' in model_fields:
-                filters['pedimento__in'] = related_keys['pedimentos']
-            
-            # Añadir datastage_ids si existen
-            if related_keys.get('datastage_ids') and 'datastage_id' in model_fields:
-                filters['datastage_id__in'] = related_keys['datastage_ids']
-        
-        else:
-            # Solo patente y pedimento específicos (no listas)
-            if 'patente' in model_fields and global_filters.get('patente'):
-                filters['patente'] = global_filters['patente']
-            
-            if 'pedimento' in model_fields and global_filters.get('pedimento'):
-                filters['pedimento'] = global_filters['pedimento']
-        
-        return filters
+        return datastage_export.apply_related_filters(global_filters, model, related_keys)
 
     def estimate_excel_file_size(self, num_records, num_columns):
         """Estima tamaño aproximado del archivo Excel"""

api/reports/views_table.py

@@ -70,14 +70,13 @@ def table_summary(request):
         status='pending',
         report_type='cumplimiento'
     )
-    generate_report_document.delay(report.id)
+    task = generate_report_document.delay(report.id)
     return Response({
         "report_id": report.id,
+        "task_id": task.id,
         "status": report.status,
         "created_at": report.created_at,
-        # "download_url": report.file.url if report.file else None
-        "download_url": storage_service.get_file_url(report.file) if report.file else None
-
+        "download_url": storage_service.get_file_url(report.file) if report.file else None,
     }, status=202)
 
 @api_view(['GET'])
@@ -127,7 +126,7 @@ def report_document_download(request, report_id):
             return Response({"error": "El archivo aún no está disponible"}, status=404)
         
         ruta = str(report.file)
-        with tempfile.NamedTemporaryFile(delete=False, suffix='.csv') as tmp:
+        with tempfile.NamedTemporaryFile(delete=False, suffix='.xlsx') as tmp:
             tmp_path = tmp.name
         
         success = storage_service.download_file(ruta, tmp_path)

config/settings.py

@@ -34,6 +34,13 @@ CELERY_BEAT_SCHEDULE = {
         'task': 'api.customs.tasks.microservice_v2.process_all_organizations',
         'schedule': crontab(hour=7, minute=1),  # analizar si se requiere otra en un futuro
     },
+    # Reintento recurrente de descargas VUCEM pendientes (T2026-05-027):
+    # cada ciclo incrementa el contador de intentos y, al agotar
+    # MAX_INTENTOS_AUTO, transiciona el registro a estado 'error'.
+    'reintentar_descargas_pendientes': {
+        'task': 'api.customs.tasks.microservice_v2.reintentar_descargas_pendientes',
+        'schedule': crontab(minute='*/30'),
+    },
     # 'process_all_organizations': {
     #     'task': 'api.customs.tasks.microservice_v2.process_all_organizations',
     #     'schedule': crontab(hour=11, minute=39),  # analizar si se requiere otra en un futuro
@@ -68,9 +75,30 @@ ALLOWED_HOSTS = [
     ,'192.168.1.79'
 ]
 
-SITE_URL = os.getenv('SITE_URL') 
+SITE_URL = os.getenv('SITE_URL')
 SERVICE_API_URL = os.getenv('SERVICE_API_URL')
 SERVICE_API_URL_V2 = os.getenv('SERVICE_API_URL_V2')
+
+# Tope de intentos automáticos de descarga VUCEM por registro (T2026-05-027).
+# Un intento = un ciclo de orquestación completo; los reintentos internos del
+# worker no incrementan el contador. Al llegar al tope solo queda el reproceso manual.
+MAX_INTENTOS_AUTO = int(os.getenv('MAX_INTENTOS_AUTO', '5'))
+
+# Hub / SSO
+HUB_URL              = os.getenv('HUB_URL', 'https://workspace.aduanasoft.com')
+HUB_PRODUCT_SLUG     = os.getenv('HUB_PRODUCT_SLUG', 'efc')
+HUB_TENANT_SLUG      = os.getenv('HUB_TENANT_SLUG', '')
+HUB_PROVISION_SECRET = os.getenv('HUB_PROVISION_SECRET', '')
+HUB_TENANT_ID        = int(os.getenv('HUB_TENANT_ID', '1'))
+COOKIE_SECURE        = os.getenv('COOKIE_SECURE', 'false').lower() in ('1', 'true', 'yes')
+
+# Keycloak admin (para auto-provisión de usuarios en migración)
+KC_URL               = os.getenv('KC_URL', 'http://hub-keycloak:8080')
+KC_REALM             = os.getenv('KC_REALM', 'master')
+KC_ADMIN_USER        = os.getenv('KC_ADMIN_USER', 'admin')
+KC_ADMIN_PASSWORD    = os.getenv('KC_ADMIN_PASSWORD', 'admin')
+KC_EFC_CLIENT_ID     = os.getenv('KC_EFC_CLIENT_ID', 'efc-backend')
+KC_EFC_CLIENT_SECRET = os.getenv('KC_EFC_CLIENT_SECRET', 'efc-backend-secret-dev')
 # Application definition
 BASE_APPS = [
     'django.contrib.admin',
@@ -162,7 +190,7 @@ if DEBUG:
     USE_X_FORWARDED_HOST = False
 else:
     CORS_ALLOW_ALL_ORIGINS = False
-    CORS_ALLOW_CREDENTIALS = False
+    CORS_ALLOW_CREDENTIALS = True
     SECURE_PROXY_SSL_HEADER = ('HTTP_X_FORWARDED_PROTO', 'https')
     CORS_ALLOWED_ORIGINS = os.getenv('CORS_ALLOWED_ORIGINS').split(',')
     CSRF_COOKIE_SECURE = True
@@ -174,11 +202,14 @@ CORS_ALLOW_HEADERS = list(default_headers) + [
     'access-control-allow-credentials',
 ]
 
+CORS_EXPOSE_HEADERS = ['Content-Disposition']
+
 # # JWT Authentication settings
 REST_FRAMEWORK = {
     'DEFAULT_AUTHENTICATION_CLASSES': [
-        'rest_framework_simplejwt.authentication.JWTAuthentication',
-        'rest_framework.authentication.TokenAuthentication',  # Añade esta línea
+        'api.cuser.hub_auth.HubAuthBackend',               # Hub SSO (local + KC)
+        'rest_framework_simplejwt.authentication.JWTAuthentication',  # legacy
+        'rest_framework.authentication.TokenAuthentication',
     ],
     'DEFAULT_PERMISSION_CLASSES': [
         'rest_framework.permissions.IsAuthenticated',
@@ -223,7 +254,9 @@ REDOC_SETTINGS = {
 CSRF_TRUSTED_ORIGINS = [
     "https://api.efc-aduanasoft.com",
     "http://192.168.1.195",
-    "http://192.168.1.195:8000"
+    "http://192.168.1.195:8000",
+    "http://localhost:5173",
+    "http://localhost:8000",
 ]
 
 # URL Configuration
@@ -319,10 +352,10 @@ CELERY_TIMEZONE = 'America/Denver'
 ASGI_APPLICATION = 'config.asgi.application'
 
 SIMPLE_JWT = {
-    'ACCESS_TOKEN_LIFETIME': timedelta(minutes=30),   # Tokens de acceso cortos por seguridad
-    'REFRESH_TOKEN_LIFETIME': timedelta(days=5),     # Refresh token de 5 días
-    'ROTATE_REFRESH_TOKENS': True,                   # Rotar refresh tokens para mayor seguridad
-    'BLACKLIST_AFTER_ROTATION': True,
+    'ACCESS_TOKEN_LIFETIME': timedelta(minutes=15),    # 1 hora — reduce frecuencia de refresh
+    'REFRESH_TOKEN_LIFETIME': timedelta(days=7),   # 7 días — sesión larga
+    'ROTATE_REFRESH_TOKENS': False,                 # OFF — evita blacklist en múltiples tabs
+    'BLACKLIST_AFTER_ROTATION': False,              # OFF — sin blacklist, múltiples tabs coexisten
     'AUTH_HEADER_TYPES': ('Bearer',),
 }
 

config/urls.py

@@ -32,11 +32,14 @@ urlpatterns = [
     path('admin/', admin.site.urls),
     path('api/v1/', include('api.licence.urls')),
 
-    # JWT Authentication
+    # JWT Authentication (legacy — mantener durante transición)
     path('api/v1/token/', TokenObtainPairView.as_view(), name='token_obtain_pair'),
     path('api/v1/token/refresh/', TokenRefreshView.as_view(), name='token_refresh'),
     path('api/v1/user/', include(('api.cuser.urls', 'cuser'), namespace='cuser')),  # Custom user app
 
+    # Hub SSO
+    path('api/v1/auth/', include('api.cuser.sso_urls')),
+
     #path('api-auth/', include('rest_framework.urls')),
     path('api/v1/swagger/', schema_view.with_ui('swagger', cache_timeout=0), name='schema-swagger-ui'),
     path('api/v1/redoc/', schema_view.with_ui('redoc', cache_timeout=0), name='schema-redoc'),

core/utils.py

@@ -150,13 +150,14 @@ class PedimentoScrapper: # Clase me extrae datos de Pedimento
     def _remesas(self, root: ET.Element) -> bool:
         """
         Método para verificar si el pedimento tiene remesas.
-        Busca identificadores con clave 'RC' (REMESAS DE CONSOLIDADO).
-        
+        Busca identificadores con clave 'PC' (PEDIMENTO CONSOLIDADO)
+        o 'RC' (REMESAS DE CONSOLIDADO).
+
         Args:
             root: Elemento raíz del XML.
-        
+
         Returns:
-            True si encuentra identificadores con clave 'RC', False en caso contrario.
+            True si encuentra identificadores con clave 'PC' o 'RC', False en caso contrario.
         """
         namespaces = {
             'ns2': 'http://www.ventanillaunica.gob.mx/pedimentos/ws/oxml/consultarpedimentocompleto',
@@ -172,8 +173,8 @@ class PedimentoScrapper: # Clase me extrae datos de Pedimento
                 clave_elem = identificador.find('ns:claveIdentificador/ns:clave', namespaces)
                 clave = clave_elem.text if clave_elem is not None else None
                 
-                # Si encontramos una clave 'RC', el pedimento tiene remesas
-                if clave == 'RC':
+                # PC (consolidado) o RC (remesas de consolidado) indican remesas
+                if clave in ('PC', 'RC'):
                     return True
                         
             except Exception as e:

script/migrate_users_to_keycloak.py

@@ -0,0 +1,251 @@
+"""
+Migración one-shot: crea usuarios EFC en Keycloak (realm master) y los
+vincula al tenant en el Hub via BD directa.
+
+Estrategia:
+  - Crear usuario en Keycloak via admin REST API
+  - Insertar registro en hub.user_tenants
+  - Guardar keycloak_user_id en cuser_customuser
+
+CÓMO USAR:
+  Dry-run (no toca nada):
+    docker exec EFC_backend_dev python script/migrate_users_to_keycloak.py --dry-run
+
+  Migración real:
+    docker exec EFC_backend_dev python script/migrate_users_to_keycloak.py
+
+CASOS ESPECIALES:
+  - Sin email: se omiten (no se pueden crear en KC sin email único)
+  - Email duplicado: se crea una sola vez en KC; el UUID se asigna a todos
+    los registros EFC con ese email
+"""
+
+import argparse
+import logging
+import os
+import sys
+import time
+from collections import defaultdict
+
+import django
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+os.environ.setdefault("DJANGO_SETTINGS_MODULE", "config.settings")
+django.setup()
+
+import requests  # noqa: E402
+from django.db import transaction  # noqa: E402
+
+from api.cuser.models import CustomUser  # noqa: E402
+
+_hub_token_cache: dict = {}
+
+
+def get_hub_admin_token(session: requests.Session) -> str:
+    """Obtiene Bearer token del hubadmin. Acepta token pre-generado via HUB_BEARER_TOKEN."""
+    preset = os.getenv("HUB_BEARER_TOKEN", "")
+    if preset:
+        return preset
+    r = session.post(
+        f"{HUB_API_URL.rstrip('/')}/api/v1/auth/login",
+        json={"username": HUB_ADMIN_USER, "password": HUB_ADMIN_PASS},
+        timeout=10,
+    )
+    r.raise_for_status()
+    return r.json()["access_token"]
+
+
+def register_user_in_hub(session: requests.Session, hub_token: str,
+                          keycloak_user_id: str) -> bool:
+    """Llama a POST /hub/user-tenants/add para vincular el usuario al tenant."""
+    r = session.post(
+        f"{HUB_API_URL.rstrip('/')}/api/v1/hub/user-tenants/add",
+        json={"keycloak_user_id": keycloak_user_id, "tenant_id": HUB_TENANT_ID, "role": "user"},
+        headers={"Authorization": f"Bearer {hub_token}"},
+        timeout=10,
+    )
+    if r.status_code in (200, 201):
+        return True
+    if r.status_code == 409:
+        return True  # ya registrado
+    logger.error("Hub user-tenants/add %s: %s", r.status_code, r.text[:200])
+    return False
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s %(levelname)-8s %(message)s",
+    datefmt="%H:%M:%S",
+)
+logger = logging.getLogger("migrate")
+
+# ── Configuración ──────────────────────────────────────────────────────────────
+KC_URL        = os.getenv("KEYCLOAK_URL", "http://hub-keycloak:8080")
+KC_REALM      = "master"
+KC_ADMIN_USER = os.getenv("KEYCLOAK_ADMIN_USERNAME", "admin")
+KC_ADMIN_PASS = os.getenv("KEYCLOAK_ADMIN_PASSWORD", "admin")
+
+HUB_API_URL       = os.getenv("HUB_URL", "http://hub-backend:8000")
+HUB_ADMIN_USER    = os.getenv("HUB_ADMIN_USERNAME", "hubadmin")
+HUB_ADMIN_PASS    = os.getenv("HUB_ADMIN_PASSWORD", "Localhost1234!")
+HUB_TENANT_ID     = int(os.getenv("HUB_TENANT_ID", "1"))
+
+TENANT_SLUG   = os.getenv("HUB_TENANT_SLUG", "efc")
+TEMP_PASSWORD = "ChangeMe!Temp2025"
+BATCH_SIZE    = 20
+
+
+def get_kc_admin_token(session: requests.Session) -> str:
+    """Obtiene token de admin de Keycloak."""
+    r = session.post(
+        f"{KC_URL}/kcauth/realms/master/protocol/openid-connect/token",
+        data={
+            "client_id": "admin-cli",
+            "grant_type": "password",
+            "username": KC_ADMIN_USER,
+            "password": KC_ADMIN_PASS,
+        },
+        timeout=10,
+    )
+    r.raise_for_status()
+    return r.json()["access_token"]
+
+
+def create_kc_user(session: requests.Session, token: str, user: CustomUser) -> str | None:
+    """Crea usuario en Keycloak. Retorna UUID o None si falla."""
+    headers = {"Authorization": f"Bearer {token}", "Content-Type": "application/json"}
+    body = {
+        "username":    user.username,
+        "email":       user.email,
+        "firstName":   user.first_name or "",
+        "lastName":    user.last_name or "",
+        "enabled":     True,
+        "credentials": [{"type": "password", "value": TEMP_PASSWORD, "temporary": True}],
+    }
+    r = session.post(
+        f"{KC_URL}/kcauth/admin/realms/{KC_REALM}/users",
+        json=body,
+        headers=headers,
+        timeout=15,
+    )
+
+    if r.status_code == 201:
+        # El ID viene en el header Location: .../users/<uuid>
+        location = r.headers.get("Location", "")
+        kc_id = location.split("/")[-1]
+        return kc_id if kc_id else None
+
+    if r.status_code == 409:
+        # Ya existe — buscar por email
+        search = session.get(
+            f"{KC_URL}/kcauth/admin/realms/{KC_REALM}/users?email={user.email}&exact=true",
+            headers=headers,
+            timeout=10,
+        )
+        users = search.json()
+        if users:
+            return users[0]["id"]
+        logger.warning("[%s] Conflicto 409 pero no se encontró por email", user.username)
+        return None
+
+    logger.error("[%s] KC %s: %s", user.username, r.status_code, r.text[:200])
+    return None
+
+
+
+def run(dry_run: bool):
+    pending = list(
+        CustomUser.objects.filter(is_active=True, keycloak_user_id__isnull=True)
+        .order_by("date_joined")
+    )
+
+    sin_email = [u for u in pending if not (u.email or "").strip()]
+    con_email = [u for u in pending if (u.email or "").strip()]
+
+    by_email: dict[str, list] = defaultdict(list)
+    for u in con_email:
+        by_email[u.email.lower()].append(u)
+
+    dup_emails = {e: us for e, us in by_email.items() if len(us) > 1}
+
+    logger.info("═══════════════════════════════════════════")
+    logger.info("Pendientes        : %d", len(pending))
+    logger.info("Sin email (omiten): %d", len(sin_email))
+    logger.info("Provisiones KC    : %d emails únicos", len(by_email))
+    logger.info("Emails duplicados : %d grupos", len(dup_emails))
+    logger.info("Tenant Hub        : %s", TENANT_SLUG)
+    logger.info("Keycloak URL      : %s", KC_URL)
+    logger.info("Hub API URL       : %s", HUB_API_URL)
+    logger.info("Hub Tenant ID     : %d", HUB_TENANT_ID)
+    logger.info("═══════════════════════════════════════════")
+
+    if sin_email:
+        logger.warning("Omitidos sin email: %s", [u.username for u in sin_email])
+
+    if dup_emails:
+        for email, users in dup_emails.items():
+            logger.info("Duplicado %s → %s", email, [u.username for u in users])
+
+    if dry_run:
+        logger.info("=== DRY-RUN completado — no se hizo ningún cambio ===")
+        return
+
+    ok = 0; failed = 0; i = 0
+    with requests.Session() as session:
+        kc_token  = get_kc_admin_token(session)
+        hub_token = get_hub_admin_token(session)
+
+        for email, users in by_email.items():
+            i += 1
+            primary = users[0]
+
+            # Refrescar tokens cada 50 usuarios
+            if i % 50 == 0:
+                try:
+                    kc_token  = get_kc_admin_token(session)
+                    hub_token = get_hub_admin_token(session)
+                except Exception as exc:
+                    logger.error("No se pudo refrescar tokens: %s", exc)
+                    sys.exit(1)
+
+            kc_id = create_kc_user(session, kc_token, primary)
+            if not kc_id:
+                failed += 1
+                continue
+
+            # Registrar en Hub via API
+            if not register_user_in_hub(session, hub_token, kc_id):
+                failed += 1
+                continue
+
+            # Guardar en EFC DB — solo el usuario principal (UNIQUE constraint)
+            # Los duplicados quedan con keycloak_user_id=NULL; comparten identidad KC
+            with transaction.atomic():
+                CustomUser.objects.filter(pk=primary.pk).update(keycloak_user_id=kc_id)
+
+            ok += 1
+            extra = f" (+{len(users)-1} dups)" if len(users) > 1 else ""
+            logger.info("[%d/%d] %-40s → %s%s", i, len(by_email), email, kc_id[:8] + "...", extra)
+
+            if i % BATCH_SIZE == 0:
+                time.sleep(0.3)
+
+    logger.info("═══════════════════════════════════════════")
+    logger.info("Exitosos : %d", ok)
+    logger.info("Fallidos : %d", failed)
+    logger.info("Sin email: %d (omitidos)", len(sin_email))
+
+    if failed:
+        logger.warning("Hay fallidos — vuelve a correr el script, es idempotente.")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--dry-run", action="store_true")
+    parser.add_argument("--tenant-slug", default=TENANT_SLUG)
+    args = parser.parse_args()
+
+    if args.tenant_slug != TENANT_SLUG:
+        TENANT_SLUG = args.tenant_slug
+
+    run(args.dry_run)

scripts/t2026_05_027/01_deteccion_registros_afectados.sql

@@ -0,0 +1,90 @@
+-- T2026-05-027 / Paso 1: detección de registros afectados (solo lectura)
+-- Ejecutar ANTES de la migración como línea base y DESPUÉS de la corrección
+-- (las queries deben regresar 0 filas al final).
+--
+-- Catálogo confirmado de document_type:
+--   4 = acuse EDoc, 7 = acuse COVE, 19/23 = request COVE, 21/25 = request EDoc,
+--   20 = error COVE, 22 = error EDoc, 24 = error acuse COVE, 26 = error acuse EDoc
+-- Confirmar con: SELECT id, nombre, descripcion FROM document_type ORDER BY id;
+
+-- (a) Acuses de EDocument marcados descargados SIN documento tipo 4 en BD
+SELECT e.id, e.numero_edocument, p.pedimento, p.id AS pedimento_id, e.organizacion_id
+FROM edocs e
+JOIN pedimento p ON p.id = e.pedimento_id
+WHERE e.acuse_descargado = TRUE
+  AND NOT EXISTS (
+    SELECT 1 FROM document d
+    WHERE d.pedimento_id = e.pedimento_id
+      AND d.document_type_id = 4
+      AND d.archivo ILIKE '%' || e.numero_edocument || '%'
+  );
+
+-- (b) EDocuments marcados descargados SIN documento general
+SELECT e.id, e.numero_edocument, p.pedimento
+FROM edocs e
+JOIN pedimento p ON p.id = e.pedimento_id
+WHERE e.edocument_descargado = TRUE
+  AND NOT EXISTS (
+    SELECT 1 FROM document d
+    WHERE d.pedimento_id = e.pedimento_id
+      AND d.archivo ILIKE '%' || e.numero_edocument || '%'
+      AND d.document_type_id NOT IN (4, 21, 22, 25, 26)
+  );
+
+-- (c) Acuses de COVE marcados descargados SIN documento tipo 7
+SELECT c.id, c.numero_cove, p.pedimento
+FROM coves c
+JOIN pedimento p ON p.id = c.pedimento_id
+WHERE c.acuse_cove_descargado = TRUE
+  AND NOT EXISTS (
+    SELECT 1 FROM document d
+    WHERE d.pedimento_id = c.pedimento_id
+      AND d.document_type_id = 7
+      AND d.archivo ILIKE '%' || c.numero_cove || '%'
+  );
+
+-- (d) COVEs marcados descargados SIN documento general
+SELECT c.id, c.numero_cove, p.pedimento
+FROM coves c
+JOIN pedimento p ON p.id = c.pedimento_id
+WHERE c.cove_descargado = TRUE
+  AND NOT EXISTS (
+    SELECT 1 FROM document d
+    WHERE d.pedimento_id = c.pedimento_id
+      AND d.archivo ILIKE '%' || c.numero_cove || '%'
+      AND d.document_type_id NOT IN (7, 19, 20, 23, 24)
+  );
+
+-- (e) Pendientes con evidencia de error (documentos tipo 20/22/24/26)
+SELECT 'cove_acuse_pendiente_con_error' AS categoria, c.id::text, c.numero_cove AS numero
+FROM coves c
+WHERE c.acuse_cove_descargado = FALSE
+  AND EXISTS (SELECT 1 FROM document d
+              WHERE d.pedimento_id = c.pedimento_id AND d.document_type_id = 24
+                AND d.archivo ILIKE '%' || c.numero_cove || '%')
+UNION ALL
+SELECT 'cove_pendiente_con_error', c.id::text, c.numero_cove
+FROM coves c
+WHERE c.cove_descargado = FALSE
+  AND EXISTS (SELECT 1 FROM document d
+              WHERE d.pedimento_id = c.pedimento_id AND d.document_type_id = 20
+                AND d.archivo ILIKE '%' || c.numero_cove || '%')
+UNION ALL
+SELECT 'edoc_pendiente_con_error', e.id::text, e.numero_edocument
+FROM edocs e
+WHERE e.edocument_descargado = FALSE
+  AND EXISTS (SELECT 1 FROM document d
+              WHERE d.pedimento_id = e.pedimento_id AND d.document_type_id = 22
+                AND d.archivo ILIKE '%' || e.numero_edocument || '%')
+UNION ALL
+SELECT 'edoc_acuse_pendiente_con_error', e.id::text, e.numero_edocument
+FROM edocs e
+WHERE e.acuse_descargado = FALSE
+  AND EXISTS (SELECT 1 FROM document d
+              WHERE d.pedimento_id = e.pedimento_id AND d.document_type_id = 26
+                AND d.archivo ILIKE '%' || e.numero_edocument || '%');
+
+-- (f) Verificación puntual del caso reportado por QA (pedimento del documento de pruebas)
+SELECT e.id, e.numero_edocument, e.edocument_descargado, e.acuse_descargado
+FROM edocs e
+WHERE e.pedimento_id = 'b4a6c3dd-5966-45a8-aa50-79b626ffd9c1';

scripts/t2026_05_027/02_backfill_estados.sql

@@ -0,0 +1,21 @@
+-- T2026-05-027 / Paso 2: backfill de estados (ejecutar DESPUÉS de aplicar la
+-- migración de customs que agrega *_estado, *_intentos, ultimo_intento_at, ultimo_error).
+-- Deriva el estado de 3 valores de los booleanos legados.
+
+BEGIN;
+
+-- Conteos de control: anotar y comparar contra las filas afectadas por cada UPDATE
+SELECT COUNT(*) AS total_edocs FROM edocs;
+SELECT COUNT(*) AS total_coves FROM coves;
+
+UPDATE edocs SET
+  edocument_estado = CASE WHEN edocument_descargado THEN 'descargado' ELSE 'pendiente' END,
+  acuse_estado     = CASE WHEN acuse_descargado     THEN 'descargado' ELSE 'pendiente' END;
+
+UPDATE coves SET
+  cove_estado       = CASE WHEN cove_descargado       THEN 'descargado' ELSE 'pendiente' END,
+  acuse_cove_estado = CASE WHEN acuse_cove_descargado THEN 'descargado' ELSE 'pendiente' END;
+
+-- Validar que cada UPDATE afectó exactamente el total de su tabla antes de confirmar:
+COMMIT;
+-- ROLLBACK;  -- usar en su lugar si los conteos no cuadran

scripts/t2026_05_027/03_correccion_pendientes_con_error.sql

@@ -0,0 +1,85 @@
+-- T2026-05-027 / Paso 3: corrección masiva de pendientes con evidencia de error.
+-- Ejecutar DESPUÉS del backfill (02). Los registros 'pendiente' con documento de
+-- error asociado (tipos 20/22/24/26) transicionan a 'error' — quedan visibles y
+-- solo reprocesables de forma manual.
+--
+-- Los falsos "descargado" se corrigen con el comando (verifica también MinIO):
+--   python manage.py reconciliar_descargas            -- dry-run
+--   python manage.py reconciliar_descargas --apply    -- corrige
+
+BEGIN;
+
+-- Conteo de control (comparar contra filas afectadas por el UPDATE correspondiente)
+SELECT COUNT(*) AS coves_acuse_error FROM coves c
+WHERE c.acuse_cove_estado = 'pendiente'
+  AND EXISTS (SELECT 1 FROM document d
+              WHERE d.pedimento_id = c.pedimento_id AND d.document_type_id = 24
+                AND d.archivo ILIKE '%' || c.numero_cove || '%');
+
+UPDATE coves c SET
+  acuse_cove_estado = 'error',
+  acuse_cove_descargado = FALSE,
+  ultimo_error = 'Corrección T2026-05-027: acuse con documento de error (tipo 24) sin reintento',
+  updated_at = NOW()
+WHERE c.acuse_cove_estado = 'pendiente'
+  AND EXISTS (SELECT 1 FROM document d
+              WHERE d.pedimento_id = c.pedimento_id AND d.document_type_id = 24
+                AND d.archivo ILIKE '%' || c.numero_cove || '%');
+
+SELECT COUNT(*) AS coves_error FROM coves c
+WHERE c.cove_estado = 'pendiente'
+  AND EXISTS (SELECT 1 FROM document d
+              WHERE d.pedimento_id = c.pedimento_id AND d.document_type_id = 20
+                AND d.archivo ILIKE '%' || c.numero_cove || '%');
+
+UPDATE coves c SET
+  cove_estado = 'error',
+  cove_descargado = FALSE,
+  ultimo_error = 'Corrección T2026-05-027: COVE con documento de error (tipo 20) sin reintento',
+  updated_at = NOW()
+WHERE c.cove_estado = 'pendiente'
+  AND EXISTS (SELECT 1 FROM document d
+              WHERE d.pedimento_id = c.pedimento_id AND d.document_type_id = 20
+                AND d.archivo ILIKE '%' || c.numero_cove || '%');
+
+SELECT COUNT(*) AS edocs_error FROM edocs e
+WHERE e.edocument_estado = 'pendiente'
+  AND EXISTS (SELECT 1 FROM document d
+              WHERE d.pedimento_id = e.pedimento_id AND d.document_type_id = 22
+                AND d.archivo ILIKE '%' || e.numero_edocument || '%');
+
+UPDATE edocs e SET
+  edocument_estado = 'error',
+  edocument_descargado = FALSE,
+  ultimo_error = 'Corrección T2026-05-027: EDocument con documento de error (tipo 22) sin reintento',
+  updated_at = NOW()
+WHERE e.edocument_estado = 'pendiente'
+  AND EXISTS (SELECT 1 FROM document d
+              WHERE d.pedimento_id = e.pedimento_id AND d.document_type_id = 22
+                AND d.archivo ILIKE '%' || e.numero_edocument || '%');
+
+SELECT COUNT(*) AS edocs_acuse_error FROM edocs e
+WHERE e.acuse_estado = 'pendiente'
+  AND EXISTS (SELECT 1 FROM document d
+              WHERE d.pedimento_id = e.pedimento_id AND d.document_type_id = 26
+                AND d.archivo ILIKE '%' || e.numero_edocument || '%');
+
+UPDATE edocs e SET
+  acuse_estado = 'error',
+  acuse_descargado = FALSE,
+  ultimo_error = 'Corrección T2026-05-027: acuse con documento de error (tipo 26) sin reintento',
+  updated_at = NOW()
+WHERE e.acuse_estado = 'pendiente'
+  AND EXISTS (SELECT 1 FROM document d
+              WHERE d.pedimento_id = e.pedimento_id AND d.document_type_id = 26
+                AND d.archivo ILIKE '%' || e.numero_edocument || '%');
+
+COMMIT;
+-- ROLLBACK;  -- usar en su lugar si los conteos no cuadran
+
+-- Censo final: distribución de estados (no debe existir valor fuera del catálogo)
+SELECT 'edocs' AS tabla, edocument_estado AS estado, COUNT(*) FROM edocs GROUP BY 2
+UNION ALL SELECT 'edocs_acuse', acuse_estado, COUNT(*) FROM edocs GROUP BY 2
+UNION ALL SELECT 'coves', cove_estado, COUNT(*) FROM coves GROUP BY 2
+UNION ALL SELECT 'coves_acuse', acuse_cove_estado, COUNT(*) FROM coves GROUP BY 2
+ORDER BY tabla, estado;