Phase 2 Complete by Claude Code

backend/melodies/models.py

@@ -1 +1,70 @@
-# TODO: Melody Pydantic schemas
+from pydantic import BaseModel
+from typing import List, Optional
+from enum import Enum
+
+
+class MelodyType(str, Enum):
+    orthodox = "orthodox"
+    catholic = "catholic"
+    all = "all"
+
+
+class MelodyTone(str, Enum):
+    normal = "normal"
+    festive = "festive"
+    cheerful = "cheerful"
+    lamentation = "lamentation"
+
+
+class MelodyInfo(BaseModel):
+    name: str
+    description: str = ""
+    melodyTone: MelodyTone = MelodyTone.normal
+    customTags: List[str] = []
+    minSpeed: int = 0
+    maxSpeed: int = 0
+    totalNotes: int = 1
+    steps: int = 0
+    color: str = ""
+    isTrueRing: bool = False
+    previewURL: str = ""
+    notes: List[int] = []
+
+
+class MelodyAttributes(BaseModel):
+    speed: int = 0
+    duration: int = 0
+    totalRunDuration: int = 0
+    pauseDuration: int = 0
+    infiniteLoop: bool = False
+    echoRing: List[int] = []
+    noteAssignments: List[int] = []
+
+
+# --- Request / Response schemas ---
+
+class MelodyCreate(BaseModel):
+    information: MelodyInfo
+    default_settings: MelodyAttributes
+    type: MelodyType = MelodyType.all
+    url: str = ""
+    uid: str = ""
+    pid: str = ""
+
+
+class MelodyUpdate(BaseModel):
+    information: Optional[MelodyInfo] = None
+    default_settings: Optional[MelodyAttributes] = None
+    type: Optional[MelodyType] = None
+    url: Optional[str] = None
+    uid: Optional[str] = None
+    pid: Optional[str] = None
+
+
+class MelodyInDB(MelodyCreate):
+    id: str
+
+
+class MelodyListResponse(BaseModel):
+    melodies: List[MelodyInDB]
+    total: int

backend/melodies/router.py

@@ -1 +1,118 @@
-# TODO: CRUD endpoints for melodies
+from fastapi import APIRouter, Depends, UploadFile, File, Query, HTTPException
+from typing import Optional
+from auth.models import TokenPayload
+from auth.dependencies import require_melody_access, require_viewer
+from melodies.models import (
+    MelodyCreate, MelodyUpdate, MelodyInDB, MelodyListResponse, MelodyInfo,
+)
+from melodies import service
+
+router = APIRouter(prefix="/api/melodies", tags=["melodies"])
+
+
+@router.get("", response_model=MelodyListResponse)
+async def list_melodies(
+    search: Optional[str] = Query(None),
+    type: Optional[str] = Query(None),
+    tone: Optional[str] = Query(None),
+    total_notes: Optional[int] = Query(None),
+    _user: TokenPayload = Depends(require_viewer),
+):
+    melodies = service.list_melodies(
+        search=search,
+        melody_type=type,
+        tone=tone,
+        total_notes=total_notes,
+    )
+    return MelodyListResponse(melodies=melodies, total=len(melodies))
+
+
+@router.get("/{melody_id}", response_model=MelodyInDB)
+async def get_melody(
+    melody_id: str,
+    _user: TokenPayload = Depends(require_viewer),
+):
+    return service.get_melody(melody_id)
+
+
+@router.post("", response_model=MelodyInDB, status_code=201)
+async def create_melody(
+    body: MelodyCreate,
+    _user: TokenPayload = Depends(require_melody_access),
+):
+    return service.create_melody(body)
+
+
+@router.put("/{melody_id}", response_model=MelodyInDB)
+async def update_melody(
+    melody_id: str,
+    body: MelodyUpdate,
+    _user: TokenPayload = Depends(require_melody_access),
+):
+    return service.update_melody(melody_id, body)
+
+
+@router.delete("/{melody_id}", status_code=204)
+async def delete_melody(
+    melody_id: str,
+    _user: TokenPayload = Depends(require_melody_access),
+):
+    service.delete_melody(melody_id)
+
+
+@router.post("/{melody_id}/upload/{file_type}")
+async def upload_file(
+    melody_id: str,
+    file_type: str,
+    file: UploadFile = File(...),
+    _user: TokenPayload = Depends(require_melody_access),
+):
+    """Upload a binary or preview file. file_type must be 'binary' or 'preview'."""
+    if file_type not in ("binary", "preview"):
+        raise HTTPException(status_code=400, detail="file_type must be 'binary' or 'preview'")
+
+    # Verify melody exists
+    melody = service.get_melody(melody_id)
+
+    contents = await file.read()
+    content_type = file.content_type or "application/octet-stream"
+
+    if file_type == "binary":
+        content_type = "application/octet-stream"
+
+    url = service.upload_file(melody_id, contents, file.filename, content_type)
+
+    # Update the melody document with the new URL if it's a preview
+    if file_type == "preview":
+        service.update_melody(melody_id, MelodyUpdate(
+            information=MelodyInfo(
+                name=melody.information.name,
+                previewURL=url,
+            )
+        ))
+
+    return {"url": url, "file_type": file_type}
+
+
+@router.delete("/{melody_id}/files/{file_type}", status_code=204)
+async def delete_file(
+    melody_id: str,
+    file_type: str,
+    _user: TokenPayload = Depends(require_melody_access),
+):
+    """Delete a binary or preview file. file_type must be 'binary' or 'preview'."""
+    if file_type not in ("binary", "preview"):
+        raise HTTPException(status_code=400, detail="file_type must be 'binary' or 'preview'")
+
+    service.get_melody(melody_id)
+    service.delete_file(melody_id, file_type)
+
+
+@router.get("/{melody_id}/files")
+async def get_files(
+    melody_id: str,
+    _user: TokenPayload = Depends(require_viewer),
+):
+    """Get storage file URLs for a melody."""
+    service.get_melody(melody_id)
+    return service.get_storage_files(melody_id)

backend/melodies/service.py

@@ -1 +1,174 @@
-# TODO: Melody Firestore operations
+from shared.firebase import get_db, get_bucket
+from shared.exceptions import NotFoundError
+from melodies.models import MelodyCreate, MelodyUpdate, MelodyInDB
+
+COLLECTION = "melodies"
+
+
+def _doc_to_melody(doc) -> MelodyInDB:
+    """Convert a Firestore document snapshot to a MelodyInDB model."""
+    data = doc.to_dict()
+    return MelodyInDB(id=doc.id, **data)
+
+
+def list_melodies(
+    search: str | None = None,
+    melody_type: str | None = None,
+    tone: str | None = None,
+    total_notes: int | None = None,
+) -> list[MelodyInDB]:
+    """List melodies with optional filters."""
+    db = get_db()
+    ref = db.collection(COLLECTION)
+
+    # Firestore doesn't support full-text search, so we fetch and filter in-memory
+    # for the name search. Type/tone/totalNotes can be queried server-side.
+    query = ref
+
+    if melody_type:
+        query = query.where("type", "==", melody_type)
+
+    docs = query.stream()
+    results = []
+
+    for doc in docs:
+        melody = _doc_to_melody(doc)
+
+        # Client-side filters
+        if tone and melody.information.melodyTone.value != tone:
+            continue
+        if total_notes is not None and melody.information.totalNotes != total_notes:
+            continue
+        if search:
+            search_lower = search.lower()
+            name_match = search_lower in melody.information.name.lower()
+            desc_match = search_lower in melody.information.description.lower()
+            tag_match = any(search_lower in t.lower() for t in melody.information.customTags)
+            if not (name_match or desc_match or tag_match):
+                continue
+
+        results.append(melody)
+
+    return results
+
+
+def get_melody(melody_id: str) -> MelodyInDB:
+    """Get a single melody by document ID."""
+    db = get_db()
+    doc = db.collection(COLLECTION).document(melody_id).get()
+    if not doc.exists:
+        raise NotFoundError("Melody")
+    return _doc_to_melody(doc)
+
+
+def create_melody(data: MelodyCreate) -> MelodyInDB:
+    """Create a new melody document in Firestore."""
+    db = get_db()
+    doc_data = data.model_dump()
+    _, doc_ref = db.collection(COLLECTION).add(doc_data)
+    return MelodyInDB(id=doc_ref.id, **doc_data)
+
+
+def update_melody(melody_id: str, data: MelodyUpdate) -> MelodyInDB:
+    """Update an existing melody document. Only provided fields are updated."""
+    db = get_db()
+    doc_ref = db.collection(COLLECTION).document(melody_id)
+    doc = doc_ref.get()
+    if not doc.exists:
+        raise NotFoundError("Melody")
+
+    update_data = data.model_dump(exclude_none=True)
+
+    # For nested structs, merge with existing data rather than replacing
+    existing = doc.to_dict()
+    for key in ("information", "default_settings"):
+        if key in update_data and key in existing:
+            merged = {**existing[key], **update_data[key]}
+            update_data[key] = merged
+
+    doc_ref.update(update_data)
+
+    updated_doc = doc_ref.get()
+    return _doc_to_melody(updated_doc)
+
+
+def delete_melody(melody_id: str) -> None:
+    """Delete a melody document and its associated storage files."""
+    db = get_db()
+    doc_ref = db.collection(COLLECTION).document(melody_id)
+    doc = doc_ref.get()
+    if not doc.exists:
+        raise NotFoundError("Melody")
+
+    # Delete associated storage files
+    _delete_storage_files(melody_id)
+
+    doc_ref.delete()
+
+
+def upload_file(melody_id: str, file_bytes: bytes, filename: str, content_type: str) -> str:
+    """Upload a file to Firebase Storage under melodies/{melody_id}/."""
+    bucket = get_bucket()
+    if not bucket:
+        raise RuntimeError("Firebase Storage not initialized")
+
+    # Determine subfolder based on content type
+    if content_type in ("application/octet-stream", "application/macbinary"):
+        storage_path = f"melodies/{melody_id}/binary.bin"
+    else:
+        # Audio preview files
+        ext = filename.rsplit(".", 1)[-1] if "." in filename else "mp3"
+        storage_path = f"melodies/{melody_id}/preview.{ext}"
+
+    blob = bucket.blob(storage_path)
+    blob.upload_from_string(file_bytes, content_type=content_type)
+    blob.make_public()
+    return blob.public_url
+
+
+def delete_file(melody_id: str, file_type: str) -> None:
+    """Delete a specific file from storage. file_type is 'binary' or 'preview'."""
+    bucket = get_bucket()
+    if not bucket:
+        return
+
+    prefix = f"melodies/{melody_id}/"
+    blobs = list(bucket.list_blobs(prefix=prefix))
+
+    for blob in blobs:
+        if file_type == "binary" and "binary" in blob.name:
+            blob.delete()
+        elif file_type == "preview" and "preview" in blob.name:
+            blob.delete()
+
+
+def _delete_storage_files(melody_id: str) -> None:
+    """Delete all storage files for a melody."""
+    bucket = get_bucket()
+    if not bucket:
+        return
+
+    prefix = f"melodies/{melody_id}/"
+    blobs = list(bucket.list_blobs(prefix=prefix))
+    for blob in blobs:
+        blob.delete()
+
+
+def get_storage_files(melody_id: str) -> dict:
+    """List storage files for a melody, returning URLs."""
+    bucket = get_bucket()
+    if not bucket:
+        return {"binary_url": None, "preview_url": None}
+
+    prefix = f"melodies/{melody_id}/"
+    blobs = list(bucket.list_blobs(prefix=prefix))
+
+    result = {"binary_url": None, "preview_url": None}
+    for blob in blobs:
+        blob.make_public()
+        if "binary" in blob.name:
+            result["binary_url"] = blob.public_url
+        elif "preview" in blob.name:
+            result["preview_url"] = blob.public_url
+
+    return result