monkeybrain-runtime 1.0.0__py3-none-any.whl

services/pm/helpers/checklists.py

@@ -0,0 +1,318 @@
+from datetime import date, datetime, timezone
+from typing import Optional
+from uuid import uuid4
+
+from motor.motor_asyncio import AsyncIOMotorDatabase
+
+from services.auth.helpers.influx_store import write_websocket_event
+from services.auth.helpers.nats_store import subject_for_event_type
+from services.common.embeddings import build_embedding
+from services.common.neo4j_mirror import mirror_document, safe_mirror
+from services.pm.models.checklists import ChecklistCreate, ChecklistItemCreate, ChecklistItemUpdate, ChecklistUpdate
+
+COLLECTION = "checklists"
+HVAC_TEMPERATURE_WORK_ORDER_ID = "WO-HVAC-TEMP-THRESHOLD-001"
+HVAC_TEMPERATURE_WORKFLOW_ID = "WF-HVAC-TEMP-THRESHOLD-001"
+
+
+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 {k: _prepare(v) for k, v in value.items()}
+    if isinstance(value, list):
+        return [_prepare(v) for v 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(d) async for d in cursor], total
+
+
+async def get_by_id(db: AsyncIOMotorDatabase, checklist_id: str) -> Optional[dict]:
+    doc = await db[COLLECTION].find_one({"checklist_id": checklist_id})
+    return _serialize(doc)
+
+
+async def get_by_owner(db: AsyncIOMotorDatabase, owner_id: str) -> list[dict]:
+    cursor = db[COLLECTION].find({"owner_id": owner_id})
+    return [_serialize(d) async for d in cursor]
+
+
+async def get_by_work_order(db: AsyncIOMotorDatabase, work_order_id: str) -> list[dict]:
+    cursor = db[COLLECTION].find({"work_order_id": work_order_id})
+    return [_serialize(d) async for d in cursor]
+
+
+async def get_by_process_definition(db: AsyncIOMotorDatabase, process_definition_id: str) -> list[dict]:
+    cursor = db[COLLECTION].find({"process_definition_id": process_definition_id})
+    return [_serialize(d) async for d in cursor]
+
+
+async def get_by_tag(db: AsyncIOMotorDatabase, tag: str) -> list[dict]:
+    cursor = db[COLLECTION].find({"tags": tag})
+    return [_serialize(d) async for d in cursor]
+
+
+async def get_by_stage(db: AsyncIOMotorDatabase, stage_id: str) -> list[dict]:
+    cursor = db[COLLECTION].find({"items.stage_id": stage_id})
+    return [_serialize(d) async for d in cursor]
+
+
+async def get_open(db: AsyncIOMotorDatabase) -> list[dict]:
+    cursor = db[COLLECTION].find({"is_archived": False, "items.is_completed": False})
+    return [_serialize(d) async for d in cursor]
+
+
+async def get_completed(db: AsyncIOMotorDatabase) -> list[dict]:
+    cursor = db[COLLECTION].find(
+        {
+            "items": {"$not": {"$elemMatch": {"is_completed": False}}},
+            "is_archived": False,
+        }
+    )
+    return [_serialize(d) async for d in cursor]
+
+
+async def create(db: AsyncIOMotorDatabase, data: ChecklistCreate) -> dict:
+    doc = _prepare(data.model_dump())
+    await db[COLLECTION].insert_one(doc)
+    return _serialize(doc)
+
+
+async def update(
+    db: AsyncIOMotorDatabase,
+    checklist_id: str,
+    data: ChecklistUpdate,
+) -> Optional[dict]:
+    fields = _prepare(data.model_dump(exclude_unset=True))
+    if not fields:
+        return await get_by_id(db, checklist_id)
+    result = await db[COLLECTION].find_one_and_update(
+        {"checklist_id": checklist_id},
+        {"$set": fields},
+        return_document=True,
+    )
+    return _serialize(result)
+
+
+async def delete(db: AsyncIOMotorDatabase, checklist_id: str) -> bool:
+    result = await db[COLLECTION].delete_one({"checklist_id": checklist_id})
+    return result.deleted_count == 1
+
+
+async def add_item(
+    db: AsyncIOMotorDatabase,
+    checklist_id: str,
+    item: ChecklistItemCreate,
+) -> Optional[dict]:
+    result = await db[COLLECTION].find_one_and_update(
+        {"checklist_id": checklist_id},
+        {"$push": {"items": _prepare(item.model_dump())}, "$set": {"updated_at": datetime.now(timezone.utc)}},
+        return_document=True,
+    )
+    return _serialize(result)
+
+
+async def update_item(
+    db: AsyncIOMotorDatabase,
+    checklist_id: str,
+    item_id: str,
+    data: ChecklistItemUpdate,
+) -> Optional[dict]:
+    fields = _prepare(data.model_dump(exclude_unset=True))
+    if not fields:
+        return await get_by_id(db, checklist_id)
+    updates = {f"items.$.{key}": value for key, value in fields.items()}
+    updates["updated_at"] = datetime.now(timezone.utc)
+    result = await db[COLLECTION].find_one_and_update(
+        {"checklist_id": checklist_id, "items.item_id": item_id},
+        {"$set": updates},
+        return_document=True,
+    )
+    return _serialize(result)
+
+
+async def set_item_completed(
+    db: AsyncIOMotorDatabase,
+    checklist_id: str,
+    item_id: str,
+    is_completed: bool,
+) -> Optional[dict]:
+    now = datetime.now(timezone.utc)
+    before = await db[COLLECTION].find_one(
+        {"checklist_id": checklist_id, "items.item_id": item_id},
+        {"items.$": 1, "checklist_id": 1, "title": 1, "work_order_id": 1, "process_definition_id": 1},
+    )
+    was_completed = bool((before or {}).get("items", [{}])[0].get("is_completed")) if before else False
+    updates = {
+        "items.$.is_completed": is_completed,
+        "items.$.completed_at": now if is_completed else None,
+        "items.$.updated_at": now,
+        "updated_at": now,
+    }
+    result = await db[COLLECTION].find_one_and_update(
+        {"checklist_id": checklist_id, "items.item_id": item_id},
+        {"$set": updates},
+        return_document=True,
+    )
+    serialized = _serialize(result)
+    if serialized and is_completed and not was_completed:
+        await _write_checklist_item_completed_event(serialized, item_id, now)
+    return serialized
+
+
+async def remove_item(
+    db: AsyncIOMotorDatabase,
+    checklist_id: str,
+    item_id: str,
+) -> Optional[dict]:
+    result = await db[COLLECTION].find_one_and_update(
+        {"checklist_id": checklist_id, "items.item_id": item_id},
+        {
+            "$pull": {"items": {"item_id": item_id}},
+            "$set": {"updated_at": datetime.now(timezone.utc)},
+        },
+        return_document=True,
+    )
+    return _serialize(result)
+
+
+async def ensure_hvac_temperature_threshold_checklist(
+    db: AsyncIOMotorDatabase,
+    sensor: dict,
+    reading: dict,
+) -> dict:
+    sensor_id = str(sensor.get("sensor_id") or "unknown")
+    sensor_token = sensor_id.replace(".", "-").replace(" ", "-")
+    checklist_id = f"CHK-HVAC-TEMP-THRESHOLD-{sensor_token}"
+    existing = await get_by_id(db, checklist_id)
+    if existing:
+        return existing
+
+    now = datetime.now(timezone.utc)
+    sensor_name = str(sensor.get("name") or sensor_id)
+    high_threshold = sensor.get("alert_threshold_high")
+    value = reading.get("value", reading.get("raw_value"))
+    unit = reading.get("unit") or sensor.get("measurement_unit") or "C"
+    document = {
+        "checklist_id": checklist_id,
+        "work_order_id": HVAC_TEMPERATURE_WORK_ORDER_ID,
+        "title": f"HVAC temperature threshold response for {sensor_name}",
+        "description": (
+            f"Auto-created checklist because {sensor_name} reported {value} {unit}"
+            f" against high threshold {high_threshold} {unit}."
+        ),
+        "owner_id": "FACILITIES-ENGINEERING",
+        "process_definition_id": HVAC_TEMPERATURE_WORKFLOW_ID,
+        "tags": ["hvac", "temperature", "threshold", "auto-created", sensor_id],
+        "items": [
+            _hvac_checklist_item(
+                checklist_id,
+                "001",
+                "Confirm latest sensor reading, timestamp, quality, and threshold.",
+                f"Record {sensor_name} value {value} {unit}, threshold {high_threshold} {unit}, and reading time {reading.get('time') or reading.get('timestamp')}.",
+                "FACILITIES-ENGINEERING",
+                now,
+            ),
+            _hvac_checklist_item(
+                checklist_id,
+                "002",
+                "Adjust HVAC setpoint within approved range.",
+                "Apply approved HVAC setpoint correction and document before/after setpoints.",
+                "FACILITIES-ENGINEERING",
+                now,
+            ),
+            _hvac_checklist_item(
+                checklist_id,
+                "003",
+                "Monitor recovery below temperature threshold.",
+                "Confirm readings are back below the configured threshold and stable during the observation window.",
+                "FACILITIES-ENGINEERING",
+                now,
+            ),
+            _hvac_checklist_item(
+                checklist_id,
+                "004",
+                "Document QA/facilities release decision.",
+                "Record excursion impact, corrective action, and QA/facilities release or hold decision.",
+                "QUALITY-ASSURANCE",
+                now,
+            ),
+        ],
+        "is_archived": False,
+        "created_at": now,
+        "updated_at": now,
+    }
+    document["embedding"] = build_embedding(COLLECTION, document)
+    await db[COLLECTION].insert_one(_prepare(document))
+    await safe_mirror(mirror_document(COLLECTION, document, "ensure_hvac_temperature_threshold_checklist"))
+    return _serialize(document)
+
+
+def _hvac_checklist_item(
+    checklist_id: str,
+    suffix: str,
+    title: str,
+    description: str,
+    assigned_to: str,
+    now: datetime,
+) -> dict:
+    return {
+        "item_id": f"{checklist_id}-{suffix}",
+        "work_order_id": HVAC_TEMPERATURE_WORK_ORDER_ID,
+        "title": title,
+        "description": description,
+        "assigned_to": assigned_to,
+        "due_at": now,
+        "is_completed": False,
+        "completed_at": None,
+        "created_at": now,
+        "updated_at": now,
+    }
+
+
+async def _write_checklist_item_completed_event(checklist: dict, item_id: str, completed_at: datetime) -> None:
+    item = next((entry for entry in checklist.get("items", []) if entry.get("item_id") == item_id), {})
+    payload = {
+        "id": f"EVT-CHECKLIST-COMPLETE-{item_id}",
+        "type": "Checklist Item Completed",
+        "category": "Checklist Completion",
+        "checklist_id": checklist.get("checklist_id"),
+        "checklist_title": checklist.get("title"),
+        "item_id": item_id,
+        "item_title": item.get("title"),
+        "work_order_id": checklist.get("work_order_id") or item.get("work_order_id"),
+        "process_definition_id": checklist.get("process_definition_id"),
+        "assigned_to": item.get("assigned_to"),
+        "completed_at": completed_at.isoformat(),
+        "details": f"Checklist item completed: {item.get('title') or item_id}",
+    }
+    event = {
+        "event_id": str(uuid4()),
+        "received_at": completed_at.isoformat(),
+        "source": "pm.checklists",
+        "event_type": "checklist-item-completed",
+        "payload_type": "json",
+        "payload": payload,
+    }
+    await write_websocket_event(event, subject_for_event_type("checklist-item-completed"))

services/pm/helpers/cleaning.py

@@ -0,0 +1,333 @@
+"""Cleaning records CRUD — reads/writes from InfluxDB cleaning_log measurement."""
+
+import json
+import logging
+from datetime import datetime, timezone
+from typing import Optional
+from urllib.request import Request, urlopen
+from urllib.parse import urlencode
+
+from motor.motor_asyncio import AsyncIOMotorDatabase
+from services.common.config import settings
+from services.pm.models.cleaning import CleaningRecordCreate, CleaningRecordUpdate
+
+logger = logging.getLogger(__name__)
+
+COLLECTION = "cleaning_log"
+
+CLEANING_TYPE_MAP = {
+    "SOP-Based": "Routine",
+    "CIP": "Routine",
+    "COP": "COP",
+    "Manual": "Routine",
+    "Deep Clean": "Deep Clean",
+    "Post-Production": "Post-Production",
+    "Pre-Production": "Pre-Production",
+    "Changeover": "Changeover",
+    "Validation": "Validation",
+    "Sanitization": "Sanitization",
+}
+
+CLEANING_METHOD_MAP = {
+    "CIP": "CIP",
+    "COP": "COP",
+    "SOP-Based": "Manual",
+    "Manual": "Manual",
+    "Automated": "Automated",
+    "Spray Wash": "Spray Wash",
+    "Ultrasonic": "Ultrasonic",
+}
+
+STATUS_MAP = {
+    "Pending": "Scheduled",
+    "Scheduled": "Scheduled",
+    "In Progress": "In Progress",
+    "Completed": "Completed",
+    "Verified": "Verified",
+    "Failed": "Failed",
+    "Cancelled": "Cancelled",
+    "Pre-Production": "Pre-Production",
+    "Post-Production": "Post-Production",
+}
+
+
+def _escape_tag(value: str) -> str:
+    return str(value).replace(",", "\\,").replace(" ", "\\ ").replace("=", "\\=")
+
+
+def _influx_write(lines: list[str]) -> None:
+    query = urlencode({"db": settings.INFLUXDB_BUCKET})
+    url = f"{settings.INFLUXDB_URL.rstrip('/')}/api/v3/write_lp?{query}"
+    headers = {"Content-Type": "text/plain; charset=utf-8"}
+    if settings.INFLUXDB_TOKEN:
+        headers["Authorization"] = f"Bearer {settings.INFLUXDB_TOKEN}"
+    body = "\n".join(lines)
+    request = Request(url, data=body.encode("utf-8"), headers=headers, method="POST")
+    with urlopen(request, timeout=10) as response:
+        response.read()
+
+
+def _influx_query(sql: str) -> list[dict]:
+    params = urlencode({"db": settings.INFLUXDB_BUCKET, "q": sql})
+    url = f"{settings.INFLUXDB_URL.rstrip('/')}/api/v3/query_sql?{params}"
+    headers = {"Content-Type": "application/json"}
+    if settings.INFLUXDB_TOKEN:
+        headers["Authorization"] = f"Bearer {settings.INFLUXDB_TOKEN}"
+    request = Request(url, headers=headers, method="GET")
+    with urlopen(request, timeout=10) as response:
+        return json.loads(response.read().decode("utf-8"))
+
+
+def _row_to_dict(row: dict) -> dict:
+    raw_clean_type = row.get("clean_type", row.get("cleaning_type", "Routine"))
+    cleaning_type = CLEANING_TYPE_MAP.get(raw_clean_type, "Routine")
+    raw_method = row.get("cleaning_method", "")
+    cleaning_method = CLEANING_METHOD_MAP.get(raw_method, "Manual") if raw_method else "Manual"
+    machine_id = row.get("machine_id", "")
+    record_id = row.get("record_id", f"CLN-{machine_id[-8:]}" if machine_id else "")
+    raw_status = row.get("status", "Scheduled")
+    status = STATUS_MAP.get(raw_status, "Scheduled")
+    return {
+        "record_id": record_id,
+        "equipment_id": machine_id,
+        "machine_id": machine_id,
+        "work_order_id": row.get("work_order_id", None),
+        "batch_execution_record_id": row.get("batch_execution_record_id", None),
+        "batch_id": row.get("batch_id", None),
+        "process_definition_id": row.get("process_definition_id", None),
+        "process_step_id": row.get("process_step_id", None),
+        "instruction_template_id": row.get("instruction_template_id", None),
+        "instruction_step_sequence": row.get("instruction_step_sequence", None),
+        "cleaning_requirement_id": row.get("cleaning_requirement_id", None),
+        "cleaning_type": cleaning_type,
+        "cleaning_method": cleaning_method,
+        "status": status,
+        "scheduled_start": row.get("scheduled_start", None) or None,
+        "scheduled_end": row.get("scheduled_end", None) or None,
+        "actual_start": row.get("actual_start", None) or None,
+        "actual_end": row.get("actual_end", None) or None,
+        "performed_by": row.get("performed_by", row.get("technician", None)),
+        "verified_by": row.get("verified_by", None),
+        "approved_by": row.get("approved_by", None),
+        "chemicals_used": [],
+        "water_type": row.get("water_type", None),
+        "water_volume_liters": row.get("water_volume_liters", None),
+        "verification_method": row.get("verification_method", "Visual Inspection"),
+        "verification_result": row.get("verification_result", None),
+        "residue_limit_ppm": row.get("residue_limit_ppm", None),
+        "residue_found_ppm": row.get("residue_found_ppm", None),
+        "previous_product": row.get("previous_product", None),
+        "current_product": row.get("current_product", None),
+        "batch_no": row.get("batch_no", None),
+        "room_temp_celsius": row.get("room_temp_celsius", None),
+        "room_humidity_pct": row.get("room_humidity_pct", None),
+        "remarks": row.get("remarks", None),
+        "attachments": row.get("attachments", []) or [],
+        "created_at": row.get("time", datetime.now(timezone.utc).isoformat()),
+        "updated_at": row.get("time", datetime.now(timezone.utc).isoformat()),
+    }
+
+
+def _record_to_line(data: dict, ts_ns: int) -> str:
+    tags = (
+        f"equipment_id={_escape_tag(data.get('equipment_id', ''))},"
+        f"machine_id={_escape_tag(data.get('machine_id', data.get('equipment_id', '')))},"
+        f"status={_escape_tag(data.get('status', 'Scheduled'))},"
+        f"technician={_escape_tag(data.get('performed_by', ''))},"
+        f"cleaning_type={_escape_tag(data.get('cleaning_type', 'Routine'))},"
+        f"cleaning_method={_escape_tag(data.get('cleaning_method', 'Manual'))}"
+    )
+    fields = (
+        f"record_id={_escape_tag(data.get('record_id', ''))},"
+        f"equipment_id={_escape_tag(data.get('equipment_id', ''))},"
+        f"machine_id={_escape_tag(data.get('machine_id', data.get('equipment_id', '')))},"
+        f"cleaning_type={_escape_tag(data.get('cleaning_type', 'Routine'))},"
+        f"cleaning_method={_escape_tag(data.get('cleaning_method', 'Manual'))},"
+        f"status={_escape_tag(data.get('status', 'Scheduled'))},"
+        f"technician={_escape_tag(data.get('performed_by', ''))},"
+        f"work_order_id={_escape_tag(data.get('work_order_id', '') or '')}"
+    )
+    return f"{COLLECTION},{tags} {fields} {ts_ns}"
+
+
+# ── Read ──────────────────────────────────────────────────────────────────────
+
+async def get_all(
+    db: AsyncIOMotorDatabase,
+    page: int = 1,
+    page_size: int = 20,
+) -> tuple[list[dict], int]:
+    sql = f"SELECT * FROM {COLLECTION} ORDER BY time DESC LIMIT 500"
+    rows = _influx_query(sql)
+    seen: dict[str, dict] = {}
+    for r in rows:
+        rid = r.get("record_id", "")
+        if rid and rid not in seen:
+            seen[rid] = r
+    deduped = list(seen.values())
+    total = len(deduped)
+    start = (page - 1) * page_size
+    return [_row_to_dict(r) for r in deduped[start:start + page_size]], total
+
+
+async def get_by_id(db: AsyncIOMotorDatabase, record_id: str) -> Optional[dict]:
+    sql = f"SELECT * FROM {COLLECTION} WHERE record_id = '{record_id}' LIMIT 1"
+    rows = _influx_query(sql)
+    return _row_to_dict(rows[0]) if rows else None
+
+
+async def get_by_equipment_id(db: AsyncIOMotorDatabase, equipment_id: str) -> list[dict]:
+    sql = f"SELECT * FROM {COLLECTION} WHERE equipment_id = '{equipment_id}' ORDER BY time DESC LIMIT 100"
+    rows = _influx_query(sql)
+    return [_row_to_dict(r) for r in rows]
+
+
+async def get_by_status(db: AsyncIOMotorDatabase, status: str) -> list[dict]:
+    sql = f"SELECT * FROM {COLLECTION} WHERE status = '{status}' ORDER BY time DESC LIMIT 100"
+    rows = _influx_query(sql)
+    return [_row_to_dict(r) for r in rows]
+
+
+async def get_by_work_order(db: AsyncIOMotorDatabase, work_order_id: str) -> list[dict]:
+    sql = f"SELECT * FROM {COLLECTION} WHERE work_order_id = '{work_order_id}' ORDER BY time DESC LIMIT 100"
+    rows = _influx_query(sql)
+    return [_row_to_dict(r) for r in rows]
+
+
+# ── Create ────────────────────────────────────────────────────────────────────
+
+async def create(db: AsyncIOMotorDatabase, data: CleaningRecordCreate) -> dict:
+    record = data.model_dump()
+    record["created_at"] = datetime.now(timezone.utc).isoformat()
+    record["updated_at"] = datetime.now(timezone.utc).isoformat()
+    ts_ns = int(datetime.now(timezone.utc).timestamp() * 1_000_000_000)
+    line = _record_to_line(record, ts_ns)
+    _influx_write([line])
+    await _attach_to_batch_record(db, record)
+    return record
+
+
+# ── Update ────────────────────────────────────────────────────────────────────
+
+async def update(
+    db: AsyncIOMotorDatabase,
+    record_id: str,
+    data: CleaningRecordUpdate,
+) -> Optional[dict]:
+    existing = await get_by_id(db, record_id)
+    if not existing:
+        return None
+    updates = data.model_dump(exclude_unset=True)
+    existing.update(updates)
+    existing["updated_at"] = datetime.now(timezone.utc).isoformat()
+    ts_ns = int(datetime.now(timezone.utc).timestamp() * 1_000_000_000)
+    line = _record_to_line(existing, ts_ns)
+    _influx_write([line])
+    return existing
+
+
+# ── Delete ────────────────────────────────────────────────────────────────────
+
+async def delete(db: AsyncIOMotorDatabase, record_id: str) -> bool:
+    existing = await get_by_id(db, record_id)
+    if not existing:
+        return False
+    existing["status"] = "Cancelled"
+    existing["updated_at"] = datetime.now(timezone.utc).isoformat()
+    ts_ns = int(datetime.now(timezone.utc).timestamp() * 1_000_000_000)
+    line = _record_to_line(existing, ts_ns)
+    _influx_write([line])
+    await _detach_from_batch_record(db, existing)
+    return True
+
+
+# ── Batch record attachment (kept as-is — operates on separate MongoDB collections) ──
+
+def _package_updates(record: dict) -> dict:
+    record_id = record.get("record_id")
+    requirement_id = record.get("cleaning_requirement_id")
+    attachments = [item for item in record.get("attachments") or [] if item]
+    add_to_set: dict = {}
+    set_fields: dict = {}
+    if record_id:
+        add_to_set["cleaning_record_ids"] = record_id
+        add_to_set["metadata.batch_record_package.cleaning_record_ids"] = record_id
+        add_to_set["metadata.bmr_package.cleaning_record_ids"] = record_id
+        add_to_set["metadata.bpr_package.cleaning_record_ids"] = record_id
+    if record_id and requirement_id:
+        add_to_set["metadata.required_cleaning_requirement_ids"] = requirement_id
+        add_to_set["metadata.batch_record_package.required_cleaning_requirement_ids"] = requirement_id
+        add_to_set["metadata.bmr_package.required_cleaning_requirement_ids"] = requirement_id
+        add_to_set["metadata.bpr_package.required_cleaning_requirement_ids"] = requirement_id
+        set_fields[f"metadata.cleaning_requirement_record_map.{requirement_id}"] = record_id
+        set_fields[f"metadata.batch_record_package.cleaning_requirement_record_map.{requirement_id}"] = record_id
+        set_fields[f"metadata.bmr_package.cleaning_requirement_record_map.{requirement_id}"] = record_id
+        set_fields[f"metadata.bpr_package.cleaning_requirement_record_map.{requirement_id}"] = record_id
+    if attachments:
+        add_to_set["evidence_document_ids"] = {"$each": attachments}
+        add_to_set["metadata.batch_record_package.cleaning_attachment_ids"] = {"$each": attachments}
+        add_to_set["metadata.bmr_package.cleaning_attachment_ids"] = {"$each": attachments}
+        add_to_set["metadata.bpr_package.cleaning_attachment_ids"] = {"$each": attachments}
+    updates: dict = {}
+    if add_to_set:
+        updates["$addToSet"] = add_to_set
+    if set_fields:
+        updates["$set"] = set_fields
+    return updates
+
+
+async def _attach_to_batch_record(db: AsyncIOMotorDatabase, record: dict) -> None:
+    batch_execution_record_id = record.get("batch_execution_record_id")
+    if not batch_execution_record_id:
+        return
+    updates = _package_updates(record)
+    if updates:
+        await db.batch_production_execution_records.update_one(
+            {"batch_execution_record_id": batch_execution_record_id},
+            updates,
+        )
+
+
+def _package_removals(record: dict) -> dict:
+    record_id = record.get("record_id")
+    requirement_id = record.get("cleaning_requirement_id")
+    attachments = [item for item in record.get("attachments") or [] if item]
+    pull: dict = {}
+    unset: dict = {}
+    if record_id:
+        pull["cleaning_record_ids"] = record_id
+        pull["metadata.batch_record_package.cleaning_record_ids"] = record_id
+        pull["metadata.bmr_package.cleaning_record_ids"] = record_id
+        pull["metadata.bpr_package.cleaning_record_ids"] = record_id
+    if requirement_id:
+        pull["metadata.required_cleaning_requirement_ids"] = requirement_id
+        pull["metadata.batch_record_package.required_cleaning_requirement_ids"] = requirement_id
+        pull["metadata.bmr_package.required_cleaning_requirement_ids"] = requirement_id
+        pull["metadata.bpr_package.required_cleaning_requirement_ids"] = requirement_id
+        unset[f"metadata.cleaning_requirement_record_map.{requirement_id}"] = ""
+        unset[f"metadata.batch_record_package.cleaning_requirement_record_map.{requirement_id}"] = ""
+        unset[f"metadata.bmr_package.cleaning_requirement_record_map.{requirement_id}"] = ""
+        unset[f"metadata.bpr_package.cleaning_requirement_record_map.{requirement_id}"] = ""
+    if attachments:
+        pull["evidence_document_ids"] = {"$in": attachments}
+        pull["metadata.batch_record_package.cleaning_attachment_ids"] = {"$in": attachments}
+        pull["metadata.bmr_package.cleaning_attachment_ids"] = {"$in": attachments}
+        pull["metadata.bpr_package.cleaning_attachment_ids"] = {"$in": attachments}
+    removals: dict = {}
+    if pull:
+        removals["$pull"] = pull
+    if unset:
+        removals["$unset"] = unset
+    return removals
+
+
+async def _detach_from_batch_record(db: AsyncIOMotorDatabase, record: dict) -> None:
+    batch_execution_record_id = record.get("batch_execution_record_id")
+    if not batch_execution_record_id:
+        return
+    removals = _package_removals(record)
+    if removals:
+        await db.batch_production_execution_records.update_one(
+            {"batch_execution_record_id": batch_execution_record_id},
+            removals,
+        )