benhutton-active_shipping 0.9.13

data/lib/active_merchant/common/error.rb

@@ -0,0 +1,26 @@
+module ActiveMerchant #:nodoc:
+  class ActiveMerchantError < StandardError #:nodoc:
+  end
+    
+  class ConnectionError < ActiveMerchantError # :nodoc:
+  end
+  
+  class RetriableConnectionError < ConnectionError # :nodoc:
+  end
+  
+  class ResponseError < ActiveMerchantError # :nodoc:
+    attr_reader :response
+
+    def initialize(response, message = nil)
+      @response = response
+      @message  = message
+    end
+
+    def to_s
+      "Failed with #{response.code} #{response.message if response.respond_to?(:message)}"
+    end
+  end
+  
+  class ClientCertificateError < ActiveMerchantError # :nodoc
+  end
+end

data/lib/active_merchant/common/post_data.rb

@@ -0,0 +1,24 @@
+require 'cgi'
+
+module ActiveMerchant
+  class PostData < Hash
+    class_inheritable_accessor :required_fields, :instance_writer => false
+    self.required_fields = []
+  
+    def []=(key, value)
+      return if value.blank? && !required?(key)
+      super
+    end
+  
+    def to_post_data
+      collect { |key, value| "#{key}=#{CGI.escape(value.to_s)}" }.join("&")  
+    end
+  
+    alias_method :to_s, :to_post_data
+  
+    private
+    def required?(key)
+      required_fields.include?(key)
+    end
+  end
+end

data/lib/active_merchant/common/posts_data.rb

@@ -0,0 +1,63 @@
+module ActiveMerchant #:nodoc:
+  module PostsData  #:nodoc:
+
+    def self.included(base)
+      base.superclass_delegating_accessor :ssl_strict
+      base.ssl_strict = true
+      
+      base.class_inheritable_accessor :retry_safe
+      base.retry_safe = false
+
+      base.superclass_delegating_accessor :open_timeout
+      base.open_timeout = 60
+
+      base.superclass_delegating_accessor :read_timeout
+      base.read_timeout = 60
+      
+      base.superclass_delegating_accessor :logger
+      base.superclass_delegating_accessor :wiredump_device
+    end
+    
+    def ssl_get(endpoint, headers={})
+      ssl_request(:get, endpoint, nil, headers)
+    end
+    
+    def ssl_post(endpoint, data, headers = {})
+      ssl_request(:post, endpoint, data, headers)
+    end
+
+    def ssl_request(method, endpoint, data, headers)
+      handle_response(raw_ssl_request(method, endpoint, data, headers))
+    end
+
+    def raw_ssl_request(method, endpoint, data, headers = {})
+      connection = Connection.new(endpoint)
+      connection.open_timeout = open_timeout
+      connection.read_timeout = read_timeout
+      connection.retry_safe   = retry_safe
+      connection.verify_peer  = ssl_strict
+      connection.logger       = logger
+      connection.tag          = self.class.name
+      connection.wiredump_device = wiredump_device
+      
+      connection.pem          = @options[:pem] if @options
+      connection.pem_password = @options[:pem_password] if @options
+
+      connection.ignore_http_status = @options[:ignore_http_status] if @options
+      
+      connection.request(method, data, headers)
+    end
+
+    private
+
+    def handle_response(response)
+      case response.code.to_i
+      when 200...300
+        response.body
+      else
+        raise ResponseError.new(response)
+      end
+    end
+    
+  end
+end

data/lib/active_merchant/common/requires_parameters.rb

@@ -0,0 +1,16 @@
+module ActiveMerchant #:nodoc:
+  module RequiresParameters #:nodoc:
+    def requires!(hash, *params)
+      params.each do |param| 
+        if param.is_a?(Array)
+          raise ArgumentError.new("Missing required parameter: #{param.first}") unless hash.has_key?(param.first) 
+
+          valid_options = param[1..-1]
+          raise ArgumentError.new("Parameter: #{param.first} must be one of #{valid_options.to_sentence(:words_connector => 'or')}") unless valid_options.include?(hash[param.first])
+        else
+          raise ArgumentError.new("Missing required parameter: #{param}") unless hash.has_key?(param) 
+        end
+      end
+    end    
+  end
+end

data/lib/active_merchant/common/utils.rb

@@ -0,0 +1,22 @@
+require 'digest/md5'
+
+module ActiveMerchant #:nodoc:
+  module Utils #:nodoc:
+    def generate_unique_id
+      md5 = Digest::MD5.new
+      now = Time.now
+      md5 << now.to_s
+      md5 << String(now.usec)
+      md5 << String(rand(0))
+      md5 << String($$)
+      md5 << self.class.name
+      md5.hexdigest
+    end
+    
+    module_function :generate_unique_id
+
+    def deprecated(message)
+      warn(Kernel.caller[1] + message)
+    end
+  end
+end

data/lib/active_merchant/common/validateable.rb

@@ -0,0 +1,76 @@
+module ActiveMerchant #:nodoc:  
+  module Validateable #:nodoc:
+    def valid?
+      errors.clear
+
+      before_validate if respond_to?(:before_validate, true)
+      validate if respond_to?(:validate, true)
+
+      errors.empty?
+    end  
+
+    def initialize(attributes = {})
+      self.attributes = attributes
+    end
+
+    def errors    
+      @errors ||= Errors.new(self)
+    end
+
+    private
+
+    def attributes=(attributes)
+      unless attributes.nil?
+        for key, value in attributes
+          send("#{key}=", value )            
+        end
+      end
+    end  
+
+    # This hash keeps the errors of the object
+    class Errors < HashWithIndifferentAccess
+
+      def initialize(base)
+        @base = base
+      end
+      
+      def count
+        size
+      end
+
+      # returns a specific fields error message. 
+      # if more than one error is available we will only return the first. If no error is available 
+      # we return an empty string
+      def on(field)
+        self[field].to_a.first
+      end
+
+      def add(field, error)
+        self[field] ||= []
+        self[field] << error
+      end    
+      
+      def add_to_base(error)
+        add(:base, error)
+      end
+
+      def each_full
+        full_messages.each { |msg| yield msg }      
+      end
+
+      def full_messages
+        result = []
+
+        self.each do |key, messages| 
+          if key == 'base'
+            result << "#{messages.first}"
+          else
+            result << "#{key.to_s.humanize} #{messages.first}"
+          end
+        end
+
+        result
+      end   
+    end  
+  end
+end

data/lib/active_shipping.rb

@@ -0,0 +1,49 @@
+#--
+# Copyright (c) 2009 Jaded Pixel
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#++
+
+$:.unshift File.dirname(__FILE__)
+
+begin
+  require 'active_support/all'
+rescue LoadError => e
+  require 'rubygems'
+  gem "activesupport", ">= 2.3.5"
+  require "active_support/all"
+end
+
+autoload :XmlNode, 'vendor/xml_node/lib/xml_node'
+autoload :Quantified, 'vendor/quantified/lib/quantified'
+
+require 'net/https'
+require 'active_merchant/common'
+
+require 'active_shipping/shipping/base'
+require 'active_shipping/shipping/response'
+require 'active_shipping/shipping/rate_response'
+require 'active_shipping/shipping/tracking_response'
+require 'active_shipping/shipping/package'
+require 'active_shipping/shipping/location'
+require 'active_shipping/shipping/rate_estimate'
+require 'active_shipping/shipping/shipment_event'
+require 'active_shipping/shipping/carrier'
+require 'active_shipping/shipping/carriers'

data/lib/active_shipping/shipping/base.rb

@@ -0,0 +1,13 @@
+module ActiveMerchant
+  module Shipping
+    module Base
+      mattr_accessor :mode
+      self.mode = :production
+      
+      def self.carrier(name)
+        ActiveMerchant::Shipping::Carriers.all.find {|c| c.name.downcase == name.to_s.downcase} ||
+          raise(NameError, "unknown carrier #{name}")
+      end
+    end
+  end
+end

data/lib/active_shipping/shipping/carrier.rb

@@ -0,0 +1,70 @@
+module ActiveMerchant
+  module Shipping
+    class Carrier
+      
+      include RequiresParameters
+      include PostsData
+      include Quantified
+      
+      attr_reader :last_request
+      attr_accessor :test_mode
+      alias_method :test_mode?, :test_mode
+      
+      # Credentials should be in options hash under keys :login, :password and/or :key.
+      def initialize(options = {})
+        requirements.each {|key| requires!(options, key)}
+        @options = options
+        @last_request = nil
+        @test_mode = @options[:test]
+      end
+
+      # Override to return required keys in options hash for initialize method.
+      def requirements
+        []
+      end
+      
+      # Override with whatever you need to get the rates
+      def find_rates(origin, destination, packages, options = {})
+      end
+      
+      # Validate credentials with a call to the API. By default this just does a find_rates call
+      # with the orgin and destination both as the carrier's default_location. Override to provide
+      # alternate functionality, such as checking for test_mode to use test servers, etc.
+      def valid_credentials?
+        location = self.class.default_location
+        find_rates(location,location,Package.new(100, [5,15,30]), :test => test_mode)
+      rescue ActiveMerchant::Shipping::ResponseError
+        false
+      else
+        true
+      end
+      
+      def maximum_weight
+        Mass.new(150, :pounds)
+      end
+      
+      protected
+      
+      def node_text_or_nil(xml_node)
+        xml_node ? xml_node.text : nil
+      end
+      
+      # Override in subclasses for non-U.S.-based carriers.
+      def self.default_location
+        Location.new( :country => 'US',
+                      :state => 'CA',
+                      :city => 'Beverly Hills',
+                      :address1 => '455 N. Rexford Dr.',
+                      :address2 => '3rd Floor',
+                      :zip => '90210',
+                      :phone => '1-310-285-1013',
+                      :fax => '1-310-275-8159')
+      end
+      
+      # Use after building the request to save for later inspection. Probably won't ever be overridden.
+      def save_request(r)
+        @last_request = r
+      end
+    end
+  end
+end

data/lib/active_shipping/shipping/carriers.rb

@@ -0,0 +1,20 @@
+require 'active_shipping/shipping/carriers/bogus_carrier'
+require 'active_shipping/shipping/carriers/ups'
+require 'active_shipping/shipping/carriers/usps'
+require 'active_shipping/shipping/carriers/fedex'
+require 'active_shipping/shipping/carriers/shipwire'
+require 'active_shipping/shipping/carriers/kunaki'
+require 'active_shipping/shipping/carriers/canada_post'
+require 'active_shipping/shipping/carriers/new_zealand_post'
+
+module ActiveMerchant
+  module Shipping
+    module Carriers
+      class <<self
+        def all
+          [BogusCarrier, UPS, USPS, FedEx, Shipwire, Kunaki, CanadaPost, NewZealandPost]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+module ActiveMerchant
+  module Shipping
+    class BogusCarrier < Carrier
+      cattr_reader :name
+      @@name = "Bogus Carrier"
+      
+      
+      def find_rates(origin, destination, packages, options = {})
+        origin = Location.from(origin)
+        destination = Location.from(destination)
+        packages = Array(packages)
+      end
+      
+    end
+  end
+end

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

@@ -0,0 +1,268 @@
+require 'cgi'
+
+module ActiveMerchant
+  module Shipping
+    
+    class CanadaPost < Carrier
+      
+      # NOTE!
+      # A Merchant CPC Id must be assigned to you by Canada Post
+      # CPC_DEMO_XML is just a public domain account for testing
+      
+      class CanadaPostRateResponse < RateResponse
+        
+        attr_reader :boxes, :postal_outlets
+        
+        def initialize(success, message, params = {}, options = {})
+          @boxes = options[:boxes]
+          @postal_outlets = options[:postal_outlets]
+          super
+        end
+        
+      end
+      
+      cattr_reader :name, :name_french
+      @@name = "Canada Post"
+      @@name_french = "Postes Canada"
+      
+      Box = Struct.new(:name, :weight, :expediter_weight, :length, :width, :height, :packedItems)
+      PackedItem = Struct.new(:quantity, :description)
+      PostalOutlet = Struct.new(:sequence_no, :distance, :name, :business_name, :postal_address, :business_hours)
+      
+      DEFAULT_TURN_AROUND_TIME = 24
+      URL = "http://sellonline.canadapost.ca:30000"
+      DOCTYPE = '<!DOCTYPE eparcel SYSTEM "http://sellonline.canadapost.ca/DevelopersResources/protocolV3/eParcel.dtd">'      
+      
+      RESPONSE_CODES = {
+       '1'     =>	"All calculation was done",
+       '2'     =>	"Default shipping rates are returned due to a problem during the processing of the request.",
+       '-2'    => "Missing argument when calling module",
+       '-5'	   => "No Item to ship",
+       '-6'	   => "Illegal Item weight",
+       '-7'	   => "Illegal item dimension",
+       '-12'   => "Can't open IM config file",
+       '-13'   => "Can't create log files",
+       '-15'   => "Invalid config file format",
+       '-102'  => "Invalid socket connection",
+       '-106'  => "Can't connect to server",
+       '-1000' => "Unknow request type sent by client",
+       '-1002' => "MAS Timed out",
+       '-1004' => "Socket communication break",
+       '-1005' => "Did not receive required data on socket.",
+       '-2000' => "Unable to estabish socket connection with RSSS",
+       '-2001' => "Merchant Id not found on server",
+       '-2002' => "One or more parameter was not sent by the IM to the MAS",
+       '-2003' => "Did not receive required data on socket.",
+       '-2004' => "The request contains to many items to process it.",
+       '-2005' => "The request received on socket is larger than the maximum allowed.",
+       '-3000' => "Origin Postal Code is illegal",
+       '-3001' => "Destination Postal Code/State Name/ Country  is illegal",
+       '-3002' => "Parcel too large to be shipped with CPC",
+       '-3003' => "Parcel too small to be shipped with CPC",
+       '-3004' => "Parcel too heavy to be shipped with CPC",
+       '-3005' => "Internal error code returned by the rating DLL",
+       '-3006' => "The pick up time format is invalid or not defined.",
+       '-4000' => "Volumetric internal error",
+       '-4001' => "Volumetric time out calculation error.",
+       '-4002' => "No bins provided to the volumetric engine.",
+       '-4003' => "No items provided to the volumetric engine.",
+       '-4004' => "Item is too large to be packed",
+       '-4005' => "Number of item more than maximum allowed",
+       '-5000' => "XML Parsing error",
+       '-5001' => "XML Tag not found",
+       '-5002' => "Node Value Number format error",
+       '-5003' => "Node value is empty",
+       '-5004' => "Unable to create/parse XML Document",
+       '-6000' => "Unable to open the database",
+       '-6001' => "Unable to read from the database",
+       '-6002' => "Unable to write to the database",
+       '-50000' => "Internal problem - Please contact Sell Online Help Desk"
+      }
+      
+      NON_ISO_COUNTRY_NAMES = {
+        'Russian Federation' => 'Russia'
+      }
+
+
+      def requirements
+        [:login]
+      end
+      
+      def find_rates(origin, destination, line_items = [], options = {})
+        rate_request = build_rate_request(origin, destination, line_items, options)
+        commit(rate_request, origin, destination, options)
+      end
+      
+      def maximum_weight
+        Mass.new(30, :kilograms)
+      end
+      
+      def self.default_location
+        {
+          :country => 'CA',
+          :province => 'ON',
+          :city => 'Ottawa',
+          :address1 => '61A York St',
+          :postal_code => 'K1N5T2'
+        }
+      end
+
+      protected
+      
+      def commit(request, origin, destination, options = {})
+        response = parse_rate_response(ssl_post(URL, request), origin, destination, options)
+      end
+      
+      private
+      
+      def build_rate_request(origin, destination, line_items = [], options = {})
+        line_items = [line_items] if !line_items.is_a?(Array)
+        origin = origin.is_a?(Location) ? origin : Location.new(origin)
+        destination = destination.is_a?(Location) ? destination : Location.new(destination)
+
+        xml_request = XmlNode.new('eparcel') do |root_node|
+          root_node << XmlNode.new('language', @options[:french] ? 'fr' : 'en')
+          root_node << XmlNode.new('ratesAndServicesRequest') do |request|
+
+            request << XmlNode.new('merchantCPCID', @options[:login])
+            request << XmlNode.new('fromPostalCode', origin.postal_code)
+            request << XmlNode.new('turnAroundTime', options[:turn_around_time] ? options[:turn_around_time] : DEFAULT_TURN_AROUND_TIME)
+            request << XmlNode.new('itemsPrice', dollar_amount(line_items.sum(&:value)))
+
+            #line items
+            request << build_line_items(line_items)
+
+            #delivery info
+            #NOTE: These tags MUST be after line items
+            request << XmlNode.new('city', destination.city)
+            request << XmlNode.new('provOrState', destination.province)
+            request << XmlNode.new('country', handle_non_iso_country_names(destination.country))
+            request << XmlNode.new('postalCode', destination.postal_code)
+          end
+        end
+
+        DOCTYPE + xml_request.to_s
+      end
+
+      def parse_rate_response(response, origin, destination, options = {})
+        xml = REXML::Document.new(response)
+        success = response_success?(xml)
+        message = response_message(xml)
+
+        rate_estimates = []
+        boxes = []
+        if success
+          xml.elements.each('eparcel/ratesAndServicesResponse/product') do |product|
+            service_name = (@options[:french] ? @@name_french : @@name) + product.get_text('name').to_s
+            service_code = product.attribute('id').to_s
+            delivery_date = date_for(product.get_text('deliveryDate').to_s)
+
+            rate_estimates << RateEstimate.new(origin, destination, @@name, service_name,
+              :service_code => service_code,
+              :total_price => product.get_text('rate').to_s,
+              :delivery_date => delivery_date,
+              :currency => 'CAD'
+            )
+          end
+
+          boxes = xml.elements.collect('eparcel/ratesAndServicesResponse/packing/box') do |box|
+            b = Box.new
+            b.packedItems = []
+            b.name = box.get_text('name').to_s
+            b.weight = box.get_text('weight').to_s.to_f
+            b.expediter_weight = box.get_text('expediterWeight').to_s.to_f
+            b.length = box.get_text('length').to_s.to_f
+            b.width = box.get_text('width').to_s.to_f
+            b.height = box.get_text('height').to_s.to_f
+            b.packedItems = box.elements.collect('packedItem') do |item|
+              p = PackedItem.new
+              p.quantity = item.get_text('quantity').to_s.to_i
+              p.description = item.get_text('description').to_s
+              p
+            end
+            b
+          end
+
+          postal_outlets = xml.elements.collect('eparcel/ratesAndServicesResponse/nearestPostalOutlet') do |outlet|
+            postal_outlet = PostalOutlet.new
+            postal_outlet.sequence_no    = outlet.get_text('postalOutletSequenceNo').to_s
+            postal_outlet.distance       = outlet.get_text('distance').to_s
+            postal_outlet.name           = outlet.get_text('outletName').to_s
+            postal_outlet.business_name  = outlet.get_text('businessName').to_s
+
+            postal_outlet.postal_address = Location.new({
+              :address1     => outlet.get_text('postalAddress/addressLine').to_s,
+              :postal_code  => outlet.get_text('postalAddress/postal_code').to_s,
+              :city         => outlet.get_text('postalAddress/municipality').to_s,
+              :province     => outlet.get_text('postalAddress/province').to_s,
+              :country      => 'Canada',
+              :phone_number => outlet.get_text('phoneNumber').to_s
+            })
+
+            postal_outlet.business_hours = outlet.elements.collect('businessHours') do |hour|
+              { :day_of_week => hour.get_text('dayOfWeek').to_s, :time => hour.get_text('time').to_s }
+            end
+
+            postal_outlet
+          end
+        end
+
+        CanadaPostRateResponse.new(success, message, Hash.from_xml(response), :rates => rate_estimates, :xml => response, :boxes => boxes, :postal_outlets => postal_outlets)
+      end
+      
+      def date_for(string)
+        string && Time.parse(string)
+      rescue ArgumentError
+        nil
+      end
+
+      def response_success?(xml)
+        value = xml.get_text('eparcel/ratesAndServicesResponse/statusCode').to_s
+        value == '1' || value == '2'
+      end
+      
+      def response_message(xml)
+        xml.get_text('eparcel/ratesAndServicesResponse/statusMessage').to_s
+      end
+      
+      # <!-- List of items in the shopping    -->
+      # <!-- cart                             -->
+      # <!-- Each item is defined by :        -->
+      # <!--   - quantity    (mandatory)      -->
+      # <!--   - size        (mandatory)      -->
+      # <!--   - weight      (mandatory)      -->
+      # <!--   - description (mandatory)      -->
+      # <!--   - ready to ship (optional)     -->
+      
+      def build_line_items(line_items)
+        xml_line_items = XmlNode.new('lineItems') do |line_items_node|
+          
+          line_items.each do |line_item|
+            
+            line_items_node << XmlNode.new('item') do |item|
+              item << XmlNode.new('quantity', 1)
+              item << XmlNode.new('weight', line_item.kilograms)
+              item << XmlNode.new('length', line_item.cm(:length).to_s)
+              item << XmlNode.new('width', line_item.cm(:width).to_s)
+              item << XmlNode.new('height', line_item.cm(:height).to_s)
+              item << XmlNode.new('description', line_item.options[:description] || ' ')
+              item << XmlNode.new('readyToShip', line_item.options[:ready_to_ship] || nil)
+              
+              # By setting the 'readyToShip' tag to true, Sell Online will not pack this item in the boxes defined in the merchant profile.
+            end
+          end
+        end
+        
+        xml_line_items
+      end
+      
+      def dollar_amount(cents)
+        "%0.2f" % (cents / 100.0)
+      end
+      
+      def handle_non_iso_country_names(country)
+        NON_ISO_COUNTRY_NAMES[country.to_s] || country
+      end
+    end
+  end
+end