MinIO S3 Storage Integration

import os
from django.conf import settings
from storages.backends.s3boto3 import S3Boto3Storage

class MinIOStorage(S3Boto3Storage):
    """
    Clase de almacenamiento personalizada para forzar el uso de MinIO/S3
    independientemente del STORAGE default (util para Planos y otros archivos criticos).
    """
    def __init__(self, *args, **kwargs):
        # Asegurar que tome las credenciales de MinIO aunque el default sea local
        kwargs.setdefault('access_key', getattr(settings, 'AWS_ACCESS_KEY_ID', None))
        kwargs.setdefault('secret_key', getattr(settings, 'AWS_SECRET_ACCESS_KEY', None))
        kwargs.setdefault('bucket_name', getattr(settings, 'AWS_STORAGE_BUCKET_NAME', None))
        kwargs.setdefault('endpoint_url', getattr(settings, 'AWS_S3_ENDPOINT_URL', None))
        kwargs.setdefault('use_ssl', getattr(settings, 'AWS_S3_USE_SSL', True))
        kwargs.setdefault('verify', getattr(settings, 'AWS_S3_VERIFY', False))
        super().__init__(*args, **kwargs)

from core.storage import MinIOStorage
from django.db import models

class Plano(models.Model):
    nombre = models.CharField(max_length=200)
    # Force MinIO storage for critical files
    archivo = models.FileField(
        upload_to='planos/',
        storage=MinIOStorage(),  # Explicit MinIO
        null=True,
        blank=True
    )

class Activo(models.Model):
    nombre = models.CharField(max_length=200)
    # Use default storage (configured in settings)
    foto = models.ImageField(
        upload_to='activos/',
        null=True,
        blank=True
    )

# File upload configuration
DATA_UPLOAD_MAX_MEMORY_SIZE = 10 * 1024 * 1024   # 10 MB (in-memory)
FILE_UPLOAD_MAX_MEMORY_SIZE = 50 * 1024 * 1024   # 50 MB (before streaming)
DATA_UPLOAD_MAX_NUMBER_FIELDS = 100000            # For large forms

from django.core.files.storage import default_storage
import uuid

def upload_documento(request):
    if request.method == 'POST' and request.FILES.get('archivo'):
        archivo = request.FILES['archivo']
        
        # Generate unique filename
        ext = archivo.name.split('.')[-1]
        filename = f"documentos/{uuid.uuid4()}.{ext}"
        
        # Save to MinIO
        path = default_storage.save(filename, archivo)
        url = default_storage.url(path)
        
        # Create database record
        documento = Documento.objects.create(
            titulo=archivo.name,
            archivo=path
        )
        
        return JsonResponse({
            'id': documento.id,
            'url': url
        })

from django.http import StreamingHttpResponse
import requests

def media_proxy(request, path):
    """
    Proxy requests to MinIO to avoid mixed content warnings
    """
    # Internal MinIO URL
    minio_url = f"{settings.AWS_S3_ENDPOINT_URL}/{settings.AWS_STORAGE_BUCKET_NAME}/{path}"
    
    try:
        # Stream from MinIO
        response = requests.get(minio_url, stream=True, timeout=30)
        
        # Determine content type
        content_type = response.headers.get('Content-Type', 'application/octet-stream')
        
        # Stream response
        streaming_response = StreamingHttpResponse(
            response.iter_content(chunk_size=8192),
            content_type=content_type
        )
        
        # Copy relevant headers
        for header in ['Content-Length', 'Content-Disposition', 'Last-Modified']:
            if header in response.headers:
                streaming_response[header] = response.headers[header]
        
        return streaming_response
        
    except Exception as e:
        return HttpResponse(f"Error: {str(e)}", status=500)

from django.urls import path, re_path
from core.views import media_proxy

urlpatterns = [
    # Media proxy for production
    re_path(r'^media-proxy/(?P<path>.*)$', media_proxy, name='media-proxy'),
    # ... other patterns
]

from celery import shared_task
from django.core.files.storage import default_storage
import os

@shared_task(bind=True)
def import_activos_task(self, file_path, file_format):
    """
    Import assets from file stored in MinIO
    """
    try:
        # Read file from MinIO
        with default_storage.open(file_path, 'rb') as f:
            file_content = f.read()
            
        # Process file
        dataset = Dataset().load(file_content, format=file_format)
        
        # ... import logic ...
        
        return {'status': 'completed', 'total': len(dataset)}
        
    finally:
        # Cleanup: Delete temporary file
        if default_storage.exists(file_path):
            default_storage.delete(file_path)