Update app.py

app.py

@@ -5,7 +5,7 @@ from datetime import datetime, timedelta
 from typing import List, Dict, Optional, Any
 
 import secrets
-from fastapi import FastAPI, Depends, HTTPException, status, UploadFile, File, Form
+from fastapi import FastAPI, Depends, HTTPException, status, UploadFile, File, Query
 from fastapi.security import OAuth2PasswordBearer, OAuth2PasswordRequestForm
 from fastapi.staticfiles import StaticFiles
 from fastapi.responses import FileResponse, RedirectResponse
@@ -41,15 +41,13 @@ class Token(BaseModel):
 class TokenData(BaseModel):
     username: Optional[str] = None
 
-class EpisodeUpdate(BaseModel):
-    """Data required to add an episode to the watch history."""
+# NEW: Model for a single watch history record, including the timestamp
+class WatchHistoryEntry(BaseModel):
     show_id: str
+    show_title: str
     season_number: int
     episode_number: int
-
-class WatchedEpisode(EpisodeUpdate):
-    """Represents a single episode in the user's watch history, including the timestamp."""
-    watch_timestamp: datetime
+    watch_timestamp: datetime # Will be stored as an ISO 8601 string in JSON
 
 class UserBase(BaseModel):
     username: str
@@ -60,6 +58,7 @@ class UserCreate(UserBase):
 class UserInDB(UserBase):
     hashed_password: str
     profile_picture_url: Optional[str] = None
+    # This reflects the raw data stored in the JSON file
     watch_history: List[Dict[str, Any]] = Field(default_factory=list)
 
 class UserPublic(UserBase):
@@ -78,8 +77,14 @@ def load_users() -> Dict[str, Dict]:
             return {}
 
 def save_users(users_db: Dict[str, Dict]):
+    # Use a custom default function to handle datetime objects during JSON serialization
+    def json_serializer(obj):
+        if isinstance(obj, datetime):
+            return obj.isoformat()
+        raise TypeError(f"Type {type(obj)} not serializable")
+
     with open(USERS_DB_FILE, "w") as f:
-        json.dump(users_db, f, indent=4)
+        json.dump(users_db, f, indent=4, default=json_serializer)
 
 # --- Password & Token Functions ---
 def verify_password(plain_password, hashed_password):
@@ -126,24 +131,28 @@ async def get_current_user(token: str = Depends(oauth2_scheme)) -> UserInDB:
 app = FastAPI(title="Media Auth API")
 
 # CORS middleware to allow the frontend to communicate with the API
-# This is crucial for web apps.
 app.add_middleware(
     CORSMiddleware,
-    allow_origins=["*"],  # Allows all origins
+    allow_origins=["*"],
     allow_credentials=True,
-    allow_methods=["*"],  # Allows all methods
-    allow_headers=["*"],  # Allows all headers
+    allow_methods=["*"],
+    allow_headers=["*"],
 )
 
 # --- Helper function to structure watch history for the frontend ---
+# MODIFIED: Now includes the watch timestamp for each episode.
 def structure_watch_history(history_list: List[Dict]) -> Dict:
     """Transforms a flat list of watched episodes into a nested dictionary."""
     structured = {}
-    for item in history_list:
+    # Sort by timestamp to ensure the latest watch time is used if duplicates exist
+    sorted_history = sorted(history_list, key=lambda x: x.get("watch_timestamp", ""), reverse=True)
+    
+    for item in sorted_history:
         show_id = item.get("show_id")
         show_title = item.get("show_title", "Unknown Show")
         season_num = item.get("season_number")
         episode_num = item.get("episode_number")
+        timestamp = item.get("watch_timestamp")
 
         if show_id not in structured:
             structured[show_id] = {
@@ -156,7 +165,8 @@ def structure_watch_history(history_list: List[Dict]) -> Dict:
                 "season_number": season_num,
                 "episodes": {}
             }
-        structured[show_id]["seasons"][season_num]["episodes"][episode_num] = True
+        # Store the timestamp instead of just 'True'
+        structured[show_id]["seasons"][season_num]["episodes"][episode_num] = timestamp
     return structured
 
 
@@ -194,7 +204,9 @@ async def signup_user(user: UserCreate):
             detail="Username already registered",
         )
     hashed_password = get_password_hash(user.password)
+    # Note: watch_history defaults to an empty list
     new_user = UserInDB(username=user.username, hashed_password=hashed_password)
+    # Pydantic's .dict() serializes the model to a dictionary suitable for JSON
     users_db[user.username] = new_user.dict()
     save_users(users_db)
     return {"message": "User created successfully. Please login."}
@@ -205,10 +217,8 @@ async def read_users_me(current_user: UserInDB = Depends(get_current_user)):
     """
     Fetch the profile of the currently authenticated user.
     """
-    # The frontend expects a detailed, nested history object. We transform it here.
     detailed_history = structure_watch_history(current_user.watch_history)
     
-    # We create a UserPublic object to avoid sending the hashed_password
     user_public_data = UserPublic(
         username=current_user.username,
         profile_picture_url=current_user.profile_picture_url,
@@ -225,23 +235,18 @@ async def upload_profile_picture(
     """
     Upload or update the user's profile picture.
     """
-    # Generate a unique filename to prevent overwrites and add extension
     file_extension = os.path.splitext(file.filename)[1]
     unique_filename = f"{uuid.uuid4()}{file_extension}"
     file_path = os.path.join(UPLOAD_DIR, unique_filename)
 
-    # Save the file
     with open(file_path, "wb") as buffer:
         buffer.write(await file.read())
 
-    # Update user data with the URL to the new picture
-    # The URL must match the static file mount path
     profile_picture_url = f"/uploads/{unique_filename}"
     users_db = load_users()
     users_db[current_user.username]["profile_picture_url"] = profile_picture_url
     save_users(users_db)
 
-    # Return the updated user profile
     current_user.profile_picture_url = profile_picture_url
     detailed_history = structure_watch_history(current_user.watch_history)
     return UserPublic(
@@ -251,66 +256,25 @@ async def upload_profile_picture(
     )
 
 
-import status
-from fastapi import Depends, APIRouter
-from pydantic import BaseModel
-from datetime import datetime, timezone
-from typing import List
-
-# Assume these are defined elsewhere in your application
-# from .dependencies import get_current_user, load_users, save_users
-# from .models import UserInDB
-
-# --- Pydantic Models ---
-# It's good practice to define your data models clearly.
-
-
-
-
-
-
-@app.get("/users/me/watch-history", response_model=List[WatchedEpisode])
-async def get_watch_history(
-    current_user: UserInDB = Depends(get_current_user)
-):
-    """
-    Retrieves the current user's watch history, sorted by most recently watched.
-    """
-    users_db = load_users()
-    user_data = users_db.get(current_user.username, {})
-    
-    # Get the watch history, defaulting to an empty list if it doesn't exist
-    watch_history = user_data.get("watch_history", [])
-    
-    # Optional: Sort the history so the most recently watched items are first
-    # The `key` lambda function handles cases where an old item might not have a timestamp.
-    watch_history.sort(
-        key=lambda item: item.get("watch_timestamp", "1970-01-01T00:00:00Z"), 
-        reverse=True
-    )
-    
-    return watch_history
-
-
-@app.post("/users/me/watch-history", status_code=status.HTTP_200_OK)
+# MODIFIED: Changed from POST to GET, accepts query parameters, and adds a timestamp.
+@app.get("/users/me/watch-history", status_code=status.HTTP_200_OK, tags=["User"])
 async def update_watch_history(
-    episode_data: EpisodeUpdate,
+    show_id: str = Query(..., description="The unique ID of the show (e.g., from TMDB)"),
+    show_title: str = Query(..., description="The title of the show"),
+    season_number: int = Query(..., ge=0, description="The season number"),
+    episode_number: int = Query(..., ge=1, description="The episode number"),
     current_user: UserInDB = Depends(get_current_user)
 ):
     """
-    Adds a new episode with a timestamp to the user's watch history.
-    If the episode already exists, its timestamp is not updated.
+    Adds a new episode to the user's watch history via GET query parameters.
+    Includes a server-generated timestamp for when the episode was marked as watched.
     """
     users_db = load_users()
     user_data = users_db[current_user.username]
-    
-    # Ensure watch_history list exists
-    if "watch_history" not in user_data:
-        user_data["watch_history"] = []
 
     # Create a unique identifier for the episode to prevent duplicates
-    episode_id = f"{episode_data.show_id}_{episode_data.season_number}_{episode_data.episode_number}"
-    
+    episode_id = f"{show_id}_{season_number}_{episode_number}"
+
     # Check if this exact episode is already in the history
     is_already_watched = any(
         (f"{item.get('show_id')}_{item.get('season_number')}_{item.get('episode_number')}" == episode_id)
@@ -318,29 +282,27 @@ async def update_watch_history(
     )
 
     if not is_already_watched:
-        # Convert the Pydantic model to a dictionary to add the new field
-        new_episode_record = episode_data.dict()
-        
-        # Add the UTC timestamp in standard ISO format
-        new_episode_record["watch_timestamp"] = datetime.now(timezone.utc).isoformat()
-        
-        user_data["watch_history"].append(new_episode_record)
+        # Create a new entry using our Pydantic model for validation and structure
+        new_entry = WatchHistoryEntry(
+            show_id=show_id,
+            show_title=show_title,
+            season_number=season_number,
+            episode_number=episode_number,
+            watch_timestamp=datetime.utcnow() # Add server-side timestamp
+        )
+        # .dict() converts the model (including the datetime object) to a JSON-serializable dict
+        user_data["watch_history"].append(new_entry.dict())
         save_users(users_db)
         return {"message": "Watch history updated."}
-    
+
     return {"message": "Episode already in watch history."}
 
 
 # --- Static File Serving ---
-# This serves the uploaded profile pictures from the persistent /data/uploads directory
 app.mount("/uploads", StaticFiles(directory=UPLOAD_DIR), name="uploads")
-
-# This serves the main login/settings pages from the /static directory
-# 'html=True' makes it so that visiting "/" serves "index.html" (we'll name login.html as index.html)
 app.mount("/", StaticFiles(directory="static", html=True), name="static")
 
 
-# Redirect root to login page for convenience
 @app.get("/", include_in_schema=False)
 def root():
     return RedirectResponse(url="/login.html")