freight_kit 0.1.15 → 0.1.16

data/lib/freight_kit/carriers/rdfs.rb

@@ -0,0 +1,521 @@
+# frozen_string_literal: true
+
+module FreightKit
+  class RDFS < Carrier
+    REACTIVE_FREIGHT_CARRIER = true
+
+    include FreightKit::Rateable
+
+    class << self
+      attr_reader :name, :scac
+    end
+    @name = 'Roadrunner Transportation Services'
+    @scac = 'RDFS'
+
+    class << self
+      def maximum_height
+        Measured::Length.new(105, :inches)
+      end
+
+      def maximum_weight
+        Measured::Weight.new(10_000, :pounds)
+      end
+
+      def minimum_length_for_overlength_fees
+        Measured::Length.new(8, :feet)
+      end
+
+      def overlength_fees_require_tariff?
+        false
+      end
+
+      def required_credential_types
+        %i[website]
+      end
+
+      def requirements
+        %i[credentials]
+      end
+    end
+
+    # Documents
+
+    def pod(tracking_number)
+      parse_document_response(:pod, tracking_number)
+    end
+
+    def scanned_bol(tracking_number)
+      parse_document_response(:bol, tracking_number)
+    end
+
+    # Pickups
+
+    def pickup_number_is_tracking_number?
+      false
+    end
+
+    # Tracking
+
+    def find_tracking_info(tracking_number)
+      response = commit_tracking_request(tracking_number)
+
+      parse_tracking_response(response)
+    end
+
+    def find_tracking_number_from_pickup_number(pickup_number, _date)
+      parse_tracking_number_from_pickup_number_response(pickup_number)
+    end
+
+    protected
+
+    def build_soap_header(action)
+      api_credential = fetch_credential(:website)
+      validate_api_credential!(api_credential)
+
+      {
+        authentication_header: {
+                                 :@xmlns => @conf.dig(:api, :soap, :namespaces, action),
+                                 password: api_credential.password,
+                                 user_name: api_credential.username
+                               }
+      }
+    end
+
+    def commit(action, request)
+      client_args = {
+                      wsdl: request_url(action),
+                      convert_request_keys_to: :camelcase,
+                      env_namespace: :soap,
+                      element_form_default: :qualified
+                    }
+
+      call_args = {
+                    soap_header: build_soap_header(action),
+                    message: request
+                  }
+
+      soap_operation = @conf.dig(:api, :actions, action)
+
+      response = ::FreightKit::SoapClient
+                 .new(carrier: self, action:, client_args:, call_args:, soap_operation:)
+                 .call(handle_soap_fault_error: false)
+
+      response
+    rescue Savon::SOAPFault => e
+      raise InvalidCredentialsError, 'Invalid credentials' if e.message.include?('RRTS.Common.BLL.InvalidUserException')
+
+      error = if e.respond_to?(:to_hash)
+                error_hash = e.to_hash
+
+                {
+                  message: error_hash.dig(:fault, :detail, :error, :error_message),
+                  number: error_hash.dig(:fault, :detail, :error, :error_number)
+                }
+              else
+                {}
+              end
+
+      if error[:message].blank?
+        erorr[:message] = if error[:number].present?
+                            "Error #{error[:number]}"
+                          else
+                            'Unknown error'
+                          end
+      end
+
+      { error: }
+    end
+
+    def parse_amount(amount)
+      negative = amount.start_with?('-$') || amount.start_with?('-')
+
+      ['$', '-', ','].each do |char|
+        amount = amount.sub(char, '')
+      end
+
+      return 0 if amount.blank?
+
+      amount = (amount.to_f * 100).to_i
+      return amount unless negative
+
+      amount * -1
+    end
+
+    def parse_api_date_time(date_time, location)
+      return if date_time.blank? || date_time == '0001-01-01T00:00:00'
+
+      local_date_time = ::Time.strptime(date_time, '%Y-%m-%dT%H:%M:%S').to_fs(:db)
+      ::FreightKit::DateTime.new(local_date_time:, location:)
+    end
+
+    def request_url(action)
+      scheme = @conf.dig(:api, :use_ssl, action) ? 'https://' : 'http://'
+      "#{scheme}#{@conf.dig(:api, :domains, action)}#{@conf.dig(:api, :endpoints, action)}"
+    end
+
+    def strip_date(str)
+      str ? str.split(/[A|P]M /)[1] : nil
+    end
+
+    def validate_api_credential!(api_credential)
+      %i[account password username].each do |attribute|
+        if !api_credential.respond_to?(attribute) || api_credential.send(attribute).blank?
+          raise InvalidCredentialsError, "Invalid #{attribute}"
+        end
+
+        next unless attribute == :account
+
+        # Raises vague input exception from API if we don't handle ourselves
+        next if api_credential.account.gsub(/\D/, '') == api_credential.account &&
+                api_credential.account.length >= 6
+
+        raise InvalidCredentialsError, 'Invalid account'
+      end
+    end
+
+    # Documents
+
+    def parse_document_response(type, tracking_number)
+      url = request_url(type).sub('%%TRACKING_NUMBER%%', tracking_number.to_s)
+      document_response = DocumentResponse.new(request: url)
+
+      begin
+        doc = Nokogiri::HTML(URI.parse(url).open)
+      rescue OpenURI::HTTPError
+        document_response.error = FreightKit::DocumentNotFoundError.new
+        return document_response
+      end
+
+      if doc.css('img').blank?
+        document_response.error = FreightKit::DocumentNotFoundError.new
+        return document_response
+      end
+
+      data = Base64.decode64(doc.css('img').first['src'].split('data:image/jpg;base64,').last)
+
+      document_response.assign_attributes(content_type: 'image/jpeg', data:)
+      document_response
+    end
+
+    # Rates
+
+    def build_rate_request(shipment:)
+      api_credential = fetch_credential(:website)
+      validate_api_credential!(api_credential)
+
+      service_delivery_options = [
+                                   # API calls this invalid now
+                                   # service_options: { service_code: 'SS' }
+                                 ]
+
+      if shipment.accessorials.present?
+        serviceable_accessorials?(shipment.accessorials)
+
+        service_delivery_options = shipment
+                                   .accessorials
+                                   .reject { |accessorial| conf.dig(:accessorials, :unquotable).include?(accessorial) }
+                                   .map do |shipment_accessorial|
+                                     {
+                                       service_options: {
+                                                          service_code: conf.dig(
+                                                            :accessorials,
+                                                            :mappable,
+                                                            shipment_accessorial,
+                                                          )
+                                                        }
+                                     }
+                                   end
+      end
+
+      shipment.packages.each do |package|
+        longest_dimension = [package.width(:inches), package.length(:inches)].max.ceil
+
+        next if longest_dimension < 96
+
+        package.quantity.times do
+          if longest_dimension >= 240
+            service_delivery_options << { service_options: { service_code: 'EXX' } }
+          elsif longest_dimension >= 144
+            service_delivery_options << { service_options: { service_code: 'EXL' } }
+          elsif longest_dimension >= 96
+            service_delivery_options << { service_options: { service_code: 'EXM' } }
+          end
+        end
+      end
+
+      shipment_detail = []
+      shipment_box_count = 0
+      shipment_pallet_count = 0
+
+      shipment.packages.each do |package|
+        if package.packaging.type == 'pallet'
+          shipment_pallet_count += package.quantity
+        else
+          shipment_box_count += package.quantity
+        end
+
+        package.quantity.times do
+          shipment_detail << {
+                               'ActualClass' => package.freight_class,
+                               'Weight' => package.pounds(:each).ceil
+                             }
+        end
+      end
+
+      cubic_feet = if shipment.packages.map { |package| package.cubic_ft(:each) }.any?(nil)
+                     nil
+                   else
+                     shipment.packages.sum { |package| package.cubic_ft(:total) }.ceil
+                   end
+
+      request = {
+                  'request' => {
+                                 account: api_credential.account,
+                                 cubic_feet:,
+                                 destination_zip: shipment.destination.postal_code.gsub(/\s+/, '').upcase,
+                                 # linear_feet: linear_ft(packages),
+                                 origin_type: 'B', # O for shipper, I for consignee, B for third party
+                                 origin_zip: shipment.origin.postal_code.gsub(/\s+/, '').upcase,
+                                 pallet_count: shipment_pallet_count,
+                                 payment_type: 'P', # prepaid
+                                 pieces: shipment_box_count,
+                                 service_delivery_options:,
+                                 shipment_details: { shipment_detail: }
+                               }
+                }
+
+      save_request(request)
+      request
+    end
+
+    def parse_rate_response(shipment:, response:)
+      rate_response = RateResponse.new(request: last_request, response:)
+
+      error_number = response.dig(:error, :number)&.to_i
+      error_message = response.dig(:error, :message)
+
+      if error_number.present?
+        case error_number
+        when 99991
+          rate_response.error = UnserviceableError.new(error_message)
+          return rate_response
+        end
+      end
+
+      # @todo Don't rely on error_message
+
+      if error_message.present? && error_message.downcase.include?('not in the standard pickup area')
+        rate_response.error = UnserviceableError
+        return rate_response
+      end
+
+      if error_message.present? || error_number.present?
+        parts = [error_message]
+        parts << "(#{error_number})" if error_number.present?
+
+        message = parts.compact_blank.join(' ')
+
+        rate_response.error = ResponseError.new(message)
+        return rate_response
+      end
+
+      result = response.dig(:rate_quote_by_account_response, :rate_quote_by_account_result)
+
+      if result[:net_charge].blank?
+        rate_response.error = ResponseError.new('Cost is empty')
+        return rate_response
+      end
+
+      estimate_reference = result[:quote_number]
+      rate_details = result.dig(:rate_details, :quote_detail)
+      transit_days = result.dig(:routing_info, :estimated_transit_days).to_i
+
+      prices = []
+
+      rate_details.each do |rate_detail|
+        if rate_detail[:description].blank?
+          prices << Price.new(
+            blame: :api,
+            cents: parse_amount(rate_detail[:charge]),
+            description: 'Freight',
+          )
+
+          next
+        end
+
+        prices << FreightKit::Price.new(
+          blame: :api,
+          cents: parse_amount(rate_detail[:charge]),
+          description: rate_detail[:description]&.capitalize,
+        )
+      end
+
+      rate = Rate.new(
+        carrier: self,
+        carrier_name: self.class.name,
+        currency: 'USD',
+        estimate_reference:,
+        scac: self.class.scac.upcase,
+        service_name: :standard,
+        shipment:,
+        prices:,
+        transit_days:,
+        with_excessive_length_fees: @conf.dig(:attributes, :rates, :with_excessive_length_fees),
+      )
+
+      rate_response.rates = [rate]
+      rate_response
+    end
+
+    # Tracking
+
+    def commit_tracking_request(tracking_number)
+      uri = URI.parse("#{request_url(:track)}/#{tracking_number}")
+      save_request(uri)
+
+      uri.open
+    rescue OpenURI::HTTPError, Errno::EHOSTUNREACH
+      nil
+    end
+
+    def parse_api_location(comment, delimiters)
+      return if comment.blank? || !comment.include?(delimiters[0])
+
+      parts = if delimiters.size == 2
+                comment.split(delimiters[0])[0].split(delimiters[1])[1].split(',')
+              else
+                comment.split(delimiters[0])[1].split(',')
+              end
+
+      if parts.size == 1
+        str = parts[0].downcase
+        if str.include?('long beach')
+          return Location.new(
+            city: 'Long Beach',
+            province: 'CA',
+            country: ActiveUtils::Country.find('USA'),
+          )
+        end
+
+        return
+      end
+
+      city = parts[0].squish.strip.titleize
+      province = parts[1].gsub('.', '').squish.strip.upcase
+      country = ActiveUtils::Country.find('USA')
+
+      Location.new(city:, province:, country:)
+    end
+
+    def parse_tracking_response(response)
+      tracking_response = TrackingResponse.new(carrier: self, request: last_request, response:)
+
+      json = JSON.parse(response&.read || '{}')
+
+      if json['SearchResults'].blank? || response.status[0] != '200'
+        tracking_response.error = ShipmentNotFoundError.new
+        return tracking_response
+      end
+
+      search_result = json['SearchResults']&.first
+
+      pro = search_result.dig('Shipment', 'ProNumber')&.downcase
+      if pro.blank? || pro.downcase.include?('not available')
+        tracking_response.error = ShipmentNotFoundError.new
+        return tracking_response
+      end
+
+      receiver_location = Location.new(
+        city: search_result.dig('Shipment', 'Consignee', 'City').titleize,
+        province: search_result.dig('Shipment', 'Consignee', 'State').upcase,
+        country: ActiveUtils::Country.find('USA'),
+      )
+
+      shipper_location = Location.new(
+        city: search_result.dig('Shipment', 'Origin', 'City').titleize,
+        province: search_result.dig('Shipment', 'Origin', 'State').upcase,
+        country: ActiveUtils::Country.find('USA'),
+      )
+
+      api_date_time = search_result.dig('Shipment', 'DeliveredDateTime')
+      actual_delivery_date = parse_api_date_time(api_date_time, receiver_location)
+
+      api_date_time = search_result.dig('Shipment', 'ApptDateTime')
+      scheduled_delivery_date = parse_api_date_time(api_date_time, receiver_location)
+
+      tracking_number = search_result.dig('Shipment', 'SearchItem')
+
+      api_date_time = search_result.dig('Shipment', 'ProDateTime')
+      ship_time = parse_api_date_time(api_date_time, shipper_location)
+
+      last_location = nil
+      shipment_events = []
+
+      search_result.dig('Shipment', 'Comments').each do |api_event|
+        type_code = api_event['ActivityCode']
+        next if !type_code || type_code == 'ARQ'
+
+        event = @conf.dig(:events, :types).key(type_code)
+        next if event.blank?
+
+        comment = strip_date(api_event['StatusComment'])
+
+        location = case event
+                   when :arrived_at_terminal
+                     parse_api_location(comment, [' terminal in '])
+                   when :delayed_due_to_weather,
+                        :delivery_appointment_scheduled,
+                        :pending_delivery_appointment,
+                        :trailer_closed,
+                        :trailer_unloaded
+                     last_location
+                   when :delivered
+                     receiver_location
+                   when :departed, :out_for_delivery
+                     parse_api_location(comment, [' to ', 'from '])
+                   when :located
+                     parse_api_location(comment, [' currently at '])
+                   when :picked_up
+                     shipper_location
+                   end
+
+        date_time = parse_api_date_time(api_event['StatusDateTime'], location)
+
+        last_location = location
+
+        shipment_events << ShipmentEvent.new(date_time:, location:, type_code: event)
+      end
+
+      status = shipment_events.last&.type_code
+
+      tracking_response.assign_attributes(
+        actual_delivery_date:,
+        destination: receiver_location,
+        origin: shipper_location,
+        scheduled_delivery_date:,
+        ship_time:,
+        shipment_events:,
+        status:,
+        tracking_number:,
+      )
+
+      tracking_response
+    end
+
+    def parse_tracking_number_from_pickup_number_response(pickup_number)
+      url = request_url(:tracking_number_from_pickup_number).sub('%%PICKUP_NUMBER%%', pickup_number.to_s)
+
+      begin
+        doc = Nokogiri::HTML(URI.parse(url).open)
+      rescue OpenURI::HTTPError, Errno::EHOSTUNREACH
+        return
+      end
+
+      pro = doc.css('#lblProNumber')&.text
+
+      return if pro.blank? || pro.downcase.include?('not available')
+
+      pro
+    end
+  end
+end