Update app.py

app.py

@@ -104,18 +104,18 @@ async def list_gcs_folder(folder: str = Query(..., description="Folder name, e.g
     #    This handles cases where user types "song" but folder is "songs/"
     config = STORAGE_MAP.get(folder)
     prefix = config["folder"] if config else f"{folder}/"
-    
+
     try:
         # 2. Run GCS List Blobs in a thread (to keep server fast)
         def _fetch_blobs():
             # 'delimiter' makes it behave like a folder (doesn't show sub-sub-files)
             blobs = bucket.list_blobs(prefix=prefix, delimiter="/")
-            
+
             file_list = []
             for blob in blobs:
                 # Remove the folder prefix (e.g. "songs/beat1.json" -> "beat1.json")
                 name = blob.name.replace(prefix, "")
-                if name and name != "": 
+                if name and name != "":
                     file_list.append({
                         "filename": name,
                         "size": blob.size,
@@ -129,7 +129,7 @@ async def list_gcs_folder(folder: str = Query(..., description="Folder name, e.g
 
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e))
-        
+
 # --- MODELS ---
 class ItemPayload(BaseModel):
     name: str
@@ -159,7 +159,7 @@ def _write_json_sync(blob_path, data):
     blob = bucket.blob(blob_path)
     # Upload as JSON string with correct content type
     blob.upload_from_string(
-        json.dumps(data), 
+        json.dumps(data),
         content_type='application/json'
     )
 
@@ -210,9 +210,9 @@ async def upload_item(payload: ItemPayload):
         "date": date_str,
         "type": item_type,
         "description": payload.description,
-        "filename": filename 
+        "filename": filename
     }
-    
+
     # Add meta to the actual data file too
     payload.data["_cloud_meta"] = meta
 
@@ -235,6 +235,79 @@ async def upload_item(payload: ItemPayload):
         except Exception as e:
             raise HTTPException(500, f"Upload failed: {str(e)}")
 
+# --- 2.5 UPDATE JSON (PUT) ---
+@app.put("/api/songs/{item_id}")
+async def update_item(item_id: str, payload: ItemPayload):
+    # Verify type configuration
+    item_type = payload.type if payload.type in STORAGE_MAP else "song"
+    config = STORAGE_MAP[item_type]
+
+    # Assume filename is {id}.json (standard convention for this app)
+    filename = f"{item_id}.json"
+    full_path = f"{config['folder']}{filename}"
+
+    # We preserve the original ID but update other metadata
+    # Note: 'date' field in metadata is typically 'created_at'.
+    # We could add an 'updated_at' field if needed, but for now we keep 'date' as is or update it?
+    # Usually you don't change the creation date.
+    # We will fetch the original creation date if possible, or just use current if not found.
+    # However, to avoid complexity, we'll just update the metadata entry in the index.
+
+    date_str = datetime.now().strftime("%Y-%m-%d") # Use current date as 'last updated' effectively?
+    # Or should we try to preserve original date?
+    # Let's try to preserve it by reading the index first.
+
+    new_meta = {
+        "id": item_id,
+        "name": payload.name,
+        "author": payload.author,
+        "date": date_str, # Defaulting to now if not found
+        "type": item_type,
+        "description": payload.description,
+        "filename": filename
+    }
+
+    # Add meta to data
+    payload.data["_cloud_meta"] = new_meta
+
+    async with INDEX_LOCK:
+        try:
+            # 1. Check if file exists (optional, but good for 404)
+            # blob = bucket.blob(full_path)
+            # if not await run_io(blob.exists):
+            #    raise HTTPException(404, "Item not found")
+
+            # 2. Write the Data File (Overwrite)
+            await run_io(_write_json_sync, full_path, payload.data)
+
+            # 3. Update the Index
+            def _update_index_logic():
+                current = _read_json_sync(config["index"])
+                if not isinstance(current, list): current = []
+
+                # Find and remove existing entry for this ID
+                # Also, capture the original date if possible to preserve "Created Date" behavior
+                # But user might want "Updated Date". Let's stick to updating it to "now" so it bubbles to top.
+                existing_index = next((i for i, item in enumerate(current) if item.get("id") == item_id), -1)
+
+                if existing_index != -1:
+                    # Preserve original creation date if desired, but user wants 'latest' usually.
+                    # Let's keep it simple: Remove old, insert new at top (Fresh Update)
+                    current.pop(existing_index)
+
+                current.insert(0, new_meta)
+                _write_json_sync(config["index"], current)
+
+            await run_io(_update_index_logic)
+
+            # Clear cache
+            await cache.clear()
+            return {"success": True, "id": item_id, "action": "updated"}
+
+        except Exception as e:
+            raise HTTPException(500, f"Update failed: {str(e)}")
+
+
 # --- 3. FETCH JSON ITEM ---
 @app.get("/api/songs/{item_id}")
 async def get_item(item_id: str, type: Optional[str] = Query(None)):
@@ -244,11 +317,11 @@ async def get_item(item_id: str, type: Optional[str] = Query(None)):
     for t in search_types:
         config = STORAGE_MAP.get(t)
         filepath = f"{config['folder']}{item_id}.json"
-        
+
         # Check existence efficiently
         blob = bucket.blob(filepath)
         exists = await run_io(blob.exists)
-        
+
         if exists:
             data = await run_io(blob.download_as_text)
             return json.loads(data)
@@ -279,7 +352,7 @@ async def upload_sample(file: UploadFile = File(...), author: str = Form(...), d
         try:
             # 1. Stream Upload to GCS
             blob = bucket.blob(full_path)
-            
+
             # GCS Python client doesn't support async streaming upload easily out of the box,
             # but upload_from_file is efficient.
             # We wrap the spooled temp file from FastAPI
@@ -293,7 +366,7 @@ async def upload_sample(file: UploadFile = File(...), author: str = Form(...), d
 
             await run_io(_update_idx)
             await cache.delete("library:sample")
-            
+
             return {"success": True, "id": sample_id}
         except Exception as e:
             raise HTTPException(500, str(e))
@@ -301,11 +374,11 @@ async def upload_sample(file: UploadFile = File(...), author: str = Form(...), d
 @app.get("/api/samples/{sample_id}")
 async def get_sample(sample_id: str):
     config = STORAGE_MAP["sample"]
-    
+
     # 1. Lookup in Index (to get original filename/extension)
     idx = await run_io(_read_json_sync, config["index"])
     entry = next((i for i in idx if i["id"] == sample_id), None)
-    
+
     if not entry:
         raise HTTPException(404, "Sample not found in index")
 
@@ -336,19 +409,19 @@ async def sync_gcs_storage():
     Scans Google Cloud Storage to rebuild JSON indexes based on actual files.
     """
     report = {}
-    
+
     async with INDEX_LOCK:
         for item_type, config in STORAGE_MAP.items():
             if item_type == "default": continue
 
             added = 0
             removed = 0
-            
+
             try:
                 # 1. List ALL objects in this folder prefix
                 # prefix="songs/" returns "songs/123.json", "songs/456.json", etc.
                 blobs = await run_io(lambda: list(bucket.list_blobs(prefix=config["folder"])))
-                
+
                 # Filter out the index file itself
                 actual_files = []
                 for b in blobs:
@@ -359,7 +432,7 @@ async def sync_gcs_storage():
 
                 # 2. Get Current Index
                 index_data = await run_io(_read_json_sync, config["index"])
-                
+
                 # 3. Compare
                 index_map = {item["filename"]: item for item in index_data}
                 disk_set = set(actual_files)