freight_kit 0.1.20 → 0.1.22

data/lib/freight_kit/platforms/the_great_information_factory.rb

@@ -1,527 +1,594 @@
-# frozen_string_literal: true
-
 module FreightKit
-  class TheGreatInformationFactory < Platform
-    class << self
-      def required_credential_types
-        %i[api]
-      end
+  module Platforms
+    class TheGreatInformationFactory < Platform
+      class << self
+        def mappable_accessorials
+          {
+            appointment_delivery: 'NOTFEE',
+            inside_delivery: 'INSDEL',
+            liftgate_delivery: 'LIFDEL',
+            liftgate_pickup: 'LIFPIC',
+            mall_delivery: 'INSDEL',
+            residential_delivery: 'RESDEL',
+            residential_pickup: 'RESPIC',
+            restaurant_delivery: 'INSDEL'
+          }
+        end
 
-      def requirements
-        %i[credentials tariff]
-      end
+        def overlength_fees_require_tariff? = true
+        def required_credential_types = %i[api]
+        def requirements = %i[credentials tariff]
+        def services = %i[standard]
+
+        def unquotable_accessorials
+          %i[
+            athletic_facility_delivery
+            athletic_facility_pickup
+            cemetery_delivery
+            cemetery_pickup
+            church_delivery
+            church_pickup
+            construction_delivery
+            construction_pickup
+            dock_dropoff
+            dock_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
+            holiday_delivery
+            holiday_pickup
+            hospital_delivery
+            hospital_pickup
+            hotel_delivery
+            hotel_pickup
+            inspection_site_delivery
+            inspection_site_pickup
+            jobsite_delivery
+            jobsite_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
+            resort_delivery
+            resort_pickup
+            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
+          ]
+        end
 
-      def overlength_fees_require_tariff?
-        true
+        def unserviceable_accessorials
+          %i[
+            afterhours_delivery
+            airport_delivery
+            airport_pickup
+            amusement_park_delivery
+            amusement_park_pickup
+            appointment_pickup
+            brewery_delivery
+            brewery_pickup
+            convention_delivery
+            convention_pickup
+            customs_brokerage
+            driver_assist
+            early_morning_delivery
+            fair_delivery
+            fair_pickup
+            grocery_warehouse_delivery
+            grocery_warehouse_pickup
+            guaranteed_delivery
+            guaranteed_delivery_am
+            guaranteed_delivery_pm
+            inside_pickup
+            marina_delivery
+            marina_pickup
+            saturday_delivery
+            saturday_pickup
+            sunday_delivery
+            sunday_pickup
+            winery_delivery
+            winery_pickup
+          ]
+        end
       end
-    end
-
-    REACTIVE_FREIGHT_PLATFORM = true
 
-    include FreightKit::Rateable
-    include FreightKit::Trackable
-    include FreightKit::Pickupable
+      include FreightKit::Rateable
+      include FreightKit::Trackable
+      include FreightKit::Pickupable
+
+      API = { actions: { rates: :getquote, track: :tracktrace, pickup: :requestpickup }, use_ssl: { rates: false, track: false } }.freeze
+      EVENTS = {
+        types: {
+          arrived_at_terminal: 'arrived',
+          delivered: 'delivered',
+          departed: 'departed',
+          out_for_delivery: 'out for delvry',
+          pickup_information_sent_to_carrier: 'p/u dispatched'
+        }
+      }.freeze
 
-    protected
+      protected
 
-    def wrap_request(request)
-      { 'arg0' => request }
-    end
+      def build_calculated_accessorials(_packages) = []
 
-    def build_soap_header
-      api_credentials = fetch_credential(:api)
+      def build_location(city, province)
+        Location.new(city: city.titleize, province: province.upcase, country: ActiveUtils::Country.find('USA'))
+      end
 
-      { username: api_credentials.username, password: api_credentials.password }
-    end
+      def build_pickup_request(
+        delivery_from:,
+        delivery_to:,
+        dispatcher:,
+        pickup_from:,
+        pickup_to:,
+        scac:,
+        service:,
+        shipment:
+      )
+        shipper_phone = shipment.origin.contact.phone.gsub(/\s+/, '').gsub(/[()-+.]/, '')
+        shipper_phone = shipper_phone[1..] if shipper_phone.length == 11
+
+        request = {
+          securityinfo: build_soap_header,
+          shipperinfo: {
+            name: shipment.origin.contact.company_name,
+            contact: shipment.origin.contact.name,
+            phonenumber: shipper_phone,
+            address1: shipment.origin.address1,
+            address2: shipment.origin.address2,
+            city: shipment.origin.city,
+            state: shipment.origin.province,
+            ReadyDate: pickup_from.strftime('%m/%d/%Y'),
+            ReadyTime: pickup_from.strftime('%H%M').to_i,
+            CloseTime: pickup_to.strftime('%H%M').to_i,
+            zip: shipment.origin.postal_code,
+            SpecialInstructions: ''
+          },
+          ShipmentCount: 1,
+          shipments: [
+            {
+              DestZip: shipment.destination.postal_code,
+              Pieces: shipment.packages.sum(&:quantity),
+              Pallets: shipment.packages.select { |p| p.packaging.pallet? }.sum(&:quantity),
+              Weight: shipment.packages.sum { |p| p.pounds(:total).ceil },
+              HAZ: shipment.packages.any?(&:hazmat?) ? 'Y' : 'N',
+              dblStack: 'N',
+              SortSeg: 'N',
+              Pro: shipment.pro,
+              Liftgate: shipment.accessorials.include?(:liftgate_pickup) ? 'Y' : 'N'
+            }
+          ]
+        }
 
-    def commit(action, request)
-      client_args = {
-                      wsdl: build_url(action),
-                      convert_request_keys_to: :upcase,
-                      env_namespace: :soapenv
-                    }
-
-      call_args = {
-                    headers: { 'SOAPAction' => '""' },
-                    soap_action: false,
-                    message: request
-                  }
-
-      ::FreightKit::SoapClient.new(
-        carrier: self,
-        action:,
-        client_args:,
-        call_args:,
-        soap_operation: @conf.dig(:api, :actions, action),
-      ).call
-    end
+        request = wrap_request(request)
+        save_request(request)
 
-    def parse_api_date(date)
-      return if date.blank?
+        request
+      end
 
-      local_date = ::Date.strptime(date, '%m/%d/%Y')
-      ::FreightKit::DateTime.new(local_date:)
-    end
+      def build_rate_request(shipment:)
+        accessorials = []
 
-    def parse_api_date_time(date_time, location)
-      return if date_time.blank?
+        if shipment.accessorials.present?
+          serviceable_accessorials?(shipment.accessorials)
 
-      format = date_time.include?('-') ? '%Y-%m-%d %H:%M' : '%m/%d/%Y %H:%M'
+          accessorials = shipment
+                         .accessorials
+                         .select { |accessorial| unserviceable_accessorials.exclude?(accessorial) }
+                         .map { |accessorial| mappable_accessorials[accessorial] }
+        end
 
-      local_date_time = ::Time.strptime(date_time, format).to_fs(:db)
-      ::FreightKit::DateTime.new(local_date_time:, location:)
-    end
+        accessorials += build_calculated_accessorials(shipment.packages)
+        accessorials.uniq!
+
+        item = shipment.packages.map do |package|
+          {
+            _class: package.freight_class,
+            description: (package.description || 'Freight')[..8].upcase,
+            haz: (package.hazmat? ? 'Y' : ''),
+            pallets: (package.packaging.pallet? ? package.quantity : 0),
+            pieces: package.quantity,
+            weight: package.pounds(:total).ceil
+          }
+        end
 
-    def build_url(action)
-      scheme = @conf.dig(:api, :use_ssl, action) ? 'https://' : 'http://'
-      domain = @conf.dig(:api, :domains, action).presence || @conf.dig(:api, :domain)
-      port = @conf.dig(:api, :ports, action)
-      return [scheme, domain, @conf.dig(:api, :endpoints, action)].join unless port
+        request = {
+          securityinfo: build_soap_header,
+          quote: {
+            iam: 'D', # S for shipper, C for consignee, D for third party
+            shipper: {
+              city: shipment.origin.city.upcase,
+              state: shipment.origin.province.upcase,
+              zip: shipment.origin.postal_code.gsub(/\s+/, '').upcase
+            },
+            consignee: {
+              city: shipment.destination.city.upcase,
+              state: shipment.destination.province.upcase,
+              zip: shipment.destination.postal_code.gsub(/\s+/, '').upcase
+            },
+            accessorialcount: accessorials.count,
+            accessorial: accessorials.map { |code| { code: } },
+            ppdcol: 'P', # Prepaid
+            itemcount: shipment.packages.sum(&:quantity),
+            item:
+          }
+        }
 
-      "#{scheme}#{domain}:#{port}#{@conf.dig(:api, :endpoints, action)}"
-    end
+        request = wrap_request(request)
+        save_request(request)
 
-    def strip_date(str)
-      str ? str.split(/[A|P]M /)[1] : nil
-    end
+        request
+      end
 
-    # Rates
+      def build_soap_header
+        api_credentials = fetch_credential(:api)
 
-    def build_calculated_accessorials(packages)
-      []
-    end
+        { username: api_credentials.username, password: api_credentials.password }
+      end
 
-    def build_rate_request(shipment:)
-      accessorials = []
+      def build_tracking_request(tracking_number)
+        request = { pronumber: tracking_number, securityinfo: build_soap_header }
 
-      if shipment.accessorials.present?
-        serviceable_accessorials?(shipment.accessorials)
+        request = wrap_request(request)
+        save_request(request)
 
-        accessorials = shipment
-                       .accessorials
-                       .select { |accessorial| @conf.dig(:accessorials, :unserviceable).exclude?(accessorial) }
-                       .map { |accessorial| @conf.dig(:accessorials, :mappable, accessorial) }
+        request
       end
 
-      accessorials += build_calculated_accessorials(shipment.packages)
-      accessorials.uniq!
-
-      item = shipment.packages.map do |package|
-        {
-          _class: package.freight_class,
-          description: (package.description || 'Freight')[..8].upcase,
-          haz: (package.hazmat? ? 'Y' : ''),
-          pallets: (package.packaging.pallet? ? package.quantity : 0),
-          pieces: package.quantity,
-          weight: package.pounds(:total).ceil
-        }
-      end
+      def build_url(action)
+        scheme = self.class::API.dig(:use_ssl, action) ? 'https://' : 'http://'
+        domain = self.class::API.dig(:domains, action).presence || self.class::API[:domain]
+        port = self.class::API.dig(:ports, action)
+        return [scheme, domain, self.class::API.dig(:endpoints, action)].join unless port
 
-      request = {
-                  securityinfo: build_soap_header,
-                  quote: {
-                           iam: 'D', # S for shipper, C for consignee, D for third party
-                           shipper: {
-                                      city: shipment.origin.city.upcase,
-                                      state: shipment.origin.province.upcase,
-                                      zip: shipment.origin.postal_code.gsub(/\s+/, '').upcase
-                                    },
-                           consignee: {
-                                        city: shipment.destination.city.upcase,
-                                        state: shipment.destination.province.upcase,
-                                        zip: shipment.destination.postal_code.gsub(/\s+/, '').upcase
-                                      },
-                           accessorialcount: accessorials.count,
-                           accessorial: accessorials.map { |code| { code: } },
-                           ppdcol: 'P', # Prepaid
-                           itemcount: shipment.packages.sum(&:quantity),
-                           item:
-                         }
-                }
-
-      request = wrap_request(request)
-      save_request(request)
-
-      request
-    end
+        "#{scheme}#{domain}:#{port}#{self.class::API.dig(:endpoints, action)}"
+      end
 
-    def rate_item_description(rate_item)
-      description = rate_item[:description] || ''
-      description = description.gsub('-', '')
-      description = description.squish
-      description = description.sub('disc.on', 'discount on')
-      description = description.capitalize
-      description = description.sub('zip code', 'ZIP code')
-      description.sub('Zip code', 'ZIP code')
-    end
+      def commit(action, request)
+        client_args = { wsdl: build_url(action), convert_request_keys_to: :upcase, env_namespace: :soapenv }
 
-    def parse_rate_response(shipment:, response:)
-      rate_response = RateResponse.new(request: last_request, response:)
+        call_args = { headers: { 'SOAPAction' => '""' }, soap_action: false, message: request }
 
-      if response.blank?
-        rate_response.error = ResponseError.new('Unknown response')
-        return rate_response
+        ::FreightKit::SoapClient.new(
+          carrier: self,
+          action:,
+          client_args:,
+          call_args:,
+          soap_operation: self.class::API.dig(:actions, action)
+        ).call
       end
 
-      error_code = response.dig(:getquote_response, :return, :rating, :errorcode)
-      if error_code
-        rate_response.error = parse_error_response(error_code)
-        return rate_response
+      def parse_api_date(date)
+        return if date.blank?
+
+        local_date = ::Date.strptime(date, '%m/%d/%Y')
+        ::FreightKit::DateTime.new(local_date:)
       end
 
-      total_cents = response.dig(:getquote_response, :return, :rating, :amount)
+      def parse_api_date_time(date_time, location)
+        return if date_time.blank?
 
-      raise FreightKit::ResponseError, 'API Error: Cost is empty' if total_cents.blank?
+        format = date_time.include?('-') ? '%Y-%m-%d %H:%M' : '%m/%d/%Y %H:%M'
 
-      rate_items = response.dig(:getquote_response, :return, :rateitem)
-      total_cents = (total_cents.to_f * 100).to_i
+        local_date_time = ::Time.strptime(date_time, format).to_fs(:db)
+        ::FreightKit::DateTime.new(local_date_time:, location:)
+      end
 
-      prices = []
+      def parse_document_response(type, tracking_number)
+        base_url = build_url(type)
+        website_credentials = fetch_credential(:api)
+        query_parameter = "&username=#{website_credentials.username}&" \
+                          "password=#{website_credentials.password}&" \
+                          "pronumber=#{tracking_number}&" \
+                          'format=PDF'
 
-      # Confusing API sometimes returns lines of freight with high costs and then later includes includes lines that
-      # override the high cost without adding a discount, etc
-      rate_items.each do |rate_item|
-        next if ['Sub Total', 'GrandTotal'].include?(rate_item[:acccode])
+        url = [base_url, query_parameter].join
 
-        # Exclude lines that are just the packages repeated back to us
-        next unless rate_item[:pallets] == '0' && rate_item[:pieces] == '0'
+        response = HTTPClient.get(url, proxy_url:)
 
-        cents = (rate_item[:amount].to_f * 100).to_i
-        description = rate_item_description(rate_item)
+        image = response.deep_symbolize_keys.dig(:ImageRequest, :Image)
+        image = image.last if image.is_a?(Array)
+        # ImageRequest[:Image] sometimes return an Array and both images are identical
 
-        prices << Price.new(blame: :api, cents:, description:)
-      end
+        document_response = DocumentResponse.new(request: url)
 
-      # Since we expected the low-cost overriding lines earlier, we need to handle situations where those lines do not
-      # appear
-      if prices.sum(&:cents) < total_cents
-        prices = [
-                   Price.new(
-                     blame: :api,
-                     cents: total_cents - prices.sum(&:cents),
-                     description: 'Freight',
-                   ),
-                 ] + prices
-      end
+        unless image
+          document_response.error = DocumentNotFoundError.new
+          return document_response
+        end
 
-      if self.class.overlength_fees_require_tariff?
-        shipment.packages.each do |package|
-          cents = overlength_fee(tariff, package)
-          next unless cents.positive?
+        base64_document_data = image.dig(:ImageData, :__content__)
 
-          prices << Price.new(
-            blame: :tariff,
-            cents:,
-            description: 'Overlength fee',
-          )
+        unless base64_document_data
+          document_response.error = DocumentNotFoundError.new
+          return document_response
         end
-      end
 
-      transit_days = response.dig(
-        :getquote_response,
-        :return,
-        :service,
-        :days,
-      ).to_i
+        decoded_pdf_data = Base64.decode64(base64_document_data)
+        document_response.assign_attributes(content_type: 'application/pdf', data: decoded_pdf_data)
 
-      # Calculate real transit time based on information we have about the destination service days
-      %i[mon tue wed thu fri].each do |weekday|
-        transit_days += 1 if response.dig(:getquote_response, :return, :service, :destination, weekday) == 'N'
+        document_response
       end
 
-      estimate_reference = response.dig(
-        :getquote_response,
-        :return,
-        :rating,
-        :quotenumber,
-      )
-
-      rate = Rate.new(
-        carrier_name: self.class.name,
-        carrier: self,
-        currency: 'USD',
-        estimate_reference:,
-        prices:,
-        scac: self.class.scac.upcase,
-        service_name: :standard,
-        shipment:,
-        transit_days:,
-        with_excessive_length_fees: @conf.dig(:attributes, :rates, :with_excessive_length_fees),
-      )
-
-      rate_response.rates = [rate]
-      rate_response
-    end
+      def parse_error_response(error_code)
+        case error_code
+        when 'BADUSRPWD' then InvalidCredentialsError.new
+        when 'NOSVC' then UnserviceableError.new('Origin or destination has no service available')
+        when 'BADCONZIP' then UnserviceableError.new('Invalid destination ZIP code')
+        else
+          ResponseError.new("API error code #{error_code}")
+        end
+      end
 
-    # Tracking
+      def parse_location(code)
+        country = ActiveUtils::Country.find('USA')
+        return Location.new(country:) unless code
 
-    def build_tracking_request(tracking_number)
-      request = { pronumber: tracking_number, securityinfo: build_soap_header }
+        location = self.class::EVENTS.dig(:locations, code.to_sym)
 
-      request = wrap_request(request)
-      save_request(request)
+        if location
+          Location.new(city: location[:city], province: location[:state], country:)
+        else
+          Location.new(city: code, country:)
+        end
+      end
 
-      request
-    end
+      def parse_pickup_response(response)
+        pickup_response = PickupResponse.new(request: last_request, response:)
 
-    def parse_location(code)
-      country = ActiveUtils::Country.find('USA')
-      return Location.new(country:) unless code
+        result = response.dig(:requestpickup_response, :return, :results)
+        if result[:errorcode]
+          pickup_response.error = FreightKit::ResponseError.new("API Error: #{result[:errorcode]}")
+          return pickup_response
+        end
 
-      location = @conf.dig(:events, :locations, code.to_sym)
+        pickup_number = result[:pickupnumber]
 
-      if location
-        Location.new(
-          city: location[:city],
-          province: location[:state],
-          country:,
-        )
-      else
-        Location.new(city: code, country:)
-      end
-    end
+        if pickup_number == '0'
+          pickup_response.error = FreightKit::ResponseError.new('Unknown Error')
+          return pickup_response
+        end
 
-    def parse_error_response(error_code)
-      case error_code
-      when 'BADUSRPWD' then InvalidCredentialsError.new
-      when 'NOSVC' then UnserviceableError.new('Origin or destination has no service available')
-      when 'BADCONZIP' then UnserviceableError.new('Invalid destination ZIP code')
-      else
-        ResponseError.new("API error code #{error_code}")
+        pickup_response.pickup_number = pickup_number
+        pickup_response
       end
-    end
 
-    def build_location(city, province)
-      Location.new(city: city.titleize, province: province.upcase, country: ActiveUtils::Country.find('USA'))
-    end
+      def parse_rate_response(shipment:, response:)
+        rate_response = RateResponse.new(request: last_request, response:)
 
-    def parse_tracking_response(response)
-      tracking_response = TrackingResponse.new(carrier: self, request: last_request, response:)
-      mapped_response = response.dig(:tracktrace_response, :return, :currentstatus)
-
-      if mapped_response[:errorcode]
-        tracking_response.error = parse_error_response(mapped_response[:errorcode])
-        return tracking_response
-      end
+        if response.blank?
+          rate_response.error = ResponseError.new('Unknown response')
+          return rate_response
+        end
 
-      receiver_location = build_location(
-        mapped_response.dig(:consignee, :city),
-        mapped_response.dig(:consignee, :state),
-      )
-      shipper_location = build_location(mapped_response.dig(:shipper, :city), mapped_response.dig(:shipper, :state))
+        error_code = response.dig(:getquote_response, :return, :rating, :errorcode)
+        if error_code
+          rate_response.error = parse_error_response(error_code)
+          return rate_response
+        end
 
-      actual_delivery_date = mapped_response[:deliverydate]
+        total_cents = response.dig(:getquote_response, :return, :rating, :amount)
 
-      if actual_delivery_date.present?
-        comment = mapped_response[:status].downcase
+        raise FreightKit::ResponseError, 'API Error: Cost is empty' if total_cents.blank?
 
-        if comment.starts_with?('delivered')
-          api_date = comment.downcase.split('signed')[0].split('on')[1].strip.sub('at ', '')
-          actual_delivery_date = parse_api_date(api_date)
-        end
-      end
+        rate_items = response.dig(:getquote_response, :return, :rateitem)
+        total_cents = (total_cents.to_f * 100).to_i
 
-      shipment_events = []
+        prices = []
 
-      ship_time = parse_api_date(mapped_response[:shipdate])
-      # Leave this open for modification later
-      picked_up_event = ShipmentEvent.new(location: shipper_location, date_time: ship_time, type_code: :picked_up)
+        # Confusing API sometimes returns lines of freight with high costs and then later includes includes lines that
+        # override the high cost without adding a discount, etc
+        rate_items.each do |rate_item|
+          next if ['Sub Total', 'GrandTotal'].include?(rate_item[:acccode])
 
-      scheduled_delivery_date = parse_api_date(mapped_response[:estdeliverydate])
-      tracking_number = response.dig(:tracktrace_response, :return, :pronumber)
+          # Exclude lines that are just the packages repeated back to us
+          next unless rate_item[:pallets] == '0' && rate_item[:pieces] == '0'
 
-      api_events = response.dig(:tracktrace_response, :return, :history)
-      api_events = [api_events] if api_events.is_a?(Hash)
+          cents = (rate_item[:amount].to_f * 100).to_i
+          description = rate_item_description(rate_item)
 
-      last_location = nil
+          prices << Price.new(blame: :api, cents:, description:)
+        end
 
-      api_events.each_with_index do |api_event, index|
-        next if api_event[:description].blank?
+        # Since we expected the low-cost overriding lines earlier, we need to handle situations where those lines do not
+        # appear
+        if prices.sum(&:cents) < total_cents
+          prices = [Price.new(blame: :api, cents: total_cents - prices.sum(&:cents), description: 'Freight')] + prices
+        end
 
-        event = nil
-        @conf.dig(:events, :types).each do |key, val|
-          next if api_event[:description].downcase.exclude?(val)
+        if self.class.overlength_fees_require_tariff?
+          shipment.packages.each do |package|
+            cents = overlength_fee(tariff, package)
+            next unless cents.positive?
 
-          event = key
-          break
+            prices << Price.new(blame: :tariff, cents:, description: 'Overlength fee')
+          end
         end
-        next if event.blank?
 
-        location = if api_event[:location].blank?
-                     case event
-                     when :departed then last_location
-                     when :picked_up, :pickup_information_sent_to_carrier then shipper_location
-                     when :delivered, :out_for_delivery then receiver_location
-                     end
-                   else
-                     parse_location(api_event[:location])
-                   end
-
-        api_date_time = "#{api_event[:date]} #{api_event[:time]}"
-        date_time = api_event[:date].present? ? parse_api_date_time(api_date_time, location) : nil
-
-        case event
-        when :arrived_at_terminal
-          # Duplicate event occurs without location data from API
-          break if api_event[:location].blank?
-        when :delivered
-          actual_delivery_date = date_time
-        when :out_for_delivery
-          # Do not consider out for delivery when out for delivery and interlined dates match
-          next_api_event = api_events[index + 1]
-
-          break if next_api_event.blank?
-
-          if next_api_event[:description].include?('INTERLINE') && next_api_event[:date] == api_event[:date]
-            shipment_events << ShipmentEvent.new(date_time:, location:, type_code: :departed)
-            next
-          end
-        when :pickup_information_sent_to_carrier
-          # Pickup event appears after carrier information sent, let's fix that
-          picked_up_event.date_time = date_time.dup
+        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|
+          transit_days += 1 if response.dig(:getquote_response, :return, :service, :destination, weekday) == 'N'
         end
 
-        last_location = location
+        estimate_reference = response.dig(:getquote_response, :return, :rating, :quotenumber)
+
+        rate = Rate.new(
+          carrier_name: name,
+          carrier: self,
+          currency: 'USD',
+          estimate_reference:,
+          prices:,
+          scac:,
+          service_name: :standard,
+          shipment:,
+          transit_days:,
+          with_excessive_length_fees: rates_with_excessive_length_fees?
+        )
 
-        shipment_events << ShipmentEvent.new(date_time:, location:, type_code: event)
+        rate_response.rates = [rate]
+        rate_response
       end
 
-      shipment_events << picked_up_event
+      def parse_tracking_response(response)
+        tracking_response = TrackingResponse.new(carrier: self, request: last_request, response:)
+        mapped_response = response.dig(:tracktrace_response, :return, :currentstatus)
 
-      if shipment_events.collect(&:date_time).none?(nil)
-        shipment_events = shipment_events.sort_by do |shipment_event|
-          d = shipment_event.date_time
-          d&.local_date_time || d.date_time_with_zone&.to_fs(:db) || d.local_date&.to_fs(:db)
+        if mapped_response[:errorcode]
+          tracking_response.error = parse_error_response(mapped_response[:errorcode])
+          return tracking_response
         end
-      end
 
-      status = shipment_events.last&.type_code
-
-      # Workarounds for false status on certain events when timestamps are in wrong order
-      status = :out_for_delivery if shipment_events.find do |shipment_event|
-                                      shipment_event.type_code == :out_for_delivery
-                                    end
-      status = :delivered if shipment_events.find { |shipment_event| shipment_event.type_code == :delivered }
-
-      tracking_response.assign_attributes(
-        actual_delivery_date:,
-        destination: receiver_location,
-        origin: shipper_location,
-        scheduled_delivery_date:,
-        ship_time:,
-        shipment_events:,
-        status:,
-        tracking_number:,
-      )
+        receiver_location = build_location(mapped_response.dig(:consignee, :city), mapped_response.dig(:consignee, :state))
+        shipper_location = build_location(mapped_response.dig(:shipper, :city), mapped_response.dig(:shipper, :state))
 
-      tracking_response
-    end
+        actual_delivery_date = mapped_response[:deliverydate]
 
-    def parse_pickup_response(response)
-      pickup_response = PickupResponse.new(request: last_request, response:)
+        if actual_delivery_date.present?
+          comment = mapped_response[:status].downcase
 
-      result = response.dig(:requestpickup_response, :return, :results)
-      if result[:errorcode]
-        pickup_response.error = FreightKit::ResponseError.new("API Error: #{result[:errorcode]}")
-        return pickup_response
-      end
+          if comment.starts_with?('delivered')
+            api_date = comment.downcase.split('signed')[0].split('on')[1].strip.sub('at ', '')
+            actual_delivery_date = parse_api_date(api_date)
+          end
+        end
 
-      pickup_number = result[:pickupnumber]
+        shipment_events = []
 
-      if pickup_number == '0'
-        pickup_response.error = FreightKit::ResponseError.new('Unknown Error')
-        return pickup_response
-      end
+        ship_time = parse_api_date(mapped_response[:shipdate])
+        # Leave this open for modification later
+        picked_up_event = ShipmentEvent.new(location: shipper_location, date_time: ship_time, type_code: :picked_up)
 
-      pickup_response.pickup_number = pickup_number
-      pickup_response
-    end
+        scheduled_delivery_date = parse_api_date(mapped_response[:estdeliverydate])
+        tracking_number = response.dig(:tracktrace_response, :return, :pronumber)
 
-    def build_pickup_request(
-      delivery_from:,
-      delivery_to:,
-      dispatcher:,
-      pickup_from:,
-      pickup_to:,
-      scac:,
-      service:,
-      shipment:
-    )
-      shipper_phone = shipment.origin.contact.phone.gsub(/\s+/, '').gsub(/[()-+.]/, '')
-      shipper_phone = shipper_phone[1..] if shipper_phone.length == 11
-
-      request = {
-                  securityinfo: build_soap_header,
-                  shipperinfo: {
-                                 name: shipment.origin.contact.company_name,
-                                 contact: shipment.origin.contact.name,
-                                 phonenumber: shipper_phone,
-                                 address1: shipment.origin.address1,
-                                 address2: shipment.origin.address2,
-                                 city: shipment.origin.city,
-                                 state: shipment.origin.province,
-                                 ReadyDate: pickup_from.strftime('%m/%d/%Y'),
-                                 ReadyTime: pickup_from.strftime('%H%M').to_i,
-                                 CloseTime: pickup_to.strftime('%H%M').to_i,
-                                 zip: shipment.origin.postal_code,
-                                 SpecialInstructions: ''
-                               },
-                  ShipmentCount: 1,
-                  shipments: [
-                               {
-                                 DestZip: shipment.destination.postal_code,
-                                 Pieces: shipment.packages.sum(&:quantity),
-                                 Pallets: shipment.packages.select { |p| p.packaging.pallet? }.sum(&:quantity),
-                                 Weight: shipment.packages.sum { |p| p.pounds(:total).ceil },
-                                 HAZ: shipment.packages.any?(&:hazmat?) ? 'Y' : 'N',
-                                 dblStack: 'N',
-                                 SortSeg: 'N',
-                                 Pro: shipment.pro,
-                                 Liftgate: shipment.accessorials.include?(:liftgate_pickup) ? 'Y' : 'N'
-                               },
-                             ]
-                }
-
-      request = wrap_request(request)
-      save_request(request)
-
-      request
-    end
+        api_events = response.dig(:tracktrace_response, :return, :history)
+        api_events = [api_events] if api_events.is_a?(Hash)
+
+        last_location = nil
 
-    def parse_document_response(type, tracking_number)
-      base_url = build_url(type)
-      website_credentials = fetch_credential(:api)
-      query_parameter = "&username=#{website_credentials.username}&" \
-                        "password=#{website_credentials.password}&" \
-                        "pronumber=#{tracking_number}&" \
-                        'format=PDF'
+        api_events.each_with_index do |api_event, index|
+          next if api_event[:description].blank?
 
-      url = [base_url, query_parameter].join
+          event = nil
+          self.class::EVENTS[:types].each do |key, val|
+            next if api_event[:description].downcase.exclude?(val)
 
-      response = HTTPClient.get(url)
+            event = key
+            break
+          end
+          next if event.blank?
+
+          location = if api_event[:location].blank?
+                       case event
+                       when :departed then last_location
+                       when :picked_up, :pickup_information_sent_to_carrier then shipper_location
+                       when :delivered, :out_for_delivery then receiver_location
+                       end
+                     else
+                       parse_location(api_event[:location])
+                     end
 
-      image = response.deep_symbolize_keys.dig(:ImageRequest, :Image)
-      image = image.last if image.is_a?(Array)
-      # ImageRequest[:Image] sometimes return an Array and both images are identical
+          api_date_time = "#{api_event[:date]} #{api_event[:time]}"
+          date_time = api_event[:date].present? ? parse_api_date_time(api_date_time, location) : nil
+
+          case event
+          when :arrived_at_terminal
+            # Duplicate event occurs without location data from API
+            break if api_event[:location].blank?
+          when :delivered
+            actual_delivery_date = date_time
+          when :out_for_delivery
+            # Do not consider out for delivery when out for delivery and interlined dates match
+            next_api_event = api_events[index + 1]
+
+            break if next_api_event.blank?
+
+            if next_api_event[:description].include?('INTERLINE') && next_api_event[:date] == api_event[:date]
+              shipment_events << ShipmentEvent.new(date_time:, location:, type_code: :departed)
+              next
+            end
+          when :pickup_information_sent_to_carrier
+            # Pickup event appears after carrier information sent, let's fix that
+            picked_up_event.date_time = date_time.dup
+          end
 
-      document_response = DocumentResponse.new(request: url)
+          last_location = location
 
-      unless image
-        document_response.error = DocumentNotFoundError.new
-        return document_response
-      end
+          shipment_events << ShipmentEvent.new(date_time:, location:, type_code: event)
+        end
 
-      base64_document_data = image.dig(:ImageData, :__content__)
+        shipment_events << picked_up_event
 
-      unless base64_document_data
-        document_response.error = DocumentNotFoundError.new
-        return document_response
+        if shipment_events.collect(&:date_time).none?(nil)
+          shipment_events = shipment_events.sort_by do |shipment_event|
+            d = shipment_event.date_time
+            d&.local_date_time || d.date_time_with_zone&.to_fs(:db) || d.local_date&.to_fs(:db)
+          end
+        end
+
+        status = shipment_events.last&.type_code
+
+        # Workarounds for false status on certain events when timestamps are in wrong order
+        status = :out_for_delivery if shipment_events.find { |shipment_event| shipment_event.type_code == :out_for_delivery }
+        status = :delivered if shipment_events.find { |shipment_event| shipment_event.type_code == :delivered }
+
+        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
 
-      decoded_pdf_data = Base64.decode64(base64_document_data)
-      document_response.assign_attributes(content_type: 'application/pdf', data: decoded_pdf_data)
+      def rate_item_description(rate_item)
+        description = rate_item[:description] || ''
+        description = description.gsub('-', '')
+        description = description.squish
+        description = description.sub('disc.on', 'discount on')
+        description = description.capitalize
+        description = description.sub('zip code', 'ZIP code')
+        description.sub('Zip code', 'ZIP code')
+      end
 
-      document_response
+      def strip_date(str) = str ? str.split(/[A|P]M /)[1] : nil
+      def wrap_request(request) = { 'arg0' => request }
     end
   end
 end