郎速科技
526 lines
23 KiB
C#
526 lines
23 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
|
|
namespace Lskj.CommandKernel
|
|
{
|
|
public static class PurchaseSourceDocumentContract
|
|
{
|
|
public const int MaximumCount = 3;
|
|
public const long MaximumSizeBytes = 12L * 1024L * 1024L;
|
|
public const string ImagePreprocessContract = "minimax_vlm_0.0.4";
|
|
public const string PdfPreprocessContract = "pdfium_minimax_pages_v1";
|
|
public const string CsvPreprocessContract = "document_sandbox_csv_v1";
|
|
public const string XlsxPreprocessContract = "document_sandbox_xlsx_v1";
|
|
|
|
public static bool Matches(
|
|
string kind,
|
|
string filename,
|
|
string preprocessContract)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(filename)
|
|
|| string.IsNullOrWhiteSpace(preprocessContract))
|
|
return false;
|
|
string name = filename.Trim();
|
|
if (kind == "image")
|
|
{
|
|
return preprocessContract == ImagePreprocessContract
|
|
&& (name.EndsWith(".png", StringComparison.OrdinalIgnoreCase)
|
|
|| name.EndsWith(".jpg", StringComparison.OrdinalIgnoreCase)
|
|
|| name.EndsWith(".jpeg", StringComparison.OrdinalIgnoreCase)
|
|
|| name.EndsWith(".webp", StringComparison.OrdinalIgnoreCase));
|
|
}
|
|
if (kind != "file") return false;
|
|
if (name.EndsWith(".pdf", StringComparison.OrdinalIgnoreCase))
|
|
return preprocessContract == PdfPreprocessContract;
|
|
if (name.EndsWith(".csv", StringComparison.OrdinalIgnoreCase))
|
|
return preprocessContract == CsvPreprocessContract;
|
|
if (name.EndsWith(".xlsx", StringComparison.OrdinalIgnoreCase))
|
|
return preprocessContract == XlsxPreprocessContract;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public enum InvoiceLineMatchStatus
|
|
{
|
|
Exact = 0,
|
|
Ambiguous = 1,
|
|
Unmatched = 2,
|
|
Invalid = 3,
|
|
Conflict = 4
|
|
}
|
|
|
|
public enum InvoiceLineAmountMode
|
|
{
|
|
None = 0,
|
|
TaxExclusive = 1,
|
|
TaxInclusive = 2
|
|
}
|
|
|
|
public sealed class PurchaseInvoiceDraft
|
|
{
|
|
public PurchaseInvoiceDraft()
|
|
{
|
|
Lines = new List<PurchaseInvoiceLine>();
|
|
SourceDocuments = new List<PurchaseSourceDocument>();
|
|
}
|
|
|
|
public string SupplierCode { get; set; }
|
|
public string CurrencyCode { get; set; }
|
|
public string InvoiceNumber { get; set; }
|
|
public DateTime InvoiceDate { get; set; }
|
|
public decimal TotalWithoutTax { get; set; }
|
|
public decimal TaxAmount { get; set; }
|
|
public decimal TotalWithTax { get; set; }
|
|
public IList<PurchaseInvoiceLine> Lines { get; private set; }
|
|
public IList<PurchaseSourceDocument> SourceDocuments { get; private set; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// 由受信任 AstrBot Tool 从本次消息附件生成的来源凭据。它会进入采购
|
|
/// 解析凭证、命令输入指纹和客户写入 payload，模型不能自行声明来源。
|
|
/// </summary>
|
|
public sealed class PurchaseSourceDocument
|
|
{
|
|
public string Kind { get; set; }
|
|
public string Filename { get; set; }
|
|
public string Sha256 { get; set; }
|
|
public long SizeBytes { get; set; }
|
|
public string ExtractionSha256 { get; set; }
|
|
public string PreprocessContract { get; set; }
|
|
}
|
|
|
|
public sealed class PurchaseInvoiceLine
|
|
{
|
|
public string LineId { get; set; }
|
|
public string MaterialCode { get; set; }
|
|
public string Unit { get; set; }
|
|
public string SourceOrderHint { get; set; }
|
|
public decimal Quantity { get; set; }
|
|
public decimal UnitPrice { get; set; }
|
|
public decimal TaxRate { get; set; }
|
|
public decimal TaxAmount { get; set; }
|
|
public decimal LineAmount { get; set; }
|
|
}
|
|
|
|
public sealed class PurchaseSourceLine
|
|
{
|
|
public string SourceLineId { get; set; }
|
|
public string SourceOrderId { get; set; }
|
|
public string SourceOrderNumber { get; set; }
|
|
public string SupplierCode { get; set; }
|
|
public string CurrencyCode { get; set; }
|
|
public string MaterialCode { get; set; }
|
|
public string Unit { get; set; }
|
|
public decimal RemainingQuantity { get; set; }
|
|
public decimal UnitPrice { get; set; }
|
|
public decimal TaxRate { get; set; }
|
|
public decimal ExchangeRate { get; set; }
|
|
public bool Closed { get; set; }
|
|
|
|
public string UniqueKey
|
|
{
|
|
get { return (SourceOrderId ?? string.Empty) + "\u001f" + (SourceLineId ?? string.Empty); }
|
|
}
|
|
}
|
|
|
|
public sealed class PurchaseInvoiceMatchOptions
|
|
{
|
|
public PurchaseInvoiceMatchOptions()
|
|
{
|
|
QuantityTolerance = 0.0001m;
|
|
UnitPriceAbsoluteTolerance = 0.01m;
|
|
UnitPriceRelativeTolerance = 0.0001m;
|
|
TaxRateTolerance = 0.0001m;
|
|
LineAmountTolerance = 0.02m;
|
|
HeaderAmountTolerance = 0.05m;
|
|
CurrencyScale = 2;
|
|
LineAmountMode = InvoiceLineAmountMode.None;
|
|
}
|
|
|
|
public decimal QuantityTolerance { get; set; }
|
|
public decimal UnitPriceAbsoluteTolerance { get; set; }
|
|
public decimal UnitPriceRelativeTolerance { get; set; }
|
|
public decimal TaxRateTolerance { get; set; }
|
|
public decimal LineAmountTolerance { get; set; }
|
|
public decimal HeaderAmountTolerance { get; set; }
|
|
public int CurrencyScale { get; set; }
|
|
public InvoiceLineAmountMode LineAmountMode { get; set; }
|
|
}
|
|
|
|
public sealed class PurchaseInvoiceLineMatch
|
|
{
|
|
public PurchaseInvoiceLineMatch(PurchaseInvoiceLine invoiceLine)
|
|
{
|
|
InvoiceLine = invoiceLine;
|
|
Candidates = new List<PurchaseSourceLine>();
|
|
Issues = new List<string>();
|
|
}
|
|
|
|
public PurchaseInvoiceLine InvoiceLine { get; private set; }
|
|
public InvoiceLineMatchStatus Status { get; set; }
|
|
public PurchaseSourceLine SelectedSource { get; set; }
|
|
public IList<PurchaseSourceLine> Candidates { get; private set; }
|
|
public IList<string> Issues { get; private set; }
|
|
}
|
|
|
|
public sealed class PurchaseInvoiceMatchPlan
|
|
{
|
|
public PurchaseInvoiceMatchPlan()
|
|
{
|
|
Lines = new List<PurchaseInvoiceLineMatch>();
|
|
Issues = new List<string>();
|
|
}
|
|
|
|
public bool Executable { get; set; }
|
|
public decimal CalculatedTotalWithoutTax { get; set; }
|
|
public decimal CalculatedTaxAmount { get; set; }
|
|
public decimal CalculatedTotalWithTax { get; set; }
|
|
public IList<PurchaseInvoiceLineMatch> Lines { get; private set; }
|
|
public IList<string> Issues { get; private set; }
|
|
}
|
|
|
|
public static class PurchaseInvoiceMatcher
|
|
{
|
|
public const decimal MaximumQuantityTolerance = 0.01m;
|
|
public const decimal MaximumUnitPriceAbsoluteTolerance = 1m;
|
|
public const decimal MaximumUnitPriceRelativeTolerance = 0.01m;
|
|
public const decimal MaximumTaxRateTolerance = 0.001m;
|
|
public const decimal MaximumLineAmountTolerance = 1m;
|
|
public const decimal MaximumHeaderAmountTolerance = 5m;
|
|
private const decimal ExchangeRateTolerance = 0.000001m;
|
|
|
|
public static PurchaseInvoiceMatchPlan Match(
|
|
PurchaseInvoiceDraft invoice,
|
|
IEnumerable<PurchaseSourceLine> sourceLines,
|
|
PurchaseInvoiceMatchOptions options)
|
|
{
|
|
if (invoice == null) throw new ArgumentNullException("invoice");
|
|
if (sourceLines == null) throw new ArgumentNullException("sourceLines");
|
|
if (options == null) throw new ArgumentNullException("options");
|
|
ValidateOptions(options);
|
|
|
|
PurchaseInvoiceMatchPlan plan = new PurchaseInvoiceMatchPlan();
|
|
List<PurchaseSourceLine> sources = sourceLines.Where(item => item != null).ToList();
|
|
IList<PurchaseInvoiceLine> invoiceLines = invoice.Lines ?? new List<PurchaseInvoiceLine>();
|
|
if (!SafeText(invoice.SupplierCode, 64))
|
|
plan.Issues.Add("供应商必须先解析为 ERP 供应商编码，禁止用名称模糊猜测。");
|
|
if (!SafeText(invoice.CurrencyCode, 64))
|
|
plan.Issues.Add("币种编码不能为空。");
|
|
if (!SafeText(invoice.InvoiceNumber, 128))
|
|
plan.Issues.Add("发票号码不能为空。");
|
|
if (invoice.InvoiceDate == DateTime.MinValue
|
|
|| invoice.InvoiceDate.Kind != DateTimeKind.Unspecified
|
|
|| invoice.InvoiceDate.TimeOfDay != TimeSpan.Zero)
|
|
plan.Issues.Add("发票日期必须是不含时间或时区的日期。");
|
|
if (invoiceLines.Count == 0)
|
|
plan.Issues.Add("发票至少需要一行有效明细。");
|
|
if (invoiceLines.Where(item => item != null && !string.IsNullOrWhiteSpace(item.LineId))
|
|
.GroupBy(item => item.LineId.Trim(), StringComparer.OrdinalIgnoreCase)
|
|
.Any(group => group.Count() > 1))
|
|
{
|
|
plan.Issues.Add("发票明细行 ID 必须唯一，禁止同一行被重复匹配。");
|
|
}
|
|
if (sources.Any(item => !ValidSource(item))
|
|
|| sources.Where(item => ValidSource(item))
|
|
.GroupBy(item => item.UniqueKey, StringComparer.OrdinalIgnoreCase)
|
|
.Any(group => group.Count() > 1))
|
|
{
|
|
plan.Issues.Add("采购来源返回了无效或重复的来源契约，已拒绝匹配。");
|
|
sources.Clear();
|
|
}
|
|
|
|
foreach (PurchaseInvoiceLine line in invoiceLines)
|
|
{
|
|
PurchaseInvoiceLineMatch match = MatchLine(invoice, line, sources, options);
|
|
plan.Lines.Add(match);
|
|
}
|
|
ValidateFinancialTotals(invoice, plan, options);
|
|
ApplyAggregateQuantityRules(plan, options);
|
|
ApplyExchangeRateRules(plan);
|
|
plan.Executable = plan.Issues.Count == 0
|
|
&& plan.Lines.Count > 0
|
|
&& plan.Lines.All(item => item.Status == InvoiceLineMatchStatus.Exact);
|
|
return plan;
|
|
}
|
|
|
|
private static PurchaseInvoiceLineMatch MatchLine(
|
|
PurchaseInvoiceDraft invoice,
|
|
PurchaseInvoiceLine line,
|
|
IEnumerable<PurchaseSourceLine> sources,
|
|
PurchaseInvoiceMatchOptions options)
|
|
{
|
|
PurchaseInvoiceLineMatch match = new PurchaseInvoiceLineMatch(line);
|
|
ValidateInvoiceLine(line, options, match.Issues);
|
|
if (match.Issues.Count > 0)
|
|
{
|
|
match.Status = InvoiceLineMatchStatus.Invalid;
|
|
return match;
|
|
}
|
|
|
|
List<PurchaseSourceLine> candidates = sources.Where(source =>
|
|
!source.Closed
|
|
&& !string.IsNullOrWhiteSpace(source.SourceOrderId)
|
|
&& !string.IsNullOrWhiteSpace(source.SourceLineId)
|
|
&& Same(source.SupplierCode, invoice.SupplierCode)
|
|
&& Same(source.CurrencyCode, invoice.CurrencyCode)
|
|
&& Same(source.MaterialCode, line.MaterialCode)
|
|
&& Same(source.Unit, line.Unit)
|
|
&& source.ExchangeRate > 0
|
|
&& source.RemainingQuantity + options.QuantityTolerance >= line.Quantity
|
|
&& PriceMatches(source.UnitPrice, line.UnitPrice, options)
|
|
&& Math.Abs(source.TaxRate - line.TaxRate) <= options.TaxRateTolerance)
|
|
.ToList();
|
|
|
|
foreach (PurchaseSourceLine candidate in candidates) match.Candidates.Add(candidate);
|
|
if (candidates.Count == 0)
|
|
{
|
|
match.Status = InvoiceLineMatchStatus.Unmatched;
|
|
match.Issues.Add("没有找到同时满足供应商、币种、物料、单位、汇率、未开票数量、单价和税率的来源行。");
|
|
return match;
|
|
}
|
|
|
|
if (!string.IsNullOrWhiteSpace(line.SourceOrderHint))
|
|
{
|
|
List<PurchaseSourceLine> hinted = candidates.Where(source =>
|
|
Same(source.SourceOrderId, line.SourceOrderHint)
|
|
|| Same(source.SourceOrderNumber, line.SourceOrderHint)).ToList();
|
|
if (hinted.Count == 1)
|
|
{
|
|
match.Status = InvoiceLineMatchStatus.Exact;
|
|
match.SelectedSource = hinted[0];
|
|
return match;
|
|
}
|
|
if (hinted.Count == 0)
|
|
match.Issues.Add("发票给出的来源单提示与候选采购单不一致。");
|
|
else
|
|
match.Issues.Add("来源单提示仍对应多个候选明细行。");
|
|
}
|
|
|
|
if (candidates.Count == 1 && string.IsNullOrWhiteSpace(line.SourceOrderHint))
|
|
{
|
|
match.Status = InvoiceLineMatchStatus.Exact;
|
|
match.SelectedSource = candidates[0];
|
|
return match;
|
|
}
|
|
|
|
match.Status = InvoiceLineMatchStatus.Ambiguous;
|
|
match.Issues.Add("存在多个合法来源行，必须由用户选择，模型不得猜测。");
|
|
return match;
|
|
}
|
|
|
|
private static void ValidateInvoiceLine(
|
|
PurchaseInvoiceLine line,
|
|
PurchaseInvoiceMatchOptions options,
|
|
IList<string> issues)
|
|
{
|
|
if (line == null)
|
|
{
|
|
issues.Add("发票明细不能为空。");
|
|
return;
|
|
}
|
|
if (!SafeText(line.LineId, 128)) issues.Add("发票明细行 ID 不能为空或格式无效。");
|
|
if (!SafeText(line.MaterialCode, 256)) issues.Add("物料必须先解析为有效的 ERP 物料编码。");
|
|
if (!SafeText(line.Unit, 64)) issues.Add("计量单位必须由 ERP 物料主数据唯一解析。");
|
|
if (!string.IsNullOrWhiteSpace(line.SourceOrderHint)
|
|
&& !SafeText(line.SourceOrderHint, 128))
|
|
issues.Add("来源采购单提示格式无效。");
|
|
if (line.Quantity <= 0) issues.Add("数量必须大于零。");
|
|
if (line.UnitPrice < 0) issues.Add("单价不能小于零。");
|
|
if (line.TaxRate < 0 || line.TaxRate > 1) issues.Add("税率必须使用 0 到 1 的小数格式。");
|
|
if (line.TaxAmount < 0) issues.Add("行税额不能小于零。");
|
|
if (line.LineAmount < 0) issues.Add("行金额不能小于零。");
|
|
|
|
if (issues.Count == 0 && options.LineAmountMode != InvoiceLineAmountMode.None)
|
|
{
|
|
decimal expectedLine;
|
|
decimal expectedTax;
|
|
try
|
|
{
|
|
expectedLine = Money(line.Quantity * line.UnitPrice, options.CurrencyScale);
|
|
expectedTax = options.LineAmountMode == InvoiceLineAmountMode.TaxInclusive
|
|
? Money(
|
|
line.TaxRate == 0
|
|
? 0
|
|
: line.LineAmount
|
|
- (line.LineAmount / (1 + line.TaxRate)),
|
|
options.CurrencyScale)
|
|
: Money(line.LineAmount * line.TaxRate, options.CurrencyScale);
|
|
}
|
|
catch (OverflowException)
|
|
{
|
|
issues.Add("数量、单价或税额计算溢出。");
|
|
return;
|
|
}
|
|
if (Math.Abs(expectedLine - line.LineAmount) > options.LineAmountTolerance)
|
|
issues.Add("行金额与数量、单价计算结果超出配置容差。");
|
|
if (Math.Abs(expectedTax - line.TaxAmount) > options.LineAmountTolerance)
|
|
issues.Add("行税额与金额、税率计算结果超出配置容差。");
|
|
}
|
|
}
|
|
|
|
private static void ValidateFinancialTotals(
|
|
PurchaseInvoiceDraft invoice,
|
|
PurchaseInvoiceMatchPlan plan,
|
|
PurchaseInvoiceMatchOptions options)
|
|
{
|
|
if (options.LineAmountMode == InvoiceLineAmountMode.None) return;
|
|
if (invoice.TotalWithoutTax < 0 || invoice.TaxAmount < 0
|
|
|| invoice.TotalWithTax <= 0)
|
|
{
|
|
plan.Issues.Add("发票不含税金额、税额或价税合计无效。");
|
|
return;
|
|
}
|
|
try
|
|
{
|
|
decimal withoutTax = 0;
|
|
decimal tax = 0;
|
|
decimal withTax = 0;
|
|
foreach (PurchaseInvoiceLine line in invoice.Lines.Where(item => item != null))
|
|
{
|
|
tax += line.TaxAmount;
|
|
if (options.LineAmountMode == InvoiceLineAmountMode.TaxInclusive)
|
|
{
|
|
withTax += line.LineAmount;
|
|
withoutTax += line.LineAmount - line.TaxAmount;
|
|
}
|
|
else
|
|
{
|
|
withoutTax += line.LineAmount;
|
|
withTax += line.LineAmount + line.TaxAmount;
|
|
}
|
|
}
|
|
plan.CalculatedTotalWithoutTax = Money(withoutTax, options.CurrencyScale);
|
|
plan.CalculatedTaxAmount = Money(tax, options.CurrencyScale);
|
|
plan.CalculatedTotalWithTax = Money(withTax, options.CurrencyScale);
|
|
if (Math.Abs(invoice.TotalWithoutTax - plan.CalculatedTotalWithoutTax)
|
|
> options.HeaderAmountTolerance)
|
|
plan.Issues.Add("发票不含税金额与明细汇总不一致。");
|
|
if (Math.Abs(invoice.TaxAmount - plan.CalculatedTaxAmount)
|
|
> options.HeaderAmountTolerance)
|
|
plan.Issues.Add("发票税额与明细税额汇总不一致。");
|
|
if (Math.Abs(invoice.TotalWithTax - plan.CalculatedTotalWithTax)
|
|
> options.HeaderAmountTolerance)
|
|
plan.Issues.Add("发票价税合计与明细汇总不一致。");
|
|
if (Math.Abs(
|
|
invoice.TotalWithoutTax + invoice.TaxAmount - invoice.TotalWithTax)
|
|
> options.HeaderAmountTolerance)
|
|
plan.Issues.Add("发票头不含税金额加税额不等于价税合计。");
|
|
}
|
|
catch (OverflowException)
|
|
{
|
|
plan.Issues.Add("发票金额汇总计算溢出。");
|
|
}
|
|
}
|
|
|
|
private static void ApplyAggregateQuantityRules(
|
|
PurchaseInvoiceMatchPlan plan,
|
|
PurchaseInvoiceMatchOptions options)
|
|
{
|
|
IEnumerable<IGrouping<string, PurchaseInvoiceLineMatch>> groups = plan.Lines
|
|
.Where(item => item.Status == InvoiceLineMatchStatus.Exact && item.SelectedSource != null)
|
|
.GroupBy(item => item.SelectedSource.UniqueKey, StringComparer.OrdinalIgnoreCase);
|
|
foreach (IGrouping<string, PurchaseInvoiceLineMatch> group in groups)
|
|
{
|
|
PurchaseSourceLine source = group.First().SelectedSource;
|
|
decimal requested = group.Sum(item => item.InvoiceLine.Quantity);
|
|
if (requested <= source.RemainingQuantity + options.QuantityTolerance) continue;
|
|
foreach (PurchaseInvoiceLineMatch item in group)
|
|
{
|
|
item.Status = InvoiceLineMatchStatus.Conflict;
|
|
item.Issues.Add("多行发票累计占用数量超过来源采购行的未开票数量。");
|
|
}
|
|
}
|
|
}
|
|
|
|
private static void ApplyExchangeRateRules(PurchaseInvoiceMatchPlan plan)
|
|
{
|
|
List<PurchaseInvoiceLineMatch> selected = plan.Lines
|
|
.Where(item => item.Status == InvoiceLineMatchStatus.Exact
|
|
&& item.SelectedSource != null)
|
|
.ToList();
|
|
if (selected.Count <= 1) return;
|
|
decimal minimum = selected.Min(item => item.SelectedSource.ExchangeRate);
|
|
decimal maximum = selected.Max(item => item.SelectedSource.ExchangeRate);
|
|
if (minimum > 0 && maximum - minimum <= ExchangeRateTolerance) return;
|
|
foreach (PurchaseInvoiceLineMatch item in selected)
|
|
{
|
|
item.Status = InvoiceLineMatchStatus.Conflict;
|
|
item.Issues.Add("同一张发票匹配到了不同汇率的采购来源，必须拆单或由财务确认汇率。");
|
|
}
|
|
}
|
|
|
|
private static bool PriceMatches(
|
|
decimal sourcePrice,
|
|
decimal invoicePrice,
|
|
PurchaseInvoiceMatchOptions options)
|
|
{
|
|
decimal allowed = Math.Max(
|
|
options.UnitPriceAbsoluteTolerance,
|
|
Math.Abs(sourcePrice) * options.UnitPriceRelativeTolerance);
|
|
return Math.Abs(sourcePrice - invoicePrice) <= allowed;
|
|
}
|
|
|
|
private static bool Same(string left, string right)
|
|
{
|
|
return string.Equals(
|
|
(left ?? string.Empty).Trim(),
|
|
(right ?? string.Empty).Trim(),
|
|
StringComparison.OrdinalIgnoreCase);
|
|
}
|
|
|
|
private static bool ValidSource(PurchaseSourceLine source)
|
|
{
|
|
return source != null
|
|
&& SafeText(source.SourceOrderId, 128)
|
|
&& SafeText(source.SourceOrderNumber, 128)
|
|
&& SafeText(source.SourceLineId, 128)
|
|
&& SafeText(source.SupplierCode, 64)
|
|
&& SafeText(source.CurrencyCode, 64)
|
|
&& SafeText(source.MaterialCode, 256)
|
|
&& SafeText(source.Unit, 64)
|
|
&& source.RemainingQuantity >= 0
|
|
&& source.UnitPrice >= 0
|
|
&& source.TaxRate >= 0
|
|
&& source.TaxRate <= 1
|
|
&& source.ExchangeRate > 0;
|
|
}
|
|
|
|
private static bool SafeText(string value, int maximum)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(value) || value.Length > maximum)
|
|
return false;
|
|
return !value.Any(char.IsControl);
|
|
}
|
|
|
|
private static void ValidateOptions(PurchaseInvoiceMatchOptions options)
|
|
{
|
|
if (options.QuantityTolerance < 0
|
|
|| options.QuantityTolerance > MaximumQuantityTolerance
|
|
|| options.UnitPriceAbsoluteTolerance < 0
|
|
|| options.UnitPriceAbsoluteTolerance > MaximumUnitPriceAbsoluteTolerance
|
|
|| options.UnitPriceRelativeTolerance < 0
|
|
|| options.UnitPriceRelativeTolerance > MaximumUnitPriceRelativeTolerance
|
|
|| options.TaxRateTolerance < 0
|
|
|| options.TaxRateTolerance > MaximumTaxRateTolerance
|
|
|| options.LineAmountTolerance < 0
|
|
|| options.LineAmountTolerance > MaximumLineAmountTolerance
|
|
|| options.HeaderAmountTolerance < 0
|
|
|| options.HeaderAmountTolerance > MaximumHeaderAmountTolerance
|
|
|| options.CurrencyScale < 0
|
|
|| options.CurrencyScale > 6
|
|
|| !Enum.IsDefined(typeof(InvoiceLineAmountMode), options.LineAmountMode))
|
|
{
|
|
throw new ArgumentOutOfRangeException(
|
|
"options",
|
|
"采购匹配容差或币种精度超出商用安全范围。");
|
|
}
|
|
}
|
|
|
|
private static decimal Money(decimal value, int scale)
|
|
{
|
|
return Math.Round(value, scale, MidpointRounding.AwayFromZero);
|
|
}
|
|
}
|
|
}
|