freight_kit 0.1.15 → 0.1.16

data/lib/freight_kit/carriers/tqyl.rb

@@ -0,0 +1,339 @@
+# frozen_string_literal: true
+
+module FreightKit
+  class TQYL < FreightKit::Carrier
+    class << self
+      def minimum_length_for_overlength_fees
+        Measured::Length.new(6, :feet)
+      end
+
+      def overlength_fees_require_tariff?
+        false
+      end
+
+      def required_credential_types
+        %i[api]
+      end
+
+      def requirements
+        %i[credentials]
+      end
+    end
+
+    REACTIVE_FREIGHT_CARRIER = true
+
+    class << self
+      attr_reader :name, :scac
+    end
+    @name = 'Total Quality Logistics'
+    @scac = 'TQYL'
+
+    API_SCOPE = 'https://tqlidentity.onmicrosoft.com/services_combined/LTLQuotes.Tender'
+
+    include FreightKit::Rateable
+    include FreightKit::Trackable
+    include FreightKit::Pickupable
+
+    protected
+
+    def build_url(action)
+      "https://#{@conf.dig(:api, :domain)}#{@conf.dig(:api, :endpoints, action)}"
+    end
+
+    def build_request(action, body: {}, query: {})
+      fetch_credential(:api).api_key
+
+      request = {
+                  url: build_url(action),
+                  method: @conf.dig(:api, :methods, action),
+                  headers: {},
+                  body:,
+                  query:
+                }.compact
+
+      request[:headers] = { 'Authorization' => "Bearer #{build_access_token}" } unless action == :auth
+
+      save_request(request)
+      request
+    end
+
+    def commit(request)
+      response = HTTParty.send(
+        request[:method],
+        request[:url],
+        headers: request[:headers].merge(subscription_key_headers),
+        query: request[:query],
+        body: request[:body],
+        debug_output: $stdout,
+      )
+
+      parsed_response = JSON.parse(response.body)
+      return parsed_response if [200, 201].include?(response.code)
+
+      message = if parsed_response.is_a?(String)
+                  parsed_response
+                else
+                  parsed_response.dig('content', 'message').presence || "HTTP #{response.code}"
+                end
+
+      raise FreightKit::ResponseError, message
+    rescue JSON::ParserError => e
+      if response.body.include?('Sorry, but we&#39;re having trouble signing you in')
+        raise FreightKit::InvalidCredentialsError
+      end
+
+      raise FreightKit::ResponseError, e.message
+    end
+
+    def build_access_token
+      build_url(:auth)
+      credentials = fetch_credential(:api)
+
+      request_body = {
+                       username: credentials.username,
+                       password: credentials.password,
+                       grant_type: 'password',
+                       scope: API_SCOPE,
+                       client_id: credentials.api_key
+                     }
+
+      request = build_request(:auth, query: request_body)
+      response = commit(request)
+
+      response['access_token']
+    end
+
+    def subscription_key_headers
+      {
+        'Ocp-Apim-Subscription-Key' => fetch_credential(:api).account,
+        'Content-Type' => 'application/json'
+      }
+    end
+
+    # Tracking
+
+    def build_tracking_request(tracking_number)
+      request = {
+                  url: build_url(:track).gsub('%TRACKING_NUMBER%', tracking_number.to_s),
+                  method: @conf.dig(:api, :methods, :track),
+                  headers: { 'Authorization' => "Bearer #{build_access_token}" }
+                }.compact
+
+      save_request(request)
+      request
+    end
+
+    def parse_tracking_response(response)
+      tracking_response = TrackingResponse.new(carrier: self, request: last_request, response:)
+
+      actual_delivery_date = nil
+      estimated_delivery_date = nil
+      scheduled_delivery_date = nil
+      ship_time = nil
+
+      pickup_city, pickup_state = response['firstPick'].split(', ')
+      drop_city, drop_state = response['lastDrop'].split(', ')
+      country = ActiveUtils::Country.find('US') # Fallback To US. Country not provided in response
+      receiver_location = Location.new(city: pickup_city, province: pickup_state, country:)
+      shipper_location = Location.new(city: drop_city, province: drop_state, country:)
+
+      tracking_number = response['poNumber']
+      status = response['status']
+
+      shipment_events = []
+
+      response['trackingDetails'].each do |api_event|
+        event = @conf.dig(:events, :types).key(api_event['status'])
+
+        case event
+        when :picked_up
+          ship_time = api_event['time']
+        when :delivered
+          actual_delivery_date = api_event['time'].to_date
+        end
+
+        shipment_events << ShipmentEvent.new(
+          date_time: api_event['time'],
+          location: Location.new(city: api_event['city'], province: api_event['state'], country:),
+          type_code: event,
+        )
+      end
+
+      tracking_response.assign_attributes(
+        actual_delivery_date:,
+        destination: receiver_location,
+        estimated_delivery_date:,
+        origin: shipper_location,
+        scheduled_delivery_date:,
+        ship_time:,
+        shipment_events:,
+        status:,
+        tracking_number:,
+      )
+    end
+
+    # Pickup
+
+    def build_pickup_request(
+      delivery_from:,
+      delivery_to:,
+      dispatcher:,
+      pickup_from:,
+      pickup_to:,
+      scac:,
+      service:,
+      shipment:
+    )
+
+      origin = shipment.origin
+      destination = shipment.destination
+      shipper_phone = shipment.origin.contact.phone.delete('^0-9')
+      receiver_phone = shipment.destination.contact.phone.delete('^0-9')
+
+      build_request(
+        :pickup,
+        body: {
+                scac:,
+                serviceLevel: service.to_s.capitalize,
+                shipmentDate: pickup_from.iso8601,
+                commodities: build_commodities(shipment),
+                accessorials: build_accessorials(shipment:),
+                pickupDetails: {
+                                 address1: origin.address1,
+                                 postalCode: origin.postal_code.to_i,
+                                 city: origin.city,
+                                 state: origin.province.upcase,
+                                 country: origin.country.code(:alpha3).value,
+                                 contactName: origin.contact.name || 'Shipping',
+                                 contactPhone: shipper_phone || '',
+                                 stopName: origin.contact.name || 'Shipping',
+                                 hoursOpen: pickup_from.strftime('%I:%M %p'),
+                                 hoursClosed: pickup_to.strftime('%I:%M %p')
+                               },
+                deliveryDetails: {
+                                   address1: destination.address1,
+                                   postalCode: destination.postal_code.to_i,
+                                   city: destination.city,
+                                   state: destination.province.upcase,
+                                   country: destination.country.code(:alpha3).value,
+                                   contactName: destination.contact.name || 'Receiving',
+                                   contactPhone: receiver_phone || '',
+                                   stopName: destination.contact.name || 'Receiving',
+                                   hoursOpen: delivery_from.strftime('%I:%M %p'),
+                                   hoursClosed: delivery_to.strftime('%I:%M %p')
+                                 }
+              },
+      )
+    end
+
+    def parse_pickup_response(response)
+      pickup_response = PickupResponse.new(request: last_request, response:)
+      pickup_number = response.dig('content', 'poNumber')
+
+      if pickup_number.blank?
+        pickup_response.error = FreightKit::ResponseError.new('Unknown response')
+        return pickup_response
+      end
+
+      pickup_response.pickup_number = pickup_number
+      pickup_response
+    end
+
+    def build_commodities(shipment)
+      shipment.packages.map do |package|
+        unit_type = package.packaging.type.to_s
+        {
+          freightClassCode: package.freight_class,
+          unitTypeCode: package.packaging.pallet? ? 'PLT' : unit_type.upcase,
+          description: package.description,
+          quantity: package.quantity.to_i,
+          weight: package.pounds(:total).ceil.to_i,
+          dimensionHeight: package.inches(:height).ceil.to_i,
+          dimensionLength: package.inches(:length).ceil.to_i,
+          dimensionWidth: package.inches(:width).ceil.to_i,
+          isHazmat: package.hazmat?
+        }
+      end
+    end
+
+    # Rates
+
+    def build_accessorials(shipment:)
+      accessorials = []
+      serviceable_accessorials?(shipment.accessorials)
+
+      shipment.accessorials.map do |accessorial|
+        next unless @conf.dig(:accessorials, :mappable)&.include?(accessorial)
+
+        accessorials << @conf.dig(:accessorials, :mappable, accessorial.to_sym)
+      end
+
+      accessorials
+    end
+
+    def build_rate_request(shipment:)
+      origin = shipment.origin
+      destination = shipment.destination
+
+      build_request(
+        :rates,
+        body: {
+                accessorials: build_accessorials(shipment:),
+                pickLocationType: origin.type || 'Commercial',
+                origin: {
+                          postalCode: origin.postal_code.to_i,
+                          city: origin.city,
+                          state: origin.province.upcase,
+                          country: origin.country.code(:alpha3).value
+                        },
+                dropLocationType: destination.type || 'Commercial',
+                destination: {
+                               postalCode: destination.postal_code.to_i,
+                               city: destination.city,
+                               state: destination.province.upcase,
+                               country: destination.country.code(:alpha3).value
+                             },
+                shipmentDate: shipment.pickup_at.date_time_with_zone.iso8601,
+                quoteCommodities: build_commodities(shipment)
+              }.to_json,
+      )
+    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
+
+      if response['statusCode'] != 201
+        rate_response.error = ResponseError.new(response.dig('content', 'message'))
+        return rate_response
+      end
+
+      rates = []
+
+      response.dig('content', 'carrierPrices').each do |response_line|
+        rate_in_cents = (response_line['customerRate'].to_f * 100).round
+        rates << Rate.new(
+          carrier_name: response_line['carrier'],
+          carrier: self,
+          currency: 'USD',
+          estimate_reference: response_line['id'],
+          prices: [
+                    Price.new(blame: :api, cents: rate_in_cents, description: response_line['CarrierName']),
+                  ],
+          scac: response_line['scac'],
+          service_name: :standard,
+          shipment:,
+          transit_days: response_line['transitDays'],
+          with_excessive_length_fees: @conf.dig(:attributes, :rates, :with_excessive_length_fees),
+        )
+      end
+
+      rate_response.rates = rates
+      rate_response
+    end
+  end
+end

data/lib/freight_kit/carriers/wrds.rb

@@ -0,0 +1,246 @@
+# frozen_string_literal: true
+
+module FreightKit
+  class WRDS < FreightKit::Carrier
+    class << self
+      def required_credential_types
+        %i[selenoid website]
+      end
+
+      def requirements
+        %i[credentials]
+      end
+    end
+
+    REACTIVE_FREIGHT_CARRIER = true
+
+    class << self
+      attr_reader :name, :scac
+    end
+    @name = 'Western Regional Delivery Service'
+    @scac = 'WRDS'
+
+    # Documents
+    def pod(tracking_number)
+      parse_pod_response(tracking_number)
+    end
+
+    # Rates
+
+    # Tracking
+    def find_tracking_info(tracking_number)
+      parse_tracking_response(tracking_number)
+    end
+
+    protected
+
+    def build_url(action, *)
+      "#{@conf.dig(:api, :domain)}#{@conf.dig(:api, :endpoints, action)}"
+    end
+
+    def commit(action, options = {})
+      url = request_url(action)
+
+      response = if @conf.dig(:api, :methods, action) == :post
+                   options[:params].blank? ? HTTParty.post(url) : HTTParty.post(url, query: options[:params])
+                 else
+                   HTTParty.get(url)
+                 end
+
+      response.parsed_response if response&.parsed_response
+    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(url)
+      document_response = DocumentResponse.new(request: URI.parse(url))
+
+      begin
+        response = HTTParty.get(url)
+      rescue StandardError => e
+        document_response.error = e
+        return document_response
+      end
+
+      document_response.assign_attributes(content_type: response.headers['content-type'], data: response.body)
+      document_response
+    end
+
+    def parse_pod_response(tracking_number)
+      selenoid_credentials = fetch_credential(:selenoid)
+      website_credentials = fetch_credential(:website)
+
+      browser = Watir::Browser.new(*selenoid_credentials.watir_args)
+      browser.goto(build_url(:pod))
+
+      browser.text_field(name: 'ctl00$cphMain$txtUserName').set(website_credentials.username)
+      browser.text_field(name: 'ctl00$cphMain$txtPassword').set(website_credentials.password)
+      browser.button(name: 'ctl00$cphMain$btnLogIn').click
+
+      if browser.html.include?('Username or password is invalid.')
+        browser.close
+        raise InvalidCredentialsError
+      end
+
+      browser.text_field(name: 'ctl00$cphMain$txtProNumber').set(tracking_number)
+      browser.button(name: 'ctl00$cphMain$btnSearchProNumber').wait_until(&:present?).click
+      browser.element(xpath: '/html/body/form/div[3]/div/div/table/tbody/tr[2]/td[1]/a').wait_until(&:present?).click
+      browser.element(xpath: '/html/body/form/div[3]/table[2]/tbody/tr[16]/td[2]/a').wait_until(&:present?).click
+
+      image_url = nil
+      browser.switch_window.use do
+        page_count = browser.element(xpath: '/html/body/form/div[3]/b/span').text.strip.to_i
+        (page_count - 1).times do
+          browser.element(xpath: '/html/body/form/div[3]/input[2]').wait_until(&:present?).click
+        end
+        image_url = browser.element(css: '#cphMain_imgImage').attribute_value('src')
+      end
+      browser.close
+
+      parse_document_response(image_url)
+    end
+
+    # Rates
+
+    # Tracking
+
+    def parse_api_city_state_zip(str)
+      return if str.blank?
+
+      Location.new(
+        city: str.split(', ')[0].titleize,
+        province: str.split(', ')[1].split[0].upcase,
+        postal_code: str.split(', ')[1].split[1],
+        country: ActiveUtils::Country.find('USA'),
+      )
+    end
+
+    def parse_api_city_state(str)
+      return if str.blank?
+
+      Location.new(
+        city: str[..-3].strip.titleize,
+        province: str[-2..].upcase,
+        country: ActiveUtils::Country.find('USA'),
+      )
+    end
+
+    def parse_api_date(date, location)
+      return if date.blank?
+
+      local_date = ::Date.strptime(date, '%m/%d/%Y')
+      ::FreightKit::DateTime.new(local_date:, location:)
+    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_tracking_response(tracking_number)
+      tracking_response = TrackingResponse.new(carrier: self)
+
+      selenoid_credentials = fetch_credential(:selenoid)
+
+      browser = Watir::Browser.new(*selenoid_credentials.watir_args)
+      browser.goto(build_url(:track))
+
+      browser.text_field(name: 'ctl00$cphMain$txtProNumber').set(tracking_number)
+      browser.button(name: 'ctl00$cphMain$btnSearchProNumber').wait_until(&:present?).click
+      browser.element(xpath: '/html/body/form/div[3]/div/div/table/tbody/tr[2]/td[1]/a').wait_until(&:present?).click
+
+      tracking_response.response = browser.html
+
+      html = browser.table(id: 'cphMain_grvLogNotes').inner_html
+      html = Nokogiri::HTML(html)
+
+      api_city_state_zip = browser.element(xpath: '/html/body/form/div[3]/table[2]/tbody/tr[14]/td[1]/span').text
+      shipper_location = parse_api_city_state_zip(api_city_state_zip)
+
+      api_city_state_zip = browser.element(xpath: '/html/body/form/div[3]/table[2]/tbody/tr[14]/td[2]/span').text
+      receiver_location = parse_api_city_state_zip(api_city_state_zip)
+
+      actual_delivery_date = nil
+      delivery_appointment_scheduled = false
+      scheduled_delivery_date = nil
+      ship_time = nil
+
+      shipment_events = []
+
+      html.css('tr').each do |tr|
+        next if tr.text.include?('DateNotes')
+
+        event = 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 = nil
+
+        unless event_key == :delivery_appointment_scheduled
+          api_city_state = event.downcase.split(@conf.dig(:events, :types, event_key)).last
+          api_city_state = api_city_state.downcase.sub(event_key.to_s, '')
+          api_city_state = api_city_state.gsub(',', '')
+
+          location = api_city_state.downcase.include?('carrier') ? nil : parse_api_city_state(api_city_state)
+        end
+
+        api_date_time = tr.css('td')[0].text
+        date_time = parse_api_date_time(api_date_time, location)
+
+        actual_delivery_date = date_time if event_key == :delivered
+        delivery_appointment_scheduled = true if event_key == :delivery_appointment_scheduled
+
+        # API doesn't provide pickup information
+        ship_time = date_time if event_key == :arrived_at_terminal && ship_time.blank?
+
+        shipment_event = ShipmentEvent.new(date_time:, location:, type_code: event_key)
+        shipment_events << shipment_event
+      end
+
+      # API doesn't provide appointment information on :delivery_appointment_scheduled
+      if delivery_appointment_scheduled
+        html.css('tr').each do |tr|
+          next if tr.text.include?('DateNotes')
+          next if tr.css('td')[1].text.exclude?('Estimated Delivery Date')
+
+          api_date = tr.css('td')[0].text.split&.first
+          scheduled_delivery_date = parse_api_date(api_date, shipment_events.last.location)
+
+          break
+        end
+      end
+
+      browser.close
+
+      # API events sometimes appear after delivered
+      status = actual_delivery_date.blank? ? shipment_events.last&.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
+  end
+end

data/lib/freight_kit/carriers.rb

@@ -22,3 +22,29 @@ module FreightKit
     end
   end
 end
+
+FreightKit::Carriers.register(:ABFS, 'freight_kit/carriers/abfs')
+FreightKit::Carriers.register(:BTVP, 'freight_kit/carriers/btvp')
+FreightKit::Carriers.register(:CCYQ, 'freight_kit/carriers/ccyq')
+FreightKit::Carriers.register(:CLNI, 'freight_kit/carriers/clni')
+FreightKit::Carriers.register(:CNWY, 'freight_kit/carriers/cnwy')
+FreightKit::Carriers.register(:DLDS, 'freight_kit/carriers/dlds')
+FreightKit::Carriers.register(:DPHE, 'freight_kit/carriers/dphe')
+FreightKit::Carriers.register(:DRRQ, 'freight_kit/carriers/drrq')
+FreightKit::Carriers.register(:FWDA, 'freight_kit/carriers/fwda')
+FreightKit::Carriers.register(:MTVL, 'freight_kit/carriers/mtvl')
+FreightKit::Carriers.register(:NUMK, 'freight_kit/carriers/numk')
+FreightKit::Carriers.register(:OTCL, 'freight_kit/carriers/otcl')
+FreightKit::Carriers.register(:PENS, 'freight_kit/carriers/pens')
+FreightKit::Carriers.register(:RDFS, 'freight_kit/carriers/rdfs')
+FreightKit::Carriers.register(:SAIA, 'freight_kit/carriers/saia')
+FreightKit::Carriers.register(:SEFL, 'freight_kit/carriers/sefl')
+FreightKit::Carriers.register(:TQYL, 'freight_kit/carriers/tqyl')
+FreightKit::Carriers.register(:WRDS, 'freight_kit/carriers/wrds')
+
+# Based on Platform
+FreightKit::Carriers.register(:CTBV, 'freight_kit/carriers/ctbv')
+FreightKit::Carriers.register(:DCHA, 'freight_kit/carriers/dcha')
+FreightKit::Carriers.register(:JFJTransportation, 'freight_kit/carriers/jfj_transportation')
+FreightKit::Carriers.register(:FCSY, 'freight_kit/carriers/fcsy')
+FreightKit::Carriers.register(:TOTL, 'freight_kit/carriers/totl')

data/lib/freight_kit/helpers/documentable.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module FreightKit
+  module Documentable
+    def pod(tracking_number)
+      parse_document_response(:pod, tracking_number)
+    end
+
+    def scanned_bol(tracking_number)
+      parse_document_response(:bol, tracking_number)
+    end
+  end
+end

data/lib/freight_kit/helpers/pickupable.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module FreightKit
+  module Pickupable
+    def create_pickup(
+      delivery_from:,
+      delivery_to:,
+      dispatcher:,
+      pickup_from:,
+      pickup_to:,
+      scac:,
+      service:,
+      shipment:
+    )
+      request = build_pickup_request(
+        delivery_from:,
+        delivery_to:,
+        dispatcher:,
+        pickup_from:,
+        pickup_to:,
+        scac:,
+        service:,
+        shipment:,
+      )
+
+      begin
+        # For SOAP APIs, the :action parameter is required
+        response = commit(:pickup, request) if method(:commit).parameters.count == 2
+        response ||= commit(request)
+      rescue FreightKit::Error => error
+        response = PickupResponse.new(request:, response: nil, error:)
+      end
+
+      return response if response.is_a?(PickupResponse)
+
+      parse_pickup_response(response)
+    end
+  end
+end

data/lib/freight_kit/helpers/rateable.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module FreightKit
+  module Rateable
+    def find_rates(shipment:)
+      begin
+        validate_packages(shipment.packages, @tariff)
+      rescue UnserviceableError => e
+        return RateResponse.new(error: e)
+      end
+
+      request = build_rate_request(shipment:)
+
+      # For SOAP APIs, the :action parameter is required
+      response = commit(:rates, request) if method(:commit).parameters.count == 2
+      response ||= commit(request)
+
+      return response if response.is_a?(RateResponse)
+
+      parse_rate_response(shipment:, response:)
+    rescue FreightKit::InvalidCredentialsError => e
+      rate_response = RateResponse.new(request:, response:)
+      rate_response.error = e
+
+      rate_response
+    end
+  end
+end