Update app.py

app.py

@@ -73,242 +73,87 @@ async def root():
         }
     }
 
-@app.post("/upload/")
-async def upload_file(file: UploadFile = File(...)):
-    """Uploads a file and stores it by filename inside the upload folder"""
-    log_request("upload", {"filename": file.filename})
-    
-    if not file.filename.lower().endswith('.mp4'):
-        raise HTTPException(status_code=400, detail="Only MP4 files are allowed")
-    
-    save_path = os.path.join(MP4_UPLOAD_FOLDER, file.filename)
-    save_file(file, save_path)
-    
-    logger.info(f"File uploaded successfully: {file.filename}")
-    return {"status": "uploaded", "filename": file.filename, "size": os.path.getsize(save_path)}
+@app.get("/courses")
+async def get_courses():
+    """List all top-level course folders."""
+    try:
+        courses = [d.name for d in Path(MP4_OUTPUT_FOLDER).iterdir() if d.is_dir()]
+        return {"courses": courses, "total": len(courses)}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Failed to list courses: {e}")
 
-@app.get("/list")
-async def list_uploaded_files():
-    """List uploaded MP4 files"""
-    log_request("list")
+@app.get("/images/{course_folder:path}")
+async def get_mp4_list(course_folder: str):
+    """List all MP4 files within a specific course folder."""
+    course_path = Path(MP4_OUTPUT_FOLDER) / course_folder
     
-    files = []
-    if os.path.exists(MP4_UPLOAD_FOLDER):
-        for file in os.listdir(MP4_UPLOAD_FOLDER):
-            if file.lower().endswith(".mp4"):
-                file_path = os.path.join(MP4_UPLOAD_FOLDER, file)
-                files.append({
-                    "filename": file,
-                    "size": os.path.getsize(file_path),
-                    "modified": os.path.getmtime(file_path)
-                })
+    if not course_path.is_dir():
+        raise HTTPException(status_code=404, detail="Course folder not found")
     
-    logger.info(f"Listed {len(files)} uploaded files")
-    return JSONResponse(content=files)
+    try:
+        mp4_files = [f.name for f in course_path.iterdir() if f.is_file() and f.suffix.lower() == ".mp4"]
+        return mp4_files
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Failed to list MP4s: {e}")
 
 @app.get("/download")
-async def download_file(course: str = Query(..., description="Course folder name"), 
-                       file: str = Query(..., description="MP4 filename")):
-    """
-    Download any MP4 under processed_mp4s, including nested course folders.
-    Usage: GET /download?course=MDS_CGAdventure_DownloadPirate.com&file=1.mp4
-    """
-    log_request("download", {"course": course, "file": file})
-    
-    logger.info(f"[DOWNLOAD] Request for course: {course}, file: {file}")
+async def download_mp4(course: str, file: str):
+    """Download a specific MP4 file from a course folder."""
+    file_path = Path(MP4_OUTPUT_FOLDER) / course / file
     
-    # Validate inputs
-    if not course or not file:
-        raise HTTPException(status_code=400, detail="Both course and file parameters are required")
+    if not file_path.is_file():
+        raise HTTPException(status_code=404, detail="File not found")
     
-    if not file.lower().endswith('.mp4'):
-        raise HTTPException(status_code=400, detail="File must be an MP4")
-    
-    # Security: Clean the inputs
-    course = course.strip().replace('..', '').replace('\\', '/')
-    file = file.strip().replace('..', '').replace('\\', '/')
-    
-    # Prevent path traversal in individual components
-    if '/' in file or '\\' in file:
-        raise HTTPException(status_code=400, detail="File parameter cannot contain path separators")
-    
-    # Construct the path
-    mp4_path = f"{course}/{file}"
-    full_path = os.path.join(MP4_OUTPUT_FOLDER, course, file)
-    
-    logger.info(f"[DOWNLOAD] Constructed path: {mp4_path}")
-    logger.info(f"[DOWNLOAD] Full system path: {full_path}")
-
-    # Security: Prevent directory traversal
-    full_path = os.path.normpath(full_path)
-    base_path = os.path.abspath(MP4_OUTPUT_FOLDER)
-    
-    if not full_path.startswith(base_path):
-        logger.warning(f"[SECURITY] Path traversal attempt - course: {course}, file: {file}")
-        raise HTTPException(status_code=400, detail="Invalid path - security violation")
-
-    logger.info(f"[DOWNLOAD] Normalized path: {full_path}")
-    logger.info(f"[DOWNLOAD] File exists: {os.path.exists(full_path)}")
-    
-    if not os.path.exists(full_path):
-        logger.warning(f"[DOWNLOAD] File not found: {full_path}")
-        
-        # Debug: Show what's actually in the course folder
-        course_path = os.path.join(MP4_OUTPUT_FOLDER, course)
-        logger.info(f"[DOWNLOAD] Checking course folder: {course_path}")
-        
-        if os.path.exists(course_path):
-            logger.info(f"[DOWNLOAD] Course folder exists, contents:")
-            try:
-                for item in os.listdir(course_path):
-                    item_path = os.path.join(course_path, item)
-                    if os.path.isfile(item_path):
-                        logger.info(f"[DOWNLOAD]   File: {item} ({os.path.getsize(item_path)} bytes)")
-                    else:
-                        logger.info(f"[DOWNLOAD]   Directory: {item}")
-            except Exception as e:
-                logger.error(f"[DOWNLOAD] Error listing course contents: {e}")
-        else:
-            logger.info(f"[DOWNLOAD] Course folder does not exist")
-            
-            # Show available courses
-            logger.info("[DOWNLOAD] Available courses:")
-            if os.path.exists(MP4_OUTPUT_FOLDER):
-                for item in os.listdir(MP4_OUTPUT_FOLDER):
-                    item_path = os.path.join(MP4_OUTPUT_FOLDER, item)
-                    if os.path.isdir(item_path):
-                        logger.info(f"[DOWNLOAD]   Course: {item}")
-        
-        raise HTTPException(
-            status_code=404, 
-            detail=f"File not found: {file} in course {course}"
-        )
+    return FileResponse(path=file_path, media_type="video/mp4", filename=file)
 
-    file_size = os.path.getsize(full_path)
-    logger.info(f"[DOWNLOAD] Serving file: {full_path} ({file_size} bytes)")
+@app.get("/debug/structure")
+async def debug_structure():
+    """Debug endpoint to inspect the file structure and sizes."""
+    mp4_output_folder_path = Path(MP4_OUTPUT_FOLDER)
     
-    return FileResponse(
-        path=full_path, 
-        filename=file, 
-        media_type="video/mp4",
-        headers={
-            "Content-Length": str(file_size),
-            "Accept-Ranges": "bytes"
+    structure = {}
+    total_size_bytes = 0
+    total_mp4_files = 0
+
+    if not mp4_output_folder_path.exists():
+        return JSONResponse(content={
+            "mp4_output_folder": str(mp4_output_folder_path),
+            "folder_exists": False,
+            "total_mp4_files": 0,
+            "total_size_bytes": 0,
+            "structure": {}
+        })
+
+    for root, dirs, files in os.walk(mp4_output_folder_path):
+        current_path = Path(root)
+        relative_path = str(current_path.relative_to(mp4_output_folder_path))
+        if relative_path == ".":
+            relative_path = "/"
+
+        structure[relative_path] = {
+            "directories": [d for d in dirs],
+            "mp4_files": [],
+            "other_files": []
         }
-    )
 
-@app.get("/courses")
-async def list_courses():
-    """List all unique course folder names based on extracted MP4 paths."""
-    log_request("courses")
-    
-    course_folders = set()
-    
-    logger.info(f"[COURSES] Scanning {MP4_OUTPUT_FOLDER} for courses")
+        for file in files:
+            file_full_path = current_path / file
+            file_size = file_full_path.stat().st_size
+            total_size_bytes += file_size
 
-    if os.path.exists(MP4_OUTPUT_FOLDER):
-        for root, dirs, files in os.walk(MP4_OUTPUT_FOLDER):
-            for file in files:
-                if file.lower().endswith(".mp4"):
-                    rel_path = os.path.relpath(os.path.join(root, file), MP4_OUTPUT_FOLDER)
-                    course_folder = os.path.dirname(rel_path)
-                    if course_folder and course_folder != ".":
-                        course_folders.add(course_folder)
-                        logger.info(f"[COURSES] Found course: {course_folder} (from file: {rel_path})")
-
-    courses_list = sorted(course_folders)
-    logger.info(f"[COURSES] Returning {len(courses_list)} courses: {courses_list}")
-    return JSONResponse(content={"courses": courses_list, "total": len(courses_list)})
-
-@app.get("/images/{course_folder:path}")
-async def list_mp4s_in_course(course_folder: str):
-    """List MP4s available for a specific course folder"""
-    log_request("images", {"course_folder": course_folder})
-    
-    logger.info(f"[IMAGES] Listing MP4s for course: {course_folder}")
-    
-    course_path = os.path.join(MP4_OUTPUT_FOLDER, course_folder)
-    logger.info(f"[IMAGES] Course path: {course_path}")
-    logger.info(f"[IMAGES] Path exists: {os.path.exists(course_path)}")
-    
-    if not os.path.exists(course_path):
-        logger.warning(f"[IMAGES] Course folder not found: {course_folder}")
-        
-        # List what's actually available
-        logger.info("[IMAGES] Available course folders:")
-        if os.path.exists(MP4_OUTPUT_FOLDER):
-            for item in os.listdir(MP4_OUTPUT_FOLDER):
-                item_path = os.path.join(MP4_OUTPUT_FOLDER, item)
-                if os.path.isdir(item_path):
-                    logger.info(f"[IMAGES]   {item}")
-        
-        raise HTTPException(status_code=404, detail=f"Course folder not found: {course_folder}")
-
-    mp4s = []
-    try:
-        for file in os.listdir(course_path):
             if file.lower().endswith(".mp4"):
-                mp4s.append(file)
-                file_path = os.path.join(course_path, file)
-                file_size = os.path.getsize(file_path)
-                logger.info(f"[IMAGES] Found MP4: {file} ({file_size} bytes)")
-    except Exception as e:
-        logger.error(f"[IMAGES] Failed to list files in {course_path}: {e}")
-        raise HTTPException(status_code=500, detail="Failed to list files")
-
-    logger.info(f"[IMAGES] Returning {len(mp4s)} MP4s: {mp4s}")
-    return JSONResponse(content=mp4s)
+                structure[relative_path]["mp4_files"].append({"name": file, "size": file_size})
+                total_mp4_files += 1
+            else:
+                structure[relative_path]["other_files"].append({"name": file, "size": file_size})
 
-@app.get("/debug/structure")
-async def debug_file_structure():
-    """Debug endpoint to show the actual file structure"""
-    log_request("debug/structure")
-    
-    structure = {}
-    total_files = 0
-    total_size = 0
-    
-    if os.path.exists(MP4_OUTPUT_FOLDER):
-        for root, dirs, files in os.walk(MP4_OUTPUT_FOLDER):
-            rel_root = os.path.relpath(root, MP4_OUTPUT_FOLDER)
-            if rel_root == ".":
-                rel_root = "/"
-            
-            mp4_files = []
-            other_files = []
-            
-            for file in files:
-                file_path = os.path.join(root, file)
-                file_size = os.path.getsize(file_path)
-                total_size += file_size
-                
-                file_info = {
-                    "name": file,
-                    "size": file_size,
-                    "modified": os.path.getmtime(file_path)
-                }
-                
-                if file.lower().endswith('.mp4'):
-                    mp4_files.append(file_info)
-                    total_files += 1
-                else:
-                    other_files.append(file_info)
-            
-            structure[rel_root] = {
-                "directories": dirs,
-                "mp4_files": mp4_files,
-                "other_files": other_files
-            }
-    
-    logger.info(f"[DEBUG] File structure scan complete - {total_files} MP4 files, {total_size} bytes total")
-    
-    return JSONResponse(content={
-        "mp4_output_folder": MP4_OUTPUT_FOLDER,
-        "folder_exists": os.path.exists(MP4_OUTPUT_FOLDER),
-        "total_mp4_files": total_files,
-        "total_size_bytes": total_size,
+    return {
+        "mp4_output_folder": str(mp4_output_folder_path),
+        "folder_exists": mp4_output_folder_path.exists(),
+        "total_mp4_files": total_mp4_files,
+        "total_size_bytes": total_size_bytes,
         "structure": structure
-    })
+    }
 
 @app.on_event("startup")
 async def startup_event():