monkeybrain-runtime 1.0.0__py3-none-any.whl

services/inventory/helpers/inventory_stage_outputs.py

@@ -0,0 +1,134 @@
+from datetime import datetime, timezone
+from typing import Optional
+from uuid import uuid4
+
+from bson import ObjectId
+from motor.motor_asyncio import AsyncIOMotorDatabase
+from pymongo import ReturnDocument
+
+from services.inventory.models.inventory_stage_outputs import (
+    InventoryStageOutputCreate,
+    InventoryStageOutputResponse,
+    InventoryStageOutputUpdate,
+)
+from services.products.models.product_common import utc_now
+
+COLLECTION = "inventory_stage_outputs"
+
+
+def _serialize(doc: Optional[dict]) -> Optional[dict]:
+    if not doc:
+        return None
+    doc = dict(doc)
+    doc["id"] = str(doc.pop("_id"))
+    return doc
+
+
+def _prepare(value):
+    if isinstance(value, ObjectId):
+        return str(value)
+    if isinstance(value, datetime):
+        if value.tzinfo is None:
+            return value.replace(tzinfo=timezone.utc)
+        return value.astimezone(timezone.utc)
+    if isinstance(value, dict):
+        return {key: _prepare(item) for key, item in value.items()}
+    if isinstance(value, list):
+        return [_prepare(item) for item in value]
+    return value
+
+
+def _as_response_doc(data: dict) -> dict:
+    return _prepare(InventoryStageOutputResponse(**data).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 [_serialize(doc) async for doc in cursor], total
+
+
+async def get_by_stage_output_id(
+    db: AsyncIOMotorDatabase,
+    stage_output_id: str,
+) -> Optional[dict]:
+    return _serialize(await db[COLLECTION].find_one({"stage_output_id": stage_output_id}))
+
+
+async def get_by_product_id(db: AsyncIOMotorDatabase, product_id: str) -> list[dict]:
+    cursor = db[COLLECTION].find({"product_id": product_id})
+    return [_serialize(doc) async for doc in cursor]
+
+
+async def get_by_sku(db: AsyncIOMotorDatabase, sku: str) -> list[dict]:
+    cursor = db[COLLECTION].find({"sku": sku})
+    return [_serialize(doc) async for doc in cursor]
+
+
+async def get_by_stage_id(db: AsyncIOMotorDatabase, stage_id: str) -> list[dict]:
+    cursor = db[COLLECTION].find({"stage_id": stage_id})
+    return [_serialize(doc) async for doc in cursor]
+
+
+async def get_by_workstation_id(
+    db: AsyncIOMotorDatabase,
+    workstation_id: str,
+) -> list[dict]:
+    cursor = db[COLLECTION].find({"workstation_id": workstation_id})
+    return [_serialize(doc) async for doc in cursor]
+
+
+async def get_final_products(db: AsyncIOMotorDatabase) -> list[dict]:
+    cursor = db[COLLECTION].find({"is_final_stage": True})
+    return [_serialize(doc) async for doc in cursor]
+
+
+async def create(db: AsyncIOMotorDatabase, data: InventoryStageOutputCreate) -> dict:
+    now = utc_now()
+    stage_output_id = f"inventory-stage-output-{uuid4().hex[:12]}"
+    doc = _prepare(
+        {
+            **data.model_dump(),
+            "stage_output_id": stage_output_id,
+            "updated_at": now,
+        }
+    )
+    result = await db[COLLECTION].insert_one(doc)
+    doc["_id"] = result.inserted_id
+    return _serialize(doc)
+
+
+async def update(
+    db: AsyncIOMotorDatabase,
+    stage_output_id: str,
+    data: InventoryStageOutputUpdate,
+) -> Optional[dict]:
+    existing = await get_by_stage_output_id(db, stage_output_id)
+    if not existing:
+        return None
+    fields = data.model_dump(exclude_unset=True)
+    if not fields:
+        return existing
+    merged = {
+        **existing,
+        **fields,
+        "stage_output_id": stage_output_id,
+        "updated_at": utc_now(),
+    }
+    doc = _as_response_doc(merged)
+    result = await db[COLLECTION].find_one_and_update(
+        {"stage_output_id": stage_output_id},
+        {"$set": {key: value for key, value in doc.items() if key != "id"}},
+        return_document=ReturnDocument.AFTER,
+    )
+    return _serialize(result)
+
+
+async def delete(db: AsyncIOMotorDatabase, stage_output_id: str) -> bool:
+    result = await db[COLLECTION].delete_one({"stage_output_id": stage_output_id})
+    return result.deleted_count == 1

services/inventory/helpers/inventory_transactions.py

@@ -0,0 +1,112 @@
+from datetime import date, datetime, timezone
+from typing import Optional
+from uuid import uuid4
+
+from motor.motor_asyncio import AsyncIOMotorDatabase
+from pymongo import ReturnDocument
+
+from services.inventory.models.inventory_transactions import (
+    InventoryTransactionCreate,
+    InventoryTransactionRecord,
+    InventoryTransactionUpdate,
+)
+from services.products.models.product_common import utc_now
+
+COLLECTION = "inventory_transactions"
+
+
+def _serialize(doc: Optional[dict]) -> Optional[dict]:
+    if not doc:
+        return None
+    doc = dict(doc)
+    doc.pop("_id", None)
+    return doc
+
+
+def _prepare(value):
+    if isinstance(value, datetime):
+        if value.tzinfo is None:
+            return value.replace(tzinfo=timezone.utc)
+        return value.astimezone(timezone.utc)
+    if isinstance(value, date):
+        return datetime(value.year, value.month, value.day, tzinfo=timezone.utc)
+    if isinstance(value, dict):
+        return {key: _prepare(item) for key, item in value.items()}
+    if isinstance(value, list):
+        return [_prepare(item) for item in value]
+    return value
+
+
+def _as_record_doc(data: dict) -> dict:
+    return _prepare(InventoryTransactionRecord(**data).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 [_serialize(doc) async for doc in cursor], total
+
+
+async def get_by_transaction_id(
+    db: AsyncIOMotorDatabase,
+    transaction_id: str,
+) -> Optional[dict]:
+    return _serialize(await db[COLLECTION].find_one({"transaction_id": transaction_id}))
+
+
+async def get_by_inventory_id(db: AsyncIOMotorDatabase, inventory_id: str) -> list[dict]:
+    cursor = db[COLLECTION].find({"inventory_id": inventory_id})
+    return [_serialize(doc) async for doc in cursor]
+
+
+async def get_by_product_id(db: AsyncIOMotorDatabase, product_id: str) -> list[dict]:
+    cursor = db[COLLECTION].find({"product_id": product_id})
+    return [_serialize(doc) async for doc in cursor]
+
+
+async def create(db: AsyncIOMotorDatabase, data: InventoryTransactionCreate) -> dict:
+    now = utc_now()
+    transaction_id = f"inventory-transaction-{uuid4().hex[:12]}"
+    doc = _as_record_doc(
+        {
+            **data.model_dump(),
+            "transaction_id": transaction_id,
+            "created_at": now,
+            "updated_at": now,
+        }
+    )
+    await db[COLLECTION].insert_one(doc)
+    return _serialize(doc)
+
+
+async def update(
+    db: AsyncIOMotorDatabase,
+    transaction_id: str,
+    data: InventoryTransactionUpdate,
+) -> Optional[dict]:
+    existing = await get_by_transaction_id(db, transaction_id)
+    if not existing:
+        return None
+    merged = {
+        **existing,
+        **data.model_dump(exclude_unset=True),
+        "transaction_id": transaction_id,
+        "updated_at": utc_now(),
+    }
+    doc = _as_record_doc(merged)
+    result = await db[COLLECTION].find_one_and_update(
+        {"transaction_id": transaction_id},
+        {"$set": doc},
+        return_document=ReturnDocument.AFTER,
+    )
+    return _serialize(result)
+
+
+async def delete(db: AsyncIOMotorDatabase, transaction_id: str) -> bool:
+    result = await db[COLLECTION].delete_one({"transaction_id": transaction_id})
+    return result.deleted_count == 1

services/inventory/helpers/stock_adjustment_requests.py

@@ -0,0 +1,101 @@
+from datetime import date, datetime, timezone
+from typing import Optional
+
+from motor.motor_asyncio import AsyncIOMotorDatabase
+from pymongo import ReturnDocument
+
+from services.products.models.product_common import utc_now
+from services.inventory.models.stock_adjustment_requests import (
+    StockAdjustmentRequestCreate,
+    StockAdjustmentRequestUpdate,
+)
+
+COLLECTION = "stock_adjustment_requests"
+
+
+def _serialize(doc: Optional[dict]) -> Optional[dict]:
+    if not doc:
+        return None
+    doc = dict(doc)
+    doc.pop("_id", None)
+    return doc
+
+
+def _prepare(value):
+    if isinstance(value, datetime):
+        if value.tzinfo is None:
+            return value.replace(tzinfo=timezone.utc)
+        return value.astimezone(timezone.utc)
+    if isinstance(value, date):
+        return datetime(value.year, value.month, value.day, tzinfo=timezone.utc)
+    if isinstance(value, dict):
+        return {key: _prepare(item) for key, item in value.items()}
+    if isinstance(value, list):
+        return [_prepare(item) for item in value]
+    return value
+
+
+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(doc) async for doc in cursor], total
+
+
+async def get_by_request_id(
+    db: AsyncIOMotorDatabase,
+    request_id: str,
+) -> Optional[dict]:
+    return _serialize(await db[COLLECTION].find_one({"request_id": request_id}))
+
+
+async def get_by_inventory_id(db: AsyncIOMotorDatabase, inventory_id: str) -> list[dict]:
+    cursor = db[COLLECTION].find({"inventory_id": inventory_id})
+    return [_serialize(doc) async for doc in cursor]
+
+
+async def get_by_product_id(db: AsyncIOMotorDatabase, product_id: str) -> list[dict]:
+    cursor = db[COLLECTION].find({"product_id": product_id})
+    return [_serialize(doc) async for doc in cursor]
+
+
+async def get_by_location_id(db: AsyncIOMotorDatabase, location_id: str) -> list[dict]:
+    cursor = db[COLLECTION].find({"location_id": location_id})
+    return [_serialize(doc) async for doc in cursor]
+
+
+async def get_by_status(db: AsyncIOMotorDatabase, status: str) -> list[dict]:
+    cursor = db[COLLECTION].find({"status": status})
+    return [_serialize(doc) async for doc in cursor]
+
+
+async def create(db: AsyncIOMotorDatabase, data: StockAdjustmentRequestCreate) -> dict:
+    doc = _prepare(data.model_dump())
+    await db[COLLECTION].insert_one(doc)
+    return _serialize(doc)
+
+
+async def update(
+    db: AsyncIOMotorDatabase,
+    request_id: str,
+    data: StockAdjustmentRequestUpdate,
+) -> Optional[dict]:
+    fields = _prepare(data.model_dump(exclude_unset=True))
+    if not fields:
+        return await get_by_request_id(db, request_id)
+    fields["updated_at"] = utc_now()
+    result = await db[COLLECTION].find_one_and_update(
+        {"request_id": request_id},
+        {"$set": fields},
+        return_document=ReturnDocument.AFTER,
+    )
+    return _serialize(result)
+
+
+async def delete(db: AsyncIOMotorDatabase, request_id: str) -> bool:
+    result = await db[COLLECTION].delete_one({"request_id": request_id})
+    return result.deleted_count == 1

services/inventory/helpers/warehouse_cycle_counts.py

@@ -0,0 +1,133 @@
+from datetime import date, datetime, timezone
+from typing import Optional
+from uuid import uuid4
+
+from bson import ObjectId
+from motor.motor_asyncio import AsyncIOMotorDatabase
+from pymongo import ReturnDocument
+
+from services.inventory.models.warehouse_cycle_counts import (
+    WarehouseCycleCountCreate,
+    WarehouseCycleCountResponse,
+    WarehouseCycleCountUpdate,
+)
+from services.products.models.product_common import utc_now
+
+COLLECTION = "warehouse_cycle_counts"
+
+
+def _serialize(doc: Optional[dict]) -> Optional[dict]:
+    if not doc:
+        return None
+    doc = dict(doc)
+    doc["id"] = str(doc.pop("_id"))
+    return doc
+
+
+def _prepare(value):
+    if isinstance(value, ObjectId):
+        return str(value)
+    if isinstance(value, datetime):
+        if value.tzinfo is None:
+            return value.replace(tzinfo=timezone.utc)
+        return value.astimezone(timezone.utc)
+    if isinstance(value, date):
+        return datetime(value.year, value.month, value.day, tzinfo=timezone.utc)
+    if isinstance(value, dict):
+        return {key: _prepare(item) for key, item in value.items()}
+    if isinstance(value, list):
+        return [_prepare(item) for item in value]
+    return value
+
+
+def _as_response_doc(data: dict) -> dict:
+    return _prepare(WarehouseCycleCountResponse(**data).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 [_serialize(doc) async for doc in cursor], total
+
+
+async def get_by_cycle_count_id(
+    db: AsyncIOMotorDatabase,
+    cycle_count_id: str,
+) -> Optional[dict]:
+    return _serialize(await db[COLLECTION].find_one({"cycle_count_id": cycle_count_id}))
+
+
+async def get_by_warehouse_id(db: AsyncIOMotorDatabase, warehouse_id: str) -> list[dict]:
+    cursor = db[COLLECTION].find({"warehouse_id": warehouse_id})
+    return [_serialize(doc) async for doc in cursor]
+
+
+async def get_by_location_id(db: AsyncIOMotorDatabase, location_id: str) -> list[dict]:
+    cursor = db[COLLECTION].find({"location_id": location_id})
+    return [_serialize(doc) async for doc in cursor]
+
+
+async def get_by_sku(db: AsyncIOMotorDatabase, sku: str) -> list[dict]:
+    cursor = db[COLLECTION].find({"sku": sku})
+    return [_serialize(doc) async for doc in cursor]
+
+
+async def get_by_status(db: AsyncIOMotorDatabase, status: str) -> list[dict]:
+    cursor = db[COLLECTION].find({"status": status})
+    return [_serialize(doc) async for doc in cursor]
+
+
+async def create(db: AsyncIOMotorDatabase, data: WarehouseCycleCountCreate) -> dict:
+    now = utc_now()
+    cycle_count_id = f"warehouse-cycle-count-{uuid4().hex[:12]}"
+    base = data.model_dump()
+    if not base.get("cycle_count_number"):
+        base["cycle_count_number"] = f"CC-{uuid4().hex[:8].upper()}"
+    doc = _prepare(
+        {
+            **base,
+            "cycle_count_id": cycle_count_id,
+            "updated_at": now,
+        }
+    )
+    result = await db[COLLECTION].insert_one(
+        {key: value for key, value in doc.items() if key != "id"}
+    )
+    doc["_id"] = result.inserted_id
+    return _serialize(doc)
+
+
+async def update(
+    db: AsyncIOMotorDatabase,
+    cycle_count_id: str,
+    data: WarehouseCycleCountUpdate,
+) -> Optional[dict]:
+    existing = await get_by_cycle_count_id(db, cycle_count_id)
+    if not existing:
+        return None
+    fields = data.model_dump(exclude_unset=True)
+    if not fields:
+        return existing
+    merged = {
+        **existing,
+        **fields,
+        "cycle_count_id": cycle_count_id,
+        "updated_at": utc_now(),
+    }
+    doc = _as_response_doc(merged)
+    result = await db[COLLECTION].find_one_and_update(
+        {"cycle_count_id": cycle_count_id},
+        {"$set": {key: value for key, value in doc.items() if key != "id"}},
+        return_document=ReturnDocument.AFTER,
+    )
+    return _serialize(result)
+
+
+async def delete(db: AsyncIOMotorDatabase, cycle_count_id: str) -> bool:
+    result = await db[COLLECTION].delete_one({"cycle_count_id": cycle_count_id})
+    return result.deleted_count == 1

services/inventory/helpers/warehouse_locations.py

@@ -0,0 +1,213 @@
+from datetime import date, datetime, timezone
+from typing import Optional
+
+from motor.motor_asyncio import AsyncIOMotorDatabase
+from pydantic import BaseModel
+from pymongo import ReturnDocument
+
+from services.inventory.models.warehouse_location_models import (
+    Aisle,
+    AisleCreate,
+    AisleTree,
+    AisleUpdate,
+    Area,
+    AreaCreate,
+    AreaTree,
+    AreaUpdate,
+    Bin,
+    BinCreate,
+    BinUpdate,
+    LocationTree,
+    Lot,
+    LotCreate,
+    LotUpdate,
+    Rack,
+    RackCreate,
+    RackTree,
+    RackUpdate,
+    WarehouseLocation,
+    Zone,
+    ZoneCreate,
+    ZoneTree,
+    ZoneUpdate,
+)
+
+
+LEVELS = {
+    "lots": ("warehouse_lots", "lot_id", Lot, LotCreate, LotUpdate),
+    "zones": ("warehouse_zones", "zone_id", Zone, ZoneCreate, ZoneUpdate),
+    "areas": ("warehouse_areas", "area_id", Area, AreaCreate, AreaUpdate),
+    "aisles": ("warehouse_aisles", "aisle_id", Aisle, AisleCreate, AisleUpdate),
+    "racks": ("warehouse_racks", "rack_id", Rack, RackCreate, RackUpdate),
+    "bins": ("warehouse_bins", "bin_id", Bin, BinCreate, BinUpdate),
+}
+
+
+def _serialize(doc: Optional[dict]) -> Optional[dict]:
+    if not doc:
+        return None
+    doc = dict(doc)
+    doc.pop("_id", None)
+    return doc
+
+
+def _prepare(value):
+    if isinstance(value, BaseModel):
+        return _prepare(value.model_dump())
+    if isinstance(value, datetime):
+        if value.tzinfo is None:
+            return value.replace(tzinfo=timezone.utc)
+        return value.astimezone(timezone.utc)
+    if isinstance(value, date):
+        return datetime(value.year, value.month, value.day, tzinfo=timezone.utc)
+    if isinstance(value, dict):
+        return {key: _prepare(item) for key, item in value.items()}
+    if isinstance(value, list):
+        return [_prepare(item) for item in value]
+    return value
+
+
+def _level_config(level: str):
+    try:
+        return LEVELS[level]
+    except KeyError as exc:
+        raise ValueError(f"Unknown warehouse location level '{level}'") from exc
+
+
+async def get_all(
+    db: AsyncIOMotorDatabase,
+    level: str,
+    *,
+    page: int = 1,
+    page_size: int = 20,
+    query: Optional[dict] = None,
+) -> tuple[list[dict], int]:
+    collection, _, _, _, _ = _level_config(level)
+    query = query or {}
+    total = await db[collection].count_documents(query)
+    cursor = db[collection].find(query).skip((page - 1) * page_size).limit(page_size)
+    return [_serialize(doc) async for doc in cursor], total
+
+
+async def get_by_id(db: AsyncIOMotorDatabase, level: str, record_id: str) -> Optional[dict]:
+    collection, id_field, _, _, _ = _level_config(level)
+    return _serialize(await db[collection].find_one({id_field: record_id}))
+
+
+async def create(db: AsyncIOMotorDatabase, level: str, data: BaseModel) -> dict:
+    collection, _, model_cls, _, _ = _level_config(level)
+    doc = _prepare(model_cls(**data.model_dump()))
+    await db[collection].insert_one(doc)
+    return _serialize(doc)
+
+
+async def update(
+    db: AsyncIOMotorDatabase,
+    level: str,
+    record_id: str,
+    data: BaseModel,
+) -> Optional[dict]:
+    collection, id_field, model_cls, _, _ = _level_config(level)
+    existing = await get_by_id(db, level, record_id)
+    if not existing:
+        return None
+
+    fields = _prepare(data.model_dump(exclude_unset=True))
+    if not fields:
+        return existing
+
+    merged = {**existing, **fields, "updated_at": datetime.now(timezone.utc)}
+    model_cls(**merged)
+    result = await db[collection].find_one_and_update(
+        {id_field: record_id},
+        {"$set": fields | {"updated_at": merged["updated_at"]}},
+        return_document=ReturnDocument.AFTER,
+    )
+    return _serialize(result)
+
+
+async def delete(db: AsyncIOMotorDatabase, level: str, record_id: str) -> bool:
+    collection, id_field, _, _, _ = _level_config(level)
+    result = await db[collection].delete_one({id_field: record_id})
+    return result.deleted_count == 1
+
+
+async def get_location_for_bin(
+    db: AsyncIOMotorDatabase,
+    bin_id: str,
+) -> Optional[WarehouseLocation]:
+    bin_doc = await get_by_id(db, "bins", bin_id)
+    if not bin_doc:
+        return None
+
+    rack_doc = await get_by_id(db, "racks", bin_doc["rack_id"])
+    if not rack_doc:
+        return None
+    aisle_doc = await get_by_id(db, "aisles", rack_doc["aisle_id"])
+    if not aisle_doc:
+        return None
+    area_doc = await get_by_id(db, "areas", aisle_doc["area_id"])
+    if not area_doc:
+        return None
+    zone_doc = await get_by_id(db, "zones", area_doc["zone_id"])
+    if not zone_doc:
+        return None
+    lot_doc = await get_by_id(db, "lots", zone_doc["lot_id"])
+    if not lot_doc:
+        return None
+
+    return WarehouseLocation(
+        bin=Bin(**bin_doc),
+        rack=Rack(**rack_doc),
+        aisle=Aisle(**aisle_doc),
+        area=Area(**area_doc),
+        zone=Zone(**zone_doc),
+        lot=Lot(**lot_doc),
+    )
+
+
+async def get_tree_for_lot(db: AsyncIOMotorDatabase, lot_id: str) -> Optional[LocationTree]:
+    lot_doc = await get_by_id(db, "lots", lot_id)
+    if not lot_doc:
+        return None
+
+    zone_docs, _ = await get_all(db, "zones", page=1, page_size=10_000, query={"lot_id": lot_id})
+    area_docs, _ = await get_all(db, "areas", page=1, page_size=10_000)
+    aisle_docs, _ = await get_all(db, "aisles", page=1, page_size=10_000)
+    rack_docs, _ = await get_all(db, "racks", page=1, page_size=10_000)
+    bin_docs, _ = await get_all(db, "bins", page=1, page_size=10_000)
+
+    areas_by_zone: dict[str, list[dict]] = {}
+    for doc in area_docs:
+        areas_by_zone.setdefault(doc["zone_id"], []).append(doc)
+
+    aisles_by_area: dict[str, list[dict]] = {}
+    for doc in aisle_docs:
+        aisles_by_area.setdefault(doc["area_id"], []).append(doc)
+
+    racks_by_aisle: dict[str, list[dict]] = {}
+    for doc in rack_docs:
+        racks_by_aisle.setdefault(doc["aisle_id"], []).append(doc)
+
+    bins_by_rack: dict[str, list[dict]] = {}
+    for doc in bin_docs:
+        bins_by_rack.setdefault(doc["rack_id"], []).append(doc)
+
+    zones = []
+    for zone_doc in zone_docs:
+        areas = []
+        for area_doc in areas_by_zone.get(zone_doc["zone_id"], []):
+            aisles = []
+            for aisle_doc in aisles_by_area.get(area_doc["area_id"], []):
+                racks = [
+                    RackTree(
+                        rack=Rack(**rack_doc),
+                        bins=[Bin(**bin_doc) for bin_doc in bins_by_rack.get(rack_doc["rack_id"], [])],
+                    )
+                    for rack_doc in racks_by_aisle.get(aisle_doc["aisle_id"], [])
+                ]
+                aisles.append(AisleTree(aisle=Aisle(**aisle_doc), racks=racks))
+            areas.append(AreaTree(area=Area(**area_doc), aisles=aisles))
+        zones.append(ZoneTree(zone=Zone(**zone_doc), areas=areas))
+
+    return LocationTree(lot=Lot(**lot_doc), zones=zones)