monkeybrain-runtime 1.0.0__py3-none-any.whl

services/facilities/helpers/locations.py

@@ -0,0 +1,231 @@
+"""Helper functions for plant location operations."""
+
+from typing import Optional, List, Tuple
+from datetime import datetime
+from motor.motor_asyncio import AsyncIOMotorDatabase
+from bson import ObjectId
+
+from services.facilities.models.locations import (
+    LocationCreate,
+    LocationUpdate,
+    LocationResponse
+)
+
+COLLECTION = "plant_locations"
+
+
+def _get_location_query(location_id: str) -> dict:
+    """Get query for location lookup supporting both ObjectId and string id."""
+    try:
+        # First try as MongoDB ObjectId
+        return {"_id": ObjectId(location_id)}
+    except Exception:
+        # If ObjectId conversion fails, use string id field
+        return {"id": location_id}
+
+
+def _serialize_location(doc: dict) -> dict:
+    """Serialize location document to response format."""
+    if not doc:
+        return None
+    
+    serialized = doc.copy()
+    mongo_id = str(serialized.pop("_id"))
+    
+    if "id" not in serialized or not serialized["id"]:
+        serialized["id"] = mongo_id
+    
+    if "parent_id" in serialized and serialized["parent_id"]:
+        serialized["parent_id"] = str(serialized["parent_id"])
+    
+    return serialized
+
+
+async def get_location_by_id(
+    db: AsyncIOMotorDatabase,
+    location_id: str
+) -> Optional[dict]:
+    """Get a location by its ID (supports both MongoDB ObjectId and string id)."""
+    try:
+        # First try as MongoDB ObjectId
+        doc = await db[COLLECTION].find_one({"_id": ObjectId(location_id)})
+        if doc:
+            return _serialize_location(doc)
+        
+        # If not found as ObjectId, try as string id field
+        doc = await db[COLLECTION].find_one({"id": location_id})
+        if doc:
+            return _serialize_location(doc)
+        
+        return None
+    except Exception:
+        # If ObjectId conversion fails, try as string id field
+        doc = await db[COLLECTION].find_one({"id": location_id})
+        return _serialize_location(doc)
+
+
+async def get_location_by_location_id(
+    db: AsyncIOMotorDatabase,
+    location_id: str
+) -> Optional[dict]:
+    """Get a location by its location_id."""
+    doc = await db[COLLECTION].find_one({"location_id": location_id})
+    return _serialize_location(doc)
+
+
+async def get_all_locations(
+    db: AsyncIOMotorDatabase,
+    page: int = 1,
+    page_size: int = 20,
+    location_type: Optional[str] = None,
+    parent_id: Optional[str] = None,
+    level: Optional[int] = None
+) -> Tuple[List[dict], int]:
+    """Get all locations with filtering and pagination."""
+    query: dict = {}
+    
+    if location_type:
+        query["type"] = location_type
+    if parent_id:
+        query["parent_id"] = ObjectId(parent_id)
+    if level:
+        query["level"] = level
+    
+    total = await db[COLLECTION].count_documents(query)
+    cursor = db[COLLECTION].find(query) \
+        .skip((page - 1) * page_size) \
+        .limit(page_size)
+    
+    return [_serialize_location(doc) async for doc in cursor], total
+
+
+async def create_location(
+    db: AsyncIOMotorDatabase,
+    location_data: LocationCreate
+) -> dict:
+    """Create a new location."""
+    # Convert to dict and add timestamps
+    doc = location_data.model_dump()
+    doc["created_at"] = datetime.utcnow()
+    doc["updated_at"] = datetime.utcnow()
+    
+    # Convert parent_id to ObjectId if it exists
+    if doc.get("parent_id"):
+        doc["parent_id"] = ObjectId(doc["parent_id"])
+    
+    result = await db[COLLECTION].insert_one(doc)
+    created = await db[COLLECTION].find_one({"_id": result.inserted_id})
+    
+    return _serialize_location(created)
+
+
+async def update_location(
+    db: AsyncIOMotorDatabase,
+    location_id: str,
+    update_data: LocationUpdate
+) -> Optional[dict]:
+    """Update a location."""
+    update_dict = update_data.model_dump(exclude_unset=True)
+    if update_dict:
+        update_dict["updated_at"] = datetime.utcnow()
+        
+        query = _get_location_query(location_id)
+        result = await db[COLLECTION].update_one(
+            query,
+            {"$set": update_dict}
+        )
+        
+        if result.modified_count > 0:
+            updated = await db[COLLECTION].find_one(query)
+            return _serialize_location(updated)
+    
+    return None
+
+
+async def delete_location(
+    db: AsyncIOMotorDatabase,
+    location_id: str
+) -> bool:
+    """Delete a location."""
+    query = _get_location_query(location_id)
+    result = await db[COLLECTION].delete_one(query)
+    return result.deleted_count > 0
+
+
+async def get_location_hierarchy(
+    db: AsyncIOMotorDatabase,
+    location_id: str
+) -> List[dict]:
+    """Get the complete hierarchy for a location."""
+    hierarchy = []
+    current_id = location_id
+    
+    while current_id:
+        location = await get_location_by_id(db, current_id)
+        if not location:
+            break
+        
+        hierarchy.append(location)
+        current_id = location.get("parent_id")
+    
+    # Reverse to get from plant down to the specific location
+    return hierarchy[::-1]
+
+
+async def get_children(
+    db: AsyncIOMotorDatabase,
+    parent_id: str
+) -> List[dict]:
+    """Get child locations of a parent."""
+    try:
+        # Try as MongoDB ObjectId first
+        cursor = db[COLLECTION].find({"parent_id": ObjectId(parent_id)})
+    except Exception:
+        # If ObjectId conversion fails, use string parent_id
+        cursor = db[COLLECTION].find({"parent_id": parent_id})
+    return [_serialize_location(doc) async for doc in cursor]
+
+
+async def get_location_with_children(
+    db: AsyncIOMotorDatabase,
+    location_id: str
+) -> Optional[dict]:
+    """Get a location with its children."""
+    location = await get_location_by_id(db, location_id)
+    if not location:
+        return None
+    
+    children = await get_children(db, location_id)
+    
+    return {
+        "location": location,
+        "children": children,
+        "children_count": len(children)
+    }
+
+
+async def search_locations(
+    db: AsyncIOMotorDatabase,
+    search_term: str,
+    limit: int = 10
+) -> List[dict]:
+    """Search locations by name or location_id."""
+    query = {
+        "$or": [
+            {"name": {"$regex": search_term, "$options": "i"}},
+            {"location_id": {"$regex": search_term, "$options": "i"}},
+            {"path": {"$regex": search_term, "$options": "i"}}
+        ]
+    }
+    
+    cursor = db[COLLECTION].find(query).limit(limit)
+    return [_serialize_location(doc) async for doc in cursor]
+
+
+async def get_locations_by_type(
+    db: AsyncIOMotorDatabase,
+    location_type: str
+) -> List[dict]:
+    """Get all locations of a specific type."""
+    cursor = db[COLLECTION].find({"type": location_type})
+    return [_serialize_location(doc) async for doc in cursor]

services/facilities/helpers/plants.py

@@ -0,0 +1,59 @@
+from typing import Optional
+from motor.motor_asyncio import AsyncIOMotorDatabase
+from services.facilities.models.industrialPlant import IndustrialPlantCreate, IndustrialPlantUpdate
+
+COLLECTION = "industrial_plants"
+
+def _serialize(doc: dict) -> dict:
+    doc.pop("_id", None)
+    return doc
+
+async def get_all(
+    db: AsyncIOMotorDatabase,
+    page: int = 1,
+    page_size: int = 20,
+    status: Optional[str] = None,
+    plant_type: Optional[str] = None,
+    country: Optional[str] = None,
+    timezone: Optional[str] = None,
+    manager: Optional[str] = None,
+) -> tuple[list[dict], int]:
+    query: dict = {}
+    if status:
+        query["status"] = status
+    if plant_type:
+        query["type"] = plant_type
+    if country:
+        query["country"] = country
+    if timezone:
+        query["timezone"] = timezone
+    if manager:
+        query["manager"] = manager
+
+    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, plant_id: str) -> Optional[dict]:
+    doc = await db[COLLECTION].find_one({"id": plant_id})
+    return _serialize(doc) if doc else None
+
+async def create(db: AsyncIOMotorDatabase, data: IndustrialPlantCreate) -> dict:
+    doc = data.model_dump()
+    await db[COLLECTION].insert_one(doc)
+    return _serialize(doc)
+
+async def update(
+    db: AsyncIOMotorDatabase, plant_id: str, data: IndustrialPlantUpdate
+) -> Optional[dict]:
+    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, plant_id)
+    result = await db[COLLECTION].find_one_and_update(
+        {"id": plant_id}, {"$set": fields}, return_document=True
+    )
+    return _serialize(result) if result else None
+
+async def delete(db: AsyncIOMotorDatabase, plant_id: str) -> bool:
+    result = await db[COLLECTION].delete_one({"id": plant_id})
+    return result.deleted_count == 1

services/facilities/helpers/stages.py

@@ -0,0 +1,110 @@
+import re
+from datetime import date, datetime
+from typing import Optional
+from fastapi import HTTPException
+from motor.motor_asyncio import AsyncIOMotorDatabase
+from services.facilities.models.stages import IndustrialStageCreate, IndustrialStageUpdate
+from bson.errors import InvalidDocument
+
+COLLECTION = "industrial_stages"
+
+def _serialize(doc: dict) -> dict:
+    doc = dict(doc)
+    doc.pop("_id", None)
+    if "last_pm" in doc and hasattr(doc["last_pm"], "date"):
+        doc["last_pm"] = doc["last_pm"].date()
+    return doc
+
+
+def _prepare(doc: dict) -> dict:
+    return {
+        k: datetime.combine(v, datetime.min.time()) if isinstance(v, date) and not isinstance(v, datetime) else v
+        for k, v in doc.items()
+    }
+
+
+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, stage_id: str) -> Optional[dict]:
+    doc = await db[COLLECTION].find_one({"id": stage_id})
+    return _serialize(doc) if doc else None
+
+
+async def get_by_line(db: AsyncIOMotorDatabase, line_id: str) -> list[dict]:
+    line_ids = {line_id}
+    line = await db["industrial_lines"].find_one(
+        {
+            "$or": [
+                {"id": line_id},
+                {"name": {"$regex": f"^{re.escape(line_id)}$", "$options": "i"}},
+            ]
+        },
+        {"id": 1, "name": 1},
+    )
+    if line:
+        if line.get("id"):
+            line_ids.add(str(line["id"]))
+        if line.get("name"):
+            line_ids.add(str(line["name"]))
+    cursor = db[COLLECTION].find({"line_id": {"$in": list(line_ids)}})
+    return [_serialize(d) async for d in cursor]
+
+
+async def get_by_plant(db: AsyncIOMotorDatabase, plant_id: str) -> list[dict]:
+    plant_ids = {plant_id}
+    plant = await db["industrial_plants"].find_one(
+        {
+            "$or": [
+                {"id": plant_id},
+                {"name": {"$regex": f"^{re.escape(plant_id)}$", "$options": "i"}},
+            ]
+        },
+        {"id": 1, "name": 1},
+    )
+    if plant:
+        if plant.get("id"):
+            plant_ids.add(str(plant["id"]))
+        if plant.get("name"):
+            plant_ids.add(str(plant["name"]))
+    cursor = db[COLLECTION].find({"plant_id": {"$in": list(plant_ids)}})
+    return [_serialize(d) async for d in cursor]
+
+
+async def get_by_circuit(db: AsyncIOMotorDatabase, circuit_id: str) -> list[dict]:
+    cursor = db[COLLECTION].find({"circuit_id": circuit_id})
+    return [_serialize(d) async for d in cursor]
+
+async def create(db: AsyncIOMotorDatabase, data: IndustrialStageCreate) -> dict:
+    doc = _prepare(data.model_dump())
+    try:
+        await db[COLLECTION].insert_one(doc)
+    except InvalidDocument as e:
+        raise HTTPException(status_code=422, detail=f"Unprocessable document: {e}")
+    return _serialize(doc)
+
+async def update(
+    db: AsyncIOMotorDatabase, stage_id: str, data: IndustrialStageUpdate
+) -> Optional[dict]:
+    fields = _prepare(data.model_dump(exclude_unset=True))
+    if not fields:
+        return await get_by_id(db, stage_id)
+    result = await db[COLLECTION].find_one_and_update(
+        {"id": stage_id},
+        {"$set": fields},
+        return_document=True,
+    )
+    return _serialize(result) if result else None
+
+
+async def delete(db: AsyncIOMotorDatabase, stage_id: str) -> bool:
+    result = await db[COLLECTION].delete_one({"id": stage_id})
+    return result.deleted_count == 1

services/facilities/helpers/workstation.py

@@ -0,0 +1,213 @@
+import re
+from typing import Optional
+from motor.motor_asyncio import AsyncIOMotorDatabase
+from services.facilities.models.workstation import WorkstationCreate, WorkstationResponse, WorkstationUpdate
+
+COLLECTION = "workstations"
+
+def _serialize(doc: dict) -> dict:
+    doc = dict(doc)
+    doc.pop("_id", None)
+    return doc
+
+
+def _normalize_mode(value: object, operator: object = None) -> str:
+    if isinstance(value, str):
+        normalized = value.strip().lower()
+        aliases = {
+            "robotic": "Robotic",
+            "automated": "Robotic",
+            "auto": "Robotic",
+            "manual": "Manual",
+            "hybrid": "Hybrid",
+            "semi-automated": "Hybrid",
+            "semi automated": "Hybrid",
+        }
+        if normalized in aliases:
+            return aliases[normalized]
+    return "Manual" if operator else "Robotic"
+
+
+def _normalize_status(value: object) -> str:
+    if isinstance(value, str):
+        normalized = value.strip().lower()
+        aliases = {
+            "active": "Active",
+            "running": "Active",
+            "online": "Active",
+            "alert": "Alert",
+            "warning": "Alert",
+            "idle": "Idle",
+            "offline": "Offline",
+            "down": "Offline",
+            "inactive": "Offline",
+        }
+        if normalized in aliases:
+            return aliases[normalized]
+    return "Active"
+
+
+def _coerce_float(value: object, fallback: float) -> float:
+    if isinstance(value, (int, float)):
+        return float(value)
+    if isinstance(value, str):
+        try:
+            return float(value)
+        except ValueError:
+            return fallback
+    return fallback
+
+
+def _normalize_workstation_record(doc: Optional[dict]) -> Optional[dict]:
+    if not doc:
+        return None
+
+    record = _serialize(doc)
+    workstation_id = str(record.get("id") or record.get("workstation_id") or record.get("name") or "WORKSTATION")
+    record["id"] = workstation_id
+    record.setdefault("name", workstation_id)
+
+    operator = record.get("operator") or record.get("operator_id") or record.get("worker_id")
+    mode = _normalize_mode(record.get("mode"), operator)
+    if mode == "Robotic":
+        operator = None
+    record["mode"] = mode
+    record["operator"] = operator
+    record["status"] = _normalize_status(record.get("status"))
+
+    target = _coerce_float(
+        record.get("cycle_time_target") or record.get("target_cycle_time") or record.get("takt_time_seconds"),
+        1.0,
+    )
+    if target <= 0:
+        target = 1.0
+    actual = _coerce_float(
+        record.get("cycle_time_actual") or record.get("actual_cycle_time") or record.get("cycle_time_seconds"),
+        0.0 if record["status"] == "Idle" else target,
+    )
+    if record["status"] == "Idle":
+        actual = 0.0
+
+    record["cycle_time_actual"] = max(actual, 0.0)
+    record["cycle_time_target"] = target
+    record["is_bottleneck"] = record["cycle_time_actual"] > record["cycle_time_target"]
+
+    return WorkstationResponse(**record).model_dump()
+
+
+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 [_normalize_workstation_record(d) async for d in cursor], total
+
+async def get_by_id(db: AsyncIOMotorDatabase, workstation_id: str) -> Optional[dict]:
+    doc = await db[COLLECTION].find_one({"id": workstation_id})
+    return _normalize_workstation_record(doc) if doc else None
+
+async def get_by_line(db: AsyncIOMotorDatabase, line_id: str) -> list[dict]:
+    line_ids = {line_id}
+    line = await db["industrial_lines"].find_one(
+        {
+            "$or": [
+                {"id": line_id},
+                {"name": {"$regex": f"^{re.escape(line_id)}$", "$options": "i"}},
+            ]
+        },
+        {"id": 1, "name": 1},
+    )
+    if line:
+        if line.get("id"):
+            line_ids.add(str(line["id"]))
+        if line.get("name"):
+            line_ids.add(str(line["name"]))
+    stages = await db["industrial_stages"].find(
+        {"line_id": {"$in": list(line_ids)}},
+        {"id": 1, "name": 1},
+    ).to_list(length=200)
+    stage_ids = {
+        str(value)
+        for stage in stages
+        for value in (stage.get("id"), stage.get("name"))
+        if value
+    }
+    query: dict = {"line_id": {"$in": list(line_ids)}}
+    if stage_ids:
+        query = {
+            "$or": [
+                {"line_id": {"$in": list(line_ids)}},
+                {"stage_id": {"$in": list(stage_ids)}},
+            ]
+        }
+    cursor = db[COLLECTION].find(query)
+    return [_normalize_workstation_record(d) async for d in cursor]
+
+async def get_by_stage_id(db: AsyncIOMotorDatabase, stage_id: str) -> list[dict]:
+    stage_ids = {stage_id}
+    stage = await db["industrial_stages"].find_one(
+        {
+            "$or": [
+                {"id": stage_id},
+                {"name": {"$regex": f"^{re.escape(stage_id)}$", "$options": "i"}},
+            ]
+        },
+        {"id": 1, "name": 1},
+    )
+    if stage:
+        if stage.get("id"):
+            stage_ids.add(str(stage["id"]))
+        if stage.get("name"):
+            stage_ids.add(str(stage["name"]))
+    cursor = db[COLLECTION].find({"stage_id": {"$in": list(stage_ids)}})
+    return [_normalize_workstation_record(d) async for d in cursor]
+
+async def get_bottlenecks(db: AsyncIOMotorDatabase, line_id: Optional[str] = None) -> list[dict]:
+    query: dict = {"is_bottleneck": True}
+    if line_id:
+        line_ids = {line_id}
+        line = await db["industrial_lines"].find_one(
+            {
+                "$or": [
+                    {"id": line_id},
+                    {"name": {"$regex": f"^{re.escape(line_id)}$", "$options": "i"}},
+                ]
+            },
+            {"id": 1, "name": 1},
+        )
+        if line:
+            if line.get("id"):
+                line_ids.add(str(line["id"]))
+            if line.get("name"):
+                line_ids.add(str(line["name"]))
+        query["line_id"] = {"$in": list(line_ids)}
+    cursor = db[COLLECTION].find(query)
+    return [_normalize_workstation_record(d) async for d in cursor]
+
+
+async def create(db: AsyncIOMotorDatabase, data: WorkstationCreate) -> dict:
+    doc = data.model_dump()
+    await db[COLLECTION].insert_one(doc)
+    return _normalize_workstation_record(doc)
+
+
+async def update(
+    db: AsyncIOMotorDatabase, workstation_id: str, data: WorkstationUpdate
+) -> Optional[dict]:
+    fields = data.model_dump(exclude_unset=True)
+    if not fields:
+        return await get_by_id(db, workstation_id)
+    result = await db[COLLECTION].find_one_and_update(
+        {"id": workstation_id},
+        {"$set": fields},
+        return_document=True,
+    )
+    return _normalize_workstation_record(result) if result else None
+
+
+async def delete(db: AsyncIOMotorDatabase, workstation_id: str) -> bool:
+    result = await db[COLLECTION].delete_one({"id": workstation_id})
+    return result.deleted_count == 1

services/facilities/main.py

@@ -0,0 +1,60 @@
+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.facilities.routers.plant import router as plants_router
+from services.facilities.routers.lines import router as lines_router
+from services.facilities.routers.stages import router as stages_router
+from services.facilities.routers.workstation import router as workstations_router
+from services.facilities.routers.locations import router as locations_router
+from services.facilities.routers.buildings import router as buildings_router
+from services.facilities.routers.floors import router as floors_router
+from services.facilities.routers.rooms import router as rooms_router
+from services.facilities.routers.bays import router as bays_router
+
+
+logger = configure_service_logging("facilities")
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    await connect_db()
+    yield
+    await close_db()
+
+
+app = FastAPI(
+    title="Facilities Service",
+    description="Microservice for facilities service.",
+    version="1.0.0",
+    lifespan=lifespan,
+)
+install_request_logging(app, "facilities")
+install_route_tracing(app, "facilities")
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+app.include_router(plants_router, prefix="/api/v1/plants", tags=["Plants"])
+app.include_router(lines_router, prefix="/api/v1/lines", tags=["Lines"])
+app.include_router(stages_router, prefix="/api/v1/stages", tags=["Stages"])
+app.include_router(workstations_router, prefix="/api/v1/workstations", tags=["Workstations"])
+app.include_router(locations_router, prefix="/api/v1/locations", tags=["Locations"])
+app.include_router(buildings_router, prefix="/api/v1/buildings", tags=["Buildings"])
+app.include_router(floors_router, prefix="/api/v1/floors", tags=["Floors"])
+app.include_router(rooms_router, prefix="/api/v1/rooms", tags=["Rooms"])
+app.include_router(bays_router, prefix="/api/v1/bays", tags=["Bays"])
+
+
+@app.get("/health", tags=["Health"])
+async def health_check():
+    return {"status": "healthy"}

services/facilities/models/__init__.py

@@ -0,0 +1,10 @@
+"""facilities service models package."""
+
+__all__ = [
+    "industrialLine",
+    "industrialPlant",
+    "stages",
+    "workstation",
+    "workstation_live_state",
+    "worker",
+]