Fix: Se crea nuevo endpoint para subir documentos a expediente electronico.

.gitignore

@@ -178,4 +178,4 @@ cython_debug/
 #.idea/
 
 # End of https://www.toptal.com/developers/gitignore/api/django
-
+*.bak

Dockerfile

@@ -3,12 +3,17 @@ FROM python:3.11-slim
 
 WORKDIR /app
 
+# Instalar dependencias del sistema necesarias
+RUN apt-get update && apt-get install -y --no-install-recommends wget && \
+    wget https://www.rarlab.com/rar/rarlinux-x64-621.tar.gz && \
+    tar -xzvf rarlinux*.tar.gz && \
+    cp rar/unrar /usr/bin/unrar && \
+    rm -rf rarlinux*.tar.gz rar
+
 COPY requirements.txt ./
 RUN pip install --no-cache-dir -r requirements.txt
-
 RUN pip install flower
 
-
 COPY . .
 
 

Dockerfile.prod

@@ -3,8 +3,16 @@ FROM python:3.11-slim
 WORKDIR /app
 
 # Instalar dependencias del sistema
-RUN apt-get update && apt-get install -y \
+# RUN apt-get update && apt-get install -y \
+#     supervisor \
+#     && rm -rf /var/lib/apt/lists/*
+RUN apt-get update && apt-get install -y --no-install-recommends \
     supervisor \
+    wget \
+    && wget https://www.rarlab.com/rar/rarlinux-x64-621.tar.gz \
+    && tar -xzvf rarlinux*.tar.gz \
+    && cp rar/unrar /usr/bin/unrar \
+    && rm -rf rarlinux*.tar.gz rar \
     && rm -rf /var/lib/apt/lists/*
 
 # Copiar e instalar dependencias de Python

api/customs/serializers.py

@@ -9,6 +9,7 @@ from api.customs.models import (
     Partida
 )
 from django.db import models
+from django.db.models import Q
 from api.record.models import Document  # Asegúrate de importar el modelo Documento
 from api.record.serializers import DocumentSerializer  
 from api.vucem.serializers import VucemSerializer
@@ -43,6 +44,59 @@ class PedimentoSerializer(serializers.ModelSerializer):
         return rep
 
 class PartidaSerializer(serializers.ModelSerializer):
+    documentos = serializers.SerializerMethodField()
+
+    def get_documentos(self, obj):
+        """
+        Busca documentos en la tabla `document` que coincidan EXACTAMENTE con:
+        'documents/vu_PT_{pedimentoApp}_{numero}' al inicio del nombre del archivo.
+        """
+
+        if not obj or not getattr(obj, 'pedimento', None):
+            return []
+
+        if not obj or not getattr(obj, 'numero_partida', None):
+            return []
+
+        try:
+            pedimentoApp = str(obj.pedimento.pedimento_app).strip()
+            numero = str(obj.numero_partida).strip()
+
+            # Construir el patrón exacto de búsqueda
+            patron_exacto = f'documents/vu_PT_{pedimentoApp}_{numero}.xml'
+
+            # Buscar documentos que empiecen EXACTAMENTE con ese patrón
+            qs = Document.objects.filter(
+                archivo=patron_exacto
+            )
+
+            # Opción 2: Si puede tener diferentes extensiones
+            # patron_base = f'documents/vu_PT_{pedimentoApp}_{numero}'
+            # qs = Document.objects.filter(
+            #     archivo__startswith=patron_base
+            # ).filter(
+            #     archivo__in=[
+            #         f'{patron_base}.xml',
+            #         f'{patron_base}.pdf',
+            #         f'{patron_base}.zip'
+            #     ]
+            # )
+
+            # Filtro adicional por pedimento si el modelo Document tiene este campo
+            if hasattr(Document, 'pedimento'):
+                qs = qs.filter(pedimento=obj.pedimento)
+
+            # Filtro por organización
+            if hasattr(obj, 'organizacion') and obj.organizacion:
+                qs = qs.filter(organizacion=obj.organizacion)
+            
+            serializer = DocumentSerializer(qs, many=True, context=self.context)
+            return serializer.data
+            
+            #return []
+        except Exception:
+            # En caso de cualquier error (por ejemplo, importaciones circulares), devolver lista vacía
+            return []
     class Meta:
         model = Partida
         fields = '__all__'
@@ -129,6 +183,47 @@ class ProcesamientoPedimentoSerializer(serializers.ModelSerializer):
         return representation
     
 class EDocumentSerializer(serializers.ModelSerializer):
+    documentos = serializers.SerializerMethodField()
+
+    def get_documentos(self, obj):
+        """
+        Busca documentos en la tabla `document` que coincidan con el
+        `numero_edocument` dentro del nombre del archivo (`archivo`). Se
+        filtra por organización para evitar devolver documentos de otras orgs.
+        Devuelve la serialización completa de los documentos encontrados:
+        1. Empiecen con 'vu_EDOCUMENT' en el nombre del archivo
+        2. Terminen con el numero_edocument + .xml
+        3. Pertenezcan a la misma organización
+        """
+        if not obj or not getattr(obj, 'numero_edocument', None):
+            return []
+
+        if not obj or not getattr(obj, 'pedimento', None):
+            return []
+
+        # if not obj or not getattr(obj, 'pedimento_id', None):
+        #     return []
+
+        try:
+            numero = str(obj.numero_edocument).strip()
+            # id_pedimento = str(obj.pedimento_id).strip()
+
+            qs = Document.objects.filter(
+                pedimento=obj.pedimento,
+                archivo__icontains=numero,
+            )
+
+            # Filtro por organización si aplica
+            if hasattr(obj, 'organizacion') and obj.organizacion:
+                qs = qs.filter(organizacion=obj.organizacion)
+            
+            serializer = DocumentSerializer(qs, many=True, context=self.context)
+            return serializer.data
+        
+        except Exception:
+            # En caso de cualquier error (por ejemplo, importaciones circulares), devolver lista vacía
+            return []
+
     class Meta:
         model = EDocument
         fields = '__all__'
@@ -142,11 +237,48 @@ class EDocumentSerializer(serializers.ModelSerializer):
             self.fields['organizacion'].read_only = True
 
 class CoveSerializer(serializers.ModelSerializer):
+    documentos = serializers.SerializerMethodField()
+
     class Meta:
         model = Cove
         fields = '__all__'
         read_only_fields = ('created_at', 'updated_at')
 
+    def get_documentos(self, obj):
+        """
+        Busca documentos en la tabla `document` que coincidan con el
+        `numero_cove` dentro del nombre del archivo (`archivo`). Se
+        filtra por organización para evitar devolver documentos de otras orgs.
+        Devuelve la serialización completa de los documentos encontrados:
+        1. Empiecen con 'vu_COVE' en el nombre del archivo
+        2. Terminen con el numero_cove + .xml
+        3. Pertenezcan a la misma organización
+        """
+        if not obj or not getattr(obj, 'numero_cove', None):
+            return []
+
+        if not obj or not getattr(obj, 'pedimento', None):
+            return []
+
+        try:
+            numero = str(obj.numero_cove).strip()
+
+            qs = Document.objects.filter(
+                pedimento=obj.pedimento,
+                archivo__icontains=numero,
+            )
+
+            # Filtro por organización si aplica
+            if hasattr(obj, 'organizacion') and obj.organizacion:
+                qs = qs.filter(organizacion=obj.organizacion)
+            
+            serializer = DocumentSerializer(qs, many=True, context=self.context)
+            return serializer.data
+        
+        except Exception:
+            # En caso de cualquier error (por ejemplo, importaciones circulares), devolver lista vacía
+            return []
+
 class ImportadorSerializer(serializers.ModelSerializer):
     class Meta:
         model = Importador

api/record/serializers.py

@@ -9,10 +9,11 @@ from api.customs.models import Pedimento
 class DocumentSerializer(serializers.ModelSerializer):
     pedimento_numero = serializers.SerializerMethodField(read_only=True)
     pedimento = serializers.PrimaryKeyRelatedField(queryset=Pedimento.objects.all())
-
+    fuente_nombre = serializers.SerializerMethodField()
+    fuente = serializers.PrimaryKeyRelatedField(queryset=Fuente.objects.all())
     class Meta:
         model = Document
-        fields = ('id', 'organizacion', 'pedimento', 'pedimento_numero', 'archivo', 'document_type', 'size', 'extension', 'fuente','created_at', 'updated_at')
+        fields = ('id', 'organizacion', 'pedimento', 'pedimento_numero', 'archivo', 'document_type', 'size', 'extension', 'fuente','fuente_nombre','created_at', 'updated_at')
         read_only_fields = ('id', 'size', 'extension', 'created_at', 'updated_at', 'pedimento_numero')
 
     def get_pedimento_numero(self, obj):
@@ -26,6 +27,12 @@ class DocumentSerializer(serializers.ModelSerializer):
             raise serializers.ValidationError("Se requiere un archivo para subir")
         return value
 
+    def get_fuente_nombre(self, obj):
+        # Método 1: Si la fuente está precargada con select_related
+        if obj.fuente:
+            return obj.fuente.nombre
+        return "Desconocido"
+
 class FuenteSerializer(serializers.ModelSerializer):
     class Meta:
         model = Fuente

api/record/urls.py

@@ -4,12 +4,21 @@ from rest_framework.routers import DefaultRouter
 
 # import necessary viewsets
 # from .views import YourViewSet  # Import your viewsets here
-from .views import  DocumentViewSet, ProtectedDocumentDownloadView, BulkDownloadZipView, GetFuenteView, DocumentTypeView
+from .views import  (DocumentViewSet
+                     , ProtectedDocumentDownloadView
+                     , BulkDownloadZipView
+                     , GetFuenteView
+                     , DocumentTypeView
+                     , ExpedienteZipDownloadView
+                     , MultiPedimentoZipDownloadView
+                     , PedimentoDocumentViewSet)
+
+
 # Create a router and register your viewsets with it
 
 router = DefaultRouter()
 
-# Register your viewsets with the router here
+# Register your viewsets with the router he -fre
 # Example:
 # from .views import MyViewSet
 # router.register(r'myviewset', MyViewSet, basename='myviewset')
@@ -23,5 +32,8 @@ urlpatterns = [
     path('documents/descargar/<uuid:pk>/', ProtectedDocumentDownloadView.as_view(), name='descargar-documento'),
     path('fuente/', GetFuenteView.as_view(), name='get-fuente'),
     path('document-type/', DocumentTypeView.as_view(), name='document-type-list-create'),
+    path('documents/expediente-zip/', ExpedienteZipDownloadView.as_view(), name='expediente-zip-download'),
+    path('documents/multi-pedimento-zip/', MultiPedimentoZipDownloadView.as_view(), name='multi-pedimento-zip-download'),
+    path('pedimento-documents/', PedimentoDocumentViewSet.as_view({'get': 'list'}), name='pedimento-document-list'),
     path('', include(router.urls)),
 ]

api/record/views.py

@@ -13,6 +13,7 @@ from rest_framework.exceptions import ValidationError
 
 from .serializers import DocumentSerializer, FuenteSerializer, DocumentTypeSerializer
 from .models import Document, Fuente, DocumentType
+from ..customs.models import Pedimento
 from api.organization.models import UsoAlmacenamiento
 from io import BytesIO
 import zipfile
@@ -32,6 +33,9 @@ from core.permissions import (
 import logging
 logger = logging.getLogger(__name__)
 
+import os
+from django.core.files.storage import default_storage
+
 from mixins.filtrado_organizacion import DocumentosFiltradosMixin
 
 class CustomPagination(PageNumberPagination):
@@ -59,7 +63,8 @@ class DocumentViewSet(viewsets.ModelViewSet, DocumentosFiltradosMixin):
     pagination_class = CustomPagination
     serializer_class = DocumentSerializer
     # Habilitar filtro por pedimento (UUID) y pedimento_numero (campo pedimento del modelo relacionado)
-    filterset_fields = ['extension', 'size', 'document_type', 'pedimento', 'pedimento__pedimento']
+    filterset_fields = ['extension', 'size', 'document_type', 'pedimento', 'pedimento__pedimento', 'created_at']
+    # filterset_fields = ['extension', 'size', 'pedimento', 'pedimento__pedimento']
 
     # Puedes filtrar por pedimento usando: /api/record/documents/?pedimento=<id> o /api/record/documents/?pedimento__pedimento=<numero>
     # Ejemplo: /api/record/documents/?pedimento_numero=12345678
@@ -67,6 +72,33 @@ class DocumentViewSet(viewsets.ModelViewSet, DocumentosFiltradosMixin):
 
     def get_queryset(self):
         queryset = self.get_queryset_filtrado_por_organizacion()
+
+        modulo_efc = self.request.query_params.get('modulo')
+        if modulo_efc:
+            if modulo_efc == 'expedientes-detalle-pedimentos':
+                queryset = queryset.exclude(document_type_id__in=['1','2','3','4','5','6','7','8','9','10'])
+                # Filtro personalizado por document_type
+                # document_type = self.request.query_params.get('document_type')
+                # if document_type:
+                #     # Puedes agregar lógica personalizada aquí si es necesario
+                #     if document_type == '1':
+                #         queryset = queryset.filter(document_type_id=document_type)
+                #     elif document_type == '2':
+                #         queryset = queryset.filter(document_type_id=document_type)
+                #     else:
+                #         queryset = queryset.filter(document_type_id=document_type)
+                # else:
+                #     queryset = queryset.filter(document_type_id='11')
+
+        fechaCreacion = self.request.query_params.get('created_at__date')
+        if fechaCreacion:
+            queryset = queryset.filter(created_at=fechaCreacion)
+
+        buscarArchivo = self.request.query_params.get('archivo__icontains')
+        if buscarArchivo:
+            queryset = queryset.filter(archivo__icontains=buscarArchivo)
+
+
         pedimento_numero = self.request.query_params.get('pedimento_numero')
         if pedimento_numero:
             queryset = queryset.filter(pedimento__pedimento_app=pedimento_numero)
@@ -531,7 +563,6 @@ class ProtectedDocumentDownloadView(APIView, DocumentosFiltradosMixin):
         if not request.user.is_authenticated or not hasattr(request.user, 'organizacion'):
             raise Http404("Usuario no autenticado")
 
-
         try:
             doc = Document.objects.get(pk=pk)
         except Document.DoesNotExist:
@@ -618,3 +649,191 @@ class DocumentTypeView(APIView):
             return Response({"detail": "No hay tipos de documento disponibles."}, status=404)
         serializer = self.serializer_class(queryset, many=True)
         return Response(serializer.data, status=200)
+    
+class ExpedienteZipDownloadView(APIView, DocumentosFiltradosMixin):
+    permission_classes = [IsAuthenticated &  (IsSameOrganization | IsSameOrganizationAndAdmin | IsSameOrganizationDeveloper | IsSuperUser)]
+    my_tags = ['Documents']
+
+    def post(self, request):
+        """
+        Descarga todos los documentos de un pedimento (o filtrados) en un ZIP.
+        Body: { "pedimento_id": "<uuid>" }
+        """
+        pedimento_id = request.data.get('pedimento_id')
+        if not pedimento_id:
+            return Response({"error": "Falta pedimento_id"}, status=status.HTTP_400_BAD_REQUEST)
+
+        # Validar que el pedimento existe
+        try:
+            pedimento = Pedimento.objects.get(pk=pedimento_id)
+        except Pedimento.DoesNotExist:
+            raise Http404("Pedimento no encontrado")
+
+        # Filtrar documentos del pedimento (y de la org del usuario)
+        base_qs = Document.objects.filter(pedimento=pedimento)
+        if not request.user.is_superuser:
+            if not hasattr(request.user, 'organizacion') or request.user.organizacion != pedimento.organizacion:
+                return Response({"error": "No autorizado"}, status=status.HTTP_403_FORBIDDEN)
+            base_qs = base_qs.filter(organizacion=request.user.organizacion)
+
+        docs = base_qs.select_related('pedimento')
+        if not docs.exists():
+            return Response({"error": "No hay documentos para este pedimento"}, status=status.HTTP_404_NOT_FOUND)
+
+        # 1. Crear un único buffer y ZIP para todos los archivos
+        buffer = BytesIO()
+        missing_files = []  # opcional: para informar después
+        files_found = [] 
+
+        with zipfile.ZipFile(buffer, 'w', zipfile.ZIP_DEFLATED) as zip_file:
+            for doc in docs:
+                # 2. Validaciones
+                if not doc.archivo.name:
+                    logger.warning("Documento %s no tiene archivo asociado", doc.id)
+                    missing_files.append(f"{doc.id} (sin archivo)")
+                    continue
+                if not default_storage.exists(doc.archivo.name):
+                    logger.warning("Archivo no encontrado en disco: %s", doc.archivo.path)
+                    missing_files.append(f"{doc.id} ({doc.archivo.name})")
+                    continue
+
+                files_found.append(f"{doc.id} ({doc.archivo.name})")
+
+                # 3. Nombre seguro para dentro del ZIP
+                file_name = slugify(doc.archivo.name.rsplit('/', 1)[-1].rsplit('.', 1)[0])
+                ext = doc.archivo.name.split('.')[-1]
+                name_inside_zip = f"{file_name}.{ext}"
+
+                # 4. Escribir el archivo dentro del ZIP
+                with doc.archivo.open('rb') as f:
+                    zip_file.writestr(name_inside_zip, f.read())
+
+        # 5. Preparar respuesta
+        buffer.seek(0)
+        zip_name = slugify(f"expediente_{pedimento.pedimento_app}")
+        response = HttpResponse(buffer, content_type='application/zip')
+        response['Content-Disposition'] = f'attachment; filename={zip_name or "documentos"}.zip'
+
+        if not files_found:
+            return Response({"error": f"No hay documentos para este pedimento: {pedimento.pedimento_app}"}, status=status.HTTP_404_NOT_FOUND)
+
+        # (Opcional) cabecera personalizada si faltaron archivos
+        # if missing_files:
+            # response['X-Missing-Files'] = ', '.join(missing_files)
+            # return Response({"error": f"No hay documentos para este pedimento: {pedimento.pedimento_app}"}, status=status.HTTP_404_NOT_FOUND)
+
+        return response
+
+class MultiPedimentoZipDownloadView(APIView):
+    permission_classes = [IsAuthenticated & (IsSuperUser | IsSameOrganization | IsSameOrganizationAndAdmin | IsSameOrganizationDeveloper)]
+    my_tags = ['Documents']
+
+    def post(self, request):
+        """
+        Descarga todos los documentos de VARIOS pedimentos en un solo ZIP.
+        Body: { "pedimento_ids": ["uuid1", "uuid2", ...] }
+        """
+        pedimento_ids = request.data.get('pedimento_ids', [])
+        if not isinstance(pedimento_ids, list) or not pedimento_ids:
+            return Response({"error": "Se requiere una lista de pedimento_ids"}, status=status.HTTP_400_BAD_REQUEST)
+
+        # Filtrar pedimentos visibles para el usuario
+        base_qs = Pedimento.objects.filter(id__in=pedimento_ids)
+        if not request.user.is_superuser:
+            if not hasattr(request.user, 'organizacion'):
+                return Response({"error": "No autorizado"}, status=status.HTTP_403_FORBIDDEN)
+            base_qs = base_qs.filter(organizacion=request.user.organizacion)
+
+        pedimentos = base_qs.select_related('organizacion')
+        if not pedimentos.exists():
+            return Response({"error": "Ningún pedimento encontrado o autorizado"}, status=status.HTTP_404_NOT_FOUND)
+
+        # Obtener todos los documentos de esos pedimentos
+        docs = Document.objects.filter(pedimento__in=pedimentos)
+        if not docs.exists():
+            return Response({"error": "No hay documentos para estos pedimentos"}, status=status.HTTP_404_NOT_FOUND)
+
+        # Crear ZIP único
+        buffer = BytesIO()
+        missing_files = []
+        summary = {}
+        with zipfile.ZipFile(buffer, 'w', zipfile.ZIP_DEFLATED) as zip_file:
+            for doc in docs:
+
+                ped_key = doc.pedimento.pedimento_app
+
+                if not doc.archivo.name or not default_storage.exists(doc.archivo.name):
+                    missing_files.append(f"{doc.id} ({doc.archivo.name or 'sin archivo'})")
+                    logger.warning("Archivo faltante: %s", doc.id)
+                    continue
+
+                summary[ped_key] = summary.get(ped_key, 0) + 1
+
+                # Nombre seguro: pedimento_app + nombre del archivo
+                file_name = slugify(doc.archivo.name.rsplit('/', 1)[-1].rsplit('.', 1)[0])
+                ext = doc.archivo.name.split('.')[-1]
+                name_inside_zip = f"{doc.pedimento.pedimento_app}/{file_name}.{ext}"
+
+                with doc.archivo.open('rb') as f:
+                    zip_file.writestr(name_inside_zip, f.read())
+
+        buffer.seek(0)
+        zip_name = slugify(f"expedientes_{len(summary)}_pedimentos")
+
+        response = HttpResponse(buffer, content_type='application/zip')
+        response['Content-Disposition'] = f'attachment; filename={zip_name}.zip'
+        response['X-Zip-Filename'] = f"{zip_name}.zip"
+        response['Access-Control-Expose-Headers'] = 'X-Zip-Filename'
+
+        if missing_files:
+            response['X-Missing-Files'] = ', '.join(missing_files)
+
+        return response
+
+class PedimentoDocumentViewSet(viewsets.ModelViewSet, DocumentosFiltradosMixin):
+    """
+    ViewSet for Document model.
+    """
+    permission_classes = [IsAuthenticated &  (IsSuperUser | IsSameOrganization | IsSameOrganizationAndAdmin | IsSameOrganizationDeveloper )]
+    model = Document
+    
+    pagination_class = CustomPagination
+    serializer_class = DocumentSerializer
+    # Habilitar filtro por pedimento (UUID) y pedimento_numero (campo pedimento del modelo relacionado)
+    # filterset_fields = ['extension', 'size', 'document_type', 'pedimento', 'pedimento__pedimento']
+    filterset_fields = ['extension', 'size', 'pedimento', 'pedimento__pedimento','fuente']
+
+    # Puedes filtrar por pedimento usando: /api/record/documents/?pedimento=<id> o /api/record/documents/?pedimento__pedimento=<numero>
+    # Ejemplo: /api/record/documents/?pedimento_numero=12345678
+    my_tags = ['Documents']
+
+    def get_queryset(self):
+        queryset = self.get_queryset_filtrado_por_organizacion()
+
+        # Tipos de documento permitidos (fijos en código, Pedimento completo y remesas) 
+        TIPOS_PERMITIDOS = ['2', '3']  # <-- Ajusta aquí tus tipos
+        tipo_documento = self.request.query_params.get('document_type')
+        if tipo_documento:
+            queryset = queryset.filter(document_type_id=tipo_documento)
+        else:
+            # Filtrar por tipos permitidos
+            queryset = queryset.filter(document_type_id__in=TIPOS_PERMITIDOS)
+
+        buscar_archivo = self.request.query_params.get('archivo__icontains')
+        if buscar_archivo:
+            queryset = queryset.filter(archivo__icontains=buscar_archivo)
+
+        created_at__date = self.request.query_params.get('created_at__date')
+        if created_at__date:
+            queryset = queryset.filter(created_at=created_at__date)
+
+        # Filtro adicional por pedimento_numero si se proporciona
+        pedimento_numero = self.request.query_params.get('pedimento_numero')
+        if pedimento_numero:
+            queryset = queryset.filter(pedimento__pedimento_app=pedimento_numero)
+
+        return queryset
+
+
+
+