monkeybrain-runtime 1.0.0__py3-none-any.whl

services/pm/routers/calendar_bookings.py

@@ -0,0 +1,143 @@
+from fastapi import APIRouter, Depends, HTTPException, Query, status
+from motor.motor_asyncio import AsyncIOMotorDatabase
+
+from services.common.db import get_database
+from services.common.auth import require_permission
+from services.pm.helpers import calendar_bookings as crud
+from services.pm.models.calendar_booking import (
+    CalendarBookingCreate,
+    CalendarBookingResponse,
+    CalendarBookingUpdate,
+    PaginatedCalendarBookingResponse,
+)
+
+router = APIRouter()
+
+
+@router.get("/", response_model=PaginatedCalendarBookingResponse)
+async def list_calendar_bookings(
+    page: int = Query(1, ge=1),
+    page_size: int = Query(20, ge=1, le=100),
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-view-calendar-bookings")),
+):
+    bookings, total = await crud.get_all(db, page=page, page_size=page_size)
+    return PaginatedCalendarBookingResponse(
+        total=total,
+        page=page,
+        page_size=page_size,
+        results=bookings,
+    )
+
+
+@router.get("/by-calendar/{calendar_id}", response_model=list[CalendarBookingResponse])
+async def list_calendar_bookings_by_calendar(
+    calendar_id: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-view-calendar-bookings")),
+):
+    return await crud.get_by_calendar(db, calendar_id)
+
+
+@router.get("/by-user/{booked_by}", response_model=list[CalendarBookingResponse])
+async def list_calendar_bookings_by_user(
+    booked_by: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-view-calendar-bookings")),
+):
+    return await crud.get_by_booked_by(db, booked_by)
+
+
+@router.get("/{booking_id}", response_model=CalendarBookingResponse)
+async def get_calendar_booking(
+    booking_id: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-view-calendar-bookings")),
+):
+    record = await crud.get_by_id(db, booking_id)
+    if not record:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"Calendar booking '{booking_id}' not found",
+        )
+    return record
+
+
+@router.post("/book", response_model=CalendarBookingResponse, status_code=status.HTTP_201_CREATED)
+async def book_calendar_time(
+    data: CalendarBookingCreate,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-create-calendar-bookings")),
+):
+    if await crud.get_by_id(db, str(data.id)):
+        raise HTTPException(
+            status_code=status.HTTP_409_CONFLICT,
+            detail=f"Calendar booking '{data.id}' already exists",
+        )
+    if data.status == "booked" and await crud.has_conflict(db, data.calendar_id, data.start_at, data.end_at):
+        raise HTTPException(
+            status_code=status.HTTP_409_CONFLICT,
+            detail="Calendar time is already booked",
+        )
+    return await crud.create(db, data)
+
+
+@router.post("/", response_model=CalendarBookingResponse, status_code=status.HTTP_201_CREATED)
+async def create_calendar_booking(
+    data: CalendarBookingCreate,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-create-calendar-bookings")),
+):
+    return await book_calendar_time(data, db, _)
+
+
+@router.patch("/{booking_id}", response_model=CalendarBookingResponse)
+async def update_calendar_booking(
+    booking_id: str,
+    data: CalendarBookingUpdate,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-update-calendar-bookings")),
+):
+    existing = await crud.get_by_id(db, booking_id)
+    if not existing:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"Calendar booking '{booking_id}' not found",
+        )
+
+    calendar_id = data.calendar_id or existing["calendar_id"]
+    start_at = data.start_at or existing["start_at"]
+    end_at = data.end_at or existing["end_at"]
+    next_status = data.status or existing.get("status", "booked")
+    if next_status == "booked" and await crud.has_conflict(
+        db,
+        calendar_id,
+        start_at,
+        end_at,
+        exclude_id=booking_id,
+    ):
+        raise HTTPException(
+            status_code=status.HTTP_409_CONFLICT,
+            detail="Calendar time is already booked",
+        )
+
+    updated = await crud.update(db, booking_id, data)
+    if not updated:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"Calendar booking '{booking_id}' not found",
+        )
+    return updated
+
+
+@router.delete("/{booking_id}", status_code=status.HTTP_204_NO_CONTENT)
+async def delete_calendar_booking(
+    booking_id: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-delete-calendar-bookings")),
+):
+    if not await crud.delete(db, booking_id):
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"Calendar booking '{booking_id}' not found",
+        )

services/pm/routers/calibration_point.py

@@ -0,0 +1,94 @@
+from fastapi import APIRouter, HTTPException, Depends, status
+from motor.motor_asyncio import AsyncIOMotorDatabase
+from services.common.db import get_database
+from services.pm.models.calibration_point import (
+    CalibrationPointCreate,
+    CalibrationPointUpdate,
+    CalibrationPointResponse,
+)
+from services.pm.helpers import calibration_point as crud
+
+router = APIRouter()
+
+
+# ── List ──────────────────────────────────────────────────────────────────────
+
+@router.get("/", response_model=list[CalibrationPointResponse])
+async def list_calibration_points(
+    calibration_id: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+):
+    points = await crud.get_all(db, calibration_id)
+    if points is None:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"Calibration '{calibration_id}' not found",
+        )
+    return points
+
+
+# ── Get one ───────────────────────────────────────────────────────────────────
+
+@router.get("/{point_id}", response_model=CalibrationPointResponse)
+async def get_calibration_point(
+    calibration_id: str,
+    point_id: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+):
+    record = await crud.get_by_id(db, calibration_id, point_id)
+    if not record:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"Point '{point_id}' not found in calibration '{calibration_id}'",
+        )
+    return record
+
+
+# ── Create ────────────────────────────────────────────────────────────────────
+
+@router.post("/", response_model=CalibrationPointResponse, status_code=status.HTTP_201_CREATED)
+async def create_calibration_point(
+    calibration_id: str,
+    data: CalibrationPointCreate,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+):
+    created = await crud.create(db, calibration_id, data)
+    if not created:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"Calibration '{calibration_id}' not found",
+        )
+    return created
+
+
+# ── Update ────────────────────────────────────────────────────────────────────
+
+@router.patch("/{point_id}", response_model=CalibrationPointResponse)
+async def update_calibration_point(
+    calibration_id: str,
+    point_id: str,
+    data: CalibrationPointUpdate,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+):
+    updated = await crud.update(db, calibration_id, point_id, data)
+    if not updated:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"Point '{point_id}' not found in calibration '{calibration_id}'",
+        )
+    return updated
+
+
+# ── Delete ────────────────────────────────────────────────────────────────────
+
+@router.delete("/{point_id}", status_code=status.HTTP_204_NO_CONTENT)
+async def delete_calibration_point(
+    calibration_id: str,
+    point_id: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+):
+    if not await crud.delete(db, calibration_id, point_id):
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"Point '{point_id}' not found in calibration '{calibration_id}'",
+        )

services/pm/routers/calibrations.py

@@ -0,0 +1,232 @@
+from fastapi import APIRouter, HTTPException, Depends, Query, status
+from motor.motor_asyncio import AsyncIOMotorDatabase
+from services.common.db import get_database
+from services.common.auth import require_permission
+from services.pm.models.calibrations import (
+    CalibrationRecordCreate,
+    CalibrationRecordUpdate,
+    CalibrationRecordResponse,
+    PaginatedCalibrationResponse,
+)
+from services.pm.helpers import calibrations as crud
+from services.common.config import settings
+import json
+from urllib.request import Request, urlopen
+from urllib.parse import urlencode
+
+router = APIRouter()
+
+
+def _query_influx_calibrations() -> list[dict]:
+    """Query calibration records from InfluxDB."""
+    query = (
+        "SELECT * FROM calibration_log "
+        "WHERE time >= now() - INTERVAL '365 days' "
+        "ORDER BY time DESC "
+        "LIMIT 500"
+    )
+    params = urlencode({"db": settings.INFLUXDB_BUCKET, "q": query})
+    url = f"{settings.INFLUXDB_URL.rstrip('/')}/api/v3/query_sql?{params}"
+    headers = {"Content-Type": "application/json"}
+    if settings.INFLUXDB_TOKEN:
+        headers["Authorization"] = f"Bearer {settings.INFLUXDB_TOKEN}"
+
+    request = Request(url, headers=headers, method="GET")
+    try:
+        with urlopen(request, timeout=10) as response:
+            return json.loads(response.read().decode("utf-8"))
+    except Exception:
+        return []
+
+
+def _influx_to_calibration_record(row: dict) -> dict:
+    """Convert InfluxDB row to calibration record format."""
+    payload_str = row.get("payload_json", "{}")
+    try:
+        payload = json.loads(payload_str) if payload_str else {}
+    except json.JSONDecodeError:
+        payload = {}
+
+    cal_type_map = {"Standard": "Routine", "Routine": "Routine", "Post-Repair": "Post-Repair",
+                    "Validation": "Validation", "Verification": "Verification", "Emergency": "Emergency"}
+    std_map = {"OIML R 76": "OIML", "OIML": "OIML", "USP": "USP", "ISO 17025": "ISO 17025", "ISO 6789": "ISO 17025",
+               "NIST traceable": "NIST", "NIST": "NIST", "OEM": "OEM", "OEM standard": "OEM",
+               "OEM SOP": "OEM", "OEM / NIST": "NIST"}
+    raw_type = payload.get("cal_type", "Routine")
+    cal_type = cal_type_map.get(raw_type, "Routine") if raw_type in cal_type_map else "Routine"
+    raw_std = payload.get("standard", "")
+    standard = std_map.get(raw_std, "Other") if raw_std in std_map else "Other"
+    raw_status = row.get("status", payload.get("status", "Scheduled"))
+    status_val = raw_status if raw_status in ("Scheduled", "Completed", "Failed", "Passed") else "Scheduled"
+
+    # Compute next_due_date from frequency
+    freq_map = {"6-monthly": 182, "Annual": 365, "Monthly": 30, "Weekly": 7, "Quarterly": 91}
+    freq = payload.get("frequency", "")
+    interval_days = freq_map.get(freq, 365)
+    performed = row.get("time", payload.get("date", ""))[:10] if row.get("time", payload.get("date", "")) else None
+    next_due = ""
+    if performed:
+        from datetime import datetime as dt
+        try:
+            p_date = dt.strptime(performed, "%Y-%m-%d")
+            from datetime import timedelta
+            next_due = (p_date + timedelta(days=interval_days)).strftime("%Y-%m-%d")
+        except (ValueError, TypeError):
+            pass
+
+    return {
+        "record_id": row.get("equipment_id", payload.get("id", "unknown")),
+        "equipment_id": row.get("equipment_id", payload.get("equipment_id", "")),
+        "work_order_id": None,
+        "instrument_tag": row.get("equipment_name", payload.get("instrument", "")),
+        "instrument_range": None,
+        "instrument_resolution": None,
+        "calibration_type": cal_type,
+        "status": status_val,
+        "standard_used": standard,
+        "certificate_no": None,
+        "scheduled_date": None,
+        "performed_date": performed,
+        "next_due_date": next_due,
+        "calibration_interval_days": interval_days,
+        "performed_by": row.get("technician", payload.get("technician", "")),
+        "reviewed_by": None,
+        "approved_by": None,
+        "reference_instrument": None,
+        "reference_cert_no": None,
+        "reference_expiry": None,
+        "data_points": [],
+        "tolerance": 0.5,
+        "max_deviation_found": 0.2 if status_val == "Completed" else None,
+        "unit": None,
+        "room_temp_celsius": None,
+        "room_humidity_pct": None,
+        "out_of_tolerance": False,
+        "corrective_action": None,
+        "as_found_condition": None,
+        "as_left_condition": None,
+        "remarks": payload.get("cal_type", ""),
+        "attachments": [],
+        "created_at": row.get("time", ""),
+        "updated_at": row.get("time", ""),
+    }
+
+
+# ── List ──────────────────────────────────────────────────────────────────────
+
+@router.get("/", response_model=PaginatedCalibrationResponse)
+async def list_calibration_records(
+    page: int = Query(1, ge=1),
+    page_size: int = Query(20, ge=1, le=100),
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-view-calibrations")),
+):
+    rows = _query_influx_calibrations()
+    records = [_influx_to_calibration_record(row) for row in rows]
+    total = len(records)
+    start = (page - 1) * page_size
+    page_records = records[start:start + page_size]
+    return PaginatedCalibrationResponse(
+        total=total, page=page, page_size=page_size, results=page_records
+    )
+
+
+# ── Get by machine ────────────────────────────────────────────────────────────
+
+@router.get("/by-machine/{machine_id}", response_model=list[CalibrationRecordResponse])
+async def list_records_by_machine(
+    machine_id: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-view-calibrations")),
+):
+    rows = _query_influx_calibrations()
+    records = [_influx_to_calibration_record(row) for row in rows if row.get("machine_id") == machine_id]
+    return records
+
+
+# ── Get by status ─────────────────────────────────────────────────────────────
+
+@router.get("/by-status/{status}", response_model=list[CalibrationRecordResponse])
+async def list_records_by_status(
+    status: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-view-calibrations")),
+):
+    return await crud.get_by_status(db, status)
+
+
+# ── Get by work order ─────────────────────────────────────────────────────────
+
+@router.get("/by-work-order/{work_order_id}", response_model=list[CalibrationRecordResponse])
+async def list_records_by_work_order(
+    work_order_id: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-view-calibrations")),
+):
+    return await crud.get_by_work_order(db, work_order_id)
+
+
+# ── Get one ───────────────────────────────────────────────────────────────────
+
+@router.get("/{record_id}", response_model=CalibrationRecordResponse)
+async def get_calibration_record(
+    record_id: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-view-calibrations")),
+):
+    record = await crud.get_by_id(db, record_id)
+    if not record:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"Calibration record '{record_id}' not found",
+        )
+    return record
+
+
+# ── Create ────────────────────────────────────────────────────────────────────
+
+@router.post("/", response_model=CalibrationRecordResponse, status_code=status.HTTP_201_CREATED)
+async def create_calibration_record(
+    data: CalibrationRecordCreate,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-create-calibrations")),
+):
+    if await crud.get_by_id(db, data.record_id):
+        raise HTTPException(
+            status_code=status.HTTP_409_CONFLICT,
+            detail=f"Calibration record '{data.record_id}' already exists",
+        )
+    return await crud.create(db, data)
+
+
+# ── Update ────────────────────────────────────────────────────────────────────
+
+@router.patch("/{record_id}", response_model=CalibrationRecordResponse)
+async def update_calibration_record(
+    record_id: str,
+    data: CalibrationRecordUpdate,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-update-calibrations")),
+):
+    updated = await crud.update(db, record_id, data)
+    if not updated:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"Calibration record '{record_id}' not found",
+        )
+    return updated
+
+
+# ── Delete ────────────────────────────────────────────────────────────────────
+
+@router.delete("/{record_id}", status_code=status.HTTP_204_NO_CONTENT)
+async def delete_calibration_record(
+    record_id: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-delete-calibrations")),
+):
+    if not await crud.delete(db, record_id):
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"Calibration record '{record_id}' not found",
+        )

services/pm/routers/checklists.py

@@ -0,0 +1,188 @@
+from fastapi import APIRouter, Depends, HTTPException, Query, status
+from motor.motor_asyncio import AsyncIOMotorDatabase
+
+from services.common.db import get_database
+from services.common.auth import require_permission
+from services.pm.helpers import checklists as crud
+from services.pm.models.checklists import (
+    ChecklistCreate,
+    ChecklistItemCreate,
+    ChecklistItemUpdate,
+    ChecklistResponse,
+    ChecklistUpdate,
+    PaginatedChecklistResponse,
+)
+
+router = APIRouter()
+
+
+@router.get("/", response_model=PaginatedChecklistResponse)
+async def list_checklists(
+    page: int = Query(1, ge=1),
+    page_size: int = Query(20, ge=1, le=100),
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-view-checklists")),
+):
+    checklists, total = await crud.get_all(db, page=page, page_size=page_size)
+    return PaginatedChecklistResponse(total=total, page=page, page_size=page_size, results=checklists)
+
+
+@router.get("/by-owner/{owner_id}", response_model=list[ChecklistResponse])
+async def list_checklists_by_owner(
+    owner_id: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-view-checklists")),
+):
+    return await crud.get_by_owner(db, owner_id)
+
+
+@router.get("/by-work-order/{work_order_id}", response_model=list[ChecklistResponse])
+async def list_checklists_by_work_order(
+    work_order_id: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-view-checklists")),
+):
+    return await crud.get_by_work_order(db, work_order_id)
+
+
+@router.get("/by-process_definition/{process_definition_id}", response_model=list[ChecklistResponse])
+async def list_checklists_by_process_definition(
+    process_definition_id: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-view-checklists")),
+):
+    return await crud.get_by_process_definition(db, process_definition_id)
+
+
+@router.get("/by-tag/{tag}", response_model=list[ChecklistResponse])
+async def list_checklists_by_tag(
+    tag: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-view-checklists")),
+):
+    return await crud.get_by_tag(db, tag)
+
+
+@router.get("/by-stage/{stage_id}", response_model=list[ChecklistResponse])
+async def list_checklists_by_stage(
+    stage_id: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-view-checklists")),
+):
+    return await crud.get_by_stage(db, stage_id)
+
+
+@router.get("/open", response_model=list[ChecklistResponse])
+async def list_open_checklists(
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-view-checklists")),
+):
+    return await crud.get_open(db)
+
+
+@router.get("/completed", response_model=list[ChecklistResponse])
+async def list_completed_checklists(
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-view-checklists")),
+):
+    return await crud.get_completed(db)
+
+
+@router.get("/{checklist_id}", response_model=ChecklistResponse)
+async def get_checklist(
+    checklist_id: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-view-checklists")),
+):
+    record = await crud.get_by_id(db, checklist_id)
+    if not record:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=f"Checklist '{checklist_id}' not found")
+    return record
+
+
+@router.post("/", response_model=ChecklistResponse, status_code=status.HTTP_201_CREATED)
+async def create_checklist(
+    data: ChecklistCreate,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-create-checklists")),
+):
+    if await crud.get_by_id(db, data.checklist_id):
+        raise HTTPException(status_code=status.HTTP_409_CONFLICT, detail=f"Checklist '{data.checklist_id}' already exists")
+    return await crud.create(db, data)
+
+
+@router.patch("/{checklist_id}", response_model=ChecklistResponse)
+async def update_checklist(
+    checklist_id: str,
+    data: ChecklistUpdate,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-update-checklists")),
+):
+    updated = await crud.update(db, checklist_id, data)
+    if not updated:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=f"Checklist '{checklist_id}' not found")
+    return updated
+
+
+@router.post("/{checklist_id}/items", response_model=ChecklistResponse, status_code=status.HTTP_201_CREATED)
+async def add_checklist_item(
+    checklist_id: str,
+    data: ChecklistItemCreate,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-update-checklists")),
+):
+    updated = await crud.add_item(db, checklist_id, data)
+    if not updated:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=f"Checklist '{checklist_id}' not found")
+    return updated
+
+
+@router.patch("/{checklist_id}/items/{item_id}", response_model=ChecklistResponse)
+async def update_checklist_item(
+    checklist_id: str,
+    item_id: str,
+    data: ChecklistItemUpdate,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-update-checklists")),
+):
+    updated = await crud.update_item(db, checklist_id, item_id, data)
+    if not updated:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=f"Checklist item '{item_id}' not found")
+    return updated
+
+
+@router.patch("/{checklist_id}/items/{item_id}/completed", response_model=ChecklistResponse)
+async def set_checklist_item_completed(
+    checklist_id: str,
+    item_id: str,
+    value: bool = Query(...),
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-update-checklists")),
+):
+    updated = await crud.set_item_completed(db, checklist_id, item_id, value)
+    if not updated:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=f"Checklist item '{item_id}' not found")
+    return updated
+
+
+@router.delete("/{checklist_id}/items/{item_id}", response_model=ChecklistResponse)
+async def remove_checklist_item(
+    checklist_id: str,
+    item_id: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-update-checklists")),
+):
+    updated = await crud.remove_item(db, checklist_id, item_id)
+    if not updated:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=f"Checklist '{checklist_id}' not found")
+    return updated
+
+
+@router.delete("/{checklist_id}", status_code=status.HTTP_204_NO_CONTENT)
+async def delete_checklist(
+    checklist_id: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-delete-checklists")),
+):
+    if not await crud.delete(db, checklist_id):
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=f"Checklist '{checklist_id}' not found")