active_shipping 0.12.6 → 1.0.0.pre1

data/lib/active_shipping/shipping/carriers/kunaki.rb

@@ -1,166 +0,0 @@
-require 'builder'
-
-module ActiveMerchant
-  module Shipping
-    class Kunaki < Carrier
-      self.retry_safe = true
-
-      cattr_reader :name
-      @@name = "Kunaki"
-
-      URL = 'https://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)
-        xml = Builder::XmlMarkup.new
-        xml.instruct!
-        xml.tag! 'ShippingOptions' do
-          xml.tag! 'AddressInfo' do
-            xml.tag! 'Country', COUNTRIES[destination.country_code]
-
-            state = %w(US CA).include?(destination.country_code.to_s) ? destination.state : ''
-
-            xml.tag! 'State_Province', state
-            xml.tag! 'PostalCode', destination.zip
-          end
-
-          options[:items].each do |item|
-            xml.tag! 'Product' do
-              xml.tag! 'ProductId', item[:sku]
-              xml.tag! 'Quantity', item[:quantity]
-            end
-          end
-        end
-        xml.target!
-      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 = REXML::Document.new(sanitize(xml))
-
-        response["ErrorCode"] = parse_child_text(document.root, "ErrorCode")
-        response["ErrorText"] = parse_child_text(document.root, "ErrorText")
-
-        document.root.elements.each("Option") do |e|
-          rate = {}
-          rate["Description"] = parse_child_text(e, "Description")
-          rate["Price"]       = parse_child_text(e, "Price")
-          response["Options"] << rate
-        end
-        response
-      end
-
-      def sanitize(response)
-        result = response.to_s
-        result.gsub!("\r\n", "")
-        result.gsub!(/<(\/)?(BODY|HTML)>/, '')
-        result
-      end
-
-      def parse_child_text(parent, name)
-        if element = parent.elements[name]
-          element.text
-        end
-      end
-
-      def success?(response)
-        response["ErrorCode"] == "0"
-      end
-
-      def message_from(response)
-        response["ErrorText"]
-      end
-    end
-  end
-end

data/lib/active_shipping/shipping/carriers/new_zealand_post.rb

@@ -1,262 +0,0 @@
-module ActiveMerchant
-  module Shipping
-    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
-end

data/lib/active_shipping/shipping/carriers/shipwire.rb

@@ -1,184 +0,0 @@
-require 'cgi'
-require 'builder'
-
-module ActiveMerchant
-  module Shipping
-    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 ActiveMerchant::Shipping::ResponseError
-        true
-      rescue ActiveMerchant::ResponseError => e
-        e.response.code != '401'
-      end
-
-      private
-
-      def requirements
-        REQUIRED_OPTIONS
-      end
-
-      def build_request(destination, options)
-        xml = Builder::XmlMarkup.new
-        xml.instruct!
-        xml.declare! :DOCTYPE, :RateRequest, :SYSTEM, SCHEMA_URL
-        xml.tag! 'RateRequest' do
-          add_credentials(xml)
-          add_order(xml, destination, options)
-        end
-        xml.target!
-      end
-
-      def add_credentials(xml)
-        xml.tag! 'EmailAddress', @options[:login]
-        xml.tag! 'Password', @options[:password]
-      end
-
-      def add_order(xml, destination, options)
-        xml.tag! 'Order', :id => options[:order_id] do
-          xml.tag! '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.tag! 'AddressInfo', :type => 'Ship' do
-          if destination.name.present?
-            xml.tag! 'Name' do
-              xml.tag! 'Full', destination.name
-            end
-          end
-          xml.tag! 'Address1', destination.address1
-          xml.tag! 'Address2', destination.address2 unless destination.address2.blank?
-          xml.tag! 'Address3', destination.address3 unless destination.address3.blank?
-          xml.tag! 'Company', destination.company unless destination.company.blank?
-          xml.tag! 'City', destination.city
-          xml.tag! 'State', destination.state unless destination.state.blank?
-          xml.tag! 'Country', destination.country_code
-          xml.tag! 'Zip', destination.zip  unless destination.zip.blank?
-        end
-      end
-
-      # Code is limited to 12 characters
-      def add_item(xml, item, index)
-        xml.tag! 'Item', :num => index do
-          xml.tag! 'Code', item[:sku]
-          xml.tag! '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 = REXML::Document.new(xml)
-
-        response["status"] = parse_child_text(document.root, "Status")
-
-        document.root.elements.each("Order/Quotes/Quote") do |e|
-          rate = {}
-          rate["method"]    = e.attributes["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.elements["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 ActiveMerchant::Shipping::ResponseContentError.new(e, xml)
-      end
-
-      def parse_child_text(parent, name)
-        if element = parent.elements[name]
-          element.text
-        end
-      end
-
-      def parse_child_attribute(parent, name, attribute)
-        if element = parent.elements[name]
-          element.attributes[attribute]
-        end
-      end
-    end
-  end
-end