inspection close ui

Author: dinesh-aot

compliance-api/src/compliance_api/services/inspection.py

@@ -381,7 +381,7 @@ def change_status(cls, inspection_id, status):
         # Check for pending items before closing inspection
         if status_enum == InspectionStatusEnum.CLOSED:
             pending_items = cls.get_pending_items(inspection_id)
-            _validate_inspection_can_be_closed(inspection_id, pending_items)
+            _validate_inspection_can_be_closed(pending_items)
 
         with session_scope() as session:
             InspectionModel.update_inspection(
@@ -527,7 +527,7 @@ def get_pending_items(cls, inspection_id: int):
             for mapping in enforcement_mappings:
                 enforcement_action = mapping.enforcement_action
                 enforcement_status = _check_enforcement_status(
-                    requirement.id, enforcement_action.id, enforcement_action.name
+                    requirement.id, enforcement_action.id
                 )
 
                 if enforcement_status is not None:
@@ -549,11 +549,10 @@ def get_pending_items(cls, inspection_id: int):
         return pending_items
 
 
-def _validate_inspection_can_be_closed(inspection_id: int, pending_items: list):
+def _validate_inspection_can_be_closed(pending_items: list):
     """Validate that an inspection can be closed by checking for pending items.
 
     Args:
-        inspection_id (int): The ID of the inspection to validate
         pending_items (list): The list of pending items
 
     Raises:
@@ -1388,7 +1387,7 @@ def _make_requirement_detail_object_optimized(
 
 
 def _check_enforcement_status(
-    requirement_id: int, enforcement_action_id: int, enforcement_name: str
+    requirement_id: int, enforcement_action_id: int
 ):
     """Check if an enforcement action exists and its status for a requirement."""
 
@@ -1404,9 +1403,8 @@ def _check_enforcement_status(
     check_function = enforcement_map.get(enforcement_action_id)
     if check_function:
         return check_function(requirement_id)
-    else:
-        # For enforcement actions we don't track separately (like TO_BE_DETERMINED, NOT_APPLICABLE, etc.)
-        return None
+    # For enforcement actions we don't track separately (like TO_BE_DETERMINED, NOT_APPLICABLE, etc.)
+    return None
 
 
 def _check_order_status(requirement_id: int):

compliance-api/tests/integration/api/test_inspection.py

@@ -439,11 +439,7 @@ def test_inspection_close(
     result = client.patch(
         url, data=json.dumps({"status": "CLOSED"}), headers=auth_header_super_user
     )
-    assert result.status_code == HTTPStatus.NO_CONTENT
-    result = client.patch(
-        url, data=json.dumps({"status": "OPEN"}), headers=auth_header_super_user
-    )
-    assert result.status_code == HTTPStatus.NO_CONTENT
+    assert result.status_code == HTTPStatus.UNPROCESSABLE_ENTITY
     result = client.patch(
         url, data=json.dumps({"status": "CANCELED"}), headers=auth_header_super_user
     )

compliance-api/tests/unit/test_pending_enforcements_service.py

@@ -12,31 +12,31 @@ class TestPendingEnforcementsService:
     """Test class for pending enforcements service functionality."""
 
     def test_schema_import(self):
-        """Test if we can import the PendingEnforcementSchema."""
+        """Test if we can import the PendingItemSchema."""
         try:
-            from compliance_api.schemas.inspection import PendingEnforcementSchema
-            print("✅ PendingEnforcementSchema import successful")
-            assert PendingEnforcementSchema is not None
+            from compliance_api.schemas.inspection import PendingItemSchema
+            print("✅ PendingItemSchema import successful")
+            assert PendingItemSchema is not None
         except ImportError as e:
-            pytest.fail(f"Failed to import PendingEnforcementSchema: {e}")
+            pytest.fail(f"Failed to import PendingItemSchema: {e}")
 
     def test_schema_functionality(self):
         """Test schema serialization functionality."""
         try:
-            from compliance_api.schemas.inspection import PendingEnforcementSchema
+            from compliance_api.schemas.inspection import PendingItemSchema
 
-            schema = PendingEnforcementSchema()
+            schema = PendingItemSchema()
             test_data = {
                 'requirement': {
                     'id': 1,
                     'summary': 'Test requirement'
                 },
-                'enforcement': {
+                'item': {
                     'id': 5,
                     'name': 'Order'
                 },
                 'is_created': False,
-                'enforcement_number': 'PROJ_001_O123'
+                'item_number': 'PROJ_001_O123'
             }
 
             result = schema.dump(test_data)
@@ -45,31 +45,31 @@ def test_schema_functionality(self):
 
             # Validate all fields are present in result
             assert 'requirement' in result
-            assert 'enforcement' in result
+            assert 'item' in result
             assert 'is_created' in result
-            assert 'enforcement_number' in result
+            assert 'item_number' in result
 
             # Validate nested object fields
             assert 'id' in result['requirement']
             assert 'summary' in result['requirement']
-            assert 'id' in result['enforcement']
-            assert 'name' in result['enforcement']
+            assert 'id' in result['item']
+            assert 'name' in result['item']
 
             # Validate field values
             assert result['requirement']['id'] == 1
             assert result['requirement']['summary'] == 'Test requirement'
-            assert result['enforcement']['id'] == 5
-            assert result['enforcement']['name'] == 'Order'
+            assert result['item']['id'] == 5
+            assert result['item']['name'] == 'Order'
             assert result['is_created'] is False
-            assert result['enforcement_number'] == 'PROJ_001_O123'
+            assert result['item_number'] == 'PROJ_001_O123'
 
         except (ImportError, AttributeError, AssertionError, KeyError) as e:
             pytest.fail(f"Schema functionality test failed: {e}")
 
     def test_schema_export(self):
         """Test schema export in __init__.py."""
         try:
-            from compliance_api.schemas import PendingEnforcementSchema as ImportedSchema
+            from compliance_api.schemas import PendingItemSchema as ImportedSchema
             print("✅ Schema export in __init__.py successful")
             assert ImportedSchema is not None
         except ImportError as e:
@@ -81,12 +81,12 @@ def test_service_method_exists(self):
             from compliance_api.services.inspection import InspectionService
 
             # Check if the method exists
-            assert hasattr(InspectionService, 'get_pending_enforcements'), \
-                "InspectionService should have get_pending_enforcements method"
+            assert hasattr(InspectionService, 'get_pending_items'), \
+                "InspectionService should have get_pending_items method"
 
             # Check if it's callable
-            method = getattr(InspectionService, 'get_pending_enforcements')
-            assert callable(method), "get_pending_enforcements should be callable"
+            method = getattr(InspectionService, 'get_pending_items')
+            assert callable(method), "get_pending_items should be callable"
 
             print("✅ Service method exists and is callable")
 
@@ -96,7 +96,7 @@ def test_service_method_exists(self):
     def test_helper_methods_exist(self):
         """Test that helper methods exist."""
         try:
-            from compliance_api.services.inspection import InspectionService
+            from compliance_api.services import inspection as inspection_module
 
             helper_methods = [
                 '_check_enforcement_status',
@@ -105,20 +105,20 @@ def test_helper_methods_exist(self):
                 '_check_administrative_penalty_status',
                 '_check_violation_ticket_status',
                 '_check_charge_recommendation_status',
-                '_check_restorative_justice_status'
+                '_check_inspection_record_status',
             ]
 
             for method_name in helper_methods:
-                assert hasattr(InspectionService, method_name), \
-                    f"InspectionService should have {method_name} method"
+                assert hasattr(inspection_module, method_name), \
+                    f"inspection module should have {method_name} function"
 
-                method = getattr(InspectionService, method_name)
+                method = getattr(inspection_module, method_name)
                 assert callable(method), f"{method_name} should be callable"
 
             print("✅ All helper methods exist and are callable")
 
         except ImportError as e:
-            pytest.fail(f"Failed to import InspectionService: {e}")
+            pytest.fail(f"Failed to import inspection module: {e}")
 
 
 def test_all_imports():
@@ -128,30 +128,30 @@ def test_all_imports():
         print("Testing imports...")
 
         # Test schema import
-        from compliance_api.schemas.inspection import PendingEnforcementSchema
-        print("✅ PendingEnforcementSchema import successful")
+        from compliance_api.schemas.inspection import PendingItemSchema
+        print("✅ PendingItemSchema import successful")
 
         # Test schema functionality
-        schema = PendingEnforcementSchema()
+        schema = PendingItemSchema()
         test_data = {
             'requirement': {
                 'id': 1,
                 'summary': 'Test requirement'
             },
-            'enforcement': {
+            'item': {
                 'id': 5,
                 'name': 'Order'
             },
             'is_created': False,
-            'enforcement_number': 'PROJ_001_O123'
+            'item_number': 'PROJ_001_O123'
         }
 
         result = schema.dump(test_data)
         print("✅ Schema serialization successful")
         print(f"   Result: {result}")
 
         # Test schema import in init - using ImportedSchema to avoid F401
-        from compliance_api.schemas import PendingEnforcementSchema as ImportedSchema
+        from compliance_api.schemas import PendingItemSchema as ImportedSchema
         assert ImportedSchema is not None
         print("✅ Schema export in __init__.py successful")
 

compliance-web/cypress/components/_components/_App/_Inspections/_Profile/InspectionFileActions.cy.tsx

@@ -4,6 +4,7 @@ import InspectionFileActions from "@/components/App/Inspections/Profile/Inspecti
 import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
 import { Inspection } from "@/models/Inspection";
 import ModalProvider from "@/components/Shared/Modals/ModalProvider";
+import * as useInspectionsHook from "@/hooks/useInspections";
 
 describe("InspectionFileActions Component", () => {
   let queryClient: QueryClient;
@@ -14,6 +15,9 @@ describe("InspectionFileActions Component", () => {
         queries: {
           retry: false,
         },
+        mutations: {
+          retry: false,
+        },
       },
     });
 
@@ -120,20 +124,94 @@ describe("InspectionFileActions Component", () => {
     cy.contains("button", "Cancel").should("exist").click();
   });
 
-  it("handles Closed click", () => {
+  it("handles Closed click with no pending items", () => {
+    // Stub the useCheckPendingItems hook to return empty array
+    const mockMutation = {
+      mutate: cy.stub().callsFake((id, callbacks) => {
+        // Simulate successful API call with empty result
+        setTimeout(() => {
+          callbacks.onSuccess([]);
+        }, 100);
+      }),
+      isPending: false,
+    };
+    
+    cy.stub(useInspectionsHook, "useCheckPendingItems").returns(mockMutation);
+    
     mountComponent("open");
     cy.contains("button", "Actions").click();
     cy.get("li[id='Close']").last().click();
 
-    // Verify the confirmation dialog opens
+    // Wait for the "Checking Pending Items..." modal to appear
+    cy.contains("Checking Pending Items...").should("exist");
+    
+    // Wait for the stubbed function to complete
+    cy.wait(500);
+
+    // Verify the confirmation dialog opens after the check completes
     cy.contains("Close Inspection?").should("exist");
     cy.contains("Are you sure you want to close inspection?").should("exist");
-    cy.contains("button", "Close Inspection").should("exist").click();
+    cy.contains("button", "Close Inspection").should("exist");
+    
+    // Close the modal to clean up
     cy.contains("button", "Cancel").should("exist").click();
+    cy.contains("Close Inspection?").should("not.exist");
+  });
+
+
+  it("handles Closed click with pending items", () => {
+    // Stub the useCheckPendingItems hook to return pending items
+    const pendingItems = [
+      {
+        requirement: {
+          id: 1,
+          summary: "Test requirement",
+        },
+        item: {
+          id: 5,
+          name: "Order",
+        },
+        is_created: false,
+        item_number: null,
+      },
+    ];
+
+    const mockMutation = {
+      mutate: cy.stub().callsFake((id, callbacks) => {
+        // Simulate successful API call with pending items
+        setTimeout(() => {
+          callbacks.onSuccess(pendingItems);
+        }, 100);
+      }),
+      isPending: false,
+    };
+    
+    cy.stub(useInspectionsHook, "useCheckPendingItems").returns(mockMutation);
+
+    mountComponent("open");
+    cy.contains("button", "Actions").click();
+    cy.get("li[id='Close']").last().click();
+
+    // Wait for the "Checking Pending Items..." modal to appear
+    cy.contains("Checking Pending Items...").should("exist");
+    
+    // Wait for the stubbed function to complete
+    cy.wait(500);
+
+    // Verify the blocking modal appears
+    cy.contains("Cannot Close Inspection").should("exist");
+    cy.contains("button", "Return to Inspection").should("exist").click();
+    
+    // Verify modal is closed
+    cy.contains("Cannot Close Inspection").should("not.exist");
   });
 
   it("handles Delete Inspection click", () => {
     mountComponent("open");
+    
+    // Wait a bit to ensure any previous modals are fully closed
+    cy.wait(200);
+    
     cy.contains("button", "Actions").click();
     cy.contains("Delete Inspection").click();
 
@@ -142,7 +220,10 @@ describe("InspectionFileActions Component", () => {
     cy.contains(
       "You are about to delete this inspection. Are you sure?"
     ).should("exist");
-    cy.contains("button", "Delete").should("exist").click();
+    cy.contains("button", "Delete").should("exist");
+    
+    // Close the modal to clean up
     cy.contains("button", "Cancel").should("exist").click();
+    cy.contains("Delete Inspection?").should("not.exist");
   });
 });

compliance-web/src/components/App/Inspections/Profile/Enforcements/Orders/OrderDrawer.tsx

@@ -182,7 +182,7 @@ const OrderDrawer: React.FC<OrderDrawerProps> = ({
   const onDeleteSuccess = useCallback(() => {
     onSubmit("Order deleted successfully!", true);
     reset();
-  }, [onSubmit, reset, inspection.id]);
+  }, [onSubmit, reset]);
 
   const { mutate: deleteInspectionOrder } =
     useDeleteInspectionOrder(onDeleteSuccess);

compliance-web/src/components/App/Inspections/Profile/Enforcements/WarningLetters/WarningLetterDrawer.tsx

@@ -166,7 +166,7 @@ const WarningLetterDrawer: React.FC<WarningLetterDrawerProps> = ({
   const onDeleteSuccess = useCallback(() => {
     onSubmit("Warning letter deleted successfully!", true);
     reset();
-  }, [onSubmit, reset, inspection.id]);
+  }, [onSubmit, reset]);
 
   const { mutate: deleteWarningLetter } =
     useDeleteWarningLetter(onDeleteSuccess);

compliance-web/src/components/App/Inspections/Profile/InspectionFileActions.tsx

@@ -178,13 +178,13 @@ const InspectionFileActions: React.FC<InspectionFileActionsProps> = ({
           if (checkPendingItemsMutation.isPending) {
             return; // Already checking
           }
-          
+
           setOpen({
             content: (
               <ConfirmationModal
                 title="Checking Pending Items..."
                 description="Please wait while we check for pending items..."
-                confirmButtonText="Please Wait"
+                showActions={false}
                 onConfirm={() => {}} // Disabled while loading
               />
             ),