@fin.cx/einvoice 8.2.1 → 8.2.3

package/ts/formats/validation/en16931.business-rules.validator.ts

@@ -4,6 +4,12 @@ import type { EInvoice } from '../../einvoice.js';
 import { CurrencyCalculator, areMonetaryValuesEqual } from '../utils/currency.utils.js';
 import { DecimalCurrencyCalculator } from '../utils/currency.calculator.decimal.js';
 import { Decimal } from '../utils/decimal.js';
+import {
+  computeDocumentTotals,
+  findInvalidItemAmounts,
+  getDocumentCalculator,
+  getTotalsSkippedResult,
+} from '../utils/document.totals.js';
 import type { ValidationResult, ValidationOptions } from './validation.types.js';
 
 /**
@@ -24,24 +30,34 @@ export class EN16931BusinessRulesValidator {
     // Initialize currency calculators if currency is available
     if (invoice.currency) {
       this.currencyCalculator = new CurrencyCalculator(invoice.currency);
-      this.decimalCalculator = new DecimalCurrencyCalculator(invoice.currency);
+      // the rounding the encoders use: the currency's minor unit, at most two decimals
+      this.decimalCalculator = getDocumentCalculator(invoice.currency);
     }
     
     // Document level rules (BR-01 to BR-65)
     this.validateDocumentRules(invoice);
     
-    // Calculation rules (BR-CO-*)
-    if (options.checkCalculations !== false) {
-      this.validateCalculationRules(invoice);
-    }
-    
-    // VAT rules (BR-S-*, BR-Z-*, BR-E-*, BR-AE-*, BR-IC-*, BR-G-*, BR-O-*)
-    if (options.checkVAT !== false) {
-      this.validateVATRules(invoice);
-    }
-    
-    // Line level rules (BR-21 to BR-30)
+    // Line level rules (BR-21 to BR-30), first: they report a line amount that is no number
     this.validateLineRules(invoice);
+
+    // The totals are computed from the line amounts; while one is no number they cannot be,
+    // so the rules that need them are skipped and the result says so
+    const invalidAmounts = findInvalidItemAmounts(invoice.items);
+    if (invalidAmounts.length > 0) {
+      if (options.checkCalculations !== false || options.checkVAT !== false) {
+        this.results.push(getTotalsSkippedResult(invalidAmounts, 'EN16931'));
+      }
+    } else {
+      // Calculation rules (BR-CO-*)
+      if (options.checkCalculations !== false) {
+        this.validateCalculationRules(invoice);
+      }
+      
+      // VAT rules (BR-S-*, BR-Z-*, BR-E-*, BR-AE-*, BR-IC-*, BR-G-*, BR-O-*)
+      if (options.checkVAT !== false) {
+        this.validateVATRules(invoice);
+      }
+    }
     
     // Allowances and charges rules
     if (options.checkAllowances !== false) {
@@ -292,18 +308,19 @@ export class EN16931BusinessRulesValidator {
     // BR-S-03: VAT category tax amount for standard rated
     vatGroups.forEach((group, rate) => {
       if (rate > 0) { // Standard rated
+        // the category amounts as EN 16931 computes them: the sum of the rounded line net
+        // amounts at the rate, and the tax on it rounded once (BR-S-08, BR-CO-17)
+        const documentGroup = useDecimal
+          ? computeDocumentTotals(invoice).vatGroups.find((groupArg) => groupArg.rate === rate)
+          : undefined;
         const expectedTaxableAmount = useDecimal
-          ? group.reduce((sum, item) => {
-              const unitPrice = new Decimal(item.unitNetPrice);
-              const quantity = new Decimal(item.unitQuantity);
-              return sum.add(unitPrice.multiply(quantity));
-            }, Decimal.ZERO)
+          ? documentGroup?.taxableAmount ?? Decimal.ZERO
           : group.reduce((sum, item) => 
               sum + (item.unitNetPrice * item.unitQuantity), 0
             );
         
         const expectedTaxAmount = useDecimal
-          ? this.decimalCalculator!.calculateVAT(expectedTaxableAmount, new Decimal(rate))
+          ? documentGroup?.taxAmount ?? Decimal.ZERO
           : (expectedTaxableAmount as number) * (rate / 100);
         
         // Find corresponding breakdown
@@ -408,9 +425,10 @@ export class EN16931BusinessRulesValidator {
         );
       }
       
-      // BR-24: Each Invoice line shall have an Invoice line net amount
-      const lineNetAmount = item.unitNetPrice * item.unitQuantity;
-      if (isNaN(lineNetAmount)) {
+      // BR-24: Each Invoice line shall have an Invoice line net amount; it is quantity × net
+      // price, so a quantity or net price that is no number leaves the line without one
+      const isAmount = (value: unknown) => typeof value === 'number' && Number.isFinite(value);
+      if (!isAmount(item.unitNetPrice) || !isAmount(item.unitQuantity)) {
         this.addError(
           'BR-24',
           `Invoice line ${index + 1} must have a valid net amount`,
@@ -418,8 +436,9 @@ export class EN16931BusinessRulesValidator {
         );
       }
       
-      // BR-CO-04: Each Invoice line shall be categorized with an Invoiced item VAT category code
-      if (item.vatPercentage === undefined) {
+      // BR-CO-04: Each Invoice line shall be categorized with an Invoiced item VAT category code;
+      // the envelope derives the category from the rate, which has to be a number
+      if (!isAmount(item.vatPercentage)) {
         this.addError(
           'BR-CO-04',
           `Invoice line ${index + 1} must have a VAT category code`,
@@ -579,34 +598,8 @@ export class EN16931BusinessRulesValidator {
    * Calculate total VAT using decimal arithmetic
    */
   private calculateTotalVATDecimal(invoice: EInvoice): Decimal {
-    let totalVAT = Decimal.ZERO;
-    
-    // Group items by VAT rate
-    const vatGroups = new Map<string, Decimal>();
-    
-    for (const item of invoice.items || []) {
-      const vatRate = item.vatPercentage || 0;
-      const rateKey = vatRate.toString();
-      
-      const unitPrice = new Decimal(item.unitNetPrice || 0);
-      const quantity = new Decimal(item.unitQuantity || 0);
-      const lineNet = unitPrice.multiply(quantity);
-      
-      if (vatGroups.has(rateKey)) {
-        vatGroups.set(rateKey, vatGroups.get(rateKey)!.add(lineNet));
-      } else {
-        vatGroups.set(rateKey, lineNet);
-      }
-    }
-    
-    // Calculate VAT for each group
-    for (const [rateKey, baseAmount] of vatGroups) {
-      const rate = new Decimal(rateKey);
-      const vat = this.decimalCalculator!.calculateVAT(baseAmount, rate);
-      totalVAT = totalVAT.add(vat);
-    }
-    
-    return totalVAT;
+    // the sum of the VAT category tax amounts, each rounded once (BR-CO-14, BR-CO-17)
+    return computeDocumentTotals(invoice).taxTotal;
   }
   
   private calculateDocumentAllowances(invoice: EInvoice): number {

package/ts/formats/validation/facturx.validator.ts

@@ -3,6 +3,7 @@
  * Implements validation for MINIMUM, BASIC, EN16931, and EXTENDED profiles
  */
 
+import { findInvalidItemAmounts, getTotalsSkippedResult } from '../utils/document.totals.js';
 import type { ValidationResult } from './validation.types.js';
 import type { EInvoice } from '../../einvoice.js';
 
@@ -211,9 +212,19 @@ export class FacturXValidator {
       return results;
     }
     
+    // The totals are computed from the line amounts; while one is no number the checks on
+    // totals are skipped and the result says so
+    const invalidAmounts = findInvalidItemAmounts(invoice.items);
+    const totalsComputable = invalidAmounts.length === 0;
+    if (!totalsComputable) {
+      results.push(getTotalsSkippedResult(invalidAmounts, 'FACTURX'));
+    }
+
     // Validate according to profile
-    results.push(...this.validateProfileRequirements(invoice, detectedProfile));
-    results.push(...this.validateProfileSpecificRules(invoice, detectedProfile));
+    results.push(...this.validateProfileRequirements(invoice, detectedProfile, totalsComputable));
+    if (totalsComputable) {
+      results.push(...this.validateProfileSpecificRules(invoice, detectedProfile));
+    }
     
     // Add profile-specific business rules
     if (detectedProfile === FacturXProfile.MINIMUM) {
@@ -267,12 +278,16 @@ export class FacturXValidator {
   /**
    * Validate field requirements for a specific profile
    */
-  private validateProfileRequirements(invoice: EInvoice, profile: FacturXProfile): ValidationResult[] {
+  private validateProfileRequirements(invoice: EInvoice, profile: FacturXProfile, totalsComputable = true): ValidationResult[] {
     const results: ValidationResult[] = [];
     const requirements = this.profileRequirements[profile];
+    const totalFields = ['totalInvoiceAmount', 'totalNetAmount', 'totalVatAmount'];
     
-    // Check mandatory fields
+    // Check mandatory fields; the totals only when they can be computed
     for (const field of requirements.mandatory) {
+      if (!totalsComputable && totalFields.includes(field)) {
+        continue;
+      }
       const value = this.getFieldValue(invoice, field);
       if (value === undefined || value === null || value === '') {
         results.push({

package/ts/formats/validation/vat-categories.validator.ts

@@ -1,4 +1,5 @@
 import * as plugins from '../../plugins.js';
+import { findInvalidItemAmounts, getTotalsSkippedResult } from '../utils/document.totals.js';
 import type { TAccountingDocItem } from '@tsclass/tsclass/dist_ts/finance/index.js';
 import type { EInvoice } from '../../einvoice.js';
 import { CurrencyCalculator } from '../utils/currency.utils.js';
@@ -50,6 +51,14 @@ export class VATCategoriesValidator {
       this.currencyCalculator = new CurrencyCalculator(invoice.currency);
     }
     
+    // The VAT breakdown is computed from the line amounts; while one is no number it cannot
+    // be, so these rules are skipped and the result says so (the line rules report the lines)
+    const invalidAmounts = findInvalidItemAmounts(invoice.items);
+    if (invalidAmounts.length > 0) {
+      this.results.push(getTotalsSkippedResult(invalidAmounts, 'EN16931'));
+      return this.results;
+    }
+
     // Group items by VAT category
     const itemsByCategory = this.groupItemsByVATCategory(invoice.items || []);
     const breakdownsByCategory = this.groupBreakdownsByCategory(invoice.taxBreakdown || []);