freight_kit 0.1.20 → 0.1.21

data/lib/freight_kit/carriers/ccyq.rb

@@ -1,310 +0,0 @@
-# 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)
-      response = HTTPClient.request(
-        request[:method],
-        request[:url],
-        headers: request[:headers].merge(JSON_HEADERS),
-        body: request[:body],
-        query: request[:query],
-        proxy: request[:proxy_url],
-      )
-
-      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

@@ -1,396 +0,0 @@
-# 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 = HTTPClient.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 = HTTPClient.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