import os import shutil import aiofiles from fastapi import ( FastAPI, UploadFile, File, HTTPException, Request, Depends, Form, APIRouter, status ) import datetime from fastapi.responses import HTMLResponse, FileResponse, JSONResponse, RedirectResponse, Response from fastapi.staticfiles import StaticFiles from fastapi.templating import Jinja2Templates from pathlib import Path import logging # Standard logging import datetime # For admin logic timestamps import math # For admin logic format_bytes from typing import List, Optional # For admin logic type hinting # --- Configuration --- BASE_DIR = Path(__file__).resolve().parent FILES_DIR = BASE_DIR / "uploaded_files" STATIC_DIR = BASE_DIR / "static" TEMPLATES_DIR = BASE_DIR / "templates" # LOG_FILE constant removed # Create directories if they don't exist FILES_DIR.mkdir(parents=True, exist_ok=True) STATIC_DIR.mkdir(parents=True, exist_ok=True) TEMPLATES_DIR.mkdir(parents=True, exist_ok=True) # --- Logging Configuration (Console Only) --- logger = logging.getLogger("file_app") logger.setLevel(logging.INFO) # No file handler, no propagate=False. Logs will go to console via root logger. logger.info("Application starting up... Logging to console.") app = FastAPI(title="File Uploader/Downloader") # Setup Jinja2 templates templates = Jinja2Templates(directory=str(TEMPLATES_DIR)) # --- Admin Panel Configuration & Logic --- ADMIN_EMAIL = "admin@example.com" ADMIN_PASSWORD = "adminpassword" ADMIN_SESSION_COOKIE_NAME = "admin_session_id" ADMIN_SESSION_SECRET_VALUE = "my_super_secret_admin_session_value_for_demo_only_change_me" admin_router = APIRouter( prefix="/admin", tags=["Admin"], ) # --- Admin Helper Functions --- def get_file_info(file_path: Path): try: if file_path.is_file(): stat_info = file_path.stat() return { "name": file_path.name, "size_bytes": stat_info.st_size, "size_human": format_bytes(stat_info.st_size), "modified_at": datetime.datetime.fromtimestamp(stat_info.st_mtime).strftime('%Y-%m-%d %H:%M:%S UTC'), "url": f"/download/{file_path.name}" } except Exception as e: logger.error(f"Admin: Error getting file info for {file_path}: {e}") return None return None def format_bytes(bytes_val, decimals=2): if bytes_val == 0: return '0 Bytes' k = 1024 dm = decimals if decimals >= 0 else 0 sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB', 'PB'] i = 0 if bytes_val > 0: i = int(math.floor(math.log(bytes_val) / math.log(k))) if i >= len(sizes): i = len(sizes) -1 return f"{bytes_val / (k**i):.{dm}f} {sizes[i]}" # get_log_lines function removed as file logging is removed. # --- Admin Authentication Dependencies --- async def get_current_admin(request: Request): session_cookie = request.cookies.get(ADMIN_SESSION_COOKIE_NAME) if session_cookie == ADMIN_SESSION_SECRET_VALUE: return {"email": ADMIN_EMAIL} current_path = request.url.path if current_path not in [app.url_path_for("admin_login_page"), app.url_path_for("admin_authenticate")]: logger.info(f"Admin: Unauthorized access attempt to {current_path}, redirecting to login.") return RedirectResponse(url=app.url_path_for("admin_login_page"), status_code=status.HTTP_307_TEMPORARY_REDIRECT) return None async def verify_admin_auth(request: Request): admin_user = await get_current_admin(request) if isinstance(admin_user, RedirectResponse): raise HTTPException( status_code=status.HTTP_307_TEMPORARY_REDIRECT, detail="Redirecting to login.", headers={"Location": app.url_path_for("admin_login_page")}, ) if not admin_user: logger.warning(f"Admin: Strict auth verification failed for {request.url.path}.") raise HTTPException( status_code=status.HTTP_401_UNAUTHORIZED, detail="Not authenticated", headers={"WWW-Authenticate": "Bearer"}, ) return admin_user # --- Admin Routes --- @admin_router.get("/login", response_class=HTMLResponse, name="admin_login_page") async def admin_login_page(request: Request): logger.info("Admin: Login page accessed.") current_year = datetime.datetime.now(datetime.timezone.utc).year # Get current UTC year return templates.TemplateResponse( "admin_login.html", { "request": request, "url_for": app.url_path_for, "current_year": current_year # Add current year to context } ) @admin_router.post("/auth", name="admin_authenticate") async def admin_authenticate(request: Request, email: str = Form(...), password: str = Form(...)): if email == ADMIN_EMAIL and password == ADMIN_PASSWORD: logger.info(f"Admin: Successful login for email {email}.") response = RedirectResponse(url=app.url_path_for("admin_dashboard"), status_code=status.HTTP_303_SEE_OTHER) response.set_cookie( key=ADMIN_SESSION_COOKIE_NAME, value=ADMIN_SESSION_SECRET_VALUE, httponly=True, samesite="lax", max_age=30 * 60 ) return response else: logger.warning(f"Admin: Failed login attempt for email {email}.") error_msg = "Invalid email or password." return templates.TemplateResponse( "admin_login.html", {"request": request, "error": error_msg, "url_for": app.url_path_for}, status_code=status.HTTP_401_UNAUTHORIZED ) @admin_router.get("/logout", name="admin_logout") async def admin_logout(request: Request): logger.info("Admin: Logout initiated.") response = RedirectResponse(url=app.url_path_for("admin_login_page"), status_code=status.HTTP_303_SEE_OTHER) response.delete_cookie(ADMIN_SESSION_COOKIE_NAME, httponly=True, samesite="lax") return response @admin_router.get("/dashboard", response_class=HTMLResponse, name="admin_dashboard") async def admin_dashboard(request: Request, admin_user: dict = Depends(get_current_admin)): if isinstance(admin_user, RedirectResponse): return admin_user if not admin_user: return RedirectResponse(url=app.url_path_for("admin_login_page"), status_code=status.HTTP_307_TEMPORARY_REDIRECT) logger.info(f"Admin: Dashboard accessed by {admin_user.get('email')}.") num_files = 0 try: num_files = len([name for name in os.listdir(FILES_DIR) if (FILES_DIR / name).is_file()]) except Exception as e: logger.error(f"Admin: Error counting files for dashboard: {e}") # log_lines_count removed return templates.TemplateResponse("admin_dashboard.html", { "request": request, "num_files": num_files, "admin_user": admin_user, "url_for": app.url_path_for }) @admin_router.get("/files", response_class=HTMLResponse, name="admin_files_page") async def admin_files_page(request: Request, admin_user: dict = Depends(get_current_admin)): if isinstance(admin_user, RedirectResponse): return admin_user if not admin_user: return RedirectResponse(url=app.url_path_for("admin_login_page"), status_code=status.HTTP_307_TEMPORARY_REDIRECT) logger.info(f"Admin: Files page accessed by {admin_user.get('email')}.") uploaded_file_objects = [] try: for item_name in sorted(os.listdir(FILES_DIR)): item_path = FILES_DIR / item_name info = get_file_info(item_path) if info: uploaded_file_objects.append(info) except Exception as e: logger.error(f"Admin: Error listing files: {e}") return templates.TemplateResponse("admin_files.html", { "request": request, "files": uploaded_file_objects, "admin_user": admin_user, "url_for": app.url_path_for }) @admin_router.post("/files/delete/{filename}", name="admin_delete_file") async def admin_delete_file(request: Request, filename: str, admin_user: dict = Depends(verify_admin_auth)): logger.info(f"Admin: Attempting to delete file '{filename}' by {admin_user.get('email')}.") safe_filename = sanitize_filename(filename) file_path = FILES_DIR / safe_filename if not file_path.resolve().is_relative_to(FILES_DIR.resolve()): logger.error(f"Admin: Invalid file path for deletion (traversal attempt) '{filename}'.") raise HTTPException(status_code=400, detail="Invalid file path for deletion.") if file_path.is_file(): try: file_path.unlink() logger.info(f"Admin: File '{filename}' deleted successfully by {admin_user.get('email')}.") return RedirectResponse(url=app.url_path_for("admin_files_page") + "?message=File+deleted+successfully", status_code=status.HTTP_303_SEE_OTHER) except Exception as e: logger.error(f"Admin: Could not delete file '{filename}': {str(e)}") raise HTTPException(status_code=500, detail=f"Could not delete file: {str(e)}") else: logger.warning(f"Admin: File not found for deletion '{filename}'.") raise HTTPException(status_code=404, detail="File not found for deletion.") # /admin/logs route and admin_logs_page function removed # --- Main Application Helper Functions (Original) --- def sanitize_filename(filename: str) -> str: return os.path.basename(filename).strip() # --- Main Application Routes (Original functionality with added logging) --- @app.get("/", response_class=HTMLResponse, name="read_root") async def read_root(request: Request): logger.info(f"Root page accessed by {request.client.host}") return templates.TemplateResponse("index.html", {"request": request, "url_for": app.url_path_for}) @app.post("/upload/", name="upload_file") async def upload_file(request: Request, file: UploadFile = File(...)): original_filename = file.filename logger.info(f"Upload attempt for '{original_filename}' from {request.client.host}") if not original_filename: logger.warning(f"Upload failed: No filename provided by {request.client.host}") raise HTTPException(status_code=400, detail="No filename provided.") filename = sanitize_filename(original_filename) if not filename: logger.warning(f"Upload failed: Invalid filename '{original_filename}' after sanitization by {request.client.host}") raise HTTPException(status_code=400, detail="Invalid filename after sanitization.") file_path = FILES_DIR / filename if not file_path.resolve().is_relative_to(FILES_DIR.resolve()): logger.error(f"Upload security violation: Attempted directory traversal for '{filename}' by {request.client.host}") raise HTTPException(status_code=400, detail="Invalid file path (attempted directory traversal).") try: async with aiofiles.open(file_path, "wb") as buffer: while content := await file.read(1024 * 1024): await buffer.write(content) file_size = file_path.stat().st_size logger.info(f"File '{filename}' uploaded successfully by {request.client.host}. Size: {file_size} bytes.") except Exception as e: logger.error(f"Could not save file '{filename}' from {request.client.host}: {str(e)}") if file_path.exists(): try: file_path.unlink() logger.info(f"Cleaned up partially uploaded file '{filename}'.") except Exception as unlink_e: logger.error(f"Error cleaning up partially uploaded file '{filename}': {unlink_e}") raise HTTPException(status_code=500, detail=f"Could not save file: {str(e)}") return JSONResponse( content={ "message": "File uploaded successfully", "filename": filename, "download_url": app.url_path_for("download_file", filename=filename) } ) @app.get("/download/{filename}", name="download_file") async def download_file(request: Request, filename: str): clean_filename = sanitize_filename(filename) logger.info(f"Download attempt for '{clean_filename}' by {request.client.host}") if not clean_filename: logger.warning(f"Download failed: Invalid filename '{filename}' by {request.client.host}") raise HTTPException(status_code=400, detail="Invalid filename.") file_path = FILES_DIR / clean_filename if not file_path.resolve().is_relative_to(FILES_DIR.resolve()) or not file_path.is_file(): logger.warning(f"Download failed: File not found or access denied for '{clean_filename}' by {request.client.host}") raise HTTPException(status_code=404, detail="File not found or access denied.") logger.info(f"File '{clean_filename}' downloaded by {request.client.host}") return FileResponse(path=file_path, filename=clean_filename, media_type='application/octet-stream') app.include_router(admin_router) logger.info("Admin panel router included. File-based logging is disabled.") if __name__ == "__main__": import uvicorn logger.info("Starting Uvicorn server for local development...") uvicorn.run("app:app", host="0.0.0.0", port=7860, reload=True)