chore(quality): apply ruff autofixes and formatting (8 fixes, 18 files reformatted)

backend/app/routers/records.py

@@ -1,48 +1,227 @@
-"""Record routes."""
-from fastapi import APIRouter, Depends, HTTPException
+from fastapi import APIRouter, Depends, HTTPException, Query
 from sqlalchemy.orm import Session
 from typing import List
 
 from app.database import get_db
-from app.models.record import Record
-from app.schemas.record import RecordCreate, RecordUpdate, RecordResponse
+from app.models.user import User
+from app.models.record import Record, CellValue
+from app.schemas.record import (
+    RecordCreate,
+    RecordRead,
+    RecordUpdate,
+    RecordDetailRead,
+    BulkRecordOperation,
+)
+from app.routers.auth import get_current_user
+from app.routers.tables import check_table_access
 
-router = APIRouter(prefix="/records", tags=["records"])
+router = APIRouter()
 
-@router.get("/table/{table_id}", response_model=List[RecordResponse])
-def list_records(table_id: int, db: Session = Depends(get_db)):
-    """List all records for a table."""
-    return db.query(Record).filter(Record.column_id.in_(
-        db.query(Column.id).filter(Column.table_id == table_id)
-    )).all()
 
-@router.post("", response_model=RecordResponse)
-def create_record(record: RecordCreate, db: Session = Depends(get_db)):
-    """Create new record."""
-    db_record = Record(**record.model_dump())
-    db.add(db_record)
+@router.get("/tables/{table_id}/records", response_model=List[RecordDetailRead])
+def list_records(
+    table_id: int,
+    skip: int = Query(0, ge=0),
+    limit: int = Query(100, ge=1, le=1000),
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user),
+):
+    """List records (paginated)."""
+    check_table_access(table_id, db, current_user)
+    records = (
+        db.query(Record)
+        .filter(Record.table_id == table_id)
+        .offset(skip)
+        .limit(limit)
+        .all()
+    )
+    return records
+
+
+@router.post("/tables/{table_id}/records", response_model=RecordRead, status_code=201)
+def create_record(
+    table_id: int,
+    data: RecordCreate,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user),
+):
+    """Create record."""
+    check_table_access(table_id, db, current_user)
+    record = Record(
+        table_id=table_id, created_by=current_user.id, updated_by=current_user.id
+    )
+    db.add(record)
+    db.flush()  # Get record.id
+
+    # Add cell values
+    if data.cells:
+        for cell in data.cells:
+            cell_value = CellValue(
+                record_id=record.id, column_id=cell.column_id, value=cell.value
+            )
+            db.add(cell_value)
+
     db.commit()
-    db.refresh(db_record)
-    return db_record
+    db.refresh(record)
+    return record
 
-@router.put("/{record_id}", response_model=RecordResponse)
-def update_record(record_id: int, record: RecordUpdate, db: Session = Depends(get_db)):
-    """Update record."""
-    db_record = db.query(Record).filter(Record.id == record_id).first()
-    if not db_record:
+
+@router.get("/tables/{table_id}/records/{record_id}", response_model=RecordDetailRead)
+def get_record(
+    table_id: int,
+    record_id: int,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user),
+):
+    """Get single record."""
+    check_table_access(table_id, db, current_user)
+    record = (
+        db.query(Record)
+        .filter(Record.id == record_id, Record.table_id == table_id)
+        .first()
+    )
+    if not record:
         raise HTTPException(status_code=404, detail="Record not found")
-    for key, value in record.model_dump(exclude_unset=True).items():
-        setattr(db_record, key, value)
-    db.commit()
-    db.refresh(db_record)
-    return db_record
+    return record
 
-@router.delete("/{record_id}")
-def delete_record(record_id: int, db: Session = Depends(get_db)):
+
+@router.put("/tables/{table_id}/records/{record_id}", response_model=RecordRead)
+def update_record(
+    table_id: int,
+    record_id: int,
+    data: RecordUpdate,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user),
+):
+    """Update record."""
+    check_table_access(table_id, db, current_user)
+    record = (
+        db.query(Record)
+        .filter(Record.id == record_id, Record.table_id == table_id)
+        .first()
+    )
+    if not record:
+        raise HTTPException(status_code=404, detail="Record not found")
+
+    record.updated_by = current_user.id
+
+    # Update cell values
+    if data.cells:
+        for cell in data.cells:
+            existing = (
+                db.query(CellValue)
+                .filter(
+                    CellValue.record_id == record_id,
+                    CellValue.column_id == cell.column_id,
+                )
+                .first()
+            )
+            if existing:
+                existing.value = cell.value
+            else:
+                cell_value = CellValue(
+                    record_id=record_id, column_id=cell.column_id, value=cell.value
+                )
+                db.add(cell_value)
+
+    db.commit()
+    db.refresh(record)
+    return record
+
+
+@router.delete("/tables/{table_id}/records/{record_id}")
+def delete_record(
+    table_id: int,
+    record_id: int,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user),
+):
     """Delete record."""
-    record = db.query(Record).filter(Record.id == record_id).first()
+    check_table_access(table_id, db, current_user)
+    record = (
+        db.query(Record)
+        .filter(Record.id == record_id, Record.table_id == table_id)
+        .first()
+    )
     if not record:
         raise HTTPException(status_code=404, detail="Record not found")
     db.delete(record)
     db.commit()
     return {"message": "Record deleted"}
+
+
+@router.post("/tables/{table_id}/records/bulk")
+def bulk_operations(
+    table_id: int,
+    data: BulkRecordOperation,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user),
+):
+    """Bulk create/update records."""
+    check_table_access(table_id, db, current_user)
+    results = {"created": [], "updated": [], "deleted": 0}
+
+    # Create
+    if data.create:
+        for record_data in data.create:
+            record = Record(
+                table_id=table_id,
+                created_by=current_user.id,
+                updated_by=current_user.id,
+            )
+            db.add(record)
+            db.flush()
+            if record_data.cells:
+                for cell in record_data.cells:
+                    cell_value = CellValue(
+                        record_id=record.id, column_id=cell.column_id, value=cell.value
+                    )
+                    db.add(cell_value)
+            results["created"].append(record.id)
+
+    # Update
+    if data.update:
+        for update_data in data.update:
+            record_id = update_data.get("id")
+            record = (
+                db.query(Record)
+                .filter(Record.id == record_id, Record.table_id == table_id)
+                .first()
+            )
+            if record:
+                record.updated_by = current_user.id
+                if update_data.get("cells"):
+                    for cell in update_data["cells"]:
+                        existing = (
+                            db.query(CellValue)
+                            .filter(
+                                CellValue.record_id == record_id,
+                                CellValue.column_id == cell["column_id"],
+                            )
+                            .first()
+                        )
+                        if existing:
+                            existing.value = cell["value"]
+                        else:
+                            cell_value = CellValue(
+                                record_id=record_id,
+                                column_id=cell["column_id"],
+                                value=cell["value"],
+                            )
+                            db.add(cell_value)
+                results["updated"].append(record_id)
+
+    # Delete
+    if data.delete:
+        for record_id in data.delete:
+            record = (
+                db.query(Record)
+                .filter(Record.id == record_id, Record.table_id == table_id)
+                .first()
+            )
+            if record:
+                db.delete(record)
+                results["deleted"] += 1
+
+    db.commit()
+    return results