monkeybrain-runtime 1.0.0__py3-none-any.whl

services/orders/routers/orders.py

@@ -0,0 +1,74 @@
+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.orders.helpers import orders as crud
+from services.orders.models.orders import (
+    OrderCreate,
+    OrderResponse,
+    OrderUpdate,
+    PaginatedOrderResponse,
+)
+
+router = APIRouter()
+
+
+@router.get("/", response_model=PaginatedOrderResponse)
+async def list_orders(
+    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-order")),
+):
+    records, total = await crud.get_all(db, page=page, page_size=page_size)
+    return PaginatedOrderResponse(total=total, page=page, page_size=page_size, results=records)
+
+
+@router.get("/{order_id}", response_model=OrderResponse)
+async def get_order(
+    order_id: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-view-order")),
+):
+    record = await crud.get_by_order_id(db, order_id)
+    if not record:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=f"Order '{order_id}' not found")
+    return record
+
+
+@router.post("/", response_model=OrderResponse, status_code=status.HTTP_201_CREATED)
+async def create_order(
+    data: OrderCreate,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-create-order")),
+):
+    if await crud.get_by_order_id(db, data.details.order_id):
+        raise HTTPException(
+            status_code=status.HTTP_409_CONFLICT,
+            detail=f"Order '{data.details.order_id}' already exists",
+        )
+    return await crud.create(db, data)
+
+
+@router.patch("/{order_id}", response_model=OrderResponse)
+async def update_order(
+    order_id: str,
+    data: OrderUpdate,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-update-order")),
+):
+    record = await crud.update(db, order_id, data)
+    if not record:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=f"Order '{order_id}' not found")
+    return record
+
+
+@router.delete("/{order_id}", status_code=status.HTTP_204_NO_CONTENT)
+async def delete_order(
+    order_id: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-delete-order")),
+):
+    if not await crud.delete(db, order_id):
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=f"Order '{order_id}' not found")

services/orders/routers/sales_orders.py

@@ -0,0 +1,111 @@
+from fastapi import APIRouter, Depends, HTTPException, Query, status
+from motor.motor_asyncio import AsyncIOMotorDatabase
+
+from services.common.auth import require_permission
+from services.common.db import get_database
+from services.orders.helpers import sales_orders as crud
+from services.orders.models.sales_orders import (
+    PaginatedSalesOrderResponse,
+    SalesOrderCreate,
+    SalesOrderResponse,
+    SalesOrderStatus,
+    SalesOrderUpdate,
+)
+
+router = APIRouter()
+
+
+@router.get("/", response_model=PaginatedSalesOrderResponse)
+async def list_sales_orders(
+    page: int = Query(1, ge=1),
+    page_size: int = Query(20, ge=1, le=1000),
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-view-order")),
+):
+    records, total = await crud.get_all(db, page=page, page_size=page_size)
+    return PaginatedSalesOrderResponse(
+        total=total,
+        page=page,
+        page_size=page_size,
+        results=records,
+    )
+
+
+@router.get("/by-customer/{customer_id}", response_model=list[SalesOrderResponse])
+async def list_sales_orders_by_customer(
+    customer_id: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-view-order")),
+):
+    return await crud.get_by_customer_id(db, customer_id)
+
+
+@router.get("/by-status/{sales_status}", response_model=list[SalesOrderResponse])
+async def list_sales_orders_by_status(
+    sales_status: SalesOrderStatus,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-view-order")),
+):
+    return await crud.get_by_status(db, sales_status.value)
+
+
+@router.get("/by-sku/{sku}", response_model=list[SalesOrderResponse])
+async def list_sales_orders_by_sku(
+    sku: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-view-order")),
+):
+    return await crud.get_by_sku(db, sku)
+
+
+@router.get("/{sales_order_id}", response_model=SalesOrderResponse)
+async def get_sales_order(
+    sales_order_id: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-view-order")),
+):
+    record = await crud.get_by_sales_order_id(db, sales_order_id)
+    if not record:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"Sales order '{sales_order_id}' not found",
+        )
+    return record
+
+
+@router.post("/", response_model=SalesOrderResponse, status_code=status.HTTP_201_CREATED)
+async def create_sales_order(
+    data: SalesOrderCreate,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-create-order")),
+):
+    return await crud.create(db, data)
+
+
+@router.patch("/{sales_order_id}", response_model=SalesOrderResponse)
+async def update_sales_order(
+    sales_order_id: str,
+    data: SalesOrderUpdate,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-update-order")),
+):
+    updated = await crud.update(db, sales_order_id, data)
+    if not updated:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"Sales order '{sales_order_id}' not found",
+        )
+    return updated
+
+
+@router.delete("/{sales_order_id}", status_code=status.HTTP_204_NO_CONTENT)
+async def delete_sales_order(
+    sales_order_id: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-delete-order")),
+):
+    if not await crud.delete(db, sales_order_id):
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"Sales order '{sales_order_id}' not found",
+        )

services/pm/helpers/__init__.py

@@ -0,0 +1,14 @@
+"""pm service helpers package."""
+
+__all__ = [
+    "calendar_bookings",
+    "calibration_point",
+    "calibrations",
+    "checklists",
+    "cleaning",
+    "downtime",
+    "kanban_boards",
+    "maintainance",
+    "sop",
+    "weekly_schedules",
+]

services/pm/helpers/calendar_bookings.py

@@ -0,0 +1,114 @@
+from __future__ import annotations
+
+from datetime import datetime
+from typing import Any, Optional
+from uuid import UUID
+
+from motor.motor_asyncio import AsyncIOMotorDatabase
+from pymongo import ReturnDocument
+
+from services.pm.models.calendar_booking import CalendarBookingCreate, CalendarBookingUpdate
+
+COLLECTION = "calendar_bookings"
+
+
+def _serialize(doc: dict) -> dict:
+    doc = dict(doc)
+    doc.pop("_id", None)
+    return doc
+
+
+def _json_safe(value: Any) -> Any:
+    if isinstance(value, UUID):
+        return str(value)
+    if isinstance(value, list):
+        return [_json_safe(item) for item in value]
+    if isinstance(value, dict):
+        return {key: _json_safe(item) for key, item in value.items()}
+    return value
+
+
+def _dump(data) -> dict:
+    return _json_safe(data.model_dump(exclude_unset=True))
+
+
+def _overlap_query(
+    calendar_id: str,
+    start_at: datetime,
+    end_at: datetime,
+    exclude_id: Optional[str] = None,
+) -> dict:
+    query = {
+        "calendar_id": calendar_id,
+        "status": "booked",
+        "start_at": {"$lt": end_at},
+        "end_at": {"$gt": start_at},
+    }
+    if exclude_id is not None:
+        query["id"] = {"$ne": exclude_id}
+    return query
+
+
+async def get_all(
+    db: AsyncIOMotorDatabase,
+    page: int = 1,
+    page_size: int = 20,
+) -> tuple[list[dict], int]:
+    query: dict = {}
+    total = await db[COLLECTION].count_documents(query)
+    cursor = db[COLLECTION].find(query).skip((page - 1) * page_size).limit(page_size)
+    return [_serialize(d) async for d in cursor], total
+
+
+async def get_by_id(db: AsyncIOMotorDatabase, booking_id: str) -> Optional[dict]:
+    doc = await db[COLLECTION].find_one({"id": booking_id})
+    return _serialize(doc) if doc else None
+
+
+async def get_by_calendar(db: AsyncIOMotorDatabase, calendar_id: str) -> list[dict]:
+    cursor = db[COLLECTION].find({"calendar_id": calendar_id})
+    return [_serialize(d) async for d in cursor]
+
+
+async def get_by_booked_by(db: AsyncIOMotorDatabase, booked_by: str) -> list[dict]:
+    cursor = db[COLLECTION].find({"booked_by": booked_by})
+    return [_serialize(d) async for d in cursor]
+
+
+async def has_conflict(
+    db: AsyncIOMotorDatabase,
+    calendar_id: str,
+    start_at: datetime,
+    end_at: datetime,
+    exclude_id: Optional[str] = None,
+) -> bool:
+    return await db[COLLECTION].find_one(
+        _overlap_query(calendar_id, start_at, end_at, exclude_id=exclude_id)
+    ) is not None
+
+
+async def create(db: AsyncIOMotorDatabase, data: CalendarBookingCreate) -> dict:
+    doc = _json_safe(data.model_dump())
+    await db[COLLECTION].insert_one(doc)
+    return _serialize(doc)
+
+
+async def update(
+    db: AsyncIOMotorDatabase,
+    booking_id: str,
+    data: CalendarBookingUpdate,
+) -> Optional[dict]:
+    fields = _dump(data)
+    if not fields:
+        return await get_by_id(db, booking_id)
+    result = await db[COLLECTION].find_one_and_update(
+        {"id": booking_id},
+        {"$set": fields},
+        return_document=ReturnDocument.AFTER,
+    )
+    return _serialize(result) if result else None
+
+
+async def delete(db: AsyncIOMotorDatabase, booking_id: str) -> bool:
+    result = await db[COLLECTION].delete_one({"id": booking_id})
+    return result.deleted_count == 1

services/pm/helpers/calibration_point.py

@@ -0,0 +1,110 @@
+from datetime import datetime
+from typing import Optional
+from uuid import uuid4
+from motor.motor_asyncio import AsyncIOMotorDatabase
+from services.pm.models.calibration_point import CalibrationPointCreate, CalibrationPointUpdate
+
+COLLECTION = "calibration_points"
+
+
+def _serialize(doc: dict) -> dict:
+    doc = dict(doc)
+    doc.pop("_id", None)
+    return doc
+
+
+# ── Read ──────────────────────────────────────────────────────────────────────
+
+async def get_all(
+    db: AsyncIOMotorDatabase,
+    calibration_id: str,
+) -> Optional[list[dict]]:
+    doc = await db[COLLECTION].find_one(
+        {"calibration_id": calibration_id},
+        {"calibration_points": 1, "_id": 0},
+    )
+    if doc is None:
+        return None
+    return [_serialize(p) for p in doc.get("calibration_points", [])]
+
+
+async def get_by_id(
+    db: AsyncIOMotorDatabase,
+    calibration_id: str,
+    point_id: str,
+) -> Optional[dict]:
+    doc = await db[COLLECTION].find_one(
+        {"calibration_id": calibration_id},
+        {"calibration_points": 1, "_id": 0},
+    )
+    if doc is None:
+        return None
+    for point in doc.get("calibration_points", []):
+        if point.get("point_id") == point_id:
+            return _serialize(point)
+    return None
+
+
+# ── Create ────────────────────────────────────────────────────────────────────
+
+async def create(
+    db: AsyncIOMotorDatabase,
+    calibration_id: str,
+    data: CalibrationPointCreate,
+) -> Optional[dict]:
+    point = data.model_dump()
+    point["point_id"] = str(uuid4())
+    point["created_at"] = datetime.utcnow()
+    point["updated_at"] = datetime.utcnow()
+
+    result = await db[COLLECTION].find_one_and_update(
+        {"calibration_id": calibration_id},
+        {"$push": {"calibration_points": point}},
+        return_document=True,
+    )
+    if result is None:
+        return None
+    return _serialize(point)
+
+
+# ── Update ────────────────────────────────────────────────────────────────────
+
+async def update(
+    db: AsyncIOMotorDatabase,
+    calibration_id: str,
+    point_id: str,
+    data: CalibrationPointUpdate,
+) -> Optional[dict]:
+    fields = data.model_dump(exclude_unset=True)
+    if not fields:
+        return await get_by_id(db, calibration_id, point_id)
+
+    fields["updated_at"] = datetime.utcnow()
+    set_payload = {f"calibration_points.$.{k}": v for k, v in fields.items()}
+
+    result = await db[COLLECTION].find_one_and_update(
+        {"calibration_id": calibration_id, "calibration_points.point_id": point_id},
+        {"$set": set_payload},
+        return_document=True,
+    )
+    if result is None:
+        return None
+
+    for point in result.get("calibration_points", []):
+        if point.get("point_id") == point_id:
+            return _serialize(point)
+    return None
+
+
+# ── Delete ────────────────────────────────────────────────────────────────────
+
+async def delete(
+    db: AsyncIOMotorDatabase,
+    calibration_id: str,
+    point_id: str,
+) -> bool:
+    result = await db[COLLECTION].update_one(
+        {"calibration_id": calibration_id},
+        {"$pull": {"calibration_points": {"point_id": point_id}}},
+    )
+    return result.modified_count == 1

services/pm/helpers/calibrations.py

@@ -0,0 +1,196 @@
+"""Calibration records CRUD — reads/writes from InfluxDB calibration_log measurement."""
+
+import json
+import logging
+from datetime import date, datetime, timezone
+from typing import Optional
+from urllib.request import Request, urlopen
+from urllib.parse import urlencode
+
+from motor.motor_asyncio import AsyncIOMotorDatabase
+from services.common.config import settings
+from services.pm.models.calibrations import CalibrationRecordCreate, CalibrationRecordUpdate
+
+logger = logging.getLogger(__name__)
+
+COLLECTION = "calibration_log"  # InfluxDB measurement name
+
+
+def _escape_tag(value: str) -> str:
+    return str(value).replace(",", "\\,").replace(" ", "\\ ").replace("=", "\\=")
+
+
+def _influx_write(lines: list[str]) -> None:
+    """Write line protocol lines to InfluxDB."""
+    query = urlencode({"db": settings.INFLUXDB_BUCKET})
+    url = f"{settings.INFLUXDB_URL.rstrip('/')}/api/v3/write_lp?{query}"
+    headers = {"Content-Type": "text/plain; charset=utf-8"}
+    if settings.INFLUXDB_TOKEN:
+        headers["Authorization"] = f"Bearer {settings.INFLUXDB_TOKEN}"
+    body = "\n".join(lines)
+    request = Request(url, data=body.encode("utf-8"), headers=headers, method="POST")
+    with urlopen(request, timeout=10) as response:
+        response.read()
+
+
+def _influx_query(sql: str) -> list[dict]:
+    """Execute SQL query against InfluxDB."""
+    params = urlencode({"db": settings.INFLUXDB_BUCKET, "q": sql})
+    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")
+    with urlopen(request, timeout=10) as response:
+        return json.loads(response.read().decode("utf-8"))
+
+
+def _row_to_dict(row: dict) -> dict:
+    """Convert InfluxDB row to dict format expected by API."""
+    time_val = row.get("time", "")
+    return {
+        "record_id": row.get("equipment_id", ""),
+        "equipment_id": row.get("equipment_id", ""),
+        "work_order_id": row.get("work_order_id", None),
+        "instrument_tag": row.get("instrument_tag", None),
+        "instrument_range": row.get("instrument_range", None),
+        "instrument_resolution": row.get("instrument_resolution", None),
+        "calibration_type": row.get("calibration_type", "Routine"),
+        "status": row.get("status", "Scheduled"),
+        "standard_used": row.get("standard_used", "In-House"),
+        "certificate_no": row.get("certificate_no", None),
+        "scheduled_date": None,
+        "performed_date": time_val[:10] if time_val else None,
+        "next_due_date": None,
+        "calibration_interval_days": None,
+        "performed_by": row.get("technician", None),
+        "reviewed_by": None,
+        "approved_by": None,
+        "reference_instrument": None,
+        "reference_cert_no": None,
+        "reference_expiry": None,
+        "data_points": [],
+        "tolerance": None,
+        "max_deviation_found": None,
+        "unit": None,
+        "room_temp_celsius": None,
+        "room_humidity_pct": None,
+        "out_of_tolerance": False,
+        "corrective_action": None,
+        "as_found_condition": row.get("result", None),
+        "as_left_condition": None,
+        "remarks": None,
+        "attachments": [],
+        "created_at": time_val or datetime.now(timezone.utc).isoformat(),
+        "updated_at": time_val or datetime.now(timezone.utc).isoformat(),
+    }
+
+
+def _record_to_line(data: dict, ts_ns: int) -> str:
+    """Convert calibration record to InfluxDB line protocol."""
+    tags = (
+        f"equipment_id={_escape_tag(data.get('equipment_id', ''))},"
+        f"machine_id={_escape_tag(data.get('machine_id', ''))},"
+        f"status={_escape_tag(data.get('status', 'Scheduled'))},"
+        f"technician={_escape_tag(data.get('technician', ''))},"
+        f"result={_escape_tag(data.get('result', ''))},"
+        f"calibration_type={_escape_tag(data.get('calibration_type', 'Routine'))},"
+        f"standard_used={_escape_tag(data.get('standard_used', 'In-House'))}"
+    )
+    fields = (
+        f"record_id={_escape_tag(data.get('record_id', ''))},"
+        f"equipment_id={_escape_tag(data.get('equipment_id', ''))},"
+        f"machine_id={_escape_tag(data.get('machine_id', ''))},"
+        f"calibration_type={_escape_tag(data.get('calibration_type', 'Routine'))},"
+        f"status={_escape_tag(data.get('status', 'Scheduled'))},"
+        f"standard_used={_escape_tag(data.get('standard_used', 'In-House'))},"
+        f"technician={_escape_tag(data.get('technician', ''))},"
+        f"result={_escape_tag(data.get('result', ''))}"
+    )
+    return f"{COLLECTION},{tags} {fields} {ts_ns}"
+
+
+# ── Read ──────────────────────────────────────────────────────────────────────
+
+async def get_all(
+    db: AsyncIOMotorDatabase,
+    page: int = 1,
+    page_size: int = 20,
+) -> tuple[list[dict], int]:
+    sql = f"SELECT * FROM {COLLECTION} ORDER BY time DESC LIMIT {page_size} OFFSET {(page - 1) * page_size}"
+    rows = _influx_query(sql)
+    total_sql = f"SELECT count(*) as cnt FROM {COLLECTION}"
+    total_rows = _influx_query(total_sql)
+    total = total_rows[0].get("cnt", 0) if total_rows else 0
+    return [_row_to_dict(r) for r in rows], total
+
+
+async def get_by_id(db: AsyncIOMotorDatabase, record_id: str) -> Optional[dict]:
+    sql = f"SELECT * FROM {COLLECTION} WHERE record_id = '{record_id}' LIMIT 1"
+    rows = _influx_query(sql)
+    return _row_to_dict(rows[0]) if rows else None
+
+
+async def get_by_machine(db: AsyncIOMotorDatabase, machine_id: str) -> list[dict]:
+    sql = f"SELECT * FROM {COLLECTION} WHERE machine_id = '{machine_id}' ORDER BY time DESC LIMIT 100"
+    rows = _influx_query(sql)
+    return [_row_to_dict(r) for r in rows]
+
+
+async def get_by_status(db: AsyncIOMotorDatabase, status: str) -> list[dict]:
+    sql = f"SELECT * FROM {COLLECTION} WHERE status = '{status}' ORDER BY time DESC LIMIT 100"
+    rows = _influx_query(sql)
+    return [_row_to_dict(r) for r in rows]
+
+
+async def get_by_work_order(db: AsyncIOMotorDatabase, work_order_id: str) -> list[dict]:
+    sql = f"SELECT * FROM {COLLECTION} WHERE work_order_id = '{work_order_id}' ORDER BY time DESC LIMIT 100"
+    rows = _influx_query(sql)
+    return [_row_to_dict(r) for r in rows]
+
+
+# ── Create ────────────────────────────────────────────────────────────────────
+
+async def create(db: AsyncIOMotorDatabase, data: CalibrationRecordCreate) -> dict:
+    record = data.model_dump()
+    record["created_at"] = datetime.now(timezone.utc).isoformat()
+    record["updated_at"] = datetime.now(timezone.utc).isoformat()
+    ts_ns = int(datetime.now(timezone.utc).timestamp() * 1_000_000_000)
+    line = _record_to_line(record, ts_ns)
+    _influx_write([line])
+    return record
+
+
+# ── Update ────────────────────────────────────────────────────────────────────
+
+async def update(
+    db: AsyncIOMotorDatabase,
+    record_id: str,
+    data: CalibrationRecordUpdate,
+) -> Optional[dict]:
+    # InfluxDB doesn't support update-in-place; write new record with updated fields
+    existing = await get_by_id(db, record_id)
+    if not existing:
+        return None
+    updates = data.model_dump(exclude_unset=True)
+    existing.update(updates)
+    existing["updated_at"] = datetime.now(timezone.utc).isoformat()
+    ts_ns = int(datetime.now(timezone.utc).timestamp() * 1_000_000_000)
+    line = _record_to_line(existing, ts_ns)
+    _influx_write([line])
+    return existing
+
+
+# ── Delete ────────────────────────────────────────────────────────────────────
+
+async def delete(db: AsyncIOMotorDatabase, record_id: str) -> bool:
+    # InfluxDB doesn't support delete-by-field; mark as deleted via status update
+    existing = await get_by_id(db, record_id)
+    if not existing:
+        return False
+    existing["status"] = "Deleted"
+    existing["updated_at"] = datetime.now(timezone.utc).isoformat()
+    ts_ns = int(datetime.now(timezone.utc).timestamp() * 1_000_000_000)
+    line = _record_to_line(existing, ts_ns)
+    _influx_write([line])
+    return True