Scenario finalisation

.gitignore

@@ -51,11 +51,7 @@ cover/
 *.mo
 *.pot
 
-# Django stuff:
-*.log
-local_settings.py
-db.sqlite3
-db.sqlite3-journal
+
 
 # Flask stuff:
 instance/

CargoHubV2/app/controllers/inventories_controller.py

@@ -66,7 +66,7 @@ def delete_inventory_endpoint(
 
 
 # locations waar een specifieke inventory is (filter)
-@router.get("/{item_reference}/locations", response_model=List[Location])
+@router.get("/{item_reference}/locations")
 def get_locations_from(
     item_reference: str = None,
     db: Session = Depends(get_db),

CargoHubV2/app/controllers/item_groups.py

@@ -40,7 +40,7 @@ def get_item_groups(
     return get_all_item_groups(db, offset, limit, sort_by, order)
 
 
-@router.put("/{id}", response_model=ItemGroupResponse)
+@router.put("/{id}")
 def update_item_group_endpoint(
     id: int,
     item_group_data: ItemGroupUpdate,

CargoHubV2/app/controllers/item_lines.py

@@ -40,7 +40,7 @@ def get_item_lines(
     return get_all_item_lines(db, offset, limit, sort_by, order)
 
 
-@router.put("/{id}", response_model=ItemLineResponse)
+@router.put("/{id}")
 def update_item_line_endpoint(
     id: int,
     item_line_data: ItemLineUpdate,

CargoHubV2/app/controllers/item_types.py

@@ -39,8 +39,7 @@ def get_item_types(
     return get_all_item_types(db, offset, limit, sort_by, order)
 
 
-
-@router.put("/{id}", response_model=ItemTypeResponse)
+@router.put("/{id}")
 def update_item_type_endpoint(
     id: int,
     item_type_data: ItemTypeUpdate,

CargoHubV2/app/controllers/orders_controller.py

@@ -12,7 +12,7 @@
 )
 
 
-@router.post("/", response_model=OrderResponse)
+@router.post("/")
 def create_order_endpoint(
     order_data: OrderCreate,
     db: Session = Depends(get_db),
@@ -35,8 +35,6 @@ def get_orders(
 ):
     if id:
         order = get_order(db, id)
-        if not order:
-            raise HTTPException(status_code=404, detail="Order not found")
         return order
     orders = get_all_orders(db, date=date, offset=offset, limit=limit, sort_by=sort_by, sort_order=sort_order)
     if not orders:
@@ -57,7 +55,7 @@ def get_order_items(
     return items
 
 
-@router.put("/{id}", response_model=OrderResponse)
+@router.put("/{id}")
 def update_order_endpoint(
     id: int,
     order_data: OrderUpdate,

CargoHubV2/app/services/inventories_service.py

@@ -8,7 +8,6 @@
 from typing import Optional
 
 
-
 def create_inventory(db: Session, inventory_data: dict):
     inventory = Inventory(**inventory_data)
     db.add(inventory)
@@ -32,7 +31,7 @@ def create_inventory(db: Session, inventory_data: dict):
 
 def get_inventory(db: Session, item_reference: str):
     try:
-        inventory = db.query(Inventory).filter(Inventory.item_reference == item_reference, Inventory.is_deleted == False).first()
+        inventory = db.query(Inventory).filter(Inventory.item_id == item_reference, Inventory.is_deleted == False).first()
         if not inventory:
             raise HTTPException(status_code=404, detail="inventory not found")
         return inventory
@@ -64,10 +63,9 @@ def get_all_inventories(
         )
 
 
-
 def update_inventory(db: Session, item_reference: str, inven_data: dict):
     try:
-        inventory = db.query(Inventory).filter(Inventory.item_reference == item_reference).first()
+        inventory = db.query(Inventory).filter(Inventory.item_id == item_reference).first()
         if not inventory:
             raise HTTPException(status_code=404, detail="Inventory not found")
 
@@ -95,12 +93,12 @@ def update_inventory(db: Session, item_reference: str, inven_data: dict):
 def delete_inventory(db: Session, item_reference: str):
     try:
         inv = db.query(Inventory).filter(
-            Inventory.item_reference == item_reference, 
+            Inventory.item_id == item_reference, 
             Inventory.is_deleted == False
         ).first()
         if not inv:
             raise HTTPException(status_code=404, detail="Inventory not found")
-        
+
         inv.is_deleted = True  # Soft delete by updating the flag
         db.commit()
     except SQLAlchemyError:
@@ -112,17 +110,15 @@ def delete_inventory(db: Session, item_reference: str):
     return {"detail": "Inventory soft deleted"}
 
 
-
 def get_locations_by_inventory(db: Session, item_reference: str):
     try:
-        inventory = db.query(Inventory).filter(Inventory.item_reference == item_reference, Inventory.is_deleted == False).first()
+        inventory = db.query(Inventory).filter(Inventory.item_id == item_reference, Inventory.is_deleted == False).first()
         if not inventory:
             raise HTTPException(status_code=404, detail="Inventory not found")
-        return [location for location in inventory.locations if not location.is_deleted]
+        return [location for location in inventory.locations]
     except SQLAlchemyError:
         db.rollback()
         raise HTTPException(
             status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
             detail="An error occurred while getting the locations."
         )
-

CargoHubV2/app/services/item_groups_service.py

@@ -41,8 +41,6 @@ def get_all_item_groups(
         )
 
 
-
-
 def update_item_group(db: Session, id: int, item_group_data: ItemGroupUpdate) -> Optional[ItemGroup]:
     item_group = get_item_group(db, id)
     if item_group:
@@ -60,4 +58,3 @@ def delete_item_group(db: Session, id: int) -> bool:
         db.commit()
         return True
     return False
-

CargoHubV2/app/services/orders_service.py

@@ -11,15 +11,17 @@
 
 
 def create_order(db: Session, order_data: dict):
+    order_data["shipment_id"] = order_data.get("shipment_id")[0]
     for item_dict in order_data["items"]:
+        # getal uit item Uid
         inventory_id = int(item_dict["item_id"].split("0")[-1])
         inventory = db.query(Inventory).filter(Inventory.id == inventory_id, Inventory.is_deleted == False).first()
         if not inventory:
-            raise HTTPException(status_code=404, detail=f"No inventory exists for item {item_dict["item_id"]} in the given order")
+            raise HTTPException(status_code=404, detail=f"No inventory exists for item {item_dict['item_id']} in the given order")
         if inventory.total_available < item_dict["amount"]:
             raise HTTPException(
-                status_code=status.HTTP_400_BAD_REQUEST,
-                detail=f"Item {item_dict["item_id"]} in order only {inventory.total_available} available, ordered {item_dict["amount"]}"
+                status_code=status.HTTP_409_CONFLICT,
+                detail=f"Item {item_dict['item_id']} in order only {inventory.total_available} available, ordered {item_dict['amount']}"
             )
         inventory.total_available -= item_dict["amount"]
         if order_data["order_status"] == "Delivered":
@@ -28,6 +30,22 @@ def create_order(db: Session, order_data: dict):
             inventory.total_ordered += item_dict["amount"]
         inventory.updated_at = datetime.now()
 
+    shipment = order_data["shipment_id"]
+    if shipment:
+        shipment = db.query(Shipment).filter(Shipment.id == shipment, Shipment.is_deleted == False).first()
+        if not shipment:
+            raise HTTPException(
+                status_code=404,
+                detail=f"Shipment with id: {shipment} does not exist")
+        if shipment.shipment_type == "I":
+            raise HTTPException(
+                status_code=409,
+                detail=f"cannot link order with an incoming shipment {shipment}")
+        if shipment.shipment_status == "Delivered":
+            raise HTTPException(
+                status_code=409,
+                detail=f"cannot link order with Delivered shipment {shipment}")
+
     order = Order(**order_data)
     db.add(order)
     try:
@@ -49,7 +67,7 @@ def create_order(db: Session, order_data: dict):
 
 
 def get_order(db: Session, id: int):
-    order = db.query(Order).filter(Order.id == id, Order.is_deleted == 0).first()
+    order = db.query(Order).filter(Order.id == id, Order.is_deleted == False).first()
     if not order:
         raise HTTPException(status_code=404, detail="Order not found")
     return order
@@ -84,11 +102,15 @@ def update_order(db: Session, id: int, order_data: OrderUpdate):
 
     old_status = order.order_status
     update_data = order_data.model_dump(exclude_unset=True)
+
+    if (old_status == "Delivered") and (update_data.get("order_status") != "Delivered"):
+        raise HTTPException(status_code=403, detail="Unable to change order status back from Delivered")
+
     if update_data.get("order_status") == "Delivered" and old_status != "Delivered":
         for item_dict in order.items:
             inventory = db.query(Inventory).filter(Inventory.item_id == item_dict["item_id"], Inventory.is_deleted == 0).first()
             if not inventory:
-                raise HTTPException(status_code=404, detail=f"No inventory exists for item {item_dict["item_id"]} in the given order")
+                raise HTTPException(status_code=404, detail=f"No inventory exists for item {item_dict['item_id']} in the given order")
             inventory.total_ordered -= item_dict["amount"]
             inventory.total_on_hand -= item_dict["amount"]
             inventory.updated_at = datetime.now()
@@ -117,14 +139,25 @@ def delete_order(db: Session, id: int):
     order = db.query(Order).filter(Order.id == id, Order.is_deleted == 0).first()
     if not order:
         raise HTTPException(status_code=404, detail="Order not found")
+
+    # bij delete de voorraaden terug veranderen
     if order.order_status != "Delivered":
         for item_dict in order.items:
-            inventory = db.query(Inventory).filter(Inventory.item_id == item_dict["item_id"], Inventory.is_deleted == 0).first()
+            inventory = db.query(Inventory).filter(Inventory.item_id == item_dict['item_id'], Inventory.is_deleted == 0).first()
             if not inventory:
-                raise HTTPException(status_code=404, detail=f"No inventory exists for item {item_dict["item_id"]} in the given order")
+                raise HTTPException(status_code=404, detail=f"No inventory exists for item {item_dict['item_id']} in the given order")
             inventory.total_ordered -= item_dict["amount"]
             inventory.total_available += item_dict["amount"]
             inventory.updated_at = datetime.now()
+    else:
+        for item_dict in order.items:
+            inventory = db.query(Inventory).filter(Inventory.item_id == item_dict['item_id'], Inventory.is_deleted == 0).first()
+            if not inventory:
+                raise HTTPException(status_code=404, detail=f"No inventory exists for item {item_dict['item_id']} in the given order")
+            inventory.total_available += item_dict["amount"]
+            inventory.total_on_hand += item_dict["amount"]
+            inventory.updated_at = datetime.now()
+
     try:
         order.is_deleted = True  # Soft delete by updating the flag
         db.commit()
@@ -143,7 +176,7 @@ def get_items_in_order(db: Session, id: int):
         raise HTTPException(
             status_code=404, detail="No items found for this order"
         )
-    return [item for item in order.items if not item.is_deleted]
+    return [item for item in order.items]
 
 
 def get_packinglist_for_order(db: Session, order_id: int):

integratie-tests/TestClientsResource.py

@@ -10,7 +10,7 @@ def setUp(self):
         self.client = Client()
         self.client.headers = {"api-key": "a1b2c3d4e5", "content-type": "application/json"}
 
-        self.TEST_ID = 9837
+        self.TEST_ID = 9838
 
         self.TEST_BODY = {
             "id": self.TEST_ID,

integratie-tests/TestDocksResource.py

@@ -10,7 +10,7 @@ def setUpClass(self):
         self.client.headers = {"api-key": "a1b2c3d4e5", "content-type": "application/json"}
         self.TEST_BODY = {
             "warehouse_id": 1,
-            "code": "DCK001",
+            "code": "DCK002",
             "status": "Free",
             "description": "Test Dock"
         }
@@ -32,7 +32,7 @@ def test_2_get_docks(self):
         self.assertEqual(response.status_code, 200)
 
     def test_3_get_dock(self):
-        response = self.client.get(f"{self.baseUrl}?code=DCK001")
+        response = self.client.get(f"{self.baseUrl}?code=DCK002")
         self.assertEqual(response.status_code, 200)
         body = response.json()
         self.assertEqual(body.get("code"), self.TEST_BODY["code"])
@@ -45,7 +45,7 @@ def test_4_put_dock(self):
         self.assertEqual(response.status_code, 200)
 
         # Fetch again by code to verify changes
-        response = self.client.get(f"{self.baseUrl}?code=DCK001")
+        response = self.client.get(f"{self.baseUrl}?code=DCK002")
         self.assertEqual(response.status_code, 200)
         body = response.json()
         self.assertEqual(body.get("status"), self.ToPut["status"])
@@ -58,7 +58,7 @@ def test_5_delete_dock(self):
         self.assertEqual(response.status_code, 200)
 
         # After deleting, getting by code should return 404
-        response = self.client.get(f"{self.baseUrl}?code=DCK001")
+        response = self.client.get(f"{self.baseUrl}?code=DCK002")
         self.assertEqual(response.status_code, 404)
 
     def test_6_no_key(self):

integratie-tests/TestInventoriesResource.py

@@ -10,10 +10,11 @@ def setUp(self):
         self.client = Client()
         self.client.headers = {"api-key": "a1b2c3d4e5", "Content-Type": "application/json"}
 
-        self.TEST_ID = 11722
+        self.TEST_ID = 11721
 
         self.TEST_BODY = {
-            "item_id": "p000000",
+            "id": self.TEST_ID,
+            "item_id": "P000000",
             "description": "Down-sized system-worthy productivity",
             "item_reference": "tijdelijke-item",
             "total_on_hand": 334,
@@ -27,7 +28,6 @@ def setUp(self):
                         26883, 9308, 22330, 14470, 8871,
                         8326, 18266, 17880, 33186, 33547],
             "is_deleted": False
-
         }
 
         self.ToPut = {
@@ -72,7 +72,7 @@ def test_2_get_inventories(self):
         self.assertEqual(len(body), 100)
 
     def test_3_get_inventory(self):
-        response = self.client.get(f"{self.baseUrl}?item_reference=tijdelijke-item")
+        response = self.client.get(f"{self.baseUrl}?item_reference=P000000")
 
         self.assertEqual(response.status_code, 200)
         body = response.json()
@@ -84,7 +84,7 @@ def test_3_get_inventory(self):
 
     def test_4_put_inventory(self):
         response = self.client.put(
-            f"{self.baseUrl}tijdelijke-item", json=self.ToPut)
+            f"{self.baseUrl}P000000", json=self.ToPut)
 
         self.assertEqual(response.status_code, 200)
 
@@ -98,24 +98,29 @@ def test_4_put_inventory(self):
                          self.ToPut["total_ordered"])
         self.assertTrue(match_date(body.get("updated_at"), date.today()))
 
-    def test_5_delete_inventory(self):
+    def test_5_get_locations(self):
+        response = self.client.get(
+            f"{self.baseUrl}P000000/locations")
+        self.assertEqual(response.status_code, 200)
+        self.assertIn(30113, response.json())
+
+    def test_6_delete_inventory(self):
         # cleanup/teardown
-        response = self.client.delete(f"{self.baseUrl}tijdelijke-item")
-        self.client.delete("http://localhost:3000/api/v2/items/tijdelijke-item")
+        response = self.client.delete(f"{self.baseUrl}P000000")
 
         self.assertEqual(response.status_code, 200)
 
         # Verify deletion
         response = self.client.get(self.baseUrl)
         self.assertFalse(check_reference_exists(response.json(), "tijdelijke-item"))
 
-    def test_6_no_key(self):
+    def test_7_no_key(self):
         self.client.headers = {"Content-Type": "application/json"}
         response = self.client.get(self.baseUrl)
 
         self.assertEqual(response.status_code, 422)
 
-    def test_7_wrong_key(self):
+    def test_8_wrong_key(self):
         self.client.headers = {"api-key": "poging", "content-type": "application/json"}
         response = self.client.get(self.baseUrl)