郎速科技
778 lines
30 KiB
C#
778 lines
30 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Data;
|
|
using System.Globalization;
|
|
using System.Linq;
|
|
using Lskj.CommandKernel;
|
|
using Newtonsoft.Json;
|
|
using Newtonsoft.Json.Linq;
|
|
using Newtonsoft.Json.Serialization;
|
|
|
|
namespace Lskj.AgentBridge
|
|
{
|
|
public interface IWorkflowProcedureGateway
|
|
{
|
|
BusinessAdapterReadiness GetReadiness(string workflow, string moduleCode);
|
|
DataTable Read(
|
|
string workflow,
|
|
string action,
|
|
string moduleCode,
|
|
CommandExecutionContext context,
|
|
IDictionary<string, object> payload);
|
|
BusinessWriteResult Write(
|
|
string workflow,
|
|
string action,
|
|
string moduleCode,
|
|
CommandExecutionContext context,
|
|
IDictionary<string, object> payload,
|
|
string idempotencyKey,
|
|
string inputFingerprint);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Optional gateway extension used by live command rechecks. Keeping it
|
|
/// separate preserves compatibility with offline contract probes and old
|
|
/// customer gateways while allowing production gateways to bind readiness
|
|
/// to the exact command session.
|
|
/// </summary>
|
|
public interface IContextualWorkflowProcedureGateway
|
|
{
|
|
BusinessAdapterReadiness GetReadiness(
|
|
string workflow,
|
|
string moduleCode,
|
|
CommandExecutionContext context);
|
|
}
|
|
|
|
public sealed class ProcedurePurchaseWorkflowAdapter : IPurchaseInvoiceWorkflowAdapter,
|
|
IPurchaseInvoiceIntentResolver,
|
|
IContextualBusinessWorkflowAdapterReadiness
|
|
{
|
|
private const string Workflow = "purchase";
|
|
private readonly IWorkflowProcedureGateway _gateway;
|
|
private readonly IBusinessAdapterReadinessAttestor _readinessAttestor;
|
|
|
|
public ProcedurePurchaseWorkflowAdapter(string moduleCode, IWorkflowProcedureGateway gateway)
|
|
: this(moduleCode, gateway, null)
|
|
{
|
|
}
|
|
|
|
public ProcedurePurchaseWorkflowAdapter(
|
|
string moduleCode,
|
|
IWorkflowProcedureGateway gateway,
|
|
IBusinessAdapterReadinessAttestor readinessAttestor)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(moduleCode))
|
|
throw new ArgumentException("采购模块编号不能为空。", "moduleCode");
|
|
if (gateway == null) throw new ArgumentNullException("gateway");
|
|
ModuleCode = moduleCode.Trim();
|
|
_gateway = gateway;
|
|
_readinessAttestor = readinessAttestor;
|
|
}
|
|
|
|
public string ModuleCode { get; private set; }
|
|
|
|
public BusinessAdapterReadiness GetReadiness()
|
|
{
|
|
return GetReadiness(null);
|
|
}
|
|
|
|
public BusinessAdapterReadiness GetReadiness(CommandExecutionContext context)
|
|
{
|
|
if (context == null)
|
|
return GetReadinessWithoutContext();
|
|
IBusinessAdapterReadinessOverride readinessOverride =
|
|
_readinessAttestor as IBusinessAdapterReadinessOverride;
|
|
if (readinessOverride != null)
|
|
{
|
|
IContextualBusinessAdapterReadinessOverride contextualOverride =
|
|
_readinessAttestor as IContextualBusinessAdapterReadinessOverride;
|
|
if (contextualOverride == null)
|
|
throw ContextualReadinessRequired();
|
|
return contextualOverride.GetReadiness(Workflow, ModuleCode, context);
|
|
}
|
|
IContextualWorkflowProcedureGateway contextualGateway =
|
|
_gateway as IContextualWorkflowProcedureGateway;
|
|
if (contextualGateway == null)
|
|
throw ContextualReadinessRequired();
|
|
BusinessAdapterReadiness readiness = contextualGateway.GetReadiness(
|
|
Workflow,
|
|
ModuleCode,
|
|
context);
|
|
return _readinessAttestor == null
|
|
? readiness
|
|
: _readinessAttestor.Attest(Workflow, ModuleCode, readiness);
|
|
}
|
|
|
|
private BusinessAdapterReadiness GetReadinessWithoutContext()
|
|
{
|
|
IBusinessAdapterReadinessOverride readinessOverride =
|
|
_readinessAttestor as IBusinessAdapterReadinessOverride;
|
|
if (readinessOverride != null)
|
|
return readinessOverride.GetReadiness(Workflow, ModuleCode);
|
|
BusinessAdapterReadiness readiness = _gateway.GetReadiness(Workflow, ModuleCode);
|
|
return _readinessAttestor == null
|
|
? readiness
|
|
: _readinessAttestor.Attest(Workflow, ModuleCode, readiness);
|
|
}
|
|
|
|
private static CommandKernelException ContextualReadinessRequired()
|
|
{
|
|
return new CommandKernelException(
|
|
"adapter_readiness_context_required",
|
|
"运行时业务适配器就绪复核必须绑定显式 ERP 会话。",
|
|
6);
|
|
}
|
|
|
|
public bool InvoiceNumberExists(
|
|
string supplierCode,
|
|
string invoiceNumber,
|
|
CommandExecutionContext context)
|
|
{
|
|
DataRow row = ProcedureRows.Single(_gateway.Read(
|
|
Workflow,
|
|
"invoice_exists",
|
|
ModuleCode,
|
|
RequireContext(context),
|
|
new Dictionary<string, object>
|
|
{
|
|
{ "supplierCode", supplierCode },
|
|
{ "invoiceNumber", invoiceNumber }
|
|
}), "purchase.invoice_exists");
|
|
return ProcedureRows.Boolean(row, "exists");
|
|
}
|
|
|
|
public IList<PurchaseSupplierCandidate> ResolveSuppliers(
|
|
string reference,
|
|
string taxId,
|
|
CommandExecutionContext context)
|
|
{
|
|
DataTable table = ReadCandidates(
|
|
"resolve_supplier",
|
|
context,
|
|
new Dictionary<string, object>
|
|
{
|
|
{ "reference", reference },
|
|
{ "taxId", taxId }
|
|
});
|
|
List<PurchaseSupplierCandidate> result =
|
|
new List<PurchaseSupplierCandidate>();
|
|
HashSet<string> codes = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
|
|
foreach (DataRow row in table.Rows)
|
|
{
|
|
PurchaseSupplierCandidate candidate = new PurchaseSupplierCandidate
|
|
{
|
|
Code = ProcedureRows.RequiredString(row, "supplier_code"),
|
|
Name = ProcedureRows.RequiredString(row, "supplier_name"),
|
|
TaxId = ProcedureRows.OptionalString(row, "supplier_tax_id")
|
|
};
|
|
if (!codes.Add(candidate.Code))
|
|
throw ProcedureRows.Protocol("purchase.resolve_supplier", "供应商候选编码重复。");
|
|
result.Add(candidate);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public IList<PurchaseCurrencyCandidate> ResolveCurrencies(
|
|
string reference,
|
|
CommandExecutionContext context)
|
|
{
|
|
DataTable table = ReadCandidates(
|
|
"resolve_currency",
|
|
context,
|
|
new Dictionary<string, object> { { "reference", reference } });
|
|
List<PurchaseCurrencyCandidate> result =
|
|
new List<PurchaseCurrencyCandidate>();
|
|
HashSet<string> codes = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
|
|
foreach (DataRow row in table.Rows)
|
|
{
|
|
PurchaseCurrencyCandidate candidate = new PurchaseCurrencyCandidate
|
|
{
|
|
Code = ProcedureRows.RequiredString(row, "currency_code"),
|
|
Name = ProcedureRows.RequiredString(row, "currency_name")
|
|
};
|
|
if (!codes.Add(candidate.Code))
|
|
throw ProcedureRows.Protocol("purchase.resolve_currency", "币种候选编码重复。");
|
|
result.Add(candidate);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public IList<PurchaseMaterialCandidate> ResolveMaterials(
|
|
PurchaseInvoiceIntentLine line,
|
|
string supplierCode,
|
|
CommandExecutionContext context)
|
|
{
|
|
if (line == null) throw new ArgumentNullException("line");
|
|
DataTable table = ReadCandidates(
|
|
"resolve_material",
|
|
context,
|
|
new Dictionary<string, object>
|
|
{
|
|
{ "lineId", line.LineId },
|
|
{ "reference", line.MaterialReference },
|
|
{ "specification", line.Specification },
|
|
{ "unit", line.Unit },
|
|
{ "supplierCode", supplierCode }
|
|
});
|
|
List<PurchaseMaterialCandidate> result =
|
|
new List<PurchaseMaterialCandidate>();
|
|
HashSet<string> codes = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
|
|
foreach (DataRow row in table.Rows)
|
|
{
|
|
PurchaseMaterialCandidate candidate = new PurchaseMaterialCandidate
|
|
{
|
|
Code = ProcedureRows.RequiredString(row, "material_code"),
|
|
Name = ProcedureRows.RequiredString(row, "material_name"),
|
|
Specification = ProcedureRows.OptionalString(row, "specification"),
|
|
Unit = ProcedureRows.RequiredString(row, "unit")
|
|
};
|
|
if (!codes.Add(candidate.Code))
|
|
throw ProcedureRows.Protocol("purchase.resolve_material", "物料候选编码重复。");
|
|
result.Add(candidate);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public IList<PurchaseSourceLine> QueryOpenSourceLines(
|
|
PurchaseInvoiceDraft draft,
|
|
CommandExecutionContext context)
|
|
{
|
|
if (draft == null) throw new ArgumentNullException("draft");
|
|
DataTable table = _gateway.Read(
|
|
Workflow,
|
|
"open_sources",
|
|
ModuleCode,
|
|
RequireContext(context),
|
|
WorkflowProcedurePayload.From(draft));
|
|
if (table == null || table.Rows.Count > 10000)
|
|
throw ProcedureRows.Protocol("purchase.open_sources", "来源结果为空或超过 10000 行。");
|
|
|
|
List<PurchaseSourceLine> result = new List<PurchaseSourceLine>();
|
|
HashSet<string> identities = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
|
|
foreach (DataRow row in table.Rows)
|
|
{
|
|
PurchaseSourceLine line = new PurchaseSourceLine
|
|
{
|
|
SourceOrderId = ProcedureRows.RequiredString(row, "source_order_id"),
|
|
SourceOrderNumber = ProcedureRows.RequiredString(row, "source_order_number"),
|
|
SourceLineId = ProcedureRows.RequiredString(row, "source_line_id"),
|
|
SupplierCode = ProcedureRows.RequiredString(row, "supplier_code"),
|
|
CurrencyCode = ProcedureRows.RequiredString(row, "currency_code"),
|
|
MaterialCode = ProcedureRows.RequiredString(row, "material_code"),
|
|
Unit = ProcedureRows.RequiredString(row, "unit"),
|
|
RemainingQuantity = ProcedureRows.Decimal(row, "remaining_quantity"),
|
|
UnitPrice = ProcedureRows.Decimal(row, "unit_price"),
|
|
TaxRate = ProcedureRows.Decimal(row, "tax_rate"),
|
|
ExchangeRate = ProcedureRows.Decimal(row, "exchange_rate"),
|
|
Closed = ProcedureRows.Boolean(row, "closed")
|
|
};
|
|
if (line.RemainingQuantity < 0 || line.UnitPrice < 0
|
|
|| line.TaxRate < 0 || line.TaxRate > 1
|
|
|| line.ExchangeRate <= 0)
|
|
throw ProcedureRows.Protocol(
|
|
"purchase.open_sources",
|
|
"来源数量、单价、税率或汇率越界。");
|
|
if (!identities.Add(line.UniqueKey))
|
|
throw ProcedureRows.Protocol("purchase.open_sources", "来源行标识重复。");
|
|
result.Add(line);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public BusinessWriteResult CreatePurchaseDocument(
|
|
PurchaseInvoiceCreateRequest request,
|
|
CommandExecutionContext context,
|
|
string idempotencyKey,
|
|
string inputFingerprint)
|
|
{
|
|
if (request == null || request.Draft == null)
|
|
throw new ArgumentNullException("request");
|
|
return _gateway.Write(
|
|
Workflow,
|
|
"create_document",
|
|
ModuleCode,
|
|
RequireContext(context),
|
|
WorkflowProcedurePayload.From(request),
|
|
idempotencyKey,
|
|
inputFingerprint);
|
|
}
|
|
|
|
private static CommandExecutionContext RequireContext(CommandExecutionContext context)
|
|
{
|
|
if (context == null) throw new ArgumentNullException("context");
|
|
return context;
|
|
}
|
|
|
|
private DataTable ReadCandidates(
|
|
string action,
|
|
CommandExecutionContext context,
|
|
IDictionary<string, object> payload)
|
|
{
|
|
DataTable table = _gateway.Read(
|
|
Workflow,
|
|
action,
|
|
ModuleCode,
|
|
RequireContext(context),
|
|
payload);
|
|
if (table == null || table.Rows.Count > 20)
|
|
throw ProcedureRows.Protocol(
|
|
"purchase." + action,
|
|
"候选结果为空或超过 20 行。");
|
|
return table;
|
|
}
|
|
}
|
|
|
|
public sealed class ProcedureLeaveWorkflowAdapter : ILeaveWorkflowAdapter,
|
|
IContextualLeaveValidationProvider, ILeaveIntentResolver,
|
|
IContextualBusinessWorkflowAdapterReadiness
|
|
{
|
|
private const string Workflow = "leave";
|
|
private readonly IWorkflowProcedureGateway _gateway;
|
|
private readonly IBusinessAdapterReadinessAttestor _readinessAttestor;
|
|
|
|
public ProcedureLeaveWorkflowAdapter(string moduleCode, IWorkflowProcedureGateway gateway)
|
|
: this(moduleCode, gateway, null)
|
|
{
|
|
}
|
|
|
|
public ProcedureLeaveWorkflowAdapter(
|
|
string moduleCode,
|
|
IWorkflowProcedureGateway gateway,
|
|
IBusinessAdapterReadinessAttestor readinessAttestor)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(moduleCode))
|
|
throw new ArgumentException("请假模块编号不能为空。", "moduleCode");
|
|
if (gateway == null) throw new ArgumentNullException("gateway");
|
|
ModuleCode = moduleCode.Trim();
|
|
_gateway = gateway;
|
|
_readinessAttestor = readinessAttestor;
|
|
}
|
|
|
|
public string ModuleCode { get; private set; }
|
|
|
|
public BusinessAdapterReadiness GetReadiness()
|
|
{
|
|
return GetReadiness(null);
|
|
}
|
|
|
|
public BusinessAdapterReadiness GetReadiness(CommandExecutionContext context)
|
|
{
|
|
if (context == null)
|
|
return GetReadinessWithoutContext();
|
|
IBusinessAdapterReadinessOverride readinessOverride =
|
|
_readinessAttestor as IBusinessAdapterReadinessOverride;
|
|
if (readinessOverride != null)
|
|
{
|
|
IContextualBusinessAdapterReadinessOverride contextualOverride =
|
|
_readinessAttestor as IContextualBusinessAdapterReadinessOverride;
|
|
if (contextualOverride == null)
|
|
throw ContextualReadinessRequired();
|
|
return contextualOverride.GetReadiness(Workflow, ModuleCode, context);
|
|
}
|
|
IContextualWorkflowProcedureGateway contextualGateway =
|
|
_gateway as IContextualWorkflowProcedureGateway;
|
|
if (contextualGateway == null)
|
|
throw ContextualReadinessRequired();
|
|
BusinessAdapterReadiness readiness = contextualGateway.GetReadiness(
|
|
Workflow,
|
|
ModuleCode,
|
|
context);
|
|
return _readinessAttestor == null
|
|
? readiness
|
|
: _readinessAttestor.Attest(Workflow, ModuleCode, readiness);
|
|
}
|
|
|
|
private BusinessAdapterReadiness GetReadinessWithoutContext()
|
|
{
|
|
IBusinessAdapterReadinessOverride readinessOverride =
|
|
_readinessAttestor as IBusinessAdapterReadinessOverride;
|
|
if (readinessOverride != null)
|
|
return readinessOverride.GetReadiness(Workflow, ModuleCode);
|
|
BusinessAdapterReadiness readiness = _gateway.GetReadiness(Workflow, ModuleCode);
|
|
return _readinessAttestor == null
|
|
? readiness
|
|
: _readinessAttestor.Attest(Workflow, ModuleCode, readiness);
|
|
}
|
|
|
|
private static CommandKernelException ContextualReadinessRequired()
|
|
{
|
|
return new CommandKernelException(
|
|
"adapter_readiness_context_required",
|
|
"运行时业务适配器就绪复核必须绑定显式 ERP 会话。",
|
|
6);
|
|
}
|
|
|
|
public string GetCurrentEmployeeId(CommandExecutionContext context)
|
|
{
|
|
return ProcedureRows.RequiredString(LeaveContext(context), "current_employee_id");
|
|
}
|
|
|
|
public bool CanApplyForOthers(CommandExecutionContext context)
|
|
{
|
|
return ProcedureRows.Boolean(LeaveContext(context), "can_apply_for_others");
|
|
}
|
|
|
|
public bool IsLeaveTypeEnabled(string leaveTypeCode, CommandExecutionContext context)
|
|
{
|
|
DataRow row = ProcedureRows.Single(Read(
|
|
"type_enabled",
|
|
context,
|
|
new Dictionary<string, object> { { "leaveTypeCode", leaveTypeCode } }),
|
|
"leave.type_enabled");
|
|
return ProcedureRows.Boolean(row, "enabled");
|
|
}
|
|
|
|
public bool IsLeaveFlowTypeEnabled(
|
|
string flowTypeCode,
|
|
CommandExecutionContext context)
|
|
{
|
|
DataRow row = ProcedureRows.Single(Read(
|
|
"flow_type_enabled",
|
|
context,
|
|
new Dictionary<string, object>
|
|
{
|
|
{ "flowTypeCode", flowTypeCode }
|
|
}),
|
|
"leave.flow_type_enabled");
|
|
return ProcedureRows.Boolean(row, "enabled");
|
|
}
|
|
|
|
public IList<LeaveTypeCandidate> ResolveLeaveTypes(
|
|
string query,
|
|
CommandExecutionContext context)
|
|
{
|
|
DataTable table = Read(
|
|
"resolve_type",
|
|
context,
|
|
new Dictionary<string, object> { { "query", query } });
|
|
if (table == null || table.Rows.Count > 10)
|
|
throw ProcedureRows.Protocol(
|
|
"leave.resolve_type",
|
|
"结果表不能为空且候选不能超过 10 行。");
|
|
List<LeaveTypeCandidate> result = new List<LeaveTypeCandidate>();
|
|
foreach (DataRow row in table.Rows)
|
|
{
|
|
result.Add(new LeaveTypeCandidate
|
|
{
|
|
Code = ProcedureRows.RequiredString(row, "leave_type_code"),
|
|
Name = ProcedureRows.RequiredString(row, "leave_type_name")
|
|
});
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public IList<LeaveFlowTypeCandidate> ResolveLeaveFlowTypes(
|
|
string employeeId,
|
|
decimal calculatedHours,
|
|
string query,
|
|
CommandExecutionContext context)
|
|
{
|
|
DataTable table = Read(
|
|
"resolve_flow_type",
|
|
context,
|
|
new Dictionary<string, object>
|
|
{
|
|
{ "employeeId", employeeId },
|
|
{ "calculatedHours", calculatedHours },
|
|
{ "query", query }
|
|
});
|
|
if (table == null || table.Rows.Count > 20)
|
|
throw ProcedureRows.Protocol(
|
|
"leave.resolve_flow_type",
|
|
"结果表不能为空且候选不能超过 20 行。");
|
|
List<LeaveFlowTypeCandidate> result =
|
|
new List<LeaveFlowTypeCandidate>();
|
|
foreach (DataRow row in table.Rows)
|
|
{
|
|
result.Add(new LeaveFlowTypeCandidate
|
|
{
|
|
Code = ProcedureRows.RequiredString(row, "flow_type_code"),
|
|
Name = ProcedureRows.RequiredString(row, "flow_type_name")
|
|
});
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public LeaveCalendarRange ResolveCalendarRange(
|
|
string employeeId,
|
|
DateTime localDate,
|
|
LeaveDayPart dayPart,
|
|
CommandExecutionContext context)
|
|
{
|
|
DataRow row = ProcedureRows.Single(Read(
|
|
"resolve_calendar_range",
|
|
context,
|
|
new Dictionary<string, object>
|
|
{
|
|
{ "employeeId", employeeId },
|
|
{ "localDate", localDate.ToString("yyyy-MM-dd", CultureInfo.InvariantCulture) },
|
|
{ "dayPart", DayPartName(dayPart) }
|
|
}),
|
|
"leave.resolve_calendar_range");
|
|
bool available = ProcedureRows.Boolean(row, "available");
|
|
LeaveCalendarRange result = new LeaveCalendarRange
|
|
{
|
|
Available = available,
|
|
ReasonCode = ProcedureRows.RequiredString(row, "reason_code")
|
|
};
|
|
if (!available) return result;
|
|
result.StartLocal = ProcedureRows.DateTime(row, "start_local");
|
|
result.EndLocal = ProcedureRows.DateTime(row, "end_local");
|
|
result.Hours = ProcedureRows.Decimal(row, "hours");
|
|
result.TimeZoneId = ProcedureRows.RequiredString(row, "time_zone_id");
|
|
return result;
|
|
}
|
|
|
|
public DateTime GetCurrentLocalTime(CommandExecutionContext context)
|
|
{
|
|
return ProcedureRows.DateTime(LeaveContext(context), "now_local");
|
|
}
|
|
|
|
public decimal CalculateHours(
|
|
string employeeId,
|
|
DateTime startLocal,
|
|
DateTime endLocal,
|
|
CommandExecutionContext context)
|
|
{
|
|
DataRow row = ProcedureRows.Single(Read(
|
|
"calculate_hours",
|
|
context,
|
|
TimePayload(employeeId, startLocal, endLocal)),
|
|
"leave.calculate_hours");
|
|
decimal hours = ProcedureRows.Decimal(row, "hours");
|
|
if (hours < 0) throw ProcedureRows.Protocol("leave.calculate_hours", "工时不能小于零。");
|
|
return hours;
|
|
}
|
|
|
|
public bool HasConflict(
|
|
string employeeId,
|
|
DateTime startLocal,
|
|
DateTime endLocal,
|
|
CommandExecutionContext context)
|
|
{
|
|
DataRow row = ProcedureRows.Single(Read(
|
|
"has_conflict",
|
|
context,
|
|
TimePayload(employeeId, startLocal, endLocal)),
|
|
"leave.has_conflict");
|
|
return ProcedureRows.Boolean(row, "has_conflict");
|
|
}
|
|
|
|
decimal IWorkingTimeCalculator.CalculateHours(
|
|
string employeeId,
|
|
DateTime startLocal,
|
|
DateTime endLocal)
|
|
{
|
|
throw new CommandKernelException(
|
|
"execution_context_required",
|
|
"请假工时查询必须携带 ERP 执行上下文。",
|
|
6);
|
|
}
|
|
|
|
bool ILeaveConflictProvider.HasConflict(
|
|
string employeeId,
|
|
DateTime startLocal,
|
|
DateTime endLocal)
|
|
{
|
|
throw new CommandKernelException(
|
|
"execution_context_required",
|
|
"请假冲突查询必须携带 ERP 执行上下文。",
|
|
6);
|
|
}
|
|
|
|
public BusinessWriteResult CreateLeaveDraft(
|
|
LeaveRequestDraft draft,
|
|
CommandExecutionContext context,
|
|
string idempotencyKey,
|
|
string inputFingerprint)
|
|
{
|
|
if (draft == null) throw new ArgumentNullException("draft");
|
|
return Write(
|
|
"create_draft",
|
|
context,
|
|
WorkflowProcedurePayload.From(draft),
|
|
idempotencyKey,
|
|
inputFingerprint);
|
|
}
|
|
|
|
public bool CanSubmitLeave(
|
|
string recordId,
|
|
CommandExecutionContext context,
|
|
out string reason)
|
|
{
|
|
DataRow row = ProcedureRows.Single(Read(
|
|
"can_submit",
|
|
context,
|
|
new Dictionary<string, object> { { "recordId", recordId } }),
|
|
"leave.can_submit");
|
|
reason = ProcedureRows.OptionalString(row, "reason");
|
|
return ProcedureRows.Boolean(row, "can_submit");
|
|
}
|
|
|
|
public BusinessWriteResult SubmitLeave(
|
|
string recordId,
|
|
CommandExecutionContext context,
|
|
string idempotencyKey,
|
|
string inputFingerprint)
|
|
{
|
|
return Write(
|
|
"submit",
|
|
context,
|
|
new Dictionary<string, object> { { "recordId", recordId } },
|
|
idempotencyKey,
|
|
inputFingerprint);
|
|
}
|
|
|
|
private DataRow LeaveContext(CommandExecutionContext context)
|
|
{
|
|
return ProcedureRows.Single(
|
|
Read("context", context, new Dictionary<string, object>()),
|
|
"leave.context");
|
|
}
|
|
|
|
private DataTable Read(
|
|
string action,
|
|
CommandExecutionContext context,
|
|
IDictionary<string, object> payload)
|
|
{
|
|
if (context == null) throw new ArgumentNullException("context");
|
|
return _gateway.Read(Workflow, action, ModuleCode, context, payload);
|
|
}
|
|
|
|
private BusinessWriteResult Write(
|
|
string action,
|
|
CommandExecutionContext context,
|
|
IDictionary<string, object> payload,
|
|
string idempotencyKey,
|
|
string inputFingerprint)
|
|
{
|
|
if (context == null) throw new ArgumentNullException("context");
|
|
return _gateway.Write(
|
|
Workflow,
|
|
action,
|
|
ModuleCode,
|
|
context,
|
|
payload,
|
|
idempotencyKey,
|
|
inputFingerprint);
|
|
}
|
|
|
|
private static IDictionary<string, object> TimePayload(
|
|
string employeeId,
|
|
DateTime startLocal,
|
|
DateTime endLocal)
|
|
{
|
|
return new Dictionary<string, object>
|
|
{
|
|
{ "employeeId", employeeId },
|
|
{ "startLocal", startLocal },
|
|
{ "endLocal", endLocal }
|
|
};
|
|
}
|
|
|
|
private static string DayPartName(LeaveDayPart dayPart)
|
|
{
|
|
switch (dayPart)
|
|
{
|
|
case LeaveDayPart.Morning:
|
|
return "morning";
|
|
case LeaveDayPart.Afternoon:
|
|
return "afternoon";
|
|
case LeaveDayPart.FullDay:
|
|
return "full_day";
|
|
default:
|
|
throw ProcedureRows.Protocol(
|
|
"leave.resolve_calendar_range",
|
|
"dayPart 无效。");
|
|
}
|
|
}
|
|
}
|
|
|
|
internal static class WorkflowProcedurePayload
|
|
{
|
|
private static readonly JsonSerializer Serializer = JsonSerializer.Create(
|
|
new JsonSerializerSettings
|
|
{
|
|
ContractResolver = new CamelCasePropertyNamesContractResolver(),
|
|
NullValueHandling = NullValueHandling.Ignore,
|
|
TypeNameHandling = TypeNameHandling.None,
|
|
MaxDepth = 64
|
|
});
|
|
|
|
public static IDictionary<string, object> From(object value)
|
|
{
|
|
if (value == null) throw new ArgumentNullException("value");
|
|
lock (Serializer)
|
|
{
|
|
return JObject.FromObject(value, Serializer)
|
|
.ToObject<Dictionary<string, object>>();
|
|
}
|
|
}
|
|
}
|
|
|
|
internal static class ProcedureRows
|
|
{
|
|
public static DataRow Single(DataTable table, string operation)
|
|
{
|
|
if (table == null || table.Rows.Count != 1)
|
|
throw Protocol(operation, "结果必须恰好包含一行。");
|
|
return table.Rows[0];
|
|
}
|
|
|
|
public static string RequiredString(DataRow row, string name)
|
|
{
|
|
string value = OptionalString(row, name);
|
|
if (string.IsNullOrWhiteSpace(value))
|
|
throw Protocol(name, "缺少必填字符串字段。");
|
|
return value.Trim();
|
|
}
|
|
|
|
public static string OptionalString(DataRow row, string name)
|
|
{
|
|
object value = Value(row, name);
|
|
return value == null || value == DBNull.Value ? string.Empty : Convert.ToString(value);
|
|
}
|
|
|
|
public static decimal Decimal(DataRow row, string name)
|
|
{
|
|
try { return Convert.ToDecimal(Value(row, name), CultureInfo.InvariantCulture); }
|
|
catch { throw Protocol(name, "字段不是有效 decimal。"); }
|
|
}
|
|
|
|
public static bool Boolean(DataRow row, string name)
|
|
{
|
|
object value = Value(row, name);
|
|
if (value is bool) return (bool)value;
|
|
string text = Convert.ToString(value, CultureInfo.InvariantCulture);
|
|
if (text == "1" || text.Equals("true", StringComparison.OrdinalIgnoreCase)) return true;
|
|
if (text == "0" || text.Equals("false", StringComparison.OrdinalIgnoreCase)) return false;
|
|
throw Protocol(name, "字段不是有效 bool。");
|
|
}
|
|
|
|
public static DateTime DateTime(DataRow row, string name)
|
|
{
|
|
try { return Convert.ToDateTime(Value(row, name), CultureInfo.InvariantCulture); }
|
|
catch { throw Protocol(name, "字段不是有效 DateTime。"); }
|
|
}
|
|
|
|
public static CommandKernelException Protocol(string operation, string message)
|
|
{
|
|
return new CommandKernelException(
|
|
"adapter_protocol_error",
|
|
"业务过程契约无效（" + operation + "）：" + message,
|
|
6);
|
|
}
|
|
|
|
private static object Value(DataRow row, string name)
|
|
{
|
|
if (row == null || row.Table == null)
|
|
throw Protocol(name, "结果行为空。");
|
|
DataColumn column = row.Table.Columns.Cast<DataColumn>().FirstOrDefault(item =>
|
|
item.ColumnName.Equals(name, StringComparison.OrdinalIgnoreCase));
|
|
if (column == null || row[column] == DBNull.Value)
|
|
throw Protocol(name, "结果缺少字段。");
|
|
return row[column];
|
|
}
|
|
}
|
|
}
|