Update updated_word.py

updated_word.py

@@ -619,7 +619,10 @@ def fix_management_summary_details_column(table, flat_json):
 # ========================================================================
 
 def fix_operator_declaration_empty_values(table, flat_json):
-    """Fix Operator Declaration table when values are empty or need updating"""
+    """Fix Operator Declaration table when values are empty or need updating.
+    - Only update name/position cells if they're empty or contain red text.
+    - If JSON gives a combined 'Name - Position' value, split it.
+    """
     replacements_made = 0
 
     print(f"    🎯 FIX: Operator Declaration empty values processing")
@@ -635,72 +638,158 @@ def fix_operator_declaration_empty_values(table, flat_json):
 
     print(f"    ✅ Confirmed Operator Declaration table")
 
-    # Find the data row with Print Name and Position Title
+    def parse_name_and_position(value):
+        """Try to split combined name/position values into (name, position)."""
+        if value is None:
+            return None, None
+
+        # If it's a list of two items - treat as [name, position]
+        if isinstance(value, list):
+            if len(value) == 0:
+                return None, None
+            if len(value) == 1:
+                return str(value[0]).strip(), None
+            # if list has more than 1, try to use first two sensible entries
+            first = str(value[0]).strip()
+            second = str(value[1]).strip()
+            if first and second:
+                return first, second
+            # fallthrough to string join
+            value = " ".join(str(v).strip() for v in value if str(v).strip())
+
+        s = str(value).strip()
+        if not s:
+            return None, None
+
+        # Common separators: hyphen, en-dash, em-dash, comma, pipe
+        parts = re.split(r'\s+[-–—]\s+|\s*,\s*|\s*\|\s*', s)
+        if len(parts) >= 2:
+            left = parts[0].strip()
+            right = parts[1].strip()
+            # Heuristic: if right looks like a role (contains common role words) treat as position
+            role_indicators = ['manager', 'auditor', 'owner', 'director', 'supervisor',
+                               'coordinator', 'driver', 'operator', 'representative', 'chief']
+            if any(ind in right.lower() for ind in role_indicators) or len(right.split()) <= 4:
+                return left, right
+            # if left looks like a role and right looks like a name, invert
+            if any(ind in left.lower() for ind in role_indicators) and not any(ind in right.lower() for ind in role_indicators):
+                return right, left
+            # else assume left=name, right=position
+            return left, right
+
+        # No separator - try to detect "Firstname Lastname Title" (less reliable)
+        # If contains two capitalised tokens + a short token like 'Manager', split last token as position
+        tokens = s.split()
+        if len(tokens) >= 3 and tokens[-1].istitle() and any(ind in tokens[-1].lower() for ind in role_indicators):
+            return " ".join(tokens[:-1]), tokens[-1]
+
+        # fallback: treat entire string as name (no position)
+        return s, None
+
+    # Find the header row and the data row
     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)
+                # data row is next row if present
                 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}'")
 
-                        # FORCE UPDATE - prefer fully qualified keys first (exact)
-                        print(f"      🔧 FORCE updating Print Name (exact-key first)")
+                        # Retrieve JSON candidates (prefer exact qualified keys)
                         name_value = find_matching_json_value("Operator Declaration.Print Name", flat_json)
                         if name_value is None:
-                            # fallback to common alternatives
                             name_value = find_matching_json_value("Print Name", flat_json)
-                        if name_value:
-                            new_name = get_value_as_string(name_value).strip()
-                            if new_name and "Pty Ltd" not in new_name and "Company" not in new_name and "Farming" not in new_name:
-                                # attempt targeted replacement: if red exists, replace red, else set text
-                                if has_red_text(name_cell):
-                                    replace_red_text_in_cell(name_cell, new_name)
-                                else:
-                                    name_cell.text = new_name
-                                replacements_made += 1
-                                print(f"      ✅ FORCE Updated Print Name: '{name_text}' -> '{new_name}'")
-
-                        print(f"      🔧 FORCE updating Position Title (exact-key first)")
+
                         position_value = find_matching_json_value("Operator Declaration.Position Title", flat_json)
                         if position_value is None:
                             position_value = find_matching_json_value("Position Title", flat_json)
-                        if position_value:
-                            new_position = get_value_as_string(position_value).strip()
-                            if new_position:
-                                if has_red_text(position_cell):
-                                    replace_red_text_in_cell(position_cell, new_position)
-                                else:
-                                    position_cell.text = new_position
-                                replacements_made += 1
-                                print(f"      ✅ FORCE Updated Position Title: '{position_text}' -> '{new_position}'")
-
-                        # If still no updates, try alternative sources (already covered via fallback above)
+
+                        # If name_value contains both name+position, split it
+                        parsed_name_from_nameval, parsed_pos_from_nameval = parse_name_and_position(name_value) if name_value is not None else (None, None)
+
+                        # If position_value also combined, parse it
+                        parsed_name_from_posval, parsed_pos_from_posval = parse_name_and_position(position_value) if position_value is not None else (None, None)
+
+                        # Decide final name and position candidates
+                        final_name = None
+                        final_pos = None
+
+                        # Priority:
+                        # - If parsed_name_from_nameval exists, use its name part as final_name and pos part as candidate for position
+                        if parsed_name_from_nameval:
+                            final_name = parsed_name_from_nameval
+                        elif name_value is not None:
+                            final_name = get_value_as_string(name_value)
+
+                        # For position: prefer explicit position_value's parsed position,
+                        # else use parsed_pos_from_nameval if present
+                        if parsed_pos_from_posval:
+                            final_pos = parsed_pos_from_posval
+                        elif position_value is not None:
+                            final_pos = get_value_as_string(position_value)
+                        elif parsed_pos_from_nameval:
+                            final_pos = parsed_pos_from_nameval
+
+                        # Normalize to strings (strip)
+                        if isinstance(final_name, list):
+                            final_name = " ".join(str(x) for x in final_name).strip()
+                        if isinstance(final_pos, list):
+                            final_pos = " ".join(str(x) for x in final_pos).strip()
+                        if isinstance(final_name, str):
+                            final_name = final_name.strip()
+                        if isinstance(final_pos, str):
+                            final_pos = final_pos.strip()
+
+                        # Filters to avoid writing company names into name slot
+                        def looks_like_person(name_str):
+                            if not name_str: 
+                                return False
+                            bad_phrases = ["pty ltd", "company", "farming", "p/l", "plc"]
+                            low = name_str.lower()
+                            if any(bp in low for bp in bad_phrases):
+                                return False
+                            # also ensure there is at least one space (first + last) or common pattern
+                            return len(name_str) > 1
+
+                        # Now perform replacements only if cell is empty or has red text
+                        # Update name cell
+                        if (not name_text or has_red_text(name_cell)) and final_name and looks_like_person(final_name):
+                            if has_red_text(name_cell):
+                                replace_red_text_in_cell(name_cell, final_name)
+                            else:
+                                name_cell.text = final_name
+                            replacements_made += 1
+                            print(f"      ✅ Updated Print Name -> '{final_name}'")
+
+                        # Update position cell
+                        if (not position_text or has_red_text(position_cell)) and final_pos:
+                            if has_red_text(position_cell):
+                                replace_red_text_in_cell(position_cell, final_pos)
+                            else:
+                                position_cell.text = final_pos
+                            replacements_made += 1
+                            print(f"      ✅ Updated Position Title -> '{final_pos}'")
 
                 break
 
-    # <<< PATCH: mark table processed so other handlers skip it
+    # Mark table processed so other handlers skip it
     if replacements_made > 0:
         try:
             setattr(table, "_processed_operator_declaration", True)
             print("    🔖 Marked table as processed by Operator Declaration handler")
         except Exception:
             pass
-    # <<< END PATCH
 
     return replacements_made