Update updated_word.py

updated_word.py

@@ -949,6 +949,168 @@ def handle_management_summary_fix(cell, flat_json):
     
     return replacements_made
 
+def fix_management_summary_details_column(table, flat_json):
+    """Fix the DETAILS column in Management Summary table"""
+    replacements_made = 0
+    
+    print(f"    🎯 FIX 1: Management Summary DETAILS column processing")
+    
+    # Check if this is a Management Summary table
+    table_text = ""
+    for row in table.rows[:2]:
+        for cell in row.cells:
+            table_text += get_clean_text(cell).lower() + " "
+    
+    if not ("mass management" in table_text and "details" in table_text):
+        return 0
+    
+    print(f"    ✅ Confirmed Mass Management Summary table")
+    
+    # Process each row looking for Std 5. and Std 6. with red text
+    for row_idx, row in enumerate(table.rows):
+        if len(row.cells) >= 2:
+            standard_cell = row.cells[0]
+            details_cell = row.cells[1]
+            
+            standard_text = get_clean_text(standard_cell).strip()
+            
+            # Look for Std 5. Verification and Std 6. Internal Review specifically
+            if "Std 5." in standard_text and "Verification" in standard_text:
+                if has_red_text(details_cell):
+                    print(f"      🔍 Found Std 5. Verification with red text")
+                    
+                    # Use the exact data from your JSON
+                    json_value = find_matching_json_value("Std 5. Verification", flat_json)
+                    if json_value is not None:
+                        replacement_text = get_value_as_string(json_value, "Std 5. Verification")
+                        cell_replacements = replace_red_text_in_cell(details_cell, replacement_text)
+                        replacements_made += cell_replacements
+                        print(f"      ✅ Replaced Std 5. Verification details")
+            
+            elif "Std 6." in standard_text and "Internal Review" in standard_text:
+                if has_red_text(details_cell):
+                    print(f"      🔍 Found Std 6. Internal Review with red text")
+                    
+                    # Use the exact data from your JSON
+                    json_value = find_matching_json_value("Std 6. Internal Review", flat_json)
+                    if json_value is not None:
+                        replacement_text = get_value_as_string(json_value, "Std 6. Internal Review")
+                        cell_replacements = replace_red_text_in_cell(details_cell, replacement_text)
+                        replacements_made += cell_replacements
+                        print(f"      ✅ Replaced Std 6. Internal Review details")
+    
+    return replacements_made
+
+def fix_operator_declaration_empty_values(table, flat_json):
+    """Fix Operator Declaration table when values are empty"""
+    replacements_made = 0
+    
+    print(f"    🎯 FIX 2: Operator Declaration empty values processing")
+    
+    # Check if this is an Operator Declaration table
+    table_context = ""
+    for row in table.rows:
+        for cell in row.cells:
+            table_context += get_clean_text(cell).lower() + " "
+    
+    if not ("print name" in table_context and "position title" in table_context):
+        return 0
+    
+    print(f"    ✅ Confirmed Operator Declaration table")
+    
+    # Find the data row with Print Name and Position Title
+    for row_idx, row in enumerate(table.rows):
+        if len(row.cells) >= 2:
+            cell1_text = get_clean_text(row.cells[0]).strip().lower()
+            cell2_text = get_clean_text(row.cells[1]).strip().lower()
+            
+            # Check if this is the header row
+            if "print name" in cell1_text and "position" in cell2_text:
+                print(f"      📌 Found header row at {row_idx + 1}")
+                
+                # Look for the data row (next row)
+                if row_idx + 1 < len(table.rows):
+                    data_row = table.rows[row_idx + 1]
+                    if len(data_row.cells) >= 2:
+                        name_cell = data_row.cells[0]
+                        position_cell = data_row.cells[1]
+                        
+                        # Check if cells are empty or have red text
+                        name_text = get_clean_text(name_cell).strip()
+                        position_text = get_clean_text(position_cell).strip()
+                        
+                        print(f"      📋 Current values: Name='{name_text}', Position='{position_text}'")
+                        
+                        # Fix Print Name if empty or has red text
+                        if not name_text or has_red_text(name_cell):
+                            print(f"      🔧 Fixing empty/red Print Name")
+                            
+                            # Try multiple sources for operator name
+                            name_sources = [
+                                "Operator Declaration.Print Name",
+                                "Print Name", 
+                                "Operator name (Legal entity)",
+                                "(print accreditation name)"
+                            ]
+                            
+                            for source in name_sources:
+                                name_value = find_matching_json_value(source, flat_json)
+                                if name_value is not None:
+                                    name_replacement = get_value_as_string(name_value)
+                                    if name_replacement.strip():
+                                        # Extract just the name if it's a company name
+                                        if "Pty Ltd" in name_replacement or "Company" in name_replacement:
+                                            # Try to get individual name instead
+                                            continue
+                                        
+                                        if has_red_text(name_cell):
+                                            cell_replacements = replace_red_text_in_cell(name_cell, name_replacement)
+                                        else:
+                                            # Cell is empty, add text directly
+                                            name_cell.text = name_replacement
+                                            cell_replacements = 1
+                                        
+                                        replacements_made += cell_replacements
+                                        print(f"      ✅ Fixed Print Name with: '{name_replacement}' (from {source})")
+                                        break
+                        
+                        # Fix Position Title if empty or has red text  
+                        if not position_text or has_red_text(position_cell):
+                            print(f"      🔧 Fixing empty/red Position Title")
+                            
+                            # Try multiple sources for position
+                            position_sources = [
+                                "Operator Declaration.Position Title",
+                                "Position Title"
+                            ]
+                            
+                            for source in position_sources:
+                                position_value = find_matching_json_value(source, flat_json)
+                                if position_value is not None:
+                                    position_replacement = get_value_as_string(position_value)
+                                    if position_replacement.strip():
+                                        
+                                        if has_red_text(position_cell):
+                                            cell_replacements = replace_red_text_in_cell(position_cell, position_replacement)
+                                        else:
+                                            # Cell is empty, add text directly
+                                            position_cell.text = position_replacement
+                                            cell_replacements = 1
+                                        
+                                        replacements_made += cell_replacements
+                                        print(f"      ✅ Fixed Position Title with: '{position_replacement}' (from {source})")
+                                        break
+                            
+                            # Fallback: use "Manager" if nothing found
+                            if not position_text and not has_red_text(position_cell):
+                                position_cell.text = "Manager"
+                                replacements_made += 1
+                                print(f"      ✅ Used fallback Position Title: 'Manager'")
+                
+                break  # Found the table, stop looking
+    
+    return replacements_made
+
 def process_tables(document, flat_json):
     """Your original function with ALL surgical fixes added"""
     replacements_made = 0
@@ -969,6 +1131,8 @@ def process_tables(document, flat_json):
         
         if has_management and has_details:
             print(f"    📋 Detected Management Summary table")
+            summary_fixes = fix_management_summary_details_column(table, flat_json)
+            replacements_made += summary_fixes
             # Process each cell in the table to find red text and apply the existing fix
             summary_replacements = 0
             for row_idx, row in enumerate(table.rows):
@@ -1115,8 +1279,12 @@ def process_tables(document, flat_json):
         if len(table.rows) <= 4:  # Only small tables
             declaration_fix = handle_operator_declaration_fix(table, flat_json)
             replacements_made += declaration_fix
-    
-    return replacements_made
+    # Check for declaration tables that need fixing
+    if "print name" in table_text and "position" in table_text:
+        declaration_fixes = fix_operator_declaration_empty_values(table, flat_json)
+        replacements_made += declaration_fixes
+   
+return replacements_made
 
 def process_paragraphs(document, flat_json):
     """Your original function (unchanged)"""