active_shipping 0.12.6 → 1.0.0.pre1

data/lib/active_shipping/carriers/bogus_carrier.rb

@@ -0,0 +1,12 @@
+module ActiveShipping
+  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

data/lib/active_shipping/carriers/canada_post.rb

@@ -0,0 +1,253 @@
+module ActiveShipping
+  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)
+
+    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 = {})
+      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] unless 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]) if options[:turn_around_time]
+          request << XmlNode.new('itemsPrice', dollar_amount(line_items.map(&:value).compact.sum))
+
+          # 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
+
+          rate_estimates << RateEstimate.new(origin, destination, @@name, service_name,
+                                             :service_code => service_code,
+                                             :total_price => product.get_text('rate').to_s,
+                                             :currency => 'CAD',
+                                             :shipping_date => product.get_text('shippingDate').to_s,
+                                             :delivery_range => [product.get_text('deliveryDate').to_s] * 2
+          )
+        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 response_success?(xml)
+      return false unless xml.get_text('eparcel/error').nil?
+
+      value = xml.get_text('eparcel/ratesAndServicesResponse/statusCode').to_s
+      value == '1' || value == '2'
+    end
+
+    def response_message(xml)
+      if response_success?(xml)
+        xml.get_text('eparcel/ratesAndServicesResponse/statusMessage').to_s
+      else
+        xml.get_text('eparcel/error/statusMessage').to_s
+      end
+    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)
+      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
+    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

data/lib/active_shipping/carriers/canada_post_pws.rb

@@ -0,0 +1,870 @@
+module ActiveShipping
+  class CanadaPostPWS < Carrier
+    @@name = "Canada Post PWS"
+
+    SHIPPING_SERVICES = {
+      "DOM.RP"        => "Regular Parcel",
+      "DOM.EP"        => "Expedited Parcel",
+      "DOM.XP"        => "Xpresspost",
+      "DOM.XP.CERT"   => "Xpresspost Certified",
+      "DOM.PC"        => "Priority",
+      "DOM.LIB"       => "Library Books",
+
+      "USA.EP"        => "Expedited Parcel USA",
+      "USA.PW.ENV"    => "Priority Worldwide Envelope USA",
+      "USA.PW.PAK"    => "Priority Worldwide pak USA",
+      "USA.PW.PARCEL" => "Priority Worldwide Parcel USA",
+      "USA.SP.AIR"    => "Small Packet USA Air",
+      "USA.SP.SURF"   => "Small Packet USA Surface",
+      "USA.XP"        => "Xpresspost USA",
+
+      "INT.XP"        => "Xpresspost International",
+      "INT.IP.AIR"    => "International Parcel Air",
+      "INT.IP.SURF"   => "International Parcel Surface",
+      "INT.PW.ENV"    => "Priority Worldwide Envelope Int'l",
+      "INT.PW.PAK"    => "Priority Worldwide pak Int'l",
+      "INT.PW.PARCEL" => "Priority Worldwide parcel Int'l",
+      "INT.SP.AIR"    => "Small Packet International Air",
+      "INT.SP.SURF"   => "Small Packet International Surface"
+    }
+
+    ENDPOINT = "https://soa-gw.canadapost.ca/"    # production
+
+    SHIPMENT_MIMETYPE = "application/vnd.cpc.ncshipment+xml"
+    RATE_MIMETYPE = "application/vnd.cpc.ship.rate+xml"
+    TRACK_MIMETYPE = "application/vnd.cpc.track+xml"
+    REGISTER_MIMETYPE = "application/vnd.cpc.registration+xml"
+
+    LANGUAGE = {
+      'en' => 'en-CA',
+      'fr' => 'fr-CA'
+    }
+
+    SHIPPING_OPTIONS = [:d2po, :d2po_office_id, :cov, :cov_amount, :cod, :cod_amount, :cod_includes_shipping,
+                        :cod_method_of_payment, :so, :dc, :dns, :pa18, :pa19, :hfp, :lad,
+                        :rase, :rts, :aban]
+
+    RATES_OPTIONS = [:cov, :cov_amount, :cod, :so, :dc, :dns, :pa18, :pa19, :hfp, :lad]
+
+    MAX_WEIGHT = 30 # kg
+
+    attr_accessor :language, :endpoint, :logger, :platform_id, :customer_number
+
+    def initialize(options = {})
+      @language = LANGUAGE[options[:language]] || LANGUAGE['en']
+      @endpoint = options[:endpoint] || ENDPOINT
+      @platform_id = options[:platform_id]
+      @customer_number = options[:customer_number]
+      super(options)
+    end
+
+    def requirements
+      [:api_key, :secret]
+    end
+
+    def find_rates(origin, destination, line_items = [], options = {}, package = nil, services = [])
+      url = endpoint + "rs/ship/price"
+      request  = build_rates_request(origin, destination, line_items, options, package, services)
+      response = ssl_post(url, request, headers(options, RATE_MIMETYPE, RATE_MIMETYPE))
+      parse_rates_response(response, origin, destination)
+    rescue ActiveUtils::ResponseError, ActiveShipping::ResponseError => e
+      error_response(e.response.body, CPPWSRateResponse)
+    end
+
+    def find_tracking_info(pin, options = {})
+      response = ssl_get(tracking_url(pin), headers(options, TRACK_MIMETYPE))
+      parse_tracking_response(response)
+    rescue ActiveUtils::ResponseError, ActiveShipping::ResponseError => e
+      if e.response
+        error_response(e.response.body, CPPWSTrackingResponse)
+      else
+        CPPWSTrackingResponse.new(false, e.message, {}, :carrier => @@name)
+      end
+    rescue InvalidPinFormatError
+      CPPWSTrackingResponse.new(false, "Invalid Pin Format", {}, :carrier => @@name)
+    end
+
+    # line_items should be a list of PackageItem's
+    def create_shipment(origin, destination, package, line_items = [], options = {})
+      request_body = build_shipment_request(origin, destination, package, line_items, options)
+      response = ssl_post(create_shipment_url(options), request_body, headers(options, SHIPMENT_MIMETYPE, SHIPMENT_MIMETYPE))
+      parse_shipment_response(response)
+    rescue ActiveUtils::ResponseError, ActiveShipping::ResponseError => e
+      error_response(e.response.body, CPPWSShippingResponse)
+    rescue MissingCustomerNumberError
+      CPPWSShippingResponse.new(false, "Missing Customer Number", {}, :carrier => @@name)
+    end
+
+    def retrieve_shipment(shipping_id, options = {})
+      response = ssl_post(shipment_url(shipping_id, options), nil, headers(options, SHIPMENT_MIMETYPE, SHIPMENT_MIMETYPE))
+      parse_shipment_response(response)
+    end
+
+    def find_shipment_receipt(shipping_id, options = {})
+      response = ssl_get(shipment_receipt_url(shipping_id, options), headers(options, SHIPMENT_MIMETYPE, SHIPMENT_MIMETYPE))
+      parse_shipment_receipt_response(response)
+    end
+
+    def retrieve_shipping_label(shipping_response, options = {})
+      raise MissingShippingNumberError unless shipping_response && shipping_response.shipping_id
+      ssl_get(shipping_response.label_url, headers(options, "application/pdf"))
+    end
+
+    def register_merchant(options = {})
+      url = endpoint + "ot/token"
+      response = ssl_post(url, nil, headers({}, REGISTER_MIMETYPE, REGISTER_MIMETYPE).merge("Content-Length" => "0"))
+      parse_register_token_response(response)
+    rescue ActiveUtils::ResponseError, ActiveShipping::ResponseError => e
+      error_response(e.response.body, CPPWSRegisterResponse)
+    end
+
+    def retrieve_merchant_details(options = {})
+      raise MissingTokenIdError unless token_id = options[:token_id]
+      url = endpoint + "ot/token/#{token_id}"
+      response = ssl_get(url, headers({}, REGISTER_MIMETYPE, REGISTER_MIMETYPE))
+      parse_merchant_details_response(response)
+    rescue ActiveUtils::ResponseError, ActiveShipping::ResponseError => e
+      error_response(e.response.body, CPPWSMerchantDetailsResponse)
+    rescue Exception => e
+      raise ResponseError.new(e.message)
+    end
+
+    def find_services(country = nil, options = {})
+      response = ssl_get(services_url(country), headers(options, RATE_MIMETYPE))
+      parse_services_response(response)
+    rescue ActiveUtils::ResponseError, ActiveShipping::ResponseError => e
+      error_response(e.response.body, CPPWSRateResponse)
+    end
+
+    def find_service_options(service_code, country, options = {})
+      response = ssl_get(services_url(country, service_code), headers(options, RATE_MIMETYPE))
+      parse_service_options_response(response)
+    rescue ActiveUtils::ResponseError, ActiveShipping::ResponseError => e
+      error_response(e.response.body, CPPWSRateResponse)
+    end
+
+    def find_option_details(option_code, options = {})
+      url = endpoint + "rs/ship/option/#{option_code}"
+      response = ssl_get(url, headers(options, RATE_MIMETYPE))
+      parse_option_response(response)
+    rescue ActiveUtils::ResponseError, ActiveShipping::ResponseError => e
+      error_response(e.response.body, CPPWSRateResponse)
+    end
+
+    def maximum_weight
+      Mass.new(MAX_WEIGHT, :kilograms)
+    end
+
+    # service discovery
+
+    def parse_services_response(response)
+      doc = REXML::Document.new(REXML::Text::unnormalize(response))
+      service_nodes = doc.elements['services'].elements.collect('service') { |node| node }
+      service_nodes.inject({}) do |result, node|
+        service_code = node.get_text("service-code").to_s
+        service_name = node.get_text("service-name").to_s
+        service_link = node.elements["link"].attributes['href']
+        service_link_media_type = node.elements["link"].attributes['media-type']
+        result[service_code] = {
+          :name => service_name,
+          :link => service_link,
+          :link_media_type => service_link_media_type
+        }
+        result
+      end
+    end
+
+    def parse_service_options_response(response)
+      doc = REXML::Document.new(REXML::Text::unnormalize(response))
+      service_node = doc.elements['service']
+      service_code = service_node.get_text("service-code").to_s
+      service_name = service_node.get_text("service-name").to_s
+      options_node = service_node.elements['options']
+      unless options_node.blank?
+        option_nodes = options_node.elements.collect('option') { |node| node }
+        options = option_nodes.inject([]) do |result, node|
+          option = {
+            :code => node.get_text("option-code").to_s,
+            :name => node.get_text("option-name").to_s,
+            :required => node.get_text("mandatory").to_s == "false" ? false : true,
+            :qualifier_required => node.get_text("qualifier-required").to_s == "false" ? false : true
+          }
+          option[:qualifier_max] = node.get_text("qualifier-max").to_s.to_i if node.get_text("qualifier-max")
+          result << option
+          result
+        end
+      end
+      restrictions_node = service_node.elements['restrictions']
+      dimensions_node = restrictions_node.elements['dimensional-restrictions']
+      restrictions = {
+        :min_weight => restrictions_node.elements["weight-restriction"].attributes['min'].to_i,
+        :max_weight => restrictions_node.elements["weight-restriction"].attributes['max'].to_i,
+        :min_length => dimensions_node.elements["length"].attributes['min'].to_f,
+        :max_length => dimensions_node.elements["length"].attributes['max'].to_f,
+        :min_height => dimensions_node.elements["height"].attributes['min'].to_f,
+        :max_height => dimensions_node.elements["height"].attributes['max'].to_f,
+        :min_width => dimensions_node.elements["width"].attributes['min'].to_f,
+        :max_width => dimensions_node.elements["width"].attributes['max'].to_f
+      }
+
+      {
+        :service_code => service_code,
+        :service_name => service_name,
+        :options => options,
+        :restrictions => restrictions
+      }
+    end
+
+    def parse_option_response(response)
+      doc = REXML::Document.new(REXML::Text::unnormalize(response))
+      option_node = doc.elements['option']
+      conflicts = option_node.elements['conflicting-options'].elements.collect('option-code') { |node| node.get_text.to_s } unless option_node.elements['conflicting-options'].blank?
+      prereqs = option_node.elements['prerequisite-options'].elements.collect('option-code') { |node| node.get_text.to_s } unless option_node.elements['prerequisite-options'].blank?
+      option = {
+        :code => option_node.get_text('option-code').to_s,
+        :name => option_node.get_text('option-name').to_s,
+        :class => option_node.get_text('option-class').to_s,
+        :prints_on_label => option_node.get_text('prints-on-label').to_s == "false" ? false : true,
+        :qualifier_required => option_node.get_text('qualifier-required').to_s == "false" ? false : true
+      }
+      option[:conflicting_options] = conflicts if conflicts
+      option[:prerequisite_options] = prereqs if prereqs
+
+      option[:qualifier_max] = option_node.get_text("qualifier-max").to_s.to_i if option_node.get_text("qualifier-max")
+      option
+    end
+
+    # rating
+
+    def build_rates_request(origin, destination, line_items = [], options = {}, package = nil, services = [])
+      line_items = Array(line_items)
+      xml =  XmlNode.new('mailing-scenario', :xmlns => "http://www.canadapost.ca/ws/ship/rate") do |node|
+        node << customer_number_node(options)
+        node << contract_id_node(options)
+        node << quote_type_node(options)
+        node << expected_mailing_date_node(shipping_date(options)) if options[:shipping_date]
+        options_node = shipping_options_node(RATES_OPTIONS, options)
+        node << options_node if options_node && !options_node.children.count.zero?
+        node << parcel_node(line_items, package)
+        node << origin_node(origin)
+        node << destination_node(destination)
+        node << services_node(services) unless services.blank?
+      end
+      xml.to_s
+    end
+
+    def parse_rates_response(response, origin, destination)
+      doc = REXML::Document.new(REXML::Text::unnormalize(response))
+      raise ActiveShipping::ResponseError, "No Quotes" unless doc.elements['price-quotes']
+
+      quotes = doc.elements['price-quotes'].elements.collect('price-quote') { |node| node }
+      rates = quotes.map do |node|
+        service_name  = node.get_text("service-name").to_s
+        service_code  = node.get_text("service-code").to_s
+        total_price   = node.elements['price-details'].get_text("due").to_s
+        expected_date = expected_date_from_node(node)
+        options = {
+          :service_code   => service_code,
+          :total_price    => total_price,
+          :currency       => 'CAD',
+          :delivery_range => [expected_date, expected_date]
+        }
+        RateEstimate.new(origin, destination, @@name, service_name, options)
+      end
+      CPPWSRateResponse.new(true, "", {}, :rates => rates)
+    end
+
+    # tracking
+
+    def parse_tracking_response(response)
+      doc = REXML::Document.new(REXML::Text::unnormalize(response))
+      raise ActiveShipping::ResponseError, "No Tracking" unless root_node = doc.elements['tracking-detail']
+
+      events = root_node.elements['significant-events'].elements.collect('occurrence') { |node| node }
+
+      shipment_events  = build_tracking_events(events)
+      change_date      = root_node.get_text('changed-expected-date').to_s
+      expected_date    = root_node.get_text('expected-delivery-date').to_s
+      dest_postal_code = root_node.get_text('destination-postal-id').to_s
+      destination      = Location.new(:postal_code => dest_postal_code)
+      origin           = Location.new(origin_hash_for(root_node))
+      options = {
+        :carrier                 => @@name,
+        :service_name            => root_node.get_text('service-name').to_s,
+        :expected_date           => expected_date.blank? ? nil : Date.parse(expected_date),
+        :changed_date            => change_date.blank? ? nil : Date.parse(change_date),
+        :change_reason           => root_node.get_text('changed-expected-delivery-reason').to_s.strip,
+        :destination_postal_code => root_node.get_text('destination-postal-id').to_s,
+        :shipment_events         => shipment_events,
+        :tracking_number         => root_node.get_text('pin').to_s,
+        :origin                  => origin,
+        :destination             => destination,
+        :customer_number         => root_node.get_text('mailed-by-customer-number').to_s
+      }
+
+      CPPWSTrackingResponse.new(true, "", {}, options)
+    end
+
+    def build_tracking_events(events)
+      events.map do |event|
+        date      = event.get_text('event-date').to_s
+        time      = event.get_text('event-time').to_s
+        zone      = event.get_text('event-time-zone').to_s
+        timestamp = DateTime.parse("#{date} #{time} #{zone}")
+        time      = Time.utc(timestamp.utc.year, timestamp.utc.month, timestamp.utc.day, timestamp.utc.hour, timestamp.utc.min, timestamp.utc.sec)
+        message   = event.get_text('event-description').to_s
+        location  = [event.get_text('event-retail-name'), event.get_text('event-site'), event.get_text('event-province')].compact.join(", ")
+        name      = event.get_text('event-identifier').to_s
+        ShipmentEvent.new(name, time, location, message)
+      end
+    end
+
+    # shipping
+
+    # options
+    # :service => 'DOM.EP'
+    # :notification_email
+    # :packing_instructions
+    # :show_postage_rate
+    # :cod, :cod_amount, :insurance, :insurance_amount, :signature_required, :pa18, :pa19, :hfp, :dns, :lad
+    #
+    def build_shipment_request(origin, destination, package, line_items = [], options = {})
+      origin = sanitize_location(origin)
+      destination = sanitize_location(destination)
+
+      xml = XmlNode.new('non-contract-shipment', :xmlns => "http://www.canadapost.ca/ws/ncshipment") do |root_node|
+        root_node << XmlNode.new('delivery-spec') do |node|
+          node << shipment_service_code_node(options)
+          node << shipment_sender_node(origin, options)
+          node << shipment_destination_node(destination, options)
+          options_node = shipment_options_node(options)
+          node << shipment_options_node(options) if options_node && !options_node.children.count.zero?
+          node << shipment_parcel_node(package)
+          node << shipment_notification_node(options)
+          node << shipment_preferences_node(options)
+          node << references_node(options)             # optional > user defined custom notes
+          node << shipment_customs_node(destination, line_items, options)
+          # COD Remittance defaults to sender
+        end
+      end
+      xml.to_s
+    end
+
+    def shipment_service_code_node(options)
+      XmlNode.new('service-code', options[:service])
+    end
+
+    def shipment_sender_node(location, options)
+      XmlNode.new('sender') do |node|
+        node << XmlNode.new('name', location.name)
+        node << XmlNode.new('company', location.company) if location.company.present?
+        node << XmlNode.new('contact-phone', location.phone)
+        node << XmlNode.new('address-details') do |innernode|
+          innernode << XmlNode.new('address-line-1', location.address1)
+          innernode << XmlNode.new('address-line-2', location.address2_and_3) unless location.address2_and_3.blank?
+          innernode << XmlNode.new('city', location.city)
+          innernode << XmlNode.new('prov-state', location.province)
+          # innernode << XmlNode.new('country-code', location.country_code)
+          innernode << XmlNode.new('postal-zip-code', location.postal_code)
+        end
+      end
+    end
+
+    def shipment_destination_node(location, options)
+      XmlNode.new('destination') do |node|
+        node << XmlNode.new('name', location.name)
+        node << XmlNode.new('company', location.company) if location.company.present?
+        node << XmlNode.new('client-voice-number', location.phone)
+        node << XmlNode.new('address-details') do |innernode|
+          innernode << XmlNode.new('address-line-1', location.address1)
+          innernode << XmlNode.new('address-line-2', location.address2_and_3) unless location.address2_and_3.blank?
+          innernode << XmlNode.new('city', location.city)
+          innernode << XmlNode.new('prov-state', location.province) unless location.province.blank?
+          innernode << XmlNode.new('country-code', location.country_code)
+          innernode << XmlNode.new('postal-zip-code', location.postal_code)
+        end
+      end
+    end
+
+    def shipment_options_node(options)
+        shipping_options_node(SHIPPING_OPTIONS, options)
+    end
+
+    def shipment_notification_node(options)
+      return unless options[:notification_email]
+      XmlNode.new('notification') do |node|
+        node << XmlNode.new('email', options[:notification_email])
+        node << XmlNode.new('on-shipment', true)
+        node << XmlNode.new('on-exception', true)
+        node << XmlNode.new('on-delivery', true)
+      end
+    end
+
+    def shipment_preferences_node(options)
+      XmlNode.new('preferences') do |node|
+        node << XmlNode.new('show-packing-instructions', options[:packing_instructions] || true)
+        node << XmlNode.new('show-postage-rate', options[:show_postage_rate] || false)
+        node << XmlNode.new('show-insured-value', true)
+      end
+    end
+
+    def references_node(options)
+      # custom values
+      # XmlNode.new('references') do |node|
+      # end
+    end
+
+    def shipment_customs_node(destination, line_items, options)
+      return unless destination.country_code != 'CA'
+
+      XmlNode.new('customs') do |node|
+        currency = options[:currency] || "CAD"
+        node << XmlNode.new('currency', currency)
+        node << XmlNode.new('conversion-from-cad', options[:conversion_from_cad].to_s) if currency != 'CAD' && options[:conversion_from_cad]
+        node << XmlNode.new('reason-for-export', 'SOG') # SOG - Sale of Goods
+        node << XmlNode.new('other-reason', options[:customs_other_reason]) if options[:customs_reason_for_export] && options[:customs_other_reason]
+        node << XmlNode.new('additional-customs-info', options[:customs_addition_info]) if options[:customs_addition_info]
+        node << XmlNode.new('sku-list') do |sku|
+          line_items.each do |line_item|
+            sku << XmlNode.new('item') do |item|
+              item << XmlNode.new('hs-tariff-code', line_item.hs_code) if line_item.hs_code && !line_item.hs_code.empty?
+              item << XmlNode.new('sku', line_item.sku) if line_item.sku && !line_item.sku.empty?
+              item << XmlNode.new('customs-description', line_item.name.slice(0, 44))
+              item << XmlNode.new('unit-weight', '%#2.3f' % sanitize_weight_kg(line_item.kg))
+              item << XmlNode.new('customs-value-per-unit', '%.2f' % sanitize_price_from_cents(line_item.value))
+              item << XmlNode.new('customs-number-of-units', line_item.quantity)
+              item << XmlNode.new('country-of-origin', line_item.options[:country_of_origin]) if line_item.options && line_item.options[:country_of_origin] && !line_item.options[:country_of_origin].empty?
+              item << XmlNode.new('province-of-origin', line_item.options[:province_of_origin]) if line_item.options && line_item.options[:province_of_origin] && !line_item.options[:province_of_origin].empty?
+            end
+          end
+        end
+
+      end
+    end
+
+    def shipment_parcel_node(package, options = {})
+      weight = sanitize_weight_kg(package.kilograms.to_f)
+      XmlNode.new('parcel-characteristics') do |el|
+        el << XmlNode.new('weight', "%#2.3f" % weight)
+        pkg_dim = package.cm
+        if pkg_dim && !pkg_dim.select { |x| x != 0 }.empty?
+          el << XmlNode.new('dimensions') do |dim|
+            dim << XmlNode.new('length', '%.1f' % ((pkg_dim[2] * 10).round / 10.0)) if pkg_dim.size >= 3
+            dim << XmlNode.new('width', '%.1f' % ((pkg_dim[1] * 10).round / 10.0)) if pkg_dim.size >= 2
+            dim << XmlNode.new('height', '%.1f' % ((pkg_dim[0] * 10).round / 10.0)) if pkg_dim.size >= 1
+          end
+        end
+        el << XmlNode.new('document', false)
+        el << XmlNode.new('mailing-tube', package.tube?)
+        el << XmlNode.new('unpackaged', package.unpackaged?)
+      end
+    end
+
+    def parse_shipment_response(response)
+      doc = REXML::Document.new(REXML::Text::unnormalize(response))
+      raise ActiveShipping::ResponseError, "No Shipping" unless root_node = doc.elements['non-contract-shipment-info']
+      options = {
+        :shipping_id      => root_node.get_text('shipment-id').to_s,
+        :tracking_number  => root_node.get_text('tracking-pin').to_s,
+        :details_url      => root_node.elements["links/link[@rel='details']"].attributes['href'],
+        :label_url        => root_node.elements["links/link[@rel='label']"].attributes['href'],
+        :receipt_url      => root_node.elements["links/link[@rel='receipt']"].attributes['href']
+      }
+      CPPWSShippingResponse.new(true, "", {}, options)
+    end
+
+    def parse_register_token_response(response)
+      doc = REXML::Document.new(REXML::Text::unnormalize(response))
+      raise ActiveShipping::ResponseError, "No Registration Token" unless root_node = doc.elements['token']
+      options = {
+        :token_id => root_node.get_text('token-id').to_s
+      }
+      CPPWSRegisterResponse.new(true, "", {}, options)
+    end
+
+    def parse_merchant_details_response(response)
+      doc = REXML::Document.new(REXML::Text::unnormalize(response))
+      raise "No Merchant Info" unless root_node = doc.elements['merchant-info']
+      raise "No Merchant Info" if root_node.get_text('customer-number').blank?
+      options = {
+        :customer_number => root_node.get_text('customer-number').to_s,
+        :contract_number => root_node.get_text('contract-number').to_s,
+        :username => root_node.get_text('merchant-username').to_s,
+        :password => root_node.get_text('merchant-password').to_s,
+        :has_default_credit_card => root_node.get_text('has-default-credit-card') == 'true'
+      }
+      CPPWSMerchantDetailsResponse.new(true, "", {}, options)
+    end
+
+    def parse_shipment_receipt_response(response)
+      doc = REXML::Document.new(REXML::Text::unnormalize(response))
+      root = doc.elements['non-contract-shipment-receipt']
+      cc_details_node = root.elements['cc-receipt-details']
+      service_standard_node = root.elements['service-standard']
+      receipt = {
+        :final_shipping_point => root.get_text("final-shipping-point").to_s,
+        :shipping_point_name => root.get_text("shipping-point-name").to_s,
+        :service_code => root.get_text("service-code").to_s,
+        :rated_weight => root.get_text("rated-weight").to_s.to_f,
+        :base_amount => root.get_text("base-amount").to_s.to_f,
+        :pre_tax_amount => root.get_text("pre-tax-amount").to_s.to_f,
+        :gst_amount => root.get_text("gst-amount").to_s.to_f,
+        :pst_amount => root.get_text("pst-amount").to_s.to_f,
+        :hst_amount => root.get_text("hst-amount").to_s.to_f,
+        :charge_amount => cc_details_node.get_text("charge-amount").to_s.to_f,
+        :currency => cc_details_node.get_text("currency").to_s,
+        :expected_transit_days => service_standard_node.get_text("expected-transit-time").to_s.to_i,
+        :expected_delivery_date => service_standard_node.get_text("expected-delivery-date").to_s
+      }
+      option_nodes = root.elements['priced-options'].elements.collect('priced-option') { |node| node } unless root.elements['priced-options'].blank?
+
+      receipt[:priced_options] = if option_nodes
+          option_nodes.inject({}) do |result, node|
+          result[node.get_text("option-code").to_s] = node.get_text("option-price").to_s.to_f
+          result
+          end
+      else
+        []
+      end
+
+      receipt
+    end
+
+    def error_response(response, response_klass)
+      doc = REXML::Document.new(REXML::Text::unnormalize(response))
+      messages = doc.elements['messages'].elements.collect('message') { |node| node }
+      message = messages.map { |m| m.get_text('description').to_s }.join(", ")
+      code = messages.map { |m| m.get_text('code').to_s }.join(", ")
+      response_klass.new(false, message, {}, :carrier => @@name, :code => code)
+    end
+
+    def log(msg)
+      logger.debug(msg) if logger
+    end
+
+    private
+
+    def tracking_url(pin)
+      case pin.length
+        when 12, 13, 16
+          endpoint + "vis/track/pin/%s/detail" % pin
+        when 15
+          endpoint + "vis/track/dnc/%s/detail" % pin
+        else
+          raise InvalidPinFormatError
+        end
+    end
+
+    def create_shipment_url(options)
+      raise MissingCustomerNumberError unless customer_number = options[:customer_number]
+      if @platform_id.present?
+        endpoint + "rs/#{customer_number}-#{@platform_id}/ncshipment"
+      else
+        endpoint + "rs/#{customer_number}/ncshipment"
+      end
+    end
+
+    def shipment_url(shipping_id, options = {})
+      raise MissingCustomerNumberError unless customer_number = options[:customer_number]
+      if @platform_id.present?
+        endpoint + "rs/#{customer_number}-#{@platform_id}/ncshipment/#{shipping_id}"
+      else
+        endpoint + "rs/#{customer_number}/ncshipment/#{shipping_id}"
+      end
+    end
+
+    def shipment_receipt_url(shipping_id, options = {})
+      raise MissingCustomerNumberError unless customer_number = options[:customer_number]
+      if @platform_id.present?
+        endpoint + "rs/#{customer_number}-#{@platform_id}/ncshipment/#{shipping_id}/receipt"
+      else
+        endpoint + "rs/#{customer_number}/ncshipment/#{shipping_id}/receipt"
+      end
+    end
+
+    def services_url(country = nil, service_code = nil)
+      url = endpoint + "rs/ship/service"
+      url += "/#{service_code}" if service_code
+      url += "?country=#{country}" if country
+      url
+    end
+
+    def customer_credentials_valid?(credentials)
+      (credentials.keys & [:customer_api_key, :customer_secret]).any?
+    end
+
+    def encoded_authorization(customer_credentials = {})
+      if customer_credentials_valid?(customer_credentials)
+        "Basic %s" % Base64.encode64("#{customer_credentials[:customer_api_key]}:#{customer_credentials[:customer_secret]}")
+      else
+        "Basic %s" % Base64.encode64("#{@options[:api_key]}:#{@options[:secret]}")
+      end
+    end
+
+    def headers(customer_credentials, accept = nil, content_type = nil)
+      headers = {
+        'Authorization'   => encoded_authorization(customer_credentials),
+        'Accept-Language' => language
+      }
+      headers['Accept'] = accept if accept
+      headers['Content-Type'] = content_type if content_type
+      headers['Platform-ID'] = platform_id if platform_id && customer_credentials_valid?(customer_credentials)
+      headers
+    end
+
+    def customer_number_node(options)
+      XmlNode.new("customer-number", options[:customer_number] || customer_number)
+    end
+
+    def contract_id_node(options)
+      XmlNode.new("contract-id", options[:contract_id]) if options[:contract_id]
+    end
+
+    def quote_type_node(options)
+      XmlNode.new("quote-type", 'commercial')
+    end
+
+    def expected_mailing_date_node(date_as_string)
+      XmlNode.new("expected-mailing-date", date_as_string)
+    end
+
+    def parcel_node(line_items, package = nil, options = {})
+      weight = sanitize_weight_kg(package && !package.kilograms.zero? ? package.kilograms.to_f : line_items.sum(&:kilograms).to_f)
+      XmlNode.new('parcel-characteristics') do |el|
+        el << XmlNode.new('weight', "%#2.3f" % weight)
+        if package
+          pkg_dim = package.cm
+          if pkg_dim && !pkg_dim.select { |x| x != 0 }.empty?
+            el << XmlNode.new('dimensions') do |dim|
+              dim << XmlNode.new('length', '%.1f' % ((pkg_dim[2] * 10).round / 10.0)) if pkg_dim.size >= 3
+              dim << XmlNode.new('width', '%.1f' % ((pkg_dim[1] * 10).round / 10.0)) if pkg_dim.size >= 2
+              dim << XmlNode.new('height', '%.1f' % ((pkg_dim[0] * 10).round / 10.0)) if pkg_dim.size >= 1
+            end
+          end
+        end
+        el << XmlNode.new('mailing-tube', line_items.any?(&:tube?))
+        el << XmlNode.new('oversized', true) if line_items.any?(&:oversized?)
+        el << XmlNode.new('unpackaged', line_items.any?(&:unpackaged?))
+      end
+    end
+
+    def origin_node(location)
+      origin = sanitize_location(location)
+      XmlNode.new("origin-postal-code", origin.zip)
+    end
+
+    def destination_node(location)
+      destination = sanitize_location(location)
+      case destination.country_code
+        when 'CA'
+          XmlNode.new('destination') do |node|
+            node << XmlNode.new('domestic') do |x|
+              x << XmlNode.new('postal-code', destination.postal_code)
+            end
+          end
+
+        when 'US'
+          XmlNode.new('destination') do |node|
+            node << XmlNode.new('united-states') do |x|
+              x << XmlNode.new('zip-code', destination.postal_code)
+            end
+          end
+
+        else
+          XmlNode.new('destination') do |dest|
+            dest << XmlNode.new('international') do |dom|
+              dom << XmlNode.new('country-code', destination.country_code)
+            end
+          end
+      end
+    end
+
+    def services_node(services)
+      XmlNode.new('services') do |node|
+        services.each { |code| node << XmlNode.new('service-code', code) }
+      end
+    end
+
+    def shipping_options_node(available_options, options = {})
+      return if (options.symbolize_keys.keys & available_options).empty?
+      XmlNode.new('options') do |el|
+
+        if options[:cod] && options[:cod_amount]
+          el << XmlNode.new('option') do |opt|
+            opt << XmlNode.new('option-code', 'COD')
+            opt << XmlNode.new('option-amount', options[:cod_amount])
+            opt << XmlNode.new('option-qualifier-1', options[:cod_includes_shipping]) unless options[:cod_includes_shipping].blank?
+            opt << XmlNode.new('option-qualifier-2', options[:cod_method_of_payment]) unless options[:cod_method_of_payment].blank?
+          end
+        end
+
+        if options[:cov]
+          el << XmlNode.new('option') do |opt|
+            opt << XmlNode.new('option-code', 'COV')
+            opt << XmlNode.new('option-amount', options[:cov_amount]) unless options[:cov_amount].blank?
+          end
+        end
+
+        if options[:d2po]
+          el << XmlNode.new('option') do |opt|
+            opt << XmlNode.new('option-code', 'D2PO')
+            opt << XmlNode.new('option-qualifier-2'. options[:d2po_office_id]) unless options[:d2po_office_id].blank?
+          end
+        end
+
+        [:so, :dc, :pa18, :pa19, :hfp, :dns, :lad, :rase, :rts, :aban].each do |code|
+          if options[code]
+            el << XmlNode.new('option') do |opt|
+              opt << XmlNode.new('option-code', code.to_s.upcase)
+            end
+          end
+        end
+      end
+    end
+
+    def expected_date_from_node(node)
+      if service = node.elements['service-standard']
+        expected_date = service.get_text("expected-delivery-date").to_s
+      else
+        expected_date = nil
+      end
+      expected_date
+    end
+
+    def shipping_date(options)
+      DateTime.strptime((options[:shipping_date] || Time.now).to_s, "%Y-%m-%d")
+    end
+
+    def sanitize_location(location)
+      location_hash = location.is_a?(Location) ? location.to_hash : location
+      location_hash = sanitize_zip(location_hash)
+      Location.new(location_hash)
+    end
+
+    def sanitize_zip(hash)
+      [:postal_code, :zip].each do |attr|
+        hash[attr].gsub!(/\s+/, '') if hash[attr]
+      end
+      hash
+    end
+
+    def sanitize_weight_kg(kg)
+      kg == 0 ? 0.001 : kg
+    end
+
+    def sanitize_price_from_cents(value)
+      value == 0 ? 0.01 : value.round / 100.0
+    end
+
+    def origin_hash_for(root_node)
+      occurrences = root_node.get_elements('significant-events').first.get_elements('occurrence')
+      earliest = occurrences.sort_by { |occurrence| time_of_occurrence(occurrence) }.first
+
+      {
+        city: earliest.get_text('event-site').to_s,
+        province: earliest.get_text('event-province').to_s,
+        address_1: earliest.get_text('event-retail-location-id').to_s,
+        country: 'Canada'
+      }
+    end
+
+    def time_of_occurrence(occurrence)
+      time = occurrence.get_text('event-time')
+      date = occurrence.get_text('event-date')
+      time_zone = occurrence.get_text('event-date')
+      DateTime.parse "#{date} #{time} #{time_zone}"
+    end
+  end
+
+  module CPPWSErrorResponse
+    attr_accessor :error_code
+    def handle_error(message, options)
+      @error_code = options[:code]
+    end
+  end
+
+  class CPPWSRateResponse < RateResponse
+    include CPPWSErrorResponse
+
+    def initialize(success, message, params = {}, options = {})
+      handle_error(message, options)
+      super
+    end
+  end
+
+  class CPPWSTrackingResponse < TrackingResponse
+    DELIVERED_EVENT_CODES = %w(1496 1498 1499 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438)
+    include CPPWSErrorResponse
+
+    attr_reader :service_name, :expected_date, :changed_date, :change_reason, :customer_number
+
+    def initialize(success, message, params = {}, options = {})
+      handle_error(message, options)
+      super
+      @service_name    = options[:service_name]
+      @expected_date   = options[:expected_date]
+      @changed_date    = options[:changed_date]
+      @change_reason   = options[:change_reason]
+      @customer_number = options[:customer_number]
+    end
+
+    def delivered?
+      !delivered_event.nil?
+    end
+
+    def actual_delivery_time
+      delivered_event.time if delivered?
+    end
+
+    private
+
+    def delivered_event
+      @delivered_event ||= @shipment_events.detect { |event| DELIVERED_EVENT_CODES.include? event.name }
+    end
+  end
+
+  class CPPWSShippingResponse < ShippingResponse
+    include CPPWSErrorResponse
+    attr_reader :label_url, :details_url, :receipt_url
+    def initialize(success, message, params = {}, options = {})
+      handle_error(message, options)
+      super
+      @label_url      = options[:label_url]
+      @details_url    = options[:details_url]
+      @receipt_url    = options[:receipt_url]
+    end
+  end
+
+  class CPPWSRegisterResponse < Response
+    include CPPWSErrorResponse
+    attr_reader :token_id
+    def initialize(success, message, params = {}, options = {})
+      handle_error(message, options)
+      super
+      @token_id = options[:token_id]
+    end
+
+    def redirect_url(customer_id, return_url)
+      "http://www.canadapost.ca/cpotools/apps/drc/merchant?return-url=#{CGI.escape(return_url)}&token-id=#{token_id}&platform-id=#{customer_id}"
+    end
+  end
+
+  class CPPWSMerchantDetailsResponse < Response
+    include CPPWSErrorResponse
+    attr_reader :customer_number, :contract_number, :username, :password, :has_default_credit_card
+    def initialize(success, message, params = {}, options = {})
+      handle_error(message, options)
+      super
+      @customer_number = options[:customer_number]
+      @contract_number = options[:contract_number]
+      @username = options[:username]
+      @password = options[:password]
+      @has_default_credit_card = options[:has_default_credit_card]
+    end
+  end
+
+  class InvalidPinFormatError < StandardError; end
+  class MissingCustomerNumberError < StandardError; end
+  class MissingShippingNumberError < StandardError; end
+  class MissingTokenIdError < StandardError; end
+end