reactive_shipping 3.0.0

data/lib/reactive_shipping/carriers/kunaki.rb

@@ -0,0 +1,155 @@
+module ReactiveShipping
+  class Kunaki < Carrier
+    self.retry_safe = true
+
+    cattr_reader :name
+    @@name = "Kunaki"
+
+    URL = 'http://Kunaki.com/XMLService.ASP'
+
+    CARRIERS = ["UPS", "USPS", "FedEx", "Royal Mail", "Parcelforce", "Pharos", "Eurotrux", "Canada Post", "DHL"]
+
+    COUNTRIES = {
+      'AR' => 'Argentina',
+      'AU' => 'Australia',
+      'AT' => 'Austria',
+      'BE' => 'Belgium',
+      'BR' => 'Brazil',
+      'BG' => 'Bulgaria',
+      'CA' => 'Canada',
+      'CN' => 'China',
+      'CY' => 'Cyprus',
+      'CZ' => 'Czech Republic',
+      'DK' => 'Denmark',
+      'EE' => 'Estonia',
+      'FI' => 'Finland',
+      'FR' => 'France',
+      'DE' => 'Germany',
+      'GI' => 'Gibraltar',
+      'GR' => 'Greece',
+      'GL' => 'Greenland',
+      'HK' => 'Hong Kong',
+      'HU' => 'Hungary',
+      'IS' => 'Iceland',
+      'IE' => 'Ireland',
+      'IL' => 'Israel',
+      'IT' => 'Italy',
+      'JP' => 'Japan',
+      'LV' => 'Latvia',
+      'LI' => 'Liechtenstein',
+      'LT' => 'Lithuania',
+      'LU' => 'Luxembourg',
+      'MX' => 'Mexico',
+      'NL' => 'Netherlands',
+      'NZ' => 'New Zealand',
+      'NO' => 'Norway',
+      'PL' => 'Poland',
+      'PT' => 'Portugal',
+      'RO' => 'Romania',
+      'RU' => 'Russia',
+      'SG' => 'Singapore',
+      'SK' => 'Slovakia',
+      'SI' => 'Slovenia',
+      'ES' => 'Spain',
+      'SE' => 'Sweden',
+      'CH' => 'Switzerland',
+      'TW' => 'Taiwan',
+      'TR' => 'Turkey',
+      'UA' => 'Ukraine',
+      'GB' => 'United Kingdom',
+      'US' => 'United States',
+      'VA' => 'Vatican City',
+      'RS' => 'Yugoslavia',
+      'ME' => 'Yugoslavia'
+    }
+
+    def find_rates(origin, destination, packages, options = {})
+      requires!(options, :items)
+      commit(origin, destination, options)
+    end
+
+    def valid_credentials?
+      true
+    end
+
+    private
+
+    def build_request(destination, options)
+      country = COUNTRIES[destination.country_code]
+      state_province = %w(US CA).include?(destination.country_code.to_s) ? destination.state : ''
+
+      builder = Nokogiri::XML::Builder.new do |xml|
+        xml.ShippingOptions do
+          xml.AddressInfo do
+            xml.Country(country)
+            xml.State_Province(state_province)
+            xml.PostalCode(destination.zip)
+          end
+
+          options[:items].each do |item|
+            xml.Product do
+              xml.ProductId(item[:sku])
+              xml.Quantity(item[:quantity])
+            end
+          end
+        end
+      end
+      builder.to_xml
+    end
+
+    def commit(origin, destination, options)
+      request = build_request(destination, options)
+      response = parse( ssl_post(URL, request, "Content-Type" => "text/xml") )
+
+      RateResponse.new(success?(response), message_from(response), response,
+                       :rates => build_rate_estimates(response, origin, destination)
+      )
+    end
+
+    def build_rate_estimates(response, origin, destination)
+      response["Options"].collect do |quote|
+        RateEstimate.new(origin, destination, carrier_for(quote["Description"]), quote["Description"],
+                         :total_price  => quote["Price"],
+                         :currency     => "USD"
+        )
+      end
+    end
+
+    def carrier_for(service)
+      CARRIERS.dup.find { |carrier| service.to_s =~ /^#{carrier}/i } || service.to_s.split(" ").first
+    end
+
+    def parse(xml)
+      response = {}
+      response["Options"] = []
+
+      document = Nokogiri.XML(sanitize(xml))
+
+      response["ErrorCode"] = document.at('/Response/ErrorCode').text
+      response["ErrorText"] = document.at('/Response/ErrorText').text
+
+      document.xpath("Response/Option").each do |node|
+        rate = {}
+        rate["Description"] = node.at("Description").text
+        rate["Price"]       = node.at("Price").text
+        response["Options"] << rate
+      end
+      response
+    end
+
+    def sanitize(response)
+      result = response.to_s
+      result.gsub!("\r\n", "")
+      result.gsub!(/<(\/)?(BODY|HTML)>/, '')
+      result
+    end
+
+    def success?(response)
+      response["ErrorCode"] == "0"
+    end
+
+    def message_from(response)
+      response["ErrorText"]
+    end
+  end
+end

data/lib/reactive_shipping/carriers/new_zealand_post.rb

@@ -0,0 +1,260 @@
+module ReactiveShipping
+  class NewZealandPost < Carrier
+    cattr_reader :name
+    @@name = "New Zealand Post"
+
+    URL = "http://api.nzpost.co.nz/ratefinder"
+
+    def requirements
+      [:key]
+    end
+
+    def find_rates(origin, destination, packages, options = {})
+      options = @options.merge(options)
+      request = RateRequest.from(origin, destination, packages, options)
+      request.raw_responses = commit(request.urls) if request.new_zealand_origin?
+      request.rate_response
+    end
+
+    protected
+
+    def commit(urls)
+      save_request(urls).map { |url| ssl_get(url) }
+    end
+
+    def self.default_location
+      Location.new(
+        :country => "NZ",
+        :city => "Wellington",
+        :address1 => "22 Waterloo Quay",
+        :address2 => "Pipitea",
+        :postal_code => "6011"
+      )
+    end
+
+    class NewZealandPostRateResponse < RateResponse
+      attr_reader :raw_responses
+
+      def initialize(success, message, params = {}, options = {})
+        @raw_responses = options[:raw_responses]
+        super
+      end
+    end
+
+    class RateRequest
+      attr_reader :urls
+      attr_writer :raw_responses
+
+      def self.from(*args)
+        return International.new(*args) unless domestic?(args[0..1])
+        Domestic.new(*args)
+      end
+
+      def initialize(origin, destination, packages, options)
+        @origin = Location.from(origin)
+        @destination = Location.from(destination)
+        @packages = Array(packages).map { |package| NewZealandPostPackage.new(package, api) }
+        @params = { :format => "json", :api_key => options[:key] }
+        @test = options[:test]
+        @rates = @responses = @raw_responses = []
+        @urls = @packages.map { |package| url(package) }
+      end
+
+      def rate_response
+        @rates = rates
+        NewZealandPostRateResponse.new(true, "success", response_params, response_options)
+      rescue => error
+        NewZealandPostRateResponse.new(false, error.message, response_params, response_options)
+      end
+
+      def new_zealand_origin?
+        self.class.new_zealand?(@origin)
+      end
+
+      protected
+
+      def self.new_zealand?(location)
+        ['NZ', nil].include?(Location.from(location).country_code)
+      end
+
+      def self.domestic?(locations)
+        locations.select { |location| new_zealand?(location) }.size == 2
+      end
+
+      def response_options
+        {
+          :rates => @rates,
+          :raw_responses => @raw_responses,
+          :request => @urls,
+          :test => @test
+        }
+      end
+
+      def response_params
+        { :responses => @responses }
+      end
+
+      def rate_options(products)
+        {
+          :total_price => products.sum { |product| price(product) },
+          :currency => "NZD",
+          :service_code => products.first["code"]
+        }
+      end
+
+      def rates
+        rates_hash.map do |service, products|
+          RateEstimate.new(@origin, @destination, NewZealandPost.name, service, rate_options(products))
+        end
+      end
+
+      def rates_hash
+        products_hash.select { |_service, products| products.size == @packages.size }
+      end
+
+      def products_hash
+        product_arrays.flatten.group_by { |product| service_name(product) }
+      end
+
+      def product_arrays
+        responses.map do |response|
+          raise(response["message"]) unless response["status"] == "success"
+          response["products"]
+        end
+      end
+
+      def responses
+        @responses = @raw_responses.map { |response| parse_response(response) }
+      end
+
+      def parse_response(response)
+        JSON.parse(response)
+      end
+
+      def url(package)
+        "#{URL}/#{api}?#{params(package).to_query}"
+      end
+
+      def params(package)
+        @params.merge(api_params).merge(package.params)
+      end
+    end
+
+    class Domestic < RateRequest
+      def service_name(product)
+        [product["service_group_description"], product["description"]].join(" ")
+      end
+
+      def api
+        :domestic
+      end
+
+      def api_params
+        {
+          :postcode_src => @origin.postal_code,
+          :postcode_dest => @destination.postal_code,
+          :carrier => "all"
+        }
+      end
+
+      def price(product)
+        product["cost"].to_f
+      end
+    end
+
+    class International < RateRequest
+      def rates
+        raise "New Zealand Post packages must originate in New Zealand" unless new_zealand_origin?
+        super
+      end
+
+      def service_name(product)
+        [product["group"], product["name"]].join(" ")
+      end
+
+      def api
+        :international
+      end
+
+      def api_params
+        { :country_code => @destination.country_code }
+      end
+
+      def price(product)
+        product["price"].to_f
+      end
+    end
+
+    class NewZealandPostPackage
+      def initialize(package, api)
+        @package = package
+        @api = api
+        @params = { :weight => weight, :length => length }
+      end
+
+      def params
+        @params.merge(api_params).merge(shape_params)
+      end
+
+      protected
+
+      def weight
+        @package.kg
+      end
+
+      def length
+        mm(:length)
+      end
+
+      def height
+        mm(:height)
+      end
+
+      def width
+        mm(:width)
+      end
+
+      def shape
+        return :cylinder if @package.cylinder?
+        :cuboid
+      end
+
+      def api_params
+        send("#{@api}_params")
+      end
+
+      def international_params
+        { :value => value }
+      end
+
+      def domestic_params
+        {}
+      end
+
+      def shape_params
+        send("#{shape}_params")
+      end
+
+      def cuboid_params
+        { :height => height, :thickness => width }
+      end
+
+      def cylinder_params
+        { :diameter => width }
+      end
+
+      def mm(measurement)
+        @package.cm(measurement) * 10
+      end
+
+      def value
+        return 0 unless @package.value && currency == "NZD"
+        @package.value / 100
+      end
+
+      def currency
+        @package.currency || "NZD"
+      end
+    end
+  end
+end

data/lib/reactive_shipping/carriers/shipwire.rb

@@ -0,0 +1,178 @@
+module ReactiveShipping
+  class Shipwire < Carrier
+    self.retry_safe = true
+
+    cattr_reader :name
+    @@name = "Shipwire"
+
+    URL = 'https://api.shipwire.com/exec/RateServices.php'
+    SCHEMA_URL = 'http://www.shipwire.com/exec/download/RateRequest.dtd'
+    WAREHOUSES = { 'CHI' => 'Chicago',
+                   'LAX' => 'Los Angeles',
+                   'REN' => 'Reno',
+                   'VAN' => 'Vancouver',
+                   'TOR' => 'Toronto',
+                   'UK'  => 'United Kingdom'
+                 }
+
+    CARRIERS = ["UPS", "USPS", "FedEx", "Royal Mail", "Parcelforce", "Pharos", "Eurotrux", "Canada Post", "DHL"]
+
+    SUCCESS = "OK"
+    SUCCESS_MESSAGE = "Successfully received the shipping rates"
+    NO_RATES_MESSAGE = "No shipping rates could be found for the destination address"
+    REQUIRED_OPTIONS = [:login, :password].freeze
+
+    def find_rates(origin, destination, packages, options = {})
+      requires!(options, :items)
+      commit(origin, destination, options)
+    end
+
+    def valid_credentials?
+      location = self.class.default_location
+      find_rates(location, location, Package.new(100, [5, 15, 30]),
+                 :items => [{ :sku => '', :quantity => 1 }]
+      )
+    rescue ReactiveShipping::ResponseError
+      true
+    rescue ActiveUtils::ResponseError => e
+      e.response.code != '401'
+    end
+
+    private
+
+    def requirements
+      REQUIRED_OPTIONS
+    end
+
+    def build_request(destination, options)
+      Nokogiri::XML::Builder.new do |xml|
+        xml.doc.create_internal_subset('RateRequest', nil, SCHEMA_URL)
+        xml.RateRequest do
+          add_credentials(xml)
+          add_order(xml, destination, options)
+        end
+      end.to_xml
+    end
+
+    def add_credentials(xml)
+      xml.EmailAddress @options[:login]
+      xml.Password @options[:password]
+    end
+
+    def add_order(xml, destination, options)
+      xml.Order :id => options[:order_id] do
+        xml.Warehouse options[:warehouse] || '00'
+
+        add_address(xml, destination)
+        Array(options[:items]).each_with_index do |line_item, index|
+          add_item(xml, line_item, index)
+        end
+      end
+    end
+
+    def add_address(xml, destination)
+      xml.AddressInfo :type => 'Ship' do
+        if destination.name.present?
+          xml.Name do
+            xml.Full destination.name
+          end
+        end
+        xml.Address1 destination.address1
+        xml.Address2 destination.address2 unless destination.address2.blank?
+        xml.Address3 destination.address3 unless destination.address3.blank?
+        xml.Company destination.company unless destination.company.blank?
+        xml.City destination.city
+        xml.State destination.state unless destination.state.blank?
+        xml.Country destination.country_code
+        xml.Zip destination.zip  unless destination.zip.blank?
+      end
+    end
+
+    # Code is limited to 12 characters
+    def add_item(xml, item, index)
+      xml.Item :num => index do
+        xml.Code item[:sku]
+        xml.Quantity item[:quantity]
+      end
+    end
+
+    def commit(origin, destination, options)
+      request = build_request(destination, options)
+      save_request(request)
+
+      response = parse( ssl_post(URL, "RateRequestXML=#{CGI.escape(request)}") )
+
+      RateResponse.new(response["success"], response["message"], response,
+                       :xml     => response,
+                       :rates   => build_rate_estimates(response, origin, destination),
+                       :request => last_request
+      )
+    end
+
+    def build_rate_estimates(response, origin, destination)
+      response["rates"].collect do |quote|
+        RateEstimate.new(origin, destination, carrier_for(quote["service"]), quote["service"],
+                         :service_code    => quote["method"],
+                         :total_price     => quote["cost"],
+                         :currency        => quote["currency"],
+                         :delivery_range  => [timestamp_from_business_day(quote["delivery_min"]),
+                                              timestamp_from_business_day(quote["delivery_max"])]
+        )
+      end
+    end
+
+    def carrier_for(service)
+      CARRIERS.dup.find { |carrier| service.to_s =~ /^#{carrier}/i } || service.to_s.split(" ").first
+    end
+
+    def parse(xml)
+      response = {}
+      response["rates"] = []
+
+      document = Nokogiri.XML(xml)
+
+      response["status"] = parse_child_text(document.root, "Status")
+
+      document.root.xpath("Order/Quotes/Quote").each do |e|
+        rate = {}
+        rate["method"]    = e["method"]
+        rate["warehouse"] = parse_child_text(e, "Warehouse")
+        rate["service"]   = parse_child_text(e, "Service")
+        rate["cost"]      = parse_child_text(e, "Cost")
+        rate["currency"]  = parse_child_attribute(e, "Cost", "currency")
+        if delivery_estimate = e.at("DeliveryEstimate")
+          rate["delivery_min"]  = parse_child_text(delivery_estimate, "Minimum").to_i
+          rate["delivery_max"]  = parse_child_text(delivery_estimate, "Maximum").to_i
+        end
+        response["rates"] << rate
+      end
+
+      if response["status"] == SUCCESS && response["rates"].any?
+        response["success"] = true
+        response["message"] = SUCCESS_MESSAGE
+      elsif response["status"] == SUCCESS && response["rates"].empty?
+        response["success"] = false
+        response["message"] = NO_RATES_MESSAGE
+      else
+        response["success"] = false
+        response["message"] = parse_child_text(document.root, "ErrorMessage")
+      end
+
+      response
+    rescue NoMethodError => e
+      raise ReactiveShipping::ResponseContentError.new(e, xml)
+    end
+
+    def parse_child_text(parent, name)
+      if element = parent.at(name)
+        element.text
+      end
+    end
+
+    def parse_child_attribute(parent, name, attribute)
+      if element = parent.at(name)
+        element[attribute]
+      end
+    end
+  end
+end