friendly_shipping 0.8.1 → 0.10.0

data/lib/friendly_shipping/services/ups_json/parse_rate_modifier_hash.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module FriendlyShipping
+  module Services
+    class UpsJson
+      class ParseRateModifierHash
+        # @param [Hash] hash the RateModifier hash from the source JSON
+        # @param [String] currency_code The currency code for this modifier's amount (i.e. 'USD')
+        # @return [Array] The label and the amount of the rate modifier
+        def self.call(rate_modifier, currency_code:)
+          return unless rate_modifier
+
+          amount = rate_modifier['Amount'].to_d
+          return if amount.zero?
+
+          currency = Money::Currency.new(currency_code)
+          amount = Money.new(amount * currency.subunit_to_unit, currency)
+
+          modifier_type = rate_modifier['ModifierType']
+          modifier_description = rate_modifier['ModifierDesc']
+          label = "#{modifier_type} (#{modifier_description})"
+
+          [label, amount]
+        end
+      end
+    end
+  end
+end

data/lib/friendly_shipping/services/ups_json/parse_rates_response.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module FriendlyShipping
+  module Services
+    class UpsJson
+      class ParseRatesResponse
+        class << self
+          def call(request:, response:, shipment:)
+            parsed_response = ParseJsonResponse.call(
+              request: request,
+              response: response,
+              expected_root_key: 'RateResponse'
+            )
+            parsed_response.fmap do |parsing_result|
+              FriendlyShipping::ApiResult.new(
+                build_rates(parsing_result, shipment),
+                original_request: request,
+                original_response: response
+              )
+            end
+          end
+
+          def build_rates(rates_result, shipment)
+            rates = []
+
+            rated_shipments = Array.wrap(rates_result.dig('RateResponse', 'RatedShipment'))
+            rated_shipments.each do |rated_shipment|
+              service_code = rated_shipment.dig('Service', 'Code')
+              shipping_method = CARRIER.shipping_methods.detect do |sm|
+                sm.service_code == service_code && shipment.origin.country.in?(sm.origin_countries)
+              end
+              days_to_delivery = rated_shipment.dig('GuaranteedDelivery', 'BusinessDaysInTransit').to_i
+              total_cost = ParseMoneyHash.call(rated_shipment['TotalCharges'], 'TotalCharges').last
+              insurance_price = ParseMoneyHash.call(rated_shipment['ServiceOptionsCharges'], 'ServiceOptionsCharges')&.last
+              negotiated_rate = ParseMoneyHash.call(rated_shipment.dig('NegotiatedRateCharges', 'TotalCharge'), 'TotalCharge')&.last
+              negotiated_charges = extract_charges(rated_shipment.dig('NegotiatedRateCharges', 'ItemizedCharges'), 'ItemizedCharges')
+              itemized_charges = extract_charges(rated_shipment['ItemizedCharges'], 'ItemizedCharges')
+
+              rated_shipment_warnings = Array.wrap(rated_shipment['RatedShipmentAlert'])
+              rated_shipment_warnings = rated_shipment_warnings.map { |alert| alert["Description"] }
+              if rated_shipment_warnings.any? { |e| e.match?(/to Residential/) }
+                new_address_type = 'residential'
+              elsif rated_shipment_warnings.any? { |e| e.match?(/to Commercial/) }
+                new_address_type = 'commercial'
+              end
+
+              rates << FriendlyShipping::Rate.new(
+                shipping_method: shipping_method,
+                amounts: { total: total_cost },
+                warnings: rated_shipment_warnings,
+                errors: [],
+                data: {
+                  insurance_price: insurance_price,
+                  negotiated_rate: negotiated_rate,
+                  negotiated_charges: negotiated_charges,
+                  days_to_delivery: days_to_delivery,
+                  new_address_type: new_address_type,
+                  itemized_charges: itemized_charges,
+                  packages: build_packages(rated_shipment)
+                }.compact
+              )
+            end
+            rates
+          end
+
+          private
+
+          def build_packages(rated_shipment)
+            package_array = Array.wrap(rated_shipment['RatedPackage'])
+            package_array.map do |rated_package|
+              currency_code = rated_package.dig('TotalCharges', 'CurrencyCode')
+              {
+                transportation_charges: ParseMoneyHash.call(rated_package['TransportationCharges'], 'TransportationCharges')&.last,
+                base_service_charge: ParseMoneyHash.call(rated_package['BaseServiceCharge'], 'BaseServiceCharge')&.last,
+                service_options_charges: ParseMoneyHash.call(rated_package['ServiceOptionsCharges'], 'ServiceOptionsCharges')&.last,
+                itemized_charges: extract_charges(rated_package['ItemizedCharges'], 'ItemizedCharges'),
+                total_charges: ParseMoneyHash.call(rated_package['TotalCharges'], 'TotalCharges')&.last,
+                negotiated_charges: extract_charges(rated_package.dig('NegotiatedCharges', 'ItemizedCharges'), 'ItemizedCharges'),
+                rate_modifiers: extract_modifiers(rated_package['RateModifier'], currency_code: currency_code),
+                weight: BigDecimal(rated_package['Weight']),
+                billing_weight: BigDecimal(rated_package.dig('BillingWeight', 'Weight'))
+              }.compact
+            end
+          end
+
+          def extract_charges(charges, key_name)
+            non_zero_charges = {}
+            Array.wrap(charges).map do |charge|
+              parsed_charge = ParseMoneyHash.call(charge, key_name)
+              non_zero_charges[parsed_charge[0]] = parsed_charge[1] if parsed_charge.present?
+            end
+            non_zero_charges
+          end
+
+          def extract_modifiers(modifiers, currency_code:)
+            rate_modifiers = {}
+            Array.wrap(modifiers).map do |modifier|
+              parsed_modifier = ParseRateModifierHash.call(modifier, currency_code: currency_code)
+              rate_modifiers[parsed_modifier[0]] = parsed_modifier[1] if parsed_modifier.present?
+            end
+            rate_modifiers
+          end
+        end
+      end
+    end
+  end
+end

data/lib/friendly_shipping/services/ups_json/parse_timings_response.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module FriendlyShipping
+  module Services
+    class UpsJson
+      class ParseTimingsResponse
+        class << self
+          def call(request:, response:, shipment:)
+            parsed_response = ParseJsonResponse.call(
+              request: request,
+              response: response,
+              expected_root_key: 'emsResponse'
+            )
+            parsed_response.fmap do |parsing_result|
+              FriendlyShipping::ApiResult.new(
+                build_timings(parsing_result, shipment),
+                original_request: request,
+                original_response: response
+              )
+            end
+          end
+
+          def build_timings(timings_result, shipment)
+            service_timings = Array.wrap(timings_result.dig('emsResponse', 'services'))
+            service_timings.map do |timing|
+              service_description = timing['serviceLevelDescription']
+              shipping_method = SHIPPING_METHODS.detect do |potential_shipping_method|
+                service_description == potential_shipping_method.name &&
+                  potential_shipping_method.origin_countries.map(&:code).include?(shipment.origin.country.code)
+              end
+              delivery_date = timing['deliveryDate']
+              delivery_time = timing['deliveryTime']
+              delivery = Time.parse("#{delivery_date} #{delivery_time}")
+              pickup_date = timing['pickupDate']
+              pickup_time = timing['pickupTime']
+              pickup = Time.parse("#{pickup_date} #{pickup_time}")
+
+              guaranteed = timing['guaranteeIndicator'] == '1'
+              business_transit_days = timing['businessTransitDays']
+
+              FriendlyShipping::Timing.new(
+                shipping_method: shipping_method,
+                pickup: pickup,
+                delivery: delivery,
+                guaranteed: guaranteed,
+                data: {
+                  business_transit_days: business_transit_days
+                }
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/friendly_shipping/services/ups_json/parse_void_response.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module FriendlyShipping
+  module Services
+    class UpsJson
+      class ParseVoidResponse
+        extend Dry::Monads::Result::Mixin
+
+        class << self
+          def call(request:, response:)
+            parsed_response = ParseJsonResponse.call(
+              request: request,
+              response: response,
+              expected_root_key: "VoidShipmentResponse"
+            )
+
+            parsed_response.bind do |void_response|
+              result = void_response["VoidShipmentResponse"]
+              Success(
+                FriendlyShipping::ApiResult.new(
+                  result,
+                  original_request: request,
+                  original_response: response
+                )
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/friendly_shipping/services/ups_json/rates_item_options.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module FriendlyShipping
+  module Services
+    class UpsJson
+      # Represents item options for determining rates.
+      # @option commodity_code [String] This item's HS or NMFC code for international shipments.
+      # @option country_of_origin [String] This item's country of origin for international shipments.
+      class RatesItemOptions < FriendlyShipping::ItemOptions
+        attr_reader :commodity_code, :country_of_origin
+
+        def initialize(commodity_code: nil, country_of_origin: nil, **kwargs)
+          @commodity_code = commodity_code
+          @country_of_origin = country_of_origin
+          super(**kwargs)
+        end
+      end
+    end
+  end
+end

data/lib/friendly_shipping/services/ups_json/rates_options.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module FriendlyShipping
+  module Services
+    # Option container for rating a shipment via UPS
+    #
+    # Required:
+    #
+    # @option shipper_number [String] The shipper number of the origin of the shipment.
+    #
+    # Optional:
+    #
+    # @option carbon_neutral [Boolean] Ship with UPS' carbon neutral program
+    # @option customer_context [String ] Optional element to identify transactions between client and server
+    # @option customer_classification [Symbol] Which kind of rates to request. See UPS docs for more details. Default: `shipper_number`
+    # @option negotiated_rates [Boolean] if truthy negotiated rates will be requested from ups. Only valid if
+    #   shipper account has negotiated rates. Default: false
+    # @option pickup_type [String] UPS pickup type. See UPS docs for more details. Default: `daily_pickup`
+    # @option pickup_date [Time] UPS pickup date/time. Default: nil
+    # @option saturday_delivery [Boolean] should we request Saturday delivery?. Default: false
+    # @option saturday_pickup [Boolean] should we request Saturday pickup?. Default: false
+    # @option shipping_method [FriendlyShipping::ShippingMethod] Request rates for a particular shipping method only?
+    #   Default is `nil`, which translates to 'All shipping methods' (The "Shop" option in UPS parlance)
+    # @option sub_version [String] The UPS API sub-version to use for requests. Default: v2205
+    # @option with_time_in_transit [Boolean] Whether to request timing information alongside the rates
+    # @option package_options_class [Class] See FriendlyShipping::ShipmentOptions
+    #
+    class UpsJson
+      class RatesOptions < FriendlyShipping::ShipmentOptions
+        PICKUP_TYPE_CODES = {
+          daily_pickup: "01",
+          customer_counter: "03",
+          one_time_pickup: "06",
+          on_call_air: "07",
+          suggested_retail_rates: "11",
+          letter_center: "19",
+          air_service_center: "20"
+        }.freeze
+
+        CUSTOMER_CLASSIFICATION_CODES = {
+          shipper_number: "00",
+          daily_rates: "01",
+          retail_rates: "04",
+          regional_rates: "05",
+          general_rates: "06",
+          standard_rates: "53"
+        }.freeze
+
+        SUB_VERSIONS = %w[1 1601 1607 1701 1707 2108 2205].freeze
+
+        attr_reader :carbon_neutral,
+                    :customer_context,
+                    :destination_account,
+                    :negotiated_rates,
+                    :pickup_date,
+                    :saturday_delivery,
+                    :saturday_pickup,
+                    :shipper,
+                    :shipper_number,
+                    :shipping_method,
+                    :sub_version,
+                    :with_time_in_transit
+
+        def initialize(
+          shipper_number:,
+          carbon_neutral: true,
+          customer_context: nil,
+          customer_classification: :daily_rates,
+          destination_account: nil,
+          negotiated_rates: false,
+          pickup_type: :daily_pickup,
+          pickup_date: nil,
+          saturday_delivery: false,
+          saturday_pickup: false,
+          shipper: nil,
+          shipping_method: nil,
+          sub_version: "2205",
+          with_time_in_transit: false,
+          package_options_class: RatesPackageOptions,
+          **kwargs
+        )
+          raise ArgumentError, "Invalid sub-version: #{sub_version}" unless sub_version.in?(SUB_VERSIONS)
+
+          @carbon_neutral = carbon_neutral
+          @customer_context = customer_context
+          @customer_classification = customer_classification
+          @destination_account = destination_account
+          @negotiated_rates = negotiated_rates
+          @shipper_number = shipper_number
+          @pickup_type = pickup_type
+          @pickup_date = pickup_date
+          @saturday_delivery = saturday_delivery
+          @saturday_pickup = saturday_pickup
+          @shipper = shipper
+          @shipping_method = shipping_method
+          @sub_version = sub_version
+          @with_time_in_transit = with_time_in_transit
+          super(**kwargs.reverse_merge(package_options_class: package_options_class))
+        end
+
+        def pickup_type_code
+          PICKUP_TYPE_CODES[@pickup_type]
+        end
+
+        def customer_classification_code
+          CUSTOMER_CLASSIFICATION_CODES[@customer_classification]
+        end
+      end
+    end
+  end
+end

data/lib/friendly_shipping/services/ups_json/rates_package_options.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module FriendlyShipping
+  module Services
+    class UpsJson
+      class RatesPackageOptions < FriendlyShipping::PackageOptions
+        attr_reader :transmit_dimensions
+
+        def initialize(transmit_dimensions: true,
+                       **kwargs)
+          @transmit_dimensions = transmit_dimensions
+          super(**kwargs.reverse_merge(item_options_class: RatesItemOptions))
+        end
+      end
+    end
+  end
+end

data/lib/friendly_shipping/services/ups_json/shipping_methods.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module FriendlyShipping
+  module Services
+    class UpsJson
+      EU_COUNTRIES = %w(
+        AT BE BG CY CZ DE DK EE ES FI FR GB GR HR HU IE IT LT LU LV MT NL PO PT RO SE SI SK
+      ).map { |country_code| Carmen::Country.coded(country_code) }
+
+      class << self
+        private
+
+        def countries_by_code(code)
+          all_countries = Carmen::Country.all
+          covered_countries = EU_COUNTRIES + %w(US PR CA PL MX).map do |country_code|
+            Carmen::Country.coded(country_code)
+          end
+          other_countries = Carmen::Country.all - covered_countries
+          case code
+          when 'EU' then EU_COUNTRIES
+          when 'OTHER' then other_countries
+          when 'ALL' then all_countries
+          else
+            [Carmen::Country.coded(code)]
+          end
+        end
+      end
+
+      SHIPPING_METHODS = [
+        ['US', 'international', 'UPS Standard', '11'],
+        ['US', 'international', 'UPS Worldwide Express®', '07'],
+        ['US', 'international', 'UPS Worldwide Expedited®', '08'],
+        ['US', 'international', 'UPS Worldwide Express Plus®', '54'],
+        ['US', 'international', 'UPS Worldwide Saver', '65'],
+        ['US', 'domestic', 'UPS 2nd Day Air®', '02'],
+        ['US', 'domestic', 'UPS 2nd Day Air A.M.', '59'],
+        ['US', 'domestic', 'UPS 3 Day Select®', '12'],
+        ['US', 'domestic', 'UPS Ground', '03'],
+        ['US', 'domestic', 'UPS Next Day Air®', '01'],
+        ['US', 'domestic', 'UPS Next Day Air® Early', '14'],
+        ['US', 'domestic', 'UPS Next Day Air Saver®', '13'],
+        ['US', 'domestic', 'UPS SurePost Less than 1LB', '92'],
+        ['US', 'domestic', 'UPS SurePost 1LB or greater', '93'],
+        ['US', 'domestic', 'UPS SurePost BPM', '94'],
+        ['US', 'domestic', 'UPS SurePost Media Mail', '95'],
+        ['CA', 'domestic', 'UPS Expedited Canadian domestic shipments', '02'],
+        ['CA', 'domestic', 'UPS Express Saver Canadian domestic shipments', '13'],
+        ['CA', 'domestic', 'UPS 3 Day Select Shipments originating in Canada to CA and US 48', '12'],
+        ['CA', 'international', 'UPS 3 Day Select Shipments originating in Canada to CA and US 48', '12'],
+        ['CA', 'domestic', 'UPS Access Point Economy Canadian domestic shipments', '70'],
+        ['CA', 'domestic', 'UPS Express Canadian domestic shipments', '01'],
+        ['CA', 'domestic', 'UPS Express Early Canadian domestic shipments', '14'],
+        ['CA', 'international', 'UPS Express Saver International shipments originating in Canada', '65'],
+        ['CA', 'international', 'UPS Standard Shipments originating in Canada (Domestic and Int’l)', '11'],
+        ['CA', 'domestic', 'UPS Standard Shipments originating in Canada (Domestic and Int’l)', '11'],
+        ['CA', 'international', 'UPS Worldwide Expedited International shipments originating in Canada', '08'],
+        ['CA', 'international', 'UPS Worldwide Express International shipments originating in Canada', '07'],
+        ['CA', 'international', 'UPS Worldwide Express Plus International shipments originating in Canada', '54'],
+        ['CA', 'international', 'UPS Express Early Shipments originating in Canada to CA and US 48', '54'],
+        ['CA', 'domestic', 'UPS Express Early Shipments originating in Canada to CA and US 48', '54'],
+        ['EU', 'domestic', 'UPS Access Point Economy Shipments within the European Union', '70'],
+        ['EU', 'international', 'UPS Expedited Shipments originating in the European Union', '08'],
+        ['EU', 'international', 'UPS Express Shipments originating in the European Union', '07'],
+        ['EU', 'international', 'UPS Standard Shipments originating in the European Union', '11'],
+        ['EU', 'international', 'UPS Worldwide Express Plus Shipments originating in the European Union', '54'],
+        ['EU', 'international', 'UPS Worldwide Saver Shipments originating in the European Union', '65'],
+        ['MX', 'domestic', 'UPS Access Point Economy Shipments within Mexico', '70'],
+        ['MX', 'international', 'UPS Expedited Shipments originating in Mexico', '08'],
+        ['MX', 'international', 'UPS Express Shipments originating in Mexico', '07'],
+        ['MX', 'international', 'UPS Standard Shipments originating in Mexico', '11'],
+        ['MX', 'international', 'UPS Worldwide Express Plus Shipments originating in Mexico', '54'],
+        ['MX', 'international', 'UPS Worldwide Saver Shipments originating in Mexico', '65'],
+        ['PL', 'domestic', 'UPS Access Point Economy Polish domestic shipments', '70'],
+        ['PL', 'domestic', 'UPS Today Dedicated Courier Polish domestic shipments', '83'],
+        ['PL', 'domestic', 'UPS Today Express Polish domestic shipments', '85'],
+        ['PL', 'domestic', 'UPS Today Express Saver Polish domestic shipments', '86'],
+        ['PL', 'domestic', 'UPS Today Standard Polish domestic shipments', '82'],
+        ['PL', 'international', 'UPS Expedited Shipments originating in Poland', '08'],
+        ['PL', 'international', 'UPS Express Shipments originating in Poland', '07'],
+        ['PL', 'international', 'UPS Express Plus Shipments originating in Poland', '54'],
+        ['PL', 'international', 'UPS Express Saver Shipments originating in Poland', '65'],
+        ['PL', 'international', 'UPS Standard Shipments originating in Poland', '11'],
+        ['PR', 'domestic', 'UPS 2nd Day Air', '02'],
+        ['PR', 'domestic', 'UPS Ground', '03'],
+        ['PR', 'domestic', 'UPS Next Day Air', '01'],
+        ['PR', 'domestic', 'UPS Next Day Air Early', '14'],
+        ['PR', 'international', 'UPS Worldwide Expedited', '08'],
+        ['PR', 'international', 'UPS Worldwide Express', '07'],
+        ['PR', 'international', 'UPS Worldwide Express Plus', '54'],
+        ['PR', 'international', 'UPS Worldwide Saver', '65'],
+        ['DE', 'domestic', 'UPS Express 12:00 German domestic shipments', '74'],
+        ['OTHER', 'domestic', 'UPS Express', '07'],
+        ['OTHER', 'domestic', 'UPS Standard', '11'],
+        ['OTHER', 'international', 'UPS Worldwide Expedited', '08'],
+        ['OTHER', 'international', 'UPS Worldwide Express Plus', '54'],
+        ['OTHER', 'international', 'UPS Worldwide Saver', '65'],
+        ['ALL', 'international', 'UPS Worldwide Express Freight', '96'],
+        ['ALL', 'international', 'UPS Worldwide Express Freight Midday', '71']
+      ].freeze.map do |origin_country_code, dom_or_intl, name, code|
+        FriendlyShipping::ShippingMethod.new(
+          name: name,
+          service_code: code,
+          domestic: dom_or_intl == 'domestic',
+          international: dom_or_intl == 'international',
+          origin_countries: countries_by_code(origin_country_code),
+          multi_package: true
+        ).freeze
+      end
+    end
+  end
+end

data/lib/friendly_shipping/services/ups_json/timings_options.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module FriendlyShipping
+  module Services
+    class UpsJson
+      # Options for getting timing information from UPS
+      # @attribute [Time] pickup When the shipment will be picked up
+      # @attribute [Money] invoice_total How much the items in the shipment are worth
+      #   As this is not super important for getting timing information, we use a default
+      #   value of 50 USD here.
+      # @attribute [Boolean] documents_only Does the shipment only contain documents?
+      # @attribute [String] customer_context A string to connect request and response in the calling code
+      class TimingsOptions
+        attr_reader :pickup,
+                    :invoice_total,
+                    :documents_only,
+                    :customer_context
+
+        def initialize(
+          pickup: Time.now,
+          invoice_total: Money.new(5000, 'USD'),
+          documents_only: false,
+          customer_context: nil
+        )
+          @pickup = pickup
+          @invoice_total = invoice_total
+          @documents_only = documents_only
+          @customer_context = customer_context
+        end
+      end
+    end
+  end
+end