facturx 0.2.0 → 1.0.0

data/lib/facturx/generate.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative 'attach'
+require_relative 'profile_resolver'
+require_relative 'writer'
+
+module Facturx
+  class Generate
+    def initialize(writer: Writer.new, attacher: Attach.new, profile_resolver: ProfileResolver.new)
+      @writer = writer
+      @attacher = attacher
+      @profile_resolver = profile_resolver
+    end
+
+    def call(pdf:, document:, profile:)
+      canonical_profile = @profile_resolver.call(profile)
+      xml = @writer.call(document:, profile: canonical_profile)
+      @attacher.call(pdf:, xml:)
+    end
+  end
+end

data/lib/facturx/profile_resolver.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative 'error'
+require_relative 'profile'
+require_relative 'profiles'
+
+module Facturx
+  class ProfileResolver
+    def initialize(profiles: Profiles)
+      @profiles = profiles
+    end
+
+    def call(profile)
+      canonical = resolve(profile)
+      return canonical unless profile.is_a?(Profile) && !profile.equal?(canonical)
+
+      unsupported!(profile)
+    rescue KeyError
+      unsupported!(profile)
+    end
+
+    private
+
+    def resolve(profile)
+      case profile
+      when Symbol then @profiles.fetch(profile)
+      when Profile
+        return unsupported!(profile) unless profile.id.is_a?(Symbol)
+
+        @profiles.fetch(profile.id)
+      else unsupported!(profile)
+      end
+    end
+
+    def unsupported!(profile)
+      identifier = profile.respond_to?(:id) ? profile.id : profile
+      raise UnsupportedProfileError.new('Factur-X profile is unsupported', profile: identifier)
+    end
+  end
+end

data/lib/facturx/reader/semantic_mapper/line_mapping.rb

@@ -34,7 +34,7 @@ module Facturx
       def line_reference_attributes(node, base)
         {
           buyer_order_reference: reference('BT-132', context: node, base_xpath: base, field: :line_id),
-          invoiced_object_identifier: identifier('BT-128', 'BT-128-1', context: node, base_xpath: base)
+          invoiced_object_identifier: line_invoiced_object_identifier(node, base)
         }
       end
 

data/lib/facturx/reader/semantic_mapper/line_references.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Facturx
+  class Reader
+    class SemanticMapper
+      private
+
+      def line_invoiced_object_identifier(parent, parent_base)
+        relative_path = './ram:SpecifiedLineTradeSettlement/ram:AdditionalReferencedDocument'
+        node = parent.at_xpath("#{relative_path}[ram:TypeCode='130']", NAMESPACES)
+        return unless node
+
+        technical_value('./ram:TypeCode', node)
+        base = "#{parent_base}/ram:SpecifiedLineTradeSettlement/ram:AdditionalReferencedDocument"
+        identifier('BT-128', 'BT-128-1', context: node, base_xpath: base)
+      end
+    end
+  end
+end

data/lib/facturx/reader/semantic_mapper/payment_mapping.rb

@@ -6,10 +6,13 @@ module Facturx
       private
 
       def payment
-        nodes = group_nodes('BG-16')
+        nodes = group_nodes('BG-16', collapse_if: method(:projected_credit_transfers?))
         base = group_xpath('BG-16')
         attributes = settlement_payment_attributes(nodes.first, base)
-        attributes.merge!(payment_means_attributes(nodes.first, base)) if nodes.first
+        if nodes.any?
+          attributes.merge!(payment_means_attributes(nodes, base,
+                                                     projected: projected_credit_transfers?(nodes)))
+        end
         return if attributes.empty?
 
         PaymentInstructions.new(**attributes)
@@ -22,18 +25,52 @@ module Facturx
         attributes.compact
       end
 
-      def payment_means_attributes(node, base)
-        provider = term_for(:credit_transfer, 'BG-16', :provider_identifier)
-        provider_identifier = identifier(provider&.id, context: node, base_xpath: base)
-        scalar_attributes(:payment_instructions, 'BG-16', context: node, base_xpath: base).merge(
-          credit_transfers: credit_transfers(node, base, provider_identifier),
-          payment_card: payment_card(node, base)
+      def payment_means_attributes(nodes, base, projected:)
+        attributes = scalar_attributes(:payment_instructions, 'BG-16', context: nodes.first, base_xpath: base)
+        payment_nodes = projected ? nodes : [nodes.first]
+        mark_repeated_payment_attributes(payment_nodes.drop(1), base) if projected
+        attributes.merge(
+          credit_transfers: credit_transfers(payment_nodes, base),
+          payment_card: payment_nodes.filter_map { |node| payment_card(node, base) }.first
         )
       end
 
-      def credit_transfers(parent, parent_base, provider_identifier)
-        group_nodes('BG-17', context: parent, base_xpath: parent_base).map do |node|
-          credit_transfer(node, provider_identifier)
+      def mark_repeated_payment_attributes(nodes, base)
+        %w[BT-81 BT-82].each do |term_id|
+          nodes.each { |node| @terms.mark_value(term_id, context: node, base_xpath: base) }
+        end
+      end
+
+      def projected_credit_transfers?(nodes)
+        return false unless nodes.size > 1
+        return false unless nodes.all? { |node| payment_account_count(node) == 1 }
+
+        repeated_payment_attributes?(nodes) && nodes.drop(1).all? { |node| supplemental_payment_node?(node) }
+      end
+
+      def repeated_payment_attributes?(nodes)
+        %w[ram:TypeCode ram:Information].all? do |xpath|
+          nodes.map { |node| node.at_xpath("./#{xpath}", NAMESPACES)&.text }.uniq.one?
+        end
+      end
+
+      def supplemental_payment_node?(node)
+        allowed = %w[TypeCode Information PayeePartyCreditorFinancialAccount
+                     PayeeSpecifiedCreditorFinancialInstitution]
+        node.element_children.all? { |child| allowed.include?(child.name) }
+      end
+
+      def payment_account_count(node)
+        node.xpath('./ram:PayeePartyCreditorFinancialAccount', NAMESPACES).size
+      end
+
+      def credit_transfers(parents, parent_base)
+        provider = term_for(:credit_transfer, 'BG-16', :provider_identifier)
+        parents.flat_map do |parent|
+          provider_identifier = identifier(provider&.id, context: parent, base_xpath: parent_base)
+          group_nodes('BG-17', context: parent, base_xpath: parent_base).map do |node|
+            credit_transfer(node, provider_identifier)
+          end
         end
       end
 

data/lib/facturx/reader/semantic_mapper.rb

@@ -21,6 +21,7 @@ module Facturx
         attributes = document_attributes(tax_breakdowns).merge(
           party_attributes, transaction_attributes, collection_attributes(tax_breakdowns.items)
         )
+        attributes[:tax_currency] ||= minimum_tax_currency(attributes[:currency])
         attributes[:totals] = totals(attributes[:currency], attributes[:tax_currency])
         Document.new(**attributes)
       end
@@ -31,6 +32,13 @@ module Facturx
 
       private
 
+      def minimum_tax_currency(currency)
+        return unless @profile.id == :minimum
+
+        nodes = @document.xpath("#{group_xpath('BG-22')}/ram:TaxTotalAmount", NAMESPACES)
+        nodes.filter_map { |node| node['currencyID'] }.find { |value| value != currency }
+      end
+
       def party_attributes
         {
           seller: party('BG-4', contact_group: 'BG-6', address_group: 'BG-5'),
@@ -63,5 +71,6 @@ require_relative 'semantic_mapper/party_mapping'
 require_relative 'semantic_mapper/delivery_mapping'
 require_relative 'semantic_mapper/payment_mapping'
 require_relative 'semantic_mapper/line_mapping'
+require_relative 'semantic_mapper/line_references'
 require_relative 'semantic_mapper/trade_mapping'
 require_relative 'semantic_mapper/helpers'

data/lib/facturx/reader/term_reader.rb

@@ -28,14 +28,13 @@ module Facturx
         materialize(term, selected, cardinality)
       end
 
-      def group_nodes(id, context: @document, base_xpath: nil, &)
+      def group_nodes(id, context: @document, base_xpath: nil, collapse_if: nil, &)
         group = active_group(id)
         return [].freeze unless group
 
-        nodes = context.xpath(relative_xpath(group.xpath, base_xpath), NAMESPACES).to_a
-        nodes.select!(&) if block_given?
+        nodes = select_group_nodes(group, context, base_xpath, &)
         cardinality = group.cardinalities.fetch(@profile.id)
-        diagnose_cardinality(group, nodes, cardinality)
+        diagnose_cardinality(group, cardinality_nodes(nodes, collapse_if), cardinality)
         nodes.each { |node| mark(node) }
         nodes.freeze
       end
@@ -71,6 +70,15 @@ module Facturx
 
       private
 
+      def select_group_nodes(group, context, base_xpath, &filter)
+        nodes = context.xpath(relative_xpath(group.xpath, base_xpath), NAMESPACES).to_a
+        filter ? nodes.select(&filter) : nodes
+      end
+
+      def cardinality_nodes(nodes, collapse_if)
+        collapse_if&.call(nodes) ? [nodes.first] : nodes
+      end
+
       def active_term(id)
         term = @registry.fetch(id)
         term if term.cardinalities.key?(@profile.id)

data/lib/facturx/reader.rb

@@ -9,17 +9,13 @@ require_relative 'reading'
 require_relative 'source_reader'
 require_relative 'terms'
 require_relative 'xml/parser'
+require_relative 'xml/namespaces'
 require_relative 'xml/profile_detector'
 
 module Facturx
   class Reader
-    CII_NAMESPACE = 'urn:un:unece:uncefact:data:standard:CrossIndustryInvoice:100'
-    NAMESPACES = {
-      'qdt' => 'urn:un:unece:uncefact:data:standard:QualifiedDataType:100',
-      'ram' => 'urn:un:unece:uncefact:data:standard:ReusableAggregateBusinessInformationEntity:100',
-      'rsm' => CII_NAMESPACE,
-      'udt' => 'urn:un:unece:uncefact:data:standard:UnqualifiedDataType:100'
-    }.freeze
+    CII_NAMESPACE = Xml::Namespaces::CII
+    NAMESPACES = Xml::Namespaces::MAP
     UNKNOWN_PROFILE_POLICIES = %i[fallback raise].freeze
 
     COLLABORATORS = %i[profile_resolver registry coercer profiles].freeze

data/lib/facturx/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Facturx
-  VERSION = '0.2.0'
+  VERSION = '1.0.0'
 end

data/lib/facturx/writer/context.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require 'nokogiri'
+require_relative '../xml/namespaces'
+
+module Facturx
+  class Writer
+    class Context
+      attr_reader :document, :profile, :tracker, :xml, :root
+
+      def initialize(document:, profile:, tracker:)
+        @document = document
+        @profile = profile
+        @tracker = tracker
+        @xml = Nokogiri::XML::Document.new
+        @xml.encoding = 'UTF-8'
+        @root = namespaced_node('rsm', 'CrossIndustryInvoice')
+        Xml::Namespaces::MAP.each { |prefix, uri| @root.add_namespace_definition(prefix, uri) }
+        @root.namespace = namespace('rsm')
+        @xml.root = @root
+      end
+
+      def transaction
+        @transaction ||= element(@root, 'rsm:SupplyChainTradeTransaction')
+      end
+
+      def element(parent, qualified_name, text: nil, attributes: {})
+        prefix, name = qualified_name.split(':', 2)
+        node = namespaced_node(prefix, name)
+        attributes.each { |attribute, value| node[attribute.to_s] = value }
+        node.content = text unless text.nil?
+        parent.add_child(node)
+        node
+      end
+
+      def to_xml
+        @xml.to_xml(encoding: 'UTF-8')
+      end
+
+      private
+
+      def namespaced_node(prefix, name)
+        node = Nokogiri::XML::Node.new(name, @xml)
+        node.namespace = namespace(prefix) if @root
+        node
+      end
+
+      def namespace(prefix)
+        @root&.namespace_definitions&.find { |item| item.prefix == prefix }
+      end
+    end
+  end
+end

data/lib/facturx/writer/stage.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative '../error'
+require_relative '../format'
+require_relative '../terms'
+require_relative 'stage_support/contact_details'
+require_relative 'stage_support/emission'
+require_relative 'stage_support/identifiers'
+require_relative 'stage_support/structure'
+
+module Facturx
+  class Writer
+    class Stage
+      include StageSupport::Emission
+      include StageSupport::Structure
+      include StageSupport::ContactDetails
+      include StageSupport::Identifiers
+
+      class << self
+        def term_ids(*ids)
+          @term_ids = ids.map(&:to_s).freeze unless ids.empty?
+          @term_ids || [].freeze
+        end
+      end
+
+      def initialize(context)
+        @context = context
+      end
+
+      private
+
+      attr_reader :context
+
+      def document
+        context.document
+      end
+
+      def profile
+        context.profile
+      end
+
+      def tracker
+        context.tracker
+      end
+    end
+  end
+end

data/lib/facturx/writer/stage_support/contact_details.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Facturx
+  class Writer
+    module StageSupport
+      module ContactDetails
+        ADDRESS_ELEMENTS = {
+          postcode: 'ram:PostcodeCode',
+          line_one: 'ram:LineOne',
+          line_two: 'ram:LineTwo',
+          line_three: 'ram:LineThree',
+          city: 'ram:CityName',
+          country_code: 'ram:CountryID',
+          country_subdivision: 'ram:CountrySubDivisionName'
+        }.freeze
+
+        private
+
+        def emit_date(parent, id, value, wrapper:, value_element: 'udt:DateTimeString')
+          unless value
+            emit(id, nil, element: value_element, parent:)
+            return
+          end
+
+          container(parent, wrapper) do |node|
+            emit(id, value, element: value_element, parent: node, attributes: { 'format' => '102' })
+          end
+        end
+
+        def emit_address(parent, address, group_id, ids)
+          within_group(group_id, address, element: 'ram:PostalTradeAddress', parent:) do |node, item|
+            ADDRESS_ELEMENTS.each do |attribute, element|
+              emit(ids.fetch(attribute), item.public_send(attribute), element:, parent: node)
+            end
+          end
+        end
+
+        def emit_contact(parent, contact, group_id, ids)
+          within_group(group_id, contact, element: 'ram:DefinedTradeContact', parent:) do |node, item|
+            emit(ids.fetch(:name), item.name, element: 'ram:PersonName', parent: node)
+            communication(node, ids.fetch(:telephone), item.telephone,
+                          'ram:TelephoneUniversalCommunication', 'ram:CompleteNumber')
+            communication(node, ids.fetch(:email), item.email, 'ram:EmailURIUniversalCommunication', 'ram:URIID')
+          end
+        end
+
+        def communication(parent, id, value, wrapper, element)
+          if value
+            container(parent, wrapper) { |node| emit(id, value, element:, parent: node) }
+          else
+            emit(id, nil, element:, parent:)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/facturx/writer/stage_support/emission.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Facturx
+  class Writer
+    module StageSupport
+      module Emission
+        private
+
+        def emit(id, value, **options)
+          term = Terms.fetch(id)
+          values = present_values(value)
+          return [] unless options.fetch(:group_present, true)
+
+          accepted = tracker.observe_term?(term, values:, path: term.xpath)
+          return [] unless accepted
+
+          values.filter_map { |item| emit_value(term, item, options) }
+        end
+
+        def emit_attribute(id, value, **options)
+          term = Terms.fetch(id)
+          values = present_values(value)
+          group_present = options.fetch(:group_present, !options.fetch(:node).nil?)
+          return unrepresentable(id, 'Qualifier requires its carrier') if !group_present && values.any?
+          return unless group_present
+
+          accepted = tracker.observe_term?(term, values:, path: term.xpath)
+          return unless accepted
+
+          emit_attribute_value(term, values, options)
+        end
+
+        def observe?(id, value, group_present: true)
+          return false unless group_present
+
+          term = Terms.fetch(id)
+          tracker.observe_term?(term, values: present_values(value), path: term.xpath)
+        end
+
+        def unrepresentable(id, message)
+          term = Terms.fetch(id)
+          tracker.invalid_term(term, error: FormattingError.new(message, path: term.xpath), path: term.xpath)
+        end
+
+        def present_values(value)
+          (value.is_a?(Array) ? value : [value]).compact
+        end
+
+        def format(value, term)
+          Format.call(value, term:)
+        rescue FormattingError => e
+          tracker.invalid_term(term, error: e, path: term.xpath)
+          nil
+        end
+
+        def emit_value(term, value, options)
+          formatted = format(value, term)
+          return unless formatted
+
+          context.element(
+            options.fetch(:parent),
+            options.fetch(:element),
+            text: formatted,
+            attributes: options.fetch(:attributes, {})
+          )
+        end
+
+        def emit_attribute_value(term, values, options)
+          node = options.fetch(:node)
+          return unless node && values.one?
+
+          formatted = format(values.first, term)
+          node[options.fetch(:attribute)] = formatted if formatted
+        end
+      end
+    end
+  end
+end

data/lib/facturx/writer/stage_support/identifiers.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module Facturx
+  class Writer
+    module StageSupport
+      module Identifiers
+        private
+
+        def emit_compound_identifier(parent, identifier, **options)
+          value_id = options.fetch(:value_id)
+          value = identifier&.value
+          node = emit(value_id, value, element: options.fetch(:element), parent:).first
+          emit_identifier_scheme(node, identifier, options)
+          node
+        end
+
+        def emit_party_identifiers(parent, identifiers, value_id, scheme_id)
+          items = Array(identifiers)
+          local, global = items.partition { |item| item.scheme_id.nil? }
+          missing, global = global.partition { |item| item.value.to_s.strip.empty? }
+          emit_global_identifiers(parent, missing, value_id, scheme_id)
+
+          return unless observe?(value_id, items.map(&:value))
+
+          emit_local_identifiers(parent, local, value_id)
+          emit_global_identifiers(parent, global, value_id, scheme_id)
+        end
+
+        def format_identifier_value(id, value)
+          return if value.nil?
+
+          format(value, Terms.fetch(id))
+        end
+
+        def emit_tax_registration(parent, id, identifier, scheme)
+          report_unrepresentable_identifier_scheme(id, identifier, represented_scheme: scheme)
+          value = identifier&.value
+          unless value
+            observe?(id, nil)
+            return
+          end
+
+          container(parent, 'ram:SpecifiedTaxRegistration') do |node|
+            emit(id, value, element: 'ram:ID', parent: node, attributes: { 'schemeID' => scheme })
+          end
+        end
+
+        def emit_document_reference(parent, id, reference, element, represented_attributes: [])
+          unless reference
+            observe?(id, nil)
+            return
+          end
+
+          represented = [:id, *represented_attributes]
+          report_unrepresentable_reference_attributes(id, reference, represented_attributes: represented)
+
+          container(parent, element) do |node|
+            emit(id, reference.id, element: 'ram:IssuerAssignedID', parent: node)
+          end
+        end
+
+        def emit_invoiced_object(parent, identifier, value_id, scheme_id)
+          unless identifier&.value
+            observe?(value_id, nil)
+            report_unrepresentable_identifier_scheme(scheme_id, identifier)
+            return
+          end
+
+          container(parent, 'ram:AdditionalReferencedDocument') do |node|
+            emit(value_id, identifier.value, element: 'ram:IssuerAssignedID', parent: node)
+            technical(node, 'ram:TypeCode', '130')
+            emit(scheme_id, identifier.scheme_id, element: 'ram:ReferenceTypeCode', parent: node)
+          end
+        end
+
+        def report_unrepresentable_reference_attributes(id, reference, represented_attributes: [])
+          %i[id line_id name issue_date].each do |attribute|
+            next unless reference.public_send(attribute) && !represented_attributes.include?(attribute)
+
+            unrepresentable(id, "Document reference #{attribute} cannot be represented")
+          end
+        end
+
+        def emit_identifier_value(id, identifier, element, parent)
+          report_unrepresentable_identifier_scheme(id, identifier)
+          emit(id, identifier&.value, element:, parent:)
+        end
+
+        def report_unrepresentable_identifier_scheme(id, identifier, represented_scheme: nil)
+          scheme_id = identifier&.scheme_id
+          return unless scheme_id && scheme_id != represented_scheme
+
+          unrepresentable(id, 'Identifier scheme cannot be represented')
+        end
+
+        def emit_identifier_scheme(node, identifier, options)
+          scheme_id = options[:scheme_id]
+          return unless scheme_id
+
+          emit_attribute(
+            scheme_id,
+            identifier&.scheme_id,
+            node:,
+            attribute: options.fetch(:scheme_attribute, 'schemeID'),
+            group_present: !node.nil?
+          )
+        end
+
+        def emit_local_identifiers(parent, identifiers, value_id)
+          identifiers.each do |item|
+            technical(parent, 'ram:ID', format_identifier_value(value_id, item.value))
+          end
+        end
+
+        def emit_global_identifiers(parent, identifiers, value_id, scheme_id)
+          identifiers.each do |item|
+            if item.value.to_s.strip.empty?
+              unrepresentable(value_id, 'Global identifier requires a value')
+              next
+            end
+
+            node = technical(parent, 'ram:GlobalID', format_identifier_value(value_id, item.value))
+            emit_attribute(scheme_id, item.scheme_id, node:, attribute: 'schemeID', group_present: true)
+          end
+        end
+      end
+    end
+  end
+end