freight_kit 0.1.20 → 0.1.21

data/lib/freight_kit/carriers/tqyl.rb

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

@@ -1,246 +0,0 @@
-# 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? ? HTTPClient.post(url) : HTTPClient.post(url, query: options[:params])
-                 else
-                   HTTPClient.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 = HTTPClient.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/platforms/next.rb

@@ -1,101 +0,0 @@
-# frozen_string_literal: true
-
-module FreightKit
-  class Next < Platform
-    class << self
-      def required_credential_types
-        %i[api]
-      end
-    end
-
-    REACTIVE_FREIGHT_PLATFORM = true
-
-    JSON_HEADERS = {
-                     Accept: 'application/json',
-                     'Content-Type': 'application/json',
-                     charset: 'utf-8'
-                   }.freeze
-
-    # Documents
-
-    # Rates
-
-    def show(id)
-      request = build_request(:show, params: "/#{id}")
-      commit(request)
-    end
-
-    # Tracking
-
-    # protected
-
-    def build_url(action, 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] if options[:params].present?
-      url
-    end
-
-    def build_request(action, options = {})
-      headers = JSON_HEADERS
-      headers = headers.merge(options[:headers]) if options[:headers].present?
-      body = options[:body].to_json if options[:body].present?
-
-      unless action == :authenticate
-        set_auth_token
-        headers = headers.merge(token)
-      end
-
-      request = {
-                  url: build_url(action, options),
-                  headers:,
-                  method: @conf.dig(:api, :methods, action),
-                  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
-                   HTTPClient.post(url, headers:, body:)
-                 else
-                   HTTPClient.get(url, 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 if @auth_token.present?
-
-      api_credentials = fetch_credential(:api)
-
-      request = build_request(
-        :authenticate,
-        body: { email: api_credentials.username, password: api_credentials.password },
-      )
-
-      response = commit(request)
-      @auth_token = response['auth_token']
-    end
-
-    def token
-      { Authorization: "Bearer #{@auth_token}" }
-    end
-
-    # Show
-  end
-end