Update storage/pending_videos_routers.py

storage/pending_videos_routers.py

@@ -0,0 +1,215 @@
+import os
+import io
+import shutil
+
+import sqlite3
+
+from pathlib import Path
+
+from fastapi import APIRouter, UploadFile, File, Query, HTTPException
+from fastapi.responses import FileResponse, JSONResponse
+
+
+from storage.files.file_manager import FileManager
+from storage.common import validate_token
+
+router = APIRouter(prefix="/peding_videos", tags=["Pending Videos Manager"])
+MEDIA_ROOT = Path("/data/peding_videos")
+file_manager = FileManager(MEDIA_ROOT)
+HF_TOKEN = os.getenv("HF_TOKEN")
+
+
+@router.delete("/clear_pending_videos", tags=["Pending Videos Manager"])
+def clear_media(token: str = Query(..., description="Token required for authorization")):
+    """
+    Delete all contents of the /data/peding_videos folder.
+    Steps:
+    - Validate the token.
+    - Ensure the folder exists.
+    - Delete all files and subfolders inside /data/peding_videos.
+    - Return a JSON response confirming the deletion.
+    Warning: This will remove all stored videos, clips, and cast CSV files.
+    """
+    validate_token(token)
+
+    if not MEDIA_ROOT.exists() or not MEDIA_ROOT.is_dir():
+        raise HTTPException(status_code=404, detail="/data/peding_videos folder does not exist")
+
+    # Delete contents
+    for item in MEDIA_ROOT.iterdir():
+        try:
+            if item.is_dir():
+                shutil.rmtree(item)
+            else:
+                item.unlink()
+        except Exception as e:
+            raise HTTPException(status_code=500, detail=f"Failed to delete {item}: {e}")
+
+    return {"status": "ok", "message": "All peding_videos files deleted successfully"}
+
+
+@router.post("/upload_peding_video", tags=["Pending Videos Manager"])
+async def upload_video(
+    video: UploadFile = File(...),
+    token: str = Query(..., description="Token required for authorization")
+):
+    """
+    Saves an uploaded video by hashing it with SHA1 and placing it under:
+    /data/media/<sha1>/<original_filename>
+    Behavior:
+    - Compute SHA1 of the uploaded video.
+    - Ensure folder structure exists.
+    - Delete any existing .mp4 files under sha1.
+    - Save the uploaded video in the folder.
+    """
+    # Read content into memory (needed to compute hash twice)
+    file_bytes = await video.read()
+
+    # Create an in-memory file handler for hashing
+    file_handler = io.BytesIO(file_bytes)
+
+    # Compute SHA1
+    try:
+        sha1 = file_manager.compute_sha1(file_handler)
+    except Exception as exc:
+        raise HTTPException(status_code=500, detail=f"SHA1 computation failed: {exc}")
+
+    # Ensure /data/media exists
+    MEDIA_ROOT.mkdir(parents=True, exist_ok=True)
+
+    # Path: /data/media/<sha1>
+    video_root = MEDIA_ROOT / sha1
+    video_root.mkdir(parents=True, exist_ok=True)
+
+    # Delete old MP4 files
+    try:
+        for old_mp4 in video_root.glob("*.mp4"):
+            old_mp4.unlink()
+    except Exception as exc:
+        raise HTTPException(status_code=500, detail=f"Failed to delete old videos: {exc}")
+
+    # Save new video path
+    final_path = video_root / video.filename
+
+    # Save file
+    save_result = file_manager.upload_file(io.BytesIO(file_bytes), final_path)
+
+    if not save_result["operation_success"]:
+        raise HTTPException(status_code=500, detail=save_result["error"])
+
+    return JSONResponse(
+        status_code=200,
+        content={
+            "status": "ok",
+            "sha1": sha1,
+            "saved_to": str(final_path)
+        }
+    )
+
+
+@router.get("/download_peding_video", tags=["Pending Videos Manager"])
+def download_video(
+    sha1: str,
+    token: str = Query(..., description="Token required for authorization")
+    ):
+    """
+    Download a stored video by its SHA-1 directory name.
+    This endpoint looks for a video stored under the path:
+        /data/media/<sha1>/clip/
+    and returns the first MP4 file found in that folder.
+    The method performs the following steps:
+    - Checks if the SHA-1 folder exists inside the media root.
+    - Validates that the "clip" subfolder exists.
+    - Searches for the first .mp4 file inside the clip folder.
+    - Uses the FileManager.get_file method to ensure the file is accessible.
+    - Returns the video directly as a FileResponse.
+    Parameters
+    ----------
+    sha1 : str
+        The SHA-1 hash corresponding to the directory where the video is stored.
+    Returns
+    -------
+    FileResponse
+        A streaming response containing the MP4 video.
+    Raises
+    ------
+    HTTPException
+        - 404 if the SHA-1 folder does not exist.
+        - 404 if the clip folder is missing.
+        - 404 if no MP4 files are found.
+        - 404 if the file cannot be retrieved using FileManager.
+    """
+    sha1_folder = MEDIA_ROOT / sha1
+
+    if not sha1_folder.exists() or not sha1_folder.is_dir():
+        raise HTTPException(status_code=404, detail="SHA1 folder not found")
+
+    # Find first MP4 file
+    mp4_files = list(sha1_folder.glob("*.mp4"))
+    if not mp4_files:
+        raise HTTPException(status_code=404, detail="No MP4 files found")
+
+    video_path = mp4_files[0]
+
+    # Convert to relative path for FileManager
+    relative_path = video_path.relative_to(MEDIA_ROOT)
+
+    handler = file_manager.get_file(relative_path)
+    if handler is None:
+        raise HTTPException(status_code=404, detail="Video not accessible")
+
+    handler.close()
+
+    return FileResponse(
+        path=video_path,
+        media_type="video/mp4",
+        filename=video_path.name
+    )
+
+@router.get("/list_peding_videos", tags=["Pending Videos Manager"])
+def list_all_videos(
+    token: str = Query(..., description="Token required for authorization")
+):
+    """
+    List all videos stored under /data/media.
+    For each SHA1 folder, the endpoint returns:
+    - sha1: folder name
+    - video_files: list of mp4 files inside /clip
+    - latest_video: the most recently modified mp4
+    - video_count: total number of mp4 files
+    Notes:
+    - Videos may not have a /clip folder.
+    - SHA1 folders without mp4 files are still returned.
+    """
+    validate_token(token)
+
+    results = []
+
+    # If media root does not exist, return empty list
+    if not MEDIA_ROOT.exists():
+        return []
+
+    for sha1_dir in MEDIA_ROOT.iterdir():
+        if not sha1_dir.is_dir():
+            continue  # skip non-folders
+
+        videos = []
+        latest_video = None
+
+        if sha1_dir.exists() and sha1_dir.is_dir():
+            mp4_files = list(sha1_dir.glob("*.mp4"))
+
+            # Sort by modification time (newest first)
+            mp4_files.sort(key=lambda f: f.stat().st_mtime, reverse=True)
+
+            videos = [f.name for f in mp4_files]
+
+            if mp4_files:
+                latest_video = mp4_files[0].name
+
+        results.append({
+            "sha1": sha1_dir.name,
+            "video_name": latest_video
+        })
+
+    return results