reactive_freight 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 17738be42395599ca8147e6dbcd058e3829f7d72978471ff9c8bda4bbac09716
+  data.tar.gz: b2d39f6d615b2cd4cc298a0ab0c9897d1f7ebae626fdf2c7760e730aa92faae8
+SHA512:
+  metadata.gz: 52059a010d29aecae940475ad22a1eccb7d4d1abaf14e74b62d879c61a97ef1aa233dc2bd2afd3605b8ecad8540222abe7453e418f340b3d3106d8902e9dcaa9
+  data.tar.gz: 3d0acc30c3db90aff7d273ba3e4931324acff2c8c44cf59e25029a0e3367e449430ddb5a54795539e8e272b53f6c5832bb595a7434e715a6b78e7ef556982230

data/Gemfile

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+gemspec

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2020 Brody Hoskins
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,166 @@
+[![Ruby Style Guide](https://img.shields.io/badge/code_style-rubocop-brightgreen.svg)](https://github.com/rubocop-hq/rubocop)
+![stability-wip](https://img.shields.io/badge/stability-work_in_progress-lightgrey.svg)
+
+# ReactiveFreight
+
+ReactiveFreight extends [ReactiveShipping](https://github.com/realsubpop/reactive_shipping) to support LTL carriers.
+
+Features specific to ReactiveFreight:
+
+**Important:** The following features require carriers to be defined as a ReactiveFreight carriers specifically; this means that carriers included with ReactiveShipping function the same as before (and do not inherit the features).
+
+- Abstracted accessorials
+- Abstracted tracking events
+- Cubic feet and density calculations
+- Freight class calculations (and manual overriding)
+- Download scanned documents including bill of lading and/or proof of delivery where supported
+
+## Supported Freight Carriers & Platforms
+
+*This list varies day to day as this the project is a work in progress*
+
+**In addition** to the carriers supported by [ReactiveShipping](https://github.com/realsubpop/reactive_shipping), ReactiveFreight supports the following carriers and platforms.
+
+Carriers differ from platforms in that they have unique web services whereas platforms host several carriers' web services on a single service (platform). Carriers however may extend platforms and override them for carrier-specific functionality.
+
+### Carriers
+
+|Carrier                            |BOL|POD|Rates|Tracking|
+|-----------------------------------|---|---|-----|--------|
+|Best Overnite Express              |✓  |✓  |✓    |✓       |
+|Clear Lane Freight Systems         |✓  |✓  |✓    |✓       |
+|The Custom Companies               |   |   |✓    |✓       |
+|Dependable Highway Express         |   |   |✓    |✓       |
+|Forward Air                        |   |✓  |✓    |✓       |
+|Frontline Freight                  |✓  |✓  |✓    |✓       |
+|Peninsula Truck Lines              |   |   |✓    |        |
+|Roadrunner Transportation Services |✓  |✓  |✓    |✓       |
+|Saia                               |   |   |✓    |✓       |
+|Southeastern Freight Lines         |   |   |✓    |        |
+|Tforce Worldwide                   |   |✓  |✓    |        |
+|Total Transportation & Distribution|✓  |✓  |✓    |✓       |
+|Western Regional Delivery Service  |   |✓  |     |✓       |
+
+### Platforms
+
+* [Carrier Logistics](https://carrierlogistics.com)
+
+## Versions
+
+[See releases](https://github.com/brodyhoskins/reactive_freight/releases)
+
+## Installation
+
+Using bundler, add to the `Gemfile`:
+
+```ruby
+gem 'reactive_freight'
+```
+
+Or stand alone:
+
+```
+$ gem install reactive_freight
+```
+
+## Sample Usage
+
+Start off by initializing the carrier:
+
+```ruby
+require 'reactive_freight'
+carrier = ReactiveShipping::BTVP.new(account: 'account_number',
+                                     username: 'username',
+                                     password: 'password')
+```
+
+### Documents
+
+```ruby
+carrier.find_bol(tracking_number)
+carrier.find_pod(tracking_number, path: 'POD.pdf') # path is optional
+```
+
+### Tracking
+
+**Important:** When a ReactiveFreight carrier is loaded `ReactiveShipping::ShipmentEvent` objects' `name` and `status` will return symbols rather than text — it is up to higher-level libraries to provide translations.
+
+Carriers included with ReactiveShipping (typically non-freight) will retain the original behavior for compatibility.
+
+```ruby
+tracking = carrier.find_tracking_info(tracking_number)
+
+tracking.delivered?
+tracking.status
+
+tracking_info.shipment_events.each do |event|
+  puts "#{event.name} at #{event.location.city}, #{event.location.state} on #{event.time}. #{event.message}"
+end
+```
+
+### Quoting
+
+**Note:** Dimensions from ReactiveShipping were passed as an array in `height x width x length` order. While this is still supported, explicitly setting dimensions in a hash (as demonstrated below) is highly recommended to reduce confusion.
+
+```ruby
+packages = [
+  ReactiveShipping::Package.new(371 * 16,            # 371 lbs
+                                {
+                                  length: 40,        # inches
+                                  width: 48,
+                                  height: 47
+                                },
+                                units: :imperial),
+  ReactiveShipping::Package.new(371 * 16,            # 371 lbs
+                                {
+                                  length: 40,        # inches
+                                  width: 48,
+                                  height: 47
+                                },
+                                freight_class: 125,  # override calculated freight class
+                                units: :imperial)
+]
+
+origin = ReactiveShipping::Location.new(country: 'US',
+                                        state: 'CA',
+                                        city: 'Los Angeles',
+                                        zip: '90001')
+
+destination = ReactiveShipping::Location.new(country: 'US',
+                                             state: 'IL',
+                                             city: 'Chicago',
+                                             zip: '60007')
+
+accessorials = %i[
+  appointment_delivery
+  liftgate_delivery
+  residential_delivery
+]
+
+response = carrier.find_rates(origin, destination, packages, accessorials: accessorials)
+rates = response.rates
+rates = response.rates.sort_by(&:price).collect { |rate| [rate.service_name, rate.price] }
+```
+
+**Important:** A ReactiveFreight `RateEstimate` returns a `Hash` rather than a `String` with the carrier's name; stock ReactiveShipping `RateEstimates` return the latter:
+
+```ruby
+rate = rates.first
+rate.carrier
+
+=> "Best Overnite Express" # ReactiveShipping
+=> {:scac=>"BTVP", :name=>"Best Overnite Express"} # ReactiveFreight
+
+# To find the relevant information, check the hash
+rate.carrier.dig(:name)
+=> "Best Overnite Express"
+rate.carrier.dig(:scac)
+=> "BTVP"
+
+# Maintain compatibility with ReactiveShipping
+rate.carrier.is_a?(Hash) ? rate.carrier.dig(:name) : rate.carrier
+=> "Best Overnite Express"
+
+rate.carrier.is_a?(Hash) ? rate.carrier.dig(:scac) : nil
+=> "BTVP"
+```

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/accessorial_symbols.txt

@@ -0,0 +1,95 @@
+:afterhours_delivery
+:afterhours_pickup
+:airport_delivery
+:airport_pickup
+:amusement_park_delivery
+:amusement_park_pickup
+:appointment_delivery
+:appointment_pickup
+:athletic_facility_delivery
+:athletic_facility_pickup
+:brewery_delivery
+:brewery_pickup
+:cemetery_delivery
+:cemetery_pickup
+:church_delivery
+:church_pickup
+:construction_delivery
+:construction_pickup
+:convention_delivery
+:convention_pickup
+:customs_brokerage
+:dock_dropoff
+:dock_pickup
+:driver_assist
+:early_morning_delivery
+:early_morning_pickup
+:fair_delivery
+:fair_pickup
+:farm_delivery
+:farm_pickup
+:fitness_center_delivery
+:fitness_center_pickup
+:flatbed_delivery
+:flatbed_pickup
+:golf_course_delivery
+:golf_course_pickup
+:government_delivery
+:government_pickup
+:grocery_store_delivery
+:grocery_store_pickup
+:grocery_warehouse_delivery
+:grocery_warehouse_pickup
+:guaranteed_delivery
+:guaranteed_delivery_am
+:guaranteed_delivery_pm
+:hospital_delivery
+:hospital_pickup
+:hotel_delivery
+:hotel_pickup
+:inside_delivery
+:inside_pickup
+:inspection_site_delivery
+:inspection_site_pickup
+:jobsite_delivery
+:jobsite_pickup
+:liftgate_delivery
+:liftgate_pickup
+:mall_delivery
+:mall_pickup
+:marina_delivery
+:marina_pickup
+:military_site_delivery
+:military_site_pickup
+:mine_site_delivery
+:mine_site_pickup
+:motel_delivery
+:motel_pickup
+:nursing_home_delivery
+:nursing_home_pickup
+:park_delivery
+:park_pickup
+:prison_delivery
+:prison_pickup
+:ranch_delivery
+:ranch_pickup
+:reservation_delivery
+:reservation_pickup
+:residential_delivery
+:residential_pickup
+:resort_delivery
+:resort_pickup
+:restaurant_delivery
+:restaurant_pickup
+:school_delivery
+:school_pickup
+:steel_mill_delivery
+:steel_mill_pickup
+:storage_facility_delivery
+:storage_facility_pickup
+:university_delivery
+:university_pickup
+:utility_site_delivery
+:utility_site_pickup
+:winery_delivery
+:winery_pickup

data/lib/reactive_freight.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'httparty'
+require 'nokogiri'
+require 'open-uri'
+require 'rmagick'
+require 'savon'
+require 'watir'
+require 'webdrivers/chromedriver'
+require 'yaml'
+
+require 'reactive_shipping'
+require 'reactive_freight/package'
+require 'reactive_freight/rate_estimate'
+require 'reactive_freight/shipment_event'
+
+require 'reactive_freight/carrier'
+require 'reactive_freight/platform'
+
+require 'reactive_freight/carriers'
+require 'reactive_freight/platforms'

data/lib/reactive_freight/carrier.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module ReactiveShipping
+  class Carrier
+    attr_accessor :conf, :rates_with_excessive_length_fees
+
+    def initialize(options = {})
+      requirements.each { |key| requires!(options, key) }
+      @conf = nil
+      @debug = options[:debug].blank? ? false : true
+      @options = options
+      @last_request = nil
+      @test_mode = @options[:test]
+
+      return unless self.class::REACTIVE_FREIGHT_CARRIER
+
+      conf_path = File.join(__dir__, 'configuration', 'carriers', "#{self.class.to_s.split('::')[1].underscore}.yml")
+      @conf = YAML.safe_load(File.read(conf_path), permitted_classes: [Symbol])
+
+      @rates_with_excessive_length_fees = @conf.dig(:attributes, :rates, :with_excessive_length_fees)
+    end
+
+    def maximum_weight
+      Measured::Weight.new(10_000, :pounds)
+    end
+
+    def serviceable_accessorials?(accessorials)
+      return true if accessorials.blank?
+
+      if !self.class::REACTIVE_FREIGHT_CARRIER ||
+         !@conf.dig(:accessorials, :mappable) ||
+         !@conf.dig(:accessorials, :unquotable) ||
+         !@conf.dig(:accessorials, :unserviceable)
+        raise NotImplementedError, "#{self.class.name}: #serviceable_accessorials? not supported"
+      end
+
+      serviceable_accessorials = @conf.dig(:accessorials, :mappable).keys + @conf.dig(:accessorials, :unquotable)
+      serviceable_count = (serviceable_accessorials & accessorials).size
+
+      unserviceable_accessorials = @conf.dig(:accessorials, :unserviceable)
+      unserviceable_count = (unserviceable_accessorials & accessorials).size
+
+      if serviceable_count != accessorials.size || !unserviceable_count.zero?
+        raise ArgumentError, "#{self.class.name}: Some accessorials unserviceable"
+      end
+
+      true
+    end
+
+    def find_bol(*)
+      raise NotImplementedError, "#{self.class.name}: #find_bol not supported"
+    end
+
+    def find_estimate(*)
+      raise NotImplementedError, "#{self.class.name}: #find_estimate not supported"
+    end
+
+    def find_pod(*)
+      raise NotImplementedError, "#{self.class.name}: #find_pod not supported"
+    end
+  end
+end

data/lib/reactive_freight/carriers.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+ReactiveShipping::Carriers.register :BTVP, 'reactive_freight/carriers/btvp'
+ReactiveShipping::Carriers.register :DPHE, 'reactive_freight/carriers/dphe'
+ReactiveShipping::Carriers.register :DRRQ, 'reactive_freight/carriers/drrq'
+ReactiveShipping::Carriers.register :FWDA, 'reactive_freight/carriers/fwda'
+ReactiveShipping::Carriers.register :PENS, 'reactive_freight/carriers/pens'
+ReactiveShipping::Carriers.register :RDFS, 'reactive_freight/carriers/rdfs'
+ReactiveShipping::Carriers.register :SAIA, 'reactive_freight/carriers/saia'
+ReactiveShipping::Carriers.register :SEFL, 'reactive_freight/carriers/sefl'
+ReactiveShipping::Carriers.register :WRDS, 'reactive_freight/carriers/wrds'
+
+# Carriers based on platforms
+ReactiveShipping::Carriers.register :CLNI, 'reactive_freight/carriers/clni'
+ReactiveShipping::Carriers.register :CTBV, 'reactive_freight/carriers/ctbv'
+ReactiveShipping::Carriers.register :JFJTransportation, 'reactive_freight/carriers/jfj_transportation'
+ReactiveShipping::Carriers.register :FCSY, 'reactive_freight/carriers/fcsy'
+ReactiveShipping::Carriers.register :TOTL, 'reactive_freight/carriers/totl'

data/lib/reactive_freight/carriers/btvp.rb

@@ -0,0 +1,384 @@
+# frozen_string_literal: true
+
+module ReactiveShipping
+  class BTVP < ReactiveShipping::Carrier
+    REACTIVE_FREIGHT_CARRIER = true
+
+    cattr_reader :name, :scac
+    @@name = 'Best Overnite Express'
+    @@scac = 'BTVP'
+
+    def requirements
+      %i[username password]
+    end
+
+    # Documents
+    def find_bol(tracking_number, options = {})
+      options = @options.merge(options)
+      parse_document_response(:bol, tracking_number, options)
+    end
+
+    def find_pod(tracking_number, options = {})
+      options = @options.merge(options)
+      parse_document_response(:pod, tracking_number, options)
+    end
+
+    # Rates
+    def find_rates(origin, destination, packages, options = {})
+      options = @options.merge(options)
+      origin = Location.from(origin)
+      destination = Location.from(destination)
+      packages = Array(packages)
+
+      request = build_rate_request(origin, destination, packages, options)
+      parse_rate_response(origin, destination, packages, commit(:rates, request))
+    end
+
+    # Tracking
+    def find_tracking_info(tracking_number, options = {})
+      options = @options.merge(options)
+      request = build_tracking_request(tracking_number)
+      parse_tracking_response(commit(:track, request))
+    end
+
+    protected
+
+    def build_soap_header
+      {
+        username: @options[:username],
+        password: @options[:password]
+      }
+    end
+
+    def commit(action, request)
+      Savon.client(
+        wsdl: build_url(action),
+        convert_request_keys_to: :upcase,
+        env_namespace: :soapenv
+      ).call(
+        @conf.dig(:api, :actions, action),
+        headers: { 'SOAPAction' => '""' },
+        soap_action: false,
+        message: request
+      ).body
+    end
+
+    def parse_date(date)
+      date ? Date.strptime(date, '%m/%d/%Y').to_s(:db) : nil
+    end
+
+    def parse_datetime(datetime)
+      return nil unless datetime
+
+      if datetime.include?('-')
+        DateTime.strptime(datetime, '%Y-%m-%d %H:%M').to_s(:db)
+      else
+        DateTime.strptime(datetime, '%m/%d/%Y %H:%M').to_s(:db)
+      end
+    end
+
+    def build_url(action)
+      scheme = @conf.dig(:api, :use_ssl, action) ? 'https://' : 'http://'
+      "#{scheme}#{@conf.dig(:api, :domain)}:#{@conf.dig(:api, :ports, action)}#{@conf.dig(:api, :endpoints, action)}"
+    end
+
+    def strip_date(str)
+      str ? str.split(/[A|P]M /)[1] : nil
+    end
+
+    # Documents
+    def download_document(type, tracking_number, url, options = {})
+      options = @options.merge(options)
+      path = options[:path].blank? ? File.join(Dir.tmpdir, "#{@@name} #{tracking_number} #{type.to_s.upcase}.pdf") : options[:path]
+      file = File.new(path, 'w')
+
+      File.open(file.path, 'wb') do |file|
+        URI.parse(url).open do |input|
+          file.write(input.read)
+        end
+      rescue OpenURI::HTTPError
+        raise ReactiveShipping::ResponseError, "API Error: #{@@name}: Document not found"
+      end
+
+      File.exist?(path) ? path : false
+    end
+
+    def parse_document_response(type, tracking_number, options = {})
+      options = @options.merge(options)
+      browser = Watir::Browser.new(:chrome, headless: !@debug)
+      browser.goto(build_url(:pod))
+
+      browser.text_field(name: 'userid').set(@options[:username])
+      browser.text_field(name: 'password').set(@options[:password])
+      browser.button(name: 'btnLogin').click
+
+      browser.element(xpath: '/html/body/div[1]/div[2]/div[2]/div[1]/div[2]/img').click
+      browser.element(xpath: '/html/body/div[1]/div[2]/div[2]/div[1]/div[3]/ul[2]/li').click
+      browser.element(xpath: '/html/body/div[1]/div[2]/div[2]/div[1]/div[3]/ul[2]/li[6]/span[2]').click
+      browser.select_list(name: 'TATIWT').select('S')
+
+      browser.textarea(name: 'TATFB').set(tracking_number)
+      browser.button(xpath: '/html/body/div[1]/div[3]/div[3]/div/div[1]/div/button[2]').click
+
+      browser.element(xpath: '/html/body/div[1]/div[3]/div[2]/div/div[1]/div[4]/div[3]/div/table/tbody/tr[2]/td[2]').double_click
+
+      html = browser.element(xpath: '/html/body/div[1]/div[3]/div[2]/div/div/div/form/div[4]/div[2]/div/div/table').inner_html
+      html = Nokogiri::HTML.parse(html)
+
+      url = nil
+      html.css('tr').each do |tr|
+        next unless tr.text.downcase.include?(@conf.dig(:documents, :types, type).downcase)
+
+        link_id = tr.css('td')[1].css('a').to_html.split('id=')[1].split('onfocus')[0].gsub('"', '').strip
+        browser.element(css: "##{link_id}").click
+        url = browser.element(xpath: '/html/body/div[1]/div[3]/div[2]/div/embed').attribute_value('src')
+      end
+
+      browser.close
+
+      raise ReactiveShipping::ResponseError, "API Error: #{@@name}: Document not found" if url.blank?
+
+      download_document(type, tracking_number, url, options)
+    end
+
+    # Rates
+    def build_rate_request(origin, destination, packages, options = {})
+      options = @options.merge(options)
+
+      accessorials = []
+
+      unless options[:accessorials].blank?
+        serviceable_accessorials?(options[:accessorials])
+        options[:accessorials].each do |a|
+          unless @conf.dig(:accessorials, :unserviceable).include?(a)
+            accessorials << { code: @conf.dig(:accessorials, :mappable)[a] }
+          end
+        end
+      end
+
+      accessorials = accessorials.uniq.to_a
+
+      request = {
+        'arg0' => {
+          securityinfo: build_soap_header,
+          quote: {
+            iam: options[:iam].blank? ? 'D' : options[:iam], # S for shipper, C for consignee, D for third party
+            shipper: {
+              city: origin.to_hash[:city].to_s.upcase,
+              state: origin.to_hash[:province].to_s.upcase,
+              zip: origin.to_hash[:postal_code].to_s.upcase
+            },
+            consignee: {
+              city: destination.to_hash[:city].to_s.upcase,
+              state: destination.to_hash[:province].to_s.upcase,
+              zip: destination.to_hash[:postal_code].to_s.upcase
+            },
+            accessorialcount: accessorials.size,
+            accessorial: accessorials.blank? ? [] : accessorials,
+            ppdcol: options[:payment_type].blank? ? 'P' : options[:payment_type].blank?, # Prepaid
+            itemcount: packages.size,
+            item: packages.inject([]) do |arr, package|
+              arr << {
+                _class: package.freight_class,
+                description: 'Freight'.upcase, # Required
+                haz: '', # Y if yes
+                pallets: 1,
+                pieces: 1,
+                weight: package.pounds.ceil
+              }
+            end
+          }
+        }
+      }
+
+      save_request(request)
+      request
+    end
+
+    def parse_rate_response(origin, destination, packages, response)
+      success = true
+      message = ''
+
+      if !response
+        success = false
+        message = 'API Error: Unknown response'
+      else
+        if !response.dig(:getquote_response, :return, :rating, :errorcode).blank?
+          success = false
+          message = response.dig(:getquote_response, :return, :rating, :errorcode)
+        else
+          cost = (response.dig(:getquote_response, :return, :rating, :amount).to_f * 100).to_i
+
+          longest_dimension = packages.inject([]) { |_arr, p| [p.length(:in), p.width(:in)] }.max.ceil
+          if !@options[:tariff].blank?
+            if longest_dimension >= 168
+              cost += @options[:tariff].dig('overlength_fees').dig('over_14_ft')
+            elsif longest_dimension >= 144 && longest_dimension < 168
+              cost += @options[:tariff].dig('overlength_fees').dig('12_through_14_ft')
+            elsif longest_dimension >= 120 && longest_dimension < 144
+              cost += @options[:tariff].dig('overlength_fees').dig('10_through_12_ft')
+            elsif longest_dimension >= 96 && longest_dimension < 120
+              cost += @options[:tariff].dig('overlength_fees').dig('8_through_10_ft')
+            end
+          elsif longest_dimension >= 96
+            warn 'API Warning: Overlength fees not applied because `tariff` is empty!'
+          end
+
+          transit_days = response.dig(
+            :getquote_response,
+            :return,
+            :service,
+            :days
+          ).to_i
+
+          # Calculate real transit time based on information we have about the destination service days
+          %i[mon tue wed thu fri].each do |weekday|
+            days += 1 if response.dig(:getquote_response, :return, :service, :destination, weekday) == 'N'
+          end
+
+          estimate_reference = response.dig(
+            :getquote_response,
+            :return,
+            :rating,
+            :quotenumber
+          )
+
+          if cost
+            rate_estimates = [
+              RateEstimate.new(
+                origin,
+                destination,
+                { scac: self.class.scac.upcase, name: self.class.name },
+                :standard,
+                transit_days: transit_days,
+                estimate_reference: estimate_reference,
+                total_cost: cost,
+                total_price: cost,
+                currency: 'USD',
+                with_excessive_length_fees: @conf.dig(:attributes, :rates, :with_excessive_length_fees)
+              )
+            ]
+          else
+            success = false
+            message = 'API Error: Cost is emtpy'
+          end
+        end
+      end
+
+      RateResponse.new(
+        success,
+        message,
+        response,
+        rates: rate_estimates,
+        response: response,
+        request: last_request
+      )
+    end
+
+    # Tracking
+    def build_tracking_request(tracking_number)
+      request = {
+        'arg0' => {
+          securityinfo: build_soap_header,
+          pronumber: tracking_number
+        }
+      }
+
+      save_request(request)
+      request
+    end
+
+    def parse_location(code)
+      case code
+      when 'LA'
+        Location.new(
+          city: 'Los Angeles',
+          province: 'CA',
+          state: 'CA',
+          country: ActiveUtils::Country.find('USA')
+        )
+      else
+        Location.new(
+          city: code,
+          province: nil,
+          state: nil,
+          country: ActiveUtils::Country.find('USA')
+        )
+      end
+    end
+
+    def parse_tracking_response(response)
+      unless response.dig(:tracktrace_response, :return, :currentstatus, :errorcode).blank?
+        status = response.dig(:tracktrace_response, :return, :currentstatus, :errorcode)
+        return TrackingResponse.new(false, status, response, carrier: "#{@@scac}, #{@@name}", xml: response, response: response, request: last_request)
+      end
+
+      receiver_address = Location.new(
+        city: response.dig(:tracktrace_response, :return, :currentstatus, :consignee, :city).titleize,
+        province: response.dig(:tracktrace_response, :return, :currentstatus, :consignee, :state).upcase,
+        state: response.dig(:tracktrace_response, :return, :currentstatus, :consignee, :state).upcase,
+        country: ActiveUtils::Country.find('USA')
+      )
+
+      shipper_address = Location.new(
+        city: response.dig(:tracktrace_response, :return, :currentstatus, :shipper, :city).titleize,
+        province: response.dig(:tracktrace_response, :return, :currentstatus, :shipper, :state).upcase,
+        state: response.dig(:tracktrace_response, :return, :currentstatus, :shipper, :state).upcase,
+        country: ActiveUtils::Country.find('USA')
+      )
+
+      actual_delivery_date = response.dig(:tracktrace_response, :return, :currentstatus, :deliverydate)
+      unless actual_delivery_date.blank?
+        comment = response.dig(:tracktrace_response, :return, :currentstatus, :status).downcase
+        if comment.starts_with?('delivered')
+          actual_delivery_date = parse_date(comment.downcase.split('signed')[0].split('on')[1].strip.sub('at ', ''))
+        end
+      end
+
+      ship_time = parse_date(response.dig(:tracktrace_response, :return, :currentstatus, :shipdate))
+      scheduled_delivery_date = parse_date(response.dig(:tracktrace_response, :return, :currentstatus, :estdeliverydate))
+      tracking_number = response.dig(:tracktrace_response, :return, :pronumber)
+
+      shipment_events = []
+      response.dig(:tracktrace_response, :return, :history).each do |api_event|
+        event = nil
+        @conf.dig(:events, :types).each do |key, val|
+          if api_event.dig(:description).downcase.include? val
+            event = key
+            break
+          end
+        end
+        next if event.blank?
+
+        datetime_without_time_zone = parse_datetime("#{api_event.dig(:date)} #{api_event.dig(:time)}")
+        location = parse_location(api_event.dig(:location))
+
+        # status and type_code set automatically by ActiveFreight based on event
+        shipment_events << ShipmentEvent.new(event, datetime_without_time_zone, location)
+      end
+
+      shipment_events = shipment_events.sort_by(&:time)
+
+      TrackingResponse.new(
+        true,
+        shipment_events.last.status,
+        response,
+        carrier: "#{@@scac}, #{@@name}",
+        xml: response,
+        response: response,
+        status: status,
+        type_code: shipment_events.last.status,
+        ship_time: ship_time,
+        scheduled_delivery_date: scheduled_delivery_date,
+        actual_delivery_date: actual_delivery_date,
+        delivery_signature: nil,
+        shipment_events: shipment_events,
+        shipper_address: shipper_address,
+        origin: shipper_address,
+        destination: receiver_address,
+        tracking_number: tracking_number,
+        request: last_request
+      )
+    end
+  end
+end