Update updated_word.py

updated_word.py

@@ -878,6 +878,7 @@ def handle_management_summary_fix(cell, flat_json):
 def handle_operator_declaration_fix(table, flat_json):
     """Wrapper for small declaration tables. Delegate to canonical fix first.
     If canonical did not change anything, fall back to the small-table auditor handling.
+    Safeguards: do not replace with date-like values; prefer person/role candidates.
     """
     replacements_made = 0
 
@@ -886,7 +887,7 @@ def handle_operator_declaration_fix(table, flat_json):
         print(f"    ⏭️ Skipping - Operator Declaration table already processed")
         return 0
 
-    # only intended for small tables; if large, skip (your original condition)
+    # only intended for small tables; if large, skip
     if len(table.rows) > 4:
         return 0
 
@@ -897,46 +898,121 @@ def handle_operator_declaration_fix(table, flat_json):
         # canonical handled it and set the processed flag
         return replacements_made
 
+    # --- Helper validators (local, minimal, safe) ---
+    def is_date_like(s: str) -> bool:
+        if not s:
+            return False
+        s = s.strip()
+        # common tokens that indicate a date string
+        month_names = r"(jan|feb|mar|apr|may|jun|jul|aug|sep|sept|oct|nov|dec|january|february|march|april|may|june|july|august|september|october|november|december)"
+        # patterns: "2nd November 2023", "02/11/2023", "2023-11-02", "November 2023", "Date"
+        if re.search(r"\bDate\b", s, re.IGNORECASE):
+            return True
+        if re.search(r"\b\d{1,2}(?:st|nd|rd|th)?\b\s+" + month_names, s, re.IGNORECASE):
+            return True
+        if re.search(month_names + r".*\b\d{4}\b", s, re.IGNORECASE):
+            return True
+        if re.search(r"\b\d{1,2}[\/\.\-]\d{1,2}[\/\.\-]\d{2,4}\b", s):
+            return True
+        if re.search(r"\b\d{4}[\/\.\-]\d{1,2}[\/\.\-]\d{1,2}\b", s):
+            return True
+        # single 4-digit year alone
+        if re.fullmatch(r"\d{4}", s):
+            return True
+        return False
+
+    def looks_like_person_name(s: str) -> bool:
+        if not s:
+            return False
+        low = s.lower().strip()
+        # reject org/company terms
+        bad_terms = ["pty ltd", "p/l", "plc", "company", "farming", "farm", "trust", "ltd"]
+        if any(bt in low for bt in bad_terms):
+            return False
+        # minimal length check and presence of alphabetic characters
+        if len(low) < 3:
+            return False
+        return bool(re.search(r"[a-zA-Z]", low))
+
+    def looks_like_position(s: str) -> bool:
+        if not s:
+            return False
+        low = s.lower()
+        roles = ["manager", "auditor", "owner", "director", "supervisor", "coordinator", "driver", "operator", "representative", "chief"]
+        return any(r in low for r in roles)
+
     # fallback: original small-table behaviour (auditor declaration etc.)
-    # (This mirrors your earlier auditor-specific logic but will not run if canonical updated table)
     print(f"    🎯 Processing other declaration table (fallback small-table behavior)")
 
     for row_idx, row in enumerate(table.rows):
         for cell_idx, cell in enumerate(row.cells):
-            if has_red_text(cell):
-                declaration_fields = [
-                    "NHVAS Approved Auditor Declaration.Print Name",
-                    "Auditor name",
-                    "Signature",
-                    "Date"
-                ]
+            if not has_red_text(cell):
+                # do not overwrite non-red content in fallback
+                continue
 
-                replaced = False
-                for field in declaration_fields:
-                    field_value = find_matching_json_value(field, flat_json)
-                    if field_value is not None:
-                        replacement_text = get_value_as_string(field_value, field)
-                        if replacement_text.strip():
-                            cell_replacements = replace_red_text_in_cell(cell, replacement_text)
-                            if cell_replacements > 0:
-                                replacements_made += cell_replacements
-                                print(f"      ✅ Fixed declaration field: {field}")
-                                replaced = True
-                                break
+            # Try auditor-specific fields first
+            declaration_fields = [
+                "NHVAS Approved Auditor Declaration.Print Name",
+                "Auditor name",
+                "Signature",
+                "Date"
+            ]
+
+            replaced_this_cell = False
+            for field in declaration_fields:
+                field_value = find_matching_json_value(field, flat_json)
+                if field_value is None:
+                    continue
 
-                if not replaced:
-                    red_text = ""
-                    for paragraph in cell.paragraphs:
-                        for run in paragraph.runs:
-                            if is_red(run):
-                                red_text += run.text
+                replacement_text = get_value_as_string(field_value, field).strip()
+                if not replacement_text:
+                    continue
 
-                    if "signature" in red_text.lower():
-                        cell_replacements = replace_red_text_in_cell(cell, "[Signature]")
+                # SAFEGUARD: do not replace with date-like text for name/position cells
+                if is_date_like(replacement_text):
+                    # allow genuinely date-targeted cells (if red text explicitly contains 'date')
+                    # but skip using a date string to fill 'name' or 'position' slots
+                    # check the red text in the cell to see if it expects a date
+                    red_text = "".join(run.text for p in cell.paragraphs for run in p.runs if is_red(run)).strip()
+                    if "date" not in red_text.lower():
+                        print(f"      ⚠️ Skipping date-like replacement for field '{field}' -> '{replacement_text[:30]}...'")
+                        continue
+
+                # Further safeguard: if replacement looks like a person or role, only then write into name/position cells
+                if (looks_like_person_name(replacement_text) or looks_like_position(replacement_text) or "signature" in field.lower() or "date" in field.lower()):
+                    # Replace only red runs (safe)
+                    cell_replacements = replace_red_text_in_cell(cell, replacement_text)
+                    if cell_replacements > 0:
                         replacements_made += cell_replacements
-                    elif "date" in red_text.lower():
-                        cell_replacements = replace_red_text_in_cell(cell, "[Date]")
+                        replaced_this_cell = True
+                        print(f"      ✅ Fixed declaration field: {field} -> '{replacement_text}'")
+                        break
+                else:
+                    # Not a person or role-looking text — skip to avoid clobbering name/position with unrelated content
+                    print(f"      ⚠️ Replacement for field '{field}' does not look like name/role, skipping: '{replacement_text[:30]}...'")
+                    continue
+
+            # If not replaced by the declared fields, try to infer from the cell's red text (date/signature fallback)
+            if not replaced_this_cell:
+                red_text = "".join(run.text for p in cell.paragraphs for run in p.runs if is_red(run)).strip().lower()
+                if "signature" in red_text:
+                    cell_replacements = replace_red_text_in_cell(cell, "[Signature]")
+                    if cell_replacements > 0:
                         replacements_made += cell_replacements
+                        print(f"      ✅ Inserted placeholder [Signature]")
+                elif "date" in red_text:
+                    # Try to find a date value in JSON for an explicit date slot else skip
+                    date_value = find_matching_json_value("Date", flat_json) or find_matching_json_value("Date of Audit", flat_json) or find_matching_json_value("Audit was conducted on", flat_json)
+                    if date_value is not None:
+                        date_text = get_value_as_string(date_value)
+                        if not is_date_like(date_text):
+                            # defensive: if the date value is not date-like, skip
+                            print(f"      ⚠️ Found date-value but not date-like, skipping: '{date_text}'")
+                        else:
+                            cell_replacements = replace_red_text_in_cell(cell, date_text)
+                            if cell_replacements > 0:
+                                replacements_made += cell_replacements
+                                print(f"      ✅ Inserted date value: '{date_text}'")
 
     # if any replacements made here, mark processed
     if replacements_made > 0: