friendly_shipping 0.3.4 → 0.4.0

data/lib/friendly_shipping/services/ups_freight.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require 'dry/monads/result'
+require 'friendly_shipping/http_client'
+require 'friendly_shipping/services/ups_freight/shipping_methods'
+require 'friendly_shipping/services/ups_freight/rates_options'
+require 'friendly_shipping/services/ups_freight/rates_package_options'
+require 'friendly_shipping/services/ups_freight/rates_item_options'
+require 'friendly_shipping/services/ups_freight/parse_freight_rate_response'
+require 'friendly_shipping/services/ups_freight/generate_freight_rate_request_hash'
+require 'friendly_shipping/services/ups_freight/generate_ups_security_hash'
+
+module FriendlyShipping
+  module Services
+    class UpsFreight
+      include Dry::Monads::Result::Mixin
+
+      attr_reader :test, :key, :login, :password, :client
+
+      CARRIER = FriendlyShipping::Carrier.new(
+        id: 'ups_freight',
+        name: 'United Parcel Service LTL',
+        code: 'ups-freight',
+        shipping_methods: SHIPPING_METHODS
+      )
+
+      TEST_URL = 'https://wwwcie.ups.com'
+      LIVE_URL = 'https://onlinetools.ups.com'
+
+      RESOURCES = {
+        rates: '/rest/FreightRate'
+      }.freeze
+
+      def initialize(key:, login:, password:, test: true, client: HttpClient.new)
+        @key = key
+        @login = login
+        @password = password
+        @test = test
+        @client = client
+      end
+
+      def carriers
+        Success([CARRIER])
+      end
+
+      # Get rates for a shipment
+      # @param [Physical::Shipment] location The shipment we want to get rates for
+      # @param [FriendlyShipping::Services::UpsFreight::RatesOptions] options Options for obtaining rates for this shipment.
+      # @return [Result<ApiResult<Array<Rate>>>] The rates returned from UPS encoded in a
+      #   `FriendlyShipping::ApiResult` object.
+      def rate_estimates(shipment, options:, debug: false)
+        freight_rate_request_hash = GenerateFreightRateRequestHash.call(shipment: shipment, options: options)
+        url = base_url + RESOURCES[:rates]
+        request = FriendlyShipping::Request.new(
+          url: url,
+          body: authentication_hash.merge(freight_rate_request_hash).to_json,
+          debug: debug
+        )
+
+        client.post(request).bind do |response|
+          ParseFreightRateResponse.call(response: response, request: request)
+        end
+      end
+
+      private
+
+      def authentication_hash
+        GenerateUpsSecurityHash.call(key: key, login: login, password: password)
+      end
+
+      def base_url
+        test ? TEST_URL : LIVE_URL
+      end
+    end
+  end
+end

data/lib/friendly_shipping/services/ups_freight/generate_commodity_information.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module FriendlyShipping
+  module Services
+    class UpsFreight
+      class GenerateCommodityInformation
+        def self.call(shipment:, options:)
+          shipment.packages.flat_map do |package|
+            package_options = options.options_for_package(package)
+            package.items.map do |item|
+              item_options = package_options.options_for_item(item)
+              {
+                # This is a required field
+                Description: item.description || 'Commodities',
+                Weight: {
+                  UnitOfMeasurement: {
+                    Code: 'LBS' # Only Pounds are supported
+                  },
+                  Value: item.weight.convert_to(:pounds).value.to_f.round(2).to_s
+                },
+                NumberOfPieces: '1', # We won't support this yet.
+                PackagingType: {
+                  Code: item_options.packaging_code
+                },
+                FreightClass: item_options.freight_class
+              }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/friendly_shipping/services/ups_freight/generate_freight_rate_request_hash.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require 'friendly_shipping/services/ups_freight/generate_location_hash'
+
+module FriendlyShipping
+  module Services
+    class UpsFreight
+      class GenerateFreightRateRequestHash
+        class << self
+          def call(shipment:, options:)
+            {
+              FreightRateRequest: {
+                Request: request_options(options.customer_context),
+                ShipperNumber: options.shipper_number,
+                ShipFrom: GenerateLocationHash.call(location: shipment.origin),
+                ShipTo: GenerateLocationHash.call(location: shipment.destination),
+                PaymentInformation: payment_information(options),
+                Service: {
+                  Code: options.shipping_method.service_code
+                },
+                Commodity: options.commodity_information_generator.call(shipment: shipment, options: options),
+                TimeInTransitIndicator: true
+              }.compact.merge(handling_units(shipment, options).reduce(&:merge).to_h)
+            }
+          end
+
+          private
+
+          def handling_units(shipment, options)
+            all_package_options = shipment.packages.map { |package| options.options_for_package(package) }
+            all_package_options.group_by(&:handling_unit_code).map do |_handling_unit_code, options_group|
+              [options_group.first, options_group.length]
+            end.map { |package_options, quantity| handling_unit_hash(package_options, quantity) }
+          end
+
+          def handling_unit_hash(package_options, quantity)
+            {
+              package_options.handling_unit_tag => {
+                Quantity: quantity.to_s,
+                Type: {
+                  Code: package_options.handling_unit_code,
+                  Description: package_options.handling_unit_description
+                }
+              }
+            }
+          end
+
+          def request_options(customer_context)
+            return {} unless customer_context
+
+            {
+              TransactionReference: {
+                CustomerContext: customer_context
+              }
+            }
+          end
+
+          def payment_information(options)
+            payer_address = GenerateLocationHash.call(location: options.billing_address).
+                            merge(ShipperNumber: options.shipper_number)
+            {
+              Payer: payer_address,
+              ShipmentBillingOption: {
+                Code: options.billing_code
+              }
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/friendly_shipping/services/ups_freight/generate_location_hash.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module FriendlyShipping
+  module Services
+    class UpsFreight
+      class GenerateLocationHash
+        class << self
+          def call(location:)
+            # We ship freight here, which will mostly be used for businesses.
+            # If a personal name is given, treat is as the contact person ("AttentionName")
+            {
+              Name: location.company_name,
+              Address: {
+                AddressLine: address_line(location),
+                City: location.city,
+                StateProvinceCode: location.region.code,
+                PostalCode: location.zip,
+                CountryCode: location.country.code
+              },
+              AttentionName: location.name
+            }
+          end
+
+          private
+
+          def address_line(location)
+            [
+              location.address1,
+              location.address2,
+              location.address3
+            ].compact.
+              reject(&:empty?).
+              join(", ")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/friendly_shipping/services/ups_freight/generate_ups_security_hash.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module FriendlyShipping
+  module Services
+    class UpsFreight
+      class GenerateUpsSecurityHash
+        def self.call(login:, password:, key:)
+          {
+            UPSSecurity: {
+              UsernameToken: {
+                Username: login,
+                Password: password
+              },
+              ServiceAccessToken: {
+                AccessLicenseNumber: key
+              }
+            }
+          }
+        end
+      end
+    end
+  end
+end

data/lib/friendly_shipping/services/ups_freight/parse_freight_rate_response.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require 'friendly_shipping/rate'
+require 'friendly_shipping/api_result'
+require 'friendly_shipping/services/ups_freight/parse_json_response'
+require 'friendly_shipping/services/ups_freight/shipping_methods'
+
+module FriendlyShipping
+  module Services
+    class UpsFreight
+      class ParseFreightRateResponse
+        class << self
+          def call(request:, response:)
+            parsed_json = ParseJSONResponse.call(response.body, 'FreightRateResponse')
+
+            parsed_json.fmap do |json|
+              service_code = json.dig("FreightRateResponse", "Service", "Code")
+              shipping_method = SHIPPING_METHODS.detect { |sm| sm.service_code == service_code }
+              total_shipment_charge = json.dig("FreightRateResponse", "TotalShipmentCharge")
+              currency = Money::Currency.new(total_shipment_charge['CurrencyCode'])
+              amount = total_shipment_charge['MonetaryValue'].to_f
+              total_money = Money.new(amount * currency.subunit_to_unit, currency)
+              data = {
+                customer_context: json.dig("FreightRateResponse", "TransactionReference", "TransactionIdentifier"),
+                commodities: Array.wrap(json.dig("FreightRateResponse", "Commodity")),
+                response_body: json
+              }
+
+              days_in_transit = json.dig("FreightRateResponse", "TimeInTransit", "DaysInTransit")
+              if days_in_transit
+                data[:days_in_transit] = days_in_transit.to_i
+              end
+
+              FriendlyShipping::ApiResult.new(
+                [
+                  FriendlyShipping::Rate.new(
+                    amounts: {
+                      total: total_money
+                    },
+                    shipping_method: shipping_method,
+                    data: data
+                  )
+                ],
+                original_request: request,
+                original_response: response
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/friendly_shipping/services/ups_freight/parse_json_response.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module FriendlyShipping
+  module Services
+    class UpsFreight
+      class ParseJSONResponse
+        extend Dry::Monads::Result::Mixin
+
+        class << self
+          def call(response_body, expected_root_tag)
+            json = JSON.parse(response_body)
+
+            if request_successful?(json, expected_root_tag)
+              Success(json)
+            else
+              Failure(error_message(json))
+            end
+          rescue JSON::ParserError => e
+            Failure(e)
+          end
+
+          private
+
+          def request_successful?(json, expected_root_tag)
+            json[expected_root_tag].present?
+          end
+
+          def error_message(json)
+            detailed_error = json.dig('Fault', 'detail', 'Errors', 'ErrorDetail', 'PrimaryErrorCode')
+            status = detailed_error['Code']
+            desc = detailed_error['Description']
+            [status, desc].compact.join(": ").presence || 'UPS could not process the request.'
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module FriendlyShipping
+  module Services
+    class UpsFreight
+      # Options for Items in a UPS Freight shipment
+      #
+      # @attribute [Symbol] packaging How the item is packaged, one of the keys of `PACKAGING_TYPES`
+      # @attribute [String] freight_class The freight class of this item, for example '55' or '92.5'
+      # @attribute [String] nmfc_code The national motor freight corporation code for this item. Something like '13050 sub 4'
+      class RatesItemOptions < FriendlyShipping::ItemOptions
+        PACKAGING_TYPES = {
+          bag: { code: "BAG", description: "Bag" },
+          bale: { code: "BAL", description: "Bale" },
+          barrel: { code: "BAR", description: "Barrel" },
+          bundle: { code: "BDL", description: "Bundle" },
+          bin: { code: "BIN", description: "Bin" },
+          box: { code: "BOX", description: "Box" },
+          basket: { code: "BSK", description: "Basket" },
+          bunch: { code: "BUN", description: "Bunch" },
+          cabinet: { code: "CAB", description: "Cabinet" },
+          can: { code: "CAN", description: "Can" },
+          carrier: { code: "CAR", description: "Carrier" },
+          case: { code: "CAS", description: "Case" },
+          carboy: { code: "CBY", description: "Carboy" },
+          container: { code: "CON", description: "Container" },
+          crate: { code: "CRT", description: "Crate" },
+          cask: { code: "CSK", description: "Cask" },
+          carton: { code: "CTN", description: "Carton" },
+          cylinder: { code: "CYL", description: "Cylinder" },
+          drum: { code: "DRM", description: "Drum" },
+          loose: { code: "LOO", description: "Loose" },
+          other: { code: "OTH", description: "Other" },
+          pail: { code: "PAL", description: "Pail" },
+          pieces: { code: "PCS", description: "Pieces" },
+          package: { code: "PKG", description: "Package" },
+          pipe_line: { code: "PLN", description: "Pipe Line" },
+          pallet: { code: "PLT", description: "Pallet" },
+          rack: { code: "RCK", description: "Rack" },
+          reel: { code: "REL", description: "Reel" },
+          roll: { code: "ROL", description: "Roll" },
+          skid: { code: "SKD", description: "Skid" },
+          spool: { code: "SPL", description: "Spool" },
+          tube: { code: "TBE", description: "Tube" },
+          tank: { code: "TNK", description: "Tank" },
+          totes: { code: "TOT", description: "Totes" },
+          unit: { code: "UNT", description: "Unit" },
+          van_pack: { code: "VPK", description: "Van Pack" },
+          wrapped: { code: "WRP", description: "Wrapped" }
+        }.freeze
+
+        attr_reader :packaging_code,
+                    :packaging_description,
+                    :freight_class,
+                    :nmfc_code
+
+        def initialize(
+          packaging: :carton,
+          freight_class: nil,
+          nmfc_code: nil,
+          **kwargs
+        )
+          @packaging_code = PACKAGING_TYPES.fetch(packaging).fetch(:code)
+          @packaging_description = PACKAGING_TYPES.fetch(packaging).fetch(:description)
+          @freight_class = freight_class
+          @nmfc_code = nmfc_code
+          super kwargs
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require 'friendly_shipping/services/ups_freight/rates_package_options'
+require 'friendly_shipping/services/ups_freight/generate_commodity_information'
+
+module FriendlyShipping
+  module Services
+    class UpsFreight
+      # Options for generating UPS Freight rates for a shipment
+      #
+      # @attribute [Physical::Location] billing_address The billing address
+      # @attribute [String] shipper_number The shipper number associated with the shipper
+      # @attribute [String] customer_context A reference to match this request with an order or shipment
+      # @attribute [FriendlyShipping::ShippingMethod] shipping_method The shipping method to use
+      # @attribute [Callable] commodity_information_generator A callable that takes a shipment
+      #     and an options object to create an Array of commodity fields as per the UPS docs.
+      # @attribute [Symbol] billing One of the keys in the `BILLING_CODES` constant. How the shipment
+      #     would be billed.
+      # @attribute [RatesPackageOptions] package_options Options for each of the packages/pallets in this shipment
+      class RatesOptions < FriendlyShipping::ShipmentOptions
+        BILLING_CODES = {
+          prepaid: '10',
+          third_party: '30',
+          freight_collect: '40'
+        }.freeze
+
+        attr_reader :shipper_number,
+                    :billing_address,
+                    :billing_code,
+                    :customer_context,
+                    :shipping_method,
+                    :commodity_information_generator
+
+        def initialize(
+          shipper_number:,
+          billing_address:,
+          shipping_method:,
+          billing: :prepaid,
+          customer_context: nil,
+          commodity_information_generator: GenerateCommodityInformation,
+          **kwargs
+        )
+          @shipper_number = shipper_number
+          @billing_address = billing_address
+          @shipping_method = shipping_method
+          @billing_code = BILLING_CODES.fetch(billing)
+          @customer_context = customer_context
+          @commodity_information_generator = commodity_information_generator
+          super kwargs.merge(package_options_class: RatesPackageOptions)
+        end
+      end
+    end
+  end
+end