Waiter PWA fixes, and extra feautures. Also added Emergency Mode, search etc

local_backend/routers/orders.py

@@ -9,7 +9,7 @@ from models.order import Order, OrderItem, OrderWaiter, OrderAuditLog
 from models.user import User, WaiterZone
 from models.table import Table
 from models.product import Product
-from schemas.order import OrderCreate, OrderOut, OrderItemOut, AddItemsRequest, AddItemsResponse, PayItemsRequest, AssignWaiterRequest, OrderWaiterOut
+from schemas.order import OrderCreate, OrderOut, OrderItemOut, AddItemsRequest, AddItemsResponse, PayItemsRequest, OfflinePaymentRequest, AssignWaiterRequest, OrderWaiterOut
 from pydantic import BaseModel
 
 class PrintOrderRequest(BaseModel):
@@ -33,6 +33,7 @@ class MoveItemsRequest(BaseModel):
 
 from routers.deps import get_current_user, require_manager
 from services.printer_service import route_and_print, route_and_print_sync, print_order_receipt, print_order_synopsis
+from services.sse_bus import broadcast_sync
 
 router = APIRouter()
 
@@ -159,6 +160,7 @@ def open_order(body: OrderCreate, db: Session = Depends(get_db), user: User = De
     _audit(db, order.id, "ORDER_OPENED", waiter_id=user.id)
     db.commit()
     db.refresh(order)
+    broadcast_sync("order_updated", {"order_id": order.id, "table_id": order.table_id, "status": order.status, "action": "opened"})
     return order
 
 
@@ -209,7 +211,7 @@ def add_items(
     db.refresh(order)
 
     print_results = route_and_print_sync(order_id, new_item_ids, db)
-
+    broadcast_sync("order_updated", {"order_id": order.id, "table_id": order.table_id, "status": order.status, "action": "items_added", "item_ids": new_item_ids})
     return {"order": order, "print_results": print_results}
 
 
@@ -295,6 +297,7 @@ def pay_items(order_id: int, body: PayItemsRequest, db: Session = Depends(get_db
     _audit(db, order_id, "PAYMENT", waiter_id=user.id, item_ids=paid_ids,
            amount=total_paid, payment_method=body.payment_method)
     db.commit()
+    broadcast_sync("order_paid", {"order_id": order_id, "table_id": order.table_id, "status": order.status, "paid_item_ids": paid_ids, "amount": total_paid, "payment_method": body.payment_method})
     return {"status": order.status, "paid_item_ids": paid_ids}
 
 
@@ -312,9 +315,105 @@ def close_order(order_id: int, db: Session = Depends(get_db), user: User = Depen
     order.closed_by = user.id
     _audit(db, order_id, "ORDER_CLOSED", waiter_id=user.id)
     db.commit()
+    broadcast_sync("order_closed", {"order_id": order_id, "table_id": order.table_id})
     return {"status": "closed"}
 
 
+@router.post("/{order_id}/pay-offline")
+def pay_items_offline(
+    order_id: int,
+    body: OfflinePaymentRequest,
+    db: Session = Depends(get_db),
+    user: User = Depends(get_current_user),
+):
+    """
+    Sync an emergency payment that was taken while the server was offline.
+    The UUID prevents double-processing. If a payment with the same UUID already
+    exists on this order, the duplicate is logged in red (is_duplicate=1) rather
+    than silently dropped — so managers can reconcile.
+    """
+    order = db.query(Order).filter(Order.id == order_id).first()
+    if not order:
+        raise HTTPException(status_code=404, detail="Order not found")
+    if not _can_access_order(order, user, db):
+        raise HTTPException(status_code=403, detail="Access denied")
+
+    # Check for duplicate UUID on this order
+    existing_uuid = db.query(OrderAuditLog).filter(
+        OrderAuditLog.order_id == order_id,
+        OrderAuditLog.offline_uuid == body.uuid,
+    ).first()
+    is_duplicate = existing_uuid is not None
+
+    from models.shift import WaiterShift
+    items = db.query(OrderItem).filter(
+        OrderItem.id.in_(body.item_ids),
+        OrderItem.order_id == order_id,
+        OrderItem.status == "active",
+    ).all()
+
+    # Reject empty payments — client had no offline snapshot for this table
+    if not items and not is_duplicate:
+        raise HTTPException(status_code=400, detail="No active items found — payment rejected")
+
+    # Use the client-recorded offline timestamp as paid_at so audit reflects real payment time
+    try:
+        paid_at = datetime.fromisoformat(body.offline_at.replace("Z", "+00:00")) if body.offline_at else datetime.now(timezone.utc)
+    except (ValueError, AttributeError):
+        paid_at = datetime.now(timezone.utc)
+
+    active_shift = db.query(WaiterShift).filter(
+        WaiterShift.waiter_id == user.id,
+        WaiterShift.ended_at == None,
+    ).first()
+
+    total_paid = 0.0
+    paid_ids = []
+    if not is_duplicate:
+        for item in items:
+            item.status = "paid"
+            item.paid_by = user.id
+            item.paid_at = paid_at
+            item.payment_method = body.payment_method
+            item.paid_in_shift_id = active_shift.id if active_shift else None
+            total_paid += item.unit_price * item.quantity
+            paid_ids.append(item.id)
+
+        db.flush()
+        active_remaining = db.query(OrderItem).filter(
+            OrderItem.order_id == order_id, OrderItem.status == "active"
+        ).count()
+        order.status = "paid" if active_remaining == 0 else "partially_paid"
+    else:
+        # Duplicate — compute total for audit record without changing item state
+        total_paid = sum(i.unit_price * i.quantity for i in items)
+        paid_ids = [i.id for i in items]
+
+    # Always write audit log — duplicate flag makes it visible in red in manager dashboard
+    db.add(OrderAuditLog(
+        order_id=order_id,
+        event_type="PAYMENT_OFFLINE",
+        waiter_id=user.id,
+        item_ids=json.dumps(paid_ids),
+        amount=total_paid,
+        payment_method=body.payment_method,
+        note=f"Emergency offline payment (uuid={body.uuid}){' — DUPLICATE' if is_duplicate else ''}",
+        offline_uuid=body.uuid,
+        offline_at=body.offline_at,
+        is_duplicate=1 if is_duplicate else 0,
+    ))
+    db.commit()
+
+    if not is_duplicate:
+        broadcast_sync("order_paid", {"order_id": order_id, "table_id": order.table_id, "status": order.status, "paid_item_ids": paid_ids, "amount": total_paid, "payment_method": body.payment_method})
+
+    return {
+        "status": order.status if not is_duplicate else "duplicate",
+        "paid_item_ids": paid_ids,
+        "is_duplicate": is_duplicate,
+    }
+
+
 @router.delete("/{order_id}", status_code=status.HTTP_204_NO_CONTENT)
 def cancel_order(order_id: int, db: Session = Depends(get_db), user: User = Depends(require_manager)):
     order = db.query(Order).filter(Order.id == order_id).first()
@@ -325,6 +424,7 @@ def cancel_order(order_id: int, db: Session = Depends(get_db), user: User = Depe
     order.closed_by = user.id
     _audit(db, order_id, "ORDER_CANCELLED", waiter_id=user.id)
     db.commit()
+    broadcast_sync("order_closed", {"order_id": order_id, "table_id": order.table_id})
 
 
 @router.put("/{order_id}/assign-waiter")
@@ -444,6 +544,7 @@ def transfer_order(
            note=f"Transferred from table {old_table_id} to table {body.target_table_id}")
     db.commit()
     db.refresh(order)
+    broadcast_sync("order_updated", {"order_id": order.id, "table_id": order.table_id, "old_table_id": old_table_id, "status": order.status, "action": "transferred"})
     return order
 
 
@@ -517,6 +618,8 @@ def merge_order(
 
     db.commit()
     db.refresh(target)
+    broadcast_sync("order_updated", {"order_id": target.id, "table_id": target.table_id, "status": target.status, "action": "merged"})
+    broadcast_sync("order_closed", {"order_id": source.id, "table_id": source.table_id})
     return target