rbox/mywebdav/routers/folders.py

from fastapi import APIRouter, Depends, HTTPException, status
from typing import List, Optional

from ..auth import get_current_user
from ..models import User, Folder
from ..schemas import FolderCreate, FolderOut, FolderUpdate, BatchFolderOperation, BatchMoveCopyPayload
from ..activity import log_activity

router = APIRouter(
    prefix="/folders",
    tags=["folders"],
)

@router.post("/", response_model=FolderOut, status_code=status.HTTP_201_CREATED)
async def create_folder(folder_in: FolderCreate, current_user: User = Depends(get_current_user)):
    # Check if parent folder exists and belongs to the current user
    parent_folder = None
    if folder_in.parent_id:
        parent_folder = await Folder.get_or_none(id=folder_in.parent_id, owner=current_user)
        if not parent_folder:
            raise HTTPException(
                status_code=status.HTTP_404_NOT_FOUND,
                detail="Parent folder not found or does not belong to the current user",
            )

    # Check for duplicate folder name in the same parent
    existing_folder = await Folder.get_or_none(
        name=folder_in.name, parent=parent_folder, owner=current_user
    )
    if existing_folder:
        raise HTTPException(
            status_code=status.HTTP_409_CONFLICT,
            detail="Folder with this name already exists in the current parent folder",
        )

    folder = await Folder.create(
        name=folder_in.name, parent=parent_folder, owner=current_user
    )
    await log_activity(current_user, "folder_created", "folder", folder.id)
    return await FolderOut.from_tortoise_orm(folder)

@router.get("/{folder_id}/path", response_model=List[FolderOut])
async def get_folder_path(folder_id: int, current_user: User = Depends(get_current_user)):
    folder = await Folder.get_or_none(id=folder_id, owner=current_user, is_deleted=False)
    if not folder:
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Folder not found")

    path = []
    current = folder
    while current:
        path.insert(0, await FolderOut.from_tortoise_orm(current))
        if current.parent_id:
            current = await Folder.get_or_none(id=current.parent_id, owner=current_user, is_deleted=False)
        else:
            current = None

    return path

@router.get("/{folder_id}", response_model=FolderOut)
async def get_folder(folder_id: int, current_user: User = Depends(get_current_user)):
    folder = await Folder.get_or_none(id=folder_id, owner=current_user, is_deleted=False)
    if not folder:
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Folder not found")
    return await FolderOut.from_tortoise_orm(folder)

@router.get("/", response_model=List[FolderOut])
async def list_folders(parent_id: Optional[int] = None, current_user: User = Depends(get_current_user)):
    if parent_id:
        parent_folder = await Folder.get_or_none(id=parent_id, owner=current_user, is_deleted=False)
        if not parent_folder:
            raise HTTPException(
                status_code=status.HTTP_404_NOT_FOUND,
                detail="Parent folder not found or does not belong to the current user",
            )
        folders = await Folder.filter(parent=parent_folder, owner=current_user, is_deleted=False).order_by("name")
    else:
        # List root folders (folders with no parent)
        folders = await Folder.filter(parent=None, owner=current_user, is_deleted=False).order_by("name")
    return [await FolderOut.from_tortoise_orm(folder) for folder in folders]

@router.put("/{folder_id}", response_model=FolderOut)
async def update_folder(folder_id: int, folder_in: FolderUpdate, current_user: User = Depends(get_current_user)):
    folder = await Folder.get_or_none(id=folder_id, owner=current_user, is_deleted=False)
    if not folder:
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Folder not found")

    if folder_in.name:
        existing_folder = await Folder.get_or_none(
            name=folder_in.name, parent_id=folder.parent_id, owner=current_user
        )
        if existing_folder and existing_folder.id != folder_id:
            raise HTTPException(
                status_code=status.HTTP_409_CONFLICT,
                detail="Folder with this name already exists in the current parent folder",
            )
        folder.name = folder_in.name

    if folder_in.parent_id is not None:
        if folder_in.parent_id == folder_id:
            raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="Cannot set folder as its own parent")
        
        new_parent_folder = None
        if folder_in.parent_id != 0: # 0 could represent moving to root
            new_parent_folder = await Folder.get_or_none(id=folder_in.parent_id, owner=current_user, is_deleted=False)
            if not new_parent_folder:
                raise HTTPException(
                    status_code=status.HTTP_404_NOT_FOUND,
                    detail="New parent folder not found or does not belong to the current user",
                )
        folder.parent = new_parent_folder

    await folder.save()
    await log_activity(current_user, "folder_updated", "folder", folder.id)
    return await FolderOut.from_tortoise_orm(folder)

@router.delete("/{folder_id}", status_code=status.HTTP_204_NO_CONTENT)
async def delete_folder(folder_id: int, current_user: User = Depends(get_current_user)):
    folder = await Folder.get_or_none(id=folder_id, owner=current_user, is_deleted=False)
    if not folder:
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Folder not found")
    
    folder.is_deleted = True
    await folder.save()
    await log_activity(current_user, "folder_deleted", "folder", folder.id)
    return

@router.post("/{folder_id}/star", response_model=FolderOut)
async def star_folder(folder_id: int, current_user: User = Depends(get_current_user)):
    db_folder = await Folder.get_or_none(id=folder_id, owner=current_user, is_deleted=False)
    if not db_folder:
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Folder not found")
    db_folder.is_starred = True
    await db_folder.save()
    await log_activity(current_user, "folder_starred", "folder", folder_id)
    return await FolderOut.from_tortoise_orm(db_folder)

@router.post("/{folder_id}/unstar", response_model=FolderOut)
async def unstar_folder(folder_id: int, current_user: User = Depends(get_current_user)):
    db_folder = await Folder.get_or_none(id=folder_id, owner=current_user, is_deleted=False)
    if not db_folder:
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Folder not found")
    db_folder.is_starred = False
    await db_folder.save()
    await log_activity(current_user, "folder_unstarred", "folder", folder_id)
    return await FolderOut.from_tortoise_orm(db_folder)

@router.post("/batch", response_model=List[FolderOut])
async def batch_folder_operations(
    batch_operation: BatchFolderOperation,
    payload: Optional[BatchMoveCopyPayload] = None,
    current_user: User = Depends(get_current_user)
):
    updated_folders = []
    for folder_id in batch_operation.folder_ids:
        db_folder = await Folder.get_or_none(id=folder_id, owner=current_user, is_deleted=False)
        if not db_folder:
            continue # Skip if folder not found or not owned by user

        if batch_operation.operation == "delete":
            db_folder.is_deleted = True
            await db_folder.save()
            await log_activity(current_user, "folder_deleted", "folder", folder_id)
            updated_folders.append(db_folder)
        elif batch_operation.operation == "star":
            db_folder.is_starred = True
            await db_folder.save()
            await log_activity(current_user, "folder_starred", "folder", folder_id)
            updated_folders.append(db_folder)
        elif batch_operation.operation == "unstar":
            db_folder.is_starred = False
            await db_folder.save()
            await log_activity(current_user, "folder_unstarred", "folder", folder_id)
            updated_folders.append(db_folder)
        elif batch_operation.operation == "move" and payload and payload.target_folder_id is not None:
            target_folder = await Folder.get_or_none(id=payload.target_folder_id, owner=current_user, is_deleted=False)
            if not target_folder:
                continue

            existing_folder = await Folder.get_or_none(
                name=db_folder.name, parent=target_folder, owner=current_user, is_deleted=False
            )
            if existing_folder and existing_folder.id != folder_id:
                continue

            db_folder.parent = target_folder
            await db_folder.save()
            await log_activity(current_user, "folder_moved", "folder", folder_id)
            updated_folders.append(db_folder)
    
    return [await FolderOut.from_tortoise_orm(f) for f in updated_folders]