facturx 0.2.0 → 1.0.0

data/lib/facturx/writer/stages/trade_lines/settlement.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Facturx
+  class Writer
+    module Stages
+      class TradeLines
+        class Settlement < Stage
+          ADJUSTMENT_IDS = {
+            'BG-27' => %w[BT-138 BT-137 BT-136 BT-140 BT-139],
+            'BG-28' => %w[BT-143 BT-142 BT-141 BT-145 BT-144]
+          }.freeze
+
+          def call(parent:, line:)
+            node = context.element(parent, 'ram:SpecifiedLineTradeSettlement')
+            line_tax(node, line.tax)
+            period(node, line.period)
+            adjustment_groups(node, line.allowances, 'BG-27', false)
+            adjustment_groups(node, line.charges, 'BG-28', true)
+            monetary_sum(node, line.net_amount)
+            line_invoiced_object(node, line.invoiced_object_identifier)
+            accounting_reference(node, 'BT-133', line.buyer_accounting_reference)
+          end
+
+          private
+
+          def line_tax(parent, value)
+            within_group('BG-30', value, element: 'ram:ApplicableTradeTax', parent:,
+                                         represented_attributes: [:type_code]) do |node, item|
+              technical(node, 'ram:TypeCode', item.type_code, default: 'VAT')
+              emit('BT-151', item.category_code, element: 'ram:CategoryCode', parent: node)
+              emit('BT-152', item.rate, element: 'ram:RateApplicablePercent', parent: node)
+            end
+          end
+
+          def period(parent, value)
+            within_group('BG-26', value, element: 'ram:BillingSpecifiedPeriod', parent:) do |node, item|
+              emit_date(node, 'BT-134', item.start_date, wrapper: 'ram:StartDateTime')
+              emit_date(node, 'BT-135', item.end_date, wrapper: 'ram:EndDateTime')
+            end
+          end
+
+          def adjustment_groups(parent, values, group_id, indicator)
+            ids = ADJUSTMENT_IDS.fetch(group_id)
+            each_group(group_id, values, element: 'ram:SpecifiedTradeAllowanceCharge', parent:,
+                                         represented_attributes: [:indicator]) do |node, item|
+              report_unrepresentable_attributes(group_id, item.tax) if item.tax
+              adjustment_indicator(node, group_id, indicator)
+              emit_adjustment_fields(node, item, ids)
+            end
+          end
+
+          def emit_adjustment_fields(parent, item, ids)
+            emit(ids[0], item.percentage, element: 'ram:CalculationPercent', parent:)
+            emit(ids[1], item.base_amount, element: 'ram:BasisAmount', parent:)
+            emit(ids[2], item.amount, element: 'ram:ActualAmount', parent:)
+            emit(ids[3], item.reason_code, element: 'ram:ReasonCode', parent:)
+            emit(ids[4], item.reason, element: 'ram:Reason', parent:)
+          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 monetary_sum(parent, value)
+            container(parent, 'ram:SpecifiedTradeSettlementLineMonetarySummation') do |node|
+              emit('BT-131', value, element: 'ram:LineTotalAmount', parent: node)
+            end
+          end
+
+          def line_invoiced_object(parent, value)
+            emit_invoiced_object(parent, value, 'BT-128', 'BT-128-1')
+          end
+
+          def accounting_reference(parent, id, value)
+            return observe?(id, nil) unless value
+
+            container(parent, 'ram:ReceivableSpecifiedTradeAccountingAccount') do |node|
+              emit(id, value, element: 'ram:ID', parent: node)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Facturx
+  class Writer
+    module Stages
+      class TradeLines < Stage
+        REPRESENTED_ATTRIBUTES = %i[
+          product gross_price net_price tax period allowances charges buyer_order_reference
+        ].freeze
+
+        term_ids(*%w[
+                   BT-126 BT-127 BT-157 BT-157-1 BT-155 BT-156 BT-153 BT-154 BT-160 BT-161 BT-158 BT-158-1
+                   BT-158-2 BT-159 BT-132 BT-148 BT-149-1 BT-150-1 BT-147-01 BT-147-02 BT-147 BT-146 BT-149
+                   BT-150 BT-129 BT-130 BT-151 BT-152 BT-134 BT-135 BT-138 BT-137 BT-136 BT-140 BT-139 BT-143
+                   BT-142 BT-141 BT-145 BT-144 BT-131 BT-128 BT-128-1 BT-133
+                 ])
+
+        def initialize(context)
+          super
+          quantity = Quantity.new(context)
+          @product = Product.new(context)
+          @agreement = Agreement.new(context, quantity:)
+          @settlement = Settlement.new(context)
+          @quantity = quantity
+        end
+
+        def call
+          each_group('BG-25', document.lines, element: 'ram:IncludedSupplyChainTradeLineItem',
+                                              parent: context.transaction,
+                                              represented_attributes: REPRESENTED_ATTRIBUTES) do |node, line|
+            line_document(node, line)
+            @product.call(parent: node, value: line.product)
+            @agreement.call(parent: node, line:)
+            delivery(node, line)
+            @settlement.call(parent: node, line:)
+          end
+        end
+
+        private
+
+        def line_document(parent, line)
+          container(parent, 'ram:AssociatedDocumentLineDocument') do |node|
+            emit('BT-126', line.id, element: 'ram:LineID', parent: node)
+            if line.note
+              container(node, 'ram:IncludedNote') do |note|
+                emit('BT-127', line.note, element: 'ram:Content', parent: note)
+              end
+            else
+              observe?('BT-127', nil)
+            end
+          end
+        end
+
+        def delivery(parent, line)
+          node = context.element(parent, 'ram:SpecifiedLineTradeDelivery')
+          @quantity.call(parent: node, value: line.quantity, amount_id: 'BT-129', unit_id: 'BT-130',
+                         element: 'ram:BilledQuantity')
+        end
+      end
+    end
+  end
+end
+
+require_relative 'trade_lines/quantity'
+require_relative 'trade_lines/product'
+require_relative 'trade_lines/agreement'
+require_relative 'trade_lines/settlement'

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.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require_relative 'conformance'
+require_relative 'error'
+require_relative 'terms'
+require_relative 'writer/context'
+require_relative 'writer/stage'
+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'
+
+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, tracker: Conformance::Tracker, stages: STAGES)
+      @schema_validator = schema_validator
+      @tracker_class = tracker
+      @stages = stages.freeze
+    end
+
+    def call(document:, profile:)
+      context = compile(document:, profile:)
+      report = context.tracker.report
+      raise_conformance_error(profile, report) if report.invalid?
+
+      @schema_validator.call(document: context.xml, profile:)
+      context.to_xml
+    end
+
+    def validate(document:, profile:)
+      compile(document:, profile:).tracker.report
+    end
+
+    private
+
+    def compile(document:, profile:)
+      tracker = @tracker_class.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 raise_conformance_error(profile, report)
+      raise ConformanceError.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/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'