freight_kit 0.1.20 → 0.1.22

data/lib/freight_kit/platforms/carrier_logistics.rb

@@ -1,450 +1,431 @@
-# frozen_string_literal: true
-
 module FreightKit
-  class CarrierLogistics < Platform
-    class << self
-      def required_credential_types
-        %i[api]
-      end
+  module Platforms
+    class CarrierLogistics < Platform
+      class << self
+        def required_credential_types = %i[api]
 
-      def requirements
-        return %i[credentials tariff] if overlength_fees_require_tariff?
+        def requirements
+          return %i[credentials tariff] if overlength_fees_require_tariff?
 
-        %i[credentials]
+          %i[credentials]
+        end
       end
-    end
-
-    REACTIVE_FREIGHT_PLATFORM = true
 
-    EXPIRED_CREDENTIALS_MESSAGES = [
-                                     'Your password has expired',
-                                   ].freeze
-    INVALID_CREDENTIALS_MESSAGES = [
-                                     'Unable to log in',
-                                     'Your Username or Password is Incorrect',
-                                   ].freeze
+      include FreightKit::Trackable
+      include FreightKit::Rateable
+
+      API = {
+        domain: 'tracking.carrierlogistics.com',
+        endpoints: {
+          bol: '/scripts/@CARRIER_CODE@.pol/web-login.htm?',
+          pod: '/scripts/@CARRIER_CODE@.pol/web-login.htm?',
+          rates: '/scripts/@CARRIER_CODE@.pol/ratequote.xml?',
+          track: '/scripts/@CARRIER_CODE@.pol/protracexml.htm?'
+        },
+        use_ssl: { bol: true, pod: true, rates: true, track: true }
+      }.freeze
+      EVENTS = {
+        types: {
+          arrived_at_terminal: 'trailer arrived',
+          delivered: 'delivered',
+          departed: 'trailer departed',
+          out_for_delivery: 'out for delivery',
+          picked_up: 'picked up',
+          pickup_scheduled: 'pickup request received',
+          trailer_closed: 'loaded on trailer',
+          trailer_unloaded: 'undisp'
+        }
+      }.freeze
+      EXPIRED_CREDENTIALS_MESSAGES = ['Your password has expired'].freeze
+      INVALID_CREDENTIALS_MESSAGES = ['Unable to log in', 'Your Username or Password is Incorrect'].freeze
+
+      # Documents
+
+      def build_calculated_accessorials(_shipment) = []
+
+      def build_rate_request(shipment:)
+        api_credentials = fetch_credential(:api)
+
+        query = {
+          xmlv: 'yes', # must be first
+          quotenumber: 'YES',
+          vdzip: shipment.destination.postal_code,
+          vozip: shipment.origin.postal_code,
+          xmlpass: api_credentials.password,
+          xmluser: api_credentials.username
+        }
+
+        i = 0
+        shipment.packages.each do |package|
+          i += 1 # API starts at 1 (not 0)
+
+          query["vclass[#{i}]"] = package.freight_class
+          query["wheight[#{i}]"] = package.height(:in).ceil
+          query["wlength[#{i}]"] = package.length(:in).ceil
+          query["wpallets[#{i}]"] = package.quantity
+          query["wpieces[#{i}]"] = package.quantity
+          query["wweight[#{i}]"] = package.pounds(:total).ceil
+          query["wwidth[#{i}]"] = package.width(:in).ceil
+        end
 
-    include FreightKit::Trackable
-    include FreightKit::Rateable
+        accessorials = []
 
-    # Documents
+        if shipment.accessorials.present?
+          serviceable_accessorials?(shipment.accessorials)
 
-    def pod(tracking_number)
-      query = build_tracking_request(tracking_number)
-      response = commit(:track, query)
-      parse_document_response(response, :pod)
-    end
+          shipment
+            .accessorials
+            .reject { |accessorial| unquotable_accessorials.include?(accessorial) }
+            .each do |shipment_accessorial|
+              conf_accessorial = mappable_accessorials[shipment_accessorial]
 
-    def scanned_bol(tracking_number)
-      query = build_tracking_request(tracking_number)
-      response = commit(:track, query)
-      parse_document_response(response, :bol)
-    end
+              case conf_accessorial
+              when Array then accessorials += conf_accessorial
+              when String then accessorials << conf_accessorial
+              end
+            end
+        end
 
-    # protected
+        accessorials += build_calculated_accessorials(shipment)
 
-    def build_url(action, query:)
-      scheme = @conf.dig(:api, :use_ssl, action) ? 'https://' : 'http://'
+        accessorials.uniq.compact.each { |accessorial| query[accessorial] = 'Yes' } if accessorials.any?
 
-      uri = URI.parse("#{scheme}#{@conf.dig(:api, :domain)}#{@conf.dig(:api, :endpoints, action)}")
-      uri.query = query.to_query
-      url = uri.to_s
-      return url if url.exclude?('@CARRIER_CODE@')
+        query
+      end
 
-      url.sub('@CARRIER_CODE@', @conf.dig(:api, :carrier_code))
-    end
+      def build_tracking_request(tracking_number)
+        api_credentials = fetch_credential(:api)
 
-    def commit(action, query)
-      url = build_url(action, query:)
-      save_request(url)
+        { pronum: tracking_number, xmlpass: api_credentials.password, xmluser: api_credentials.username }
+      end
 
-      HTTPClient.get(url)
-    end
+      def build_url(action, query:)
+        scheme = self.class::API.dig(:use_ssl, action) ? 'https://' : 'http://'
 
-    def map_response_errors(response, not_found_error: DocumentNotFoundError)
-      return ResponseError.new('Unknown response') if response.blank?
+        uri = URI.parse("#{scheme}#{self.class::API[:domain]}#{self.class::API.dig(:endpoints, action)}")
+        uri.query = query.to_query
+        url = uri.to_s
+        return url if url.exclude?('@CARRIER_CODE@')
 
-      webspeed_error = (response.is_a?(String) || response.is_a?(HTTPClient::Response)) &&
-                       response.include?('WebSpeed error')
-      return ResponseError.new('Temporary error (WebSpeed error)') if webspeed_error
+        url.sub('@CARRIER_CODE@', self.class::API[:carrier_code])
+      end
 
-      return if response.code == 200
+      def commit(action, query)
+        url = build_url(action, query:)
+        save_request(url)
 
-      response.code == 400 ? not_found_error.new : ResponseError.new("HTTP #{response.code}")
-    end
+        HTTPClient.get(url, proxy_url:)
+      end
 
-    # Documents
+      def map_response_errors(response, not_found_error: DocumentNotFoundError)
+        return ResponseError.new('Unknown response') if response.blank?
 
-    def parse_document_response(tracking_response, document_type)
-      document_response = DocumentResponse.new
-      document_response.error = map_response_errors(tracking_response)
-      return document_response if document_response.error.present?
+        webspeed_error = (response.is_a?(String) || response.is_a?(HTTPClient::Response)) && response.include?('WebSpeed error')
+        return ResponseError.new('Temporary error (WebSpeed error)') if webspeed_error
 
-      tracking_response.deep_symbolize_keys!
+        return if response.code == 200
 
-      image_type_code = case document_type
-                        when :bol then 'B'
-                        when :pod then 'P'
-                        end
+        response.code == 400 ? not_found_error.new : ResponseError.new("HTTP #{response.code}")
+      end
 
-      api_images = tracking_response.dig(:protrace, :images, :image)
-      api_images = [api_images] if api_images.is_a?(Hash)
+      def parse_amount(amount)
+        negative = amount.include?('-')
 
-      image = api_images&.find { |image| image[:imagetypecode] == image_type_code }
-      url = image.blank? ? nil : (image[:directurl].presence || image[:imageurl])
+        ['$', ',', '-'].each { |char| amount = amount.sub(char, '') }
 
-      if url.blank?
-        document_response.error = DocumentNotFoundError.new
-        return document_response
-      end
+        return 0 if amount.blank?
 
-      begin
-        response = HTTPClient.get(url)
-      rescue StandardError => e
-        document_response.error = e
-        return document_response
-      end
+        amount = (amount.to_f * 100).to_i
+        return amount unless negative
 
-      unless response.code == 200
-        document_response.error = DocumentNotFoundError.new
-        return document_response
+        amount * -1
       end
 
-      document_response.assign_attributes(content_type: response.headers['content-type'], data: response.body)
-      document_response
-    end
+      def parse_api_city_state(str)
+        return if str.blank?
 
-    # Tracking
+        city = str.split(', ')[0].titleize
+        province = str.split(', ')[1].upcase
 
-    def build_tracking_request(tracking_number)
-      api_credentials = fetch_credential(:api)
+        if province == '*'
+          province = case city
+                     when 'Albuquerque' then 'NM'
+                     end
+        end
 
-      { pronum: tracking_number, xmlpass: api_credentials.password, xmluser: api_credentials.username }
-    end
+        Location.new(city:, province:, country: ActiveUtils::Country.find('USA'))
+      end
 
-    def parse_api_city_state(str)
-      return if str.blank?
+      def parse_api_city_state_zip(str)
+        return if str.blank?
 
-      city = str.split(', ')[0].titleize
-      province = str.split(', ')[1].upcase
+        parts = str.split(', ')
 
-      if province == '*'
-        province = case city
-                   when 'Albuquerque' then 'NM'
-                   end
+        Location.new(city: parts.first.titleize, province: parts.last.upcase, country: ActiveUtils::Country.find('USA'))
       end
 
-      Location.new(
-        city:,
-        province:,
-        country: ActiveUtils::Country.find('USA'),
-      )
-    end
+      def parse_api_date(date, location)
+        return if date.blank?
 
-    def parse_api_city_state_zip(str)
-      return if str.blank?
+        separator = ['?', '-'].find { |separator| date.include?(separator) }
+        return if separator.blank?
 
-      parts = str.split(', ')
+        format = case date
+                 when /^\d{4}#{separator}/
+                   ['%Y', '%m', '%d'].join(separator)
+                 when /^\d{2}#{separator}/
+                   ['%m', '%d', '%Y'].join(separator)
+                 end
+        return if format.blank?
 
-      Location.new(
-        city: parts.first.titleize,
-        province: parts.last.upcase,
-        country: ActiveUtils::Country.find('USA'),
-      )
-    end
+        local_date = ::Date.strptime(date, format)
+        ::FreightKit::DateTime.new(local_date:, location:)
+      end
 
-    def parse_api_date(date, location)
-      return if date.blank?
+      def parse_api_date_time(date_time, location)
+        return if date_time.blank?
 
-      separator = ['?', '-'].find { |separator| date.include?(separator) }
-      return if separator.blank?
+        local_date_time = ::Time.strptime(date_time, '%Y-%m-%d %H:%M').to_fs(:db)
+        ::FreightKit::DateTime.new(local_date_time:, location:)
+      rescue Date::Error
+        raise if local_date_time.present?
 
-      format = case date
-               when /^\d{4}#{separator}/
-                 ['%Y', '%m', '%d'].join(separator)
-               when /^\d{2}#{separator}/
-                 ['%m', '%d', '%Y'].join(separator)
-               end
-      return if format.blank?
+        parse_api_date(local_date_time, location)
+      end
 
-      local_date = ::Date.strptime(date, format)
-      ::FreightKit::DateTime.new(local_date:, location:)
-    end
+      def parse_document_response(tracking_response, document_type)
+        document_response = DocumentResponse.new
+        document_response.error = map_response_errors(tracking_response)
+        return document_response if document_response.error.present?
 
-    def parse_api_date_time(date_time, location)
-      return if date_time.blank?
+        tracking_response.deep_symbolize_keys!
 
-      local_date_time = ::Time.strptime(date_time, '%Y-%m-%d %H:%M').to_fs(:db)
-      ::FreightKit::DateTime.new(local_date_time:, location:)
-    rescue Date::Error
-      raise if local_date_time.present?
+        image_type_code = case document_type
+                          when :bol then 'B'
+                          when :pod then 'P'
+                          end
 
-      parse_api_date(local_date_time, location)
-    end
+        api_images = tracking_response.dig(:protrace, :images, :image)
+        api_images = [api_images] if api_images.is_a?(Hash)
+
+        image = api_images&.find { |image| image[:imagetypecode] == image_type_code }
+        url = image.blank? ? nil : (image[:directurl].presence || image[:imageurl])
 
-    def parse_tracking_response(tracking_number, response:)
-      tracking_response = TrackingResponse.new(carrier: self, request: last_request, response:)
-      tracking_response.error = map_response_errors(response, not_found_error: ShipmentNotFoundError)
-      return tracking_response if tracking_response.error.present?
+        if url.blank?
+          document_response.error = DocumentNotFoundError.new
+          return document_response
+        end
 
-      response.deep_symbolize_keys!
+        begin
+          response = HTTPClient.get(url, proxy_url:)
+        rescue StandardError => e
+          document_response.error = e
+          return document_response
+        end
 
-      api_events = response.dig(:protrace, :shiphists, :shiphist)
-      if api_events.blank?
-        tracking_response.error = ResponseError.new('Empty response')
-        return tracking_response
+        unless response.code == 200
+          document_response.error = DocumentNotFoundError.new
+          return document_response
+        end
+
+        document_response.assign_attributes(content_type: response.headers['content-type'], data: response.body)
+        document_response
       end
 
-      origin = Location.new(
-        address1: response.dig(:protrace, :shipaddr)&.titleize,
-        address2: response.dig(:protrace, :shipaddr2)&.titleize,
-        city: response.dig(:protrace, :origcity)&.titleize,
-        province: response.dig(:protrace, :origstate)&.upcase,
-        country: ActiveUtils::Country.find('USA'),
-      )
-
-      destination = Location.new(
-        address1: response.dig(:protrace, :consaddr)&.titleize,
-        address2: response.dig(:protrace, :consaddr2)&.titleize,
-        city: response.dig(:protrace, :destcity)&.titleize,
-        province: response.dig(:protrace, :deststate)&.upcase,
-        country: ActiveUtils::Country.find('USA'),
-      )
-
-      deldateiso = response.dig(:protrace, :deldateiso)
-      actual_delivery_date = (parse_api_date(deldateiso, destination) if deldateiso.present?)
-
-      estdeliverydateiso = response.dig(:protrace, :estdeliverydateiso)
-      estdeliverytimestart = response.dig(:protrace, :estdeliverytimestart)
-      estimated_delivery_date = if estdeliverydateiso.present? && estdeliverytimestart.present?
-                                  parse_api_date_time([estdeliverydateiso, estdeliverytimestart].join(' '), destination)
-                                elsif estdeliverydateiso.present?
-                                  parse_api_date(estdeliverydateiso, destination)
-                                end
-
-      scheduled_delivery_date = nil
-      ship_time = nil
-
-      api_events = response.dig(:protrace, :shiphists, :shiphist)
-      api_events = [api_events] if api_events.is_a?(Hash)
-
-      last_location = origin
-
-      shipment_events = api_events.reverse.map do |api_event|
-        hist_code = api_event[:histcode]&.downcase
-        next if hist_code.blank?
-
-        event = conf.dig(:events, :types).key(hist_code)
-        next if event.blank?
-
-        remarks = api_event[:histremarks]
-
-        location = if remarks.present? && remarks.match?(/, \w{2}/) # ends in state abbreviation
-                     parse_api_city_state(api_event[:histremarks])
-                   end
-
-        location ||= case event
-                     when :delivered then destination
-                     when :departed then last_location
-                     when :picked_up, :pickup_scheduled then origin
-                     end
+      def parse_rate_response(shipment:, response:)
+        rate_response = RateResponse.new(request: last_request, response:)
 
-        date = api_event[:histdate]
-        time = api_event[:histtime]
-        # Some api_event[:histtime] returns a string with missing hours and minutes like '  :  '
-        time = nil if (time =~ /\d/).blank?
+        rate_response.error = map_response_errors(response)
+        return rate_response if rate_response.error.present?
 
-        date_time = if [date, time].all?(&:present?)
-                      parse_api_date_time([date, time].compact.join(' '), location)
-                    elsif date.present?
-                      parse_api_date(date, location)
-                    end
+        error = response.dig('error', 'errormessage')
 
-        last_location = location
+        if error.present?
+          rate_response.error = InvalidCredentialsError.new if error.downcase.include?('invalid username/password')
 
-        ShipmentEvent.new(location:, date_time:, type_code: event)
-      end
+          if error.downcase.include?('is not available') || error.downcase.include?('out of the serviceable area')
+            rate_response.error = UnserviceableError.new(error)
+          end
 
-      shipment_events.compact!
+          rate_response.error = ResponseError.new(error) if rate_response.error.blank?
 
-      status = shipment_events.last&.type_code
+          return rate_response
+        end
 
-      tracking_response.assign_attributes(
-        actual_delivery_date:,
-        destination:,
-        estimated_delivery_date:,
-        origin:,
-        scheduled_delivery_date:,
-        ship_time:,
-        shipment_events:,
-        status:,
-        tracking_number:,
-      )
+        if response.dig('ratequote', 'quotetotal').blank?
+          rate_response.error = ResponseError.new('Cost is blank')
+          return rate_response
+        end
 
-      tracking_response
-    end
+        total_cents = parse_amount(response.dig('ratequote', 'quotetotal'))
 
-    # Rates
+        transit_days = response.dig('ratequote', 'busdays').to_i
+        estimate_reference = response.dig('ratequote', 'quotenumber')
 
-    def build_calculated_accessorials(shipment)
-      []
-    end
+        ratequote_lines = response.dig('ratequote', 'ratequoteline')
+        prices = []
 
-    def parse_amount(amount)
-      negative = amount.include?('-')
+        ratequote_lines.each do |ratequote_line|
+          next if ratequote_line['chrg'].blank?
+          next if ratequote_line['chargedesc'] == 'FREIGHT'
 
-      ['$', ',', '-'].each do |char|
-        amount = amount.sub(char, '')
-      end
+          cents = parse_amount(ratequote_line['chrg'])
+          next if cents.zero?
 
-      return 0 if amount.blank?
+          prices << Price.new(blame: :api, cents:, description: ratequote_line_description(ratequote_line))
+        end
 
-      amount = (amount.to_f * 100).to_i
-      return amount unless negative
+        prices = [Price.new(blame: :api, cents: total_cents - prices.sum(&:cents), description: 'Freight')] + prices
 
-      amount * -1
-    end
+        if self.class.overlength_fees_require_tariff?
+          cents = 0
 
-    def ratequote_line_description(ratequote_line)
-      description = ratequote_line['chargedesc'] || ''
-      description = description.capitalize
+          shipment.packages.each { |package| cents += overlength_fee(tariff, package) }
 
-      code = ratequote_line['chargecode']&.upcase || ''
-      description = "#{description} (#{code})" if code.present?
+          prices << Price.new(blame: :tariff, cents:, description: 'Overlength fees') if cents.nonzero?
+        end
 
-      description.squish
-    end
+        rate = Rate.new(
+          carrier: self,
+          carrier_name: name,
+          currency: 'USD',
+          estimate_reference:,
+          scac:,
+          service_name: :standard,
+          shipment:,
+          prices:,
+          transit_days:,
+          with_excessive_length_fees: rates_with_excessive_length_fees?
+        )
 
-    def build_rate_request(shipment:)
-      api_credentials = fetch_credential(:api)
-
-      query = {
-                xmlv: 'yes', # must be first
-                quotenumber: 'YES',
-                vdzip: shipment.destination.postal_code,
-                vozip: shipment.origin.postal_code,
-                xmlpass: api_credentials.password,
-                xmluser: api_credentials.username
-              }
-
-      i = 0
-      shipment.packages.each do |package|
-        i += 1 # API starts at 1 (not 0)
-
-        query["vclass[#{i}]"] = package.freight_class
-        query["wheight[#{i}]"] = package.height(:in).ceil
-        query["wlength[#{i}]"] = package.length(:in).ceil
-        query["wpallets[#{i}]"] = package.quantity
-        query["wpieces[#{i}]"] = package.quantity
-        query["wweight[#{i}]"] = package.pounds(:total).ceil
-        query["wwidth[#{i}]"] = package.width(:in).ceil
+        rate_response.rates = [rate]
+        rate_response
       end
 
-      accessorials = []
+      def parse_tracking_response(tracking_number, response:)
+        tracking_response = TrackingResponse.new(carrier: self, request: last_request, response:)
+        tracking_response.error = map_response_errors(response, not_found_error: ShipmentNotFoundError)
+        return tracking_response if tracking_response.error.present?
 
-      if shipment.accessorials.present?
-        serviceable_accessorials?(shipment.accessorials)
+        response.deep_symbolize_keys!
 
-        shipment
-        .accessorials
-        .reject { |accessorial| conf.dig(:accessorials, :unquotable).include?(accessorial) }
-        .each do |shipment_accessorial|
-          conf_accessorial = conf.dig(:accessorials, :mappable, shipment_accessorial)
-
-          case conf_accessorial
-          when Array then accessorials += conf_accessorial
-          when String then accessorials << conf_accessorial
-          end
+        api_events = response.dig(:protrace, :shiphists, :shiphist)
+        if api_events.blank?
+          tracking_response.error = ResponseError.new('Empty response')
+          return tracking_response
         end
-      end
 
-      accessorials += build_calculated_accessorials(shipment)
+        origin = Location.new(
+          address1: response.dig(:protrace, :shipaddr)&.titleize,
+          address2: response.dig(:protrace, :shipaddr2)&.titleize,
+          city: response.dig(:protrace, :origcity)&.titleize,
+          province: response.dig(:protrace, :origstate)&.upcase,
+          country: ActiveUtils::Country.find('USA')
+        )
 
-      accessorials.uniq.compact.each { |accessorial| query[accessorial] = 'Yes' } if accessorials.any?
+        destination = Location.new(
+          address1: response.dig(:protrace, :consaddr)&.titleize,
+          address2: response.dig(:protrace, :consaddr2)&.titleize,
+          city: response.dig(:protrace, :destcity)&.titleize,
+          province: response.dig(:protrace, :deststate)&.upcase,
+          country: ActiveUtils::Country.find('USA')
+        )
 
-      query
-    end
+        deldateiso = response.dig(:protrace, :deldateiso)
+        actual_delivery_date = (parse_api_date(deldateiso, destination) if deldateiso.present?)
 
-    def parse_rate_response(shipment:, response:)
-      rate_response = RateResponse.new(request: last_request, response:)
+        estdeliverydateiso = response.dig(:protrace, :estdeliverydateiso)
+        estdeliverytimestart = response.dig(:protrace, :estdeliverytimestart)
+        estdelivery = [estdeliverydateiso, estdeliverytimestart].join(' ')
+        estimated_delivery_date = if estdeliverydateiso.present? && estdeliverytimestart.present?
+                                    parse_api_date_time(estdelivery, destination)
+                                  elsif estdeliverydateiso.present?
+                                    parse_api_date(estdeliverydateiso, destination)
+                                  end
 
-      rate_response.error = map_response_errors(response)
-      return rate_response if rate_response.error.present?
+        scheduled_delivery_date = nil
+        ship_time = nil
 
-      error = response.dig('error', 'errormessage')
+        api_events = response.dig(:protrace, :shiphists, :shiphist)
+        api_events = [api_events] if api_events.is_a?(Hash)
 
-      if error.present?
-        rate_response.error = InvalidCredentialsError.new if error.downcase.include?('invalid username/password')
+        last_location = origin
 
-        if error.downcase.include?('is not available') || error.downcase.include?('out of the serviceable area')
-          rate_response.error = UnserviceableError.new(error)
-        end
+        shipment_events = api_events.reverse.map do |api_event|
+          hist_code = api_event[:histcode]&.downcase
+          next if hist_code.blank?
 
-        rate_response.error = ResponseError.new(error) if rate_response.error.blank?
+          event = self.class::EVENTS[:types].key(hist_code)
+          next if event.blank?
 
-        return rate_response
-      end
+          remarks = api_event[:histremarks]
 
-      if response.dig('ratequote', 'quotetotal').blank?
-        rate_response.error = ResponseError.new('Cost is blank')
-        return rate_response
-      end
+          location = if remarks.present? && remarks.match?(/, \w{2}/) # ends in state abbreviation
+                       parse_api_city_state(api_event[:histremarks])
+                     end
 
-      total_cents = parse_amount(response.dig('ratequote', 'quotetotal'))
+          location ||= case event
+                       when :delivered then destination
+                       when :departed then last_location
+                       when :picked_up, :pickup_scheduled then origin
+                       end
 
-      transit_days = response.dig('ratequote', 'busdays').to_i
-      estimate_reference = response.dig('ratequote', 'quotenumber')
+          date = api_event[:histdate]
+          time = api_event[:histtime]
+          # Some api_event[:histtime] returns a string with missing hours and minutes like '  :  '
+          time = nil if (time =~ /\d/).blank?
 
-      ratequote_lines = response.dig('ratequote', 'ratequoteline')
-      prices = []
+          date_time = if [date, time].all?(&:present?)
+                        parse_api_date_time([date, time].compact.join(' '), location)
+                      elsif date.present?
+                        parse_api_date(date, location)
+                      end
 
-      ratequote_lines.each do |ratequote_line|
-        next if ratequote_line['chrg'].blank?
-        next if ratequote_line['chargedesc'] == 'FREIGHT'
+          last_location = location
 
-        cents = parse_amount(ratequote_line['chrg'])
-        next if cents.zero?
+          ShipmentEvent.new(location:, date_time:, type_code: event)
+        end
+
+        shipment_events.compact!
 
-        prices << Price.new(
-          blame: :api,
-          cents:,
-          description: ratequote_line_description(ratequote_line),
+        status = shipment_events.last&.type_code
+
+        tracking_response.assign_attributes(
+          actual_delivery_date:,
+          destination:,
+          estimated_delivery_date:,
+          origin:,
+          scheduled_delivery_date:,
+          ship_time:,
+          shipment_events:,
+          status:,
+          tracking_number:
         )
+
+        tracking_response
       end
 
-      prices = [
-                 Price.new(
-                   blame: :api,
-                   cents: total_cents - prices.sum(&:cents),
-                   description: 'Freight',
-                 ),
-               ] + prices
+      def pod(tracking_number)
+        query = build_tracking_request(tracking_number)
+        response = commit(:track, query)
+        parse_document_response(response, :pod)
+      end
 
-      if self.class.overlength_fees_require_tariff?
-        cents = 0
+      def ratequote_line_description(ratequote_line)
+        description = ratequote_line['chargedesc'] || ''
+        description = description.capitalize
 
-        shipment.packages.each do |package|
-          cents += overlength_fee(tariff, package)
-        end
+        code = ratequote_line['chargecode']&.upcase || ''
+        description = "#{description} (#{code})" if code.present?
 
-        prices << Price.new(blame: :tariff, cents:, description: 'Overlength fees') if cents.nonzero?
+        description.squish
       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
+      def scanned_bol(tracking_number)
+        query = build_tracking_request(tracking_number)
+        response = commit(:track, query)
+        parse_document_response(response, :bol)
+      end
     end
   end
 end