files-server-fastapi 0.1.4__tar.gz → 0.1.6__tar.gz

{files_server_fastapi-0.1.4 → files_server_fastapi-0.1.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: files-server-fastapi
-Version: 0.1.4
+Version: 0.1.6
 Summary: Este repositorio es un paquete python desarrollado con FastAPI, gestiona la comunicación con un servidor Samba y utiliza PostgreSQL para administrar rutas de archivos y el control de acceso basado en roles (RBAC) de los usuarios.
 Project-URL: Homepage, https://github.com/AldoBP/files-server-fastapi
 Project-URL: Repository, https://github.com/AldoBP/files-server-fastapi

{files_server_fastapi-0.1.4 → files_server_fastapi-0.1.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "files-server-fastapi"
-version = "0.1.4"
+version = "0.1.6"
 description = "Este repositorio es un paquete python desarrollado con FastAPI, gestiona la comunicación con un servidor Samba y utiliza PostgreSQL para administrar rutas de archivos y el control de acceso basado en roles (RBAC) de los usuarios."
 readme = "README.md"
 license = { file = "LICENSE" }

files_server_fastapi-0.1.6/src/files_server_fastapi/files/__init__.py

@@ -0,0 +1,12 @@
+"""
+Paquete de sub-módulos para el router de archivos.
+
+  constants.py       — BASE_DIR, OFFICE_PROTOCOLS, INLINE_MIME_TYPES
+  dependencies.py    — check_folder_access (validación ACL)
+  list_router.py     — GET  /files/list
+  folder_router.py   — POST /files/folder
+  upload_router.py   — POST /files/upload
+  open_url_router.py — GET  /files/open-url
+  download_router.py — GET  /files/download
+  tree_router.py     — GET  /files/tree
+"""

files_server_fastapi-0.1.6/src/files_server_fastapi/files/constants.py

@@ -0,0 +1,24 @@
+# Directorio maestro (ruta de red Samba vista desde Windows)
+BASE_DIR = r"\\192.168.1.122\Compartido"
+
+# Mapeo extensión → protocolo de Office
+OFFICE_PROTOCOLS = {
+    "doc":  "ms-word",
+    "docx": "ms-word",
+    "dot":  "ms-word",
+    "dotx": "ms-word",
+    "xls":  "ms-excel",
+    "xlsx": "ms-excel",
+    "xlsm": "ms-excel",
+    "ppt":  "ms-powerpoint",
+    "pptx": "ms-powerpoint",
+    "pps":  "ms-powerpoint",
+    "ppsx": "ms-powerpoint",
+}
+
+# MIME types que el navegador puede mostrar inline (sin descarga forzada)
+INLINE_MIME_TYPES = {
+    "application/pdf",
+    "image/jpeg", "image/png", "image/gif", "image/webp", "image/svg+xml",
+    "text/plain", "text/csv", "text/html",
+}

files_server_fastapi-0.1.6/src/files_server_fastapi/files/dependencies.py

@@ -0,0 +1,90 @@
+from fastapi import HTTPException, Depends
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlmodel import select
+from pgsqlasync2fast_fastapi.dependencies import get_db_session
+from oauth2fast_fastapi import get_current_user, User
+from files_server_fastapi.models.permisos_model import User_Ruta_Access
+from files_server_fastapi.models.rutas_model import Rutas
+from files_server_fastapi.models.users_extend_model import Users_extend
+from files_server_fastapi.models.area_model import Area
+from files_server_fastapi.models.rol_model import Rol
+
+
+async def check_folder_access(
+    area: str,
+    subpath: str = "/",
+    required_access: str = "allow_read",
+    current_user: User = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db_session),
+):
+    """
+    Verifica si el usuario actual tiene acceso al área y subpath indicados.
+    required_access: 'allow_read' (por defecto) o 'allow_write'
+    """
+    # 1. Obtener extensión de usuario y verificar pertenencia al área
+    result_ext = await db.execute(
+        select(Users_extend).where(Users_extend.user_id == current_user.id)
+    )
+    user_exts = result_ext.scalars().all()
+
+    area_obj = None
+    user_ext_match = None
+    for ext in user_exts:
+        res_area = await db.execute(select(Area).where(Area.id == ext.area_id))
+        a = res_area.scalars().first()
+        if a and a.area_name.upper() == area.upper():
+            area_obj = a
+            user_ext_match = ext
+            break
+
+    if not area_obj or not user_ext_match:
+        raise HTTPException(status_code=403, detail="No perteneces a esta área")
+
+    # Obtener el Rol Base del usuario en esta área
+    res_rol = await db.execute(select(Rol).where(Rol.id == user_ext_match.rol_id))
+    rol_obj = res_rol.scalars().first()
+    rol_name = rol_obj.role_name.lower() if rol_obj else ""
+
+    # 2. Verificar ACL específico por ruta y herencia de padres
+    logical_path = f"/{area.upper()}/{subpath.strip('/')}".replace("//", "/")
+    parts = logical_path.strip("/").split("/")
+    paths_to_check = []
+    current_path = ""
+    for part in parts:
+        if part:
+            current_path += f"/{part}"
+            paths_to_check.append(current_path)
+
+    paths_to_check.reverse()  # Más específico primero
+
+    res_acl = await db.execute(
+        select(Rutas.ruta, User_Ruta_Access)
+        .join(User_Ruta_Access, User_Ruta_Access.ruta_id == Rutas.id)
+        .where(Rutas.ruta.in_(paths_to_check))
+        .where(User_Ruta_Access.user_id == current_user.id)
+    )
+    acls_encontrados = {row[0]: row[1] for row in res_acl.all()}
+
+    for path_in_tree in paths_to_check:
+        if path_in_tree in acls_encontrados:
+            acl_obj = acls_encontrados[path_in_tree]
+
+            if acl_obj.access_type == "deny_all":
+                raise HTTPException(status_code=403, detail="Acceso denegado a esta carpeta o heredado de una superior")
+
+            if required_access == "allow_write":
+                if acl_obj.access_type == "allow_write":
+                    return True
+                elif acl_obj.access_type == "allow_read":
+                    raise HTTPException(status_code=403, detail="Solo tienes permiso de lectura (regla heredada)")
+
+            if required_access == "allow_read":
+                if acl_obj.access_type in ["allow_read", "allow_write"]:
+                    return True
+
+    # 3. Sin ACL explícito → aplicar reglas del Rol Base
+    if required_access == "allow_write":
+        if "editor" not in rol_name and "admin" not in rol_name:
+            raise HTTPException(status_code=403, detail="Tu rol no permite modificar esta carpeta")
+
+    return True

files_server_fastapi-0.1.6/src/files_server_fastapi/files/download_router.py

@@ -0,0 +1,42 @@
+import os
+import mimetypes
+from fastapi import APIRouter, HTTPException, Depends
+from fastapi.responses import FileResponse
+from files_server_fastapi.files.constants import BASE_DIR, INLINE_MIME_TYPES
+from files_server_fastapi.files.dependencies import check_folder_access
+
+router = APIRouter()
+
+
+@router.get("/download", summary="Descargar o visualizar un archivo inline en el navegador")
+async def download_file(
+    area: str,
+    filename: str,
+    subpath: str = "/",
+    has_access: bool = Depends(check_folder_access)
+):
+    """
+    Sirve un archivo desde el share Samba.
+    - PDFs e imágenes → inline en el navegador.
+    - Otros tipos → descarga forzada.
+    """
+    if ".." in subpath or ".." in filename:
+        raise HTTPException(status_code=400, detail="Ruta o nombre de archivo inválido")
+
+    safe_filename = os.path.basename(filename)
+    safe_subpath = subpath.strip("/")
+    ruta_real = os.path.join(BASE_DIR, area.upper(), safe_subpath, safe_filename) if safe_subpath else os.path.join(BASE_DIR, area.upper(), safe_filename)
+
+    if not os.path.isfile(ruta_real):
+        raise HTTPException(status_code=404, detail=f"Archivo no encontrado: {safe_filename}")
+
+    mime_type, _ = mimetypes.guess_type(safe_filename)
+    mime_type = mime_type or "application/octet-stream"
+    disposition = "inline" if mime_type in INLINE_MIME_TYPES else "attachment"
+
+    return FileResponse(
+        path=ruta_real,
+        media_type=mime_type,
+        filename=safe_filename,
+        headers={"Content-Disposition": f'{disposition}; filename="{safe_filename}"', "Cache-Control": "no-cache"},
+    )

files_server_fastapi-0.1.6/src/files_server_fastapi/files/folder_router.py

@@ -0,0 +1,41 @@
+import os
+from fastapi import APIRouter, HTTPException, Depends
+from pydantic import BaseModel
+from sqlalchemy.ext.asyncio import AsyncSession
+from pgsqlasync2fast_fastapi.dependencies import get_db_session
+from oauth2fast_fastapi import get_current_user, User
+from files_server_fastapi.files.constants import BASE_DIR
+from files_server_fastapi.files.dependencies import check_folder_access
+
+router = APIRouter()
+
+
+class FolderCreate(BaseModel):
+    area: str
+    subpath: str
+    folder_name: str
+
+
+@router.post("/folder", summary="Crear una nueva carpeta en el servidor")
+async def create_folder(
+    req: FolderCreate,
+    current_user: User = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db_session)
+):
+    await check_folder_access(area=req.area, subpath=req.subpath, required_access="allow_write", current_user=current_user, db=db)
+
+    if ".." in req.subpath or ".." in req.folder_name or "/" in req.folder_name:
+        raise HTTPException(status_code=400, detail="Nombre de carpeta o ruta inválida")
+
+    safe_subpath = req.subpath.strip("/")
+    ruta_final = os.path.join(BASE_DIR, req.area.upper(), safe_subpath, req.folder_name) if safe_subpath else os.path.join(BASE_DIR, req.area.upper(), req.folder_name)
+
+    try:
+        os.makedirs(ruta_final, exist_ok=False)
+        return {"message": "Carpeta creada exitosamente", "path": ruta_final}
+    except FileExistsError:
+        raise HTTPException(status_code=400, detail="Ya existe una carpeta con ese nombre aquí")
+    except PermissionError:
+        raise HTTPException(status_code=403, detail="El servidor rechazó el permiso de escritura")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))

files_server_fastapi-0.1.6/src/files_server_fastapi/files/list_router.py

@@ -0,0 +1,44 @@
+import os
+from datetime import datetime
+from fastapi import APIRouter, HTTPException, Depends
+from files_server_fastapi.files.constants import BASE_DIR
+from files_server_fastapi.files.dependencies import check_folder_access
+
+router = APIRouter()
+
+
+@router.get("/list", summary="Listar archivos de una carpeta")
+async def list_directory(
+    area: str,
+    subpath: str = "/",
+    has_access: bool = Depends(check_folder_access)
+):
+    """Devuelve el contenido de una carpeta dentro del área indicada."""
+    if ".." in subpath:
+        raise HTTPException(status_code=400, detail="Ruta inválida")
+
+    safe_subpath = subpath.strip("/")
+    ruta_real = os.path.join(BASE_DIR, area.upper(), safe_subpath) if safe_subpath else os.path.join(BASE_DIR, area.upper())
+
+    if not os.path.exists(ruta_real):
+        return []
+    if not os.path.isdir(ruta_real):
+        raise HTTPException(status_code=400, detail="La ruta no es un directorio")
+
+    items = []
+    try:
+        with os.scandir(ruta_real) as ficheros:
+            for fichero in ficheros:
+                info = fichero.stat()
+                fecha_mod = datetime.fromtimestamp(info.st_mtime).strftime("%Y-%m-%d %H:%M")
+                if fichero.is_dir():
+                    items.append({"name": fichero.name, "type": "folder", "updated": fecha_mod, "size": "", "locked": False})
+                else:
+                    size_kb = info.st_size / 1024
+                    size_str = f"{size_kb:.1f} KB" if size_kb < 1024 else f"{size_kb / 1024:.1f} MB"
+                    items.append({"name": fichero.name, "type": "file", "updated": fecha_mod, "size": size_str, "locked": False})
+
+        items.sort(key=lambda x: (x["type"] == "file", x["name"].lower()))
+        return items
+    except PermissionError:
+        raise HTTPException(status_code=403, detail="Acceso denegado por el sistema operativo")

files_server_fastapi-0.1.6/src/files_server_fastapi/files/open_url_router.py

@@ -0,0 +1,51 @@
+import os
+from fastapi import APIRouter, HTTPException, Depends
+from files_server_fastapi.files.constants import BASE_DIR, OFFICE_PROTOCOLS
+from files_server_fastapi.files.dependencies import check_folder_access
+
+router = APIRouter()
+
+
+@router.get("/open-url", summary="Obtener URL para abrir un archivo en la app local (Office, etc.)")
+async def get_open_url(
+    area: str,
+    filename: str,
+    subpath: str = "/",
+    has_access: bool = Depends(check_folder_access)
+):
+    """
+    Devuelve la URL de protocolo adecuada para abrir el archivo directamente
+    en la aplicación instalada en la PC del usuario.
+
+    - Archivos **Office** (.docx, .xlsx, .pptx…): URL `ms-word:ofe|u|...` para abrir y guardar directo.
+    - **Otros** (PDF, imágenes, txt): URL del endpoint `/files/download` para vista inline.
+    """
+    if ".." in subpath or ".." in filename:
+        raise HTTPException(status_code=400, detail="Ruta o nombre de archivo inválido")
+
+    safe_filename = os.path.basename(filename)
+    safe_subpath = subpath.strip("/")
+    ruta_real = os.path.join(BASE_DIR, area.upper(), safe_subpath, safe_filename) if safe_subpath else os.path.join(BASE_DIR, area.upper(), safe_filename)
+
+    if not os.path.isfile(ruta_real):
+        raise HTTPException(status_code=404, detail=f"Archivo no encontrado: {safe_filename}")
+
+    ext = safe_filename.rsplit(".", 1)[-1].lower() if "." in safe_filename else ""
+    office_protocol = OFFICE_PROTOCOLS.get(ext)
+
+    if office_protocol:
+        subpath_win = safe_subpath.replace("/", "\\")
+        unc_path = f"{BASE_DIR}\\{area.upper()}\\{subpath_win}\\{safe_filename}" if safe_subpath else f"{BASE_DIR}\\{area.upper()}\\{safe_filename}"
+        return {
+            "type": "office",
+            "protocol": office_protocol,
+            "url": f"{office_protocol}:ofe|u|{unc_path}",
+            "unc_path": unc_path,
+            "filename": safe_filename,
+        }
+
+    return {
+        "type": "download",
+        "url": f"/files/download?area={area}&subpath={subpath}&filename={safe_filename}",
+        "filename": safe_filename,
+    }

files_server_fastapi-0.1.6/src/files_server_fastapi/files/tree_router.py

@@ -0,0 +1,31 @@
+import os
+from fastapi import APIRouter
+from files_server_fastapi.files.constants import BASE_DIR
+
+router = APIRouter()
+
+
+def get_directory_tree(path_to_scan: str, base_name: str = "") -> list:
+    """Función recursiva para leer el árbol de subcarpetas."""
+    tree = []
+    try:
+        with os.scandir(path_to_scan) as entries:
+            for entry in entries:
+                if entry.is_dir():
+                    relative_path = os.path.join(base_name, entry.name).replace("\\", "/")
+                    tree.append({
+                        "name": entry.name,
+                        "path": f"/{relative_path}",
+                        "children": get_directory_tree(entry.path, relative_path)
+                    })
+    except PermissionError:
+        pass
+    return sorted(tree, key=lambda x: x["name"].lower())
+
+
+@router.get("/tree", summary="Obtener el árbol de carpetas de un área")
+async def get_area_tree(area: str):
+    area_path = os.path.join(BASE_DIR, area.upper())
+    if not os.path.exists(area_path):
+        return []
+    return get_directory_tree(area_path)

files_server_fastapi-0.1.6/src/files_server_fastapi/files/upload_router.py

@@ -0,0 +1,64 @@
+import os
+from fastapi import APIRouter, HTTPException, Depends, UploadFile, File, Form
+from sqlalchemy.ext.asyncio import AsyncSession
+from pgsqlasync2fast_fastapi.dependencies import get_db_session
+from oauth2fast_fastapi import get_current_user, User
+from files_server_fastapi.files.constants import BASE_DIR
+from files_server_fastapi.files.dependencies import check_folder_access
+
+router = APIRouter()
+
+
+@router.post("/upload", summary="Subir un archivo a una carpeta del servidor")
+async def upload_file(
+    area: str = Form(...),
+    subpath: str = Form(default="/"),
+    file: UploadFile = File(...),
+    current_user: User = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db_session)
+):
+    """
+    Sube un archivo a la carpeta indicada dentro del share Samba.
+
+    - **area**: Área destino (ej: 'CONTABILIDAD')
+    - **subpath**: Subcarpeta relativa (ej: '/' raíz, '/2024/Enero' subcarpeta)
+    - **file**: El archivo a subir (multipart/form-data)
+    """
+    await check_folder_access(area=area, subpath=subpath, required_access="allow_write", current_user=current_user, db=db)
+
+    if ".." in subpath or ".." in (file.filename or ""):
+        raise HTTPException(status_code=400, detail="Ruta o nombre de archivo inválido")
+
+    safe_filename = os.path.basename(file.filename or "archivo_sin_nombre")
+    if not safe_filename:
+        raise HTTPException(status_code=400, detail="Nombre de archivo inválido")
+
+    safe_subpath = subpath.strip("/")
+    ruta_destino = os.path.join(BASE_DIR, area.upper(), safe_subpath) if safe_subpath else os.path.join(BASE_DIR, area.upper())
+
+    if not os.path.isdir(ruta_destino):
+        raise HTTPException(status_code=404, detail=f"La carpeta de destino no existe: /{area.upper()}/{safe_subpath}")
+
+    ruta_archivo = os.path.join(ruta_destino, safe_filename)
+    if os.path.exists(ruta_archivo):
+        raise HTTPException(status_code=409, detail=f"Ya existe un archivo con ese nombre: {safe_filename}")
+
+    try:
+        CHUNK_SIZE = 1024 * 1024  # 1 MB por chunk
+        with open(ruta_archivo, "wb") as f:
+            while chunk := await file.read(CHUNK_SIZE):
+                f.write(chunk)
+
+        size_bytes = os.path.getsize(ruta_archivo)
+        size_kb = size_bytes / 1024
+        size_str = f"{size_kb:.1f} KB" if size_kb < 1024 else f"{size_kb / 1024:.1f} MB"
+        ruta_logica = f"/{area.upper()}/{safe_subpath}/{safe_filename}".replace("//", "/")
+
+        return {"message": "Archivo subido exitosamente", "filename": safe_filename, "size": size_str, "path": ruta_logica}
+
+    except PermissionError:
+        raise HTTPException(status_code=403, detail="El servidor rechazó el permiso de escritura en el share Samba")
+    except OSError as e:
+        raise HTTPException(status_code=500, detail=f"Error del sistema al guardar el archivo: {e}")
+    finally:
+        await file.close()

files_server_fastapi-0.1.6/src/files_server_fastapi/routers/area_router.py

@@ -0,0 +1,131 @@
+from typing import Optional
+from fastapi import APIRouter, Depends, HTTPException, status
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy import select
+from pydantic import BaseModel
+
+from pgsqlasync2fast_fastapi.dependencies import get_db_session
+from files_server_fastapi.models.area_model import Area
+
+router = APIRouter(prefix="/areas", tags=["Gestión de Áreas"])
+
+
+class AreaCreate(BaseModel):
+    area_name: str
+    description: Optional[str] = None
+
+
+class AreaUpdate(BaseModel):
+    area_name: Optional[str] = None
+    description: Optional[str] = None
+
+
+# ==========================================
+# POST /areas/ — Crear nueva área
+# ==========================================
+@router.post("/", response_model=Area, status_code=status.HTTP_201_CREATED, summary="Crear una nueva Área")
+async def create_area(area_data: AreaCreate, db: AsyncSession = Depends(get_db_session)):
+    """
+    Crea y guarda una nueva área en la base de datos.
+    Solo accesible por superusuarios desde el panel de administración.
+    """
+    # Verificar si ya existe un área con el mismo nombre
+    result = await db.execute(select(Area).where(Area.area_name == area_data.area_name))
+    existing = result.scalars().first()
+    if existing:
+        raise HTTPException(
+            status_code=status.HTTP_409_CONFLICT,
+            detail=f"Ya existe un área con el nombre '{area_data.area_name}'."
+        )
+
+    new_area = Area(**area_data.model_dump())
+    db.add(new_area)
+    await db.commit()
+    await db.refresh(new_area)
+    return new_area
+
+
+# ==========================================
+# GET /areas/ — Listar todas las áreas
+# ==========================================
+@router.get("/", response_model=list[Area], summary="Obtener todas las Áreas")
+async def get_areas(db: AsyncSession = Depends(get_db_session)):
+    """
+    Devuelve la lista de todas las áreas registradas.
+    """
+    result = await db.execute(select(Area))
+    return result.scalars().all()
+
+
+# ==========================================
+# GET /areas/{area_id} — Obtener área por ID
+# ==========================================
+@router.get("/{area_id}", response_model=Area, summary="Obtener un Área por ID")
+async def get_area(area_id: int, db: AsyncSession = Depends(get_db_session)):
+    """
+    Devuelve los datos de un área específica por su ID.
+    """
+    result = await db.execute(select(Area).where(Area.id == area_id))
+    area = result.scalars().first()
+    if not area:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"No se encontró el área con ID {area_id}."
+        )
+    return area
+
+
+# ==========================================
+# PATCH /areas/{area_id} — Actualizar área
+# ==========================================
+@router.patch("/{area_id}", response_model=Area, summary="Actualizar un Área")
+async def update_area(area_id: int, area_update: AreaUpdate, db: AsyncSession = Depends(get_db_session)):
+    """
+    Actualiza parcialmente los datos de un área existente.
+    """
+    result = await db.execute(select(Area).where(Area.id == area_id))
+    area = result.scalars().first()
+    if not area:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"No se encontró el área con ID {area_id}."
+        )
+
+    # Si se quiere cambiar el nombre, verificar que no exista otro con ese nombre
+    if area_update.area_name and area_update.area_name != area.area_name:
+        dup_result = await db.execute(select(Area).where(Area.area_name == area_update.area_name))
+        if dup_result.scalars().first():
+            raise HTTPException(
+                status_code=status.HTTP_409_CONFLICT,
+                detail=f"Ya existe un área con el nombre '{area_update.area_name}'."
+            )
+
+    update_data = area_update.model_dump(exclude_unset=True)
+    for key, value in update_data.items():
+        setattr(area, key, value)
+
+    db.add(area)
+    await db.commit()
+    await db.refresh(area)
+    return area
+
+
+# ==========================================
+# DELETE /areas/{area_id} — Eliminar área
+# ==========================================
+@router.delete("/{area_id}", status_code=status.HTTP_204_NO_CONTENT, summary="Eliminar un Área")
+async def delete_area(area_id: int, db: AsyncSession = Depends(get_db_session)):
+    """
+    Elimina un área por su ID.
+    ADVERTENCIA: Solo eliminar si no hay usuarios asociados a esta área.
+    """
+    result = await db.execute(select(Area).where(Area.id == area_id))
+    area = result.scalars().first()
+    if not area:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"No se encontró el área con ID {area_id}."
+        )
+
+    await db.delete(area)
+    await db.commit()

files_server_fastapi-0.1.6/src/files_server_fastapi/routers/files_router.py

@@ -0,0 +1,18 @@
+from fastapi import APIRouter
+from files_server_fastapi.files import (
+    list_router,
+    folder_router,
+    upload_router,
+    open_url_router,
+    download_router,
+    tree_router,
+)
+
+router = APIRouter(prefix="/files", tags=["Archivos del Sistema"])
+
+router.include_router(list_router.router)
+router.include_router(folder_router.router)
+router.include_router(upload_router.router)
+router.include_router(open_url_router.router)
+router.include_router(download_router.router)
+router.include_router(tree_router.router)