验证规则构建器

业务场景

问题陈述

• - 命名规范不一致
• 无效的成本代码和工作分解结构
• 数据缺失或格式错误
• 不符合规范的BIM构件

解决方案

技术实现

python
import re
from typing import Dict, Any, List, Optional, Callable
from dataclasses import dataclass, field
from enum import Enum
from datetime import date

class RuleType(Enum):
REGEX = regex
RANGE = range
ENUM = enum
CUSTOM = custom
REQUIRED = required
DATE = date
REFERENCE = reference

class Severity(Enum):
ERROR = error
WARNING = warning
INFO = info

@dataclass
class ValidationResult:
field: str
is_valid: bool
message: str
severity: Severity
value: Any = None

@dataclass
class ValidationRule:
name: str
field: str
rule_type: RuleType
pattern: str =
min_value: float = None
max_value: float = None
allowedvalues: List[Any] = field(defaultfactory=list)
custom_func: Callable = None
severity: Severity = Severity.ERROR
message: str =
enabled: bool = True

class ValidationRulesBuilder:
构建并执行施工数据的验证规则。

# 施工数据预定义模式
PATTERNS = {
wbs_code: r^[0-9]{2}\.[0-9]{2}\.[0-9]{2}(\.[0-9]{2})?$,
cost_code: r^[A-Z]{1,3}-[0-9]{3,6}$,
activity_id: r^[A-Z]{1,3}[0-9]{4,6}$,
drawing_number: r^[A-Z]{1,2}-[0-9]{3}-[A-Z0-9]{2,4}$,
specification_section: r^[0-9]{2}\s?[0-9]{2}\s?[0-9]{2}(\.[0-9]{2})?$,
levelname: r^(Level|L|FL)\s?[-]?\s?([0-9]{1,3}|B[0-9]|R|G|M)$,
grid_line: r^[A-Z]\.?[0-9]?$|^[0-9]{1,2}\.?[A-Z]?$,
revision: r^[A-Z]$|^[0-9]{1,2}$|^Rev\.?\s?[A-Z0-9]+$,
date_iso: r^\d{4}-\d{2}-\d{2}$,
email: r^[\w\.-]+@[\w\.-]+\.\w+$,
phone: r^\+?[0-9]{1,3}[-.\s]?[0-9]{3,4}[-.\s]?[0-9]{4}$,
}

def init(self):
self.rules: List[ValidationRule] = []
self.custom_patterns: Dict[str, str] = {}

def addregexrule(self,
name: str,
field: str,
pattern: str,
message: str = ,
severity: Severity = Severity.ERROR) -> ValidationRulesBuilder:
添加正则表达式验证规则。

self.rules.append(ValidationRule(
name=name,
field=field,
rule_type=RuleType.REGEX,
pattern=pattern,
message=message or f字段{field}不匹配模式,
severity=severity
))
return self

def addrangerule(self,
name: str,
field: str,
min_value: float = None,
max_value: float = None,
message: str = ,
severity: Severity = Severity.ERROR) -> ValidationRulesBuilder:
添加数值范围验证规则。

self.rules.append(ValidationRule(
name=name,
field=field,
rule_type=RuleType.RANGE,
minvalue=minvalue,
maxvalue=maxvalue,
message=message or f字段{field}超出范围[{minvalue}, {maxvalue}],
severity=severity
))
return self

def addenumrule(self,
name: str,
field: str,
allowed_values: List[Any],
message: str = ,
severity: Severity = Severity.ERROR) -> ValidationRulesBuilder:
添加枚举验证规则。

self.rules.append(ValidationRule(
name=name,
field=field,
rule_type=RuleType.ENUM,
allowedvalues=allowedvalues,
message=message or f字段{field}必须为以下值之一：{allowed_values},
severity=severity
))
return self

def addrequiredrule(self,
name: str,
field: str,
message: str = ,
severity: Severity = Severity.ERROR) -> ValidationRulesBuilder:
添加必填字段验证规则。

self.rules.append(ValidationRule(
name=name,
field=field,
rule_type=RuleType.REQUIRED,
message=message or f字段{field}为必填项,
severity=severity
))
return self

def addcustomrule(self,
name: str,
field: str,
func: Callable[[Any], bool],
message: str = ,
severity: Severity = Severity.ERROR) -> ValidationRulesBuilder:
添加自定义验证函数。

self.rules.append(ValidationRule(
name=name,
field=field,
rule_type=RuleType.CUSTOM,
custom_func=func,
message=message or f字段{field}未通过自定义验证,
severity=severity
))
return self

def add_pattern(self, name: str, pattern: str):
添加可复用的自定义模式。
self.custom_patterns[name] = pattern

def use_pattern(self,
rule_name: str,
field: str,
pattern_name: str,
message: str = ,
severity: Severity = Severity.ERROR) -> ValidationRulesBuilder:
使用预定义或自定义模式。

pattern = self.custompatterns.get(patternname) or self.PATTERNS.get(pattern_name)
if not pattern:
raise ValueError(f未找到模式{pattern_name})

return self.addregexrule(rule_name, field, pattern, message, severity)

def validate_record(self, record: Dict[str, Any]) -> List[ValidationResult]:
根据所有规则验证单条记录。

results = []

for rule in self.rules:
if not rule.enabled:
continue

value = record.get(rule.field)
result = self.applyrule(rule, value)
results.append(result)

return results

def validate_records(self, records: List[Dict[str, Any]]) -> Dict[str, Any]:
验证多条记录并返回摘要。

all_results = []
error_count = 0
warning_count = 0

for i, record in enumerate(records):
recordresults = self.validaterecord(record)
for result in record_results:
if not result.is_valid:
result_dict = {
record_index: i,
field: result.field,
message: result.message,
severity: result.severity.value,
value: result.value
}
allresults.append(resultdict)

if result.severity == Severity.ERROR:
error_count += 1
elif result.severity == Severity.WARNING:
warning_count += 1

return {
total_records: len(records),
validrecords: len(records) - len(set(r[recordindex] for r in all_results if r[severity] == error)),
errorcount: errorcount,
warningcount: warningcount,
issues: all_results
}

def applyrule(self, rule: ValidationRule, value: Any) -> ValidationResult:
应用单条验证规则。

if rule.rule_type == RuleType.REQUIRED:
is_valid = value is not None and value != and value != []
return ValidationResult(
field=rule.field,
isvalid=isvalid,
message= if is_valid else rule.message,
severity=rule.severity,
value=value
)

# 如果值为None/空，跳过其他验证
if value is