friendly_shipping 0.3.4 → 0.4.0

data/lib/friendly_shipping/services/ups/label_package_options.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'friendly_shipping/services/ups/label_item_options'
+
+module FriendlyShipping
+  module Services
+    class Ups
+      # Package properties relevant for generating a UPS shipping label
+      #
+      # @option reference_numbers [Hash] a Hash where keys are _reference number codes_ and
+      #   values are _reference number values_. Example: `{ reference_numbers: { xn: 'my_reference_1 }`
+      # @option delivery_confirmation [Symbol] Can be set to any key from PACKAGE_DELIVERY_CONFIRMATION_CODES.
+      #   Only possible for domestic shipments or shipments between the US and Puerto Rico.
+      class LabelPackageOptions < FriendlyShipping::PackageOptions
+        PACKAGE_DELIVERY_CONFIRMATION_CODES = {
+          delivery_confirmation: 1,
+          delivery_confirmation_signature_required: 2,
+          delivery_confirmation_adult_signature_required: 3
+        }.freeze
+
+        attr_reader :reference_numbers
+
+        def initialize(
+          reference_numbers: {},
+          delivery_confirmation: nil,
+          **kwargs
+        )
+          @reference_numbers = reference_numbers
+          @delivery_confirmation = delivery_confirmation
+          super kwargs.merge(item_options_class: LabelItemOptions)
+        end
+
+        def delivery_confirmation_code
+          PACKAGE_DELIVERY_CONFIRMATION_CODES[delivery_confirmation]
+        end
+
+        private
+
+        attr_reader :delivery_confirmation
+      end
+    end
+  end
+end

data/lib/friendly_shipping/services/ups/parse_money_element.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+module FriendlyShipping
+  module Services
+    class Ups
+      class ParseMoneyElement
+        def self.call(element)
+          return unless element
+
+          monetary_value = element.at('MonetaryValue').text.to_d
+          return if monetary_value.zero?
+
+          currency_code = element.at('CurrencyCode').text
+          currency = Money::Currency.new(currency_code)
+          amount = Money.new(monetary_value * currency.subunit_to_unit, currency)
+
+          surcharge_code = element.at('Code')&.text
+          label = surcharge_code ? UPS_SURCHARGE_CODES[surcharge_code] : element.name
+
+          [label, amount]
+        end
+
+        UPS_SURCHARGE_CODES = {
+          "100" => "ADDITIONAL HANDLING",
+          "110" => "COD",
+          "120" => "DELIVERY CONFIRMATION",
+          "121" => "SHIP DELIVERY CONFIRMATION",
+          "153" => "PKG EMAIL SHIP NOTIFICATION",
+          "154" => "PKG EMAIL RETURN NOTIFICATION",
+          "155" => "PKG EMAIL INBOUND RETURN NOTIFICATION",
+          "156" => "PKG EMAIL QUANTUM VIEW SHIP NOTIFICATION",
+          "157" => "PKG EMAIL QUANTUM VIEW EXCEPTION NOTIFICATION",
+          "158" => "PKG EMAIL QUANTUM VIEW DELIVERY NOTIFICATION",
+          "165" => "PKG FAX INBOUND RETURN NOTIFICATION",
+          "166" => "PKG FAX QUANTUM VIEW SHIP NOTIFICATION",
+          "171" => "SHIP EMAIL ERL NOTIFICATION",
+          "173" => "SHIP EMAIL SHIP NOTIFICATION",
+          "174" => "SHIP EMAIL RETURN NOTIFICATION",
+          "175" => "SHIP EMAIL INBOUND RETURN NOTIFICATION",
+          "176" => "SHIP EMAIL QUANTUM VIEW SHIP NOTIFICATION",
+          "177" => "SHIP EMAIL QUANTUM VIEW EXCEPTION NOTIFICATION",
+          "178" => "SHIP EMAIL QUANTUM VIEW DELIVERY NOTIFICATION",
+          "179" => "SHIP EMAIL QUANTUM VIEW NOTIFY",
+          "187" => "SHIP UPS ACCESS POINT NOTIFICATION",
+          "188" => "SHIP EEI FILING NOTIFICATION",
+          "189" => "SHIP UAP SHIPPER NOTIFICATION",
+          "190" => "EXTENDED AREA",
+          "200" => "DRY ICE",
+          "220" => "HOLD FOR PICKUP",
+          "240" => "ORIGIN CERTIFICATE",
+          "250" => "PRINT RETURN LABEL",
+          "258" => "EXPORT LICENSE VERIFICATION",
+          "260" => "PRINT N MAIL",
+          "270" => "RESIDENTIAL ADDRESS",
+          "280" => "RETURN SERVICE 1ATTEMPT",
+          "290" => "RETURN SERVICE 3ATTEMPT",
+          "300" => "SATURDAY DELIVERY",
+          "310" => "SATURDAY PICKUP",
+          "330" => "PKG VERBAL CONFIRMATION",
+          "350" => "ELECTRONIC RETURN LABEL",
+          "372" => "QUANTUM VIEW NOTIFY DELIVERY",
+          "374" => "UPS PREPARED SED FORM",
+          "375" => "FUEL SURCHARGE",
+          "376" => "DELIVERY AREA",
+          "377" => "LARGE PACKAGE",
+          "378" => "SHIPPER PAYS DUTY TAX",
+          "379" => "SHIPPER PAYS DUTY TAX UNPAID",
+          "400" => "INSURANCE",
+          "401" => "SHIP ADDITIONAL HANDLING",
+          "402" => "SHIPPER RELEASE",
+          "403" => "CHECK TO SHIPPER",
+          "404" => "UPS PROACTIVE RESPONSE",
+          "405" => "GERMAN PICKUP",
+          "406" => "GERMAN ROAD TAX",
+          "407" => "EXTENDED AREA PICKUP",
+          "410" => "RETURN OF DOCUMENT",
+          "430" => "PEAK SEASON",
+          "431" => "PEAK SEASON SURCHARGE - LARGE PACK",
+          "432" => "PEAK SEASON SURCHARGE - ADDITIONAL HANDLING",
+          "440" => "SHIP LARGE PACKAGE",
+          "441" => "CARBON NEUTRAL",
+          "442" => "PKG QV IN TRANSIT NOTIFICATION",
+          "443" => "SHIP QV IN TRANSIT NOTIFICATION",
+          "444" => "IMPORT CONTROL",
+          "445" => "COMMERCIAL INVOICE REMOVAL",
+          "446" => "IMPORT CONTROL ELECTRONIC LABEL",
+          "447" => "IMPORT CONTROL PRINT LABEL",
+          "448" => "IMPORT CONTROL PRINT AND MAIL LABEL",
+          "449" => "IMPORT CONTROL ONE PICK UP ATTEMPT LABEL",
+          "450" => "IMPORT CONTROL THREE PICK UP ATTEMPT LABEL",
+          "452" => "REFRIGERATION",
+          "454" => "PAC 1A BOX1",
+          "455" => "PAC 3A BOX1",
+          "456" => "PAC 1A BOX2",
+          "457" => "PAC 3A BOX2",
+          "458" => "PAC 1A BOX3",
+          "459" => "PAC 3A BOX3",
+          "460" => "PAC 1A BOX4",
+          "461" => "PAC 3A BOX4",
+          "462" => "PAC 1A BOX5",
+          "463" => "PAC 3A BOX5",
+          "464" => "EXCHANGE PRINT RETURN LABEL",
+          "465" => "EXCHANGE FORWARD",
+          "466" => "SHIP PREALERT NOTIFICATION",
+          "470" => "COMMITTED DELIVERY WINDOW",
+          "480" => "SECURITY SURCHARGE",
+          "492" => "CUSTOMER TRANSACTION FEE",
+          "500" => "SHIPMENT COD",
+          "510" => "LIFT GATE FOR PICKUP",
+          "511" => "LIFT GATE FOR DELIVERY",
+          "512" => "DROP OFF AT UPS FACILITY",
+          "515" => "UPS PREMIUM CARE",
+          "520" => "OVERSIZE PALLET",
+          "530" => "FREIGHT DELIVERY SURCHARGE",
+          "531" => "FREIGHT PICKUP SURCHARGE",
+          "540" => "DIRECT TO RETAIL",
+          "541" => "DIRECT DELIVERY ONLY",
+          "542" => "DELIVER TO ADDRESSEE ONLY",
+          "543" => "DIRECT TO RETAIL COD",
+          "544" => "RETAIL ACCESS POINT545 SHIPPING TICKET NOTIFICATION",
+          "546" => "ELECTRONIC PACKAGE RELEASE AUTHENTICATION",
+          "547" => "PAY AT STORE"
+        }.freeze
+        private_constant :UPS_SURCHARGE_CODES
+      end
+    end
+  end
+end

data/lib/friendly_shipping/services/ups/parse_rate_response.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'friendly_shipping/services/ups/parse_xml_response'
+require 'friendly_shipping/services/ups/parse_money_element'
 
 module FriendlyShipping
   module Services
@@ -24,16 +25,16 @@ module FriendlyShipping
               sm.service_code == service_code && shipment.origin.country.in?(sm.origin_countries)
             end
             days_to_delivery = rated_shipment.at('GuaranteedDaysToDelivery').text.to_i
-            currency = Money::Currency.new(rated_shipment.at('TotalCharges/CurrencyCode').text)
-            total_cents = rated_shipment.at('TotalCharges/MonetaryValue').text.to_d * currency.subunit_to_unit
-            insurance_price = rated_shipment.at('ServiceOptionsCharges/MonetaryValue').text.to_f
-            negotiated_rate = rated_shipment.at(
-              'NegotiatedRates/NetSummaryCharges/GrandTotal/MonetaryValue'
-            )&.text.to_f
+
+            total = ParseMoneyElement.call(rated_shipment.at('TotalCharges')).last
+            insurance_price = ParseMoneyElement.call(rated_shipment.at('ServiceOptionsCharges'))&.last
+            negotiated_rate = ParseMoneyElement.call(
+              rated_shipment.at('NegotiatedRates/NetSummaryCharges/GrandTotal')
+            )&.last
 
             FriendlyShipping::Rate.new(
               shipping_method: shipping_method,
-              amounts: { total: Money.new(total_cents, currency) },
+              amounts: { total: total },
               warnings: [rated_shipment.at("RatedShipmentWarning")&.text].compact,
               errors: [],
               data: {

data/lib/friendly_shipping/services/ups/parse_shipment_accept_response.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require 'dry/monads/result'
+require 'friendly_shipping/services/ups/parse_money_element'
+
+module FriendlyShipping
+  module Services
+    class Ups
+      class ParseShipmentAcceptResponse
+        extend Dry::Monads::Result::Mixin
+
+        class << self
+          def call(request:, response:)
+            parsing_result = ParseXMLResponse.call(response.body, 'ShipmentAcceptResponse')
+            parsing_result.fmap do |xml|
+              FriendlyShipping::ApiResult.new(
+                build_labels(xml),
+                original_request: request,
+                original_response: response
+              )
+            end
+          end
+
+          private
+
+          def build_labels(xml)
+            packages = xml.xpath('//ShipmentAcceptResponse/ShipmentResults/PackageResults')
+            form_format = xml.at('Form/Image/ImageFormat/Code')&.text
+            encoded_form = xml.at('Form/Image/GraphicImage')&.text
+            decoded_form = encoded_form ? Base64.decode64(encoded_form) : nil
+            packages.map do |package|
+              cost_breakdown = build_cost_breakdown(package)
+              package_cost = cost_breakdown.values.any? ? cost_breakdown.values.sum : nil
+              encoded_label_data = package.at('LabelImage/GraphicImage')&.text
+              FriendlyShipping::Label.new(
+                tracking_number: package.at('TrackingNumber').text,
+                label_data: encoded_label_data ? Base64.decode64(encoded_label_data) : nil,
+                label_format: package.at('LabelImage/LabelImageFormat/Code')&.text,
+                cost: package_cost,
+                shipment_cost: get_shipment_cost(xml),
+                data: {
+                  cost_breakdown: cost_breakdown,
+                  negotiated_rate: get_negotiated_rate(xml),
+                  form_format: form_format,
+                  form: decoded_form,
+                  customer_context: xml.xpath('//TransactionReference/CustomerContext')&.text
+                }.compact
+              )
+            end
+          end
+
+          def build_cost_breakdown(package)
+            cost_elements = [
+              package.at('BaseServiceCharge'),
+              package.at('ServiceOptionsCharges'),
+              package.xpath('ItemizedCharges')
+            ].flatten
+
+            cost_elements.map { |element| ParseMoneyElement.call(element) }.compact.to_h
+          end
+
+          def get_shipment_cost(shipment_xml)
+            total_charges_element = shipment_xml.at('ShipmentResults/ShipmentCharges/TotalCharges')
+            ParseMoneyElement.call(total_charges_element).last
+          end
+
+          def get_negotiated_rate(shipment_xml)
+            negotiated_total_element = shipment_xml.at('NegotiatedRates/NetSummaryCharges/GrandTotal')
+            ParseMoneyElement.call(negotiated_total_element)&.last
+          end
+        end
+      end
+    end
+  end
+end

data/lib/friendly_shipping/services/ups/parse_shipment_confirm_response.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'dry/monads/result'
+
+module FriendlyShipping
+  module Services
+    class Ups
+      class ParseShipmentConfirmResponse
+        def self.call(request:, response:)
+          parsing_result = ParseXMLResponse.call(response.body, 'ShipmentConfirmResponse')
+          parsing_result.fmap do |xml|
+            FriendlyShipping::ApiResult.new(
+              xml.root.at('ShipmentDigest').text,
+              original_request: request,
+              original_response: response
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/friendly_shipping/services/ups/parse_xml_response.rb

@@ -9,7 +9,8 @@ module FriendlyShipping
 
         class << self
           def call(response_body, expected_root_tag)
-            xml = Nokogiri.XML(response_body)
+            xml = Nokogiri.XML(response_body, &:strict)
+
             if xml.root.nil? || xml.root.name != expected_root_tag
               Failure('Invalid document')
             end

data/lib/friendly_shipping/services/ups/serialize_address_snippet.rb

@@ -37,14 +37,19 @@ module FriendlyShipping
               # StateProvinceCode required for negotiated rates but not otherwise, for some reason
               xml.StateProvinceCode(location.region.code) if location.region
               xml.CountryCode(location.country.code) if location.country
-
-              # Quote residential rates by default. If UPS doesn't know if the address is residential or
-              # commercial, it will quote a residential rate by default. Even with this flag being set,
-              # if UPS knows the address is commercial it will often quote a commercial rate.
-              #
-              xml.ResidentialAddressIndicator unless location.commercial?
+              residential_address_indicator(xml, location)
             end
           end
+
+          private
+
+          def residential_address_indicator(xml, location)
+            # Quote residential rates by default. If UPS doesn't know if the address is residential or
+            # commercial, it will quote a residential rate by default. Even with this flag being set,
+            # if UPS knows the address is commercial it will often quote a commercial rate.
+            #
+            xml.ResidentialAddressIndicator unless location.commercial?
+          end
         end
       end
     end

data/lib/friendly_shipping/services/ups/serialize_package_node.rb

@@ -4,12 +4,22 @@ module FriendlyShipping
   module Services
     class Ups
       class SerializePackageNode
-        def self.call(xml:, package:)
+        def self.call(
+          xml:,
+          package:,
+          reference_numbers: {},
+          delivery_confirmation_code: nil,
+          shipper_release: false
+        )
           xml.Package do
             xml.PackagingType do
               xml.Code('02')
             end
 
+            if package.items.any?(&:description)
+              xml.Description(package.items.map(&:description).compact.join(', '))
+            end
+
             if package.dimensions.all? { |dim| !dim.value.zero? && !dim.value.infinite? }
               xml.Dimensions do
                 xml.UnitOfMeasurement do
@@ -29,16 +39,21 @@ module FriendlyShipping
               xml.Weight([package.weight.convert_to(:pounds).value.to_f.round(2).ceil, 1].max)
             end
 
-            if package.properties[:shipper_release]
-              xml.PackageServiceOptions do
+            xml.PackageServiceOptions do
+              if shipper_release
                 xml.ShipperReleaseIndicator
               end
+              if delivery_confirmation_code
+                xml.DeliveryConfirmation do
+                  xml.DCISType(delivery_confirmation_code)
+                end
+              end
             end
 
-            Array.wrap(package.properties[:reference_numbers]).each do |reference_number_info|
+            reference_numbers.each do |reference_code, reference_number|
               xml.ReferenceNumber do
-                xml.Code(reference_number_info[:code] || "")
-                xml.Value(reference_number_info[:value])
+                xml.Code(reference_code)
+                xml.Value(reference_number)
               end
             end
           end

data/lib/friendly_shipping/services/ups/serialize_shipment_accept_request.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module FriendlyShipping
+  module Services
+    class Ups
+      class SerializeShipmentAcceptRequest
+        def self.call(digest:, options:)
+          xml_builder = Nokogiri::XML::Builder.new do |xml|
+            xml.ShipmentAcceptRequest do
+              xml.Request do
+                xml.RequestAction('ShipAccept')
+                xml.SubVersion('1707')
+                if options.customer_context
+                  xml.TransactionReference do
+                    xml.CustomerContext(options.customer_context)
+                  end
+                end
+              end
+              xml.ShipmentDigest(digest)
+            end
+          end
+          xml_builder.to_xml
+        end
+      end
+    end
+  end
+end

data/lib/friendly_shipping/services/ups/serialize_shipment_address_snippet.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module FriendlyShipping
+  module Services
+    class Ups
+      class SerializeShipmentAddressSnippet < SerializeAddressSnippet
+        class << self
+          private
+
+          def residential_address_indicator(xml, location)
+            # Shipment creation uses a different element to indicate residential addresses.
+            # Rates use ResidentialAddressIndicator whereas shipments use ResidentialAddress.
+            # Presence indicates residential address. Absence indicates commercial address.
+            #
+            xml.ResidentialAddressIndicator unless location.commercial?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/friendly_shipping/services/ups/serialize_shipment_confirm_request.rb

@@ -0,0 +1,282 @@
+# frozen_string_literal: true
+
+require 'friendly_shipping/services/ups/serialize_shipment_address_snippet'
+require 'friendly_shipping/services/ups/serialize_package_node'
+
+module FriendlyShipping
+  module Services
+    class Ups
+      class SerializeShipmentConfirmRequest
+        class << self
+          # Item options (only necessary for international shipping)
+          #
+          # @option description [String] A description of the item for the intl. invoice
+          # @option commodity_code [String] Commodity code for the item. See https://www.tariffnumber.com/
+          # @option value [Money] Price of the item
+          # @option unit_of_item_count [String] What kind of thing is one of this item? Example: Barrel, m3.
+          #   See UPS docs for codes.
+          #
+          def call(
+            shipment:,
+            options:
+          )
+            xml_builder = Nokogiri::XML::Builder.new do |xml|
+              xml.ShipmentConfirmRequest do
+                xml.Request do
+                  xml.RequestAction('ShipConfirm')
+                  # Required element controls level of address validation.
+                  xml.RequestOption(options.validate_address ? 'validate' : 'nonvalidate')
+                  xml.SubVersion('1707')
+                  # Optional element to identify transactions between client and server.
+                  if options.customer_context
+                    xml.TransactionReference do
+                      xml.CustomerContext(options.customer_context)
+                    end
+                  end
+                end
+
+                xml.Shipment do
+                  xml.Service do
+                    xml.Code(options.shipping_method.service_code)
+                  end
+
+                  xml.ShipTo do
+                    SerializeShipmentAddressSnippet.call(xml: xml, location: shipment.destination)
+                  end
+
+                  # Required element. The company whose account is responsible for the label(s).
+                  xml.Shipper do
+                    SerializeShipmentAddressSnippet.call(xml: xml, location: options.shipper || shipment.origin)
+
+                    xml.ShipperNumber(options.shipper_number)
+                  end
+
+                  if options.shipper || options.return_service_code
+                    origin = options.return_service_code ? shipment.destination : shipment.origin
+                    xml.ShipFrom do
+                      SerializeShipmentAddressSnippet.call(xml: xml, location: origin)
+                    end
+                  end
+
+                  if options.negotiated_rates
+                    xml.RateInformation do
+                      xml.NegotiatedRatesIndicator
+                    end
+                  end
+
+                  # shipment.options.fetch(:reference_numbers, {}).each do |reference_code, reference_value|
+                  #   xml.ReferenceNumber do
+                  #     xml.Code(reference_code)
+                  #     xml.Value(reference_value)
+                  #   end
+                  # end
+
+                  if options.billing_options.prepay
+                    xml.PaymentInformation do
+                      xml.Prepaid do
+                        build_billing_info_node(xml, options)
+                      end
+                    end
+                  else
+                    xml.ItemizedPaymentInformation do
+                      xml.ShipmentCharge do
+                        # Type '01' means 'Transportation'
+                        # This node specifies who will be billed for transportation.
+                        xml.Type('01')
+                        build_billing_info_node(xml, options)
+                      end
+                      if international?(shipment) && options.terms_of_shipment_code == 'DDP'
+                        # The shipper will cover duties and taxes
+                        # Otherwise UPS will charge the receiver
+                        xml.ShipmentCharge do
+                          xml.Type('02') # Type '02' means 'Duties and Taxes'
+                          build_billing_info_node(
+                            xml,
+                            options,
+                            bill_to_consignee: true
+                          )
+                        end
+                      end
+                    end
+                  end
+
+                  if international?(shipment)
+                    unless options.return_service_code
+                      xml.SoldTo do
+                        sold_to_location = options.sold_to || shipment.destination
+                        SerializeShipmentAddressSnippet.call(xml: xml, location: sold_to_location)
+                      end
+                    end
+
+                    if shipment.origin.country.code == 'US' && ['CA', 'PR'].include?(shipment.destination.country.code)
+                      # Required for shipments from the US to Puerto Rico or Canada
+                      # We'll assume USD as the origin country is the United States here.
+                      xml.InvoiceLineTotal do
+                        total_value = shipment.packages.inject(Money.new(0, 'USD')) do |shipment_sum, package|
+                          shipment_sum + package.items.inject(Money.new(0, 'USD')) do |package_sum, item|
+                            package_sum + (item.cost || Money.new(0, 'USD'))
+                          end
+                        end
+                        xml.MonetaryValue(total_value.to_f)
+                      end
+                    end
+
+                    contents_description = shipment.packages.flat_map do |package|
+                      package.items.map(&:description)
+                    end.compact.join(', ')
+
+                    unless contents_description.empty?
+                      xml.Description(contents_description)
+                    end
+                  end
+
+                  if options.return_service_code
+                    xml.ReturnService do
+                      xml.Code(options.return_service_code)
+                    end
+                  end
+
+                  xml.ShipmentServiceOptions do
+                    xml.SaturdayDelivery if options.saturday_delivery
+                    xml.UPScarbonneutralIndicator if options.carbon_neutral
+                    if options.delivery_confirmation_code
+                      xml.DeliveryConfirmation do
+                        xml.DCISType(options.delivery_confirmation_code)
+                      end
+                    end
+
+                    if international?(shipment)
+                      build_international_forms(xml, shipment, options)
+                    end
+                  end
+
+                  shipment.packages.each do |package|
+                    package_options = options.options_for_package(package)
+                    reference_numbers = allow_package_level_reference_numbers(shipment) ? package_options.reference_numbers : {}
+                    delivery_confirmation_code = package_level_delivery_confirmation?(shipment) ? package_options.delivery_confirmation_code : nil
+                    SerializePackageNode.call(
+                      xml: xml,
+                      package: package,
+                      reference_numbers: reference_numbers,
+                      delivery_confirmation_code: delivery_confirmation_code
+                    )
+                  end
+                end
+
+                xml.LabelSpecification do
+                  xml.LabelStockSize do
+                    xml.Height(options.label_size[0])
+                    xml.Width(options.label_size[1])
+                  end
+
+                  xml.LabelPrintMethod do
+                    xml.Code(options.label_format)
+                  end
+
+                  # API requires these only if returning a GIF formated label
+                  if options.label_format == 'GIF'
+                    xml.HTTPUserAgent('Mozilla/4.5')
+                    xml.LabelImageFormat(options.label_format) do
+                      xml.Code(options.label_format)
+                    end
+                  end
+                end
+              end
+            end
+            xml_builder.to_xml
+          end
+
+          private
+
+          # if the package is US -> US or PR -> PR the only type of reference numbers that are allowed are package-level
+          # Otherwise the only type of reference numbers that are allowed are shipment-level
+          def allow_package_level_reference_numbers(shipment)
+            origin, destination = shipment.origin.country, shipment.destination.country
+            [['US', 'US'], ['PR', 'PR']].include?([origin, destination])
+          end
+
+          # For certain origin/destination pairs, UPS allows each package in a shipment to have a specified
+          # delivery_confirmation option
+          # otherwise the delivery_confirmation option must be specified on the entire shipment.
+          # See Appendix P of UPS Shipping Package XML Developers Guide for the rules on which the logic below is based.
+          def package_level_delivery_confirmation?(shipment)
+            origin, destination = shipment.origin.country, shipment.destination.country
+            origin == destination || [['US', 'PR'], ['PR', 'US']].include?([origin, destination])
+          end
+
+          def build_billing_info_node(xml, options, bill_to_consignee: false)
+            billing_options = options.billing_options
+            if billing_options.bill_third_party
+              xml.BillThirdParty do
+                node_type = bill_to_consignee ? :BillThirdPartyConsignee : :BillThirdPartyShipper
+                xml.public_send(node_type) do
+                  xml.AccountNumber(billing_options.billing_account)
+                  xml.ThirdParty do
+                    xml.Address do
+                      xml.PostalCode(billing_options.billing_zip)
+                      xml.CountryCode(billing_options.billing_country)
+                    end
+                  end
+                end
+              end
+            else
+              xml.BillShipper do
+                xml.AccountNumber(options.shipper_number)
+              end
+            end
+          end
+
+          def build_international_forms(xml, shipment, options)
+            return unless options.paperless_invoice
+
+            reason_for_export = options.return_service_code ? "RETURN" : options.reason_for_export
+
+            invoice_date = options.invoice_date || Date.current
+            xml.InternationalForms do
+              xml.FormType('01') # 01 is "Invoice"
+              xml.InvoiceDate(invoice_date.strftime('%Y%m%d'))
+              xml.ReasonForExport(reason_for_export)
+              xml.CurrencyCode(options.billing_options.currency || 'USD')
+
+              if options.terms_of_shipment_code
+                xml.TermsOfShipment(options.terms_of_shipment_code)
+              end
+              all_items = shipment.packages.map(&:items).map(&:to_a).flatten
+              all_item_options = shipment.packages.flat_map do |package|
+                package_options = options.options_for_package(package)
+                package.items.flat_map do |item|
+                  package_options.options_for_item(item)
+                end
+              end
+
+              all_items.group_by(&:description).each do |description, items|
+                # This is a group of identically described items
+                reference_item = items.first
+                # Get the options for this item
+                item_options = all_item_options.detect { |o| o.item_id == reference_item.id } || LabelItemOptions.new(item_id: nil)
+
+                xml.Product do
+                  cost = reference_item.cost || Money.new(0, 'USD')
+                  xml.Description(description)
+                  xml.CommodityCode(item_options.commodity_code)
+                  xml.OriginCountryCode(shipment.origin.country.code)
+                  xml.Unit do
+                    xml.Value(cost * items.length)
+                    xml.Number(items.length)
+                    xml.UnitOfMeasurement do
+                      xml.Code(item_options.product_unit_of_measure_code)
+                    end
+                  end
+                end
+              end
+            end
+          end
+
+          def international?(shipment)
+            shipment.origin.country != shipment.destination.country
+          end
+        end
+      end
+    end
+  end
+end