scripts/dotnet/MiniMaxAIDocx.Core/Validation/BusinessRuleValidator.cs
GitHubusing System.IO.Compression;
using System.Xml.Linq;
namespace MiniMaxAIDocx.Core.Validation;
public class BusinessRuleValidator
{
private static readonly XNamespace W = "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
private static readonly XNamespace R = "http://schemas.openxmlformats.org/officeDocument/2006/relationships";
private static readonly XNamespace WP = "http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing";
private static readonly XNamespace A = "http://schemas.openxmlformats.org/drawingml/2006/main";
private const int MinMarginDxa = 360; // 0.25 inch
private const int MaxMarginDxa = 4320; // 3 inches
private const int MinBodyFontHps = 16; // 8pt
private const int MaxBodyFontHps = 144; // 72pt
private const int MinHeadingFontHps = 20; // 10pt
private const int MaxHeadingFontHps = 192; // 96pt
public ValidationResult Validate(string docxPath)
{
var result = new ValidationResult();
using var zip = ZipFile.OpenRead(docxPath);
var docEntry = zip.GetEntry("word/document.xml")
?? throw new InvalidOperationException("Missing word/document.xml");
var doc = LoadXml(docEntry);
var body = doc.Root?.Element(W + "body");
if (body == null)
{
result.Errors.Add(Error("Document has no body element"));
return result;
}
ValidateMargins(body, result);
ValidateFontSizes(body, result);
ValidateHeadingHierarchy(body, result);
ValidateTableColumnWidths(body, result);
ValidateRelationships(zip, doc, result);
ValidateComments(zip, result);
return result;
}
private void ValidateMargins(XElement body, ValidationResult result)
{
foreach (var sectPr in body.Descendants(W + "sectPr"))
{
var pgMar = sectPr.Element(W + "pgMar");
if (pgMar == null) continue;
foreach (var attr in new[] { "top", "bottom", "left", "right" })
{
var val = (string?)pgMar.Attribute(W + attr);
if (val != null && int.TryParse(val, out var dxa))
{
var absDxa = Math.Abs(dxa);
if (absDxa < MinMarginDxa)
result.Errors.Add(Error($"Margin '{attr}' is {absDxa} DXA ({absDxa / 1440.0:F2}\"), below minimum {MinMarginDxa} DXA"));
if (absDxa > MaxMarginDxa)
result.Warnings.Add(Warning($"Margin '{attr}' is {absDxa} DXA ({absDxa / 1440.0:F2}\"), above maximum {MaxMarginDxa} DXA"));
}
}
}
}
private void ValidateFontSizes(XElement body, ValidationResult result)
{
foreach (var p in body.Descendants(W + "p"))
{
var pStyle = p.Element(W + "pPr")?.Element(W + "pStyle")?.Attribute(W + "val")?.Value;
bool isHeading = pStyle?.StartsWith("Heading", StringComparison.OrdinalIgnoreCase) == true;
foreach (var rPr in p.Descendants(W + "rPr"))
{
var szEl = rPr.Element(W + "sz");
var val = (string?)szEl?.Attribute(W + "val");
if (val != null && int.TryParse(val, out var hps))
{
int min = isHeading ? MinHeadingFontHps : MinBodyFontHps;
int max = isHeading ? MaxHeadingFontHps : MaxBodyFontHps;
if (hps < min || hps > max)
result.Warnings.Add(Warning($"Font size {hps / 2.0}pt is outside {(isHeading ? "heading" : "body")} range ({min / 2}-{max / 2}pt)"));
}
}
}
}
private void ValidateHeadingHierarchy(XElement body, ValidationResult result)
{
int lastLevel = 0;
foreach (var p in body.Descendants(W + "p"))
{
var pStyle = p.Element(W + "pPr")?.Element(W + "pStyle")?.Attribute(W + "val")?.Value;
if (pStyle == null) continue;
int level = 0;
if (pStyle.StartsWith("Heading", StringComparison.OrdinalIgnoreCase))
{
var numPart = pStyle.AsSpan(7);
if (int.TryParse(numPart, out var parsed)) level = parsed;
}
if (level > 0)
{
if (lastLevel > 0 && level > lastLevel + 1)
result.Warnings.Add(Warning($"Heading level skips from {lastLevel} to {level} (missing Heading{lastLevel + 1})"));
lastLevel = level;
}
}
}
private void ValidateTableColumnWidths(XElement body, ValidationResult result)
{
var sectPr = body.Element(W + "sectPr");
if (sectPr == null) return;
var pgSz = sectPr.Element(W + "pgSz");
var pgMar = sectPr.Element(W + "pgMar");
if (pgSz == null || pgMar == null) return;
if (!int.TryParse((string?)pgSz.Attribute(W + "w"), out var pageWidth)) return;
int.TryParse((string?)pgMar.Attribute(W + "left"), out var marginLeft);
int.TryParse((string?)pgMar.Attribute(W + "right"), out var marginRight);
var contentWidth = pageWidth - marginLeft - marginRight;
int tableIndex = 0;
foreach (var tbl in body.Descendants(W + "tbl"))
{
tableIndex++;
var firstRow = tbl.Element(W + "tr");
if (firstRow == null) continue;
int totalWidth = 0;
foreach (var tc in firstRow.Elements(W + "tc"))
{
var tcW = tc.Element(W + "tcPr")?.Element(W + "tcW");
var w = (string?)tcW?.Attribute(W + "w");
if (w != null && int.TryParse(w, out var cellWidth))
totalWidth += cellWidth;
}
if (totalWidth > 0)
{
var tolerance = contentWidth * 0.02;
if (Math.Abs(totalWidth - contentWidth) > tolerance)
result.Warnings.Add(Warning($"Table {tableIndex}: column widths sum to {totalWidth} DXA but content width is {contentWidth} DXA"));
}
}
}
private void ValidateRelationships(ZipArchive zip, XDocument doc, ValidationResult result)
{
var relsEntry = zip.GetEntry("word/_rels/document.xml.rels");
if (relsEntry == null) return;
var relDoc = LoadXml(relsEntry);
var ns = relDoc.Root?.Name.Namespace ?? XNamespace.None;
var definedIds = new HashSet<string>();
foreach (var rel in relDoc.Descendants(ns + "Relationship"))
{
var id = (string?)rel.Attribute("Id");
if (id != null) definedIds.Add(id);
}
var referencedIds = new HashSet<string>();
foreach (var el in doc.Descendants())
{
var rid = (string?)el.Attribute(R + "id") ?? (string?)el.Attribute(R + "embed");
if (rid != null) referencedIds.Add(rid);
}
foreach (var id in referencedIds.Except(definedIds))
result.Errors.Add(Error($"Reference r:id='{id}' has no matching relationship"));
foreach (var id in definedIds.Except(referencedIds))
result.Warnings.Add(Warning($"Orphaned relationship: Id='{id}' is defined but never referenced"));
}
private void ValidateComments(ZipArchive zip, ValidationResult result)
{
var commentFiles = new[] { "word/comments.xml", "word/commentsExtended.xml", "word/commentsIds.xml", "word/commentsExtensible.xml" };
var existing = commentFiles.Where(f => zip.GetEntry(f) != null).ToList();
if (existing.Count > 0 && existing.Count < 4)
{
var missing = commentFiles.Except(existing);
result.Warnings.Add(Warning($"Comments partially present. Missing: {string.Join(", ", missing)}"));
}
if (zip.GetEntry("word/comments.xml") is { } commentsEntry)
{
var commentsDoc = LoadXml(commentsEntry);
var commentIds = commentsDoc.Descendants(W + "comment")
.Select(c => (string?)c.Attribute(W + "id"))
.Where(id => id != null)
.ToHashSet();
if (zip.GetEntry("word/commentsExtended.xml") is { } extEntry)
{
var W15 = XNamespace.Get("http://schemas.microsoft.com/office/word/2012/wordml");
var extDoc = LoadXml(extEntry);
var extIds = extDoc.Descendants(W15 + "commentEx")
.Select(c => (string?)c.Attribute(W15 + "paraId"))
.Where(id => id != null)
.ToHashSet();
if (commentIds.Count > 0 && extIds.Count == 0)
result.Warnings.Add(Warning("comments.xml has entries but commentsExtended.xml has none"));
}
}
}
private static XDocument LoadXml(ZipArchiveEntry entry)
{
using var stream = entry.Open();
return XDocument.Load(stream);
}
private static ValidationError Error(string msg) => new() { Message = msg, Severity = "Error" };
private static ValidationError Warning(string msg) => new() { Message = msg, Severity = "Warning" };
}