reactive_freight 0.0.1

data/lib/reactive_freight/carriers/fcsy.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module ReactiveShipping
+  class FCSY < CarrierLogistics
+    REACTIVE_FREIGHT_CARRIER = true
+
+    cattr_reader :name, :scac
+    @@name = 'Frontline Freight'
+    @@scac = 'FCSY'
+
+    # Documents
+
+    # Rates
+    def build_calculated_accessorials(*); end
+
+    # Tracking
+
+    # protected
+
+    # Documents
+
+    # Rates
+  end
+end

data/lib/reactive_freight/carriers/fwda.rb

@@ -0,0 +1,243 @@
+# frozen_string_literal: true
+
+module ReactiveShipping
+  class FWDA < ReactiveShipping::Carrier
+    REACTIVE_FREIGHT_CARRIER = true
+
+    cattr_reader :name, :scac
+    @@name = 'Forward Air'
+    @@scac = 'FWDA'
+
+    JSON_HEADERS = {
+      'Accept': 'application/json',
+      'charset': 'utf-8',
+      'Content-Type' => 'application/json'
+    }.freeze
+
+    # Override Carrier#serviceable_accessorials? since we have separate delivery/pickup accessorials
+    def serviceable_accessorials?(accessorials)
+      return true if accessorials.blank?
+
+      if !self.class::REACTIVE_FREIGHT_CARRIER ||
+         !@conf.dig(:accessorials, :mappable) ||
+         !@conf.dig(:accessorials, :unquotable) ||
+         !@conf.dig(:accessorials, :unserviceable)
+        raise NotImplementedError, "#{self.class.name}: #serviceable_accessorials? not supported"
+      end
+
+      serviceable_accessorials = @conf.dig(:accessorials, :mappable, :delivery).keys + 
+                                 @conf.dig(:accessorials, :mappable, :pickup).keys + 
+                                 @conf.dig(:accessorials, :unquotable)
+      serviceable_count = (serviceable_accessorials & accessorials).size
+
+      unserviceable_accessorials = @conf.dig(:accessorials, :unserviceable)
+      unserviceable_count = (unserviceable_accessorials & accessorials).size
+
+      if serviceable_count != accessorials.size || !unserviceable_count.zero?
+        raise ArgumentError, "#{self.class.name}: Some accessorials unserviceable"
+      end
+
+      true
+    end
+
+    # Documents
+
+    # Rates
+    def find_rates(origin, destination, packages, options = {})
+      options = @options.merge(options)
+      origin = Location.from(origin)
+      destination = Location.from(destination)
+      packages = Array(packages)
+
+      request = build_rate_request(origin, destination, packages, options)
+      parse_rate_response(origin, destination, commit(request))
+    end
+
+    # Tracking
+
+    protected
+
+    def build_url(action, options = {})
+      options = @options.merge(options)
+      "#{base_url}#{@conf.dig(:api, :endpoints, action)}"
+    end
+
+    def base_url
+      "https://#{@conf.dig(:api, :domain)}"
+    end
+
+    def build_headers(options = {})
+      options = @options.merge(options)
+      if !options[:username].blank? && !options[:password].blank? && !options[:account].blank?
+        return JSON_HEADERS.merge(
+          'user': options[:username],
+          'password': options[:password],
+          'customerId': options[:account]
+        )
+      end
+
+      JSON_HEADERS
+    end
+
+    def build_request(action, options = {})
+      options = @options.merge(options)
+      headers = JSON_HEADERS
+      headers = headers.merge(options[:headers]) unless options[:headers].blank?
+      body = options[:body].to_json unless options[:body].blank?
+
+      request = {
+        url: build_url(action, options),
+        headers: headers,
+        method: @conf.dig(:api, :methods, action),
+        body: body
+      }
+
+      save_request(request)
+      request
+    end
+
+    def commit(request)
+      url = request[:url]
+      headers = request[:headers]
+      method = request[:method]
+      body = request[:body]
+
+      response = case method
+                 when :post
+                   HTTParty.post(url, headers: headers, body: body)
+                 else
+                   HTTParty.get(url, headers: headers)
+                 end
+
+      JSON.parse(response.body)
+    end
+
+    # Documents
+
+    # Rates
+    def build_rate_request(origin, destination, packages, options = {})
+      options = @options.merge(options)
+
+      delivery_accessorials = []
+      pickup_accessorials = []
+      unless options[:accessorials].blank?
+        serviceable_accessorials?(options[:accessorials])
+        options[:accessorials].each do |a|
+          unless @conf.dig(:accessorials, :unserviceable).include?(a)
+            if @conf.dig(:accessorials, :mappable, :pickup).include?(a)
+              pickup_accessorials << @conf.dig(:accessorials, :mappable, :pickup)[a]
+            elsif delivery_accessorials << @conf.dig(:accessorials, :mappable, :delivery)[a]
+            end
+          end
+        end
+      end
+
+      unless delivery_accessorials.blank?
+        # Remove duplicate delivery appointment accessorial when residential delivery (included with RDE)
+        delivery_accessorials -= ['ADE'] if delivery_accessorials.include?('RDE')
+      end
+
+      unless pickup_accessorials.blank?
+        # Remove duplicate pickup appointment accessorial when residential pickup (included with RPU)
+        pickup_accessorials -= ['APP'] if pickup_accessorials.include?('RPU')
+      end
+
+      delivery_accessorials = delivery_accessorials.uniq
+      pickup_accessorials = pickup_accessorials.uniq
+
+      # API doesn't like empty arrays
+      delivery_accessorials = nil if delivery_accessorials.blank?
+      pickup_accessorials = nil if pickup_accessorials.blank?
+
+      freight_details = []
+      packages.each do |package|
+        freight_details << {
+          description: 'Freight',
+          freightClass: package.freight_class.to_s,
+          pieces: '1',
+          weightType: 'L',
+          weight: package.pounds.ceil.to_s
+        }
+      end
+
+      request = {
+        url: build_url(:rates, options),
+        headers: build_headers(options),
+        method: @conf.dig(:api, :methods, :rates),
+        body: {
+          billToCustomerNumber: options[:account],
+          origin: {
+            originZipCode: origin.to_hash[:postal_code].to_s.upcase,
+            pickup: {
+              airportPickup: pickup_accessorials&.include?('ALP') ? 'Y' : 'N',
+              pickupAccessorials: { pickupAccessorial: pickup_accessorials }
+            }
+          },
+          destination: {
+            destinationZipCode: destination.to_hash[:postal_code].to_s.upcase,
+            delivery: {
+              airportDelivery: delivery_accessorials&.include?('ALD') ? 'Y' : 'N',
+              deliveryAccessorials: { deliveryAccessorial: delivery_accessorials }
+            }
+          },
+          freightDetails: { freightDetail: freight_details },
+          hazmat: 'N',
+          inBondShipment: 'N',
+          declaredValue: '0.00',
+          shipmentDate: Date.current.strftime('%Y-%m-%d')
+        }.to_json
+      }
+
+      save_request(request)
+      request
+    end
+
+    def parse_rate_response(origin, destination, response)
+      success = true
+      message = ''
+
+      if !response
+        success = false
+        message = 'API Error: Unknown response'
+      elsif response.key?('errorMessage')
+        success = false
+        message = response.dig('errorMessage')
+      else
+        cost = response.dig('quoteTotal')
+        if cost
+          cost = (cost.to_f * 100).to_i
+          transit_days = response.dig('transitDaysTotal')
+
+          rate_estimates = [
+            RateEstimate.new(
+              origin,
+              destination,
+              self.class,
+              :standard,
+              transit_days: transit_days,
+              estimate_reference: nil,
+              total_cost: cost,
+              total_price: cost,
+              currency: 'USD',
+              with_excessive_length_fees: @conf.dig(:attributes, :rates, :with_excessive_length_fees)
+            )
+          ]
+        else
+          success = false
+          message = 'API Error: Cost is emtpy'
+        end
+      end
+
+      RateResponse.new(
+        success,
+        message,
+        response.to_hash,
+        rates: rate_estimates,
+        response: response,
+        request: last_request
+      )
+    end
+
+    # Tracking
+  end
+end

data/lib/reactive_freight/carriers/jfj_transportation.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module ReactiveShipping
+  class JFJTransportation < Liftoff
+    REACTIVE_FREIGHT_CARRIER = true
+
+    cattr_reader :name, :scac
+    @@name = 'JFJ Transportation'
+    @@scac = nil
+  end
+end

data/lib/reactive_freight/carriers/pens.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+module ReactiveShipping
+  class PENS < ReactiveShipping::Carrier
+    REACTIVE_FREIGHT_CARRIER = true
+
+    cattr_reader :name, :scac
+    @@name = 'Peninsula Truck Lines'
+    @@scac = 'PENS'
+
+    def requirements
+      %i[username password account]
+    end
+
+    # Documents
+
+    # Rates
+    def find_rates(origin, destination, packages, options = {})
+      options = @options.merge(options)
+      origin = Location.from(origin)
+      destination = Location.from(destination)
+      packages = Array(packages)
+
+      request = build_rate_request(origin, destination, packages, options)
+      parse_rate_response(origin, destination, commit_soap(:rates, request))
+    end
+
+    # Tracking
+
+    protected
+
+    def commit_soap(action, request)
+      Savon.client(
+        wsdl: request_url(action),
+        convert_request_keys_to: :lower_camelcase,
+        env_namespace: :soap,
+        element_form_default: :qualified
+      ).call(
+        @conf.dig(:api, :actions, action),
+        message: request
+      ).body.to_json
+    end
+
+    def request_url(action)
+      scheme = @conf.dig(:api, :use_ssl, action) ? 'https://' : 'http://'
+      "#{scheme}#{@conf.dig(:api, :domains, action)}#{@conf.dig(:api, :endpoints, action)}"
+    end
+
+    # Documents
+
+    # Rates
+    def build_rate_request(origin, destination, packages, options = {})
+      options = @options.merge(options)
+
+      request = {
+        user_id: @options[:username],
+        password: @options[:password],
+        account: @options[:account],
+        customer_type: @options[:customer_type].blank? ? 'B' : @options[:customer_type],
+        origin_zip: origin.to_hash[:postal_code].to_s,
+        destination_zip: destination.to_hash[:postal_code].to_s,
+        accessorial_list: '', # TODO: Fix this!
+        class_list: packages.map(&:freight_class).join(','),
+        weight_list: packages.map(&:lbs).inject([]) { |weights, lbs| weights << lbs.ceil }.join(','),
+        none_palletized_mode: 'N',
+        plt_count_list: Array.new(packages.size, 1).join(','),
+        plt_length_list: packages.map(&:inches).inject([]) { |lengths, inches| lengths << length(:in).ceil }.join(','),
+        plt_total_weight: packages.map(&:lbs).inject(0) { |sum, lbs| sum += lbs }.ceil,
+        plt_width_list: packages.map(&:inches).inject([]) { |lengths, inches| lengths << width(:in).ceil }.join(',')
+      }
+
+      save_request(request)
+      request
+    end
+
+    def parse_rate_response(origin, destination, response)
+      success = true
+      message = ''
+
+      if !response
+        success = false
+        message = 'API Error: Unknown response'
+      else
+        response = JSON.parse(response)
+        error = response.dig('create_pens_rate_quote_response', 'create_pens_rate_quote_result', 'errors', 'message')
+        if !error.blank?
+          success = false
+          message = error
+        else
+          result = response.dig('create_pens_rate_quote_response', 'create_pens_rate_quote_result')
+
+          service_type = :standard
+          api_service_type = result.dig('quote', 'transit_type')
+          @conf.dig(:services, :mappable).each do |key, val|
+            service_type = key if api_service_type.downcase.include?(val)
+          end
+
+          cost = result.dig('quote', 'gross_charge').sub(',', '').sub('.', '').to_i
+          transit_days = service_type == :next_day_ltl ? 1 : nil # TODO: Detect correctly
+          estimate_reference = result.dig('quote', 'quote_number')
+          if cost
+            rate_estimates = [
+              RateEstimate.new(
+                origin,
+                destination,
+                { scac: self.class.scac.upcase, name: self.class.name },
+                service_type,
+                transit_days: transit_days,
+                estimate_reference: estimate_reference,
+                total_cost: cost,
+                total_price: cost,
+                currency: 'USD',
+                with_excessive_length_fees: @conf.dig(:attributes, :rates, :with_excessive_length_fees)
+              )
+            ]
+          else
+            success = false
+            message = 'API Error: Cost is emtpy'
+          end
+        end
+      end
+
+      RateResponse.new(
+        success,
+        message,
+        response.to_hash,
+        rates: rate_estimates,
+        response: response,
+        request: last_request
+      )
+    end
+
+    # Tracking
+  end
+end

data/lib/reactive_freight/carriers/rdfs.rb

@@ -0,0 +1,320 @@
+# frozen_string_literal: true
+
+module ReactiveShipping
+  class RDFS < ReactiveShipping::Carrier
+    REACTIVE_FREIGHT_CARRIER = true
+
+    cattr_reader :name, :scac
+    @@name = 'Roadrunner Transportation Services'
+    @@scac = 'RRDS'
+
+    def requirements
+      %i[username password account]
+    end
+
+    # Documents
+    def find_bol(tracking_number, options = {})
+      options = @options.merge(options)
+      parse_document_response(:bol, tracking_number, options)
+    end
+
+    def find_pod(tracking_number, options = {})
+      options = @options.merge(options)
+      parse_document_response(:pod, tracking_number, options)
+    end
+
+    # Rates
+    def find_rates(origin, destination, packages, options = {})
+      options = @options.merge(options)
+      origin = Location.from(origin)
+      destination = Location.from(destination)
+      packages = Array(packages)
+
+      request = build_rate_request(origin, destination, packages, options)
+      parse_rate_response(origin, destination, commit_soap(:rates, request))
+    end
+
+    # Tracking
+    def find_tracking_info(tracking_number)
+      tracking_request = build_tracking_request(tracking_number)
+      parse_tracking_response(tracking_request)
+    end
+
+    protected
+
+    def build_soap_header(action)
+      {
+        authentication_header: {
+          :@xmlns => @conf.dig(:api, :soap, :namespaces, action),
+          :user_name => @options[:username],
+          :password => @options[:password]
+        }
+      }
+    end
+
+    def commit_soap(action, request)
+      Savon.client(
+        wsdl: request_url(action),
+        convert_request_keys_to: :camelcase,
+        env_namespace: :soap,
+        element_form_default: :qualified
+      ).call(
+        @conf.dig(:api, :actions, action),
+        soap_header: build_soap_header(action),
+        message: request
+      ).body.to_json
+    end
+
+    def parse_date(date)
+      date ? DateTime.strptime(date, '%Y-%m-%dT%H:%M:%S').to_s(:db) : nil
+    end
+
+    def request_url(action)
+      scheme = @conf.dig(:api, :use_ssl, action) ? 'https://' : 'http://'
+      "#{scheme}#{@conf.dig(:api, :domains, action)}#{@conf.dig(:api, :endpoints, action)}"
+    end
+
+    def strip_date(str)
+      str ? str.split(/[A|P]M /)[1] : nil
+    end
+
+    # Documents
+    def parse_document_response(type, tracking_number, options = {})
+      url = request_url(type).sub('%%TRACKING_NUMBER%%', tracking_number.to_s)
+
+      begin
+        doc = Nokogiri::HTML(URI.parse(url).open)
+      rescue OpenURI::HTTPError
+        raise ReactiveShipping::ResponseError, "API Error: #{@@name}: Document not found"
+      end
+
+      data = Base64.decode64(doc.css('img').first['src'].split('data:image/jpg;base64,').last)
+      path = if options[:path].blank?
+               File.join(Dir.tmpdir, "#{@@name} #{tracking_number} #{type.to_s.upcase}.pdf")
+             else
+               options[:path]
+             end
+
+      file = Tempfile.new
+      file.write(data)
+      file = Magick::ImageList.new(file.path)
+      file.write(path)
+      File.exist?(path) ? path : false
+    end
+
+    # Rates
+    def build_rate_request(origin, destination, packages, options = {})
+      options = @options.merge(options)
+
+      service_deliveryoptions = [
+        serviceoptions: { service_code: 'SS' }
+      ]
+
+      unless options[:accessorials].blank?
+        serviceable_accessorials?(options[:accessorials])
+        options[:accessorials].each do |a|
+          unless @conf.dig(:accessorials, :unserviceable).include?(a)
+            service_deliveryoptions << { serviceoptions: { service_code: @conf.dig(:accessorials, :mappable)[a] } }
+          end
+        end
+      end
+
+      longest_dimension = packages.inject([]) { |_arr, p| [p.length(:in), p.width(:in)] }.max.ceil
+      if longest_dimension > 144
+        service_deliveryoptions << { serviceoptions: { service_code: 'EXL' } }
+      elsif longest_dimension > 96
+        service_deliveryoptions << { serviceoptions: { service_code: 'EXM' } }
+      end
+
+      service_deliveryoptions = service_deliveryoptions.uniq.to_a
+
+      request = {
+        'request' => {
+          origin_zip: origin.to_hash[:postal_code].to_s,
+          destination_zip: destination.to_hash[:postal_code].to_s,
+          shipment_details: {
+            shipment_detail: packages.inject([]) do |arr, package|
+              arr << {
+                'ActualClass' => package.freight_class,
+                'Weight' => package.pounds.ceil
+              }
+            end
+          },
+          service_deliveryoptions: service_deliveryoptions,
+          origin_type: options[:origin_type] || 'B', # O for shipper, I for consignee, B for third party
+          payment_type: options[:payment_type] || 'P', # Prepaid
+          pallet_count: packages.size,
+          # :linear_feet => linear_ft(packages),
+          pieces: packages.size,
+          account: options[:account]
+        }
+      }
+
+      save_request(request)
+      request
+    end
+
+    def parse_rate_response(origin, destination, response)
+      success = true
+      message = ''
+
+      if !response
+        success = false
+        message = 'API Error: Unknown response'
+      else
+        response = JSON.parse(response)
+        if response[:error]
+          success = false
+          message = response[:error]
+        else
+          cost = response.dig('rate_quote_by_account_response', 'rate_quote_by_account_result', 'net_charge')
+          transit_days = response.dig(
+            'rate_quote_by_account_response',
+            'rate_quote_by_account_result',
+            'routing_info',
+            'estimated_transit_days'
+          ).to_i
+          estimate_reference = response.dig(
+            'rate_quote_by_account_response',
+            'rate_quote_by_account_result',
+            'quote_number'
+          )
+          if cost
+            rate_estimates = [
+              RateEstimate.new(
+                origin,
+                destination,
+                { scac: self.class.scac.upcase, name: self.class.name },
+                :standard,
+                transit_days: transit_days,
+                estimate_reference: estimate_reference,
+                total_cost: cost,
+                total_price: cost,
+                currency: 'USD',
+                with_excessive_length_fees: @conf.dig(:attributes, :rates, :with_excessive_length_fees)
+              )
+            ]
+          else
+            success = false
+            message = 'API Error: Cost is emtpy'
+          end
+        end
+      end
+
+      RateResponse.new(
+        success,
+        message,
+        response.to_hash,
+        rates: rate_estimates,
+        response: response,
+        request: last_request
+      )
+    end
+
+    # Tracking
+    def build_tracking_request(tracking_number)
+      URI.parse("#{request_url(:track)}/#{tracking_number}").open
+    end
+
+    def parse_location(comment, delimiters)
+      city = comment.split(delimiters[0])[0].split(delimiters[1])[1].split(', ')[0].titleize
+      state = comment.split(delimiters[0])[0].split(delimiters[1])[1].split(', ')[1].upcase
+
+      Location.new(
+        city: city,
+        province: state,
+        state: state,
+        country: ActiveUtils::Country.find('USA')
+      )
+    end
+
+    def parse_tracking_response(response)
+      json = JSON.parse(response.read)
+
+      if (response.status[0] != '200') || !json.dig('SearchResults')
+        status = json.dig('error') || "API Error: HTTP #{response.status[0]}"
+        return TrackingResponse.new(false, status, json, carrier: "#{@@scac}, #{@@name}", json: json, response: response, request: last_request)
+      end
+
+      search_result = json.dig('SearchResults')[0]
+      if search_result.dig('Shipment', 'ProNumber').downcase.include?('not available')
+        status = "API Error: #{@@name} tracking number not found"
+        return TrackingResponse.new(false, status, json, carrier: "#{@@scac}, #{@@name}", json: json, response: response, request: last_request)
+      end
+
+      receiver_address = Location.new(
+        city: search_result.dig('Shipment', 'Consignee', 'City').titleize,
+        province: search_result.dig('Shipment', 'Consignee', 'State').upcase,
+        state: search_result.dig('Shipment', 'Consignee', 'State').upcase,
+        country: ActiveUtils::Country.find('USA')
+      )
+
+      shipper_address = Location.new(
+        city: search_result.dig('Shipment', 'Origin', 'City').titleize,
+        province: search_result.dig('Shipment', 'Origin', 'State').upcase,
+        state: search_result.dig('Shipment', 'Origin', 'State').upcase,
+        country: ActiveUtils::Country.find('USA')
+      )
+
+      actual_delivery_date = parse_date(search_result.dig('Shipment', 'DeliveredDateTime'))
+      scheduled_delivery_date = parse_date(search_result.dig('Shipment', 'ApptDateTime'))
+      tracking_number = search_result.dig('Shipment', 'SearchItem')
+
+      last_location = nil
+      shipment_events = []
+      search_result.dig('Shipment', 'Comments').each do |api_event|
+        type_code = api_event.dig('ActivityCode')
+        next if !type_code || type_code == 'ARQ'
+
+        event = @conf.dig(:events, :types).key(type_code)
+        next if event.blank?
+
+        datetime_without_time_zone = parse_date(api_event.dig('StatusDateTime'))
+        comment = strip_date(api_event.dig('StatusComment'))
+
+        case event
+        when :arrived_at_terminal
+          location = parse_location(comment, [' to ', 'in '])
+        when :delivered
+          location = receiver_address
+        when :departed
+          location = parse_location(comment, [' to ', 'from '])
+        when :out_for_delivery
+          location = parse_location(comment, [' to ', 'from '])
+        when :picked_up
+          location = shipper_address
+        when :trailer_closed
+          location = last_location
+        when :trailer_unloaded
+          location = parse_location(comment, [' to ', 'in '])
+        end
+        last_location = location
+
+        # status and type_code set automatically by ActiveFreight based on event
+        shipment_events << ShipmentEvent.new(event, datetime_without_time_zone, location)
+      end
+
+      shipment_events = shipment_events.sort_by(&:time)
+
+      TrackingResponse.new(
+        true,
+        shipment_events.last.status,
+        json,
+        carrier: "#{@@scac}, #{@@name}",
+        json: json,
+        response: response,
+        status: status,
+        type_code: shipment_events.last.status,
+        ship_time: parse_date(search_result.dig('Shipment', 'ProDateTime')),
+        scheduled_delivery_date: scheduled_delivery_date,
+        actual_delivery_date: actual_delivery_date,
+        delivery_signature: nil,
+        shipment_events: shipment_events,
+        shipper_address: shipper_address,
+        origin: shipper_address,
+        destination: receiver_address,
+        tracking_number: tracking_number
+      )
+    end
+  end
+end