Update app.py

app.py

@@ -1,7 +1,7 @@
 from fastapi import FastAPI, HTTPException, Header, Depends
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.staticfiles import StaticFiles
-from fastapi.responses import FileResponse, HTMLResponse
+from fastapi.responses import FileResponse
 from pydantic import BaseModel
 from typing import Optional, List
 from datetime import datetime
@@ -9,82 +9,65 @@ import json
 import os
 from pathlib import Path
 
-# Load Secret from Environment Variable (Set this in HF Spaces Settings)
-ADMIN_PASSWORD = os.getenv("ADMIN_PASSWORD", "default_secure_password")
+# Load Secret from Environment Variable
+# On HF Spaces, set 'ADMIN_PASSWORD' in the Settings > Secrets tab
+ADMIN_PASSWORD = os.getenv("ADMIN_PASSWORD")
 
 DATA_DIR = Path("data")
 DATA_DIR.mkdir(exist_ok=True)
 
 ARTICLES_FILE = DATA_DIR / "articles.json"
-SNIPPETS_FILE = DATA_DIR / "snippets.json"
 COMMENTS_FILE = DATA_DIR / "comments.json"
 
-for file in [ARTICLES_FILE, SNIPPETS_FILE, COMMENTS_FILE]:
+for file in [ARTICLES_FILE, COMMENTS_FILE]:
     if not file.exists():
         file.write_text("[]")
 
 def read_json(file_path):
-    with open(file_path, 'r') as f:
-        return json.load(f)
+    try:
+        with open(file_path, 'r') as f:
+            return json.load(f)
+    except:
+        return []
 
 def write_json(file_path, data):
     with open(file_path, 'w') as f:
         json.dump(data, f, indent=2, default=str)
 
-# Security Dependency
 async def verify_admin(x_admin_password: Optional[str] = Header(None)):
     if x_admin_password != ADMIN_PASSWORD:
         raise HTTPException(status_code=401, detail="Unauthorized Access")
     return True
 
-# Pydantic models
+# --- MODELS ---
 class ArticleCreate(BaseModel):
     title: str
     slug: str
     content: str
-    excerpt: Optional[str] = None
-    tags: Optional[List[str]] = []
-    published: bool = False
+    excerpt: Optional[str] = ""
+    tags: List[str] = []
+    published: bool = True
 
 class ArticleResponse(BaseModel):
     id: int
     title: str
     slug: str
     content: str
-    excerpt: Optional[str]
-    tags: Optional[List[str]]
+    excerpt: str
+    tags: List[str]
     published: bool
     created_at: str
-    updated_at: str
-
-class SnippetCreate(BaseModel):
-    title: str
-    description: Optional[str] = None
-    code: str
-    language: str
-    tags: Optional[List[str]] = []
-
-class CommentCreate(BaseModel):
-    author_name: str
-    content: str
-
-class CommentResponse(BaseModel):
-    id: int
-    article_id: int
-    author_name: str
-    content: str
-    created_at: str
 
 app = FastAPI(title="Aditya's DevLog API")
 
 app.add_middleware(
     CORSMiddleware,
     allow_origins=["*"],
-    allow_credentials=True,
     allow_methods=["*"],
     allow_headers=["*"],
 )
 
+# Serve UI
 app.mount("/static", StaticFiles(directory="static"), name="static")
 
 @app.get("/")
@@ -95,14 +78,25 @@ async def read_root():
 async def read_admin():
     return FileResponse("static/admin.html")
 
-# --- ARTICLES ---
+# --- API ---
+@app.get("/api/articles", response_model=List[ArticleResponse])
+async def get_articles(published_only: bool = True):
+    articles = read_json(ARTICLES_FILE)
+    if published_only:
+        articles = [a for a in articles if a.get('published', True)]
+    # Ensure nested fields exist to avoid frontend crashes
+    for a in articles:
+        if "tags" not in a or a["tags"] is None: a["tags"] = []
+        if "excerpt" not in a or a["excerpt"] is None: a["excerpt"] = ""
+    return sorted(articles, key=lambda x: x['created_at'], reverse=True)
+
 @app.get("/api/articles/{slug}", response_model=ArticleResponse)
 async def get_article(slug: str):
     articles = read_json(ARTICLES_FILE)
-    # Ensure we strip any whitespace and handle case sensitivity
-    article = next((a for a in articles if a['slug'].strip().lower() == slug.strip().lower()), None)
+    article = next((a for a in articles if a['slug'].lower() == slug.lower()), None)
     if not article:
-        raise HTTPException(status_code=404, detail=f"Article with slug '{slug}' not found")
+        raise HTTPException(status_code=404, detail="Article not found")
+    if "tags" not in article or article["tags"] is None: article["tags"] = []
     return article
 
 @app.post("/api/articles", response_model=ArticleResponse)
@@ -112,10 +106,10 @@ async def create_article(article: ArticleCreate, auth: bool = Depends(verify_adm
         raise HTTPException(status_code=400, detail="Slug already exists")
     
     new_id = max([a['id'] for a in articles], default=0) + 1
-    now = datetime.utcnow().isoformat()
     new_article = {
-        "id": new_id, **article.dict(),
-        "created_at": now, "updated_at": now
+        "id": new_id,
+        **article.dict(),
+        "created_at": datetime.utcnow().isoformat()
     }
     articles.append(new_article)
     write_json(ARTICLES_FILE, articles)
@@ -126,43 +120,7 @@ async def delete_article(article_id: int, auth: bool = Depends(verify_admin)):
     articles = read_json(ARTICLES_FILE)
     articles = [a for a in articles if a['id'] != article_id]
     write_json(ARTICLES_FILE, articles)
-    return {"message": "Purged"}
-
-# --- SNIPPETS ---
-@app.get("/api/snippets")
-async def get_snippets():
-    snippets = read_json(SNIPPETS_FILE)
-    return sorted(snippets, key=lambda x: x['created_at'], reverse=True)
-
-@app.post("/api/snippets")
-async def create_snippet(snippet: SnippetCreate, auth: bool = Depends(verify_admin)):
-    snippets = read_json(SNIPPETS_FILE)
-    new_id = max([s['id'] for s in snippets], default=0) + 1
-    new_snippet = {
-        "id": new_id, **snippet.dict(),
-        "created_at": datetime.utcnow().isoformat()
-    }
-    snippets.append(new_snippet)
-    write_json(SNIPPETS_FILE, snippets)
-    return new_snippet
-
-# --- COMMENTS ---
-@app.get("/api/articles/{article_id}/comments", response_model=List[CommentResponse])
-async def get_comments(article_id: int):
-    comments = read_json(COMMENTS_FILE)
-    return [c for c in comments if c['article_id'] == article_id]
-
-@app.post("/api/articles/{article_id}/comments", response_model=CommentResponse)
-async def create_comment(article_id: int, comment: CommentCreate):
-    comments = read_json(COMMENTS_FILE)
-    new_id = max([c['id'] for c in comments], default=0) + 1
-    new_comment = {
-        "id": new_id, "article_id": article_id, **comment.dict(),
-        "created_at": datetime.utcnow().isoformat()
-    }
-    comments.append(new_comment)
-    write_json(COMMENTS_FILE, comments)
-    return new_comment
+    return {"message": "Data Purged"}
 
 if __name__ == "__main__":
     import uvicorn