monkeybrain-runtime 1.0.0__py3-none-any.whl

services/process_definitions/helpers/process_pre_checks.py

@@ -0,0 +1,351 @@
+"""
+helpers/prechecks_helper.py
+----------------------------
+MongoDB CRUD helper for ProcessPrechecks and ProcessStepPrechecks models.
+Mirrors the pattern established in the devices helper.
+
+Collections
+-----------
+  process_definition_prechecks       → ProcessPrechecks documents (one per process_definition)
+  process_step_prechecks  → ProcessStepPrechecks documents (one per step)
+"""
+
+from typing import Optional
+from motor.motor_asyncio import AsyncIOMotorDatabase
+
+from services.process_definitions.models.process_pre_checks import (
+    ProcessPrechecksCreate,
+    ProcessPrechecksUpdate,
+    ProcessStepPrechecksCreate,
+    ProcessStepPrechecksUpdate,
+    PreCheckConditionCreate,
+)
+
+WORKFLOW_COLLECTION = "process_definition_prechecks"
+STEP_COLLECTION = "process_step_prechecks"
+
+
+def _serialize(doc: dict) -> dict:
+    """Strip MongoDB's internal _id before returning a document."""
+    doc.pop("_id", None)
+    return doc
+
+
+# ===========================================================================
+# ProcessPrechecks  (process_definition-level)
+# ===========================================================================
+
+# ---------------------------------------------------------------------------
+# Read
+# ---------------------------------------------------------------------------
+
+async def get_all(
+    db: AsyncIOMotorDatabase,
+    page: int = 1,
+    page_size: int = 20,
+) -> tuple[list[dict], int]:
+    """Return a paginated list of all ProcessPrechecks containers."""
+    query: dict = {}
+    total = await db[WORKFLOW_COLLECTION].count_documents(query)
+    cursor = (
+        db[WORKFLOW_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,
+    prechecks_id: str,
+) -> Optional[dict]:
+    """Fetch a ProcessPrechecks container by its id."""
+    doc = await db[WORKFLOW_COLLECTION].find_one({"id": prechecks_id})
+    return _serialize(doc) if doc else None
+
+
+async def get_by_process_definition_id(
+    db: AsyncIOMotorDatabase,
+    process_definition_id: str,
+) -> Optional[dict]:
+    """Fetch the prechecks container that belongs to a given process_definition."""
+    if not process_definition_id:
+        return None
+    doc = await db[WORKFLOW_COLLECTION].find_one({"process_definition_id": process_definition_id})
+    return _serialize(doc) if doc else None
+
+
+async def get_conditions_by_severity(
+    db: AsyncIOMotorDatabase,
+    prechecks_id: str,
+    severity: str,
+) -> list[dict]:
+    """Return all conditions within a container that match a given severity."""
+    doc = await db[WORKFLOW_COLLECTION].find_one({"id": prechecks_id})
+    if not doc:
+        return []
+    return [
+        c for c in doc.get("process_definition_precheck_conditions", [])
+        if c.get("severity") == severity
+    ]
+
+
+async def get_mandatory_conditions(
+    db: AsyncIOMotorDatabase,
+    prechecks_id: str,
+) -> list[dict]:
+    """Return only the mandatory conditions from a container."""
+    doc = await db[WORKFLOW_COLLECTION].find_one({"id": prechecks_id})
+    if not doc:
+        return []
+    return [
+        c for c in doc.get("process_definition_precheck_conditions", [])
+        if c.get("is_mandatory") is True
+    ]
+
+
+# ---------------------------------------------------------------------------
+# Write
+# ---------------------------------------------------------------------------
+
+async def create(
+    db: AsyncIOMotorDatabase,
+    data: ProcessPrechecksCreate,
+) -> dict:
+    """Insert a new ProcessPrechecks container and return it."""
+    doc = data.model_dump()
+    await db[WORKFLOW_COLLECTION].insert_one(doc)
+    return _serialize(doc)
+
+
+async def update(
+    db: AsyncIOMotorDatabase,
+    prechecks_id: str,
+    data: ProcessPrechecksUpdate,
+) -> Optional[dict]:
+    """
+    Partially update a ProcessPrechecks container.
+    Only non-None fields are written.
+    """
+    fields = {k: v for k, v in data.model_dump().items() if v is not None}
+    if not fields:
+        return await get_by_id(db, prechecks_id)
+    result = await db[WORKFLOW_COLLECTION].find_one_and_update(
+        {"id": prechecks_id},
+        {"$set": fields},
+        return_document=True,
+    )
+    return _serialize(result) if result else None
+
+
+async def add_condition(
+    db: AsyncIOMotorDatabase,
+    prechecks_id: str,
+    condition: PreCheckConditionCreate,
+) -> Optional[dict]:
+    """Append a new PreCheckCondition to the conditions array."""
+    result = await db[WORKFLOW_COLLECTION].find_one_and_update(
+        {"id": prechecks_id},
+        {"$push": {"process_definition_precheck_conditions": condition.model_dump()}},
+        return_document=True,
+    )
+    return _serialize(result) if result else None
+
+
+async def update_condition(
+    db: AsyncIOMotorDatabase,
+    prechecks_id: str,
+    condition_id: str,
+    fields: dict,
+) -> Optional[dict]:
+    """
+    Update specific fields of a PreCheckCondition inside the conditions array.
+    Pass only the fields you want to change in the `fields` dict.
+    """
+    updates = {f"process_definition_precheck_conditions.$.{k}": v for k, v in fields.items()}
+    result = await db[WORKFLOW_COLLECTION].find_one_and_update(
+        {"id": prechecks_id, "process_definition_precheck_conditions.id": condition_id},
+        {"$set": updates},
+        return_document=True,
+    )
+    return _serialize(result) if result else None
+
+
+async def remove_condition(
+    db: AsyncIOMotorDatabase,
+    prechecks_id: str,
+    condition_id: str,
+) -> Optional[dict]:
+    """Remove a specific condition from the conditions array."""
+    result = await db[WORKFLOW_COLLECTION].find_one_and_update(
+        {"id": prechecks_id},
+        {"$pull": {"process_definition_precheck_conditions": {"id": condition_id}}},
+        return_document=True,
+    )
+    return _serialize(result) if result else None
+
+
+async def delete(
+    db: AsyncIOMotorDatabase,
+    prechecks_id: str,
+) -> bool:
+    """Delete a ProcessPrechecks container by ID."""
+    result = await db[WORKFLOW_COLLECTION].delete_one({"id": prechecks_id})
+    return result.deleted_count == 1
+
+
+async def delete_by_process_definition_id(
+    db: AsyncIOMotorDatabase,
+    process_definition_id: str,
+) -> bool:
+    """Delete the prechecks container that belongs to a process_definition (cascade delete)."""
+    result = await db[WORKFLOW_COLLECTION].delete_one({"process_definition_id": process_definition_id})
+    return result.deleted_count == 1
+
+
+# ===========================================================================
+# ProcessStepPrechecks  (step-level)
+# ===========================================================================
+
+# ---------------------------------------------------------------------------
+# Read
+# ---------------------------------------------------------------------------
+
+async def get_step_prechecks_by_id(
+    db: AsyncIOMotorDatabase,
+    prechecks_id: str,
+) -> Optional[dict]:
+    """Fetch a ProcessStepPrechecks container by its id."""
+    doc = await db[STEP_COLLECTION].find_one({"id": prechecks_id})
+    return _serialize(doc) if doc else None
+
+
+async def get_step_prechecks_by_step_id(
+    db: AsyncIOMotorDatabase,
+    step_id: str,
+) -> Optional[dict]:
+    """Fetch the prechecks container that belongs to a given process_definition step."""
+    if not step_id:
+        return None
+    doc = await db[STEP_COLLECTION].find_one({"process_step_id": step_id})
+    return _serialize(doc) if doc else None
+
+
+async def get_step_prechecks_by_process_definition_id(
+    db: AsyncIOMotorDatabase,
+    process_definition_id: str,
+) -> list[dict]:
+    """Return all step-level prechecks containers that share the same process_definition_id."""
+    if not process_definition_id:
+        return []
+    cursor = db[STEP_COLLECTION].find({"process_definition_id": process_definition_id})
+    return [_serialize(d) async for d in cursor]
+
+
+async def get_step_conditions_by_severity(
+    db: AsyncIOMotorDatabase,
+    prechecks_id: str,
+    severity: str,
+) -> list[dict]:
+    """Return all step-level conditions that match a given severity."""
+    doc = await db[STEP_COLLECTION].find_one({"id": prechecks_id})
+    if not doc:
+        return []
+    return [
+        c for c in doc.get("process_step_precheck_conditions", [])
+        if c.get("severity") == severity
+    ]
+
+
+# ---------------------------------------------------------------------------
+# Write
+# ---------------------------------------------------------------------------
+
+async def create_step_prechecks(
+    db: AsyncIOMotorDatabase,
+    data: ProcessStepPrechecksCreate,
+) -> dict:
+    """Insert a new ProcessStepPrechecks container and return it."""
+    doc = data.model_dump()
+    await db[STEP_COLLECTION].insert_one(doc)
+    return _serialize(doc)
+
+
+async def update_step_prechecks(
+    db: AsyncIOMotorDatabase,
+    prechecks_id: str,
+    data: ProcessStepPrechecksUpdate,
+) -> Optional[dict]:
+    """Partially update a ProcessStepPrechecks container."""
+    fields = {k: v for k, v in data.model_dump().items() if v is not None}
+    if not fields:
+        return await get_step_prechecks_by_id(db, prechecks_id)
+    result = await db[STEP_COLLECTION].find_one_and_update(
+        {"id": prechecks_id},
+        {"$set": fields},
+        return_document=True,
+    )
+    return _serialize(result) if result else None
+
+
+async def add_step_condition(
+    db: AsyncIOMotorDatabase,
+    prechecks_id: str,
+    condition: PreCheckConditionCreate,
+) -> Optional[dict]:
+    """Append a new PreCheckCondition to a step's conditions array."""
+    result = await db[STEP_COLLECTION].find_one_and_update(
+        {"id": prechecks_id},
+        {"$push": {"process_step_precheck_conditions": condition.model_dump()}},
+        return_document=True,
+    )
+    return _serialize(result) if result else None
+
+
+async def update_step_condition(
+    db: AsyncIOMotorDatabase,
+    prechecks_id: str,
+    condition_id: str,
+    fields: dict,
+) -> Optional[dict]:
+    """Update specific fields of a condition inside a step's conditions array."""
+    updates = {f"process_step_precheck_conditions.$.{k}": v for k, v in fields.items()}
+    result = await db[STEP_COLLECTION].find_one_and_update(
+        {"id": prechecks_id, "process_step_precheck_conditions.id": condition_id},
+        {"$set": updates},
+        return_document=True,
+    )
+    return _serialize(result) if result else None
+
+
+async def remove_step_condition(
+    db: AsyncIOMotorDatabase,
+    prechecks_id: str,
+    condition_id: str,
+) -> Optional[dict]:
+    """Remove a specific condition from a step's conditions array."""
+    result = await db[STEP_COLLECTION].find_one_and_update(
+        {"id": prechecks_id},
+        {"$pull": {"process_step_precheck_conditions": {"id": condition_id}}},
+        return_document=True,
+    )
+    return _serialize(result) if result else None
+
+
+async def delete_step_prechecks(
+    db: AsyncIOMotorDatabase,
+    prechecks_id: str,
+) -> bool:
+    """Delete a ProcessStepPrechecks container by ID."""
+    result = await db[STEP_COLLECTION].delete_one({"id": prechecks_id})
+    return result.deleted_count == 1
+
+
+async def delete_step_prechecks_by_step_id(
+    db: AsyncIOMotorDatabase,
+    step_id: str,
+) -> bool:
+    """Delete the step prechecks container that belongs to a step (cascade delete)."""
+    result = await db[STEP_COLLECTION].delete_one({"process_step_id": step_id})
+    return result.deleted_count == 1

services/process_definitions/helpers/process_steps.py

@@ -0,0 +1,220 @@
+"""
+helpers/process_steps_helper.py
+---------------------------------
+MongoDB CRUD helper for ProcessSteps and ProcessStep models.
+Mirrors the pattern established in the devices helper.
+"""
+
+from typing import Optional
+from motor.motor_asyncio import AsyncIOMotorDatabase
+
+from services.process_definitions.models.process_steps import ProcessStepsCreate, ProcessStepsUpdate, ProcessStepUpdate
+
+COLLECTION = "process_steps"
+
+
+def _serialize(doc: dict) -> dict:
+    """Strip MongoDB's internal _id before returning a document."""
+    doc.pop("_id", None)
+    return doc
+
+
+# ---------------------------------------------------------------------------
+# ProcessSteps — top-level container
+# ---------------------------------------------------------------------------
+
+async def get_all(
+    db: AsyncIOMotorDatabase,
+    page: int = 1,
+    page_size: int = 20,
+) -> tuple[list[dict], int]:
+    """Return a paginated list of all ProcessSteps containers and the total count."""
+    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,
+    steps_id: str,
+) -> Optional[dict]:
+    """Fetch a ProcessSteps container by its id."""
+    doc = await db[COLLECTION].find_one({"id": steps_id})
+    return _serialize(doc) if doc else None
+
+
+async def get_by_process_definition_id(
+    db: AsyncIOMotorDatabase,
+    process_definition_id: str,
+) -> Optional[dict]:
+    """Fetch the ProcessSteps container that belongs to a given process_definition."""
+    if not process_definition_id:
+        return None
+    doc = await db[COLLECTION].find_one({"process_definition_id": process_definition_id})
+    return _serialize(doc) if doc else None
+
+
+async def create(
+    db: AsyncIOMotorDatabase,
+    data: ProcessStepsCreate,
+) -> dict:
+    """Insert a new ProcessSteps container and return it."""
+    doc = data.model_dump()
+    await db[COLLECTION].insert_one(doc)
+    return _serialize(doc)
+
+
+async def update(
+    db: AsyncIOMotorDatabase,
+    steps_id: str,
+    data: ProcessStepsUpdate,
+) -> Optional[dict]:
+    """
+    Partially update a ProcessSteps container.
+    Only non-None fields are written.
+    """
+    fields = {k: v for k, v in data.model_dump().items() if v is not None}
+    if not fields:
+        return await get_by_id(db, steps_id)
+    result = await db[COLLECTION].find_one_and_update(
+        {"id": steps_id},
+        {"$set": fields},
+        return_document=True,
+    )
+    return _serialize(result) if result else None
+
+
+async def delete(
+    db: AsyncIOMotorDatabase,
+    steps_id: str,
+) -> bool:
+    """Delete a ProcessSteps container by ID. Returns True if removed."""
+    result = await db[COLLECTION].delete_one({"id": steps_id})
+    return result.deleted_count == 1
+
+
+async def delete_by_process_definition_id(
+    db: AsyncIOMotorDatabase,
+    process_definition_id: str,
+) -> bool:
+    """Delete the ProcessSteps container that belongs to a process_definition."""
+    result = await db[COLLECTION].delete_one({"process_definition_id": process_definition_id})
+    return result.deleted_count == 1
+
+
+# ---------------------------------------------------------------------------
+# Individual ProcessStep — operations on steps[] array inside the container
+# ---------------------------------------------------------------------------
+
+async def get_step_by_id(
+    db: AsyncIOMotorDatabase,
+    steps_id: str,
+    step_id: str,
+) -> Optional[dict]:
+    """Return a single step from within a ProcessSteps container."""
+    doc = await db[COLLECTION].find_one(
+        {"id": steps_id, "steps.id": step_id},
+        {"steps.$": 1},
+    )
+    if not doc or not doc.get("steps"):
+        return None
+    return doc["steps"][0]
+
+
+async def get_steps_by_status(
+    db: AsyncIOMotorDatabase,
+    steps_id: str,
+    status: str,
+) -> list[dict]:
+    """Return all steps within a container that match a given status."""
+    doc = await db[COLLECTION].find_one({"id": steps_id})
+    if not doc:
+        return []
+    return [s for s in doc.get("steps", []) if s.get("status") == status]
+
+
+async def get_steps_by_action_type(
+    db: AsyncIOMotorDatabase,
+    steps_id: str,
+    action_type: str,
+) -> list[dict]:
+    """Return all steps within a container that match a given action_type."""
+    doc = await db[COLLECTION].find_one({"id": steps_id})
+    if not doc:
+        return []
+    return [s for s in doc.get("steps", []) if s.get("action_type") == action_type]
+
+
+async def add_step(
+    db: AsyncIOMotorDatabase,
+    steps_id: str,
+    step: dict,
+) -> Optional[dict]:
+    """Append a new ProcessStep to the steps array of a container."""
+    result = await db[COLLECTION].find_one_and_update(
+        {"id": steps_id},
+        {"$push": {"steps": step}},
+        return_document=True,
+    )
+    return _serialize(result) if result else None
+
+
+async def update_step(
+    db: AsyncIOMotorDatabase,
+    steps_id: str,
+    step_id: str,
+    data: ProcessStepUpdate,
+) -> Optional[dict]:
+    """
+    Update fields of a specific step inside the steps array.
+    Uses the positional $ operator to target the matched element.
+    Only non-None fields are written.
+    """
+    fields = {
+        f"steps.$.{k}": v
+        for k, v in data.model_dump().items()
+        if v is not None
+    }
+    if not fields:
+        return await get_by_id(db, steps_id)
+    result = await db[COLLECTION].find_one_and_update(
+        {"id": steps_id, "steps.id": step_id},
+        {"$set": fields},
+        return_document=True,
+    )
+    return _serialize(result) if result else None
+
+
+async def update_step_status(
+    db: AsyncIOMotorDatabase,
+    steps_id: str,
+    step_id: str,
+    status: str,
+) -> Optional[dict]:
+    """Convenience helper: flip only the status of a single step."""
+    result = await db[COLLECTION].find_one_and_update(
+        {"id": steps_id, "steps.id": step_id},
+        {"$set": {"steps.$.status": status}},
+        return_document=True,
+    )
+    return _serialize(result) if result else None
+
+
+async def remove_step(
+    db: AsyncIOMotorDatabase,
+    steps_id: str,
+    step_id: str,
+) -> Optional[dict]:
+    """Remove a specific step from the steps array. Returns the updated container."""
+    result = await db[COLLECTION].find_one_and_update(
+        {"id": steps_id},
+        {"$pull": {"steps": {"id": step_id}}},
+        return_document=True,
+    )
+    return _serialize(result) if result else None

services/process_definitions/main.py

@@ -0,0 +1,71 @@
+from contextlib import asynccontextmanager
+
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+
+from services.common.logging import configure_service_logging, install_request_logging
+from services.common.tracing import install_route_tracing
+
+from services.common.db import close_db, connect_db
+from services.process_definitions.routers.cpp_cqa_registry import router as cpp_cqa_registry_router
+from services.process_definitions.routers.mbmr_templates import router as mbmr_templates_router
+from services.process_definitions.routers.packing_instructions import router as packing_instructions_router
+from services.process_definitions.routers.process_definition import router as process_definition_router
+from services.process_definitions.routers.process_steps import router as process_steps_router
+from services.process_definitions.routers.process_pre_checks import router as process_definition_prechecks_router
+from services.process_definitions.routers.process_post_checks import router as process_definition_postchecks_router
+from services.process_definitions.routers.process_constraints import router as process_constraints_router
+from services.process_definitions.routers.process_corrections import router as process_corrections_router
+
+
+logger = configure_service_logging("process_definition")
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    await connect_db()
+    yield
+    await close_db()
+
+
+app = FastAPI(
+    title="Process Definition Service",
+    description="Microservice for process definition service.",
+    version="1.0.0",
+    lifespan=lifespan,
+)
+install_request_logging(app, "process_definition")
+install_route_tracing(app, "process_definition")
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=[
+        "http://localhost:5173",
+        "http://127.0.0.1:5173",
+    ],
+    allow_origin_regex=(
+        r"^http://("
+        r"192\.168\.\d+\.\d+|"
+        r"10\.\d+\.\d+\.\d+|"
+        r"172\.(1[6-9]|2\d|3[0-1])\.\d+\.\d+|"
+        r"[A-Za-z0-9.-]+\.local"
+        r"):5173$"
+    ),
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+app.include_router(process_definition_router, prefix="/api/v1/process-definitions", tags=["Process Definitions"])
+app.include_router(cpp_cqa_registry_router, prefix="/api/v1/cpp-cqa-registry", tags=["CPP CQA Registry"])
+app.include_router(mbmr_templates_router, prefix="/api/v1/mbmr-templates", tags=["MBMR Templates"])
+app.include_router(packing_instructions_router, prefix="/api/v1/packing-instructions", tags=["Packing Instructions"])
+app.include_router(process_steps_router, prefix="/api/v1/process-steps", tags=["Process Steps"])
+app.include_router(process_definition_prechecks_router, prefix="/api/v1/process-prechecks", tags=["Process Prechecks"])
+app.include_router(process_definition_postchecks_router, prefix="/api/v1/process-postchecks", tags=["Process Postchecks"])
+app.include_router(process_constraints_router, prefix="/api/v1/process-constraints", tags=["Process Constraints"])
+app.include_router(process_corrections_router, prefix="/api/v1/process-corrections", tags=["Process Corrections"])
+
+
+@app.get("/health", tags=["Health"])
+async def health_check():
+    return {"status": "healthy"}

services/process_definitions/models/__init__.py

@@ -0,0 +1,13 @@
+"""process definition service models package."""
+
+__all__ = [
+    "process_definition",
+    "process_definition_common",
+    "process_constraints",
+    "process_corrections",
+    "process_definition_execution_path",
+    "process_node_catalog",
+    "process_post_checks",
+    "process_pre_checks",
+    "process_steps",
+]