finalize Catering Service

src/EzLanManager.py

@@ -12,6 +12,7 @@ from src.ez_lan_manager.services.SeatingService import SeatingService
 from src.ez_lan_manager.services.TicketingService import TicketingService
 from src.ez_lan_manager.services.UserService import UserService
 from src.ez_lan_manager.types.CateringMenuItem import CateringMenuItemCategory, CateringMenuItem
+from src.ez_lan_manager.types.CateringOrder import CateringOrderStatus
 
 logger = logging.getLogger(__name__.split(".")[-1])
 
@@ -29,7 +30,6 @@ if __name__ == "__main__":
     ticketing_service = TicketingService(lan_info, db_service, accounting_service)
     seating_service = SeatingService(seating_config, lan_info, db_service, ticketing_service)
     catering_service = CateringService(db_service, accounting_service, user_service)
-    #print(catering_service.get_menu())
 
     # catering_service.place_order(
     #     {

src/ez_lan_manager/services/CateringService.py

@@ -41,20 +41,26 @@ class CateringService:
         logger.info(f"User '{order.customer.user_name}' (ID:{order.customer.user_id}) ordered from catering for {self._accounting_service.make_euro_string_from_int(total_price)}")
         return order
 
-    def update_order_status(self, order_id: int, new_status: CateringOrderStatus) -> None:
+    def update_order_status(self, order_id: int, new_status: CateringOrderStatus) -> bool:
-        pass
+        if new_status == CateringOrderStatus.CANCELED:
+            # Cancelled orders need to be refunded
+            raise CateringError("Orders cannot be canceled this way, use CateringService.cancel_order")
+        return self._db_service.change_order_status(order_id, new_status)
 
     def get_orders(self) -> list[CateringOrder]:
-        pass
+        return self._db_service.get_orders()
 
     def get_orders_for_user(self, user_id: int) -> list[CateringOrder]:
-        pass
+        return self._db_service.get_orders(user_id=user_id)
 
     def get_orders_by_status(self, status: CateringOrderStatus) -> list[CateringOrder]:
-        pass
+        return self._db_service.get_orders(status=status)
 
-    def cancel_order(self, order: CateringOrder) -> None:
+    def cancel_order(self, order: CateringOrder) -> bool:
-        pass
+        if self._db_service.change_order_status(order.order_id, CateringOrderStatus.CANCELED):
+            self._accounting_service.add_balance(order.customer.user_id, order.price, f"CATERING REFUND - {order.order_id}")
+            return True
+        return False
 
     # MENU ITEMS
 

src/ez_lan_manager/services/DatabaseService.py

@@ -410,3 +410,75 @@ class DatabaseService:
         except Exception as e:
             logger.warning(f"Error placing order: {e}")
             return
+
+    def change_order_status(self, order_id: int, status: CateringOrderStatus) -> bool:
+        cursor = self._get_cursor()
+        try:
+            cursor.execute(
+                "UPDATE orders SET status = ? WHERE order_id = ?;",
+                (status.value, order_id)
+            )
+            affected_rows = cursor.rowcount
+            self._connection.commit()
+        except Exception as e:
+            logger.warning(f"Error updating menu item: {e}")
+            return False
+        return bool(affected_rows)
+
+    def get_orders(self, user_id: Optional[int] = None, status: Optional[CateringOrderStatus] = None) -> list[CateringOrder]:
+        fetched_orders = []
+        query = "SELECT * FROM orders LEFT JOIN users ON orders.user = users.user_id"
+        if user_id is not None and status is None:
+            query += f" WHERE user = {user_id};"
+        elif status is not None and user_id is None:
+            query += f" WHERE status = '{status.value}';"
+        elif status is not None and user_id is not None:
+            query += f" WHERE user = {user_id} AND status = '{status.value}';"
+        else:
+            query += ";"
+        cursor = self._get_cursor()
+        try:
+            cursor.execute(query)
+        except Exception as e:
+            logger.warning(f"Error getting orders: {e}")
+            return fetched_orders
+
+        for raw_order in cursor.fetchall():
+            fetched_orders.append(
+                CateringOrder(
+                    order_id=raw_order[0],
+                    status=CateringOrderStatus(raw_order[1]),
+                    customer=self._map_db_result_to_user(raw_order[5:]),
+                    items=self.get_menu_items_for_order(raw_order[0]),
+                    is_delivery=bool(raw_order[4]),
+                    order_date=raw_order[3],
+                )
+            )
+
+        return fetched_orders
+
+    def get_menu_items_for_order(self, order_id: int) -> CateringMenuItemsWithAmount:
+        cursor = self._get_cursor()
+        result = {}
+        try:
+            cursor.execute(
+                "SELECT * FROM order_catering_menu_item "
+                "LEFT JOIN catering_menu_items ON order_catering_menu_item.catering_menu_item_id = catering_menu_items.catering_menu_item_id "
+                "WHERE order_id = ?;",
+                (order_id, )
+            )
+        except Exception as e:
+            logger.warning(f"Error getting order items: {e}")
+            return result
+
+        for order_catering_menu_item_raw in cursor.fetchall():
+            result[CateringMenuItem(
+                item_id=order_catering_menu_item_raw[1],
+                name=order_catering_menu_item_raw[4],
+                additional_info=order_catering_menu_item_raw[5],
+                price=order_catering_menu_item_raw[6],
+                category=CateringMenuItemCategory(order_catering_menu_item_raw[7]),
+                is_disabled=bool(order_catering_menu_item_raw[8])
+            )] = order_catering_menu_item_raw[2]
+
+        return result