friendly_shipping 0.10.1 → 0.10.2

data/lib/friendly_shipping/services/ups.rb

@@ -1,218 +0,0 @@
-# frozen_string_literal: true
-
-require 'nokogiri'
-
-module FriendlyShipping
-  module Services
-    class Ups
-      include Dry::Monads::Result::Mixin
-
-      attr_reader :test, :key, :login, :password, :client
-
-      CARRIER = FriendlyShipping::Carrier.new(
-        id: 'ups',
-        name: 'United Parcel Service',
-        code: 'ups',
-        shipping_methods: SHIPPING_METHODS
-      )
-
-      TEST_URL = 'https://wwwcie.ups.com'
-      LIVE_URL = 'https://onlinetools.ups.com'
-
-      RESOURCES = {
-        address_validation: '/ups.app/xml/XAV',
-        city_state_lookup: '/ups.app/xml/AV',
-        rates: '/ups.app/xml/Rate',
-        ship_confirm: '/ups.app/xml/ShipConfirm',
-        ship_accept: '/ups.app/xml/ShipAccept',
-        timings: '/ups.app/xml/TimeInTransit',
-        void: '/ups.app/xml/Void',
-      }.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] shipment The shipment we want to get rates for
-      # @param [FriendlyShipping::Services::Ups::RateEstimateOptions] options What options
-      #    to use for this rate estimate call
-      # @return [Result<ApiResult<Array<Rate>>>] The rates returned from UPS encoded in a
-      #   `FriendlyShipping::ApiResult` object.
-      def rate_estimates(shipment, options:, debug: false)
-        rate_request_xml = SerializeRatingServiceSelectionRequest.call(shipment: shipment, options: options)
-        url = base_url + RESOURCES[:rates]
-        request = FriendlyShipping::Request.new(
-          url: url,
-          http_method: "POST",
-          body: access_request_xml + rate_request_xml,
-          readable_body: rate_request_xml,
-          debug: debug
-        )
-
-        client.post(request).bind do |response|
-          ParseRateResponse.call(response: response, request: request, shipment: shipment)
-        end
-      end
-
-      # Get timing information for a shipment
-      # @param [Physical::Shipment] shipment The shipment we want to estimate timings for
-      # @param [FriendlyShipping::Services::Ups::TimingOptions] options Options for this call
-      def timings(shipment, options:, debug: false)
-        time_in_transit_request_xml = SerializeTimeInTransitRequest.call(
-          shipment: shipment,
-          options: options
-        )
-        time_in_transit_url = base_url + RESOURCES[:timings]
-
-        request = FriendlyShipping::Request.new(
-          url: time_in_transit_url,
-          http_method: "POST",
-          body: access_request_xml + time_in_transit_request_xml,
-          readable_body: time_in_transit_request_xml,
-          debug: debug
-        )
-
-        client.post(request).bind do |response|
-          ParseTimeInTransitResponse.call(response: response, request: request)
-        end
-      end
-
-      def labels(shipment, options:, debug: false)
-        ## Method body starts
-        ship_confirm_request_xml = SerializeShipmentConfirmRequest.call(
-          shipment: shipment,
-          options: options
-        )
-        ship_confirm_url = base_url + RESOURCES[:ship_confirm]
-
-        ship_confirm_request = FriendlyShipping::Request.new(
-          url: ship_confirm_url,
-          http_method: "POST",
-          body: access_request_xml + ship_confirm_request_xml,
-          readable_body: ship_confirm_request_xml,
-          debug: debug
-        )
-
-        client.post(ship_confirm_request).bind do |ship_confirm_response|
-          ParseShipmentConfirmResponse.call(
-            request: ship_confirm_request,
-            response: ship_confirm_response
-          )
-        end.bind do |ship_confirm_result|
-          ship_accept_url = base_url + RESOURCES[:ship_accept]
-          ship_accept_request_xml = SerializeShipmentAcceptRequest.call(
-            digest: ship_confirm_result.data,
-            options: options
-          )
-
-          ship_accept_request = FriendlyShipping::Request.new(
-            url: ship_accept_url,
-            http_method: "POST",
-            body: access_request_xml + ship_accept_request_xml,
-            readable_body: ship_accept_request_xml,
-            debug: debug
-          )
-
-          client.post(ship_accept_request).bind do |ship_accept_response|
-            ParseShipmentAcceptResponse.call(request: ship_accept_request, response: ship_accept_response)
-          end
-        end
-      end
-
-      # Validate an address.
-      # @param [Physical::Location] location The address we want to verify
-      # @return [Result<ApiResult<Array<Physical::Location>>>] The response data from UPS encoded in a
-      #   `Physical::Location` object. Name and Company name are always nil, the
-      #   address lines will be made conformant to what UPS considers right. The returned location will
-      #   have the address_type set if possible.
-      def address_validation(location, debug: false)
-        address_validation_request_xml = SerializeAddressValidationRequest.call(location: location)
-        url = base_url + RESOURCES[:address_validation]
-        request = FriendlyShipping::Request.new(
-          url: url,
-          http_method: "POST",
-          body: access_request_xml + address_validation_request_xml,
-          readable_body: address_validation_request_xml,
-          debug: debug
-        )
-
-        client.post(request).bind do |response|
-          ParseAddressValidationResponse.call(response: response, request: request)
-        end
-      end
-
-      # Classify an address.
-      # @param [Physical::Location] location The address we want to classify
-      # @return [Result<ApiResult<String>>] Either `"commercial"`, `"residential"`, or `"unknown"`
-      def address_classification(location, debug: false)
-        address_validation_request_xml = SerializeAddressValidationRequest.call(location: location)
-        url = base_url + RESOURCES[:address_validation]
-        request = FriendlyShipping::Request.new(
-          url: url,
-          http_method: "POST",
-          body: access_request_xml + address_validation_request_xml,
-          readable_body: address_validation_request_xml,
-          debug: debug
-        )
-
-        client.post(request).bind do |response|
-          ParseAddressClassificationResponse.call(response: response, request: request)
-        end
-      end
-
-      # Find city and state for a given ZIP code
-      # @param [Physical::Location] location A location object with country and ZIP code set
-      # @return [Result<ApiResult<Array<Physical::Location>>>] The response data from UPS encoded in a
-      #   `Physical::Location` object. Country, City and ZIP code will be set, everything else nil.
-      def city_state_lookup(location, debug: false)
-        city_state_lookup_request_xml = SerializeCityStateLookupRequest.call(location: location)
-        url = base_url + RESOURCES[:city_state_lookup]
-        request = FriendlyShipping::Request.new(
-          url: url,
-          http_method: "POST",
-          body: access_request_xml + city_state_lookup_request_xml,
-          readable_body: city_state_lookup_request_xml,
-          debug: debug
-        )
-
-        client.post(request).bind do |response|
-          ParseCityStateLookupResponse.call(response: response, request: request, location: location)
-        end
-      end
-
-      def void(label, debug: false)
-        url = base_url + RESOURCES[:void]
-        void_request_xml = SerializeVoidShipmentRequest.call(label: label)
-        request = FriendlyShipping::Request.new(
-          url: url,
-          http_method: "POST",
-          body: access_request_xml + void_request_xml,
-          readable_body: void_request_xml,
-          debug: debug
-        )
-        client.post(request).bind do |response|
-          ParseVoidShipmentResponse.call(request: request, response: response)
-        end
-      end
-
-      private
-
-      def access_request_xml
-        SerializeAccessRequest.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/usps/choose_package_rate.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-module FriendlyShipping
-  module Services
-    class Usps
-      class ChoosePackageRate
-        class CannotDetermineRate < StandardError; end
-        # Some shipping rates use 'Flat Rate Boxes', indicating that
-        # they are available for ALL flat rate boxes.
-        FLAT_RATE_BOX = /Flat Rate Box/i
-
-        # Select the corresponding rate for a package from all the rates USPS returns to us
-        #
-        # @param [FriendlyShipping::ShippingMethod] shipping_method The shipping method we want to filter by
-        # @param [Array<FriendlyShipping::Rate>] rates The rates we select from
-        # @param [FriendlyShipping::PackageOptions] package_options The package options we want to match with a rate
-        #
-        # @return [FriendlyShipping::Rate] The rate that most closely matches our package
-        def self.call(shipping_method, rates, package_options)
-          # Keep all rates with the requested shipping method
-          rates_with_this_shipping_method = rates.select { |r| r.shipping_method == shipping_method }
-
-          # Keep only rates with the package type of this package
-          rates_with_this_package_type = rates_with_this_shipping_method.select do |r|
-            r.data[:box_name] == package_options.box_name
-          end
-
-          # Filter by our package's `hold_for_pickup` option
-          rates_with_this_hold_for_pickup_option = rates_with_this_package_type.select do |r|
-            r.data[:hold_for_pickup] == package_options.hold_for_pickup
-          end
-
-          # At this point, we have one or two rates left, and they're similar enough.
-          # Once this poses an actual problem, we'll fix it.
-          rates_with_this_hold_for_pickup_option.first
-        end
-      end
-    end
-  end
-end

data/lib/friendly_shipping/services/usps/machinable_package.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-module FriendlyShipping
-  module Services
-    class Usps
-      # USPS has certain size and weight requirements for packages to
-      # be considered machinable. Machinable packages are generally
-      # less expensive to ship. For more information see:
-      #   https://pe.usps.com/BusinessMail101?ViewName=Parcels
-      #
-      class MachinablePackage
-        attr_reader :package
-
-        MIN_LENGTH = Measured::Length(6, :inches)
-        MIN_WIDTH = Measured::Length(3, :inches)
-        MIN_HEIGHT = Measured::Length(0.25, :inches)
-
-        MAX_LENGTH = Measured::Length(27, :inches)
-        MAX_WIDTH = Measured::Length(17, :inches)
-        MAX_HEIGHT = Measured::Length(17, :inches)
-
-        MAX_WEIGHT = Measured::Weight(25, :pounds)
-
-        # @param [Physical::Package] package
-        def initialize(package)
-          @package = package
-        end
-
-        def machinable?
-          at_least_minimum && at_most_maximum
-        end
-
-        private
-
-        def at_least_minimum
-          package.length >= MIN_LENGTH &&
-            package.width >= MIN_WIDTH &&
-            package.height >= MIN_HEIGHT
-        end
-
-        def at_most_maximum
-          package.length <= MAX_LENGTH &&
-            package.width <= MAX_WIDTH &&
-            package.height <= MAX_HEIGHT &&
-            package.weight <= MAX_WEIGHT
-        end
-      end
-    end
-  end
-end

data/lib/friendly_shipping/services/usps/parse_address_validation_response.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-module FriendlyShipping
-  module Services
-    class Usps
-      class ParseAddressValidationResponse
-        class << self
-          # Parse a response from USPS' address validation API
-          #
-          # @param [FriendlyShipping::Request] request The request that was used to obtain this Response
-          # @param [FriendlyShipping::Response] response The response that USPS returned
-          # @return [Result<FriendlyShipping::AddressValidationResult>]
-          def call(request:, response:)
-            # Filter out error responses and directly return a failure
-            parsing_result = ParseXMLResponse.call(
-              request: request,
-              response: response,
-              expected_root_tag: 'AddressValidateResponse'
-            )
-            parsing_result.fmap do |xml|
-              address = xml.root.at('Address')
-              suggestions = [
-                Physical::Location.new(
-                  address1: address&.at('Address2')&.text, # USPS swaps Address1 and Address2 in the response
-                  address2: address&.at('Address1')&.text,
-                  city: address&.at('City')&.text,
-                  region: address&.at('State')&.text,
-                  zip: address&.at('Zip5')&.text,
-                  country: 'US'
-                )
-              ]
-              FriendlyShipping::ApiResult.new(
-                suggestions,
-                original_request: request,
-                original_response: response
-              )
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/friendly_shipping/services/usps/parse_city_state_lookup_response.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-module FriendlyShipping
-  module Services
-    class Usps
-      class ParseCityStateLookupResponse
-        class << self
-          # Parse a response from USPS' city/state lookup API
-          #
-          # @param [FriendlyShipping::Request] request The request that was used to obtain this Response
-          # @param [FriendlyShipping::Response] response The response that USPS returned
-          # @return [Result<FriendlyShipping::AddressValidationResult>]
-          def call(request:, response:)
-            # Filter out error responses and directly return a failure
-            parsing_result = ParseXMLResponse.call(
-              request: request,
-              response: response,
-              expected_root_tag: 'CityStateLookupResponse'
-            )
-            parsing_result.fmap do |xml|
-              address = xml.root.at('ZipCode')
-              suggestions = [
-                Physical::Location.new(
-                  city: address&.at('City')&.text,
-                  region: address&.at('State')&.text,
-                  zip: address&.at('Zip5')&.text,
-                  country: 'US'
-                )
-              ]
-              FriendlyShipping::ApiResult.new(
-                suggestions,
-                original_request: request,
-                original_response: response,
-              )
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/friendly_shipping/services/usps/parse_package_rate.rb

@@ -1,159 +0,0 @@
-# frozen_string_literal: true
-
-module FriendlyShipping
-  module Services
-    class Usps
-      class ParsePackageRate
-        # USPS returns all the info about a rate in a long string with a bit of gibberish.
-        ESCAPING_AND_SYMBOLS = /<\S*>/
-
-        # At the beginning of the long String, USPS keeps a copy of its own name. We know we're dealing with
-        # them though, so we can filter that out, too.
-        LEADING_USPS = /^USPS /
-
-        # This combines all the things we want to filter out.
-        SERVICE_NAME_SUBSTITUTIONS = /#{ESCAPING_AND_SYMBOLS}|#{LEADING_USPS}/
-
-        # Often we get a multitude of rates for the same service given some combination of
-        # Box type and (see below) and "Hold for Pickup" service. This creates a regular expression
-        # with groups named after the keys from the `Usps::CONTAINERS` constant.
-        # Unfortunately, the keys don't correspond directly to the codes we use when serializing the
-        # request.
-        BOX_REGEX = {
-          flat_rate_boxes: 'Flat Rate Boxes',
-          large_flat_rate_box: 'Large Flat Rate Box',
-          medium_flat_rate_box: 'Medium Flat Rate Box',
-          small_flat_rate_box: 'Small Flat Rate Box',
-          regional_rate_box_a: 'Regional Rate Box A',
-          regional_rate_box_b: 'Regional Rate Box B',
-          regional_rate_box_c: 'Regional Rate Box C',
-          flat_rate_envelope: 'Flat Rate Envelope',
-          legal_flat_rate_envelope: 'Legal Flat Rate Envelope',
-          padded_flat_rate_envelope: 'Padded Flat Rate Envelope',
-          gift_card_flat_rate_envelope: 'Gift Card Flat Rate Envelope',
-          window_flat_rate_envelope: 'Window Flat Rate Envelope',
-          small_flat_rate_envelope: 'Small Flat Rate Envelope',
-          large_envelope: 'Large Envelope',
-          parcel: 'Parcel',
-          postcards: 'Postcards'
-        }.map { |k, v| "(?<#{k}>#{v})" }.join("|").freeze
-
-        # We use this for identifying rates that use the Hold for Pickup service.
-        HOLD_FOR_PICKUP = /Hold for Pickup/i
-
-        # For most rate options, USPS will return how many business days it takes to deliver this
-        # package in the format "{1,2,3}-Day". We can filter this out using the below Regex.
-        DAYS_TO_DELIVERY = /(?<days>\d)-Day/
-
-        # When delivering to military ZIP codes, we don't actually get a timing estimate, but instead the string
-        # "Military". We use this to indicate that this rate is for a military zip code in the rates' data Hash.
-        MILITARY = /MILITARY/i
-
-        # The tags used in the rate node that we get information from.
-        SERVICE_CODE_TAG = 'CLASSID'
-        SERVICE_NAME_TAG = 'MailService'
-        RATE_TAG = 'Rate'
-        COMMERCIAL_RATE_TAG = 'CommercialRate'
-        COMMERCIAL_PLUS_RATE_TAG = 'CommercialPlusRate'
-        DIMENSIONAL_WEIGHT_RATE = 'DimensionalWeightRate'
-        FEES = './/Fees/Fee'
-        CURRENCY = Money::Currency.new('USD').freeze
-
-        class << self
-          def call(rate_node, package, package_options)
-            # "A mail class identifier for the postage returned. Not necessarily unique within a <Package/>."
-            # (from the USPS docs). We save this on the data Hash, but do not use it for identifying shipping methods.
-            service_code = rate_node.attributes[SERVICE_CODE_TAG].value
-
-            # The long string discussed above.
-            service_name = rate_node.at(SERVICE_NAME_TAG).text
-
-            # Does this rate assume Hold for Pickup service?
-            hold_for_pickup = service_name.match?(HOLD_FOR_PICKUP)
-
-            # Is the destination a military ZIP code?
-            military = service_name.match?(MILITARY)
-
-            # If we get a days-to-delivery indication, save it in the `days_to_delivery` variable.
-            days_to_delivery_match = service_name.match(DAYS_TO_DELIVERY)
-            days_to_delivery = if days_to_delivery_match
-                                 days_to_delivery_match.named_captures.values.first.to_i
-                               end
-
-            # Clean up the long string
-            service_name.gsub!(SERVICE_NAME_SUBSTITUTIONS, '')
-
-            # Some USPS services only offer commercial pricing. Unfortunately, USPS then returns a retail rate of 0.
-            # In these cases, return the commercial rate instead of the normal rate.
-            #
-            # Some rates are available in both commercial and retail pricing - if we want the commercial pricing here,
-            # we need to specify the commercial_pricing property on the `Physical::Package`.
-            #
-            commercial_rate_requested_or_rate_is_zero = package_options.commercial_pricing || rate_node.at(RATE_TAG).text.to_d.zero?
-            commercial_rate_available = rate_node.at(COMMERCIAL_RATE_TAG) || rate_node.at(COMMERCIAL_PLUS_RATE_TAG)
-
-            rate_value =
-              if commercial_rate_requested_or_rate_is_zero && commercial_rate_available
-                commercial_rate = rate_node.at(COMMERCIAL_RATE_TAG)&.text.to_d
-                commercial_rate.zero? ? rate_node.at(COMMERCIAL_PLUS_RATE_TAG).text.to_d : commercial_rate
-              else
-                rate_node.at(RATE_TAG).text.to_d
-              end
-
-            # The rate expressed as a RubyMoney objext
-            rate = Money.new(rate_value * CURRENCY.subunit_to_unit, CURRENCY)
-
-            # Which shipping method does this rate belong to? We first try to match a rate to a shipping method
-            # by class ID (the CLASSID attribute in the USPS API rate response). Not every shipping method
-            # has a class ID defined, and a shipping method can have multiple class IDs (for example, Priority
-            # Express has different class IDs for standard, hold for pickup, and Sunday/Holiday delivery).
-            #
-            # If we don't find a match for class ID, we next try to match a rate to a shipping method using the
-            # shipping method's service code. The USPS API rate response includes a name for each rate in the
-            # MailService element. We match to see if the name starts with the given value. For example:
-            #   `Priority Mail Express 2-day™`
-            #
-            shipping_method =
-              SHIPPING_METHODS.detect { |sm| sm.data[:class_ids]&.include?(service_code) } ||
-              SHIPPING_METHODS.detect { |sm| service_name.tr('-', ' ').upcase.starts_with?(sm.service_code) }
-
-            # We find out the box name using a bit of Regex magic using named captures. See the `BOX_REGEX`
-            # constant above.
-            box_name_match = service_name.match(/#{BOX_REGEX}/)
-            box_name = box_name_match ? box_name_match.named_captures.compact.keys.last.to_sym : :variable
-
-            dimensional_weight_rate = rate_node.at(DIMENSIONAL_WEIGHT_RATE)&.text&.to_i
-
-            fees = rate_node.xpath(FEES).map do |fee_node|
-              type = fee_node.at('FeeType').text
-              price = fee_node.at('FeePrice').text.to_d
-              {
-                type: type,
-                price: Money.new(price * CURRENCY.subunit_to_unit, CURRENCY)
-              }
-            end
-
-            # Combine all the gathered information in a FriendlyShipping::Rate object.
-            # Careful: This rate is only for one package within the shipment, and we get multiple
-            # rates per package for the different shipping method/box/hold for pickup combinations.
-            FriendlyShipping::Rate.new(
-              shipping_method: shipping_method,
-              amounts: { package.id => rate },
-              data: {
-                package: package,
-                box_name: box_name,
-                hold_for_pickup: hold_for_pickup,
-                days_to_delivery: days_to_delivery,
-                military: military,
-                full_mail_service: service_name,
-                service_code: service_code,
-                dimensional_weight_rate: dimensional_weight_rate,
-                fees: fees
-              }
-            )
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,86 +0,0 @@
-# frozen_string_literal: true
-
-module FriendlyShipping
-  module Services
-    class Usps
-      class ParseRateResponse
-        class BoxNotFoundError < StandardError; end
-
-        class << self
-          # Parse a response from USPS' rating API
-          #
-          # @param [FriendlyShipping::Request] request The request that was used to obtain this Response
-          # @param [FriendlyShipping::Response] response The response that USPS returned
-          # @param [Physical::Shipment] shipment The shipment object we're trying to get results for
-          # @param [FriendlyShipping::Services::Usps::RateEstimateOptions] options The options we sent with this request
-          # @return [Result<ApiResult<Array<FriendlyShipping::Rate>>>] When successfully parsing, an array of rates in a Success Monad.
-          def call(request:, response:, shipment:, options:)
-            # Filter out error responses and directly return a failure
-            parsing_result = ParseXMLResponse.call(
-              request: request,
-              response: response,
-              expected_root_tag: 'RateV4Response'
-            )
-            parsing_result.fmap do |xml|
-              # Get all the possible rates for each package
-              rates_by_package = rates_from_response_node(xml, shipment, options)
-
-              rates = SHIPPING_METHODS.map do |shipping_method|
-                # For every package ...
-                matching_rates = rates_by_package.map do |package, package_rates|
-                  # ... choose the rate that fits this package best.
-
-                  package_options = options.options_for_package(package)
-
-                  ChoosePackageRate.call(shipping_method, package_rates, package_options)
-                end.compact # Some shipping rates are not available for every shipping method.
-
-                # in this case, go to the next shipping method.
-                next if matching_rates.empty?
-
-                # return one rate for all packages with the amount keys being the package IDs.
-                FriendlyShipping::Rate.new(
-                  amounts: matching_rates.map(&:amounts).reduce({}, :merge),
-                  shipping_method: shipping_method,
-                  data: matching_rates.first.data
-                )
-              end.compact
-
-              ApiResult.new(
-                rates,
-                original_request: request,
-                original_response: response
-              )
-            end
-          end
-
-          private
-
-          PACKAGE_NODE_XPATH = '//Package'
-          SERVICE_NODE_NAME = 'Postage'
-
-          # Iterate over all packages and parse the rates for each package
-          #
-          # @param [Nokogiri::XML::Node] xml The XML document containing packages and rates
-          # @param [Physical::Shipment] shipment The shipment we're trying to get rates for
-          #
-          # @return [Hash<Physical::Package => Array<FriendlyShipping::Rate>>]
-          def rates_from_response_node(xml, shipment, options)
-            xml.xpath(PACKAGE_NODE_XPATH).each_with_object({}) do |package_node, result|
-              package_id = package_node['ID']
-              corresponding_package = shipment.packages[package_id.to_i]
-              package_options = options.options_for_package(corresponding_package)
-              # There should always be a package in the original shipment that corresponds to the package ID
-              # in the USPS response.
-              raise BoxNotFoundError if corresponding_package.nil?
-
-              result[corresponding_package] = package_node.xpath(SERVICE_NODE_NAME).map do |service_node|
-                ParsePackageRate.call(service_node, corresponding_package, package_options)
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end