freight_kit 0.1.15 → 0.1.16

data/lib/freight_kit/carriers/ccyq.rb

@@ -0,0 +1,317 @@
+# frozen_string_literal: true
+
+module FreightKit
+  class CCYQ < 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_key api_proxy]
+      end
+
+      def requirements
+        %i[credentials]
+      end
+    end
+
+    REACTIVE_FREIGHT_CARRIER = true
+
+    class << self
+      attr_reader :name, :scac
+    end
+    @name = 'CrossCountry Freight Solutions'
+    @scac = 'CCYQ'
+
+    JSON_HEADERS = {
+                     Accept: 'application/json',
+                     charset: 'utf-8',
+                     'Content-Type' => 'application/json'
+                   }.freeze
+
+    include FreightKit::Rateable
+    include FreightKit::Trackable
+    include FreightKit::Documentable
+    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: {})
+      api_key = fetch_credential(:api_key).api_key
+      proxy_url = fetch_credential(:api_proxy).proxy_url
+
+      request = {
+                  url: build_url(action),
+                  headers: { APIKEY: api_key },
+                  method: @conf.dig(:api, :methods, action),
+                  body:,
+                  query:,
+                  proxy_url:
+                }.compact
+
+      save_request(request)
+      request
+    end
+
+    def commit(_action, request)
+      proxy_uri = URI.parse(request[:proxy_url])
+
+      response = HTTParty.send(
+        request[:method],
+        request[:url],
+        headers: request[:headers].merge(JSON_HEADERS),
+        body: request[:body],
+        query: request[:query],
+        http_proxyaddr: proxy_uri.host,
+        http_proxyport: proxy_uri.port.to_s,
+        http_proxyuser: proxy_uri.user,
+        http_proxypass: proxy_uri.password,
+        debug_output: $stdout,
+      )
+
+      unless response.code == 200
+        message = begin
+          JSON.parse(response.body)['Message'] || "HTTP #{response.code}"
+        rescue JSON::ParserError
+          "HTTP #{response.code}"
+        end
+
+        if message == 'API key is inactive'
+          raise FreightKit::InvalidCredentialsError, message
+        end
+
+        raise FreightKit::ResponseError, message
+      end
+
+      JSON.parse(response.body)
+    end
+
+    # Documents
+
+    def parse_document_response(type, tracking_number)
+      # Tracking Endpoint returns Images for the Shipment
+      request = build_request(:track, query: { ReferenceNum: tracking_number })
+      response = commit(type, request)
+
+      document_response = DocumentResponse.new
+
+      unless response
+        document_response.error = DocumentNotFoundError.new
+        return document_response
+      end
+
+      # API response sometimes returns an array
+      response = response.first if response.is_a?(Array)
+
+      unless response
+        document_response.error = DocumentNotFoundError.new
+        return document_response
+      end
+
+      document = response['Images']&.find { |image| image['DocumentType'] == type.upcase }
+
+      unless document
+        document_response.error = DocumentNotFoundError.new
+        return document_response
+      end
+
+      decoded_pdf_data = Base64.decode64(document['Content'])
+      document_response.assign_attributes(content_type: 'application/pdf', data: decoded_pdf_data)
+
+      document_response
+    end
+
+    # Tracking
+
+    def build_tracking_request(tracking_number)
+      build_request(:track, query: { ReferenceNum: tracking_number })
+    end
+
+    def parse_tracking_response(response)
+      TrackingResponse.new(carrier: self, request: last_request, response:)
+
+      # TODO
+    end
+
+    # Pickups
+
+    def build_pickup_request(
+      delivery_from:,
+      delivery_to:,
+      dispatcher:,
+      pickup_from:,
+      pickup_to:,
+      scac:,
+      service:,
+      shipment:
+    )
+
+      dispatcher_phone = dispatcher.phone.delete('^0-9')
+      receiver_phone = shipment.destination.contact.phone.delete('^0-9')
+
+      build_request(
+        :pickup,
+        body: {
+                PickupAddress: {
+                                 Name: shipment.origin.contact.company_name || shipment.destination.origin.name,
+                                 Address1: shipment.origin.address1,
+                                 Address2: '',
+                                 City: shipment.origin.city,
+                                 State: shipment.origin.province,
+                                 Zip: shipment.origin.postal_code.to_s,
+                                 Phone: dispatcher_phone.presence || '',
+                                 Contact: shipment.origin.contact.name,
+                                 Country: shipment.origin.country.code(:alpha2).value
+                               },
+                DeliveryAddress: {
+                                   Name: shipment.destination.contact.company_name || shipment.destination.contact.name,
+                                   Address1: shipment.destination.address1,
+                                   Address2: '',
+                                   City: shipment.destination.city,
+                                   State: shipment.destination.province,
+                                   Zip: shipment.destination.postal_code.to_s,
+                                   Phone: receiver_phone || '',
+                                   Contact: shipment.destination.contact.name,
+                                   Country: shipment.destination.country.code(:alpha2).value
+                                 },
+                PickupSchedule: {
+                                  After: pickup_from.iso8601,
+                                  Before: pickup_to.iso8601,
+                                  AppointmentRequired: false,
+                                  AppointmentMade: false
+                                },
+                TotalWeight: shipment.packages.sum { |p| p.pounds(:total).ceil },
+                TotalUnits: shipment.packages.sum(&:quantity),
+                TotalBills: 1,
+                # TODO: Update with actual value: TotalBills desc =>
+                # Total number of freight bills that will be picked up
+                TestFlag: false
+              }.to_json,
+      )
+    end
+
+    def parse_pickup_response(response)
+      pickup_response = PickupResponse.new(request: last_request, response:)
+      pickup_number = response['FreightBillNum']
+
+      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
+
+    # Rates
+
+    def build_accessorials(shipment:)
+      accessorials = []
+      serviceable_accessorials?(shipment.accessorials)
+
+      accessorials << { Code: 'HAZMAT', Factor: 1 } if shipment.hazmat?
+
+      shipment.packages.each do |package|
+        longest_dimension = [package.width(:inches), package.length(:inches)].max.ceil
+
+        next if longest_dimension < 96
+
+        package.quantity.times do
+          accessorials << { Code: 'EXLEN', Factor: longest_dimension }
+        end
+      end
+
+      shipment.accessorials.map do |accessorial|
+        next if @conf.dig(:accessorials, :unquotable)&.include?(accessorial)
+
+        accessorials << { Code: @conf.dig(:accessorials, :mappable, accessorial.to_sym), Factor: 1 }
+      end
+
+      accessorials
+    end
+
+    def build_rate_request(shipment:)
+      build_request(
+        :rates,
+        body: {
+                Orig: shipment.origin.postal_code,
+                Dest: shipment.destination.postal_code,
+                Accessorials: build_accessorials(shipment:),
+                Details: shipment.packages.map do |package|
+                           {
+                             Height: package.inches(:height).ceil.to_f,
+                             Length: package.inches(:length).ceil.to_f,
+                             Width: package.inches(:width).ceil.to_f,
+                             Units: package.quantity.to_i,
+                             Class: package.freight_class.to_f,
+                             Weight: package.pounds(:total).ceil.to_f
+                           }
+                         end
+              }.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('API Error: Unknown response')
+        return rate_response
+      end
+
+      if response['Message'].include?('Quotes between these points are not available')
+        rate_response.error = UnserviceableError.new(response['Message'])
+        return rate_response
+      end
+
+      if response['TotalCharge'].blank?
+        rate_response.error = ResponseError.new('Cost is blank')
+        return rate_response
+      end
+
+      estimate_reference = response['QuoteNum']
+      expires_at = ::Time.iso8601(response['QuoteExpiryDate'])
+
+      transit_days = (
+        ::Time.iso8601(response['EarliestDeliveryDate']).to_date -
+        ::Time.iso8601(response['PickupDate']).to_date
+      ).to_i
+
+      prices = []
+
+      ['AccessorialCharge', 'FuelCharge', 'HighCostCharge', 'MinCharge'].each do |charge_line_key|
+        charge_line = response[charge_line_key]
+        next unless charge_line
+
+        cents = (charge_line.to_f * 100).to_i
+        prices << Price.new(blame: :api, cents:, description: charge_line_key)
+      end
+
+      rate = Rate.new(
+        carrier: self,
+        carrier_name: self.class.name,
+        currency: 'USD',
+        estimate_reference:,
+        expires_at:,
+        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
+  end
+end

data/lib/freight_kit/carriers/clni.rb

@@ -0,0 +1,396 @@
+# frozen_string_literal: true
+
+module FreightKit
+  class CLNI < FreightKit::Carrier
+    class << self
+      # @note Explicitly set to `false` because though API allows this, it "doesn't quote correctly" per customer
+      # service
+      def find_rates_with_declared_value?
+        false
+      end
+
+      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 website]
+      end
+
+      def requirements
+        %i[credentials]
+      end
+    end
+
+    REACTIVE_FREIGHT_CARRIER = true
+
+    include FreightKit::Rateable
+
+    class << self
+      attr_reader :name, :scac
+    end
+    @name = 'Clear Lane Freight Systems'
+    @scac = 'CLNI'
+
+    # Documents
+
+    def pod(tracking_number)
+      parse_document_response(:pod, tracking_number)
+    end
+
+    def scanned_bol(tracking_number)
+      parse_document_response(:bol, tracking_number)
+    end
+
+    # Rates
+
+    def validate_packages(packages, tariff = nil)
+      raise UnserviceableError, 'Must be fewer than 10 items altogether' if packages.sum(&:quantity) > 10
+
+      super
+    end
+
+    # Tracking
+
+    protected
+
+    def commit(action, request)
+      client_args = {
+                      wsdl: build_url(:api, action),
+                      convert_request_keys_to: :none,
+                      env_namespace: :soap,
+                      element_form_default: :qualified
+                    }
+
+      call_args = { message: request_blueprint.deep_merge(request) }
+
+      ::FreightKit::SoapClient.new(
+        carrier: self,
+        action:,
+        client_args:,
+        call_args:,
+        soap_operation: @conf.dig(:api, :actions, action),
+      ).call&.to_hash&.with_indifferent_access
+    end
+
+    def request_blueprint
+      api_credentials = fetch_credential(:api)
+
+      {
+        request: {
+                   Application: 'ThirdParty',
+                   AccountNumber: api_credentials.account,
+                   UserID: api_credentials.username,
+                   Password: api_credentials.password,
+                   TestMode: 'N'
+                 }
+      }
+    end
+
+    def build_url(api_or_website, action)
+      case api_or_website
+      when :api
+        scheme = @conf.dig(:api, :use_ssl) ? 'https://' : 'http://'
+        "#{scheme}#{@conf.dig(:api, :domain)}#{@conf.dig(:api, :endpoints, action)}"
+      when :website
+        @conf.dig(:website, action)
+      end
+    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('https://ssworldtrak.com/WebtrakWTNew/')
+
+      browser.text_field(name: 'txtUserId').set(website_credentials.username)
+      browser.text_field(name: 'txtPass').set(website_credentials.password)
+      browser.button(name: 'btnSubmit').click
+
+      if browser.html.include?('Either UserID or Password are incorrect, please try again.')
+        browser.close
+
+        document_response.error = InvalidCredentialsError.new
+        return document_response
+      end
+
+      # Bypass the hover menu
+      browser.goto('https://ssworldtrak.com/WebtrakWTNew/Main/Reports/POD.aspx')
+
+      from = 90.days.ago.strftime('%m%d%Y')
+
+      browser.text_field(name: 'txtFromDate').wait_until(&:present?).focus
+
+      # Hack to get around JavaScript messing up our input
+      sleep(1)
+      from.chars.each do |char|
+        browser.text_field(name: 'txtFromDate').append(char)
+      end
+
+      browser.text_field(name: 'txtToDate').click
+      browser
+      .element(xpath: '/html/body/form/div[3]/div[4]/div[3]/div[2]/div/div/div[3]/div')
+      .wait_until(&:present?)
+      .click
+
+      browser.button(name: 'btnSubmit').click
+
+      browser.text_field(id: 'yadcf-filter--grid-2').set(tracking_number)
+      browser.send_keys(:enter)
+
+      if browser.element(id: 'tdPODName0').wait_until(&:present?).text == 'NO POD' && action == :pod
+        browser.window.close
+        browser.original_window.use
+        browser.goto('https://ssworldtrak.com/WebtrakWTNew/logoff.aspx')
+        browser.close
+
+        document_response.error = DocumentNotFoundError.new
+        return document_response
+      end
+
+      browser
+      .element(xpath: '/html/body/form/div[3]/div[4]/div[8]/div/table/tbody/tr/td[12]/a')
+      .wait_until(&:present?)
+      .click
+
+      browser.switch_window
+
+      sleep(5)
+
+      html = browser.element(id: 'DataTables_Table_0').wait_until(&:present?).html
+      html = Nokogiri::HTML(html)
+      link_id = nil
+
+      html.css('tbody tr').each do |row|
+        next unless row.css('td:nth-child(3)').text == action.to_s.upcase
+
+        link_id = row.css('td:nth-child(1) a').attr('id').value
+      end
+
+      if link_id.blank?
+        browser.window.close
+        browser.original_window.use
+        browser.goto('https://ssworldtrak.com/WebtrakWTNew/logoff.aspx')
+        browser.close
+
+        document_response.error = DocumentNotFoundError.new
+        return document_response
+      end
+
+      browser.element(css: "##{link_id}").click
+
+      sleep(50) # so Chrome can finish downloading, Selenoid default timeout is 60s
+
+      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.window.close
+      browser.original_window.use
+      browser.goto('https://ssworldtrak.com/WebtrakWTNew/logoff.aspx')
+      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_commodity_input(packages)
+      packages.map do |package|
+        {
+          CommodityInput: {
+                            CommodityClass: package.freight_class,
+                            CommodityHazmat: package.hazmat? ? 'Y' : 'N',
+                            CommodityHeight: package.height(:in).ceil,
+                            CommodityLength: package.length(:in).ceil,
+                            CommodityPieces: package.quantity,
+                            CommodityPieceType: package.packaging.pallet? ? 'pallet' : 'box',
+                            CommodityWeight: package.pounds(:total).ceil,
+                            CommodityWeightPerPiece: package.pounds(:each).ceil,
+                            CommodityWidth: package.width(:in).ceil
+                          }
+        }
+      end
+    end
+
+    def build_rate_request(shipment:)
+      accessorial_input = []
+      if shipment.accessorials.present?
+        serviceable_accessorials?(shipment.accessorials)
+        shipment.accessorials.each do |a|
+          if @conf.dig(:accessorials, :unserviceable).exclude?(a)
+            accessorial_input << { AccessorialInput: { AccessorialCode: @conf.dig(:accessorials, :mappable)[a] } }
+          end
+        end
+      end
+
+      accessorial_input.uniq!
+
+      commodity_input = build_commodity_input(shipment.packages)
+
+      palletized = shipment.packages.all? { |package| package.packaging.pallet? } ? 'Y' : 'N'
+
+      pickup_from = ::Time.current.beginning_of_day + 14.hours
+      pickup_from += 1.day if ::Time.current > pickup_from
+      pickup_to = pickup_from + 3.hours
+
+      api_credentials = fetch_credential(:api)
+
+      request = {
+                  RatingParam: {
+                                 AccessorialInput: accessorial_input,
+                                 CommodityInput: commodity_input,
+                                 RatingInput: {
+                                                DeclaredValue: 0,
+                                                DestinationCity: shipment.destination.city,
+                                                DestinationCountry: shipment.destination.country.code(:alpha2).value,
+                                                DestinationState: shipment.destination.province,
+                                                DestinationZip: shipment.destination.postal_code,
+                                                LiabilityType: '',
+                                                OriginCity: shipment.origin.city,
+                                                OriginCountry: shipment.origin.country.code(:alpha2).value,
+                                                OriginState: shipment.origin.province,
+                                                OriginZip: shipment.origin.postal_code,
+                                                Palletized: palletized,
+                                                PickupDate: pickup_from.to_date.strftime('%Y-%m-%d'),
+                                                PickupLocationCloseTime: pickup_to.strftime('%H:%M:00'),
+                                                PickupTime: pickup_from.strftime('%H:%M:00'),
+                                                RequestID: rand(0..999_999).to_s,
+                                                ServiceLevelID: '',
+                                                ShipmentTerms: '',
+                                                Stackable: false,
+                                                WebTrakUserID: api_credentials.username
+                                              }
+                               }
+                }
+
+      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('Blank response')
+        return rate_response
+      end
+
+      error = response.dig(:get_rating_response, :get_rating_result, :rating_output, :message)
+
+      if error.present?
+        if error.include?('do not service this lane')
+          rate_response.error = UnserviceableError.new(
+            'Incorrect ZIP code or no service available at origin and/or destination',
+          )
+          return rate_response
+        end
+
+        pretty_error = error.strip.gsub('can not', 'cannot')
+
+        rate_response.error = ResponseError.new(pretty_error)
+        return rate_response
+      end
+
+      result = response.dig(:get_rating_response, :get_rating_result, :rating_output)
+
+      if result.blank?
+        rate_response.error = ResponseError.new('Blank response')
+        return rate_response
+      end
+
+      cents = parse_amount(result[:standard_total_rate])
+
+      if cents.blank?
+        rate_response.error = ResponseError.new('Cost is blank')
+        return rate_response
+      end
+
+      prices = []
+      prices << Price.new(blame: :api, cents:, description: 'Freight')
+
+      accessorial_outputs = result.dig(:accessorial_output, :accessorial_output)
+
+      accessorial_outputs.each do |accessorial_output|
+        prices << Price.new(
+          blame: :api,
+          cents: 0,
+          description: accessorial_output_description(accessorial_output),
+        )
+      end
+
+      transit_days = response[:transit_days].to_i
+
+      rate = Rate.new(
+        carrier: self,
+        carrier_name: self.class.name,
+        currency: 'USD',
+        estimate_reference: nil,
+        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
+
+    def accessorial_output_description(accessorial_output)
+      return '' if accessorial_output[:accessorial_desc].blank?
+
+      description = accessorial_output[:accessorial_desc]
+      description = description.capitalize
+      description.gsub('Smc', 'SMC')
+    end
+
+    def parse_amount(amount)
+      ['$', ','].each do |char|
+        amount = amount.sub(char, '')
+      end
+
+      return 0 if amount.blank?
+
+      amount = (amount.to_f * 100).to_i
+    end
+
+    # Tracking
+  end
+end