monkeybrain-runtime 1.0.0__py3-none-any.whl

services/shipping/routers/vehicle.py

@@ -0,0 +1,117 @@
+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.shipping.helpers import vehicle as crud
+from services.shipping.models.vehicle import (
+    PaginatedVehicleResponse,
+    VehicleCreate,
+    VehicleResponse,
+    VehicleUpdate,
+)
+
+router = APIRouter()
+
+
+@router.get("/", response_model=PaginatedVehicleResponse)
+async def list_vehicles(
+    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-products")),
+):
+    records, total = await crud.get_all(db, page=page, page_size=page_size)
+    return PaginatedVehicleResponse(total=total, page=page, page_size=page_size, results=records)
+
+
+@router.get("/by-carrier/{carrier_id}", response_model=list[VehicleResponse])
+async def list_vehicles_by_carrier(
+    carrier_id: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-view-products")),
+):
+    return await crud.get_by_carrier(db, carrier_id)
+
+
+@router.get("/by-registration-plate/{registration_plate}", response_model=VehicleResponse)
+async def get_vehicle_by_registration_plate(
+    registration_plate: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-view-products")),
+):
+    record = await crud.get_by_registration_plate(db, registration_plate)
+    if not record:
+        raise HTTPException(
+            status.HTTP_404_NOT_FOUND,
+            detail=f"Vehicle with registration plate '{registration_plate}' not found",
+        )
+    return record
+
+
+@router.get("/by-active/{active}", response_model=list[VehicleResponse])
+async def list_vehicles_by_active(
+    active: bool,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-view-products")),
+):
+    return await crud.get_by_active(db, active)
+
+
+@router.get("/{vehicle_id}", response_model=VehicleResponse)
+async def get_vehicle(
+    vehicle_id: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-view-products")),
+):
+    record = await crud.get_by_id(db, vehicle_id)
+    if not record:
+        raise HTTPException(status.HTTP_404_NOT_FOUND, detail=f"Vehicle '{vehicle_id}' not found")
+    return record
+
+
+@router.post("/", response_model=VehicleResponse, status_code=status.HTTP_201_CREATED)
+async def create_vehicle(
+    data: VehicleCreate,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-create-products")),
+):
+    vehicle_id = str(data.id)
+    if await crud.get_by_id(db, vehicle_id):
+        raise HTTPException(status.HTTP_409_CONFLICT, detail=f"Vehicle '{vehicle_id}' already exists")
+    if await crud.get_by_registration_plate(db, data.registration_plate):
+        raise HTTPException(
+            status.HTTP_409_CONFLICT,
+            detail=f"Vehicle with registration plate '{data.registration_plate}' already exists",
+        )
+    return await crud.create(db, data)
+
+
+@router.patch("/{vehicle_id}", response_model=VehicleResponse)
+async def update_vehicle(
+    vehicle_id: str,
+    data: VehicleUpdate,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-update-products")),
+):
+    if data.registration_plate:
+        existing = await crud.get_by_registration_plate(db, data.registration_plate)
+        if existing and existing.get("id") != vehicle_id:
+            raise HTTPException(
+                status.HTTP_409_CONFLICT,
+                detail=f"Vehicle with registration plate '{data.registration_plate}' already exists",
+            )
+    updated = await crud.update(db, vehicle_id, data)
+    if not updated:
+        raise HTTPException(status.HTTP_404_NOT_FOUND, detail=f"Vehicle '{vehicle_id}' not found")
+    return updated
+
+
+@router.delete("/{vehicle_id}", status_code=status.HTTP_204_NO_CONTENT)
+async def delete_vehicle(
+    vehicle_id: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-delete-products")),
+):
+    if not await crud.delete(db, vehicle_id):
+        raise HTTPException(status.HTTP_404_NOT_FOUND, detail=f"Vehicle '{vehicle_id}' not found")

services/shipping/routers/waybill.py

@@ -0,0 +1,119 @@
+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.shipping.helpers import waybill as crud
+from services.shipping.models.waybill import (
+    PaginatedWaybillResponse,
+    WaybillCreate,
+    WaybillResponse,
+    WaybillStatus,
+    WaybillUpdate,
+)
+
+
+router = APIRouter()
+
+
+@router.get("/", response_model=PaginatedWaybillResponse)
+async def list_waybills(
+    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-products")),
+):
+    records, total = await crud.get_all(db, page=page, page_size=page_size)
+    return PaginatedWaybillResponse(total=total, page=page, page_size=page_size, results=records)
+
+
+@router.get("/by-number/{waybill_number}", response_model=WaybillResponse)
+async def get_waybill_by_number(
+    waybill_number: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-view-products")),
+):
+    record = await crud.get_by_number(db, waybill_number)
+    if not record:
+        raise HTTPException(status.HTTP_404_NOT_FOUND, detail=f"Waybill '{waybill_number}' not found")
+    return record
+
+
+@router.get("/by-status/{waybill_status}", response_model=list[WaybillResponse])
+async def list_waybills_by_status(
+    waybill_status: WaybillStatus,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-view-products")),
+):
+    return await crud.get_by_status(db, waybill_status.value)
+
+
+@router.get("/by-barcode/{barcode}", response_model=WaybillResponse)
+async def get_waybill_by_barcode(
+    barcode: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-view-products")),
+):
+    record = await crud.get_by_barcode(db, barcode)
+    if not record:
+        raise HTTPException(status.HTTP_404_NOT_FOUND, detail=f"Waybill barcode '{barcode}' not found")
+    return record
+
+
+@router.get("/{waybill_id}", response_model=WaybillResponse)
+async def get_waybill(
+    waybill_id: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-view-products")),
+):
+    record = await crud.get_by_id(db, waybill_id)
+    if not record:
+        raise HTTPException(status.HTTP_404_NOT_FOUND, detail=f"Waybill '{waybill_id}' not found")
+    return record
+
+
+@router.post("/", response_model=WaybillResponse, status_code=status.HTTP_201_CREATED)
+async def create_waybill(
+    data: WaybillCreate,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-create-products")),
+):
+    waybill_id = str(data.id)
+    if await crud.get_by_id(db, waybill_id):
+        raise HTTPException(status.HTTP_409_CONFLICT, detail=f"Waybill '{waybill_id}' already exists")
+    if await crud.get_by_number(db, data.waybill_number):
+        raise HTTPException(status.HTTP_409_CONFLICT, detail=f"Waybill '{data.waybill_number}' already exists")
+    if data.barcode and await crud.get_by_barcode(db, data.barcode):
+        raise HTTPException(status.HTTP_409_CONFLICT, detail=f"Waybill barcode '{data.barcode}' already exists")
+    return await crud.create(db, data)
+
+
+@router.patch("/{waybill_id}", response_model=WaybillResponse)
+async def update_waybill(
+    waybill_id: str,
+    data: WaybillUpdate,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-update-products")),
+):
+    if data.waybill_number:
+        existing = await crud.get_by_number(db, data.waybill_number)
+        if existing and existing.get("id") != waybill_id:
+            raise HTTPException(status.HTTP_409_CONFLICT, detail=f"Waybill '{data.waybill_number}' already exists")
+    if data.barcode:
+        existing = await crud.get_by_barcode(db, data.barcode)
+        if existing and existing.get("id") != waybill_id:
+            raise HTTPException(status.HTTP_409_CONFLICT, detail=f"Waybill barcode '{data.barcode}' already exists")
+    updated = await crud.update(db, waybill_id, data)
+    if not updated:
+        raise HTTPException(status.HTTP_404_NOT_FOUND, detail=f"Waybill '{waybill_id}' not found")
+    return updated
+
+
+@router.delete("/{waybill_id}", status_code=status.HTTP_204_NO_CONTENT)
+async def delete_waybill(
+    waybill_id: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-delete-products")),
+):
+    if not await crud.delete(db, waybill_id):
+        raise HTTPException(status.HTTP_404_NOT_FOUND, detail=f"Waybill '{waybill_id}' not found")

services/suppliers/helpers/__init__.py

@@ -0,0 +1,13 @@
+"""suppliers service helpers package."""
+
+__all__ = [
+    "supplier_capabilities",
+    "supplier_certifications",
+    "supplier_details",
+    "supplier_financials",
+    "supplier_inventory",
+    "supplier_locations",
+    "supplier_pricing",
+    "supplier_quality",
+    "supplier_shipping",
+]

services/suppliers/helpers/supplier_capabilities.py

@@ -0,0 +1,58 @@
+from typing import Optional
+
+from motor.motor_asyncio import AsyncIOMotorDatabase
+from pymongo import ReturnDocument
+
+from services.suppliers.models.supplier_capabilities import SupplierCapabilitiesCreate, SupplierCapabilitiesUpdate
+
+COLLECTION = "supplier_capabilities"
+
+
+def _serialize(doc: Optional[dict]) -> Optional[dict]:
+    if not doc:
+        return None
+    doc = dict(doc)
+    doc.pop("_id", None)
+    return doc
+
+
+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_supplier_id(db: AsyncIOMotorDatabase, supplier_id: str) -> Optional[dict]:
+    return _serialize(await db[COLLECTION].find_one({"supplier_id": supplier_id}))
+
+
+async def create(db: AsyncIOMotorDatabase, data: SupplierCapabilitiesCreate) -> dict:
+    doc = data.model_dump()
+    await db[COLLECTION].insert_one(doc)
+    return _serialize(doc)
+
+
+async def update(
+    db: AsyncIOMotorDatabase,
+    supplier_id: str,
+    data: SupplierCapabilitiesUpdate,
+) -> Optional[dict]:
+    fields = data.model_dump(exclude_unset=True)
+    if not fields:
+        return await get_by_supplier_id(db, supplier_id)
+    result = await db[COLLECTION].find_one_and_update(
+        {"supplier_id": supplier_id},
+        {"$set": fields},
+        return_document=ReturnDocument.AFTER,
+    )
+    return _serialize(result)
+
+
+async def delete(db: AsyncIOMotorDatabase, supplier_id: str) -> bool:
+    result = await db[COLLECTION].delete_one({"supplier_id": supplier_id})
+    return result.deleted_count == 1

services/suppliers/helpers/supplier_certifications.py

@@ -0,0 +1,67 @@
+from typing import Optional
+from uuid import uuid4
+
+from motor.motor_asyncio import AsyncIOMotorDatabase
+from pymongo import ReturnDocument
+
+from services.suppliers.models.supplier_certifications import CertificationCreate, CertificationUpdate
+
+COLLECTION = "supplier_certifications"
+
+
+def _serialize(doc: Optional[dict]) -> Optional[dict]:
+    if not doc:
+        return None
+    doc = dict(doc)
+    doc.pop("_id", None)
+    return doc
+
+
+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, certification_id: str) -> Optional[dict]:
+    return _serialize(await db[COLLECTION].find_one({"certification_id": certification_id}))
+
+
+async def get_by_supplier(db: AsyncIOMotorDatabase, supplier_id: str) -> list[dict]:
+    cursor = db[COLLECTION].find({"supplier_id": supplier_id})
+    return [_serialize(d) async for d in cursor]
+
+
+async def create(db: AsyncIOMotorDatabase, data: CertificationCreate) -> dict:
+    doc = {
+        **data.model_dump(),
+        "certification_id": f"cert-{uuid4().hex[:12]}",
+    }
+    await db[COLLECTION].insert_one(doc)
+    return _serialize(doc)
+
+
+async def update(
+    db: AsyncIOMotorDatabase,
+    certification_id: str,
+    data: CertificationUpdate,
+) -> Optional[dict]:
+    fields = data.model_dump(exclude_unset=True)
+    if not fields:
+        return await get_by_id(db, certification_id)
+    result = await db[COLLECTION].find_one_and_update(
+        {"certification_id": certification_id},
+        {"$set": fields},
+        return_document=ReturnDocument.AFTER,
+    )
+    return _serialize(result)
+
+
+async def delete(db: AsyncIOMotorDatabase, certification_id: str) -> bool:
+    result = await db[COLLECTION].delete_one({"certification_id": certification_id})
+    return result.deleted_count == 1

services/suppliers/helpers/supplier_details.py

@@ -0,0 +1,58 @@
+from typing import Optional
+
+from motor.motor_asyncio import AsyncIOMotorDatabase
+from pymongo import ReturnDocument
+
+from services.suppliers.models.supplier_details import SupplierDetailsCreate, SupplierDetailsUpdate
+
+COLLECTION = "supplier_details"
+
+
+def _serialize(doc: Optional[dict]) -> Optional[dict]:
+    if not doc:
+        return None
+    doc = dict(doc)
+    doc.pop("_id", None)
+    return doc
+
+
+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_supplier_id(db: AsyncIOMotorDatabase, supplier_id: str) -> Optional[dict]:
+    return _serialize(await db[COLLECTION].find_one({"supplier_id": supplier_id}))
+
+
+async def create(db: AsyncIOMotorDatabase, data: SupplierDetailsCreate) -> dict:
+    doc = data.model_dump()
+    await db[COLLECTION].insert_one(doc)
+    return _serialize(doc)
+
+
+async def update(
+    db: AsyncIOMotorDatabase,
+    supplier_id: str,
+    data: SupplierDetailsUpdate,
+) -> Optional[dict]:
+    fields = data.model_dump(exclude_unset=True)
+    if not fields:
+        return await get_by_supplier_id(db, supplier_id)
+    result = await db[COLLECTION].find_one_and_update(
+        {"supplier_id": supplier_id},
+        {"$set": fields},
+        return_document=ReturnDocument.AFTER,
+    )
+    return _serialize(result)
+
+
+async def delete(db: AsyncIOMotorDatabase, supplier_id: str) -> bool:
+    result = await db[COLLECTION].delete_one({"supplier_id": supplier_id})
+    return result.deleted_count == 1

services/suppliers/helpers/supplier_financials.py

@@ -0,0 +1,58 @@
+from typing import Optional
+
+from motor.motor_asyncio import AsyncIOMotorDatabase
+from pymongo import ReturnDocument
+
+from services.suppliers.models.supplier_financials import SupplierFinancialsCreate, SupplierFinancialsUpdate
+
+COLLECTION = "supplier_financials"
+
+
+def _serialize(doc: Optional[dict]) -> Optional[dict]:
+    if not doc:
+        return None
+    doc = dict(doc)
+    doc.pop("_id", None)
+    return doc
+
+
+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_supplier_id(db: AsyncIOMotorDatabase, supplier_id: str) -> Optional[dict]:
+    return _serialize(await db[COLLECTION].find_one({"supplier_id": supplier_id}))
+
+
+async def create(db: AsyncIOMotorDatabase, data: SupplierFinancialsCreate) -> dict:
+    doc = data.model_dump()
+    await db[COLLECTION].insert_one(doc)
+    return _serialize(doc)
+
+
+async def update(
+    db: AsyncIOMotorDatabase,
+    supplier_id: str,
+    data: SupplierFinancialsUpdate,
+) -> Optional[dict]:
+    fields = data.model_dump(exclude_unset=True)
+    if not fields:
+        return await get_by_supplier_id(db, supplier_id)
+    result = await db[COLLECTION].find_one_and_update(
+        {"supplier_id": supplier_id},
+        {"$set": fields},
+        return_document=ReturnDocument.AFTER,
+    )
+    return _serialize(result)
+
+
+async def delete(db: AsyncIOMotorDatabase, supplier_id: str) -> bool:
+    result = await db[COLLECTION].delete_one({"supplier_id": supplier_id})
+    return result.deleted_count == 1

services/suppliers/helpers/supplier_inventory.py

@@ -0,0 +1,74 @@
+from typing import Optional
+from uuid import uuid4
+
+from motor.motor_asyncio import AsyncIOMotorDatabase
+from pymongo import ReturnDocument
+
+from services.suppliers.models.supplier_inventory import SupplierInventoryCreate, SupplierInventoryUpdate
+
+COLLECTION = "supplier_inventory"
+
+
+def _serialize(doc: Optional[dict]) -> Optional[dict]:
+    if not doc:
+        return None
+    doc = dict(doc)
+    doc.pop("_id", None)
+    return doc
+
+
+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, supplier_inventory_id: str) -> Optional[dict]:
+    return _serialize(await db[COLLECTION].find_one({"supplier_inventory_id": supplier_inventory_id}))
+
+
+async def get_by_supplier(db: AsyncIOMotorDatabase, supplier_id: str) -> list[dict]:
+    cursor = db[COLLECTION].find({"supplier_id": supplier_id})
+    return [_serialize(d) async for d in cursor]
+
+
+async def get_by_item(db: AsyncIOMotorDatabase, item_id: str) -> list[dict]:
+    cursor = db[COLLECTION].find({"item_id": item_id})
+    return [_serialize(d) async for d in cursor]
+
+
+async def get_by_location(db: AsyncIOMotorDatabase, location_id: str) -> list[dict]:
+    cursor = db[COLLECTION].find({"location_id": location_id})
+    return [_serialize(d) async for d in cursor]
+
+
+async def get_by_sku(db: AsyncIOMotorDatabase, sku: str) -> list[dict]:
+    cursor = db[COLLECTION].find({"sku": sku})
+    return [_serialize(d) async for d in cursor]
+
+
+async def create(db: AsyncIOMotorDatabase, data: SupplierInventoryCreate) -> dict:
+    doc = {
+        **data.model_dump(),
+        "supplier_inventory_id": f"supplier-inv-{uuid4().hex[:12]}",
+    }
+    await db[COLLECTION].insert_one(doc)
+    return _serialize(doc)
+
+
+async def update(db: AsyncIOMotorDatabase, supplier_inventory_id: str, data: SupplierInventoryUpdate) -> Optional[dict]:
+    fields = data.model_dump(exclude_unset=True)
+    if not fields:
+        return await get_by_id(db, supplier_inventory_id)
+    result = await db[COLLECTION].find_one_and_update(
+        {"supplier_inventory_id": supplier_inventory_id},
+        {"$set": fields},
+        return_document=ReturnDocument.AFTER,
+    )
+    return _serialize(result)
+
+
+async def delete(db: AsyncIOMotorDatabase, supplier_inventory_id: str) -> bool:
+    result = await db[COLLECTION].delete_one({"supplier_inventory_id": supplier_inventory_id})
+    return result.deleted_count == 1

services/suppliers/helpers/supplier_locations.py

@@ -0,0 +1,60 @@
+from typing import Optional
+
+from motor.motor_asyncio import AsyncIOMotorDatabase
+from pymongo import ReturnDocument
+
+from services.suppliers.models.supplier_locations import SupplierLocationCreate, SupplierLocationUpdate
+
+COLLECTION = "supplier_locations"
+
+
+def _serialize(doc: Optional[dict]) -> Optional[dict]:
+    if not doc:
+        return None
+    doc = dict(doc)
+    doc.pop("_id", None)
+    return doc
+
+
+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, location_id: str) -> Optional[dict]:
+    return _serialize(await db[COLLECTION].find_one({"location_id": location_id}))
+
+
+async def get_by_supplier(db: AsyncIOMotorDatabase, supplier_id: str) -> list[dict]:
+    cursor = db[COLLECTION].find({"supplier_id": supplier_id})
+    return [_serialize(d) async for d in cursor]
+
+
+async def get_by_item(db: AsyncIOMotorDatabase, item_id: str) -> list[dict]:
+    cursor = db[COLLECTION].find({"item_id": item_id})
+    return [_serialize(d) async for d in cursor]
+
+
+async def create(db: AsyncIOMotorDatabase, data: SupplierLocationCreate) -> dict:
+    doc = data.model_dump()
+    await db[COLLECTION].insert_one(doc)
+    return _serialize(doc)
+
+
+async def update(db: AsyncIOMotorDatabase, location_id: str, data: SupplierLocationUpdate) -> Optional[dict]:
+    fields = data.model_dump(exclude_unset=True)
+    if not fields:
+        return await get_by_id(db, location_id)
+    result = await db[COLLECTION].find_one_and_update(
+        {"location_id": location_id},
+        {"$set": fields},
+        return_document=ReturnDocument.AFTER,
+    )
+    return _serialize(result)
+
+
+async def delete(db: AsyncIOMotorDatabase, location_id: str) -> bool:
+    result = await db[COLLECTION].delete_one({"location_id": location_id})
+    return result.deleted_count == 1