CRM_AGENTES_CARGA/backend/api/v1/modules/crm/uploads/routes.py

"""Subida de archivos a MinIO/S3 para documentos del CRM y Operaciones.

Flujo: el frontend sube el archivo aquí, recibe ``file_key`` (permanente) y lo
guarda en el documento (crm.documents / ops.shipment_documents). Para abrirlo se
pide una URL firmada fresca en ``/uploads/url`` (las presignadas expiran).
"""
import re
import uuid

from fastapi import APIRouter, Depends, File, HTTPException, Query, UploadFile, status

from core.security import get_current_user
from core.storage_s3 import presigned_get_url, put_object_bytes

router = APIRouter()

MAX_UPLOAD_BYTES = 25 * 1024 * 1024  # 25 MB
_SAFE_NAME = re.compile(r"[^A-Za-z0-9._-]+")

# Trozo de lectura. No es crítico afinarlo: lo que importa es que la lectura sea POR PARTES y no de
# golpe, para poder abortar en cuanto se pase del tope.
_CHUNK_BYTES = 1 * 1024 * 1024

# Allowlist de extensiones, igual que la que ya tienen el avatar y el centro de ayuda. Coincide con
# la que EFC aplica del otro lado del carril del expediente: si aquí se aceptara algo que allá se
# rechaza, el archivo se guardaría y su entrega quedaría condenada a `failed`.
ALLOWED_UPLOAD_EXTENSIONS = (
    ".pdf", ".xml", ".png", ".jpg", ".jpeg", ".json", ".txt", ".zip", ".docx", ".xlsx",
)

# Prefijos que este endpoint puede firmar. Es un subárbol EXPLÍCITO, no toda la company: ver la
# nota de `get_upload_url`.
_PREFIJOS_FIRMABLES = ("crm-docs/", "expedientes/")


def _safe_filename(name: str | None) -> str:
    base = (name or "archivo").strip().replace(" ", "_")
    base = _SAFE_NAME.sub("", base) or "archivo"
    return base[:120]


def extension_de(name: str | None) -> str:
    base = (name or "").rsplit("/", 1)[-1].rsplit("\\", 1)[-1]
    if "." not in base:
        return ""
    return "." + base.rsplit(".", 1)[1].lower()


def validar_extension(name: str | None) -> None:
    if extension_de(name) not in ALLOWED_UPLOAD_EXTENSIONS:
        raise HTTPException(
            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
            detail="Ese tipo de archivo no está permitido.",
        )


async def leer_acotado(file: UploadFile, max_bytes: int = MAX_UPLOAD_BYTES) -> bytes:
    """Lee el archivo POR PARTES y aborta en cuanto pasa del tope.

    ``await file.read()`` a secas trae el archivo entero a memoria **antes** de que nadie pueda
    mirar su tamaño: un archivo de 2 GB se bufferiza completo solo para responder 422 después. Aquí
    el corte ocurre al superar el tope, así que el peor caso en RAM es el tope más un trozo.
    """
    partes: list[bytes] = []
    total = 0
    while True:
        chunk = await file.read(_CHUNK_BYTES)
        if not chunk:
            break
        total += len(chunk)
        if total > max_bytes:
            raise HTTPException(
                status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
                detail="El archivo excede el tamaño máximo permitido.",
            )
        partes.append(chunk)
    return b"".join(partes)


@router.post("/uploads")
async def upload_file(
    file: UploadFile = File(...),
    company_id: int = Query(..., description="Company ID"),
    current_user: dict = Depends(get_current_user),
):
    tenant_id = current_user["tenant_id"]
    validar_extension(file.filename)
    content = await leer_acotado(file)
    filename = _safe_filename(file.filename)
    key = f"tenants/{tenant_id}/companies/{company_id}/crm-docs/{uuid.uuid4().hex}/{filename}"
    put_object_bytes(key, content, content_type=file.content_type or "application/octet-stream")
    return {
        "file_key": key,
        "file_url": presigned_get_url(key),
        "name": file.filename,
        "content_type": file.content_type,
        "size_bytes": len(content),
    }


@router.get("/uploads/url")
def get_upload_url(
    key: str = Query(..., description="Object key del archivo en el almacén"),
    company_id: int = Query(..., description="Company ID"),
    current_user: dict = Depends(get_current_user),
):
    tenant_id = current_user["tenant_id"]
    # Un archivo solo puede consultarse dentro de su propio tenant/company (aislamiento).
    prefix = f"tenants/{tenant_id}/companies/{company_id}/"
    if not key.startswith(prefix):
        raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="Archivo fuera de tu alcance")

    # Y SOLO dentro de los subárboles de documentos. Validar únicamente el prefijo de la company
    # permitía firmar una URL para CUALQUIER objeto suyo —`certificates/` (llaves privadas de la
    # FIEL), `fin-invoices/`, `imports/csv/`— con solo el permiso `crm.access`. El alcance de este
    # endpoint es "los archivos que el CRM subió", no "todo el almacén de la company".
    resto = key[len(prefix):]
    if not resto.startswith(_PREFIJOS_FIRMABLES):
        raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="Archivo fuera de tu alcance")

    return {"url": presigned_get_url(key)}