facturx 0.2.0 → 1.1.0

data/lib/facturx/writer/stages/trade_settlement/parties.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Facturx
+  class Writer
+    module Stages
+      module TradeSettlementParties
+        private
+
+        def payee(parent)
+          within_group('BG-10', document.payee, element: 'ram:PayeeTradeParty', parent:) do |node, party|
+            emit_party_identifiers(node, party.identifiers, 'BT-60', 'BT-60-1')
+            emit('BT-59', party.name, element: 'ram:Name', parent: node)
+            payee_legal_organization(node, party)
+          end
+        end
+
+        def payee_legal_organization(parent, party)
+          legal = party.legal_registration
+          return missing_payee_registration? unless legal
+
+          container(parent, 'ram:SpecifiedLegalOrganization') do |node|
+            emit_compound_identifier(node, legal, value_id: 'BT-61', scheme_id: 'BT-61-1', element: 'ram:ID')
+          end
+        end
+
+        def missing_payee_registration?
+          observe?('BT-61', nil)
+          observe?('BT-61-1', nil, group_present: false)
+        end
+      end
+    end
+  end
+end

data/lib/facturx/writer/stages/trade_settlement/payment.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module Facturx
+  class Writer
+    module Stages
+      module TradeSettlementPayment
+        private
+
+        def payment_means(parent, payment)
+          value = payment if payment_means_present?(payment)
+          within_group('BG-16', value, element: 'ram:SpecifiedTradeSettlementPaymentMeans', parent:,
+                                       represented_attributes: %i[
+                                         remittance_information payment_card direct_debit credit_transfers
+                                       ]) do |node, item|
+            emit_payment_means(parent, node, item)
+          end
+        end
+
+        def emit_payment_means(parent, node, payment)
+          transfers = payment.credit_transfers
+          nodes = [node, *additional_payment_means(parent, transfers)]
+          means_code, means_text = payment_descriptions(node, payment)
+          duplicate_payment_terms(nodes.drop(1), means_code, means_text)
+          payment_card(node, payment.payment_card)
+          debtor_account(node, payment.direct_debit)
+          credit_transfers(nodes, transfers)
+        end
+
+        def payment_descriptions(parent, payment)
+          code = emit('BT-81', payment.means_code, element: 'ram:TypeCode', parent:).first&.text
+          text = emit('BT-82', payment.means_text, element: 'ram:Information', parent:).first&.text
+          [code, text]
+        end
+
+        def additional_payment_means(parent, transfers)
+          Array.new([Array(transfers).size - 1, 0].max) do
+            context.element(parent, 'ram:SpecifiedTradeSettlementPaymentMeans')
+          end
+        end
+
+        def duplicate_payment_terms(nodes, means_code, means_text)
+          nodes.each do |node|
+            technical(node, 'ram:TypeCode', means_code)
+            technical(node, 'ram:Information', means_text)
+          end
+        end
+
+        def payment_means_present?(payment)
+          return false unless payment
+
+          [payment.means_code, payment.means_text, payment.payment_card,
+           payment.direct_debit&.debtor_account_identifier, *payment.credit_transfers].any?
+        end
+
+        def payment_card(parent, value)
+          within_group('BG-18', value, element: 'ram:ApplicableTradeSettlementFinancialCard', parent:) do |node, card|
+            emit('BT-87', card.primary_account_number, element: 'ram:ID', parent: node)
+            emit('BT-88', card.holder_name, element: 'ram:CardholderName', parent: node)
+          end
+        end
+
+        def debtor_account(parent, value)
+          identifier = value&.debtor_account_identifier
+          return observe?('BT-91', nil) unless identifier
+
+          container(parent, 'ram:PayerPartyDebtorFinancialAccount') do |node|
+            emit_identifier_value('BT-91', identifier, 'ram:IBANID', node)
+          end
+        end
+
+        def credit_transfers(parents, values)
+          transfers = Array(values)
+          group = Terms.group('BG-17')
+          return unless tracker.observe_group?(group, count: transfers.size, path: group.xpath)
+
+          transfers.zip(parents).each { |item, parent| emit_credit_transfer(parent, item) }
+        end
+
+        def emit_credit_transfer(parent, transfer)
+          container(parent, 'ram:PayeePartyCreditorFinancialAccount') do |node|
+            emit_identifier_value('BT-84', transfer.account_identifier, 'ram:IBANID', node)
+            emit('BT-85', transfer.account_name, element: 'ram:AccountName', parent: node)
+          end
+          emit_provider(parent, transfer.provider_identifier)
+        end
+
+        def emit_provider(parent, identifier)
+          return observe?('BT-86', nil) unless identifier
+
+          container(parent, 'ram:PayeeSpecifiedCreditorFinancialInstitution') do |node|
+            emit_identifier_value('BT-86', identifier, 'ram:BICID', node)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/facturx/writer/stages/trade_settlement/summary.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Facturx
+  class Writer
+    module Stages
+      module TradeSettlementSummary
+        private
+
+        def payment_terms(parent, direct_debit)
+          values = [document.payment_terms, document.payment_due_date, direct_debit&.mandate_identifier]
+          return missing_payment_terms? unless values.any?
+
+          container(parent, 'ram:SpecifiedTradePaymentTerms') do |node|
+            emit('BT-20', document.payment_terms, element: 'ram:Description', parent: node)
+            emit_date(node, 'BT-9', document.payment_due_date, wrapper: 'ram:DueDateDateTime')
+            emit_identifier_value('BT-89', direct_debit&.mandate_identifier, 'ram:DirectDebitMandateID', node)
+          end
+        end
+
+        def missing_payment_terms?
+          observe?('BT-20', nil)
+          observe?('BT-9', nil)
+          observe?('BT-89', nil)
+        end
+
+        def totals(parent)
+          within_group('BG-22', document.totals, element: 'ram:SpecifiedTradeSettlementHeaderMonetarySummation',
+                                                 parent:) do |node, item|
+            emit_subtotals(node, item)
+            emit_tax_totals(node, item)
+            emit_balance(node, item)
+          end
+        end
+
+        def emit_subtotals(parent, totals)
+          emit('BT-106', totals.line_total, element: 'ram:LineTotalAmount', parent:)
+          emit('BT-108', totals.charge_total, element: 'ram:ChargeTotalAmount', parent:)
+          emit('BT-107', totals.allowance_total, element: 'ram:AllowanceTotalAmount', parent:)
+          emit('BT-109', totals.tax_basis_total, element: 'ram:TaxBasisTotalAmount', parent:)
+        end
+
+        def emit_tax_totals(parent, totals)
+          emit('BT-110', totals.tax_total, element: 'ram:TaxTotalAmount', parent:,
+                                           attributes: { 'currencyID' => document.currency })
+          emit_tax_total_in_tax_currency(parent, totals.tax_total_in_tax_currency)
+        end
+
+        def emit_tax_total_in_tax_currency(parent, value)
+          return observe?('BT-111', nil) unless value
+          return unrepresentable('BT-111', 'Tax total requires a distinct tax currency') unless distinct_tax_currency?
+
+          emit('BT-111', value, element: 'ram:TaxTotalAmount', parent:,
+                                attributes: { 'currencyID' => document.tax_currency })
+        end
+
+        def distinct_tax_currency?
+          tax_currency = document.tax_currency
+          !tax_currency.to_s.strip.empty? && tax_currency != document.currency
+        end
+
+        def emit_balance(parent, totals)
+          emit('BT-114', totals.rounding, element: 'ram:RoundingAmount', parent:)
+          emit('BT-112', totals.grand_total, element: 'ram:GrandTotalAmount', parent:)
+          emit('BT-113', totals.prepaid, element: 'ram:TotalPrepaidAmount', parent:)
+          emit('BT-115', totals.due_payable, element: 'ram:DuePayableAmount', parent:)
+        end
+
+        def preceding_invoices(parent)
+          each_group('BG-3', document.preceding_invoices,
+                     element: 'ram:InvoiceReferencedDocument', parent:) do |node, item|
+            emit('BT-25', item.id, element: 'ram:IssuerAssignedID', parent: node)
+            emit_date(node, 'BT-26', item.issue_date, wrapper: 'ram:FormattedIssueDateTime',
+                                                      value_element: 'qdt:DateTimeString')
+          end
+        end
+
+        def accounting_reference(parent)
+          value = document.buyer_accounting_reference
+          return observe?('BT-19', nil) unless value
+
+          container(parent, 'ram:ReceivableSpecifiedTradeAccountingAccount') do |node|
+            emit('BT-19', value, element: 'ram:ID', parent: node)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/facturx/writer/stages/trade_settlement/taxes.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module Facturx
+  class Writer
+    module Stages
+      module TradeSettlementTaxes
+        ADJUSTMENT_IDS = {
+          false => %w[BT-94 BT-93 BT-92 BT-98 BT-97 BT-95 BT-96],
+          true => %w[BT-101 BT-100 BT-99 BT-105 BT-104 BT-102 BT-103]
+        }.freeze
+        ADJUSTMENT_FIELDS = [
+          [:percentage, 'ram:CalculationPercent'],
+          [:base_amount, 'ram:BasisAmount'],
+          [:amount, 'ram:ActualAmount'],
+          [:reason_code, 'ram:ReasonCode'],
+          [:reason, 'ram:Reason']
+        ].freeze
+        private_constant :ADJUSTMENT_IDS, :ADJUSTMENT_FIELDS
+
+        private
+
+        def taxes(parent)
+          first = true
+          each_group('BG-23', document.tax_breakdowns, element: 'ram:ApplicableTradeTax', parent:,
+                                                       represented_attributes: [:type_code]) do |node, item|
+            emit_tax(node, item, include_tax_point: first)
+            first = false
+          end
+          return unless first
+
+          report_vat_point_attributes
+        end
+
+        def emit_tax(parent, tax, include_tax_point:)
+          emit('BT-117', tax.tax_amount, element: 'ram:CalculatedAmount', parent:)
+          technical(parent, 'ram:TypeCode', tax.type_code, default: 'VAT')
+          emit('BT-120', tax.exemption_reason, element: 'ram:ExemptionReason', parent:)
+          emit('BT-116', tax.basis_amount, element: 'ram:BasisAmount', parent:)
+          emit('BT-118', tax.category_code, element: 'ram:CategoryCode', parent:)
+          emit('BT-121', tax.exemption_reason_code, element: 'ram:ExemptionReasonCode', parent:)
+          tax_point_date(parent) if include_tax_point
+          tax_due_date_type(parent, tax, check_conflict: include_tax_point)
+          emit('BT-119', tax.rate, element: 'ram:RateApplicablePercent', parent:)
+        end
+
+        def tax_due_date_type(parent, tax, check_conflict:)
+          document_code = document.vat_point_date_code
+          if check_conflict && tax.due_date_type_code && document_code && tax.due_date_type_code != document_code
+            report_unrepresentable_attribute('BG-23', model: :document, attribute: :vat_point_date_code)
+          end
+          emit('BT-8', tax.due_date_type_code || document_code, element: 'ram:DueDateTypeCode', parent:)
+        end
+
+        def tax_point_date(parent)
+          emit_date(
+            parent, 'BT-7', document.vat_point_date, wrapper: 'ram:TaxPointDate', value_element: 'udt:DateString'
+          )
+        end
+
+        def report_vat_point_attributes
+          %i[vat_point_date vat_point_date_code].each do |attribute|
+            value = document.public_send(attribute)
+            report_unrepresentable_attribute('BG-23', model: :document, attribute:) if value
+          end
+        end
+
+        def billing_period(parent)
+          within_group('BG-14', document.billing_period, element: 'ram:BillingSpecifiedPeriod', parent:) do |node, item|
+            emit_date(node, 'BT-73', item.start_date, wrapper: 'ram:StartDateTime')
+            emit_date(node, 'BT-74', item.end_date, wrapper: 'ram:EndDateTime')
+          end
+        end
+
+        def adjustments(parent, values, group_id, indicator)
+          ids = ADJUSTMENT_IDS.fetch(indicator)
+          each_group(group_id, values, element: 'ram:SpecifiedTradeAllowanceCharge', parent:,
+                                       represented_attributes: [:indicator]) do |node, item|
+            emit_adjustment(node, item, group_id, indicator, ids)
+          end
+        end
+
+        def emit_adjustment(parent, adjustment, group_id, indicator, ids)
+          adjustment_indicator(parent, group_id, indicator)
+          emit_adjustment_values(parent, adjustment, ids)
+          adjustment_tax(parent, adjustment.tax, group_id, ids[5], ids[6])
+        end
+
+        def emit_adjustment_values(parent, adjustment, ids)
+          ADJUSTMENT_FIELDS.each_with_index do |(attribute, element), index|
+            emit(ids[index], adjustment.public_send(attribute), element:, parent:)
+          end
+        end
+
+        def adjustment_indicator(parent, group_id, value)
+          within_group("#{group_id}-0", value, element: 'ram:ChargeIndicator', parent:) do |node, indicator|
+            within_group("#{group_id}-1", indicator, element: 'udt:Indicator', parent: node) do |leaf, raw|
+              leaf.content = raw ? 'true' : 'false'
+            end
+          end
+        end
+
+        def adjustment_tax(parent, tax, group_id, category_id, rate_id)
+          return missing_adjustment_tax?(category_id, rate_id) unless tax
+
+          report_unrepresentable_attributes(group_id, tax, represented_attributes: %i[type_code category_code rate])
+
+          container(parent, 'ram:CategoryTradeTax') do |node|
+            technical(node, 'ram:TypeCode', tax.type_code, default: 'VAT')
+            emit(category_id, tax.category_code, element: 'ram:CategoryCode', parent: node)
+            emit(rate_id, tax.rate, element: 'ram:RateApplicablePercent', parent: node)
+          end
+        end
+
+        def missing_adjustment_tax?(category_id, rate_id)
+          observe?(category_id, nil)
+          observe?(rate_id, nil)
+        end
+      end
+    end
+  end
+end

data/lib/facturx/writer/stages/trade_settlement.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require_relative 'trade_settlement/parties'
+require_relative 'trade_settlement/payment'
+require_relative 'trade_settlement/taxes'
+require_relative 'trade_settlement/summary'
+
+module Facturx
+  class Writer
+    module Stages
+      class TradeSettlement < Stage
+        include TradeSettlementParties
+        include TradeSettlementPayment
+        include TradeSettlementTaxes
+        include TradeSettlementSummary
+
+        term_ids(*%w[
+                   BT-90 BT-83 BT-6 BT-5 BT-60 BT-60-1 BT-59 BT-61 BT-61-1 BT-81 BT-82 BT-87 BT-88 BT-91 BT-84
+                   BT-85 BT-86 BT-117 BT-120 BT-116 BT-118 BT-121 BT-7 BT-8 BT-119 BT-73 BT-74 BT-94 BT-93 BT-92
+                   BT-98 BT-97 BT-95 BT-96 BT-101 BT-100 BT-99 BT-105 BT-104 BT-102 BT-103 BT-20 BT-9 BT-89 BT-106
+                   BT-108 BT-107 BT-109 BT-110 BT-111 BT-114 BT-112 BT-113 BT-115 BT-25 BT-26 BT-19
+                 ])
+
+        def call
+          node = context.element(context.transaction, 'ram:ApplicableHeaderTradeSettlement')
+          payment = document.payment
+          emit_header(node, payment)
+          emit_content(node, payment)
+        end
+
+        private
+
+        def emit_header(parent, payment)
+          direct_debit = payment&.direct_debit
+          emit_identifier_value('BT-90', direct_debit&.creditor_identifier, 'ram:CreditorReferenceID', parent)
+          emit('BT-83', payment&.remittance_information, element: 'ram:PaymentReference', parent:)
+          emit('BT-6', tax_currency_term_value, element: 'ram:TaxCurrencyCode', parent:)
+          emit('BT-5', document.currency, element: 'ram:InvoiceCurrencyCode', parent:)
+        end
+
+        def tax_currency_term_value
+          return if profile.id == :minimum && document.totals&.tax_total_in_tax_currency
+
+          document.tax_currency
+        end
+
+        def emit_content(parent, payment)
+          payee(parent)
+          payment_means(parent, payment)
+          taxes(parent)
+          billing_period(parent)
+          document_adjustments(parent)
+          settlement_summary(parent, payment&.direct_debit)
+        end
+
+        def document_adjustments(parent)
+          adjustments(parent, document.allowances, 'BG-20', false)
+          adjustments(parent, document.charges, 'BG-21', true)
+        end
+
+        def settlement_summary(parent, direct_debit)
+          payment_terms(parent, direct_debit)
+          totals(parent)
+          preceding_invoices(parent)
+          accounting_reference(parent)
+        end
+      end
+    end
+  end
+end

data/lib/facturx/writer/tracker.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+require_relative '../error'
+require_relative '../validation'
+
+module Facturx
+  class Writer
+    class Tracker
+      attr_reader :profile
+
+      def initialize(profile:)
+        @profile = profile
+        @issues = []
+      end
+
+      def check_guideline(guideline_urn, path: nil)
+        return if guideline_urn.nil? || guideline_urn == profile.guideline_urn
+
+        add(
+          :profile_mismatch,
+          'Document guideline does not match the selected profile',
+          term_id: 'BT-24',
+          path:,
+          details: { expected: profile.guideline_urn, actual: guideline_urn }
+        )
+      end
+
+      def check_document(document, path: nil)
+        check_guideline(document.guideline_urn, path:)
+      end
+
+      def observe_group?(group, count:, path: nil)
+        definition_observed?(group, count, path)
+      end
+
+      def observe_term?(term, values:, path: nil)
+        definition_observed?(term, values.size, path)
+      end
+
+      def invalid_term(term, error:, path: nil)
+        raise TypeError, 'error must be a FormattingError' unless error.is_a?(FormattingError)
+
+        add(
+          :invalid_value,
+          error.message,
+          term_id: term.id,
+          group_id: term.group_id,
+          path: path || error.details[:path] || term.xpath,
+          details: error.details
+        )
+      end
+
+      def unrepresentable_attribute(group, model:, attribute:, path: nil)
+        add(
+          :unrepresentable_attribute,
+          'Model attribute cannot be represented in this group',
+          group_id: group.id,
+          path: path || group.xpath,
+          details: { model:, attribute: }
+        )
+      end
+
+      def report
+        Validation::Report.new(profile:, issues: @issues)
+      end
+
+      private
+
+      def definition_observed?(definition, count, path)
+        cardinality = definition.cardinalities[profile.id]
+        return forbidden?(definition, count, path) unless cardinality
+
+        missing(definition, path, cardinality) if count.zero? && required?(cardinality)
+        invalid_cardinality(definition, count, path, cardinality) if count > 1 && !repeated?(cardinality)
+        count.positive?
+      end
+
+      def forbidden?(definition, count, path)
+        return false if count.zero?
+
+        kind = definition_kind(definition)
+        add(
+          :"forbidden_#{kind}",
+          "#{kind.capitalize} is forbidden by the selected profile",
+          **definition_context(definition, path),
+          details: { profile: profile.id, count: }
+        )
+        false
+      end
+
+      def missing(definition, path, cardinality)
+        kind = definition_kind(definition)
+        add(
+          :"missing_required_#{kind}",
+          "Required #{kind} is missing",
+          **definition_context(definition, path),
+          details: { profile: profile.id, cardinality: }
+        )
+      end
+
+      def invalid_cardinality(definition, count, path, cardinality)
+        add(
+          :invalid_cardinality,
+          'Value count exceeds the profile cardinality',
+          **definition_context(definition, path),
+          details: { profile: profile.id, cardinality:, count: }
+        )
+      end
+
+      def add(code, message, **context)
+        @issues << Validation::Issue.new(code:, message:, layer: :document, **context)
+      end
+
+      def definition_context(definition, path)
+        if definition.respond_to?(:group_id)
+          { term_id: definition.id, group_id: definition.group_id, path: path || definition.xpath }
+        else
+          { group_id: definition.id, path: path || definition.xpath }
+        end
+      end
+
+      def definition_kind(definition)
+        definition.respond_to?(:group_id) ? 'term' : 'group'
+      end
+
+      def required?(cardinality) = cardinality.start_with?('1')
+
+      def repeated?(cardinality) = cardinality.end_with?('n')
+    end
+  end
+end

data/lib/facturx/writer.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require_relative 'error'
+require_relative 'terms'
+require_relative 'writer/context'
+require_relative 'writer/stage'
+require_relative 'writer/tracker'
+require_relative 'writer/stages/document_context'
+require_relative 'writer/stages/exchanged_document'
+require_relative 'writer/stages/trade_lines'
+require_relative 'writer/stages/trade_agreement'
+require_relative 'writer/stages/trade_delivery'
+require_relative 'writer/stages/trade_settlement'
+require_relative 'xml/schema_validator'
+require_relative 'xml/report_builder'
+
+module Facturx
+  class Writer
+    STAGES = [
+      Stages::DocumentContext,
+      Stages::ExchangedDocument,
+      Stages::TradeLines,
+      Stages::TradeAgreement,
+      Stages::TradeDelivery,
+      Stages::TradeSettlement
+    ].freeze
+    MODELED_TERM_IDS = STAGES.flat_map(&:term_ids).freeze
+
+    unless MODELED_TERM_IDS.sort == Terms.all.map(&:id).sort
+      raise 'Factur-X writer stages must cover every modeled term exactly once'
+    end
+
+    def initialize(schema_validator: Xml::SchemaValidator.new)
+      @schema_validator = schema_validator
+    end
+
+    def call(document:, profile:)
+      context = compile(document:, profile:)
+      report = validate_context(context, profile)
+      raise_invalid_document(profile, report) if report.invalid?
+
+      context.to_xml
+    end
+
+    def validate(document:, profile:)
+      validate_context(compile(document:, profile:), profile)
+    end
+
+    private
+
+    def compile(document:, profile:)
+      tracker = Tracker.new(profile:)
+      tracker.check_document(document, path: Terms.fetch('BT-24').xpath)
+      context = Context.new(document:, profile:, tracker:)
+      STAGES.each { |stage| stage.new(context).call }
+      context
+    end
+
+    def validate_context(context, profile)
+      report = context.tracker.report
+      return report if report.invalid?
+
+      @schema_validator.call(document: context.xml, profile:)
+      report
+    rescue XsdValidationError => e
+      Xml::ReportBuilder.xsd(profile, e)
+    end
+
+    def raise_invalid_document(profile, report)
+      raise InvalidDocumentError.new(
+        'Factur-X document does not conform to the selected profile',
+        profile: profile.id, report:, issues: report.issues
+      )
+    end
+  end
+end

data/lib/facturx/xml/namespaces.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Facturx
+  module Xml
+    module Namespaces
+      CII = 'urn:un:unece:uncefact:data:standard:CrossIndustryInvoice:100'
+      QUALIFIED = 'urn:un:unece:uncefact:data:standard:QualifiedDataType:100'
+      REUSABLE = 'urn:un:unece:uncefact:data:standard:ReusableAggregateBusinessInformationEntity:100'
+      UNQUALIFIED = 'urn:un:unece:uncefact:data:standard:UnqualifiedDataType:100'
+
+      MAP = {
+        'qdt' => QUALIFIED,
+        'ram' => REUSABLE,
+        'rsm' => CII,
+        'udt' => UNQUALIFIED
+      }.freeze
+    end
+  end
+end

data/lib/facturx/xml/parser.rb

@@ -8,7 +8,7 @@ module Facturx
     class Parser
       def call(xml:)
         unless xml.is_a?(String)
-          raise InvalidXmlError.new('XML must be provided as a byte String', input_class: xml.class.name)
+          raise InvalidSourceError.new('XML must be provided as a byte String', input_class: xml.class.name)
         end
 
         Nokogiri::XML::Document.parse(xml) { |config| config.strict.nonet }

data/lib/facturx/xml/profile_detector.rb

@@ -2,14 +2,12 @@
 
 require_relative '../profiles'
 require_relative '../error'
+require_relative 'namespaces'
 
 module Facturx
   module Xml
     class ProfileDetector
-      NAMESPACES = {
-        'ram' => 'urn:un:unece:uncefact:data:standard:ReusableAggregateBusinessInformationEntity:100',
-        'rsm' => 'urn:un:unece:uncefact:data:standard:CrossIndustryInvoice:100'
-      }.freeze
+      NAMESPACES = Namespaces::MAP
       GUIDELINE_XPATH = '/rsm:CrossIndustryInvoice/rsm:ExchangedDocumentContext/' \
                         'ram:GuidelineSpecifiedDocumentContextParameter/ram:ID'