facturx 0.2.0 → 1.0.0

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

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Facturx
+  class Writer
+    module StageSupport
+      module Structure
+        private
+
+        def within_group(id, value, element:, parent:, represented_attributes: [])
+          group = Terms.group(id)
+          values = present_values(value)
+          accepted = tracker.observe_group?(group, count: values.size, path: group.xpath)
+          return unless accepted
+
+          values.each do |item|
+            write_group_item(group, item, element, parent, represented_attributes) { |node| yield(node, item) }
+          end
+        end
+
+        def each_group(id, values, element:, parent:, represented_attributes: [], &)
+          within_group(id, Array(values), element:, parent:, represented_attributes:, &)
+        end
+
+        def write_group_item(group, item, element, parent, represented_attributes)
+          if group.attribute
+            report_unrepresentable_attributes(group.id, item, model: group.model,
+                                                              represented_attributes:)
+          end
+          node = context.element(parent, element)
+          yield node
+          remove_if_empty(node)
+        end
+
+        def technical(parent, element, value, default: nil)
+          text = value.to_s
+          text = default.to_s if text.strip.empty?
+          return if text.strip.empty?
+
+          context.element(parent, element, text:)
+        end
+
+        def container(parent, element)
+          node = context.element(parent, element)
+          yield node
+          remove_if_empty(node)
+          node
+        end
+
+        def remove_if_empty(node)
+          node.remove if node.element_children.empty? && node.text.empty? && node.attribute_nodes.empty?
+        end
+
+        def report_unrepresentable_attributes(group_id, item, model: model_for(item), represented_attributes: [])
+          return unless item.is_a?(Data) && model_for(item) == model
+
+          group = Terms.group(group_id)
+          item.members.each do |attribute|
+            value = item.public_send(attribute)
+            next unless unrepresentable_attribute?(group, model, attribute, value, represented_attributes)
+
+            tracker.unrepresentable_attribute(group, model:, attribute:)
+          end
+        end
+
+        def report_unrepresentable_attribute(group_id, model:, attribute:)
+          tracker.unrepresentable_attribute(Terms.group(group_id), model:, attribute:)
+        end
+
+        def attribute_supported_in_group?(group, model, attribute)
+          Terms.all.any? { |term| term.group_id == group.id && term.model == model && term.attribute == attribute }
+        end
+
+        def unrepresentable_attribute?(group, model, attribute, value, represented_attributes)
+          populated?(value) && !represented_attributes.include?(attribute) &&
+            !attribute_supported_in_group?(group, model, attribute)
+        end
+
+        def populated?(value)
+          !value.nil? && (!value.respond_to?(:empty?) || !value.empty?)
+        end
+
+        def model_for(item)
+          item.class.name.split('::').last.gsub(/([a-z\\d])([A-Z])/, '\\1_\\2').downcase.to_sym
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Facturx
+  class Writer
+    module Stages
+      class DocumentContext < Stage
+        term_ids 'BT-23', 'BT-24'
+
+        def call
+          within_group('BG-2', document, element: 'rsm:ExchangedDocumentContext', parent: context.root,
+                                         represented_attributes: [:vat_point_date_code]) do |node,|
+            emit_context_parameter(node, 'BT-23', document.business_process,
+                                   'ram:BusinessProcessSpecifiedDocumentContextParameter')
+            guideline = document.guideline_urn || profile.guideline_urn
+            emit_context_parameter(node, 'BT-24', guideline, 'ram:GuidelineSpecifiedDocumentContextParameter')
+          end
+        end
+
+        private
+
+        def emit_context_parameter(parent, id, value, element)
+          if value
+            container(parent, element) { |node| emit(id, value, element: 'ram:ID', parent: node) }
+          else
+            emit(id, nil, element: 'ram:ID', parent: parent)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Facturx
+  class Writer
+    module Stages
+      class ExchangedDocument < Stage
+        term_ids 'BT-1', 'BT-3', 'BT-2', 'BT-22', 'BT-21'
+
+        def call
+          node = context.element(context.root, 'rsm:ExchangedDocument')
+          emit('BT-1', document.invoice_number, element: 'ram:ID', parent: node)
+          emit('BT-3', document.type_code, element: 'ram:TypeCode', parent: node)
+          issue_date(node)
+          notes(node)
+        end
+
+        private
+
+        def notes(parent)
+          each_group('BG-1', document.notes, element: 'ram:IncludedNote', parent:) do |note_node, note|
+            emit('BT-22', note.content, element: 'ram:Content', parent: note_node)
+            emit('BT-21', note.subject_code, element: 'ram:SubjectCode', parent: note_node)
+          end
+        end
+
+        def issue_date(parent)
+          emit_date(parent, 'BT-2', document.issue_date, wrapper: 'ram:IssueDateTime')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module Facturx
+  class Writer
+    module Stages
+      module TradeAgreementSupport
+        module Parties
+          private
+
+          def write_parties(parent)
+            seller(parent)
+            buyer(parent)
+            tax_representative(parent)
+          end
+
+          def seller(parent)
+            within_group('BG-4', document.seller, element: 'ram:SellerTradeParty', parent:,
+                                                  represented_attributes: %i[address contact]) do |node, party|
+              write_seller_identity(node, party)
+              write_seller_details(node, party)
+            end
+          end
+
+          def write_seller_identity(node, party)
+            emit_party_identifiers(node, party.identifiers, 'BT-29', 'BT-29-1')
+            emit('BT-27', party.name, element: 'ram:Name', parent: node)
+            emit('BT-33', party.description, element: 'ram:Description', parent: node)
+            legal_organization(node, party, 'BT-30', 'BT-30-1', trading_name_id: 'BT-28')
+          end
+
+          def write_seller_details(node, party)
+            emit_contact(node, party.contact, 'BG-6', self.class::SELLER_CONTACT)
+            emit_address(node, party.address, 'BG-5', self.class::SELLER_ADDRESS)
+            electronic_address(node, party.electronic_address, 'BT-34', 'BT-34-1')
+            emit_tax_registration(node, 'BT-31', party.vat_identifier, 'VA')
+            emit_tax_registration(node, 'BT-32', party.tax_identifier, 'FC')
+          end
+
+          def buyer(parent)
+            within_group('BG-7', document.buyer, element: 'ram:BuyerTradeParty', parent:,
+                                                 represented_attributes: %i[address contact]) do |node, party|
+              write_buyer_identity(node, party)
+              write_buyer_details(node, party)
+            end
+          end
+
+          def write_buyer_identity(node, party)
+            emit_party_identifiers(node, party.identifiers, 'BT-46', 'BT-46-1')
+            emit('BT-44', party.name, element: 'ram:Name', parent: node)
+            legal_organization(node, party, 'BT-47', 'BT-47-1', trading_name_id: 'BT-45')
+          end
+
+          def write_buyer_details(node, party)
+            emit_contact(node, party.contact, 'BG-9', self.class::BUYER_CONTACT)
+            emit_address(node, party.address, 'BG-8', self.class::BUYER_ADDRESS)
+            electronic_address(node, party.electronic_address, 'BT-49', 'BT-49-1')
+            emit_tax_registration(node, 'BT-48', party.vat_identifier, 'VA')
+          end
+
+          def tax_representative(parent)
+            within_group('BG-11', document.tax_representative, element: 'ram:SellerTaxRepresentativeTradeParty',
+                                                               parent:,
+                                                               represented_attributes: [:address]) do |node, party|
+              emit('BT-62', party.name, element: 'ram:Name', parent: node)
+              emit_address(node, party.address, 'BG-12', self.class::REPRESENTATIVE_ADDRESS)
+              emit_tax_registration(node, 'BT-63', party.vat_identifier, 'VA')
+            end
+          end
+
+          def legal_organization(parent, party, value_id, scheme_id, trading_name_id:)
+            legal = party.legal_registration
+            trading = party.trading_name
+            return observe_missing_legal_organization(value_id, scheme_id, trading_name_id) unless legal || trading
+
+            container(parent, 'ram:SpecifiedLegalOrganization') do |node|
+              emit_compound_identifier(node, legal, value_id:, scheme_id:, element: 'ram:ID')
+              emit(trading_name_id, trading, element: 'ram:TradingBusinessName', parent: node)
+            end
+          end
+
+          def observe_missing_legal_organization(value_id, scheme_id, trading_name_id)
+            observe?(value_id, nil)
+            observe?(scheme_id, nil, group_present: false)
+            observe?(trading_name_id, nil)
+            nil
+          end
+
+          def electronic_address(parent, identifier, value_id, scheme_id)
+            return observe_missing_identifier(value_id, scheme_id) unless identifier
+
+            container(parent, 'ram:URIUniversalCommunication') do |node|
+              emit_compound_identifier(node, identifier, value_id:, scheme_id:, element: 'ram:URIID')
+            end
+          end
+
+          def observe_missing_identifier(value_id, scheme_id)
+            observe?(value_id, nil)
+            observe?(scheme_id, nil, group_present: false)
+            nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/facturx/writer/stages/trade_agreement/references.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Facturx
+  class Writer
+    module Stages
+      module TradeAgreementSupport
+        module References
+          private
+
+          def write_references(parent)
+            document_references(parent)
+            additional_references(parent)
+            project(parent)
+          end
+
+          def document_references(parent)
+            emit_document_reference(parent, 'BT-14', document.sales_order_reference,
+                                    'ram:SellerOrderReferencedDocument')
+            emit_document_reference(parent, 'BT-13', document.purchase_order_reference,
+                                    'ram:BuyerOrderReferencedDocument')
+            emit_document_reference(parent, 'BT-12', document.contract_reference, 'ram:ContractReferencedDocument')
+          end
+
+          def additional_references(parent)
+            typed_reference(parent, 'BT-17', document.tender_or_lot_reference, '50')
+            invoiced_object_reference(parent)
+            each_group('BG-24', document.supporting_documents, element: 'ram:AdditionalReferencedDocument',
+                                                               parent:) do |node, item|
+              write_supporting_document(node, item)
+            end
+          end
+
+          def write_supporting_document(node, item)
+            emit('BT-122', item.reference, element: 'ram:IssuerAssignedID', parent: node)
+            emit('BT-124', item.external_location, element: 'ram:URIID', parent: node)
+            technical(node, 'ram:TypeCode', '916')
+            emit('BT-123', item.description, element: 'ram:Name', parent: node)
+            attachment(node, item)
+          end
+
+          def typed_reference(parent, id, value, type_code)
+            report_unrepresentable_reference_attributes(id, value, represented_attributes: [:id]) if value
+
+            unless value&.id
+              observe?(id, nil)
+              return
+            end
+
+            container(parent, 'ram:AdditionalReferencedDocument') do |node|
+              emit(id, value.id, element: 'ram:IssuerAssignedID', parent: node)
+              technical(node, 'ram:TypeCode', type_code)
+            end
+          end
+
+          def invoiced_object_reference(parent)
+            emit_invoiced_object(parent, document.invoiced_object_identifier, 'BT-18', 'BT-18-1')
+          end
+
+          def attachment(parent, item)
+            node = emit('BT-125', item.content, element: 'ram:AttachmentBinaryObject', parent:).first
+            present = !item.content.nil?
+            emit_attribute('BT-125-1', item.mime_code, node:, attribute: 'mimeCode', group_present: present)
+            emit_attribute('BT-125-2', item.filename, node:, attribute: 'filename', group_present: present)
+          end
+
+          def project(parent)
+            value = document.project_reference
+            return observe?('BT-11', nil) unless project_reference?(value)
+            return unless representable_project_reference?(value)
+
+            container(parent, 'ram:SpecifiedProcuringProject') do |node|
+              emit('BT-11', value.id, element: 'ram:ID', parent: node)
+              technical(node, 'ram:Name', value.name, default: value.id)
+            end
+          end
+
+          def project_reference?(value)
+            value && (value.id || value.name)
+          end
+
+          def representable_project_reference?(value)
+            report_unrepresentable_reference_attributes('BT-11', value, represented_attributes: %i[id name])
+            return true if value.id
+
+            unrepresentable('BT-11', 'Project reference requires an identifier')
+            false
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative 'trade_agreement/parties'
+require_relative 'trade_agreement/references'
+
+module Facturx
+  class Writer
+    module Stages
+      class TradeAgreement < Stage
+        include TradeAgreementSupport::Parties
+        include TradeAgreementSupport::References
+
+        SELLER_ADDRESS = {
+          postcode: 'BT-38', line_one: 'BT-35', line_two: 'BT-36', line_three: 'BT-162', city: 'BT-37',
+          country_code: 'BT-40', country_subdivision: 'BT-39'
+        }.freeze
+        BUYER_ADDRESS = {
+          postcode: 'BT-53', line_one: 'BT-50', line_two: 'BT-51', line_three: 'BT-163', city: 'BT-52',
+          country_code: 'BT-55', country_subdivision: 'BT-54'
+        }.freeze
+        REPRESENTATIVE_ADDRESS = {
+          postcode: 'BT-67', line_one: 'BT-64', line_two: 'BT-65', line_three: 'BT-164', city: 'BT-66',
+          country_code: 'BT-69', country_subdivision: 'BT-68'
+        }.freeze
+        SELLER_CONTACT = { name: 'BT-41', telephone: 'BT-42', email: 'BT-43' }.freeze
+        BUYER_CONTACT = { name: 'BT-56', telephone: 'BT-57', email: 'BT-58' }.freeze
+
+        term_ids(*%w[
+                   BT-10 BT-29 BT-29-1 BT-27 BT-33 BT-30 BT-30-1 BT-28 BT-41 BT-42 BT-43 BT-38 BT-35 BT-36
+                   BT-162 BT-37 BT-40 BT-39 BT-34 BT-34-1 BT-31 BT-32 BT-46 BT-46-1 BT-44 BT-47 BT-47-1 BT-45
+                   BT-56 BT-57 BT-58 BT-53 BT-50 BT-51 BT-163 BT-52 BT-55 BT-54 BT-49 BT-49-1 BT-48 BT-62 BT-67
+                   BT-64 BT-65 BT-164 BT-66 BT-69 BT-68 BT-63 BT-14 BT-13 BT-12 BT-17 BT-18 BT-18-1 BT-122 BT-124
+                   BT-123 BT-125 BT-125-1 BT-125-2 BT-11
+                 ])
+
+        def call
+          agreement = context.element(context.transaction, 'ram:ApplicableHeaderTradeAgreement')
+          emit('BT-10', document.buyer_reference, element: 'ram:BuyerReference', parent: agreement)
+          write_parties(agreement)
+          write_references(agreement)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Facturx
+  class Writer
+    module Stages
+      class TradeDelivery < Stage
+        ADDRESS_IDS = {
+          postcode: 'BT-78', line_one: 'BT-75', line_two: 'BT-76', line_three: 'BT-165', city: 'BT-77',
+          country_code: 'BT-80', country_subdivision: 'BT-79'
+        }.freeze
+
+        term_ids(*%w[BT-71 BT-71-1 BT-70 BT-78 BT-75 BT-76 BT-165 BT-77 BT-80 BT-79 BT-72 BT-16 BT-15])
+
+        def call
+          value = document.delivery
+          node = context.element(context.transaction, 'ram:ApplicableHeaderTradeDelivery')
+          delivery(node, value) if delivery_accepted?(value)
+          references(node)
+        end
+
+        private
+
+        def delivery_accepted?(value)
+          group = Terms.group('BG-13-00')
+          tracker.observe_group?(group, count: value ? 1 : 0, path: group.xpath)
+        end
+
+        def references(parent)
+          emit_document_reference(parent, 'BT-16', document.despatch_advice_reference,
+                                  'ram:DespatchAdviceReferencedDocument')
+          emit_document_reference(parent, 'BT-15', document.receiving_advice_reference,
+                                  'ram:ReceivingAdviceReferencedDocument')
+        end
+
+        def delivery(parent, value)
+          ship_to(parent, value)
+          delivery_date(parent, value.date)
+        end
+
+        def delivery_date(parent, value)
+          unless value
+            observe?('BT-72', nil)
+            return
+          end
+
+          container(parent, 'ram:ActualDeliverySupplyChainEvent') do |event|
+            emit_date(event, 'BT-72', value, wrapper: 'ram:OccurrenceDateTime')
+          end
+        end
+
+        def ship_to(parent, delivery)
+          party = delivery.party
+          location = delivery.location_identifier
+          present = party || location
+          within_group('BG-13', present, element: 'ram:ShipToTradeParty', parent:,
+                                         represented_attributes: %i[name address]) do |node,|
+            delivery_identifier(node, location)
+            emit('BT-70', party&.name, element: 'ram:Name', parent: node)
+            emit_address(node, party&.address, 'BG-15', ADDRESS_IDS)
+          end
+        end
+
+        def delivery_identifier(parent, value)
+          if value&.scheme_id
+            node = if observe?('BT-71', value.value)
+                     technical(parent, 'ram:GlobalID', format_identifier_value('BT-71', value.value))
+                   end
+            emit_attribute('BT-71-1', value.scheme_id, node:, attribute: 'schemeID', group_present: !node.nil?)
+          else
+            emit('BT-71', value&.value, element: 'ram:ID', parent:)
+            observe?('BT-71-1', nil, group_present: false)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Facturx
+  class Writer
+    module Stages
+      class TradeLines
+        class Agreement < Stage
+          PRICES = {
+            gross: { ids: %w[BT-148 BT-149-1 BT-150-1], element: 'ram:GrossPriceProductTradePrice' },
+            net: { ids: %w[BT-146 BT-149 BT-150], element: 'ram:NetPriceProductTradePrice' }
+          }.freeze
+
+          def initialize(context, quantity:)
+            super(context)
+            @quantity = quantity
+          end
+
+          def call(parent:, line:)
+            within_group('BG-29', line, element: 'ram:SpecifiedLineTradeAgreement', parent:) do |node, item|
+              buyer_order_reference(node, item.buyer_order_reference)
+              price(node, item.gross_price, kind: :gross)
+              price(node, item.net_price, kind: :net)
+            end
+          end
+
+          private
+
+          def buyer_order_reference(parent, value)
+            return observe?('BT-132', nil) unless value
+
+            report_unrepresentable_reference_attributes('BT-132', value, represented_attributes: [:line_id])
+
+            container(parent, 'ram:BuyerOrderReferencedDocument') do |node|
+              emit('BT-132', value.line_id, element: 'ram:LineID', parent: node)
+            end
+          end
+
+          def price(parent, value, kind:)
+            config = PRICES.fetch(kind)
+            return observe_missing_price(config, kind:) unless value
+            return unrepresentable(config.fetch(:ids).first, 'Price requires an amount') unless value.amount
+
+            represented_attributes = %i[amount basis_quantity]
+            represented_attributes << :discount if kind == :gross
+            report_unrepresentable_attributes('BG-29', value, represented_attributes:)
+
+            container(parent, config.fetch(:element)) do |node|
+              emit_price(node, value, config.fetch(:ids))
+              gross_discount(node, value.discount) if kind == :gross
+            end
+          end
+
+          def emit_price(parent, value, ids)
+            emit(ids[0], value.amount, element: 'ram:ChargeAmount', parent:)
+            @quantity.call(parent:, value: value.basis_quantity, amount_id: ids[1], unit_id: ids[2],
+                           element: 'ram:BasisQuantity')
+          end
+
+          def observe_missing_price(config, kind:)
+            config.fetch(:ids).each { |id| observe?(id, nil) }
+            return unless kind == :gross
+
+            observe?('BT-147-01', nil)
+            observe?('BT-147', nil)
+          end
+
+          def gross_discount(parent, value)
+            return observe_missing_discount? unless value
+            return unless observe?('BT-147-01', false) && observe?('BT-147-02', false)
+
+            emit_discount(parent, value)
+          end
+
+          def observe_missing_discount?
+            observe?('BT-147-01', nil)
+            observe?('BT-147-02', nil, group_present: false)
+            observe?('BT-147', nil)
+          end
+
+          def emit_discount(parent, value)
+            container(parent, 'ram:AppliedTradeAllowanceCharge') do |node|
+              container(node, 'ram:ChargeIndicator') do |indicator|
+                technical(indicator, 'udt:Indicator', format_identifier_value('BT-147-02', false))
+              end
+              emit('BT-147', value, element: 'ram:ActualAmount', parent: node)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Facturx
+  class Writer
+    module Stages
+      class TradeLines
+        class Product < Stage
+          def call(parent:, value:)
+            within_group('BG-31', value, element: 'ram:SpecifiedTradeProduct', parent:,
+                                         represented_attributes: %i[attributes classifications]) do |node, item|
+              identifiers(node, item)
+              emit('BT-153', item.name, element: 'ram:Name', parent: node)
+              emit('BT-154', item.description, element: 'ram:Description', parent: node)
+              attributes(node, item.attributes)
+              classifications(node, item.classifications)
+              origin_country(node, item.origin_country_code)
+            end
+          end
+
+          private
+
+          def identifiers(parent, item)
+            emit_compound_identifier(parent, item.global_identifier, value_id: 'BT-157', scheme_id: 'BT-157-1',
+                                                                     element: 'ram:GlobalID')
+            emit_identifier_value('BT-155', item.seller_identifier, 'ram:SellerAssignedID', parent)
+            emit_identifier_value('BT-156', item.buyer_identifier, 'ram:BuyerAssignedID', parent)
+          end
+
+          def attributes(parent, values)
+            each_group('BG-32', values, element: 'ram:ApplicableProductCharacteristic', parent:) do |node, item|
+              emit('BT-160', item.name, element: 'ram:Description', parent: node)
+              emit('BT-161', item.value, element: 'ram:Value', parent: node)
+            end
+          end
+
+          def classifications(parent, values)
+            emit_unrepresentable_classifications(parent, values)
+            emit_representable_classifications(parent, values)
+          end
+
+          def emit_unrepresentable_classifications(parent, values)
+            Array(values).reject { |item| classification_code?(item) }.each do |item|
+              classification(parent, item)
+            end
+          end
+
+          def emit_representable_classifications(parent, values)
+            items = Array(values).select { |item| classification_code?(item) }
+            return unless observe?('BT-158', items.map(&:code))
+
+            items.each { |item| classification(parent, item) }
+          end
+
+          def classification_code?(item)
+            !item.code.to_s.strip.empty?
+          end
+
+          def classification(parent, item)
+            container(parent, 'ram:DesignatedProductClassification') do |node|
+              code = technical(node, 'ram:ClassCode', format_identifier_value('BT-158', item.code))
+              emit_attribute('BT-158-1', item.list_id, node: code, attribute: 'listID', group_present: !code.nil?)
+              emit_attribute('BT-158-2', item.list_version_id, node: code, attribute: 'listVersionID',
+                                                               group_present: !code.nil?)
+            end
+          end
+
+          def origin_country(parent, value)
+            return observe?('BT-159', nil) unless value
+
+            container(parent, 'ram:OriginTradeCountry') do |node|
+              emit('BT-159', value, element: 'ram:ID', parent: node)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Facturx
+  class Writer
+    module Stages
+      class TradeLines
+        class Quantity < Stage
+          def call(parent:, value:, amount_id:, unit_id:, element:)
+            node = emit(amount_id, value&.value, element:, parent:).first
+            emit_attribute(unit_id, value&.unit_code, node:, attribute: 'unitCode',
+                                                      group_present: !node.nil?)
+          end
+        end
+      end
+    end
+  end
+end