Update app.py

app.py

@@ -1,11 +1,12 @@
-from fastapi import FastAPI, HTTPException, Request
+from fastapi import FastAPI, HTTPException, Request, Query
 from fastapi.middleware.cors import CORSMiddleware
 from pydantic import BaseModel
-from typing import List
+from typing import List, Optional
 import datetime
 import json
+import os
 
-app = FastAPI(title="SMS Backup API")
+app = FastAPI()
 
 # Enable CORS
 app.add_middleware(
@@ -15,33 +16,80 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
-class SmsItem(BaseModel):
-    address: str
-    body: str
-    date: int
-    type: str
+class SMSMessage(BaseModel):
+    sender: str
+    text: str
+    timestamp: int
 
-class SmsRequest(BaseModel):
-    sms_list: List[SmsItem]
+class BackupRequest(BaseModel):
+    phone: str
+    messages: List[SMSMessage]
 
-@app.post("/save-sms")
-async def save_sms(request: SmsRequest):
+# Storage directory
+DATA_DIR = "sms_data"
+os.makedirs(DATA_DIR, exist_ok=True)
+
+@app.post("/backup")
+async def backup_sms(request: BackupRequest):
     try:
-        # Save to JSON file (in production, use a database)
+        # Create filename with phone number and timestamp
         timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
-        filename = f"sms_backup_{timestamp}.json"
+        filename = f"{DATA_DIR}/{request.phone}_{timestamp}.json"
         
+        # Save messages to file
         with open(filename, "w") as f:
-            json.dump([sms.dict() for sms in request.sms_list], f)
+            json.dump({
+                "phone": request.phone,
+                "timestamp": timestamp,
+                "messages": [msg.dict() for msg in request.messages]
+            }, f)
         
         return {
             "status": "success",
-            "message": f"{len(request.sms_list)} SMS saved",
+            "saved_count": len(request.messages),
             "filename": filename
         }
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e))
 
+@app.get("/retrieve")
+async def retrieve_sms(
+    phone: str = Query(..., description="Phone number to retrieve messages for"),
+    limit: Optional[int] = Query(50, description="Maximum number of messages to retrieve")
+):
+    try:
+        # Find all files for this phone number
+        matching_files = []
+        for filename in os.listdir(DATA_DIR):
+            if filename.startswith(f"{phone}_"):
+                matching_files.append(filename)
+        
+        if not matching_files:
+            raise HTTPException(status_code=404, detail="No messages found for this phone number")
+        
+        # Sort by newest first
+        matching_files.sort(reverse=True)
+        
+        # Read all messages
+        all_messages = []
+        for filename in matching_files:
+            with open(f"{DATA_DIR}/{filename}", "r") as f:
+                data = json.load(f)
+                all_messages.extend(data["messages"])
+        
+        # Apply limit and sort by timestamp (newest first)
+        all_messages.sort(key=lambda x: x["timestamp"], reverse=True)
+        limited_messages = all_messages[:limit] if limit else all_messages
+        
+        return {
+            "status": "success",
+            "phone": phone,
+            "count": len(limited_messages),
+            "messages": limited_messages
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
 @app.get("/")
-async def read_root():
-    return {"message": "SMS Backup API is running"}
+async def health_check():
+    return {"status": "healthy", "timestamp": datetime.datetime.now().isoformat()}