tradedoc 0.1.0

data/lib/tradedoc/format/ubl/coder/date.rb

@@ -0,0 +1,21 @@
+module Tradedoc
+  module Format
+    module UBL
+      module Coder
+        class Date
+          def self.ruby_type
+            ::Date
+          end
+
+          def self.dump(w, obj, as:)
+            w.add("cbc:#{as}", obj.to_date.iso8601)
+          end
+
+          def self.parse(r)
+            ruby_type.parse(r.text)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tradedoc/format/ubl/coder/document_reference.rb

@@ -0,0 +1,55 @@
+module Tradedoc
+  module Format
+    module UBL
+      module Coder
+        class DocumentReference
+          DREF_SUFFIX = "DocumentReference"
+
+          # Element names are based on the document type.
+          # Map based on our internal document type IDs.
+          TYPE_MAP = {
+            commercial_invoice: "Invoice",
+            credit_note: "CreditNote",
+            debit_note: "DebitNote"
+          }
+
+          private_constant :DREF_SUFFIX, :TYPE_MAP
+
+          def self.ruby_type
+            Model::DocumentReference
+          end
+
+          def self.dump(w, obj, as:)
+            element_name_root = TYPE_MAP.fetch(obj.type.id)
+
+            w.add(as) do
+              w.add("cac:#{element_name_root}#{DREF_SUFFIX}") do
+                w.add("cbc:ID", obj.id)
+                w.add("cbc:UUID", obj.uuid)
+                w.render(obj.issue_date, as: "IssueDate")
+              end
+            end
+          end
+
+          def self.parse(r)
+            # The type of the document reference is embedded in the node name, so we
+            # have to match that manually to derive the type and pick the right child node.
+            dr_node = r.node.children.detect { it.node_name.end_with?(DREF_SUFFIX) }
+
+            return if dr_node.nil?
+
+            ruby_type.new.tap do |dr|
+              dr.type = TYPE_MAP.key(dr_node.node_name.delete_suffix(DREF_SUFFIX))
+
+              r.with_node(dr_node) do
+                r.parse("cbc:ID", :String) { dr.id = it }
+                r.parse("cbc:UUID", :String) { dr.uuid = it }
+                r.parse("cbc:IssueDate", :Date) { dr.issue_date = it }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tradedoc/format/ubl/coder/exchange_rate.rb

@@ -0,0 +1,33 @@
+module Tradedoc
+  module Format
+    module UBL
+      module Coder
+        class ExchangeRate
+          def self.ruby_type
+            Model::ExchangeRate
+          end
+
+          def self.dump(w, obj, as: "cac:ExchangeRate")
+            w.add(as) do
+              w.render(obj.source_currency_code, as: "cbc:SourceCurrencyCode")
+              w.render(obj.target_currency_code, as: "cbc:TargetCurrencyCode")
+              w.render(obj.market_id, as: "cbc:ExchangeMarketID")
+              w.render(obj.rate, as: "cbc:CalculationRate")
+              w.render(obj.date, as: "Date")
+            end
+          end
+
+          def self.parse(r)
+            ruby_type.new.tap do |xr|
+              r.parse("cbc:SourceCurrencyCode", :String) { xr.source_currency_code = it }
+              r.parse("cbc:TargetCurrencyCode", :String) { xr.target_currency_code = it }
+              r.parse("cbc:CalculationRate", :BigDecimal) { xr.rate = it }
+              r.parse("cbc:ExchangeMarketID", :String) { xr.market_id = it }
+              r.parse("cbc:Date", :Date) { xr.date = it }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tradedoc/format/ubl/coder/financial_account.rb

@@ -0,0 +1,32 @@
+module Tradedoc
+  module Format
+    module UBL
+      module Coder
+        class FinancialAccount
+          def self.ruby_type
+            Model::FinancialAccount
+          end
+
+          def self.dump(w, obj, as:)
+            w.add(as) do
+              w.add("cbc:ID", obj.account_number, schemeName: obj.scheme_name)
+              w.render(obj.financial_institution)
+            end
+          end
+
+          def self.parse(r)
+            ruby_type.new.tap do |obj|
+              r.with_node("cbc:ID") do
+                r.parse("@schemeName", :String) { obj.scheme_name = it }
+                r.parse("text()", :String) { obj.account_number = it }
+              end
+              r.parse("cac:FinancialInstitutionBranch", :FinancialInstitution) do
+                obj.financial_institution = it
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tradedoc/format/ubl/coder/financial_institution.rb

@@ -0,0 +1,42 @@
+module Tradedoc
+  module Format
+    module UBL
+      module Coder
+        class FinancialInstitution
+          def self.ruby_type
+            Model::FinancialInstitution
+          end
+
+          def self.dump(w, obj, as: "cac:FinancialInstitutionBranch")
+            w.add(as) do
+              w.add("cac:FinancialInstitution") do
+                # If there's no NCS, then this is a SWIFT code
+                scheme_name = if (ncs = obj.national_clearing_system)
+                  ncs.iso_code
+                else
+                  "SWIFTBIC"
+                end
+
+                w.add("cbc:ID", obj.id, schemeName: scheme_name)
+              end
+            end
+          end
+
+          def self.parse(r)
+            r.with_node("cac:FinancialInstitution") do
+              ruby_type.new.tap do |obj|
+                r.with_node("cbc:ID") do
+                  obj.id = r.text
+
+                  # Won't be present for SWIFT/BIC, and that's what we want
+                  obj.national_clearing_system =
+                    Tradedoc::Code::NationalClearingSystem.find_by_iso_code(r.attribute("schemeName"))
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tradedoc/format/ubl/coder/invoice.rb

@@ -0,0 +1,92 @@
+module Tradedoc
+  module Format
+    module UBL
+      module Coder
+        class Invoice
+          NS = {
+            "xmlns:inv" => "urn:oasis:names:specification:ubl:schema:xsd:Invoice-2",
+            "xmlns:cac" => "urn:oasis:names:specification:ubl:schema:xsd:CommonAggregateComponents-2",
+            "xmlns:cbc" => "urn:oasis:names:specification:ubl:schema:xsd:CommonBasicComponents-2",
+            "xmlns:ext" => "urn:oasis:names:specification:ubl:schema:xsd:CommonExtensionComponents-2"
+          }.freeze
+
+          private_constant :NS
+
+          def self.namespaces
+            NS
+          end
+
+          # @param xmldoc [Nokogiri::XML::Document]
+          def self.can_parse?(xmldoc)
+            xmldoc.root.namespace&.href == namespaces.fetch("xmlns:inv")
+          end
+
+          def self.ruby_type
+            Model::Invoice
+          end
+
+          def self.dump(w, obj)
+            w.add("inv:Invoice", NS) do
+              w.render(obj.specification_id, as: "cbc:CustomizationID")
+              w.render(obj.invoice_number, as: "cbc:ID")
+              w.render(obj.issue_date, as: "IssueDate")
+              w.render(obj.due_date, as: "DueDate")
+              w.render(obj.invoice_type_code, as: "cbc:InvoiceTypeCode", listAgencyID: Code::Agency::CEFACT)
+              w.render(obj.note, as: "cbc:Note")
+              w.render(obj.currency_code, as: "cbc:DocumentCurrencyCode", listAgencyID: Code::Agency::CEFACT)
+              w.render(obj.invoice_period, as: "InvoicePeriod")
+              if (po_number = obj.purchase_order_number)
+                w.add("cac:OrderReference") do
+                  w.render(po_number, as: "cbc:ID")
+                end
+              end
+              if (supplier = obj.supplier)
+                w.add("cac:AccountingSupplierParty") do
+                  w.render(supplier, as: "cac:Party")
+                end
+              end
+              if (buyer = obj.buyer)
+                w.add("cac:AccountingCustomerParty") do
+                  w.render(buyer, as: "cac:Party")
+                end
+              end
+              w.render(obj.monetary_total&.tax_breakdown)
+              w.render(obj.monetary_total)
+              w.render_list(obj.lines)
+            end
+          end
+
+          def self.parse(r)
+            ruby_type.new.tap do |inv|
+              r.with_node("inv:Invoice") do
+                r.parse("cbc:ID", :String) { inv.invoice_number = it }
+                r.parse("cbc:IssueDate", :Date) { inv.issue_date = it }
+                r.parse("cbc:DueDate", :Date) { inv.due_date = it }
+                r.parse("cbc:InvoiceTypeCode", :String) { inv.invoice_type_code = it }
+                r.parse("cbc:Note", :String) { inv.note = it }
+                r.parse("cbc:DocumentCurrencyCode", :String) { inv.currency_code = it }
+                r.parse("cac:InvoicePeriod", :Period) { inv.invoice_period = it }
+                r.parse("cac:AccountingSupplierParty", :TradeParty) { inv.supplier = it }
+                r.parse("cac:AccountingCustomerParty", :TradeParty) { inv.buyer = it }
+                r.parse_list("cac:PaymentMeans", :PaymentMeans) { inv.payment_means = it }
+                r.parse("cac:LegalMonetaryTotal", :MonetaryTotal) { inv.monetary_total = it }
+                r.parse("cac:TaxTotal", :TaxBreakdown) { inv.monetary_total.tax_breakdown = it }
+                r.parse_list("cac:InvoiceLine", :InvoiceLine) { inv.lines = it }
+
+                r.with_node("cac:OrderReference") do
+                  r.parse("cbc:ID", :String) { inv.purchase_order_number = it }
+                end
+
+                # The due date may have been put into payment means
+                # This is allowed per the Peppol docs
+                if inv.due_date.nil?
+                  r.parse("cac:PaymentMeans/cbc:PaymentDueDate", :Date) { inv.due_date = it }
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tradedoc/format/ubl/coder/invoice_line.rb

@@ -0,0 +1,53 @@
+module Tradedoc
+  module Format
+    module UBL
+      module Coder
+        class InvoiceLine
+          def self.ruby_type
+            Model::InvoiceLine
+          end
+
+          def self.dump(w, obj, as: "cac:InvoiceLine")
+            w.add(as) do
+              w.render(obj.id, as: "cbc:ID")
+              w.render(obj.invoiced_quantity, as: "cbc:InvoicedQuantity")
+              w.render(obj.total_excluding_tax, as: "LineExtensionAmount")
+              if (total_tax = obj.total_tax)
+                w.add("cac:TaxTotal") do
+                  w.render(total_tax, as: "TotalTax")
+                end
+              end
+
+              w.render(obj.product)
+
+              if (price = obj.price)
+                w.add("cac:Price") do
+                  w.render(price.net, as: "PriceAmount")
+                  w.render(price.base_quantity, as: "cbc:BaseQuantity")
+                end
+              end
+            end
+          end
+
+          def self.parse(r)
+            ruby_type.new.tap do |line|
+              r.parse("cbc:ID", :String) { line.id = it }
+              r.parse("cbc:InvoicedQuantity", :BigDecimal) { line.invoiced_quantity = it }
+              r.parse("cbc:LineExtensionAmount", :Money) { line.total_excluding_tax = it }
+              r.with_node("cac:TaxTotal") do
+                r.parse("cbc:TotalTax", :Money) { line.total_tax = it }
+              end
+              r.parse("cac:Item", :Product) { line.product = it }
+              r.with_node("cac:Price") do
+                line.price = Model::Price.new.tap do |price|
+                  r.parse("cbc:PriceAmount", :Money) { price.net = it }
+                  r.parse("cbc:BaseQuantity", :BigDecimal) { price.base_quantity = it }
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tradedoc/format/ubl/coder/monetary_total.rb

@@ -0,0 +1,39 @@
+module Tradedoc
+  module Format
+    module UBL
+      module Coder
+        class MonetaryTotal
+          def self.ruby_type
+            Model::MonetaryTotal
+          end
+
+          def self.dump(w, obj, as: "cac:LegalMonetaryTotal")
+            w.add(as) do
+              w.render(obj.line_items_tax_exclusive, as: "LineExtensionAmount")
+              w.render(obj.tax_exclusive, as: "TaxExclusiveAmount")
+              w.render(obj.tax_inclusive, as: "TaxInclusiveAmount")
+              w.render(obj.discounts, as: "AllowanceTotalAmount")
+              w.render(obj.charges, as: "ChargeTotalAmount")
+              w.render(obj.prepaid, as: "PrepaidAmount")
+              w.render(obj.rounding, as: "PayableRoundingAmount")
+              w.render(obj.payable, as: "PayableAmount")
+            end
+          end
+
+          def self.parse(r)
+            ruby_type.new.tap do |mt|
+              r.parse("cbc:LineExtensionAmount", :Money) { mt.line_items_tax_exclusive = it }
+              r.parse("cbc:TaxExclusiveAmount", :Money) { mt.tax_exclusive = it }
+              r.parse("cbc:TaxInclusiveAmount", :Money) { mt.tax_inclusive = it }
+              r.parse("cbc:AllowanceTotalAmount", :Money) { mt.discounts = it }
+              r.parse("cbc:ChargeTotalAmount", :Money) { mt.charges = it }
+              r.parse("cbc:PrepaidAmount", :Money) { mt.prepaid = it }
+              r.parse("cbc:PayableRoundingAmount", :Money) { mt.rounding = it }
+              r.parse("cbc:PayableAmount", :Money) { mt.payable = it }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tradedoc/format/ubl/coder/money.rb

@@ -0,0 +1,22 @@
+module Tradedoc
+  module Format
+    module UBL
+      module Coder
+        class Money
+          def self.ruby_type
+            ::Money
+          end
+
+          def self.dump(w, obj, as:, decimals: 2)
+            as_string = obj.to_d.round(decimals).to_s("F")
+            w.add("cbc:#{as}", as_string, currencyID: obj.currency.iso_code)
+          end
+
+          def self.parse(r)
+            ruby_type.from_amount(BigDecimal(r.text), r.attribute!("currencyID"))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tradedoc/format/ubl/coder/payment_means.rb

@@ -0,0 +1,39 @@
+module Tradedoc
+  module Format
+    module UBL
+      module Coder
+        class PaymentMeans
+          def self.ruby_type
+            Model::PaymentMeans
+          end
+
+          def self.dump(w, obj, as: "cac:PaymentMeans")
+            w.add(as) do
+              w.add("cbc:PaymentMeansCode", obj.type_code.code, listID: "UN/CE 4461", listAgencyID: Code::Agency::CEFACT)
+              w.render(obj.instruction_id, as: "cbc:InstructionID")
+              obj.messages.each do |msg|
+                w.add("cbc:InstructionNote", msg)
+              end
+              w.render(obj.payment_id, as: "cbc:PaymentID")
+              w.render(obj.sending_account, as: "cac:PayerFinancialAccount")
+              w.render(obj.receiving_account, as: "cac:PayeeFinancialAccount")
+            end
+          end
+
+          def self.parse(r)
+            ruby_type.new.tap do |obj|
+              r.parse("cbc:PaymentMeansCode", :String) { obj.type_code = it }
+              r.parse("cbc:PaymentID", :String) { obj.payment_id = it }
+              r.parse("cbc:InstructionID", :String) { obj.instruction_id = it }
+              r.with_nodes("cbc:InstructionNote") do
+                obj.messages.push(r.text)
+              end
+              r.parse("cac:PayerFinancialAccount", :FinancialAccount) { obj.sending_account = it }
+              r.parse("cac:PayeeFinancialAccount", :FinancialAccount) { obj.receiving_account = it }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tradedoc/format/ubl/coder/period.rb

@@ -0,0 +1,27 @@
+module Tradedoc
+  module Format
+    module UBL
+      module Coder
+        class Period
+          def self.ruby_type
+            Model::Period
+          end
+
+          def self.dump(w, obj, as:)
+            w.add("cac:#{as}") do
+              w.render(obj.start_date, as: "StartDate")
+              w.render(obj.end_date, as: "EndDate")
+            end
+          end
+
+          def self.parse(r)
+            ruby_type.new.tap do |obj|
+              r.parse("cbc:StartDate", :Date) { obj.start_date = it }
+              r.parse("cbc:EndDate", :Date) { obj.end_date = it }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tradedoc/format/ubl/coder/product.rb

@@ -0,0 +1,37 @@
+module Tradedoc
+  module Format
+    module UBL
+      module Coder
+        class Product
+          def self.ruby_type
+            Model::Product
+          end
+
+          def self.dump(w, obj, as: "cac:Item")
+            w.add(as) do
+              w.render(obj.description, as: "cbc:Description")
+              w.render(obj.name, as: "cbc:Name")
+              if (id = obj.seller_assigned_id)
+                w.add("cac:SellersItemIdentification") do
+                  w.render(id, as: "cbc:ID")
+                end
+              end
+              w.render(obj.tax_category, as: "cac:ClassifiedTaxCategory")
+            end
+          end
+
+          def self.parse(r)
+            ruby_type.new.tap do |prod|
+              r.parse("cbc:Description", :String) { prod.description = it }
+              r.parse("cbc:Name", :String) { prod.name = it }
+              r.with_node("cac:SellersItemIdentification") do
+                r.parse("cbc:ID", :String) { prod.seller_assigned_id = it }
+              end
+              r.parse("cac:ClassifiedTaxCategory", :TaxCategory) { prod.tax_category = it }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tradedoc/format/ubl/coder/remittance_advice.rb

@@ -0,0 +1,91 @@
+module Tradedoc
+  module Format
+    module UBL
+      module Coder
+        class RemittanceAdvice
+          NS = {
+            "xmlns:rad" => "urn:oasis:names:specification:ubl:schema:xsd:RemittanceAdvice-2",
+            "xmlns:cac" => "urn:oasis:names:specification:ubl:schema:xsd:CommonAggregateComponents-2",
+            "xmlns:cbc" => "urn:oasis:names:specification:ubl:schema:xsd:CommonBasicComponents-2"
+          }.freeze
+
+          private_constant :NS
+
+          def self.namespaces
+            NS
+          end
+
+          # @param xmldoc [Nokogiri::XML::Document]
+          def self.can_parse?(xmldoc)
+            xmldoc.root.namespace&.href == namespaces.fetch("xmlns:rad")
+          end
+
+          def self.ruby_type
+            Model::RemittanceAdvice
+          end
+
+          def self.dump(w, obj)
+            w.add("rad:RemittanceAdvice", NS) do
+              w.add("cbc:ID", obj.id)
+              w.render(obj.uuid, as: "cbc:UUID")
+              w.render(obj.issue_date, as: "IssueDate")
+              w.render(obj.note, as: "cbc:Note")
+
+              w.render(obj.total_payment_amount, as: "TotalPaymentAmount")
+              w.render(obj.invoice_period, as: "InvoicePeriod")
+
+              w.add("cac:AccountingCustomerParty") do
+                w.render(obj.buyer)
+              end
+
+              w.add("cac:AccountingSupplierParty") do
+                w.render(obj.supplier)
+              end
+
+              w.render(obj.payment_means)
+
+              obj.lines.each do |line|
+                w.add("cac:RemittanceAdviceLine") do
+                  w.add("cbc:ID", line.id)
+                  w.render(line.note, as: "cbc:Note")
+                  w.render(line.balance_amount, as: "BalanceAmount")
+                  w.render(line.document_reference, as: "cac:BillingReference")
+                  w.render(line.exchange_rate, as: "cac:ExchangeRate")
+                end
+              end
+            end
+          end
+
+          def self.parse(r)
+            obj = ruby_type.new
+
+            r.with_node("rad:RemittanceAdvice") do
+              r.parse("cbc:ID", :String) { obj.id = it }
+              r.parse("cbc:UUID", :String) { obj.uuid = it }
+              r.parse("cbc:IssueDate", :Date) { obj.issue_date = it }
+              r.parse("cbc:Note", :String) { obj.note = it }
+              r.parse("cbc:TotalPaymentAmount", :Money) { obj.total_payment_amount = it }
+              r.parse("cac:AccountingCustomerParty", :TradeParty) { obj.buyer = it }
+              r.parse("cac:AccountingSupplierParty", :TradeParty) { obj.supplier = it }
+              r.parse("cac:PaymentMeans", :PaymentMeans) { obj.payment_means = it }
+              r.parse("cac:InvoicePeriod", :Period) { obj.invoice_period = it }
+
+              r.with_nodes("cac:RemittanceAdviceLine") do
+                line = Model::RemittanceAdviceLine.new
+                r.parse("cbc:ID", :String) { line.id = it }
+                r.parse("cbc:Note", :String) { line.note = it }
+                r.parse("cbc:BalanceAmount", :Money) { line.balance_amount = it }
+                r.parse("cac:BillingReference", :DocumentReference) { line.document_reference = it }
+                r.parse("cac:ExchangeRate", :ExchangeRate) { line.exchange_rate = it }
+
+                obj.lines.push(line)
+              end
+            end
+
+            obj
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tradedoc/format/ubl/coder/string.rb

@@ -0,0 +1,21 @@
+module Tradedoc
+  module Format
+    module UBL
+      module Coder
+        class String
+          def self.ruby_type
+            ::String
+          end
+
+          def self.dump(w, obj, as:, **opts)
+            w.add(as, obj, **opts)
+          end
+
+          def self.parse(r, strip: true, nilify: true)
+            r.text(strip:, nilify:)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tradedoc/format/ubl/coder/tax_breakdown.rb

@@ -0,0 +1,27 @@
+module Tradedoc
+  module Format
+    module UBL
+      module Coder
+        class TaxBreakdown
+          def self.ruby_type
+            Model::TaxBreakdown
+          end
+
+          def self.dump(w, obj, as: "cac:TaxTotal")
+            w.add(as) do
+              w.render(obj.total_tax, as: "TaxAmount")
+              w.render_list(obj.subtotals, as: "cac:TaxSubtotal")
+            end
+          end
+
+          def self.parse(r)
+            ruby_type.new.tap do |tax|
+              r.parse("cbc:TaxAmount", :Money) { tax.total_tax = it }
+              r.parse_list("cac:TaxSubtotal", :TaxSubtotal) { tax.subtotals = it }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tradedoc/format/ubl/coder/tax_category.rb

@@ -0,0 +1,37 @@
+module Tradedoc
+  module Format
+    module UBL
+      module Coder
+        class TaxCategory
+          def self.ruby_type
+            Model::TaxCategory
+          end
+
+          def self.dump(w, obj, as: "cac:TaxCategory")
+            w.add(as) do
+              w.render(obj.code.edifact_id, as: "cbc:ID")
+              w.render(obj.rate_percent, as: "cbc:Percent")
+              w.render(obj.exemption_reason_code, as: "cbc:TaxExemptionReasonCode")
+              w.render(obj.exemption_reason, as: "cbc:TaxExemptionReason")
+              if (tax_scheme = obj.tax_scheme)
+                w.add("cac:TaxScheme") do
+                  w.render(tax_scheme, as: "cbc:ID")
+                end
+              end
+            end
+          end
+
+          def self.parse(r)
+            ruby_type.new.tap do |cat|
+              r.parse("cbc:ID", :String) { cat.code = it }
+              r.parse("cbc:Percent", :BigDecimal) { cat.rate_percent = it }
+              r.parse("cbc:TaxExemptionReason", :String) { cat.exemption_reason = it }
+              r.parse("cbc:TaxExemptionReasonCode", :String) { cat.exemption_reason_code = it }
+              r.parse("cac:TaxScheme/cbc:ID", :String) { cat.tax_scheme = it }
+            end
+          end
+        end
+      end
+    end
+  end
+end