Update app.py

app.py

@@ -1,11 +1,10 @@
-from fastapi import FastAPI, HTTPException, Request, Query
+from fastapi import FastAPI, HTTPException
 from fastapi.middleware.cors import CORSMiddleware
 from pydantic import BaseModel
-from typing import List, Optional
+from typing import List
 import datetime
 import json
 import os
-from pathlib import Path
 
 app = FastAPI()
 
@@ -17,85 +16,42 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
-class SMSMessage(BaseModel):
-    sender: str
-    text: str
-    timestamp: int
+class SmsItem(BaseModel):
+    address: str
+    body: str
+    date: int
+    type: str
 
-class BackupRequest(BaseModel):
-    phone: str
-    messages: List[SMSMessage]
+class SmsRequest(BaseModel):
+    sms_list: List[SmsItem]
 
 # Use /tmp directory which has write permissions
 DATA_DIR = "/tmp/sms_data"
 os.makedirs(DATA_DIR, exist_ok=True)
 
-@app.post("/backup")
-async def backup_sms(request: BackupRequest):
+@app.post("/save-sms")
+async def save_sms(request: SmsRequest):
     try:
-        # Create filename with phone number and timestamp
+        # Create filename with timestamp
         timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
-        filename = f"{DATA_DIR}/{request.phone}_{timestamp}.json"
+        filename = f"{DATA_DIR}/backup_{timestamp}.json"
         
-        # Save messages to file
+        # Save to file
         with open(filename, "w") as f:
-            json.dump({
-                "phone": request.phone,
-                "timestamp": timestamp,
-                "messages": [msg.dict() for msg in request.messages]
-            }, f)
+            json.dump([sms.dict() for sms in request.sms_list], f, indent=2)
         
         return {
             "status": "success",
-            "saved_count": len(request.messages),
+            "message": f"{len(request.sms_list)} SMS saved",
             "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 entry in os.scandir(DATA_DIR):
-            if entry.name.startswith(f"{phone}_") and entry.is_file():
-                matching_files.append(entry.path)
-        
-        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(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 health_check():
     return {
         "status": "healthy",
         "timestamp": datetime.datetime.now().isoformat(),
-        "storage_path": DATA_DIR,
-        "writable": os.access(DATA_DIR, os.W_OK)
+        "sms_storage": DATA_DIR
     }