monkeybrain-runtime 1.0.0__py3-none-any.whl

services/facilities/routers/bays.py

@@ -0,0 +1,81 @@
+"""Router for bays — queries plant_locations where type=bay."""
+
+from fastapi import APIRouter, Depends, Query, status, HTTPException
+from motor.motor_asyncio import AsyncIOMotorDatabase
+
+from services.common.db import get_database
+from services.common.auth import require_permission
+from services.facilities.helpers.locations import get_all_locations, update_location, delete_location, get_location_by_id
+from services.facilities.models.locations import LocationCreate, LocationUpdate
+
+router = APIRouter()
+
+
+def _to_bay(doc: dict, parent_loc_id_map: dict[str, str] | None = None) -> dict:
+    parent_id = doc.get("parent_id")
+    room_id = parent_loc_id_map.get(parent_id, parent_id) if parent_loc_id_map else parent_id
+    return {
+        "bay_id": doc.get("location_id") or doc.get("id"),
+        "room_id": room_id,
+        "name": doc.get("name", ""),
+    }
+
+
+@router.get("/")
+async def list_bays(
+    page: int = Query(1, ge=1),
+    page_size: int = Query(100, ge=1),
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-view-bays")),
+):
+    locs, _ = await get_all_locations(db, page=page, page_size=page_size, location_type="bay")
+
+    parent_ids = {loc.get("parent_id") for loc in locs if loc.get("parent_id")}
+    parent_loc_id_map: dict[str, str] = {}
+    for pid in parent_ids:
+        parent_loc = await get_location_by_id(db, pid)
+        if parent_loc:
+            parent_loc_id_map[pid] = parent_loc.get("location_id", pid)
+
+    return [_to_bay(loc, parent_loc_id_map) for loc in locs]
+
+
+@router.post("/", status_code=status.HTTP_201_CREATED)
+async def create_bay(
+    data: dict,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-create-bays")),
+):
+    from services.facilities.helpers.locations import create_location
+    loc_data = LocationCreate(
+        name=data["name"],
+        location_id=data.get("bay_id") or data.get("name", "").upper().replace(" ", "-"),
+        type="bay",
+        level=5,
+        path=data.get("path", data["name"]),
+        parent_id=data.get("room_id"),
+    )
+    created = await create_location(db, loc_data)
+    return _to_bay(created)
+
+
+@router.patch("/{bay_id}")
+async def update_bay(
+    bay_id: str,
+    data: dict,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-update-bays")),
+):
+    updated = await update_location(db, bay_id, LocationUpdate(name=data.get("name")))
+    if not updated:
+        raise HTTPException(status_code=404, detail="Bay not found")
+    return _to_bay(updated)
+
+
+@router.delete("/{bay_id}", status_code=status.HTTP_204_NO_CONTENT)
+async def delete_bay(
+    bay_id: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-delete-bays")),
+):
+    await delete_location(db, bay_id)

services/facilities/routers/buildings.py

@@ -0,0 +1,92 @@
+"""Router for buildings — queries plant_locations where type=building."""
+
+from typing import Optional
+from fastapi import APIRouter, 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.facilities.helpers.locations import get_all_locations, get_location_by_id, create_location, update_location, delete_location
+from services.facilities.models.locations import LocationCreate, LocationUpdate, LocationResponse
+
+router = APIRouter()
+
+_plant_loc_to_id_cache: dict[str, str] = {}
+
+
+def _to_building(doc: dict, plant_loc_to_id: dict[str, str] | None = None) -> dict:
+    parent_id = doc.get("parent_id")
+    plant_id = plant_loc_to_id.get(parent_id, parent_id) if plant_loc_to_id else parent_id
+    return {
+        "building_id": doc.get("location_id") or doc.get("id"),
+        "plant_id": plant_id,
+        "name": doc.get("name", ""),
+    }
+
+
+@router.get("/")
+async def list_buildings(
+    page: int = Query(1, ge=1),
+    page_size: int = Query(100, ge=1),
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-view-buildings")),
+):
+    locs, total = await get_all_locations(db, page=page, page_size=page_size, location_type="building")
+
+    plant_loc_ids = {loc.get("parent_id") for loc in locs if loc.get("parent_id")}
+    plant_loc_to_id: dict[str, str] = {}
+    for loc_id in plant_loc_ids:
+        plant_doc = await db["industrial_plants"].find_one(
+            {"$or": [{"id": loc_id}, {"_id": loc_id}]}, {"id": 1}
+        )
+        if plant_doc:
+            plant_loc_to_id[loc_id] = plant_doc.get("id", loc_id)
+        else:
+            plant_loc = await get_location_by_id(db, loc_id)
+            if plant_loc:
+                plant_loc_to_id[loc_id] = plant_loc.get("location_id", loc_id)
+
+    return [_to_building(loc, plant_loc_to_id) for loc in locs]
+
+
+@router.post("/", status_code=status.HTTP_201_CREATED)
+async def create_building(
+    data: dict,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-create-buildings")),
+):
+    loc_data = LocationCreate(
+        name=data["name"],
+        location_id=data.get("building_id") or data.get("name", "").upper().replace(" ", "-"),
+        type="building",
+        level=2,
+        path=data.get("path", data["name"]),
+        description=data.get("description", ""),
+        parent_id=data.get("plant_id"),
+    )
+    created = await create_location(db, loc_data)
+    return _to_building(created)
+
+
+@router.patch("/{building_id}")
+async def update_building(
+    building_id: str,
+    data: dict,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-update-buildings")),
+):
+    update = LocationUpdate(name=data.get("name"))
+    updated = await update_location(db, building_id, update)
+    if not updated:
+        from fastapi import HTTPException
+        raise HTTPException(status_code=404, detail="Building not found")
+    return _to_building(updated)
+
+
+@router.delete("/{building_id}", status_code=status.HTTP_204_NO_CONTENT)
+async def delete_building(
+    building_id: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-delete-buildings")),
+):
+    await delete_location(db, building_id)

services/facilities/routers/floors.py

@@ -0,0 +1,81 @@
+"""Router for floors — queries plant_locations where type=floor."""
+
+from fastapi import APIRouter, Depends, Query, status, HTTPException
+from motor.motor_asyncio import AsyncIOMotorDatabase
+
+from services.common.db import get_database
+from services.common.auth import require_permission
+from services.facilities.helpers.locations import get_all_locations, update_location, delete_location, get_location_by_id
+from services.facilities.models.locations import LocationCreate, LocationUpdate
+
+router = APIRouter()
+
+
+def _to_floor(doc: dict, parent_loc_id_map: dict[str, str] | None = None) -> dict:
+    parent_id = doc.get("parent_id")
+    building_id = parent_loc_id_map.get(parent_id, parent_id) if parent_loc_id_map else parent_id
+    return {
+        "floor_id": doc.get("location_id") or doc.get("id"),
+        "building_id": building_id,
+        "name": doc.get("name", ""),
+    }
+
+
+@router.get("/")
+async def list_floors(
+    page: int = Query(1, ge=1),
+    page_size: int = Query(100, ge=1),
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-view-floors")),
+):
+    locs, _ = await get_all_locations(db, page=page, page_size=page_size, location_type="floor")
+
+    parent_ids = {loc.get("parent_id") for loc in locs if loc.get("parent_id")}
+    parent_loc_id_map: dict[str, str] = {}
+    for pid in parent_ids:
+        parent_loc = await get_location_by_id(db, pid)
+        if parent_loc:
+            parent_loc_id_map[pid] = parent_loc.get("location_id", pid)
+
+    return [_to_floor(loc, parent_loc_id_map) for loc in locs]
+
+
+@router.post("/", status_code=status.HTTP_201_CREATED)
+async def create_floor(
+    data: dict,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-create-floors")),
+):
+    from services.facilities.helpers.locations import create_location
+    loc_data = LocationCreate(
+        name=data["name"],
+        location_id=data.get("floor_id") or data.get("name", "").upper().replace(" ", "-"),
+        type="floor",
+        level=3,
+        path=data.get("path", data["name"]),
+        parent_id=data.get("building_id"),
+    )
+    created = await create_location(db, loc_data)
+    return _to_floor(created)
+
+
+@router.patch("/{floor_id}")
+async def update_floor(
+    floor_id: str,
+    data: dict,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-update-floors")),
+):
+    updated = await update_location(db, floor_id, LocationUpdate(name=data.get("name")))
+    if not updated:
+        raise HTTPException(status_code=404, detail="Floor not found")
+    return _to_floor(updated)
+
+
+@router.delete("/{floor_id}", status_code=status.HTTP_204_NO_CONTENT)
+async def delete_floor(
+    floor_id: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-delete-floors")),
+):
+    await delete_location(db, floor_id)

services/facilities/routers/lines.py

@@ -0,0 +1,154 @@
+import re
+from typing import Optional
+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 get_current_user, require_permission
+from services.facilities.helpers import lines as crud
+from services.facilities.helpers import stages as stage_crud
+from services.facilities.helpers import workstation as workstation_crud
+
+from services.facilities.models.industrialLine import (
+    IndustrialLineCreate,
+    IndustrialLineUpdate,
+    IndustrialLineResponse,
+    PaginatedLineResponse,
+)
+from services.facilities.models.stages import IndustrialStageResponse
+from services.facilities.models.workstation import WorkstationResponse
+
+router = APIRouter()
+
+
+# ── List ──────────────────────────────────────────────────────────────────────
+
+@router.get("/", response_model=PaginatedLineResponse)
+async def list_lines(
+    page: int = Query(1, ge=1),
+    page_size: int = Query(20, ge=1),
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-view-lines")),
+):
+    lines, total = await crud.get_all(
+        db,
+        page=page,
+        page_size=page_size,
+    )
+    return PaginatedLineResponse(
+        total=total,
+        page=page,
+        page_size=page_size,
+        results=lines,
+    )
+
+
+# ── Get by plant ──────────────────────────────────────────────────────────────
+
+@router.get("/by-plant/{plant_id}", response_model=list[IndustrialLineResponse])
+async def list_lines_by_plant(
+    plant_id: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-view-lines")),
+):
+    return await crud.get_by_plant(db, plant_id)
+
+
+@router.get("/{line_id}/stages", response_model=list[IndustrialStageResponse])
+async def list_line_stages(
+    line_id: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-view-stages")),
+):
+    record = await crud.get_by_id(db, line_id)
+    if not record:
+        record = await db["industrial_lines"].find_one({"name": {"$regex": f"^{re.escape(line_id)}$", "$options": "i"}})
+    if not record:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"Line '{line_id}' not found",
+        )
+    return await stage_crud.get_by_line(db, str(record.get("id") or line_id))
+
+
+@router.get("/{line_id}/workstations", response_model=list[WorkstationResponse])
+async def list_line_workstations(
+    line_id: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(get_current_user),
+):
+    record = await crud.get_by_id(db, line_id)
+    if not record:
+        record = await db["industrial_lines"].find_one({"name": {"$regex": f"^{re.escape(line_id)}$", "$options": "i"}})
+    if not record:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"Line '{line_id}' not found",
+        )
+    return await workstation_crud.get_by_line(db, str(record.get("id") or line_id))
+
+
+# ── Get one ───────────────────────────────────────────────────────────────────
+
+@router.get("/{line_id}", response_model=IndustrialLineResponse)
+async def get_line(
+    line_id: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-view-lines")),
+):
+    record = await crud.get_by_id(db, line_id)
+    if not record:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"Line '{line_id}' not found",
+        )
+    return record
+
+
+# ── Create ────────────────────────────────────────────────────────────────────
+
+@router.post("/", response_model=IndustrialLineResponse, status_code=status.HTTP_201_CREATED)
+async def create_line(
+    data: IndustrialLineCreate,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-create-lines")),
+):
+    if await crud.get_by_id(db, data.id):
+        raise HTTPException(
+            status_code=status.HTTP_409_CONFLICT,
+            detail=f"Line '{data.id}' already exists",
+        )
+    return await crud.create(db, data)
+
+
+# ── Update ────────────────────────────────────────────────────────────────────
+
+@router.patch("/{line_id}", response_model=IndustrialLineResponse)
+async def update_line(
+    line_id: str,
+    data: IndustrialLineUpdate,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-update-lines")),
+):
+    updated = await crud.update(db, line_id, data)
+    if not updated:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"Line '{line_id}' not found",
+        )
+    return updated
+
+
+# ── Delete ────────────────────────────────────────────────────────────────────
+
+@router.delete("/{line_id}", status_code=status.HTTP_204_NO_CONTENT)
+async def delete_line(
+    line_id: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-delete-lines")),
+):
+    if not await crud.delete(db, line_id):
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"Line '{line_id}' not found",
+        )

services/facilities/routers/locations.py

@@ -0,0 +1,208 @@
+"""API routers for plant location management."""
+
+from typing import Optional, List
+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.facilities.models.locations import (
+    LocationCreate,
+    LocationUpdate,
+    LocationResponse,
+    PaginatedLocationResponse,
+    LocationHierarchyResponse,
+    LocationWithChildrenResponse
+)
+from services.facilities.helpers import locations as crud
+
+router = APIRouter()
+
+
+def get_db() -> AsyncIOMotorDatabase:
+    """Get database dependency."""
+    return get_database()
+
+
+@router.get("/", response_model=PaginatedLocationResponse)
+async def list_locations(
+    page: int = Query(1, ge=1, description="Page number"),
+    page_size: int = Query(20, ge=1, le=100, description="Items per page"),
+    location_type: Optional[str] = Query(None, description="Filter by location type"),
+    parent_id: Optional[str] = Query(None, description="Filter by parent ID"),
+    level: Optional[int] = Query(None, description="Filter by hierarchy level"),
+    db: AsyncIOMotorDatabase = Depends(get_db),
+    _: dict = Depends(require_permission("perm-view-locations"))
+) -> PaginatedLocationResponse:
+    """List all locations with filtering and pagination."""
+    locations, total = await crud.get_all_locations(
+        db, page, page_size, location_type, parent_id, level
+    )
+    return PaginatedLocationResponse(
+        total=total,
+        page=page,
+        page_size=page_size,
+        results=locations
+    )
+
+
+@router.post("/", response_model=LocationResponse, status_code=status.HTTP_201_CREATED)
+async def create_location(
+    location_data: LocationCreate,
+    db: AsyncIOMotorDatabase = Depends(get_db),
+    _: dict = Depends(require_permission("perm-create-locations"))
+) -> LocationResponse:
+    """Create a new location."""
+    try:
+        return await crud.create_location(db, location_data)
+    except Exception as e:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail=f"Failed to create location: {str(e)}"
+        )
+
+
+@router.get("/{location_id}", response_model=LocationResponse)
+async def get_location(
+    location_id: str,
+    db: AsyncIOMotorDatabase = Depends(get_db),
+    _: dict = Depends(require_permission("perm-view-locations"))
+) -> LocationResponse:
+    """Get a specific location by ID."""
+    location = await crud.get_location_by_id(db, location_id)
+    if not location:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail="Location not found"
+        )
+    return location
+
+
+@router.put("/{location_id}", response_model=LocationResponse)
+async def update_location(
+    location_id: str,
+    update_data: LocationUpdate,
+    db: AsyncIOMotorDatabase = Depends(get_db),
+    _: dict = Depends(require_permission("perm-update-locations"))
+) -> LocationResponse:
+    """Update a location."""
+    location = await crud.update_location(db, location_id, update_data)
+    if not location:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail="Location not found or no changes made"
+        )
+    return location
+
+
+@router.delete("/{location_id}", status_code=status.HTTP_204_NO_CONTENT)
+async def delete_location(
+    location_id: str,
+    db: AsyncIOMotorDatabase = Depends(get_db),
+    _: dict = Depends(require_permission("perm-delete-locations"))
+) -> None:
+    """Delete a location."""
+    success = await crud.delete_location(db, location_id)
+    if not success:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail="Location not found"
+        )
+
+
+@router.get("/{location_id}/hierarchy", response_model=LocationHierarchyResponse)
+async def get_location_hierarchy(
+    location_id: str,
+    db: AsyncIOMotorDatabase = Depends(get_db),
+    _: dict = Depends(require_permission("perm-view-locations"))
+) -> LocationHierarchyResponse:
+    """Get the complete hierarchy for a location."""
+    hierarchy = await crud.get_location_hierarchy(db, location_id)
+    if not hierarchy:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail="Location not found"
+        )
+    
+    # Organize hierarchy into response structure
+    response = LocationHierarchyResponse()
+    for location in hierarchy:
+        if location["type"] == "plant":
+            response.plant = location
+        elif location["type"] == "building":
+            response.building = location
+        elif location["type"] == "floor":
+            response.floor = location
+        elif location["type"] == "room":
+            response.room = location
+        elif location["type"] == "bay":
+            response.bay = location
+    
+    return response
+
+
+@router.get("/{location_id}/children", response_model=LocationWithChildrenResponse)
+async def get_location_children(
+    location_id: str,
+    db: AsyncIOMotorDatabase = Depends(get_db),
+    _: dict = Depends(require_permission("perm-view-locations"))
+) -> LocationWithChildrenResponse:
+    """Get a location with its children."""
+    result = await crud.get_location_with_children(db, location_id)
+    if not result:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail="Location not found"
+        )
+    return result
+
+
+@router.get("/by-location-id/{location_id}", response_model=LocationResponse)
+async def get_location_by_location_id(
+    location_id: str,
+    db: AsyncIOMotorDatabase = Depends(get_db),
+    _: dict = Depends(require_permission("perm-view-locations"))
+) -> LocationResponse:
+    """Get a location by its location_id (not MongoDB ID)."""
+    location = await crud.get_location_by_location_id(db, location_id)
+    if not location:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail="Location not found"
+        )
+    return location
+
+
+@router.get("/types/{location_type}", response_model=PaginatedLocationResponse)
+async def get_locations_by_type(
+    location_type: str,
+    page: int = Query(1, ge=1, description="Page number"),
+    page_size: int = Query(20, ge=1, le=100, description="Items per page"),
+    db: AsyncIOMotorDatabase = Depends(get_db),
+    _: dict = Depends(require_permission("perm-view-locations"))
+) -> PaginatedLocationResponse:
+    """Get all locations of a specific type."""
+    locations = await crud.get_locations_by_type(db, location_type)
+    
+    # Apply pagination
+    start = (page - 1) * page_size
+    end = start + page_size
+    paginated_results = locations[start:end]
+    
+    return PaginatedLocationResponse(
+        total=len(locations),
+        page=page,
+        page_size=page_size,
+        results=paginated_results
+    )
+
+
+@router.get("/search/", response_model=list[LocationResponse])
+async def search_locations(
+    search_term: str = Query(..., min_length=1, description="Search term"),
+    limit: int = Query(10, ge=1, le=50, description="Maximum results"),
+    db: AsyncIOMotorDatabase = Depends(get_db),
+    _: dict = Depends(require_permission("perm-view-locations"))
+) -> list[LocationResponse]:
+    """Search locations by name, location_id, or path."""
+    return await crud.search_locations(db, search_term, limit)