files-server-fastapi 0.1.44__tar.gz → 0.1.45__tar.gz

{files_server_fastapi-0.1.44 → files_server_fastapi-0.1.45}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: files-server-fastapi
-Version: 0.1.44
+Version: 0.1.45
 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.44 → files_server_fastapi-0.1.45}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "files-server-fastapi"
-version = "0.1.44"
+version = "0.1.45"
 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.45/src/files_server_fastapi/dependencies/__init__.py

@@ -0,0 +1,13 @@
+from files_server_fastapi.dependencies.user_dependencies import (
+    get_active_user,
+    get_current_user_ext,
+    require_superadmin,
+    require_area_admin_or_superadmin,
+)
+
+__all__ = [
+    "get_active_user",
+    "get_current_user_ext",
+    "require_superadmin",
+    "require_area_admin_or_superadmin",
+]

files_server_fastapi-0.1.45/src/files_server_fastapi/dependencies/user_dependencies.py

@@ -0,0 +1,183 @@
+"""
+dependencies/user_dependencies.py
+==================================
+Dependencies de autenticación y autorización propias del proyecto.
+
+Propósito:
+    El paquete oauth2fast-fastapi maneja la autenticación base (token JWT),
+    pero no conoce el concepto de "usuario dado de baja" ni el sistema de
+    niveles de privilegio de este proyecto.
+
+    Este módulo extiende esa lógica con:
+
+    - get_active_user: verifica que el usuario NO esté dado de baja.
+    - require_superadmin: verifica privilege_level >= 2.
+    - require_area_admin_or_superadmin: verifica privilege_level >= 1.
+
+Niveles de privilegio (tabla rol.privilege_level):
+    0 → Usuario regular     (sin permisos de gestión)
+    1 → Admin de Área       (gestión de su propia área)
+    2 → Superadmin/Sistemas (acceso total)
+
+¿Por qué privilege_level en vez de comparar nombres de rol?
+    Los nombres de rol pueden cambiar ("admin" → "lider", "jefe", etc.).
+    El privilege_level es un contrato estable: el código solo lee el número,
+    no el texto. Renombrar un rol en la DB nunca rompe la autorización.
+"""
+
+from datetime import datetime, timezone
+
+from fastapi import Depends, HTTPException, status
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from oauth2fast_fastapi import User, get_current_verified_user
+from pgsqlasync2fast_fastapi.dependencies import get_db_session
+
+from files_server_fastapi.models.rol_model import Rol
+from files_server_fastapi.models.users_extend_model import Users_extend
+
+# ── Constantes de nivel de privilegio ────────────────────────────────────────
+# Cambia estos valores SOLO si redefiniste la escala en tu tabla rol.
+PRIVILEGE_USER       = 0  # Usuario regular
+PRIVILEGE_AREA_ADMIN = 1  # Admin de Área
+PRIVILEGE_SUPERADMIN = 2  # Sistemas / Superadmin
+
+
+# ── Helper interno ────────────────────────────────────────────────────────────
+
+async def _get_privilege_level(rol_id: int, db: AsyncSession) -> int:
+    """
+    Obtiene el privilege_level del rol desde la DB.
+    Retorna PRIVILEGE_USER (0) si el rol no existe.
+    """
+    result = await db.execute(select(Rol).where(Rol.id == rol_id))
+    rol = result.scalars().first()
+    return rol.privilege_level if rol else PRIVILEGE_USER
+
+
+# ── Dependency principal ──────────────────────────────────────────────────────
+
+async def get_active_user(
+    current_user: User = Depends(get_current_verified_user),
+    db: AsyncSession = Depends(get_db_session),
+) -> User:
+    """
+    Extiende get_current_verified_user con verificación de soft delete.
+
+    Flujo:
+        1. get_current_verified_user valida el token JWT y que is_verified=True.
+        2. Esta dependency verifica que deleted_at IS NULL en users_extend.
+
+    Lanza:
+        HTTP 403 si el usuario tiene deleted_at con fecha/hora de baja.
+    """
+    result = await db.execute(
+        select(Users_extend).where(Users_extend.user_id == current_user.id)
+    )
+    ext = result.scalars().first()
+
+    if ext is not None and ext.deleted_at is not None:
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail=(
+                "Tu cuenta ha sido dada de baja del sistema. "
+                "Contacta a sistemas para más información."
+            ),
+        )
+    return current_user
+
+
+# ── Helper: extensión del usuario actual ──────────────────────────────────────
+
+async def get_current_user_ext(
+    current_user: User = Depends(get_active_user),
+    db: AsyncSession = Depends(get_db_session),
+) -> Users_extend:
+    """
+    Retorna el registro Users_extend del usuario autenticado y activo.
+    Lanza 404 si el usuario no tiene extensión registrada.
+    """
+    result = await db.execute(
+        select(Users_extend).where(Users_extend.user_id == current_user.id)
+    )
+    ext = result.scalars().first()
+    if not ext:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail="El usuario no tiene datos de extensión registrados.",
+        )
+    return ext
+
+
+# ── Verificadores de nivel de privilegio ──────────────────────────────────────
+
+async def require_superadmin(
+    current_user: User = Depends(get_active_user),
+    db: AsyncSession = Depends(get_db_session),
+) -> tuple[User, Users_extend]:
+    """
+    Verifica que el usuario tenga privilege_level >= 2 (Superadmin/Sistemas).
+
+    Retorna:
+        (User, Users_extend) para uso en el endpoint.
+
+    Lanza:
+        HTTP 403 si el nivel de privilegio es insuficiente.
+    """
+    result = await db.execute(
+        select(Users_extend).where(Users_extend.user_id == current_user.id)
+    )
+    ext = result.scalars().first()
+
+    if not ext:
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail="No tienes permisos suficientes para esta acción.",
+        )
+
+    level = await _get_privilege_level(ext.rol_id, db)
+    if level < PRIVILEGE_SUPERADMIN:
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail="Solo Sistemas/Superadmin puede ejecutar esta acción.",
+        )
+
+    return current_user, ext
+
+
+async def require_area_admin_or_superadmin(
+    current_user: User = Depends(get_active_user),
+    db: AsyncSession = Depends(get_db_session),
+) -> tuple[User, Users_extend, bool]:
+    """
+    Verifica que el usuario tenga privilege_level >= 1 (Admin de Área o superior).
+
+    Retorna:
+        (User, Users_extend, is_superadmin: bool)
+        El booleano permite al endpoint saber si tiene permisos totales.
+
+    Lanza:
+        HTTP 403 si el nivel de privilegio es insuficiente.
+    """
+    result = await db.execute(
+        select(Users_extend).where(Users_extend.user_id == current_user.id)
+    )
+    ext = result.scalars().first()
+
+    if not ext:
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail="No tienes permisos suficientes para esta acción.",
+        )
+
+    level = await _get_privilege_level(ext.rol_id, db)
+    if level < PRIVILEGE_AREA_ADMIN:
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail="Se requiere nivel de Admin de Área o superior.",
+        )
+
+    is_superadmin = level >= PRIVILEGE_SUPERADMIN
+    return current_user, ext, is_superadmin
+

{files_server_fastapi-0.1.44 → files_server_fastapi-0.1.45}/src/files_server_fastapi/files/acls_router.py

@@ -267,9 +267,10 @@ async def get_specific_user_acls(
     Acepta el auth user_id directamente (el mismo que esta en user_ruta_access.user_id).
     Por compatibilidad tambien acepta users_extend.id si el user_id no se encuentra como auth user_id.
 
-    **Requiere rol SUPER_ADMIN o AREA_ADMIN.**
+    **Requiere rol SUPER_ADMIN o AREA_ADMIN (excepto si el usuario consulta sus propios permisos).**
     """
-    await _require_admin_role(current_user, db)
+    if current_user.id != user_id:
+        await _require_admin_role(current_user, db)
     ext_result = await db.execute(
         select(Users_extend).where(Users_extend.user_id == user_id)
     )

{files_server_fastapi-0.1.44 → files_server_fastapi-0.1.45}/src/files_server_fastapi/files/delete_router.py

@@ -3,7 +3,7 @@ import shutil
 from fastapi import APIRouter, HTTPException, Depends
 from pydantic import BaseModel
 from sqlalchemy.ext.asyncio import AsyncSession
-from sqlalchemy import select, delete as sql_delete
+from sqlalchemy import select, delete as sql_delete, or_
 
 from pgsqlasync2fast_fastapi.dependencies import get_db_session
 from oauth2fast_fastapi import get_current_verified_user, User
@@ -17,7 +17,7 @@ router = APIRouter()
 class DeleteRequest(BaseModel):
     area: str
     subpath: str = "/"
-    name: str  # nombre del archivo o carpeta a eliminar
+    filename: str  # nombre del archivo o carpeta a eliminar
 
 
 @router.delete("/delete", summary="Eliminar un archivo o carpeta del servidor")
@@ -35,8 +35,8 @@ async def delete_item(
     - La base de datos se limpia **solo si** la eliminación física tuvo éxito, evitando registros huérfanos.
     """
     # ── 1. Validar rutas ANTES de cualquier lógica de negocio ─────────────────
-    # req.name nunca debe contener separadores de directorio ni secuencias de traversal.
-    if ".." in req.subpath or ".." in req.name or "/" in req.name:
+    # req.filename nunca debe contener separadores de directorio ni secuencias de traversal.
+    if ".." in req.subpath or ".." in req.filename or "/" in req.filename:
         raise HTTPException(status_code=400, detail="Ruta o nombre inválido")
 
     # ── 2. Verificar permiso de eliminación ───────────────────────────────────
@@ -49,7 +49,7 @@ async def delete_item(
     )
 
     # ── 3. Construir rutas ────────────────────────────────────────────────────
-    safe_name = os.path.basename(req.name)
+    safe_name = os.path.basename(req.filename)
     safe_subpath = req.subpath.strip("/")
     ruta_real = (
         os.path.join(BASE_DIR, req.area.upper(), safe_subpath, safe_name)
@@ -85,7 +85,12 @@ async def delete_item(
     # Para archivos regulares no suele haber entrada en Rutas, pero el DELETE
     # es seguro (no borra nada si no hay coincidencia).
     await db.execute(
-        sql_delete(Rutas).where(Rutas.ruta.like(f"{logical_prefix}%"))
+        sql_delete(Rutas).where(
+            or_(
+                Rutas.ruta == logical_prefix,
+                Rutas.ruta.like(f"{logical_prefix}/%")
+            )
+        )
     )
     await db.commit()
 

files_server_fastapi-0.1.45/src/files_server_fastapi/models/rol_model.py

@@ -0,0 +1,26 @@
+from typing import Optional
+from datetime import datetime, timezone
+from sqlmodel import Field
+from oauth2fast_fastapi import AuthModel
+
+
+def get_utc_now():
+    return datetime.now(timezone.utc)
+
+
+class Rol(AuthModel, table=True):
+    __tablename__ = "rol"
+
+    role_name: str = Field(nullable=False)
+    description: Optional[str] = Field(default=None)
+
+    # Nivel de privilegio del rol. Desacopla la autorización del nombre del rol:
+    # el nombre puede cambiar libremente sin afectar la lógica del sistema.
+    #
+    #   0 → Usuario regular     (sin permisos de gestión)
+    #   1 → Admin de Área       (gestión de su propia área)
+    #   2 → Superadmin/Sistemas (acceso total)
+    #
+    # Para agregar nuevos niveles en el futuro, solo actualiza este campo en la DB.
+    privilege_level: int = Field(default=0, nullable=False)
+

{files_server_fastapi-0.1.44 → files_server_fastapi-0.1.45}/src/files_server_fastapi/models/users_extend_model.py

@@ -1,20 +1,30 @@
 from typing import Optional
+from datetime import datetime
 from sqlmodel import Field
 from oauth2fast_fastapi import AuthModel
 
+
 class Users_extend(AuthModel, table=True):
     __tablename__ = "users_extend"
-    
+
     # Es Foreign Key al usuario (Relación 1 a 1)
     user_id: int = Field(foreign_key="users.id", unique=True)
-    
+
     area_id: int = Field(foreign_key="area.id")
     rol_id: int = Field(foreign_key="rol.id")
     puesto: Optional[str] = Field(default=None)
-    
+
     # Contraseña en texto plano para sincronización con el sistema de archivos centralizado de red
     samba_password: Optional[str] = Field(default=None)
-    
+
     # Indica si el usuario tiene acceso Samba activado manualmente por el administrador.
     # Cuando es True, los permisos web se replican automáticamente a Linux ACLs / Samba.
     samba_enabled: bool = Field(default=False)
+
+    # ── Soft Delete ───────────────────────────────────────────────────────────
+    # NULL  → usuario activo
+    # NOT NULL → usuario dado de baja (fecha/hora exacta de la baja)
+    deleted_at: Optional[datetime] = Field(default=None)
+
+    # ID del usuario (admin/sistemas) que ejecutó la baja. NULL si está activo.
+    deleted_by: Optional[int] = Field(default=None, foreign_key="users.id")

files_server_fastapi-0.1.45/src/files_server_fastapi/routers/rol_router.py

@@ -0,0 +1,90 @@
+from fastapi import APIRouter, Depends, HTTPException, status
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy import select
+
+from pgsqlasync2fast_fastapi.dependencies import get_db_session
+from files_server_fastapi.models.rol_model import Rol
+from files_server_fastapi.dependencies.user_dependencies import require_superadmin
+
+router = APIRouter(prefix="/roles", tags=["Gestión de Roles"])
+
+@router.post("/", response_model=Rol, summary="Crear un nuevo Rol")
+async def create_rol(
+    rol: Rol, 
+    auth: tuple = Depends(require_superadmin),
+    db: AsyncSession = Depends(get_db_session)
+):
+    """
+    Crea un nuevo rol en el sistema.
+    Solo accesible por Superadmin/Sistemas.
+    
+    Puedes enviar 'privilege_level' en el cuerpo de la petición:
+      0 = Usuario regular
+      1 = Admin de Área
+      2 = Superadmin/Sistemas
+    """
+    db.add(rol)
+    await db.commit()
+    await db.refresh(rol)
+    return rol
+
+@router.get("/", response_model=list[Rol], summary="Obtener todos los Roles")
+async def get_roles(
+    db: AsyncSession = Depends(get_db_session)
+):
+    """
+    Obtiene la lista de todos los roles.
+    Público para lectura (necesario para formularios de registro/edición).
+    """
+    result = await db.execute(select(Rol))
+    return result.scalars().all()
+
+@router.put("/{rol_id}", response_model=Rol, summary="Editar un Rol")
+async def update_rol(
+    rol_id: int, 
+    rol_data: Rol, 
+    auth: tuple = Depends(require_superadmin),
+    db: AsyncSession = Depends(get_db_session)
+):
+    """
+    Actualiza un rol existente, incluyendo su nivel de privilegio.
+    Solo accesible por Superadmin/Sistemas.
+    """
+    result = await db.execute(select(Rol).where(Rol.id == rol_id))
+    db_rol = result.scalars().first()
+    if not db_rol:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail="Rol no encontrado"
+        )
+    
+    db_rol.role_name = rol_data.role_name
+    db_rol.description = rol_data.description
+    db_rol.privilege_level = rol_data.privilege_level # <-- Ahora sí se actualiza desde el Dashboard
+    
+    await db.commit()
+    await db.refresh(db_rol)
+    return db_rol
+
+@router.delete("/{rol_id}", summary="Eliminar un Rol")
+async def delete_rol(
+    rol_id: int, 
+    auth: tuple = Depends(require_superadmin),
+    db: AsyncSession = Depends(get_db_session)
+):
+    """
+    Elimina un rol.
+    Solo accesible por Superadmin/Sistemas.
+    """
+    result = await db.execute(select(Rol).where(Rol.id == rol_id))
+    db_rol = result.scalars().first()
+    if not db_rol:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail="Rol no encontrado"
+        )
+    
+    await db.delete(db_rol)
+    await db.commit()
+    return {"message": "Rol eliminado correctamente"}
+

{files_server_fastapi-0.1.44 → files_server_fastapi-0.1.45}/src/files_server_fastapi/routers/samba_router.py

@@ -30,7 +30,8 @@ from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy import select
 
 from pgsqlasync2fast_fastapi.dependencies import get_db_session
-from oauth2fast_fastapi import get_current_verified_user, User
+from oauth2fast_fastapi import User
+from files_server_fastapi.dependencies.user_dependencies import get_active_user
 from files_server_fastapi.models.users_extend_model import Users_extend
 from files_server_fastapi.models.permisos_model import User_Ruta_Access
 from files_server_fastapi.models.rutas_model import Rutas
@@ -170,7 +171,7 @@ class SambaActivateRequest(BaseModel):
 async def activate_samba(
     user_ext_id: int,
     req: SambaActivateRequest = SambaActivateRequest(),
-    current_user: User = Depends(get_current_verified_user),
+    current_user: User = Depends(get_active_user),
     db: AsyncSession = Depends(get_db_session),
 ):
     """
@@ -225,7 +226,7 @@ async def activate_samba(
 )
 async def deactivate_samba(
     user_ext_id: int,
-    current_user: User = Depends(get_current_verified_user),
+    current_user: User = Depends(get_active_user),
     db: AsyncSession = Depends(get_db_session),
 ):
     """
@@ -275,7 +276,7 @@ async def deactivate_samba(
 )
 async def get_samba_status(
     user_ext_id: int,
-    current_user: User = Depends(get_current_verified_user),
+    current_user: User = Depends(get_active_user),
     db: AsyncSession = Depends(get_db_session),
 ):
     """
@@ -320,7 +321,7 @@ async def get_samba_status(
 )
 async def sync_samba(
     user_ext_id: int,
-    current_user: User = Depends(get_current_verified_user),
+    current_user: User = Depends(get_active_user),
     db: AsyncSession = Depends(get_db_session),
 ):
     """

{files_server_fastapi-0.1.44 → files_server_fastapi-0.1.45}/src/files_server_fastapi/routers/users_extend_router.py

@@ -1,16 +1,22 @@
+from datetime import datetime, timezone
+from typing import Optional
+
 from fastapi import APIRouter, Depends, HTTPException, status
-from sqlalchemy.ext.asyncio import AsyncSession
+from pydantic import BaseModel, Field, model_validator
 from sqlalchemy import select
-from typing import Optional
-from pydantic import BaseModel
+from sqlalchemy.ext.asyncio import AsyncSession
 
+from oauth2fast_fastapi import User
 from pgsqlasync2fast_fastapi.dependencies import get_db_session
-from files_server_fastapi.models.users_extend_model import Users_extend
+
+from files_server_fastapi.dependencies.user_dependencies import (
+    get_active_user,
+    require_area_admin_or_superadmin,
+    require_superadmin,
+)
 from files_server_fastapi.models.area_model import Area
 from files_server_fastapi.models.rol_model import Rol
-
-
-from pydantic import BaseModel, Field, model_validator
+from files_server_fastapi.models.users_extend_model import Users_extend
 
 class UserExtendCreate(BaseModel):
     user_id: int
@@ -32,9 +38,11 @@ class UserExtendResponse(BaseModel):
     user_id: int
     area_id: int
     rol_id: int
-    role_id: int  # Añadimos alias virtual para el frontend
+    role_id: int  # Alias virtual para el frontend
     puesto: Optional[str] = None
-    
+    deleted_at: Optional[datetime] = None
+    deleted_by: Optional[int] = None
+
     class Config:
         from_attributes = True
 
@@ -206,12 +214,13 @@ async def update_user_extend(user_id: int, user_ext_update: UserExtendUpdate, db
 
 
 # ==========================================
-# DELETE /users-extend/{user_id} — Eliminar
+# DELETE /users-extend/{user_id} — Eliminar (Hard Delete - solo estructura)
 # ==========================================
 @router.delete("/{user_id}", status_code=status.HTTP_204_NO_CONTENT, summary="Eliminar extensión de usuario")
 async def delete_user_extend(user_id: int, db: AsyncSession = Depends(get_db_session)):
     """
     Elimina el vínculo de área y rol de un usuario.
+    NOTA: Para dar de baja a un usuario sin eliminar sus datos, usa DELETE /{user_id}/deactivate.
     """
     result = await db.execute(select(Users_extend).where(Users_extend.user_id == user_id))
     user_ext = result.scalars().first()
@@ -224,3 +233,174 @@ async def delete_user_extend(user_id: int, db: AsyncSession = Depends(get_db_ses
 
     await db.delete(user_ext)
     await db.commit()
+
+
+# ==========================================
+# DELETE /users-extend/{user_id}/deactivate — Soft Delete (Baja Lógica)
+# ==========================================
+@router.delete(
+    "/{user_id}/deactivate",
+    status_code=status.HTTP_200_OK,
+    summary="Dar de baja a un usuario (Borrado Lógico)",
+)
+async def deactivate_user(
+    user_id: int,
+    auth: tuple = Depends(require_area_admin_or_superadmin),
+    db: AsyncSession = Depends(get_db_session),
+):
+    """
+    Da de baja lógica a un usuario. El usuario no podrá hacer login ni usar
+    ningún endpoint del sistema. Sus datos se conservan para auditoría.
+
+    Reglas de autorización:
+    - Superadmin/Sistemas: puede dar de baja a cualquier usuario.
+    - Admin de Área: solo puede dar de baja a usuarios de su misma área,
+      y no puede dar de baja a otros admins de área.
+
+    El trigger PostgreSQL automáticamente:
+    - Pone is_verified = FALSE en la tabla users (bloquea el login).
+    - Pone samba_enabled = FALSE en users_extend.
+    """
+    current_user, executor_ext, is_superadmin = auth
+
+    # Buscar al usuario objetivo
+    result = await db.execute(
+        select(Users_extend).where(Users_extend.user_id == user_id)
+    )
+    target_ext = result.scalars().first()
+
+    if not target_ext:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"Usuario con ID {user_id} no encontrado.",
+        )
+
+    # No puede darse de baja a sí mismo
+    if user_id == current_user.id:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="No puedes darte de baja a ti mismo.",
+        )
+
+    # Verificar si ya está dado de baja
+    if target_ext.deleted_at is not None:
+        raise HTTPException(
+            status_code=status.HTTP_409_CONFLICT,
+            detail=f"El usuario con ID {user_id} ya está dado de baja.",
+        )
+
+    if not is_superadmin:
+        # Admin de área: solo puede dar de baja a usuarios de su misma área
+        if target_ext.area_id != executor_ext.area_id:
+            raise HTTPException(
+                status_code=status.HTTP_403_FORBIDDEN,
+                detail="Solo puedes dar de baja a usuarios de tu propia área.",
+            )
+
+        # Admin de área: no puede dar de baja a otros admins de área ni superadmins
+        from files_server_fastapi.dependencies.user_dependencies import (
+            _get_privilege_level,
+            PRIVILEGE_AREA_ADMIN,
+        )
+        target_level = await _get_privilege_level(target_ext.rol_id, db)
+        if target_level >= PRIVILEGE_AREA_ADMIN:
+            raise HTTPException(
+                status_code=status.HTTP_403_FORBIDDEN,
+                detail="No puedes dar de baja a un Admin de Área o Superadmin. Contacta a Sistemas.",
+            )
+
+    # Ejecutar el soft delete
+    target_ext.deleted_at = datetime.now(timezone.utc)
+    target_ext.deleted_by = current_user.id
+    db.add(target_ext)
+    await db.commit()
+    await db.refresh(target_ext)
+
+    return {
+        "message": f"Usuario con ID {user_id} dado de baja correctamente.",
+        "deleted_at": target_ext.deleted_at.isoformat(),
+        "deleted_by": current_user.id,
+    }
+
+
+# ==========================================
+# POST /users-extend/{user_id}/reactivate — Reactivar usuario
+# ==========================================
+@router.post(
+    "/{user_id}/reactivate",
+    status_code=status.HTTP_200_OK,
+    summary="Reactivar un usuario dado de baja (solo Sistemas/Superadmin)",
+)
+async def reactivate_user(
+    user_id: int,
+    auth: tuple = Depends(require_superadmin),
+    db: AsyncSession = Depends(get_db_session),
+):
+    """
+    Reactiva a un usuario previamente dado de baja.
+    Solo Sistemas/Superadmin puede ejecutar esta acción.
+
+    El trigger PostgreSQL automáticamente restaura is_verified = TRUE
+    en la tabla users, permitiendo que el usuario vuelva a hacer login.
+    """
+    result = await db.execute(
+        select(Users_extend).where(Users_extend.user_id == user_id)
+    )
+    target_ext = result.scalars().first()
+
+    if not target_ext:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"Usuario con ID {user_id} no encontrado.",
+        )
+
+    if target_ext.deleted_at is None:
+        raise HTTPException(
+            status_code=status.HTTP_409_CONFLICT,
+            detail=f"El usuario con ID {user_id} no está dado de baja.",
+        )
+
+    target_ext.deleted_at = None
+    target_ext.deleted_by = None
+    db.add(target_ext)
+    await db.commit()
+
+    return {
+        "message": f"Usuario con ID {user_id} reactivado correctamente.",
+        "user_id": user_id,
+    }
+
+
+# ==========================================
+# GET /users-extend/inactive — Listar usuarios dados de baja (Auditoría)
+# ==========================================
+@router.get(
+    "/inactive",
+    status_code=status.HTTP_200_OK,
+    summary="Listar usuarios dados de baja (Auditoría — solo Sistemas/Superadmin)",
+)
+async def list_inactive_users(
+    auth: tuple = Depends(require_superadmin),
+    db: AsyncSession = Depends(get_db_session),
+):
+    """
+    Retorna todos los usuarios dados de baja con su fecha y responsable de baja.
+    Solo accesible por Sistemas/Superadmin. Útil para auditoría y trazabilidad.
+    """
+    result = await db.execute(
+        select(Users_extend).where(Users_extend.deleted_at.is_not(None))
+    )
+    inactive_users = result.scalars().all()
+
+    return [
+        {
+            "id": u.id,
+            "user_id": u.user_id,
+            "area_id": u.area_id,
+            "rol_id": u.rol_id,
+            "puesto": u.puesto,
+            "deleted_at": u.deleted_at.isoformat() if u.deleted_at else None,
+            "deleted_by": u.deleted_by,
+        }
+        for u in inactive_users
+    ]

{files_server_fastapi-0.1.44 → files_server_fastapi-0.1.45}/uv.lock

@@ -637,7 +637,7 @@ wheels = [
 
 [[package]]
 name = "files-server-fastapi"
-version = "0.1.43"
+version = "0.1.44"
 source = { editable = "." }
 dependencies = [
     { name = "oauth2fast-fastapi" },

files_server_fastapi-0.1.44/src/files_server_fastapi/models/rol_model.py

@@ -1,13 +0,0 @@
-from typing import Optional
-from datetime import datetime, timezone
-from sqlmodel import Field
-from oauth2fast_fastapi import AuthModel
-
-def get_utc_now():
-    return datetime.now(timezone.utc)
-
-class Rol(AuthModel, table=True):
-    __tablename__ = "rol"
-    
-    role_name: str = Field(nullable=False)
-    description: Optional[str] = Field(default=None)

files_server_fastapi-0.1.44/src/files_server_fastapi/routers/rol_router.py

@@ -1,45 +0,0 @@
-from fastapi import APIRouter, Depends
-from sqlalchemy.ext.asyncio import AsyncSession
-from sqlalchemy import select
-
-from pgsqlasync2fast_fastapi.dependencies import get_db_session
-from files_server_fastapi.models.rol_model import Rol
-
-router = APIRouter(prefix="/roles", tags=["Gestión de Roles"])
-
-@router.post("/", response_model=Rol, summary="Crear un nuevo Rol")
-async def create_rol(rol: Rol, db: AsyncSession = Depends(get_db_session)):
-    db.add(rol)
-    await db.commit()
-    await db.refresh(rol)
-    return rol
-
-@router.get("/", response_model=list[Rol], summary="Obtener todos los Roles")
-async def get_roles(db: AsyncSession = Depends(get_db_session)):
-    result = await db.execute(select(Rol))
-    return result.scalars().all()
-
-@router.put("/{rol_id}", response_model=Rol, summary="Editar un Rol")
-async def update_rol(rol_id: int, rol_data: Rol, db: AsyncSession = Depends(get_db_session)):
-    result = await db.execute(select(Rol).where(Rol.id == rol_id))
-    db_rol = result.scalars().first()
-    if not db_rol:
-        return {"detail": "Rol no encontrado"} # Simplified error handling for now
-    
-    db_rol.role_name = rol_data.role_name
-    db_rol.description = rol_data.description
-    
-    await db.commit()
-    await db.refresh(db_rol)
-    return db_rol
-
-@router.delete("/{rol_id}", summary="Eliminar un Rol")
-async def delete_rol(rol_id: int, db: AsyncSession = Depends(get_db_session)):
-    result = await db.execute(select(Rol).where(Rol.id == rol_id))
-    db_rol = result.scalars().first()
-    if not db_rol:
-        return {"detail": "Rol no encontrado"}
-    
-    await db.delete(db_rol)
-    await db.commit()
-    return {"message": "Rol eliminado correctamente"}