reactive_freight 0.0.1

data/lib/reactive_freight/platforms.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require 'reactive_freight/platforms/carrier_logistics'
+require 'reactive_freight/platforms/liftoff'

data/lib/reactive_freight/platforms/carrier_logistics.rb

@@ -0,0 +1,317 @@
+# frozen_string_literal: true
+
+module ReactiveShipping
+  class CarrierLogistics < ReactiveShipping::Platform
+    REACTIVE_FREIGHT_CARRIER = true
+
+    # Documents
+    def find_bol(tracking_number, options = {})
+      options = @options.merge(options)
+      parse_document_response(:bol, tracking_number, options)
+    end
+
+    def find_pod(tracking_number, options = {})
+      options = @options.merge(options)
+      parse_document_response(:pod, tracking_number, options)
+    end
+
+    # Rates
+    def find_rates(origin, destination, packages, options = {})
+      options = @options.merge(options)
+      origin = Location.from(origin)
+      destination = Location.from(destination)
+      packages = Array(packages)
+
+      params = build_rate_params(origin, destination, packages, options)
+      parse_rate_response(origin, destination, packages, commit(:rates, params: params))
+    end
+
+    # Tracking
+    def find_tracking_info(tracking_number)
+      parse_tracking_response(tracking_number)
+    end
+
+    # protected
+
+    def debug?
+      return false if @options[:debug].blank?
+
+      @options[:debug]
+    end
+
+    def build_url(action, options = {})
+      options = @options.merge(options)
+      scheme = @conf.dig(:api, :use_ssl, action) ? 'https://' : 'http://'
+      url = ''.dup
+      url << "#{scheme}#{@conf.dig(:api, :domain)}#{@conf.dig(:api, :endpoints, action)}"
+      url = url.sub('@CARRIER_CODE@', @conf.dig(:api, :carrier_code)) if url.include?('@CARRIER_CODE@')
+      url << options[:params] unless options[:params].blank?
+      url
+    end
+
+    def commit(action, options = {})
+      options = @options.merge(options)
+      url = build_url(action, params: options[:params])
+
+      response = HTTParty.get(url)
+      response.parsed_response if response&.parsed_response
+    end
+
+    # Documents
+    def parse_document_response(action, tracking_number, options = {})
+      options = @options.merge(options)
+      browser = Watir::Browser.new(:chrome, headless: !debug?)
+      browser.goto(build_url(action))
+
+      browser.text_field(name: 'wlogin').set(@options[:username])
+      browser.text_field(name: 'wpword').set(@options[:password])
+      browser.button(name: 'BtnAction1').click
+
+      browser.frameset.frames[1].text_field(id: 'menuquicktrack').set(tracking_number)
+      browser.browser.frameset.frames[1].button(id: 'menusubmit').click
+
+      if action == :bol
+        element = browser.frameset.frames[1].button(value: 'View Bill Of Lading Image')
+        if element.exists?
+          element.click
+        else
+          browser.close
+          raise ReactiveShipping::ResponseError, "API Error: #{self.class.name}: Document not found"
+        end
+      else
+        element = browser.frameset.frames[1].button(value: 'View Delivery Receipt Image')
+        if element.exists?
+          element.click
+        else
+          browser.close
+          raise ReactiveShipping::ResponseError, "API Error: #{self.class.name}: Document not found"
+        end
+      end
+
+      url = nil
+      browser.windows.last.use do
+        url = browser.url
+        if url.include?('viewdoc.php')
+          browser.close
+          raise ReactiveShipping::ResponseError, "API Error: #{self.class.name}: Documnent cannot be downloaded"
+        end
+      end
+
+      browser.close
+
+      path = if options[:path].blank?
+               File.join(Dir.tmpdir, "#{self.class.name} #{tracking_number} #{action.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
+
+      File.exist?(path) ? path : false
+    end
+
+    # Tracking
+    def parse_city_state(str)
+      return nil if str.blank?
+
+      Location.new(
+        city: str.split(', ')[0].titleize,
+        state: str.split(', ')[1].upcase,
+        country: ActiveUtils::Country.find('USA')
+      )
+    end
+
+    def parse_city_state_zip(str)
+      return nil if str.blank?
+
+      Location.new(
+        city: str.split(', ')[0].titleize,
+        state: str.split(', ')[1].split(' ')[0].upcase,
+        zip_code: str.split(', ')[1].split(' ')[1],
+        country: ActiveUtils::Country.find('USA')
+      )
+    end
+
+    def parse_date(date)
+      date ? DateTime.strptime(date, '%m/%d/%Y %I:%M %p').to_s(:db) : nil
+    end
+
+    def parse_tracking_response(tracking_number)
+      url = "#{build_url(:track)}wbtn=PRO&wpro1=#{tracking_number}"
+      save_request({ url: url })
+
+      begin
+        response = HTTParty.get(url)
+        if !response.code == 200
+          raise ReactiveShipping::ResponseError, "API Error: #{self.class.name}: HTTP #{response.code}"
+        end
+      rescue StandardError
+        raise ReactiveShipping::ResponseError, "API Error: #{self.class.name}: Unknown response:\n#{response.inspect}"
+      end
+
+      if response.body.downcase.include?('please enter a valid pro')
+        raise ReactiveShipping::ResponseError, "API Error: #{self.class.name}: Invalid tracking number"
+      end
+
+      html = Nokogiri::HTML(response.body)
+      tracking_table = html.css('.newtables2')[0]
+
+      actual_delivery_date = nil
+      receiver_address = nil
+      ship_time = nil
+      shipper_address = nil
+
+      shipment_events = []
+      tracking_table.css('tr').reverse.each do |tr|
+        next if tr.text.include?('shipment status')
+        next if tr.css('td').blank?
+
+        datetime_without_time_zone = "#{tr.css('td')[2].text} #{tr.css('td')[3].text}".squeeze
+        event = tr.css('td')[0].text
+        location = tr.css('td')[1].text
+
+        event_key = nil
+        @conf.dig(:events, :types).each do |key, val|
+          if event.downcase.include?(val) && !event.downcase.include?('estimated')
+            event_key = key
+            break
+          end
+        end
+        next if event_key.blank?
+
+        location = (parse_city_state(location.squeeze) if !location.blank? && location.downcase.include?(','))
+
+        event = event_key
+        datetime_without_time_zone = parse_date(datetime_without_time_zone)
+
+        case event_key
+        when :delivered
+          actual_delivery_date = datetime_without_time_zone
+          receiver_address = location
+        when :picked_up
+          shipper_address = location
+          ship_time = datetime_without_time_zone
+        end
+
+        # status and type_code set automatically by ActiveFreight based on event
+        shipment_events << ShipmentEvent.new(event, datetime_without_time_zone, location)
+      end
+
+      scheduled_delivery_date = nil
+      status = shipment_events.last.status
+
+      shipment_events = shipment_events.sort_by(&:time)
+
+      TrackingResponse.new(
+        true,
+        status,
+        { html: html.to_s },
+        carrier: "#{self.class.scac}, #{self.class.name}",
+        html: html,
+        response: html.to_s,
+        status: status,
+        type_code: status,
+        ship_time: ship_time,
+        scheduled_delivery_date: scheduled_delivery_date,
+        actual_delivery_date: actual_delivery_date,
+        delivery_signature: nil,
+        shipment_events: shipment_events,
+        shipper_address: shipper_address,
+        origin: shipper_address,
+        destination: receiver_address,
+        tracking_number: tracking_number,
+        request: last_request
+      )
+    end
+
+    # Rates
+    def build_rate_params(origin, destination, packages, options = {})
+      options = @options.merge(options)
+      params = ''.dup
+      params << "xmlv=yes&xmluser=#{@options[:username]}"
+      params << "&xmlpass=#{@options[:password]}"
+      params << "&vozip=#{origin.to_hash[:postal_code]}"
+      params << "&vdzip=#{destination.to_hash[:postal_code]}"
+
+      i = 0
+      packages.each do |package|
+        i += 1 # API starts at 1 (not 0)
+        params << "&wpieces[#{i}]=1"
+        params << "&wpallets[#{i}]=1"
+        params << "&vclass[#{i}]=#{package.freight_class}"
+        params << "&wweight[#{i}]=#{package.pounds.ceil}"
+      end
+
+      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
+
+      calculated_accessorials = build_calculated_accessorials(packages, origin, destination)
+      accessorials = accessorials + calculated_accessorials unless calculated_accessorials.blank?
+
+      accessorials.uniq!
+      params << accessorials.join unless accessorials.blank?
+
+      save_request({ params: params })
+      params
+    end
+
+    def parse_rate_response(origin, destination, _packages, response)
+      success = true
+      message = ''
+
+      if !response
+        success = false
+        message = 'API Error: Unknown response'
+      else
+        if response['error']
+          success = false
+          message = response['error']
+        else
+          cost = response.dig('ratequote', 'quotetotal').delete(',').delete('.').to_i
+          transit_days = response.dig('ratequote', 'busdays').to_i
+          if cost
+            rate_estimates = [
+              RateEstimate.new(
+                origin,
+                destination,
+                { scac: self.class.scac.upcase, name: self.class.name },
+                :standard,
+                transit_days: transit_days,
+                estimate_reference: nil,
+                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
+  end
+end

data/lib/reactive_freight/platforms/liftoff.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module ReactiveShipping
+  class Liftoff < ReactiveShipping::Platform
+    REACTIVE_FREIGHT_CARRIER = true
+
+    JSON_HEADERS = {
+      'Accept': 'application/json',
+      'Content-Type': 'application/json',
+      'charset': 'utf-8'
+    }.freeze
+
+    def requirements
+      %i[email password scope]
+    end
+
+    # Documents
+
+    # Rates
+
+    def show(id)
+      request = build_request(:show, params: "/#{id}")
+      commit(request)
+    end
+
+    # Tracking
+
+    # protected
+
+    def build_url(action, options = {})
+      options = @options.merge(options)
+      url = ''.dup
+      url += "#{base_url}#{@conf.dig(:api, :scopes, options[:scope])}#{@conf.dig(:api, :endpoints, action)}"
+      url = url.sub(@conf.dig(:api, :scopes, options[:scope]), '') if action == :authenticate
+      url += options[:params] unless options[:params].blank?
+      url
+    end
+
+    def build_request(action, options = {})
+      options = @options.merge(options)
+      headers = JSON_HEADERS
+      headers = headers.merge(options[:headers]) unless options[:headers].blank?
+      body = options[:body].to_json unless options[:body].blank?
+
+      unless action == :authenticate
+        set_auth_token
+        headers = headers.merge(token)
+      end
+
+      request = {
+        url: build_url(action, options),
+        headers: headers,
+        method: @conf.dig(:api, :methods, action),
+        body: body
+      }
+
+      save_request(request)
+      request
+    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 base_url
+      "https://#{@conf.dig(:api, :domain)}#{@conf.dig(:api, :prefix)}#{@conf.dig(:api, :scope, @options[:scope])}"
+    end
+
+    def set_auth_token
+      return @auth_token unless @auth_token.blank?
+
+      request = build_request(
+        :authenticate,
+        body: {
+          email: @options[:email],
+          password: @options[:password]
+        }
+      )
+
+      response = commit(request)
+      @auth_token = response.dig('auth_token')
+    end
+
+    def token
+      { 'Authorization': "Bearer #{@auth_token}" }
+    end
+
+    # Show
+  end
+end

data/lib/reactive_freight/rate_estimate.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module ReactiveShipping
+  class RateEstimate
+    attr_accessor :carrier, :charge_items, :compare_price, :currency,
+                  :delivery_category, :delivery_date, :delivery_range,
+                  :description, :destination, :estimate_reference, :expires_at,
+                  :insurance_price, :messages, :negotiated_rate, :origin,
+                  :package_rates, :phone_required, :pickup_time, :service_code,
+                  :service_name, :shipment_options, :shipping_date, :transit_days,
+                  :with_excessive_length_fees
+
+    def initialize(origin, destination, carrier, service_name, options = {})
+      self.charge_items = options[:charge_items] || []
+      self.compare_price = options[:compare_price]
+      self.currency = options[:currency]
+      self.delivery_category = options[:delivery_category]
+      self.delivery_range = options[:delivery_range]
+      self.description = options[:description]
+      self.estimate_reference = options[:estimate_reference]
+      self.expires_at = options[:expires_at]
+      self.insurance_price = options[:insurance_price]
+      self.messages = options[:messages] || []
+      self.negotiated_rate = options[:negotiated_rate]
+      self.origin = origin
+      self.destination = destination
+      self.carrier = carrier
+      self.service_name = service_name
+      self.package_rates = if options[:package_rates]
+                             options[:package_rates].map { |p| p.update(rate: Package.cents_from(p[:rate])) }
+                           else
+                             Array(options[:packages]).map { |p| { package: p } }
+                           end
+      self.phone_required = options[:phone_required]
+      self.pickup_time = options[:pickup_time]
+      self.service_code = options[:service_code]
+      self.shipment_options = options[:shipment_options] || []
+      self.shipping_date = options[:shipping_date]
+      self.transit_days = options[:transit_days]
+      self.total_price = options[:total_price]
+      self.with_excessive_length_fees = options.dig(:with_excessive_length_fees)
+
+      self.delivery_date = @delivery_range.last
+    end
+
+    def total_price
+      @total_price || @package_rates.sum { |pr| pr[:rate] }
+    rescue NoMethodError
+      raise ArgumentError, 'RateEstimate must have a total_price set, or have a full set of valid package rates.'
+    end
+    alias price total_price
+
+    def add(package, rate = nil)
+      cents = Package.cents_from(rate)
+      if cents.nil? && total_price.nil?
+        raise ArgumentError, 'New packages must have valid rate information since this RateEstimate has no total_price set.'
+      end
+
+      @package_rates << { package: package, rate: cents }
+      self
+    end
+
+    def packages
+      package_rates.map { |p| p[:package] }
+    end
+
+    def package_count
+      package_rates.length
+    end
+
+    protected
+
+    def delivery_range=(delivery_range)
+      @delivery_range = delivery_range ? delivery_range.map { |date| date_for(date) }.compact : []
+    end
+
+    def total_price=(total_price)
+      @total_price = Package.cents_from(total_price)
+    end
+
+    def negotiated_rate=(negotiated_rate)
+      @negotiated_rate = negotiated_rate ? Package.cents_from(negotiated_rate) : nil
+    end
+
+    def compare_price=(compare_price)
+      @compare_price = compare_price ? Package.cents_from(compare_price) : nil
+    end
+
+    def currency=(currency)
+      @currency = ActiveUtils::CurrencyCode.standardize(currency)
+    end
+
+    def phone_required=(phone_required)
+      @phone_required = !!phone_required
+    end
+
+    def shipping_date=(shipping_date)
+      @shipping_date = date_for(shipping_date)
+    end
+
+    def insurance_price=(insurance_price)
+      @insurance_price = Package.cents_from(insurance_price)
+    end
+
+    private
+
+    def date_for(date)
+      date && Date.strptime(date.to_s, '%Y-%m-%d')
+    rescue ArgumentError
+      nil
+    end
+  end
+end