郎速科技
609 lines
26 KiB
C#
609 lines
26 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Text.RegularExpressions;
|
|
|
|
namespace Lskj.CommandKernel
|
|
{
|
|
public sealed class BusinessAdapterReadiness
|
|
{
|
|
public string AdapterId { get; set; }
|
|
public string AdapterVersion { get; set; }
|
|
public string EvidenceId { get; set; }
|
|
public string EvidenceSha256 { get; set; }
|
|
public string AccountBook { get; set; }
|
|
public string SubSystemId { get; set; }
|
|
public string ValidatedBy { get; set; }
|
|
public DateTime ValidatedAtUtc { get; set; }
|
|
public bool CustomerConfigurationValidated { get; set; }
|
|
public bool ParameterizedReadQueriesVerified { get; set; }
|
|
public bool TransactionalWriteVerified { get; set; }
|
|
public bool PersistentIdempotencyVerified { get; set; }
|
|
public bool PermissionRecheckVerified { get; set; }
|
|
public bool WindowsIntegrationVerified { get; set; }
|
|
public bool AcceptanceManifestVerified { get; set; }
|
|
public bool AcceptanceSignatureVerified { get; set; }
|
|
public string ActivationMode { get; set; }
|
|
public bool UatAuthorizationVerified { get; set; }
|
|
|
|
public IList<string> MissingRequirements()
|
|
{
|
|
List<string> missing = new List<string>();
|
|
if (string.IsNullOrWhiteSpace(AdapterId)) missing.Add("adapter_id");
|
|
if (string.IsNullOrWhiteSpace(AdapterVersion)) missing.Add("adapter_version");
|
|
if (string.IsNullOrWhiteSpace(EvidenceId)) missing.Add("integration_evidence");
|
|
if (!CommandInputFingerprint.IsValid(EvidenceSha256)) missing.Add("integration_evidence_hash");
|
|
if (string.IsNullOrWhiteSpace(AccountBook)) missing.Add("evidence_account_book");
|
|
if (string.IsNullOrWhiteSpace(SubSystemId)) missing.Add("evidence_subsystem");
|
|
if (string.IsNullOrWhiteSpace(ValidatedBy)) missing.Add("evidence_validator");
|
|
if (ValidatedAtUtc == DateTime.MinValue) missing.Add("evidence_validation_time");
|
|
if (string.Equals(
|
|
ActivationMode,
|
|
"customer_uat",
|
|
StringComparison.Ordinal))
|
|
{
|
|
if (!UatAuthorizationVerified)
|
|
missing.Add("uat_authorization");
|
|
return missing;
|
|
}
|
|
if (!string.IsNullOrWhiteSpace(ActivationMode)
|
|
&& !string.Equals(
|
|
ActivationMode,
|
|
"commercial",
|
|
StringComparison.Ordinal))
|
|
{
|
|
missing.Add("activation_mode");
|
|
return missing;
|
|
}
|
|
if (!CustomerConfigurationValidated) missing.Add("customer_configuration");
|
|
if (!ParameterizedReadQueriesVerified) missing.Add("parameterized_read_queries");
|
|
if (!TransactionalWriteVerified) missing.Add("transactional_write");
|
|
if (!PersistentIdempotencyVerified) missing.Add("persistent_idempotency");
|
|
if (!PermissionRecheckVerified) missing.Add("permission_recheck");
|
|
if (!WindowsIntegrationVerified) missing.Add("windows_integration");
|
|
if (!AcceptanceManifestVerified) missing.Add("acceptance_manifest");
|
|
if (!AcceptanceSignatureVerified) missing.Add("acceptance_signature");
|
|
return missing;
|
|
}
|
|
}
|
|
|
|
public interface IBusinessWorkflowAdapterReadiness
|
|
{
|
|
BusinessAdapterReadiness GetReadiness();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Optional runtime readiness contract. Startup registration still uses
|
|
/// <see cref="IBusinessWorkflowAdapterReadiness"/>, while an actual
|
|
/// command rechecks readiness against the exact request session instead of
|
|
/// allowing an adapter to silently consult a mutable global ERP singleton.
|
|
/// </summary>
|
|
public interface IContextualBusinessWorkflowAdapterReadiness
|
|
{
|
|
BusinessAdapterReadiness GetReadiness(CommandExecutionContext context);
|
|
}
|
|
|
|
public sealed class AdapterPreflightIssue
|
|
{
|
|
public string Code { get; set; }
|
|
public string Message { get; set; }
|
|
public string Field { get; set; }
|
|
}
|
|
|
|
public sealed class AdapterPreflightResult
|
|
{
|
|
public AdapterPreflightResult()
|
|
{
|
|
Issues = new List<AdapterPreflightIssue>();
|
|
}
|
|
|
|
public bool Ready
|
|
{
|
|
get { return Issues.Count == 0; }
|
|
}
|
|
|
|
public bool Registered { get; internal set; }
|
|
public IList<AdapterPreflightIssue> Issues { get; private set; }
|
|
|
|
internal void Add(string code, string message, string field)
|
|
{
|
|
Issues.Add(new AdapterPreflightIssue
|
|
{
|
|
Code = code,
|
|
Message = message,
|
|
Field = field
|
|
});
|
|
}
|
|
}
|
|
|
|
public sealed class PurchaseWorkflowFieldMap
|
|
{
|
|
public string ModuleCode { get; set; }
|
|
public string SupplierCode { get; set; }
|
|
public string InvoiceNumber { get; set; }
|
|
public string InvoiceDate { get; set; }
|
|
public string CurrencyCode { get; set; }
|
|
public string MaterialCode { get; set; }
|
|
public string Unit { get; set; }
|
|
public string Quantity { get; set; }
|
|
public string UnitPrice { get; set; }
|
|
public string TaxRate { get; set; }
|
|
public string ExchangeRate { get; set; }
|
|
public string LineAmount { get; set; }
|
|
public string SourceOrderId { get; set; }
|
|
public string SourceLineId { get; set; }
|
|
}
|
|
|
|
public sealed class LeaveWorkflowFieldMap
|
|
{
|
|
public string ModuleCode { get; set; }
|
|
public string EmployeeId { get; set; }
|
|
public string LeaveTypeCode { get; set; }
|
|
public string FlowTypeCode { get; set; }
|
|
public string StartLocal { get; set; }
|
|
public string EndLocal { get; set; }
|
|
public string RequestedHours { get; set; }
|
|
public string Reason { get; set; }
|
|
}
|
|
|
|
public static class BusinessAdapterRegistrationGate
|
|
{
|
|
private static readonly Regex SafeIdentifier = new Regex(
|
|
@"^[A-Za-z_][A-Za-z0-9_]{0,127}$",
|
|
RegexOptions.Compiled | RegexOptions.CultureInvariant);
|
|
|
|
public static AdapterPreflightResult RegisterPurchase(
|
|
CommandRegistry registry,
|
|
IPurchaseInvoiceWorkflowAdapter adapter,
|
|
PurchaseInvoiceMatchOptions options,
|
|
PurchaseWorkflowFieldMap fields,
|
|
ModuleInspection inspection)
|
|
{
|
|
if (registry == null) throw new ArgumentNullException("registry");
|
|
AdapterPreflightResult result = ValidatePurchase(adapter, fields, inspection);
|
|
ValidateCommercialPurchaseOptions(options, result);
|
|
if (!result.Ready) return result;
|
|
IPurchaseInvoiceIntentResolver resolver =
|
|
adapter as IPurchaseInvoiceIntentResolver;
|
|
if (resolver == null)
|
|
{
|
|
result.Add(
|
|
"purchase_intent_resolver_missing",
|
|
"采购适配器缺少供应商、币种和物料主数据解析能力。",
|
|
null);
|
|
return result;
|
|
}
|
|
if (registry.Resolve("purchase.invoice.resolve") != null
|
|
|| registry.Resolve("purchase.invoice.create") != null)
|
|
{
|
|
result.Add("command_already_registered", "采购发票解析或创建命令已经注册。", null);
|
|
return result;
|
|
}
|
|
|
|
IPurchaseResolutionProofService proofs =
|
|
HmacPurchaseResolutionProofService.Create(new SystemClock());
|
|
registry.RegisterMany(new ICommandHandler[]
|
|
{
|
|
new PurchaseInvoiceIntentResolveCommandHandler(adapter, resolver, proofs),
|
|
new PurchaseInvoiceCreateCommandHandler(adapter, options, proofs)
|
|
});
|
|
result.Registered = true;
|
|
return result;
|
|
}
|
|
|
|
public static AdapterPreflightResult RegisterLeave(
|
|
CommandRegistry registry,
|
|
ILeaveWorkflowAdapter adapter,
|
|
LeaveValidationOptions options,
|
|
LeaveWorkflowFieldMap fields,
|
|
ModuleInspection inspection)
|
|
{
|
|
if (registry == null) throw new ArgumentNullException("registry");
|
|
AdapterPreflightResult result = ValidateLeave(adapter, fields, inspection);
|
|
if (!result.Ready) return result;
|
|
ILeaveIntentResolver resolver = adapter as ILeaveIntentResolver;
|
|
if (resolver == null)
|
|
{
|
|
result.Add(
|
|
"leave_intent_resolver_missing",
|
|
"请假适配器缺少自然语言假别与员工日历解析能力。",
|
|
null);
|
|
return result;
|
|
}
|
|
if (registry.Resolve("hr.leave.resolve") != null
|
|
|| registry.Resolve("hr.leave.create") != null
|
|
|| registry.Resolve("hr.leave.submit") != null)
|
|
{
|
|
result.Add("command_already_registered", "请假解析、创建或提交命令已经注册。", null);
|
|
return result;
|
|
}
|
|
|
|
ILeaveResolutionProofService proofs =
|
|
HmacLeaveResolutionProofService.Create(new SystemClock());
|
|
registry.RegisterMany(new ICommandHandler[]
|
|
{
|
|
new LeaveIntentResolveCommandHandler(adapter, resolver, options, proofs),
|
|
new LeaveCreateCommandHandler(adapter, options, proofs),
|
|
new LeaveSubmitCommandHandler(adapter)
|
|
});
|
|
result.Registered = true;
|
|
return result;
|
|
}
|
|
|
|
public static AdapterPreflightResult ValidatePurchase(
|
|
IPurchaseInvoiceWorkflowAdapter adapter,
|
|
PurchaseWorkflowFieldMap fields,
|
|
ModuleInspection inspection)
|
|
{
|
|
AdapterPreflightResult result = ValidateAdapterReadiness(adapter);
|
|
if (adapter != null && !(adapter is IPurchaseInvoiceIntentResolver))
|
|
{
|
|
result.Add(
|
|
"purchase_intent_resolver_missing",
|
|
"采购适配器必须实现供应商、币种和物料主数据解析契约。",
|
|
null);
|
|
}
|
|
Append(result, ValidatePurchaseFieldMap(fields, inspection));
|
|
if (fields != null && adapter != null
|
|
&& !string.Equals(
|
|
fields.ModuleCode,
|
|
adapter.ModuleCode,
|
|
StringComparison.Ordinal))
|
|
{
|
|
result.Add("module_code_mismatch", "字段映射模块编号与适配器模块编号不一致。", "moduleCode");
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public static AdapterPreflightResult ValidatePurchaseFieldMap(
|
|
PurchaseWorkflowFieldMap fields,
|
|
ModuleInspection inspection)
|
|
{
|
|
AdapterPreflightResult result = ValidateInspection(inspection, "bill");
|
|
if (fields == null)
|
|
{
|
|
result.Add("field_map_missing", "采购字段映射不能为空。", null);
|
|
return result;
|
|
}
|
|
ValidateInspectedModuleCode(fields.ModuleCode, inspection, result);
|
|
ValidateFields(
|
|
inspection,
|
|
result,
|
|
new[]
|
|
{
|
|
Mapping("supplierCode", "master", fields.SupplierCode),
|
|
Mapping("invoiceNumber", "master", fields.InvoiceNumber),
|
|
Mapping("invoiceDate", "master", fields.InvoiceDate),
|
|
Mapping("currencyCode", "master", fields.CurrencyCode),
|
|
Mapping("materialCode", "detail", fields.MaterialCode),
|
|
Mapping("unit", "detail", fields.Unit),
|
|
Mapping("quantity", "detail", fields.Quantity),
|
|
Mapping("unitPrice", "detail", fields.UnitPrice),
|
|
Mapping("taxRate", "detail", fields.TaxRate),
|
|
Mapping("exchangeRate", "detail", fields.ExchangeRate),
|
|
Mapping("lineAmount", "detail", fields.LineAmount),
|
|
Mapping("sourceOrderId", "detail", fields.SourceOrderId),
|
|
Mapping("sourceLineId", "detail", fields.SourceLineId)
|
|
});
|
|
return result;
|
|
}
|
|
|
|
public static AdapterPreflightResult ValidateLeave(
|
|
ILeaveWorkflowAdapter adapter,
|
|
LeaveWorkflowFieldMap fields,
|
|
ModuleInspection inspection)
|
|
{
|
|
AdapterPreflightResult result = ValidateAdapterReadiness(adapter);
|
|
if (adapter != null && !(adapter is ILeaveIntentResolver))
|
|
{
|
|
result.Add(
|
|
"leave_intent_resolver_missing",
|
|
"请假适配器必须实现自然语言假别与员工日历解析契约。",
|
|
null);
|
|
}
|
|
Append(result, ValidateLeaveFieldMap(fields, inspection));
|
|
if (fields != null && adapter != null
|
|
&& !string.Equals(
|
|
fields.ModuleCode,
|
|
adapter.ModuleCode,
|
|
StringComparison.Ordinal))
|
|
{
|
|
result.Add("module_code_mismatch", "字段映射模块编号与适配器模块编号不一致。", "moduleCode");
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public static AdapterPreflightResult ValidateLeaveFieldMap(
|
|
LeaveWorkflowFieldMap fields,
|
|
ModuleInspection inspection)
|
|
{
|
|
AdapterPreflightResult result = ValidateInspection(inspection, null);
|
|
if (inspection != null
|
|
&& !string.Equals(inspection.Kind, "bill", StringComparison.OrdinalIgnoreCase)
|
|
&& !string.Equals(inspection.Kind, "base", StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
result.Add("module_kind_unsupported", "请假模块必须是单据或基础档案模块。", "moduleCode");
|
|
}
|
|
if (fields == null)
|
|
{
|
|
result.Add("field_map_missing", "请假字段映射不能为空。", null);
|
|
return result;
|
|
}
|
|
ValidateInspectedModuleCode(fields.ModuleCode, inspection, result);
|
|
ValidateFields(
|
|
inspection,
|
|
result,
|
|
new[]
|
|
{
|
|
Mapping("employeeId", "master", fields.EmployeeId),
|
|
Mapping("leaveTypeCode", "master", fields.LeaveTypeCode),
|
|
Mapping("flowTypeCode", "master", fields.FlowTypeCode),
|
|
Mapping("startLocal", "master", fields.StartLocal),
|
|
Mapping("endLocal", "master", fields.EndLocal),
|
|
Mapping("requestedHours", "master", fields.RequestedHours),
|
|
Mapping("reason", "master", fields.Reason)
|
|
});
|
|
return result;
|
|
}
|
|
|
|
public static void EnsureRuntimeReady(IBusinessWorkflowAdapterReadiness adapter)
|
|
{
|
|
EnsureRuntimeReady(adapter, null);
|
|
}
|
|
|
|
public static void EnsureRuntimeReady(
|
|
IBusinessWorkflowAdapterReadiness adapter,
|
|
CommandExecutionContext context)
|
|
{
|
|
if (adapter == null)
|
|
throw new CommandKernelException(
|
|
"adapter_readiness_missing",
|
|
"业务适配器没有实现商用就绪检查。",
|
|
6);
|
|
BusinessAdapterReadiness readiness;
|
|
try
|
|
{
|
|
IContextualBusinessWorkflowAdapterReadiness contextual =
|
|
adapter as IContextualBusinessWorkflowAdapterReadiness;
|
|
readiness = context != null && contextual != null
|
|
? contextual.GetReadiness(context)
|
|
: adapter.GetReadiness();
|
|
}
|
|
catch (CommandKernelException error)
|
|
{
|
|
if (IsSafeCustomerProfileRuntimeCode(error.Code))
|
|
throw new CommandKernelException(
|
|
error.Code,
|
|
"客户画像在线目录复核未通过，写命令保持禁用。",
|
|
6);
|
|
throw new CommandKernelException(
|
|
"adapter_readiness_failed",
|
|
"业务适配器就绪检查失败，写命令保持禁用。",
|
|
6);
|
|
}
|
|
catch
|
|
{
|
|
throw new CommandKernelException(
|
|
"adapter_readiness_failed",
|
|
"业务适配器就绪检查失败，写命令保持禁用。",
|
|
6);
|
|
}
|
|
IList<string> missing = readiness == null
|
|
? new List<string> { "readiness_result" }
|
|
: readiness.MissingRequirements();
|
|
if (context != null && readiness != null
|
|
&& (!string.Equals(
|
|
readiness.AccountBook,
|
|
context.AccountBook,
|
|
StringComparison.Ordinal)
|
|
|| !string.Equals(
|
|
readiness.SubSystemId,
|
|
context.SubSystemId,
|
|
StringComparison.Ordinal)))
|
|
missing.Add("readiness_scope");
|
|
if (missing.Count > 0)
|
|
{
|
|
throw new CommandKernelException(
|
|
"adapter_not_ready",
|
|
"业务适配器未满足商用注册条件：" + string.Join(",", missing.ToArray()),
|
|
6);
|
|
}
|
|
}
|
|
|
|
private static bool IsSafeCustomerProfileRuntimeCode(string code)
|
|
{
|
|
return code == "profile_runtime_hash_mismatch"
|
|
|| code == "profile_runtime_contract_invalid"
|
|
|| code == "profile_workflow_activation_blocked"
|
|
|| code == "profile_runtime_metadata_contract_invalid"
|
|
|| code == "profile_runtime_metadata_unavailable"
|
|
|| code == "profile_runtime_metadata_changed"
|
|
|| code == "profile_critical_catalog_contract_changed"
|
|
|| code == "runtime_configuration_changed"
|
|
|| code == "runtime_configuration_unavailable";
|
|
}
|
|
|
|
private static AdapterPreflightResult ValidateAdapterReadiness(
|
|
IBusinessWorkflowAdapterReadiness adapter)
|
|
{
|
|
AdapterPreflightResult result = new AdapterPreflightResult();
|
|
if (adapter == null)
|
|
{
|
|
result.Add("adapter_missing", "业务适配器不能为空。", null);
|
|
}
|
|
else
|
|
{
|
|
try
|
|
{
|
|
BusinessAdapterReadiness readiness = adapter.GetReadiness();
|
|
IList<string> missing = readiness == null
|
|
? new List<string> { "readiness_result" }
|
|
: readiness.MissingRequirements();
|
|
foreach (string item in missing)
|
|
result.Add("adapter_requirement_missing", "业务适配器缺少商用证据：" + item, item);
|
|
}
|
|
catch (CommandKernelException error)
|
|
{
|
|
result.Add(
|
|
string.IsNullOrWhiteSpace(error.Code)
|
|
? "adapter_readiness_failed"
|
|
: error.Code,
|
|
"业务适配器就绪检查返回了安全错误代码，写命令保持禁用。",
|
|
null);
|
|
}
|
|
catch
|
|
{
|
|
result.Add("adapter_readiness_failed", "业务适配器就绪检查失败。", null);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
private static AdapterPreflightResult ValidateInspection(
|
|
ModuleInspection inspection,
|
|
string expectedKind)
|
|
{
|
|
AdapterPreflightResult result = new AdapterPreflightResult();
|
|
if (inspection == null)
|
|
{
|
|
result.Add("module_inspection_missing", "缺少模块元数据检查结果。", "moduleCode");
|
|
}
|
|
else if (!string.IsNullOrWhiteSpace(expectedKind)
|
|
&& !string.Equals(inspection.Kind, expectedKind, StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
result.Add("module_kind_mismatch", "业务适配器与低代码模块类型不匹配。", "moduleCode");
|
|
}
|
|
if (inspection != null)
|
|
{
|
|
try
|
|
{
|
|
IDictionary<string, object> diagnosis = ModuleInspector.Diagnose(inspection);
|
|
object healthy;
|
|
if (!diagnosis.TryGetValue("healthy", out healthy) || !Convert.ToBoolean(healthy))
|
|
{
|
|
result.Add(
|
|
"module_configuration_unhealthy",
|
|
"低代码模块配置诊断未通过；请先运行 modules diagnose 修复错误。",
|
|
"moduleCode");
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
result.Add(
|
|
"module_diagnosis_failed",
|
|
"无法完成低代码模块配置诊断，写命令保持禁用。",
|
|
"moduleCode");
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
private static void ValidateCommercialPurchaseOptions(
|
|
PurchaseInvoiceMatchOptions options,
|
|
AdapterPreflightResult result)
|
|
{
|
|
if (options == null
|
|
|| options.LineAmountMode == InvoiceLineAmountMode.None)
|
|
{
|
|
result.Add(
|
|
"purchase_amount_validation_required",
|
|
"采购写入必须明确含税或不含税金额模式，禁止关闭财务一致性复核。",
|
|
"lineAmountMode");
|
|
return;
|
|
}
|
|
try
|
|
{
|
|
PurchaseInvoiceMatcher.Match(
|
|
new PurchaseInvoiceDraft(),
|
|
new List<PurchaseSourceLine>(),
|
|
options);
|
|
}
|
|
catch
|
|
{
|
|
result.Add(
|
|
"purchase_match_options_invalid",
|
|
"采购金额、税额或匹配容差配置无效。",
|
|
"matchOptions");
|
|
}
|
|
}
|
|
|
|
private static void ValidateInspectedModuleCode(
|
|
string configured,
|
|
ModuleInspection inspection,
|
|
AdapterPreflightResult result)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(configured)
|
|
|| inspection == null
|
|
|| !string.Equals(
|
|
configured,
|
|
inspection.ModuleCode,
|
|
StringComparison.Ordinal))
|
|
result.Add("module_code_mismatch", "字段映射模块编号与已检查模块编号不一致。", "moduleCode");
|
|
}
|
|
|
|
private static void Append(AdapterPreflightResult target, AdapterPreflightResult source)
|
|
{
|
|
if (target == null || source == null) return;
|
|
foreach (AdapterPreflightIssue issue in source.Issues)
|
|
target.Issues.Add(issue);
|
|
}
|
|
|
|
private static void ValidateFields(
|
|
ModuleInspection inspection,
|
|
AdapterPreflightResult result,
|
|
IEnumerable<FieldMapping> mappings)
|
|
{
|
|
List<FieldMapping> values = mappings.ToList();
|
|
foreach (FieldMapping mapping in values)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(mapping.FieldName)
|
|
|| !SafeIdentifier.IsMatch(mapping.FieldName))
|
|
{
|
|
result.Add("unsafe_field_mapping", "字段映射必须是安全的精确数据库字段名。", mapping.SemanticName);
|
|
continue;
|
|
}
|
|
if (inspection == null) continue;
|
|
IEnumerable<FieldSpec> source = string.Equals(
|
|
mapping.Scope, "detail", StringComparison.OrdinalIgnoreCase)
|
|
? inspection.DetailFields : inspection.MasterFields;
|
|
List<FieldSpec> exact = source.Where(item => item != null
|
|
&& string.Equals(
|
|
item.Name,
|
|
mapping.FieldName,
|
|
StringComparison.OrdinalIgnoreCase)).ToList();
|
|
if (exact.Count == 0)
|
|
result.Add("mapped_field_not_found", "低代码元数据中不存在映射字段。", mapping.SemanticName);
|
|
else if (exact.Count > 1)
|
|
result.Add("mapped_field_ambiguous", "低代码元数据中存在重复映射字段。", mapping.SemanticName);
|
|
else if (!exact[0].Exposed)
|
|
result.Add("mapped_field_not_exposed", "映射字段未在当前低代码界面和字段权限中暴露。", mapping.SemanticName);
|
|
}
|
|
|
|
foreach (IGrouping<string, FieldMapping> duplicate in values
|
|
.Where(item => !string.IsNullOrWhiteSpace(item.FieldName))
|
|
.GroupBy(item => item.Scope + ":" + item.FieldName, StringComparer.OrdinalIgnoreCase)
|
|
.Where(group => group.Count() > 1))
|
|
{
|
|
result.Add("mapped_field_reused", "多个业务含义映射到了同一个字段。", duplicate.Key);
|
|
}
|
|
}
|
|
|
|
private static FieldMapping Mapping(string semanticName, string scope, string fieldName)
|
|
{
|
|
return new FieldMapping
|
|
{
|
|
SemanticName = semanticName,
|
|
Scope = scope,
|
|
FieldName = fieldName == null ? null : fieldName.Trim()
|
|
};
|
|
}
|
|
|
|
private sealed class FieldMapping
|
|
{
|
|
public string SemanticName;
|
|
public string Scope;
|
|
public string FieldName;
|
|
}
|
|
}
|
|
}
|