freight_kit 0.1.20 → 0.1.21

data/lib/freight_kit/carriers/rdfs.rb

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