feature/pedimentos-correccion-partidas
This commit is contained in:
117
api/customs/management/commands/fix_archivo_case.py
Normal file
117
api/customs/management/commands/fix_archivo_case.py
Normal file
@@ -0,0 +1,117 @@
|
||||
"""
|
||||
Corrige el mismatch de case entre el campo `archivo` en BD y los nombres
|
||||
reales de los objetos en MinIO.
|
||||
|
||||
Causa habitual: transferencia de archivos de producción a local lowercaseó
|
||||
los filenames, pero la BD conserva los nombres originales con mayúsculas.
|
||||
|
||||
Estrategia: para cada Document cuyo `archivo` no exista en MinIO con el
|
||||
nombre exacto, intenta el filename en minúsculas. Si lo encuentra, actualiza
|
||||
el campo en BD. Los archivos que ya coinciden no se tocan.
|
||||
|
||||
Uso:
|
||||
python manage.py fix_archivo_case --pedimento <UUID> --dry-run
|
||||
python manage.py fix_archivo_case --pedimento <UUID>
|
||||
python manage.py fix_archivo_case --organizacion <UUID> --dry-run
|
||||
python manage.py fix_archivo_case --organizacion <UUID>
|
||||
"""
|
||||
import posixpath
|
||||
|
||||
from django.core.management.base import BaseCommand, CommandError
|
||||
|
||||
from api.customs.models import Pedimento
|
||||
from api.record.models import Document
|
||||
from api.utils.minio_client import minio_client
|
||||
|
||||
|
||||
class Command(BaseCommand):
|
||||
help = "Corrige mismatch de case entre campo archivo en BD y MinIO."
|
||||
|
||||
def add_arguments(self, parser):
|
||||
parser.add_argument(
|
||||
"--pedimento", metavar="UUID",
|
||||
help="UUID del pedimento a corregir.",
|
||||
)
|
||||
parser.add_argument(
|
||||
"--organizacion", metavar="UUID",
|
||||
help="UUID de la organización.",
|
||||
)
|
||||
parser.add_argument(
|
||||
"--dry-run", action="store_true",
|
||||
help="Solo diagnóstico, sin aplicar cambios.",
|
||||
)
|
||||
|
||||
def handle(self, *args, **options):
|
||||
ped_id = options.get("pedimento")
|
||||
org_id = options.get("organizacion")
|
||||
dry_run = options["dry_run"]
|
||||
|
||||
if dry_run:
|
||||
self.stdout.write(self.style.WARNING(
|
||||
"=== MODO PRUEBA (--dry-run): Sin cambios en BD ===\n"
|
||||
))
|
||||
|
||||
qs = Document.objects.all()
|
||||
if ped_id:
|
||||
try:
|
||||
ped = Pedimento.objects.get(id=ped_id)
|
||||
except Pedimento.DoesNotExist:
|
||||
raise CommandError(f"Pedimento {ped_id!r} no encontrado.")
|
||||
qs = qs.filter(pedimento=ped)
|
||||
self.stdout.write(f"Pedimento: {ped.pedimento_app}\n")
|
||||
elif org_id:
|
||||
qs = qs.filter(organizacion_id=org_id)
|
||||
|
||||
total = qs.count()
|
||||
self.stdout.write(f"Documentos a revisar: {total}\n")
|
||||
|
||||
ok = mismatch = not_found = 0
|
||||
|
||||
for doc in qs.iterator(chunk_size=500):
|
||||
name = doc.archivo.name if doc.archivo else None
|
||||
if not name:
|
||||
continue
|
||||
|
||||
if minio_client.file_exists(name):
|
||||
ok += 1
|
||||
continue
|
||||
|
||||
lower_name = self._lower_filename(name)
|
||||
if lower_name == name:
|
||||
not_found += 1
|
||||
continue
|
||||
|
||||
if minio_client.file_exists(lower_name):
|
||||
mismatch += 1
|
||||
self.stdout.write(
|
||||
f" {'[DRY]' if dry_run else '[FIX]'} doc {doc.id}:\n"
|
||||
f" BD : {name}\n"
|
||||
f" MinIO : {lower_name}\n"
|
||||
)
|
||||
if not dry_run:
|
||||
doc.archivo.name = lower_name
|
||||
doc.save(update_fields=["archivo"])
|
||||
else:
|
||||
not_found += 1
|
||||
|
||||
self.stdout.write(
|
||||
f"\n{'─' * 60}\nRESUMEN\n"
|
||||
f" Coinciden exacto : {ok}\n"
|
||||
f" Mismatch de case : {mismatch}\n"
|
||||
f" No encontrados : {not_found}\n"
|
||||
)
|
||||
|
||||
if dry_run and mismatch:
|
||||
self.stdout.write(self.style.WARNING(
|
||||
"\nEjecuta sin --dry-run para aplicar los cambios."
|
||||
))
|
||||
elif not dry_run and mismatch:
|
||||
self.stdout.write(self.style.SUCCESS(
|
||||
f"\n{mismatch} registros actualizados en BD."
|
||||
))
|
||||
|
||||
def _lower_filename(self, name):
|
||||
"""Lowercase solo el filename, preserva el path del directorio."""
|
||||
dir_part = posixpath.dirname(name)
|
||||
filename = posixpath.basename(name)
|
||||
return posixpath.join(dir_part, filename.lower())
|
||||
382
api/customs/management/commands/fix_partidas_error.py
Normal file
382
api/customs/management/commands/fix_partidas_error.py
Normal file
@@ -0,0 +1,382 @@
|
||||
"""
|
||||
Diagnóstico y corrección de partidas con descargado=True cuyos documentos
|
||||
de respuesta VUCEM contienen <tieneError>true</tieneError>.
|
||||
|
||||
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
|
||||
|
||||
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 --dry-run # todas las orgs
|
||||
"""
|
||||
import io
|
||||
import posixpath
|
||||
|
||||
from django.core.management.base import BaseCommand, CommandError
|
||||
from django.db import transaction
|
||||
from django.db.models import Q
|
||||
from django.db.models.functions import Length
|
||||
|
||||
from api.customs.models import Partida, Pedimento
|
||||
from api.record.models import Document
|
||||
from api.utils.minio_client import minio_client
|
||||
|
||||
_PT_REQUEST = 17
|
||||
_PT_ERROR = 18
|
||||
|
||||
|
||||
class Command(BaseCommand):
|
||||
help = "Corrección de partidas descargado=True con respuestas de error VUCEM."
|
||||
|
||||
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(
|
||||
"--pedimento", metavar="UUID",
|
||||
help="UUID del pedimento a diagnosticar/corregir.",
|
||||
)
|
||||
# Filtros de fecha (aplican sobre fecha_pago del pedimento)
|
||||
parser.add_argument(
|
||||
"--fecha-desde", metavar="YYYY-MM-DD",
|
||||
help="Procesar pedimentos con fecha_pago >= esta fecha.",
|
||||
)
|
||||
parser.add_argument(
|
||||
"--fecha-hasta", metavar="YYYY-MM-DD",
|
||||
help="Procesar pedimentos con fecha_pago <= esta fecha.",
|
||||
)
|
||||
# Control de lote
|
||||
parser.add_argument(
|
||||
"--offset", type=int, default=0,
|
||||
help="Saltar los primeros N pedimentos malformados (default: 0).",
|
||||
)
|
||||
parser.add_argument(
|
||||
"--limit", type=int, default=0,
|
||||
help="Procesar máximo N pedimentos (default: 0 = todos).",
|
||||
)
|
||||
parser.add_argument(
|
||||
"--dry-run", action="store_true",
|
||||
help="Solo diagnóstico, sin aplicar cambios.",
|
||||
)
|
||||
|
||||
# ------------------------------------------------------------------ #
|
||||
# Entry point
|
||||
# ------------------------------------------------------------------ #
|
||||
|
||||
def handle(self, *args, **options):
|
||||
org_id = options.get("organizacion")
|
||||
ped_id = options.get("pedimento")
|
||||
fecha_desde = options.get("fecha_desde")
|
||||
fecha_hasta = options.get("fecha_hasta")
|
||||
offset = options["offset"]
|
||||
limit = options["limit"]
|
||||
dry_run = options["dry_run"]
|
||||
|
||||
if dry_run:
|
||||
self.stdout.write(self.style.WARNING(
|
||||
"=== MODO PRUEBA (--dry-run): Sin cambios en BD ni storage ===\n"
|
||||
))
|
||||
|
||||
if ped_id:
|
||||
self._handle_single(ped_id, dry_run)
|
||||
return
|
||||
|
||||
ped_qs = self._malformed_qs()
|
||||
|
||||
if org_id:
|
||||
ped_qs = ped_qs.filter(organizacion_id=org_id)
|
||||
if fecha_desde:
|
||||
ped_qs = ped_qs.filter(fecha_pago__gte=fecha_desde)
|
||||
if fecha_hasta:
|
||||
ped_qs = ped_qs.filter(fecha_pago__lte=fecha_hasta)
|
||||
|
||||
ped_qs = ped_qs.select_related("organizacion").order_by("fecha_pago", "pedimento_app")
|
||||
|
||||
total_sin_filtro = ped_qs.count()
|
||||
|
||||
if offset:
|
||||
ped_qs = ped_qs[offset:]
|
||||
if limit:
|
||||
ped_qs = ped_qs[:limit]
|
||||
|
||||
total = ped_qs.count() 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" [offset={offset}]" if offset else "")
|
||||
+ (f" [limit={limit}]" if limit else "")
|
||||
+ "\n"
|
||||
)
|
||||
|
||||
if total == 0:
|
||||
self.stdout.write(self.style.SUCCESS("Nada que corregir en este lote."))
|
||||
return
|
||||
|
||||
total_partidas = total_docs = 0
|
||||
for ped in ped_qs:
|
||||
p, d = self._process_pedimento(ped, dry_run)
|
||||
total_partidas += p
|
||||
total_docs += d
|
||||
|
||||
self._print_summary(total, total_partidas, total_docs, dry_run)
|
||||
|
||||
# ------------------------------------------------------------------ #
|
||||
# Flujo --pedimento
|
||||
# ------------------------------------------------------------------ #
|
||||
|
||||
def _handle_single(self, ped_id, dry_run):
|
||||
try:
|
||||
ped = Pedimento.objects.get(id=ped_id)
|
||||
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)
|
||||
|
||||
# ------------------------------------------------------------------ #
|
||||
# Queryset de pedimentos malformados
|
||||
# ------------------------------------------------------------------ #
|
||||
|
||||
def _malformed_qs(self):
|
||||
return Pedimento.objects.annotate(
|
||||
aduana_len=Length("aduana"),
|
||||
patente_len=Length("patente"),
|
||||
pedimento_len=Length("pedimento"),
|
||||
).filter(
|
||||
Q(aduana__isnull=True) | Q(aduana="") | Q(aduana_len__lt=3)
|
||||
| Q(numero_operacion__isnull=True) | Q(numero_operacion="")
|
||||
| Q(patente__isnull=True) | Q(patente="") | Q(patente_len__lt=4)
|
||||
| Q(pedimento__isnull=True) | Q(pedimento="") | Q(pedimento_len__lt=7)
|
||||
)
|
||||
|
||||
# ------------------------------------------------------------------ #
|
||||
# Diagnóstico de un pedimento
|
||||
# ------------------------------------------------------------------ #
|
||||
|
||||
def _field_checks(self, ped):
|
||||
return {
|
||||
"aduana (debe tener 3 dígitos)": not ped.aduana or len(ped.aduana.strip()) < 3,
|
||||
"numero_operacion (obligatorio)": not ped.numero_operacion or not ped.numero_operacion.strip(),
|
||||
"patente (debe tener 4 dígitos)": not ped.patente or len(ped.patente.strip()) < 4,
|
||||
"pedimento_fld (debe tener 7 dígitos)": not ped.pedimento or len(ped.pedimento.strip()) < 7,
|
||||
}
|
||||
|
||||
def _print_ped_diagnosis(self, ped, checks):
|
||||
es_malo = any(checks.values())
|
||||
estado = self.style.ERROR("MALFORMADO") if es_malo else self.style.SUCCESS("VÁLIDO")
|
||||
self.stdout.write(
|
||||
f"Pedimento {ped.pedimento_app} (id={ped.id}) → {estado}\n"
|
||||
f" aduana = {ped.aduana!r} (len={len(ped.aduana or '')})\n"
|
||||
f" patente = {ped.patente!r} (len={len(ped.patente or '')})\n"
|
||||
f" numero_op = {ped.numero_operacion!r}\n"
|
||||
f" pedimento_fld = {ped.pedimento!r} (len={len(ped.pedimento or '')})\n"
|
||||
)
|
||||
for campo, malo in checks.items():
|
||||
marca = self.style.ERROR("✗") if malo else self.style.SUCCESS("✓")
|
||||
self.stdout.write(f" {marca} {campo}")
|
||||
self.stdout.write("")
|
||||
|
||||
# ------------------------------------------------------------------ #
|
||||
# Procesamiento de un pedimento malformado
|
||||
# ------------------------------------------------------------------ #
|
||||
|
||||
def _process_pedimento(self, ped, dry_run):
|
||||
self.stdout.write(
|
||||
f"Pedimento: {ped.pedimento_app} | "
|
||||
f"aduana={ped.aduana!r} patente={ped.patente!r} num_op={ped.numero_operacion!r}"
|
||||
)
|
||||
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
|
||||
|
||||
self.stdout.write(f" Partidas con descargado=True: {n_partidas}")
|
||||
total_docs_error = 0
|
||||
|
||||
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.stdout.write("")
|
||||
return n_partidas, total_docs_error
|
||||
|
||||
# ------------------------------------------------------------------ #
|
||||
# Detección de error VUCEM en el XML
|
||||
# ------------------------------------------------------------------ #
|
||||
|
||||
def _check_vucem_error(self, doc):
|
||||
"""
|
||||
Lee el XML desde MinIO y verifica si VUCEM devolvió un error.
|
||||
Retorna ("error" | "ok" | "no_verificable", motivo: str | None).
|
||||
"""
|
||||
try:
|
||||
name = doc.archivo.name
|
||||
if not minio_client.file_exists(name):
|
||||
return "no_verificable", "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
|
||||
except Exception as 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)
|
||||
|
||||
# ------------------------------------------------------------------ #
|
||||
# Aplicación de correcciones
|
||||
# ------------------------------------------------------------------ #
|
||||
|
||||
@transaction.atomic
|
||||
def _apply_fix(self, partida, docs, 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.
|
||||
"""
|
||||
for idx, doc in enumerate(docs):
|
||||
new_name = self._build_error_filename(
|
||||
doc.archivo.name, pedimento_app, partida.numero_partida, idx
|
||||
)
|
||||
final_name = self._rename_in_storage(doc.archivo.name, new_name)
|
||||
doc.archivo = final_name
|
||||
doc.document_type_id = _PT_ERROR
|
||||
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}"
|
||||
))
|
||||
|
||||
partida.descargado = False
|
||||
partida.save(update_fields=["descargado"])
|
||||
self.stdout.write(self.style.SUCCESS(
|
||||
f" ✓ Partida {partida.numero_partida}: descargado=False"
|
||||
))
|
||||
|
||||
def _rename_in_storage(self, old_name, new_name):
|
||||
if old_name == new_name:
|
||||
return old_name
|
||||
|
||||
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}"
|
||||
))
|
||||
if minio_client.file_exists(old_name):
|
||||
minio_client.delete_file(old_name)
|
||||
return new_name
|
||||
|
||||
if not minio_client.file_exists(old_name):
|
||||
self.stderr.write(self.style.WARNING(
|
||||
f" ⚠ Archivo no encontrado en storage: {old_name}"
|
||||
))
|
||||
return old_name
|
||||
|
||||
response = minio_client._client.get_object(minio_client._bucket_name, old_name)
|
||||
try:
|
||||
content = response.read()
|
||||
finally:
|
||||
response.close()
|
||||
response.release_conn()
|
||||
|
||||
minio_client.upload_file(new_name, file_data=io.BytesIO(content), content_type="application/xml")
|
||||
minio_client.delete_file(old_name)
|
||||
return new_name
|
||||
|
||||
# ------------------------------------------------------------------ #
|
||||
# Resumen final
|
||||
# ------------------------------------------------------------------ #
|
||||
|
||||
def _print_summary(self, total_peds, total_partidas, total_docs, 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"
|
||||
)
|
||||
if dry_run:
|
||||
self.stdout.write(self.style.WARNING(
|
||||
"\nMODO PRUEBA: ejecuta sin --dry-run para aplicar los cambios."
|
||||
))
|
||||
else:
|
||||
self.stdout.write(self.style.SUCCESS("\nCorrección completada."))
|
||||
Reference in New Issue
Block a user