reactive_freight 0.0.1

data/lib/reactive_freight/carriers/clni.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module ReactiveShipping
+  class CLNI < CarrierLogistics
+    REACTIVE_FREIGHT_CARRIER = true
+
+    cattr_reader :name, :scac
+    @@name = 'Clear Lane Freight Systems'
+    @@scac = 'CLNI'
+
+    # Documents
+
+    # Rates
+    def build_calculated_accessorials(packages, origin, destination)
+      accessorials = []
+
+      longest_dimension = packages.inject([]) { |_arr, p| [p.length(:in), p.width(:in)] }.max.ceil
+      if longest_dimension > 48
+        if longest_dimension < 240
+          accessorials << '&HHG=yes' # standard overlength fee
+        elsif longest_dimension >= 240
+          accessorials << '&OVER20=yes'
+        elsif longest_dimension >= 192 && longest_dimension < 240
+          accessorials << '&OVER16=yes'
+        elsif longest_dimension >= 132 && longest_dimension < 192
+          accessorials << '&OVER11=yes'
+        elsif longest_dimension >= 96 && longest_dimension < 132
+          accessorials << '&OVER11=yes'
+        end
+      end
+
+      accessorials << '&BOSP=yes' if destination.city == 'Boston' && destination.state == 'MA'
+      accessorials << '&BOSD=yes' if origin.city == 'Boston' && origin.state == 'MA'
+
+      accessorials << '&SDDLY=yes' if destination.state == 'SD'
+      accessorials << '&SDPU=yes' if origin.state == 'SD'
+
+      # TODO: Add support for:
+      # NYBDY, NYC BUROUGH DELY
+      # NYBPU, NYC BUROUGH PU
+      # NYLID, NYC LONG ISLAND DELY
+      # NYLIP, NYC LONG ISLAND PU
+      # NYMDY, NYC MANHATTAN DELY
+      # NYMPU, NYC MANHATTAN PU
+      # TXWDY, TXWST DELY
+      # TXWPU, TXWST PU SURCHARGE
+
+      accessorials
+    end
+
+    # Tracking
+
+    # protected
+
+    # Documents
+
+    # Rates
+  end
+end

data/lib/reactive_freight/carriers/ctbv.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module ReactiveShipping
+  class CTBV < CarrierLogistics
+    REACTIVE_FREIGHT_CARRIER = true
+
+    cattr_reader :name, :scac
+    @@name = 'The Custom Companies'
+    @@scac = 'CTBV'
+
+    # Documents
+
+    # Rates
+    def build_calculated_accessorials(packages, *)
+      accessorials = []
+
+      longest_dimension = packages.inject([]) { |_arr, p| [p.length(:in), p.width(:in)] }.max.ceil
+      if longest_dimension > 144
+        accessorials << '&OL=yes'
+      elsif longest_dimension >= 96 && longest_dimension <= 144
+        accessorials << '&OL1=yes'
+      end
+
+      accessorials
+    end
+
+    # Tracking
+
+    # protected
+
+    # Documents
+
+    # Rates
+  end
+end

data/lib/reactive_freight/carriers/dphe.rb

@@ -0,0 +1,296 @@
+# frozen_string_literal: true
+
+module ReactiveShipping
+  class DPHE < ReactiveShipping::Carrier
+    REACTIVE_FREIGHT_CARRIER = true
+
+    cattr_reader :name, :scac
+    @@name = 'Dependable Highway Express'
+    @@scac = 'DPHE'
+
+    # Documents
+
+    # 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, commit_soap(:rates, request))
+    end
+
+    # Tracking
+    def find_tracking_info(tracking_number)
+      request = build_tracking_request(tracking_number)
+      parse_tracking_response(commit_soap(:track, request))
+    end
+
+    protected
+
+    def build_soap_header(_action)
+      {
+        authentication_header: {
+          user_name: @options[:username],
+          password: @options[:password]
+        }
+      }
+    end
+
+    def commit_soap(action, request)
+      Savon.client(
+        wsdl: request_url(action),
+        convert_request_keys_to: :camelcase,
+        env_namespace: :soap,
+        element_form_default: :qualified
+      ).call(
+        @conf.dig(:api, :actions, action),
+        message: request
+      ).body.to_hash
+    end
+
+    def request_url(action)
+      scheme = @conf.dig(:api, :use_ssl, action) ? 'https://' : 'http://'
+      "#{scheme}#{@conf.dig(:api, :domain)}#{@conf.dig(:api, :endpoints, action)}"
+    end
+
+    # Documents
+
+    # 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 << @conf.dig(:accessorials, :mappable)[a]
+          end
+        end
+      end
+
+      longest_dimension = packages.inject([]) { |_arr, p| [p.length(:in), p.width(:in)] }.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 = []
+      packages.each do |package|
+        shipment_detail << "1|#{package.freight_class}|#{package.pounds.ceil}"
+      end
+      shipment_detail = shipment_detail.join('|')
+
+      request = {
+        customer_code: @options[:account],
+        origin_zip: origin.to_hash[:postal_code].to_s.upcase,
+        destination_zip: destination.to_hash[:postal_code].to_s.upcase,
+        shipment_detail: shipment_detail,
+        rating_type: '', # per API documentation
+        accessorials: accessorials
+      }
+
+      save_request(request)
+      request
+    end
+
+    def parse_rate_response(origin, destination, response)
+      success = true
+      message = ''
+
+      if !response
+        success = false
+        message = 'API Error: Unknown response'
+      else
+        error = response.dig(:get_rates_response, :get_rates_result, :rate_error)
+        quote_number = response.dig(:get_rates_response, :get_rates_result, :rate_quote_number).blank?
+
+        # error on its own isn't reliable indicator of error - returns false on error
+        if !error.blank? || quote_number
+          success = false
+          message = response.dig(:get_rates_response, :get_rates_result, :return_line)
+        else
+          cost = response.dig(:get_rates_response, :get_rates_result, :totals)
+          if cost
+            cost = cost.sub('$', '').sub(',', '').sub('.', '').to_i
+            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)
+
+            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.to_hash,
+        rates: rate_estimates,
+        response: response,
+        request: last_request
+      )
+    end
+
+    # Tracking
+    def build_tracking_request(tracking_number)
+      request = { pro_number: tracking_number }
+      save_request(request)
+      request
+    end
+
+    def parse_city_state(str)
+      return nil if str.blank?
+
+      Location.new(
+        city: str.split(', ')[0].titleize,
+        state: str.split(', ')[1].split(' ')[0].upcase,
+        country: ActiveUtils::Country.find('USA')
+      )
+    end
+
+    def parse_city(str)
+      return nil if str.blank?
+
+      Location.new(
+        city: str.squeeze.strip.titleize,
+        state: nil,
+        country: ActiveUtils::Country.find('USA')
+      )
+    end
+
+    def parse_date(date)
+      date ? DateTime.strptime(date, '%m/%d/%Y %l:%M:%S %p').to_s(:db) : nil
+    end
+
+    def parse_location(comment, delimiters)
+      city = comment.split(delimiters[0])[0].split(delimiters[1])[1].split(', ')[0].titleize
+      state = comment.split(delimiters[0])[0].split(delimiters[1])[1].split(', ')[1].upcase
+
+      Location.new(
+        city: city,
+        province: state,
+        state: state,
+        country: ActiveUtils::Country.find('USA')
+      )
+    end
+
+    def parse_tracking_response(response)
+      unless response.dig(:get_tracking_response, :get_tracking_result, :tracking_status_response)
+        status = json.dig('error') || "API Error: HTTP #{response.status[0]}"
+        return TrackingResponse.new(false, status, json, carrier: "#{@@scac}, #{@@name}", json: json, response: response, request: last_request)
+      end
+
+      search_result = response.dig(:get_tracking_response, :get_tracking_result)
+
+      shipper_address = Location.new(
+        street: search_result.dig(:shipperaddress).squeeze.strip.titleize,
+        city: search_result.dig(:shipper_city).squeeze.strip.titleize,
+        state: search_result.dig(:shipper_state).strip.upcase,
+        postal_code: search_result.dig(:shipper_zip).strip,
+        country: ActiveUtils::Country.find('USA')
+      )
+
+      receiver_address = Location.new(
+        street: search_result.dig(:consaddress).squeeze.strip.titleize,
+        city: search_result.dig(:cons_city).squeeze.strip.titleize,
+        state: search_result.dig(:cons_state).strip.upcase,
+        postal_code: search_result.dig(:cons_zip).strip,
+        country: ActiveUtils::Country.find('USA')
+      )
+
+      actual_delivery_date = parse_date(search_result.dig('Shipment', 'DeliveredDateTime'))
+      pickup_date = parse_date(search_result.dig(:pickup_date))
+      scheduled_delivery_date = parse_date(search_result.dig('Shipment', 'ApptDateTime'))
+      tracking_number = search_result.dig('Shipment', 'SearchItem')
+
+      shipment_events = []
+      shipment_events << ShipmentEvent.new(
+        :picked_up,
+        pickup_date,
+        shipper_address
+      )
+
+      api_events = search_result.dig(:tracking_status_response, :tracking_status_row).reverse
+      api_events.each do |api_event|
+        event_key = nil
+        comment = api_event.dig(:tracking_status)
+
+        @conf.dig(:events, :types).each do |key, val|
+          if comment.downcase.include?(val)
+            event_key = key
+            break
+          end
+        end
+        next if event_key.blank?
+
+        case event_key
+        when :arrived_at_terminal
+          location = parse_city(comment.split('arrived')[1].upcase.split('SERVICE CENTER')[0])
+        when :delivered
+          location = parse_city_state(comment.split('in ')[1].split('completed')[0])
+        when :departed
+          location = parse_city(comment.split('departed')[1].upcase.split('SERVICE CENTER')[0])
+        when :out_for_delivery
+          location = receiver_address
+        when :trailer_closed
+          location = parse_city(comment.split('Location:')[1])
+        when :trailer_unloaded
+          location = parse_city(comment.split('Location:')[1])
+        end
+
+        datetime_without_time_zone = parse_date(api_event.dig(:tracking_date))
+
+        # status and type_code set automatically by ActiveFreight based on event
+        shipment_events << ShipmentEvent.new(event_key, datetime_without_time_zone, location)
+      end
+
+      shipment_events = shipment_events.sort_by(&:time)
+
+      TrackingResponse.new(
+        true,
+        shipment_events.last.status,
+        response,
+        carrier: "#{@@scac}, #{@@name}",
+        hash: response,
+        response: response,
+        status: status,
+        type_code: shipment_events.last.status,
+        ship_time: parse_date(search_result.dig('Shipment', 'ProDateTime')),
+        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

data/lib/reactive_freight/carriers/drrq.rb

@@ -0,0 +1,303 @@
+# frozen_string_literal: true
+
+module ReactiveShipping
+  class DRRQ < ReactiveShipping::Carrier
+    REACTIVE_FREIGHT_CARRIER = true
+
+    JSON_HEADERS = {
+      'Accept': 'application/json',
+      'Content-Type': 'application/json',
+      'charset': 'utf-8'
+    }.freeze
+
+    cattr_reader :name, :scac
+    @@name = 'TForce Worldwide'
+    @@scac = 'DRRQ'
+
+    def available_services
+      nil
+    end
+
+    def requirements
+      %i[username password]
+    end
+
+    # Documents
+    def find_pod(tracking_number, options = {})
+      options = @options.merge(options)
+      parse_pod_response(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, commit(request))
+    end
+
+    # Tracking
+
+    protected
+
+    def build_headers(action, options = {})
+      options = @options.merge(options)
+
+      case action
+      when :quote
+        JSON_HEADERS.merge(
+          {
+            'UserName' => options[:username],
+            'ApiKey' => options[:password]
+          }
+        )
+      else
+        {}
+      end
+    end
+
+    def build_url(action)
+      "#{@conf.dig(:api, :use_ssl, action) ? 'https' : 'http'}://#{@conf.dig(:api, :domains, action)}#{@conf.dig(:api, :endpoints, action)}"
+    end
+
+    def commit(request)
+      url = request[:url]
+      headers = request[:headers]
+      method = request[:method]
+      body = request[:body]
+
+      response = case method
+                 when :post
+                   HTTParty.post(url, headers: headers, body: body)
+                 else
+                   HTTParty.get(url, headers: headers)
+                 end
+
+      JSON.parse(response.body) if response&.body
+    end
+
+    def request_url(action)
+      scheme = @conf.dig(:api, :use_ssl, action) ? 'https://' : 'http://'
+      "#{scheme}#{@conf.dig(:api, :domain)}#{@conf.dig(:api, :endpoints, action)}"
+    end
+
+    # Documents
+
+    def parse_document_response(type, tracking_number, url, options = {})
+      options = @options.merge(options)
+
+      raise ReactiveShipping::ResponseError, "API Error: #{self.class.name}: Document not found" if url.blank?
+
+      path = if options[:path].blank?
+               File.join(Dir.tmpdir, "#{self.class.name} #{tracking_number} #{type.to_s.upcase}.pdf")
+             else
+               options[:path]
+             end
+      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: #{self.class.name}: Document not found"
+      end
+
+      unless url.end_with?('.pdf')
+        file = Magick::ImageList.new(file.path)
+        file.write(path)
+      end
+
+      File.exist?(path) ? path : false
+    end
+
+    def parse_pod_response(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: 'submitbutton').click
+
+      browser
+        .element(xpath: '//*[@id="__AppFrameBaseTable"]/tbody/tr[2]/td/div[4]')
+        .click
+
+      browser.iframes(src: '../mainframe/MainFrame.jsp?bRedirect=true')
+      browser.iframe(name: 'AppBody').frame(id: 'Header')
+             .text_field(name: 'filter')
+             .set(tracking_number)
+      browser.iframe(name: 'AppBody').frame(id: 'Header').button(value: 'Find')
+             .click
+
+      begin
+        browser.iframe(name: 'AppBody').frame(id: 'Detail')
+               .iframe(id: 'transportsWin')
+               .element(xpath: '/html/body/div/table/tbody/tr[2]/td[1]/span/a[2]')
+               .click
+      rescue StandardError
+        # POD not yet available
+        raise ReactiveShipping::ResponseError, "API Error: #{self.class.name}: Document not found"
+      end
+
+      browser.iframe(name: 'AppBody').frame(id: 'Detail')
+             .element(xpath: '/html/body/div[1]/div/div/div[1]/div[1]/div[2]/div/a[5]')
+             .click
+
+      html = browser.iframe(name: 'AppBody').frame(id: 'Detail').iframes[1]
+                    .element(xpath: '/html/body/table[3]')
+                    .html
+      html = Nokogiri::HTML(html)
+
+      browser.close
+
+      url = nil
+      html.css('tr').each do |tr|
+        tds = tr.css('td')
+        next if tds.size <= 1 || tds.blank?
+
+        text = tds[1].text
+        next unless text&.include?('http')
+
+        url = text if url.blank? || !url.include?('hubtran') # Prefer HubTran
+      end
+
+      parse_document_response(:pod, 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 << { ServiceCode: @conf.dig(:accessorials, :mappable)[a] }
+          end
+        end
+      end
+
+      longest_dimension_ft = (packages.inject([]) { |_arr, p| [p.length(:in), p.width(:in)] }.max.ceil.to_f / 12).ceil.to_i
+      if longest_dimension_ft >= 8 && longest_dimension_ft < 30
+        accessorials << { ServiceCode: "OVL#{longest_dimension_ft}" }
+      end
+
+      accessorials = accessorials.uniq.to_a
+
+      items = []
+      packages.each do |package|
+        items << {
+          Name: 'Freight',
+          FreightClass: package.freight_class.to_s,
+          Weight: package.pounds.ceil.to_s,
+          WeightUnits: 'lb',
+          Width: package.width(:in).ceil,
+          Length: package.length(:in).ceil,
+          Height: package.height(:in).ceil,
+          DimensionUnits: 'in',
+          Quantity: 1,
+          QuantityUnits: 'PLT' # Check this
+        }
+      end
+
+      body = {
+        Constraints: {
+          ServiceFlags: accessorials
+        },
+        Items: items,
+        PickupEvent: {
+          Date: DateTime.now.strftime('%m/%d/%Y %I:%M:00 %p'),
+          LocationCode: 'PLocationCode',
+          City: origin.to_hash[:city].upcase,
+          State: origin.to_hash[:province].upcase,
+          Zip: origin.to_hash[:postal_code].upcase,
+          Country: 'USA'
+        },
+        DropEvent: {
+          Date: (DateTime.now + 5.days).strftime('%m/%d/%Y %I:%M:00 %p'),
+          LocationCode: 'DLocationCode',
+          City: destination.to_hash[:city].upcase,
+          State: destination.to_hash[:province].upcase,
+          Zip: destination.to_hash[:postal_code].upcase,
+          Country: 'USA',
+          MaxPriceSheet: 6,
+          ShowInsurance: false
+        }
+      }.to_json
+
+      request = {
+        url: build_url(:quote),
+        headers: build_headers(:quote, options),
+        method: @conf.dig(:api, :methods, :quote),
+        body: body
+      }
+
+      save_request(request)
+      request
+    end
+
+    def parse_rate_response(origin, destination, response)
+      success = true
+      message = ''
+      rate_estimates = []
+
+      if !response
+        success = false
+        message = 'API Error: Unknown response'
+      else
+        response.each do |response_line|
+          next if response_line.dig('Message') # Signifies error
+
+          cost = response_line.dig('Total')
+          if cost
+            cost = (cost.to_f * 100).to_i
+            service = response_line.dig('Charges').map { |charges| charges.dig('Description') }
+            service = case service
+                      when service.any?('Standard LTL Guarantee')
+                        :guaranteed
+                      when service.any?('Guaranteed LTL Service AM')
+                        :guaranteed_am
+                      when service.any?('Guaranteed LTL Service PM')
+                        :guaranteed_pm
+                      else
+                        :standard
+                      end
+            transit_days = response_line.dig('ServiceDays').to_i
+            rate_estimates << RateEstimate.new(
+              origin,
+              destination,
+              { scac: response_line.dig('Scac'), name: response_line.dig('CarrierName') },
+              service,
+              transit_days: transit_days,
+              estimate_reference: nil,
+              total_cost: cost,
+              total_price: cost,
+              currency: 'USD',
+              with_excessive_length_fees: @conf.dig(:attributes, :rates, :with_excessive_length_fees)
+            )
+          else
+            next
+          end
+        end
+      end
+
+      RateResponse.new(
+        success,
+        message,
+        { response: response },
+        rates: rate_estimates,
+        response: response,
+        request: last_request
+      )
+    end
+
+    # Tracking
+  end
+end