EFC/backend
5
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Mudanza de repo

Browse Source
This commit is contained in:
Kevin Rosales
2025-09-22 18:43:29 -06:00
parent 26fe36ca52
commit d11d543bdc
193 changed files with 10998 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
api/customs/tasks/__init__.py Normal file
View File

@@ -0,0 +1,2 @@
from .microservice import *
from .internal_services import *

78
api/customs/tasks/auditoria.py Normal file
View File

@@ -0,0 +1,78 @@
from celery import shared_task, group
from api.customs.models import ProcesamientoPedimento, Pedimento, Cove, EDocument
from core.utils import xml_controller
import requests
from core.utils import xml_remesas_controller
def obtener_pedimentos(organizacion_id):
return Pedimento.objects.filter(organizacion_id=organizacion_id)
def extraer_coves(pedimento):
remesas = pedimento.documents.filter(document_type=3).first()
with open(f'./media/{remesas.archivo}', 'r') as f:
xml_content = f.read()
xml_data = xml_remesas_controller.extract_remesas(xml_content)
return xml_data
@shared_task
def auditar_procesamiento_remesas(organizacion_id):
pedimentos = obtener_pedimentos(organizacion_id)
for pedimento in pedimentos:
if pedimento.remesas:
# Tipo 3: Remesa
if not pedimento.documents.filter(document_type=3).exists():
ProcesamientoPedimento.objects.get_or_create(
pedimento=pedimento,
servicio_id=5, # ID del servicio de remesas
organizacion=organizacion_id
)
else:
xml_data = extraer_coves(pedimento)
if xml_data:
for remesa in xml_data:
Cove.objects.get_or_create(
pedimento=pedimento,
numero_cove=remesa.get('remesaSA'),
organizacion=organizacion_id
)
@shared_task
def auditar_partidas(organizacion_id):
pedimentos = Pedimento.objects.filter(organizacion_id=organizacion_id)
for pedimento in pedimentos:
partidas_descargadas = pedimento.documents.filter(document_type=1)
partidas = {str(documento.archivo).split('_')[-1].split('.')[0]: documento.archivo for documento in partidas_descargadas}
partidas_faltantes = []
for i in range(1, pedimento.numero_partidas + 1):
if str(i) not in partidas.keys():
partidas_faltantes.append(i)
# crear servicio individual para cada partida faltante en microservicios
@shared_task
def auditar_coves(organizacion_id):
# crear servicio individual para cada cove faltante en microservicios
pass
@shared_task
def auditar_edocuments(organizacion_id):
# crear servicio individual para cada Edocument faltante en microservicios
pass
@shared_task
def auditar_acuse_coves(organizacion_id):
# crear servicio individual para cada cove faltante en microservicios
pass
@shared_task
def auditar_acuse_edocuments(organizacion_id):
# crear servicio individual para cada acuse de edocument faltante en microservicios
pass

220
api/customs/tasks/internal_services.py Normal file
View File

@@ -0,0 +1,220 @@
from celery import shared_task, group
from api.customs.models import ProcesamientoPedimento, Pedimento, Cove, EDocument
from core.utils import xml_controller
@shared_task
def crear_procesamiento_remesa(pedimento_id):
import logging
logger = logging.getLogger('api.customs.async_operations')
pedimento = Pedimento.objects.get(id=pedimento_id)
logger.info(f"[TAREA] crear_procesamiento_remesa para pedimento {pedimento_id}")
if pedimento.remesas:
existe = ProcesamientoPedimento.objects.filter(
pedimento=pedimento,
servicio_id=5, # ID del servicio de remesas
organizacion=pedimento.organizacion,
estado_id__in=[1, 2, 3, 4]
).exists()
if not existe:
logger.info(f"[TAREA] ProcesamientoPedimento remesa creado para pedimento {pedimento_id}")
ProcesamientoPedimento.objects.create(
pedimento=pedimento,
estado_id=1, # Estado "pendiente"
servicio_id=5,
organizacion=pedimento.organizacion
)
@shared_task
def crear_procesamiento_partida(pedimento_id):
import logging
logger = logging.getLogger('api.customs.async_operations')
pedimento = Pedimento.objects.get(id=pedimento_id)
logger.info(f"[TAREA] crear_procesamiento_partida para pedimento {pedimento_id}")
existe = ProcesamientoPedimento.objects.filter(
pedimento=pedimento,
servicio_id=4, # ID del servicio de partidas
organizacion=pedimento.organizacion,
estado_id__in=[1, 2, 3, 4]
).exists()
if not existe:
logger.info(f"[TAREA] ProcesamientoPedimento partida creado para pedimento {pedimento_id}")
ProcesamientoPedimento.objects.create(
pedimento=pedimento,
estado_id=1, # Estado "pendiente"
servicio_id=4,
organizacion=pedimento.organizacion
)
@shared_task
def crear_procesamiento_cove(pedimento_id):
import logging
logger = logging.getLogger('api.customs.async_operations')
pedimento = Pedimento.objects.get(id=pedimento_id)
logger.info(f"[TAREA] crear_procesamiento_cove para pedimento {pedimento_id}")
if pedimento.coves.exists():
existe = ProcesamientoPedimento.objects.filter(
pedimento=pedimento,
servicio_id=8, # ID del servicio de Coves
organizacion=pedimento.organizacion,
estado_id__in=[1, 2, 3, 4]
).exists()
if not existe:
logger.info(f"[TAREA] ProcesamientoPedimento cove creado para pedimento {pedimento_id}")
ProcesamientoPedimento.objects.create(
pedimento=pedimento,
estado_id=1, # Estado "pendiente"
servicio_id=8,
organizacion=pedimento.organizacion
)
@shared_task
def crear_procesamiento_acuse(pedimento_id):
import logging
logger = logging.getLogger('api.customs.async_operations')
pedimento = Pedimento.objects.get(id=pedimento_id)
logger.info(f"[TAREA] crear_procesamiento_acuse para pedimento {pedimento_id}")
if pedimento.coves.exists():
existe = ProcesamientoPedimento.objects.filter(
pedimento=pedimento,
servicio_id=6, # ID del servicio de Acuse Cove
organizacion=pedimento.organizacion,
estado_id__in=[1, 2, 3, 4]
).exists()
if not existe:
logger.info(f"[TAREA] ProcesamientoPedimento acuse creado para pedimento {pedimento_id}")
ProcesamientoPedimento.objects.create(
pedimento=pedimento,
estado_id=1, # Estado "pendiente"
servicio_id=6,
organizacion=pedimento.organizacion
)
@shared_task
def crear_procesamiento_acuse_cove(pedimento_id):
import logging
logger = logging.getLogger('api.customs.async_operations')
pedimento = Pedimento.objects.get(id=pedimento_id)
logger.info(f"[TAREA] crear_procesamiento_acuse_cove para pedimento {pedimento_id}")
if pedimento.coves.exists():
existe = ProcesamientoPedimento.objects.filter(
pedimento=pedimento,
servicio_id=9, # ID del servicio de Acuse Cove
organizacion=pedimento.organizacion,
estado_id__in=[1, 2, 3, 4]
).exists()
if not existe:
logger.info(f"[TAREA] ProcesamientoPedimento acuse_cove creado para pedimento {pedimento_id}")
ProcesamientoPedimento.objects.create(
pedimento=pedimento,
estado_id=1, # Estado "pendiente"
servicio_id=9,
organizacion=pedimento.organizacion
)
@shared_task
def crear_procesamiento_edocument(pedimento_id):
import logging
logger = logging.getLogger('api.customs.async_operations')
pedimento = Pedimento.objects.get(id=pedimento_id)
logger.info(f"[TAREA] crear_procesamiento_edocument para pedimento {pedimento_id}")
if pedimento.documentos.exists():
existe = ProcesamientoPedimento.objects.filter(
pedimento=pedimento,
servicio_id=7, # ID del servicio de EDocument
organizacion=pedimento.organizacion,
estado_id__in=[1, 2, 3, 4]
).exists()
if not existe:
logger.info(f"[TAREA] ProcesamientoPedimento edocument creado para pedimento {pedimento_id}")
ProcesamientoPedimento.objects.create(
pedimento=pedimento,
estado_id=1, # Estado "pendiente"
servicio_id=7,
organizacion=pedimento.organizacion
)
@shared_task
def crear_procesamiento_pedimento_completo(organizacion_id):
import logging
logger = logging.getLogger('api.customs.async_operations')
pedimentos = Pedimento.objects.filter(organizacion_id=organizacion_id)
for pedimento in pedimentos:
logger.info(f"[TAREA] crear_procesamiento_pedimento_completo para pedimento {pedimento.id}")
existe = ProcesamientoPedimento.objects.filter(
pedimento=pedimento,
servicio_id=3, # ID del servicio de Pedimento Completo
organizacion=pedimento.organizacion,
estado_id__in=[1, 2, 3, 4]
).exists()
if not existe:
logger.info(f"[TAREA] ProcesamientoPedimento pedimento_completo creado para pedimento {pedimento.id}")
ProcesamientoPedimento.objects.create(
pedimento=pedimento,
estado_id=1, # Estado "pendiente"
servicio_id=3,
organizacion=pedimento.organizacion
)
@shared_task
def crear_servicios(organizacion_id):
pedimentos = Pedimento.objects.filter(organizacion=organizacion_id)
for pedimento in pedimentos:
crear_procesamiento_remesa.apply_async(args=[str(pedimento.id)])
crear_procesamiento_partida.apply_async(args=[str(pedimento.id)])
crear_procesamiento_cove.apply_async(args=[str(pedimento.id)])
crear_procesamiento_acuse.apply_async(args=[str(pedimento.id)])
crear_procesamiento_acuse_cove.apply_async(args=[str(pedimento.id)])
crear_procesamiento_edocument.apply_async(args=[str(pedimento.id)])
@shared_task
def auditar_pedimento(organizacion_id):
pedimentos = Pedimento.objects.filter(organizacion_id=organizacion_id)
for pedimento in pedimentos:
pc = pedimento.documents.filter(document_type__id=2).first()
if pc:
with open(f'./media/{pc.archivo}', 'r') as f:
xml_content = f.read()
xml_data = xml_controller.extract_data(xml_content)
pedimento.numero_operacion = xml_data.get('numero_operacion')
pedimento.curp_apoderado = xml_data.get('curp_apoderado')
pedimento.agente_aduanal = xml_data.get('agente_aduanal')
pedimento.numero_partidas = xml_data.get('numero_partidas')
pedimento.remesas = xml_data.get('remesas')
pedimento.tipo_operacion__id = xml_data.get('tipo_operacion')
pedimento.save()
for edoc in xml_data.get('edocuments', []):
EDocument.objects.get_or_create(
pedimento=pedimento,
organizacion=pedimento.organizacion,
clave=edoc.get('clave'),
descripcion=edoc.get('descripcion'),
numero_edocument=edoc.get('complemento1')
)
from django.db import IntegrityError
try:
for cove in xml_data.get('coves', []):
try:
Cove.objects.get_or_create(
pedimento=pedimento,
organizacion=pedimento.organizacion,
numero_cove=cove
)
except IntegrityError:
# Si ya existe por unique, recupera el objeto existente
Cove.objects.get(numero_cove=cove)
except:
# Si ya existe por unique, recupera el objeto existente
pass
@shared_task
def crear_todos_los_servicios():
from organization.models import Organizacion
organizaciones = Organizacion.objects.all()
for org in organizaciones:
crear_procesamiento_pedimento_completo.apply_async(args=[str(org.id)])
crear_servicios.apply_async(args=[str(org.id)])

213
api/customs/tasks/microservice.py Normal file
View File

@@ -0,0 +1,213 @@
from celery import shared_task, group
from api.customs.models import ProcesamientoPedimento
import requests
from config.settings import SERVICE_API_URL
from datetime import datetime
# ===================
# Pedimento Completo
# ===================
@shared_task
def procesar_pedimento_completo_individual(pedimento_id, organizacion_id):
response = requests.post(
f"{SERVICE_API_URL}/async/services/pedimento_completo",
json={"pedimento": str(pedimento_id), "organizacion": str(organizacion_id)}
)
if response.status_code == 200:
print(f"Pedimento {pedimento_id} procesado correctamente.")
else:
print(f"Error al procesar el pedimento {pedimento_id}: {response.status_code} - {response.text}")
print(f"Disparando evento para procesamiento {pedimento_id}")
@shared_task
def ejecutar_pedimento_completo():
pendientes = ProcesamientoPedimento.objects.filter(estado=1, servicio=3)
batch_size = 20
ids = list(pendientes.values_list('pedimento_id', 'organizacion_id'))
for i in range(0, len(ids), batch_size):
batch = ids[i:i+batch_size]
job = group(procesar_pedimento_completo_individual.s(ped_id, org_id) for ped_id, org_id in batch)
job.apply_async()
# Validar horario permitido (5:00 a 22:00)
ahora = datetime.now().time()
if (ahora < datetime.strptime('05:00', '%H:%M').time()) or (ahora >= datetime.strptime('22:00', '%H:%M').time()):
print('ejecutar_pedimento_completo: fuera de horario permitido (5:00-22:00). Abortando.')
return
# ===================
# Partidas
# ===================
@shared_task
def procesar_partida_individual(pedimento_id, organizacion_id):
response = requests.post(
f"{SERVICE_API_URL}/async/services/partidas",
json={"pedimento": str(pedimento_id), "organizacion": str(organizacion_id)}
)
if response.status_code == 200:
print(f"Partidas del pedimento {pedimento_id} procesadas correctamente.")
else:
print(f"Error al procesar partidas del pedimento {pedimento_id}: {response.status_code} - {response.text}")
print(f"Disparando evento para procesamiento {pedimento_id}")
@shared_task
def ejecutar_partidas_pedimento():
pendientes = ProcesamientoPedimento.objects.filter(estado=1, servicio=4)
batch_size = 20
ids = list(pendientes.values_list('pedimento_id', 'organizacion_id'))
for i in range(0, len(ids), batch_size):
batch = ids[i:i+batch_size]
job = group(procesar_partida_individual.s(ped_id, org_id) for ped_id, org_id in batch)
job.apply_async()
# Validar horario permitido (5:00 a 22:00)
ahora = datetime.now().time()
if (ahora < datetime.strptime('05:00', '%H:%M').time()) or (ahora >= datetime.strptime('22:00', '%H:%M').time()):
print('ejecutar_partidas_pedimento: fuera de horario permitido (5:00-22:00). Abortando.')
return
# ===================
# Remesas
# ===================
@shared_task
def procesar_remesa_individual(pedimento_id, organizacion_id):
response = requests.post(
f"{SERVICE_API_URL}/async/services/remesas",
json={"pedimento": str(pedimento_id), "organizacion": str(organizacion_id)}
)
if response.status_code == 200:
print(f"Remesas del pedimento {pedimento_id} procesadas correctamente.")
else:
print(f"Error al procesar remesas del pedimento {pedimento_id}: {response.status_code} - {response.text}")
print(f"Disparando evento para procesamiento {pedimento_id}")
@shared_task
def ejecutar_remesas():
pendientes = ProcesamientoPedimento.objects.filter(estado=1, servicio=5)
batch_size = 20
ids = list(pendientes.values_list('pedimento_id', 'organizacion_id'))
for i in range(0, len(ids), batch_size):
batch = ids[i:i+batch_size]
job = group(procesar_remesa_individual.s(ped_id, org_id) for ped_id, org_id in batch)
job.apply_async()
# Validar horario permitido (5:00 a 22:00)
ahora = datetime.now().time()
if (ahora < datetime.strptime('05:00', '%H:%M').time()) or (ahora >= datetime.strptime('22:00', '%H:%M').time()):
print('ejecutar_remesas: fuera de horario permitido (5:00-22:00). Abortando.')
return
# ===================
# Acuses
# ===================
@shared_task
def procesar_acuse_individual(pedimento_id, organizacion_id):
response = requests.post(
f"{SERVICE_API_URL}/async/services/acuse",
json={"pedimento": str(pedimento_id), "organizacion": str(organizacion_id)}
)
if response.status_code == 200:
print(f"Acuses del pedimento {pedimento_id} procesadas correctamente.")
else:
print(f"Error al procesar Acuses del pedimento {pedimento_id}: {response.status_code} - {response.text}")
print(f"Disparando evento para procesamiento {pedimento_id}")
@shared_task
def ejecutar_acuse():
pendientes = ProcesamientoPedimento.objects.filter(estado=1, servicio=6)
batch_size = 20
ids = list(pendientes.values_list('pedimento_id', 'organizacion_id'))
for i in range(0, len(ids), batch_size):
batch = ids[i:i+batch_size]
job = group(procesar_acuse_individual.s(ped_id, org_id) for ped_id, org_id in batch)
job.apply_async()
# Validar horario permitido (5:00 a 22:00)
ahora = datetime.now().time()
if (ahora < datetime.strptime('05:00', '%H:%M').time()) or (ahora >= datetime.strptime('22:00', '%H:%M').time()):
print('ejecutar_acuse: fuera de horario permitido (5:00-22:00). Abortando.')
return
# ===================
# Edocuments
# ===================
@shared_task
def procesar_edoc_individual(pedimento_id, organizacion_id):
response = requests.post(
f"{SERVICE_API_URL}/async/services/edocument",
json={"pedimento": str(pedimento_id), "organizacion": str(organizacion_id)}
)
if response.status_code == 200:
print(f"Edocuments del pedimento {pedimento_id} procesadas correctamente.")
else:
print(f"Error al procesar Edocuments del pedimento {pedimento_id}: {response.status_code} - {response.text}")
print(f"Disparando evento para procesamiento {pedimento_id}")
@shared_task
def ejecutar_edocs():
pendientes = ProcesamientoPedimento.objects.filter(estado=1, servicio=7)
batch_size = 20
ids = list(pendientes.values_list('pedimento_id', 'organizacion_id'))
for i in range(0, len(ids), batch_size):
batch = ids[i:i+batch_size]
job = group(procesar_edoc_individual.s(ped_id, org_id) for ped_id, org_id in batch)
job.apply_async()
# ===================
# Coves
# ===================
@shared_task
def procesar_cove_individual(pedimento_id, organizacion_id):
response = requests.post(
f"{SERVICE_API_URL}/async/services/coves",
json={"pedimento": str(pedimento_id), "organizacion": str(organizacion_id)}
)
if response.status_code == 200:
print(f"Coves del pedimento {pedimento_id} procesadas correctamente.")
else:
print(f"Error al procesar Coves del pedimento {pedimento_id}: {response.status_code} - {response.text}")
print(f"Disparando evento para procesamiento {pedimento_id}")
@shared_task
def ejecutar_coves():
pendientes = ProcesamientoPedimento.objects.filter(estado=1, servicio=8)
batch_size = 20
ids = list(pendientes.values_list('pedimento_id', 'organizacion_id'))
for i in range(0, len(ids), batch_size):
batch = ids[i:i+batch_size]
job = group(procesar_cove_individual.s(ped_id, org_id) for ped_id, org_id in batch)
job.apply_async()
# Validar horario permitido (5:00 a 22:00)
ahora = datetime.now().time()
if (ahora < datetime.strptime('05:00', '%H:%M').time()) or (ahora >= datetime.strptime('22:00', '%H:%M').time()):
print('ejecutar_coves: fuera de horario permitido (5:00-22:00). Abortando.')
return
# ===================
# Acuse Cove
# ===================
@shared_task
def procesar_acuse_cove_individual(pedimento_id, organizacion_id):
response = requests.post(
f"{SERVICE_API_URL}/async/services/acuse-cove",
json={"pedimento": str(pedimento_id), "organizacion": str(organizacion_id)}
)
if response.status_code == 200:
print(f"Coves del pedimento {pedimento_id} procesadas correctamente.")
else:
print(f"Error al procesar Coves del pedimento {pedimento_id}: {response.status_code} - {response.text}")
print(f"Disparando evento para procesamiento {pedimento_id}")
@shared_task
def ejecutar_acuseCoves():
pendientes = ProcesamientoPedimento.objects.filter(estado=1, servicio=9)
batch_size = 20
ids = list(pendientes.values_list('pedimento_id', 'organizacion_id'))
for i in range(0, len(ids), batch_size):
batch = ids[i:i+batch_size]
job = group(procesar_acuse_cove_individual.s(ped_id, org_id) for ped_id, org_id in batch)
job.apply_async()
# Validar horario permitido (5:00 a 22:00)
ahora = datetime.now().time()
if (ahora < datetime.strptime('05:00', '%H:%M').time()) or (ahora >= datetime.strptime('22:00', '%H:%M').time()):
print('ejecutar_acuseCoves: fuera de horario permitido (5:00-22:00). Abortando.')
return