Update app.py

app.py

@@ -1,4 +1,3 @@
-# app.py
 from fastapi import FastAPI, Request
 from fastapi.middleware.cors import CORSMiddleware
 from pydantic import BaseModel, Field
@@ -12,6 +11,7 @@ import hashlib
 from datetime import datetime, timezone
 import re
 import fastapi
+import random
 
 app = FastAPI()
 logging.basicConfig(level=logging.INFO)
@@ -114,6 +114,12 @@ def _rand_token() -> str:
     return hashlib.sha256(os.urandom(32)).hexdigest()
 
 
+def _gen_temp_pin(digits: int = 6) -> str:
+    # numeric temp PIN (easier to convey to students)
+    lower = 10 ** (digits - 1)
+    return str(random.randint(lower, 10 ** digits - 1))
+
+
 async def _append_user(record: dict) -> None:
     line = json.dumps(record, ensure_ascii=False) + "\n"
 
@@ -171,9 +177,8 @@ def _require_admin(request: Request):
 # 💬 Chat API (public read, authed write)
 # ---------------------------
 class NewMessage(BaseModel):
-    # author is ignored and server uses authenticated user's profile.
+    author: Optional[str] = Field(default="anon", max_length=64)  # ignored on server write
     text: str = Field(..., min_length=1, max_length=5000)
-    images: Optional[List[str]] = []  # base64 data-urls or URLs
 
 
 @app.get("/chat/{video_id}")
@@ -216,7 +221,6 @@ class NewUser(BaseModel):
     profile_image: Optional[str] = ""
     description: Optional[str] = ""
     pin: str = Field(..., min_length=3, max_length=32)
-    verified: Optional[str] = None  # 'staff' or 'dev' or None
 
 
 class UpdateUser(BaseModel):
@@ -227,7 +231,6 @@ class UpdateUser(BaseModel):
     description: Optional[str] = None
     pin: Optional[str] = None
     disabled: Optional[bool] = None
-    verified: Optional[str] = None
 
 
 class LoginReq(BaseModel):
@@ -254,7 +257,7 @@ async def admin_create_user(user: NewUser, request: Request):
         "description": (user.description or "").strip(),
         "pin_hash": _hash_pin(user.pin),
         "disabled": False,
-        "verified": (user.verified or None),
+        "must_change_pin": False,
         "created_at": _now_iso(),
     }
     await _append_user(rec)
@@ -275,6 +278,22 @@ async def admin_list_users(request: Request, q: Optional[str] = None, limit: int
     return {"count": len(users), "users": users}
 
 
+@app.get("/admin/users/{handle}")
+async def admin_get_user(handle: str, request: Request):
+    """
+    Return user details (names, email, class, disabled, must_change_pin, created_at).
+    NOTE: For security we DO NOT return the existing PIN or pin_hash.
+    """
+    _require_admin(request)
+    handle = _safe_handle(handle)
+    users = await _read_users()
+    u = next((x for x in users if x.get("handle") == handle), None)
+    if not u:
+        raise fastapi.HTTPException(status_code=404, detail="User not found")
+    pub = {k: v for k, v in u.items() if k != "pin_hash"}
+    return {"ok": True, "user": pub}
+
+
 @app.put("/admin/users/{handle}")
 async def admin_update_user(handle: str, patch: UpdateUser, request: Request):
     _require_admin(request)
@@ -297,8 +316,7 @@ async def admin_update_user(handle: str, patch: UpdateUser, request: Request):
                 u["disabled"] = bool(patch.disabled)
             if patch.pin is not None:
                 u["pin_hash"] = _hash_pin(patch.pin)
-            if patch.verified is not None:
-                u["verified"] = patch.verified
+                u["must_change_pin"] = False
             changed = True
             break
     if not changed:
@@ -314,6 +332,53 @@ async def admin_update_user(handle: str, patch: UpdateUser, request: Request):
     return {"ok": True}
 
 
+@app.post("/admin/users/{handle}/reset_pin")
+async def admin_reset_pin(handle: str, body: dict = None, request: Request = None):
+    """
+    Admin-only endpoint to reset a user's PIN.
+    Request body (optional): { "new_pin": "123456" }
+    If new_pin is not provided, the server will generate a numeric temporary PIN (6 digits)
+    and set must_change_pin = true on the user record.
+    The endpoint returns {"ok": True, "new_pin": "..."} so the admin can communicate it.
+    NOTE: We DO NOT return the user's old PIN for security reasons.
+    """
+    _require_admin(request)
+    handle = _safe_handle(handle)
+    users = await _read_users()
+    found = False
+    new_pin = None
+    for u in users:
+        if u.get("handle") == handle:
+            found = True
+            new_pin = (body or {}).get("new_pin")
+            if new_pin:
+                # basic validation
+                new_pin = str(new_pin).strip()
+                if len(new_pin) < 3 or len(new_pin) > 32:
+                    raise fastapi.HTTPException(status_code=400, detail="PIN length invalid")
+                u["pin_hash"] = _hash_pin(new_pin)
+                u["must_change_pin"] = False
+            else:
+                # generate temporary numeric PIN and flag must_change_pin
+                new_pin = _gen_temp_pin(6)
+                u["pin_hash"] = _hash_pin(new_pin)
+                u["must_change_pin"] = True
+            break
+    if not found:
+        raise fastapi.HTTPException(status_code=404, detail="User not found")
+
+    # rewrite file with updated pin_hash
+    async with app.state.users_lock:
+        def _write_all():
+            with open(USERS_FILE, "w", encoding="utf-8") as f:
+                for rec in users:
+                    f.write(json.dumps(rec, ensure_ascii=False) + "\n")
+        await asyncio.to_thread(_write_all)
+
+    logging.info(f"Admin reset PIN for @{handle}")
+    return {"ok": True, "new_pin": new_pin}
+
+
 @app.post("/auth/login")
 async def login(req: LoginReq):
     users = await _read_users()
@@ -327,7 +392,8 @@ async def login(req: LoginReq):
     token = _rand_token()
     app.state.sessions[token] = handle
     await _save_sessions()
-    return {"ok": True, "token": token}
+    # include must_change_pin to allow client to force password change
+    return {"ok": True, "token": token, "must_change_pin": bool(u.get("must_change_pin", False))}
 
 
 async def _require_user(request: Request) -> dict:
@@ -357,7 +423,7 @@ async def me(request: Request):
 async def post_message(video_id: str, msg: NewMessage, request: Request):
     """
     Append a message to a room's chat.
-    Body: { "text": "hello", "images": [...] }
+    Body: { "text": "hello" }
     """
     path = _chat_file_for(video_id)
     lock = _lock_for(path)
@@ -370,8 +436,8 @@ async def post_message(video_id: str, msg: NewMessage, request: Request):
     profile_image = user.get("profile_image", "")
 
     text = _valid_text(msg.text)
-    if not text and not (msg.images and len(msg.images) > 0):
-        return {"ok": False, "error": "Empty message and no images"}
+    if not text:
+        return {"ok": False, "error": "Empty message"}
 
     created = _now_iso()
     mid = hashlib.sha1(f"{video_id}|{author}|{created}|{text}".encode("utf-8")).hexdigest()[:16]
@@ -380,13 +446,11 @@ async def post_message(video_id: str, msg: NewMessage, request: Request):
     record = {
         "id": mid,
         "video_id": video_id,
-        "room": video_id,
         "author": author,
         "handle": handle,
         "klass": klass,
         "profile_image": profile_image,
         "text": text,
-        "images": msg.images or [],
         "created_at": created,
         "ip": ip,
         "ua": request.headers.get("user-agent", "")[:200],
@@ -398,132 +462,7 @@ async def post_message(video_id: str, msg: NewMessage, request: Request):
     return {"ok": True, "message": record}
 
 
-# ---------------------------
-# DM endpoints (map to deterministic dm room names)
-# ---------------------------
-@app.get("/dm/{other_handle}")
-async def get_dm(other_handle: str, request: Request, limit: int = 50, since: Optional[str] = None):
-    user = await _require_user(request)
-    a = user["handle"]
-    b = _safe_handle(other_handle.lstrip("@"))
-    if a == b:
-        # Allow reading your own DMs (empty)
-        room = f"dm_{a}_{b}"
-    else:
-        handles = sorted([a, b])
-        room = f"dm_{handles[0]}_{handles[1]}"
-    return await get_messages(room, limit=limit, since=since)
-
-
-@app.post("/dm/{other_handle}")
-async def post_dm(other_handle: str, msg: NewMessage, request: Request):
-    user = await _require_user(request)
-    a = user["handle"]
-    b = _safe_handle(other_handle.lstrip("@"))
-    handles = sorted([a, b])
-    room = f"dm_{handles[0]}_{handles[1]}"
-    # reuse post_message logic: make a NewMessage-like object and call post_message
-    return await post_message(room, msg, request)
-
-
-# ---------------------------
-# Admin: user posts listing & deletion
-# ---------------------------
-@app.get("/admin/user_posts/{handle}")
-async def admin_user_posts(handle: str, request: Request, limit: int = 500):
-    """Return a list of messages authored by handle across chat files (admin-only)."""
-    _require_admin(request)
-    handle = _safe_handle(handle.lstrip("@"))
-    collected = []
-    # scan all chat files
-    for fname in os.listdir(CHAT_DIR):
-        if not fname.endswith(".jsonl"):
-            continue
-        path = os.path.join(CHAT_DIR, fname)
-        try:
-            msgs = await _read_jsonl(path)
-        except Exception:
-            msgs = []
-        for m in msgs:
-            if m.get("handle") == handle:
-                collected.append(m)
-                if len(collected) >= limit:
-                    break
-        if len(collected) >= limit:
-            break
-    # sort descending by created_at
-    collected.sort(key=lambda m: m.get("created_at", ""), reverse=True)
-    return {"count": len(collected), "messages": collected}
-
-
-@app.delete("/admin/posts/{post_id}")
-async def admin_delete_post_admin(post_id: str, request: Request):
-    """Admin-only deletion endpoint (x-admin-key)."""
-    _require_admin(request)
-    # reuse deletion routine
-    ok = await _delete_post_by_id(post_id)
-    if not ok:
-        raise fastapi.HTTPException(status_code=404, detail="Post not found")
-    return {"ok": True}
-
-
-@app.delete("/posts/{post_id}")
-async def delete_post(post_id: str, request: Request):
-    """
-    Delete a post if the caller is admin (x-admin-key) or a verified moderator (staff/dev).
-    """
-    # admin via header
-    provided = request.headers.get("x-admin-key", "")
-    if ADMIN_KEY and provided == ADMIN_KEY:
-        ok = await _delete_post_by_id(post_id)
-        if not ok:
-            raise fastapi.HTTPException(status_code=404, detail="Post not found")
-        return {"ok": True}
-
-    # otherwise require user and verified
-    user = await _require_user(request)
-    if user.get("verified") not in ("staff", "dev"):
-        raise fastapi.HTTPException(status_code=403, detail="Not authorized to delete posts")
-
-    ok = await _delete_post_by_id(post_id)
-    if not ok:
-        raise fastapi.HTTPException(status_code=404, detail="Post not found")
-    return {"ok": True}
-
-
-async def _delete_post_by_id(post_id: str) -> bool:
-    """
-    Scan chat files and remove the message with id==post_id.
-    Returns True if deleted, False if not found.
-    """
-    for fname in os.listdir(CHAT_DIR):
-        if not fname.endswith(".jsonl"):
-            continue
-        path = os.path.join(CHAT_DIR, fname)
-        lock = _lock_for(path)
-        async with lock:
-            msgs = await _read_jsonl(path)
-            found = False
-            new_msgs = []
-            for m in msgs:
-                if m.get("id") == post_id:
-                    found = True
-                    continue
-                new_msgs.append(m)
-            if found:
-                # rewrite file atomically
-                def _write_all():
-                    with open(path, "w", encoding="utf-8") as f:
-                        for rec in new_msgs:
-                            f.write(json.dumps(rec, ensure_ascii=False) + "\n")
-                await asyncio.to_thread(_write_all)
-                return True
-    return False
-
-
-# ---------------------------
-# (Original iCloud album endpoints)
-# ---------------------------
+# (rest of your iCloud album endpoints unchanged)
 BASE_62_MAP = {c: i for i, c in enumerate("0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz")}
 
 
@@ -549,6 +488,11 @@ async def get_base_url(token: str) -> str:
     return f"https://p{n:02d}-sharedstreams.icloud.com/{token}/sharedstreams/"
 
 
+
+
+# ... (keep your existing iCloud helper endpoints as-is) ...
+
+
 ICLOUD_HEADERS = {
     "Origin": "https://www.icloud.com",
     "Content-Type": "text/plain",