freight_kit 0.1.19 → 0.1.21

data/lib/freight_kit/carriers/dphe.rb

@@ -1,474 +0,0 @@
-# frozen_string_literal: true
-
-module FreightKit
-  class DPHE < FreightKit::Carrier
-    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[api selenoid website]
-      end
-
-      def requirements
-        %i[credentials]
-      end
-    end
-
-    CITY_STATES = {
-                    ca: ['Los Angeles', 'Mammoth Lakes', 'Sacramento', 'Redding', 'West Sacramento'],
-                    nv: ['Reno', 'Sparks']
-                  }
-
-    REACTIVE_FREIGHT_CARRIER = true
-
-    include FreightKit::Rateable
-    include FreightKit::Trackable
-
-    class << self
-      attr_reader :name, :scac
-    end
-    @name = 'Dependable Highway Express'
-    @scac = 'DPHE'
-
-    # Documents
-
-    def pod(tracking_number)
-      parse_document_response(:pod, tracking_number)
-    end
-
-    def scanned_bol(tracking_number)
-      parse_document_response(:bol, tracking_number)
-    end
-
-    protected
-
-    def build_soap_header(_action)
-      api_credentials = fetch_credential(:api)
-
-      { authentication_header: { user_name: api_credentials.username, password: api_credentials.password } }
-    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 = { message: request }
-
-      response = ::FreightKit::SoapClient.new(
-        carrier: self,
-        action:,
-        client_args:,
-        call_args:,
-        soap_operation: @conf.dig(:api, :actions, action),
-      ).call
-
-      return response if response.is_a?(TrackingResponse) || response.is_a?(RateResponse)
-
-      response.to_hash
-    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 parse_amount(amount)
-      negative = amount.include?('(') && amount.include?(')')
-
-      ['$', ',', '(', ')'].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
-
-    # Documents
-
-    def parse_document_response(action, tracking_number)
-      document_response = DocumentResponse.new
-
-      selenoid_credential = fetch_credential(:selenoid)
-      website_credentials = fetch_credential(:website)
-
-      browser = Watir::Browser.new(*selenoid_credential.watir_args)
-
-      browser.goto(request_url(action))
-
-      browser.text_field(name: 'dnn$ctr1914$View$TextBox1').set(website_credentials.username)
-      browser.text_field(name: 'dnn$ctr1914$View$TextBox2').set(website_credentials.password)
-      browser.button(name: 'dnn$ctr1914$View$Button1').click
-
-      if browser.html.downcase.include?('invalid username or password')
-        browser.close
-
-        document_response.error = InvalidCredentialsError.new
-        return document_response
-      end
-
-      browser.text_field(name: 'ctl00$ContentPlaceHolder1$txtProNumber').set(tracking_number)
-      browser.button(name: 'ctl00$ContentPlaceHolder1$btnSubmit').click
-
-      begin
-        browser
-        .element(xpath: '//*[@id="ContentPlaceHolder1_GridView1"]/tbody/tr[2]/td[2]/a')
-        .click
-      rescue Watir::Exception::UnknownObjectException
-        document_response.error = DocumentNotFoundError.new
-        return document_response
-      end
-
-      browser.switch_window
-      button_xpath = case action
-                     when :bol then '//*[@id="ContentPlaceHolder1_btnDocs"]'
-                     when :pod then '//*[@id="ContentPlaceHolder1_btnPOD"]'
-                     end
-
-      if !button_xpath || !browser.element(xpath: button_xpath).exists?
-        browser.close
-
-        document_response.error = DocumentNotFoundError.new
-        return document_response
-      end
-
-      browser.element(xpath: button_xpath).click
-
-      if !button_xpath || browser.element(xpath: button_xpath).innertext.downcase.include?('unavailable')
-        browser.close
-
-        document_response.error = DocumentNotFoundError.new
-        return document_response
-      end
-
-      sleep(10) # so Chrome can finish downloading
-
-      download_url = "#{selenoid_credential.selenoid_options[:download_url]}/#{browser.driver.session_id}"
-      response = HTTParty.get("#{download_url}/?json")
-
-      filename = URI.encode_www_form_component(JSON.parse(response.body)&.last)
-      url = "#{download_url}/#{filename}"
-
-      document_response.request = URI.parse(url)
-
-      begin
-        response = HTTParty.get(url)
-      rescue StandardError => e
-        document_response.error = e
-        return document_response
-      end
-
-      browser.close
-
-      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
-
-    # Rates
-
-    def build_rate_request(shipment:)
-      country_codes = [shipment.destination.country.code(:alpha2).value, shipment.origin.country.code(:alpha2).value]
-
-      if country_codes.reject { |c| c.upcase == 'US' }.any?
-        raise UnserviceableError,
-              "No service from #{shipment.origin.postal_code} to #{shipment.destination.postal_code}"
-      end
-
-      accessorials = []
-      if shipment.accessorials.present?
-        serviceable_accessorials?(shipment.accessorials)
-        shipment.accessorials.each do |a|
-          if @conf.dig(:accessorials, :unserviceable).exclude?(a)
-            accessorials << @conf.dig(:accessorials, :mappable)[a]
-          end
-        end
-      end
-
-      longest_dimension = shipment.packages.map { |p| [p.length(:in), p.width(:in)].max }.max.ceil
-      if longest_dimension >= 336
-        accessorials << 'X29'
-      elsif longest_dimension >= 240 && longest_dimension < 336
-        accessorials << 'X28'
-      elsif longest_dimension >= 144 && longest_dimension < 240
-        accessorials << 'X20'
-      elsif longest_dimension >= 96 && longest_dimension < 144
-        accessorials << 'X12'
-      end
-
-      accessorials = accessorials.uniq.join(',')
-
-      shipment_detail = []
-      shipment.packages.each do |package|
-        shipment_detail << [package.quantity, package.freight_class, package.pounds(:total)].join('|')
-      end
-      shipment_detail = shipment_detail.join('|')
-
-      api_credentials = fetch_credential(:api)
-
-      request = {
-                  customer_code: api_credentials.account,
-                  origin_zip: shipment.origin.postal_code.to_s.upcase,
-                  destination_zip: shipment.destination.postal_code.to_s.upcase,
-                  shipment_detail:,
-                  rating_type: '', # per API documentation
-                  accessorials:
-                }
-
-      save_request(request)
-      request
-    end
-
-    def parse_rate_response(shipment:, response:)
-      rate_response = RateResponse.new(request: last_request, response:)
-
-      if response.blank?
-        rate_response.error = ResponseError.new('Unknown response')
-        return rate_response
-      end
-
-      error = response.dig(:get_rates_response, :get_rates_result, :return_line)
-      error ||= response.dig(:get_rates_response, :get_rates_result, :rate_error)
-
-      if error
-        rate_response.error = InvalidCredentialsError.new(error) if error.downcase.include?('not a valid customer code')
-
-        if error.downcase.include?('not a direct service point') || error.downcase.include?('lanes not serviced')
-          rate_response.error = UnserviceableError.new(error)
-        end
-
-        rate_response.error = ResponseError.new(error) if rate_response.error.blank?
-        return rate_response
-      end
-
-      quote_number = response.dig(:get_rates_response, :get_rates_result, :rate_quote_number)
-      raise FreightKit::UnserviceableError if quote_number.blank?
-
-      if response.dig(:get_rates_response, :get_rates_result, :totals).blank?
-        rate_response.error = ResponseError.new('Cost is empty')
-        return rate_response
-      end
-
-      transit_days = response.dig(:get_rates_response, :get_rates_result, :transit_days)&.to_i
-      estimate_reference = response.dig(:get_rates_response, :get_rates_result, :rate_quote_number)
-
-      prices = []
-
-      shipment_details = response.dig(
-        :get_rates_response,
-        :get_rates_result,
-        :shipment_detail_response,
-        :shipment_detail_row,
-      )
-
-      shipment_details.each do |shipment_detail|
-        next if shipment_detail[:charge].blank?
-        next if shipment_detail[:description] == 'Totals'
-
-        cents = parse_amount(shipment_detail[:charge])
-        description = shipment_detail_description(shipment_detail)
-
-        prices << Price.new(blame: :api, cents:, description:)
-      end
-
-      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 shipment_detail_description(shipment_detail)
-      return '' if shipment_detail[:description].blank?
-
-      shipment_detail[:description].capitalize.squish
-    end
-
-    # Tracking
-
-    def build_tracking_request(tracking_number)
-      request = { pro_number: tracking_number }
-      save_request(request)
-      request
-    end
-
-    def parse_api_city_state(str)
-      return if str.blank?
-
-      Location.new(
-        city: str.split(', ')[0].titleize,
-        province: str.split(', ')[1].split[0].upcase,
-        country: ActiveUtils::Country.find('USA'),
-      )
-    end
-
-    def parse_api_city(str)
-      return if str.blank?
-
-      city = str.squish.strip.titleize
-      province = nil
-      country = ActiveUtils::Country.find('USA')
-
-      CITY_STATES.each do |state, cities|
-        if cities.include?(city)
-          province = state.to_s.upcase
-          break
-        end
-      end
-
-      Location.new(city:, province:, country:)
-    end
-
-    def parse_api_date_time(date_time, location)
-      return if date_time.blank?
-
-      local_date_time = ::Time.strptime(date_time, '%m/%d/%Y %l:%M:%S %p').to_fs(:db)
-      ::FreightKit::DateTime.new(local_date_time:, location:)
-    end
-
-    def parse_location(comment, delimiters)
-      return if comment.blank? || !comment.include?(delimiters[0]) || !comment.include?(delimiters[1])
-
-      parts = comment.split(delimiters[0])[0].split(delimiters[1])[1].split(',')
-
-      city = parts[0].squish.strip.titleize
-      province = parts[1].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:)
-
-      if response.dig(:get_tracking_response, :get_tracking_result, :tracking_status_response).blank?
-        tracking_response.error = ShipmentNotFoundError.new
-        return tracking_response
-      end
-
-      search_result = response.dig(:get_tracking_response, :get_tracking_result)
-
-      country = ActiveUtils::Country.find('USA')
-
-      shipper_location = Location.new(
-        address1: search_result[:shipperaddress]&.squish&.strip&.titleize,
-        city: search_result[:shipper_city].squish.strip.titleize,
-        province: search_result[:shipper_state].strip.upcase,
-        postal_code: search_result[:shipper_zip].strip,
-        country:,
-      )
-
-      receiver_location = Location.new(
-        address1: search_result[:consaddress]&.squish&.strip&.titleize,
-        city: search_result[:cons_city].squish.strip.titleize,
-        province: search_result[:cons_state].strip.upcase,
-        postal_code: search_result[:cons_zip].strip,
-        country:,
-      )
-
-      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[:pickup_date]
-      pickup_date = parse_api_date_time(api_date_time, shipper_location)
-
-      api_date_time = search_result.dig('Shipment', 'ApptDateTime')
-      scheduled_delivery_date = parse_api_date_time(api_date_time, receiver_location)
-
-      ship_time = pickup_date
-      tracking_number = search_result.dig('Shipment', 'SearchItem')
-
-      shipment_events = []
-      shipment_events << ShipmentEvent.new(location: shipper_location, date_time: pickup_date, type_code: :picked_up)
-
-      api_events = search_result.dig(:tracking_status_response, :tracking_status_row).reverse
-      api_events.each do |api_event|
-        event_key = nil
-        comment = api_event[:tracking_status]
-
-        @conf.dig(:events, :types).each do |key, val|
-          if comment.downcase.include?(val)
-            event_key = key
-          else
-            ['signed by', 'partner delivery'].each { |val| event_key = :delivered if comment.downcase.include?(val) }
-          end
-
-          break if event_key
-        end
-
-        next if event_key.blank?
-
-        location =  case event_key
-                    when :arrived_at_terminal
-                      parse_api_city(comment.split('arrived')[1].upcase.split('SERVICE CENTER')[0])
-                    when :delivered
-                      receiver_location
-                    when :departed
-                      parse_api_city(comment.split('departed')[1].upcase.split('SERVICE CENTER')[0])
-                    when :out_for_delivery
-                      receiver_location
-                    when :trailer_closed
-                      parse_api_city(comment.split('Location:')[1])
-                    when :trailer_unloaded
-                      parse_api_city(comment.split('Location:')[1])
-                    end
-
-        date_time = parse_api_date_time(api_event[:tracking_date], location)
-
-        actual_delivery_date = date_time if event_key == :delivered
-
-        shipment_events << ShipmentEvent.new(date_time:, location:, type_code: event_key)
-      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
-  end
-end