active_shipping 1.0.0.pre4 → 1.0.0

data/lib/active_shipping/carriers/correios.rb

@@ -0,0 +1,285 @@
+# -*- encoding utf-8 -*-
+
+module ActiveShipping
+  class Correios < Carrier
+
+    cattr_reader :name
+    @@name = "Correios do Brasil"
+
+    def find_rates(origin, destination, packages, options = {})
+      options = @options.merge(options)
+
+      request = CorreiosRequest.new(origin, destination, packages, options)
+      response = request.create_response(perform(request.urls))
+
+      response
+    end
+
+    def self.available_services
+      AVAILABLE_SERVICES
+    end
+
+    protected
+
+    DEFAULT_SERVICES = [41106, 40010]
+    AVAILABLE_SERVICES = {
+      41106 => 'PAC sem contrato',
+      41068 => 'PAC com contrato',
+      41300 => 'PAC para grandes formatos',
+      40010 => 'SEDEX sem contrato',
+      40045 => 'SEDEX a Cobrar, sem contrato',
+      40126 => 'SEDEX a Cobrar, com contrato',
+      40215 => 'SEDEX 10, sem contrato',
+      40290 => 'SEDEX Hoje, sem contrato',
+      40096 => 'SEDEX com contrato',
+      40436 => 'SEDEX com contrato',
+      40444 => 'SEDEX com contrato',
+      40568 => 'SEDEX com contrato',
+      40606 => 'SEDEX com contrato',
+      81019 => 'e-SEDEX, com contrato',
+      81027 => 'e-SEDEX Prioritário, com contrato',
+      81035 => 'e-SEDEX Express, com contrato',
+      81868 => '(Grupo 1) e-SEDEX, com contrato',
+      81833 => '(Grupo 2) e-SEDEX, com contrato',
+      81850 => '(Grupo 3) e-SEDEX, com contrato'
+    }.freeze
+
+    def perform(urls)
+      urls.map { |url| ssl_get(url) }
+    end
+
+    class CorreiosRequest
+
+      URL = "http://ws.correios.com.br/calculador/CalcPrecoPrazo.aspx"
+
+      RETURN_TYPE = 'xml'
+      RETURN_INFORMATION_TYPE = {
+        :prices => '1',
+        :time => '2',
+        :prices_and_time => '3'
+      }
+
+      attr_reader :origin, :destination, :urls
+
+      def initialize(origin, destination, packages, options)
+        @options = options
+        @origin = origin
+        @destination = destination
+
+        packages = packages.map do |package|
+          CorreiosPackage.new(package, 1)
+        end
+
+        @params = {
+          company_id: options[:company_id],
+          password: options[:password],
+          service_type: service_type,
+          origin_zip: origin.zip,
+          destination_zip: destination.zip,
+          mao_propria_extra: parse_boolean(options[:mao_propria_extra]),
+          declared_value_extra: parse_currency(options[:declared_value_extra]),
+          delivery_notice_extra: parse_boolean(options[:delivery_notice_extra]),
+          return_type: RETURN_TYPE,
+          return_information: RETURN_INFORMATION_TYPE[:prices]
+        }
+        @urls = packages.map { |package| create_url(package).to_s }
+      end
+
+      def create_response(raw_xmls)
+        correios_response = CorreiosResponse.new(self, raw_xmls)
+        correios_response.rate_response
+      end
+
+      private
+
+      def parse_boolean(param)
+        param ? 'S' : 'N'
+      end
+
+      def parse_currency(param)
+        param.nil? ? '0' : param.to_s.gsub('.', ',')
+      end
+
+      def build_params(package)
+        @params.merge(package.params)
+      end
+
+      def hash_query_string(params)
+        {
+          'nCdEmpresa' => params[:company_id],
+          'sDsSenha' => params[:password],
+          'nCdServico' => params[:service_type],
+          'sCepOrigem' => params[:origin_zip],
+          'sCepDestino' => params[:destination_zip],
+          'nVlPeso' => params[:weight],
+          'nCdFormato' => params[:format],
+          'nVlComprimento' => params[:length],
+          'nVlAltura' => params[:height],
+          'nVlLargura' => params[:width],
+          'nVlDiametro' => params[:diameter],
+          'sCdMaoPropria' => params[:mao_propria_extra],
+          'nVlValorDeclarado' => params[:declared_value_extra],
+          'sCdAvisoRecebimento' => params[:delivery_notice_extra],
+          'nIndicaCalculo' => params[:return_information],
+          'StrRetorno' => params[:return_type]
+        }
+      end
+
+      def query_string(package)
+        params = build_params(package)
+        hash_query_string(params)
+      end
+
+      def create_url(package)
+        scheme, userinfo, host, port, registry, path, opaque, query, fragment = URI::split(URL)
+
+        query ||= ""
+        query = CGI.parse(query)
+                  .merge(query_string(package))
+                  .to_query
+
+        URI::HTTP.new(scheme, userinfo, host, port, registry, path, opaque, query, fragment)
+      end
+
+      def service_type
+        @options[:services].nil? ? DEFAULT_SERVICES.join(',') : @options[:services].join(',')
+      end
+
+    end
+
+    class CorreiosRateResponse < ActiveShipping::RateResponse
+      attr_reader :raw_responses, :urls
+
+      def initialize(success, message, params = {}, options = {})
+        @raw_responses = options[:raw_responses]
+        @urls = options[:urls]
+        super
+      end
+    end
+
+    class CorreiosResponse
+
+      def initialize(request, raw_xmls)
+        @request = request
+        @raw_xmls = raw_xmls
+        @documents = raw_xmls.map { |xml| Nokogiri::XML(xml) }
+      end
+
+      def rate_response
+        @rates = rates
+        CorreiosRateResponse.new(true, nil, params_options, response_options)
+      rescue => error
+        CorreiosRateResponse.new(false, error.message, {}, response_options)
+      end
+
+      private
+
+      def response_options
+        {
+          :rates => @rates,
+          :raw_responses => @raw_xmls,
+          :urls => @request.urls
+        }
+      end
+
+      def params_options
+        { :responses => @documents }
+      end
+
+      def normalized_services
+        services = @documents.map { |document| document.root.elements }.flatten
+        services = services.group_by do |service_xml|
+          raise(error_message(service_xml)) if error?(service_xml)
+          service_code(service_xml)
+        end
+      end
+
+      def rates_array
+        services = normalized_services.map do |service_id, elements|
+          total_price = elements.sum { |element| price(element) }
+          { :service_code => service_id, :total_price => total_price, :currency => "BRL" }
+        end
+      end
+
+      def rates
+        rates_array.map { |rate_hash| create_rate_estimate(rate_hash) }
+      end
+
+      def create_rate_estimate(rate_hash)
+        RateEstimate.new(@request.origin, @request.destination, Correios.name, AVAILABLE_SERVICES[rate_hash[:service_code]], rate_hash)
+      end
+
+      def error?(xml_item)
+        error_id = error_id(xml_item)
+        !error_id.empty? && error_id != "0"
+      end
+
+      def error_id(xml_item)
+        xml_item.css('Erro').text
+      end
+
+      def error_message(xml_item)
+        xml_item.css('MsgErro').text
+      end
+
+      def service_code(xml_item)
+         xml_item.css('Codigo').text.to_i
+      end
+
+      def price(xml_item)
+        xml_item.css('Valor').text.gsub(',', '.').to_f
+      end
+
+    end
+
+    class CorreiosPackage
+      attr_reader :params
+
+      FORMAT = {
+        :package => 1,
+        :roll => 2,
+        :envelope => 3
+      }
+
+      def initialize(package, format)
+        @package = package
+
+        @params = {
+          :format => format,
+          :weight => weight,
+          :width => width,
+          :length => length,
+          :height => height(format),
+          :diameter => diameter
+        }
+      end
+
+      private
+
+      def weight
+        @package.kg
+      end
+
+      def width
+        @package.cm(:width)
+      end
+
+      def length
+        @package.cm(:length)
+      end
+
+      def height(format)
+        return 0 if format == FORMAT[:envelope]
+        return diameter if @package.cylinder?
+        @package.cm(:height)
+      end
+
+      def diameter
+        return 0 unless @package.cylinder?
+        @package.cm(:width)
+      end
+
+    end
+
+  end
+end

data/lib/active_shipping/carriers/fedex.rb

@@ -1,12 +1,9 @@
-# FedEx module by Jimmy Baker
-# http://github.com/jimmyebaker
-
-require 'date'
 module ActiveShipping
-  # :key is your developer API key
-  # :password is your API password
-  # :account is your FedEx account number
-  # :login is your meter number
+
+  # FedEx carrier implementation.
+  #
+  # FedEx module by Jimmy Baker (http://github.com/jimmyebaker)
+  # Documentation can be found here: http://images.fedex.com/us/developer/product/WebServices/MyWebHelp/PropDevGuide.pdf
   class FedEx < Carrier
     self.retry_safe = true
 
@@ -87,7 +84,8 @@ module ActiveShipping
       'ground_customer_reference' => 'GROUND_CUSTOMER_REFERENCE',
       'ground_po' => 'GROUND_PO',
       'express_reference' => 'EXPRESS_REFERENCE',
-      'express_mps_master' => 'EXPRESS_MPS_MASTER'
+      'express_mps_master' => 'EXPRESS_MPS_MASTER',
+      'shipper_reference' => 'SHIPPER_REFERENCE',
     }
 
     TRANSIT_TIMES = %w(UNKNOWN ONE_DAY TWO_DAYS THREE_DAYS FOUR_DAYS FIVE_DAYS SIX_DAYS SEVEN_DAYS EIGHT_DAYS NINE_DAYS TEN_DAYS ELEVEN_DAYS TWELVE_DAYS THIRTEEN_DAYS FOURTEEN_DAYS FIFTEEN_DAYS SIXTEEN_DAYS SEVENTEEN_DAYS EIGHTEEN_DAYS)
@@ -143,9 +141,8 @@ module ActiveShipping
       rate_request = build_rate_request(origin, destination, packages, options)
 
       xml = commit(save_request(rate_request), (options[:test] || false))
-      response = remove_version_prefix(xml)
 
-      parse_rate_response(origin, destination, packages, response, options)
+      parse_rate_response(origin, destination, packages, xml, options)
     end
 
     def find_tracking_info(tracking_number, options = {})
@@ -153,8 +150,7 @@ module ActiveShipping
 
       tracking_request = build_tracking_request(tracking_number, options)
       xml = commit(save_request(tracking_request), (options[:test] || false))
-      response = remove_version_prefix(xml)
-      parse_tracking_response(response, options)
+      parse_tracking_response(xml, options)
     end
 
     protected
@@ -162,90 +158,90 @@ module ActiveShipping
     def build_rate_request(origin, destination, packages, options = {})
       imperial = %w(US LR MM).include?(origin.country_code(:alpha2))
 
-      xml_request = XmlNode.new('RateRequest', 'xmlns' => 'http://fedex.com/ws/rate/v13') do |root_node|
-        root_node << build_request_header
-        root_node << build_version_node
+      xml_builder = Nokogiri::XML::Builder.new do |xml|
+        xml.RateRequest(xmlns: 'http://fedex.com/ws/rate/v13') do
+          build_request_header(xml)
+          build_version_node(xml, 'crs', 13, 0 ,0)
 
-        # Returns delivery dates
-        root_node << XmlNode.new('ReturnTransitAndCommit', true)
-        # Returns saturday delivery shipping options when available
-        root_node << XmlNode.new('VariableOptions', 'SATURDAY_DELIVERY')
+          # Returns delivery dates
+          xml.ReturnTransitAndCommit(true)
 
-        root_node << XmlNode.new('RequestedShipment') do |rs|
-          rs << XmlNode.new('ShipTimestamp', ship_timestamp(options[:turn_around_time]))
+          # Returns saturday delivery shipping options when available
+          xml.VariableOptions('SATURDAY_DELIVERY')
 
-          freight = has_freight?(options)
+          xml.RequestedShipment do
+            xml.ShipTimestamp(ship_timestamp(options[:turn_around_time]).iso8601(0))
 
-          unless freight
-            # fedex api wants this up here otherwise request returns an error
-            rs << XmlNode.new('DropoffType', options[:dropoff_type] || 'REGULAR_PICKUP')
-            rs << XmlNode.new('PackagingType', options[:packaging_type] || 'YOUR_PACKAGING')
-          end
-
-          rs << build_location_node('Shipper', (options[:shipper] || origin))
-          rs << build_location_node('Recipient', destination)
-          if options[:shipper] and options[:shipper] != origin
-            rs << build_location_node('Origin', origin)
-          end
+            freight = has_freight?(options)
 
-          if freight
-            # build xml for freight rate requests
-            freight_options = options[:freight]
-            rs << build_shipping_charges_payment_node(freight_options)
-            rs << build_freight_shipment_detail_node(freight_options, packages, imperial)
-            rs << build_rate_request_types_node
-          else
-            # build xml for non-freight rate requests
-            rs << XmlNode.new('SmartPostDetail') do |spd|
-              spd << XmlNode.new('Indicia', options[:smart_post_indicia] || 'PARCEL_SELECT')
-              spd << XmlNode.new('HubId', options[:smart_post_hub_id] || 5902) # default to LA
+            unless freight
+              # fedex api wants this up here otherwise request returns an error
+              xml.DropoffType(options[:dropoff_type] || 'REGULAR_PICKUP')
+              xml.PackagingType(options[:packaging_type] || 'YOUR_PACKAGING')
             end
 
-            rs << build_rate_request_types_node
-            rs << XmlNode.new('PackageCount', packages.size)
-            rs << build_packages_nodes(packages, imperial)
+            build_location_node(xml, 'Shipper', options[:shipper] || origin)
+            build_location_node(xml, 'Recipient', destination)
+            if options[:shipper] && options[:shipper] != origin
+              build_location_node(xml, 'Origin', origin)
+            end
 
+            if freight
+              freight_options = options[:freight]
+              build_shipping_charges_payment_node(xml, freight_options)
+              build_freight_shipment_detail_node(xml, freight_options, packages, imperial)
+              build_rate_request_types_node(xml)
+            else
+              xml.SmartPostDetail do
+                xml.Indicia(options[:smart_post_indicia] || 'PARCEL_SELECT')
+                xml.HubId(options[:smart_post_hub_id] || 5902) # default to LA
+              end
+
+              build_rate_request_types_node(xml)
+              xml.PackageCount(packages.size)
+              build_packages_nodes(xml, packages, imperial)
+            end
           end
         end
       end
-      xml_request.to_s
+      xml_builder.to_xml
     end
 
-    def build_packages_nodes(packages, imperial)
+    def build_packages_nodes(xml, packages, imperial)
       packages.map do |pkg|
-        XmlNode.new('RequestedPackageLineItems') do |rps|
-          rps << XmlNode.new('GroupPackageCount', 1)
-          rps << build_package_weight_node(pkg, imperial)
-          rps << build_package_dimensions_node(pkg, imperial)
+        xml.RequestedPackageLineItems do
+          xml.GroupPackageCount(1)
+          build_package_weight_node(xml, pkg, imperial)
+          build_package_dimensions_node(xml, pkg, imperial)
         end
       end
     end
 
-    def build_shipping_charges_payment_node(freight_options)
-      XmlNode.new('ShippingChargesPayment') do |shipping_charges_payment|
-        shipping_charges_payment << XmlNode.new('PaymentType', freight_options[:payment_type])
-        shipping_charges_payment << XmlNode.new('Payor') do |payor|
-          payor << XmlNode.new('ResponsibleParty') do |responsible_party|
+    def build_shipping_charges_payment_node(xml, freight_options)
+      xml.ShippingChargesPayment do
+        xml.PaymentType(freight_options[:payment_type])
+        xml.Payor do
+          xml.ResponsibleParty do
             # TODO: case of different freight account numbers?
-            responsible_party << XmlNode.new('AccountNumber', freight_options[:account])
+            xml.AccountNumber(freight_options[:account])
           end
         end
       end
     end
 
-    def build_freight_shipment_detail_node(freight_options, packages, imperial)
-      XmlNode.new('FreightShipmentDetail') do |freight_shipment_detail|
+    def build_freight_shipment_detail_node(xml, freight_options, packages, imperial)
+      xml.FreightShipmentDetail do
         # TODO: case of different freight account numbers?
-        freight_shipment_detail << XmlNode.new('FedExFreightAccountNumber', freight_options[:account])
-        freight_shipment_detail << build_location_node('FedExFreightBillingContactAndAddress', freight_options[:billing_location])
-        freight_shipment_detail << XmlNode.new('Role', freight_options[:role])
+        xml.FedExFreightAccountNumber(freight_options[:account])
+        build_location_node(xml, 'FedExFreightBillingContactAndAddress', freight_options[:billing_location])
+        xml.Role(freight_options[:role])
 
         packages.each do |pkg|
-          freight_shipment_detail << XmlNode.new('LineItems') do |line_items|
-            line_items << XmlNode.new('FreightClass', freight_options[:freight_class])
-            line_items << XmlNode.new('Packaging', freight_options[:packaging])
-            line_items << build_package_weight_node(pkg, imperial)
-            line_items << build_package_dimensions_node(pkg, imperial)
+          xml.LineItems do
+            xml.FreightClass(freight_options[:freight_class])
+            xml.Packaging(freight_options[:packaging])
+            build_package_weight_node(xml, pkg, imperial)
+            build_package_dimensions_node(xml, pkg, imperial)
           end
         end
       end
@@ -255,125 +251,116 @@ module ActiveShipping
       options[:freight] && options[:freight].present?
     end
 
-    def build_package_weight_node(pkg, imperial)
-      XmlNode.new('Weight') do |tw|
-        tw << XmlNode.new('Units', imperial ? 'LB' : 'KG')
-        tw << XmlNode.new('Value', [((imperial ? pkg.lbs : pkg.kgs).to_f * 1000).round / 1000.0, 0.1].max)
-      end
-    end
-
-    def build_version_node
-      XmlNode.new('Version') do |version_node|
-        version_node << XmlNode.new('ServiceId', 'crs')
-        version_node << XmlNode.new('Major', '13')
-        version_node << XmlNode.new('Intermediate', '0')
-        version_node << XmlNode.new('Minor', '0')
+    def build_package_weight_node(xml, pkg, imperial)
+      xml.Weight do
+        xml.Units(imperial ? 'LB' : 'KG')
+        xml.Value([((imperial ? pkg.lbs : pkg.kgs).to_f * 1000).round / 1000.0, 0.1].max)
       end
     end
 
-    def build_package_dimensions_node(pkg, imperial)
-      XmlNode.new('Dimensions') do |dimensions|
+    def build_package_dimensions_node(xml, pkg, imperial)
+      xml.Dimensions do
         [:length, :width, :height].each do |axis|
           value = ((imperial ? pkg.inches(axis) : pkg.cm(axis)).to_f * 1000).round / 1000.0 # 3 decimals
-          dimensions << XmlNode.new(axis.to_s.capitalize, value.ceil)
+          xml.public_send(axis.to_s.capitalize, value.ceil)
         end
-        dimensions << XmlNode.new('Units', imperial ? 'IN' : 'CM')
+        xml.Units(imperial ? 'IN' : 'CM')
       end
     end
 
-    def build_rate_request_types_node(type = 'ACCOUNT')
-      XmlNode.new('RateRequestTypes', type)
+    def build_rate_request_types_node(xml, type = 'ACCOUNT')
+      xml.RateRequestTypes(type)
     end
 
     def build_tracking_request(tracking_number, options = {})
-      xml_request = XmlNode.new('TrackRequest', 'xmlns' => 'http://fedex.com/ws/track/v3') do |root_node|
-        root_node << build_request_header
-
-        # Version
-        root_node << XmlNode.new('Version') do |version_node|
-          version_node << XmlNode.new('ServiceId', 'trck')
-          version_node << XmlNode.new('Major', '3')
-          version_node << XmlNode.new('Intermediate', '0')
-          version_node << XmlNode.new('Minor', '0')
-        end
+      xml_builder = Nokogiri::XML::Builder.new do |xml|
+        xml.TrackRequest(xmlns: 'http://fedex.com/ws/track/v7') do
+          build_request_header(xml)
+          build_version_node(xml, 'trck', 7, 0, 0)
+
+          xml.SelectionDetails do
+            xml.PackageIdentifier do
+              xml.Type(PACKAGE_IDENTIFIER_TYPES[options[:package_identifier_type] || 'tracking_number'])
+              xml.Value(tracking_number)
+            end
 
-        root_node << XmlNode.new('PackageIdentifier') do |package_node|
-          package_node << XmlNode.new('Value', tracking_number)
-          package_node << XmlNode.new('Type', PACKAGE_IDENTIFIER_TYPES[options['package_identifier_type'] || 'tracking_number'])
-        end
+            xml.ShipDateRangeBegin(options[:ship_date_range_begin])         if options[:ship_date_range_begin]
+            xml.ShipDateRangeEnd(options[:ship_date_range_end])             if options[:ship_date_range_end]
+            xml.TrackingNumberUniqueIdentifier(options[:unique_identifier]) if options[:unique_identifier]
+          end
 
-        root_node << XmlNode.new('ShipDateRangeBegin', options['ship_date_range_begin']) if options['ship_date_range_begin']
-        root_node << XmlNode.new('ShipDateRangeEnd', options['ship_date_range_end']) if options['ship_date_range_end']
-        root_node << XmlNode.new('IncludeDetailedScans', 1)
+          xml.ProcessingOptions('INCLUDE_DETAILED_SCANS')
+        end
       end
-      xml_request.to_s
+      xml_builder.to_xml
     end
 
-    def build_request_header
-      web_authentication_detail = XmlNode.new('WebAuthenticationDetail') do |wad|
-        wad << XmlNode.new('UserCredential') do |uc|
-          uc << XmlNode.new('Key', @options[:key])
-          uc << XmlNode.new('Password', @options[:password])
+    def build_request_header(xml)
+      xml.WebAuthenticationDetail do
+        xml.UserCredential do
+          xml.Key(@options[:key])
+          xml.Password(@options[:password])
         end
       end
 
-      client_detail = XmlNode.new('ClientDetail') do |cd|
-        cd << XmlNode.new('AccountNumber', @options[:account])
-        cd << XmlNode.new('MeterNumber', @options[:login])
+      xml.ClientDetail do
+        xml.AccountNumber(@options[:account])
+        xml.MeterNumber(@options[:login])
       end
 
-      trasaction_detail = XmlNode.new('TransactionDetail') do |td|
-        td << XmlNode.new('CustomerTransactionId', @options[:transaction_id] || 'ActiveShipping') # TODO: Need to do something better with this..
+      xml.TransactionDetail do
+        xml.CustomerTransactionId(@options[:transaction_id] || 'ActiveShipping') # TODO: Need to do something better with this...
       end
-
-      [web_authentication_detail, client_detail, trasaction_detail]
     end
 
-    def build_location_node(name, location)
-      XmlNode.new(name) do |xml_node|
-        xml_node << XmlNode.new('Address') do |address_node|
-          address_node << XmlNode.new('StreetLines', location.address1) if location.address1
-          address_node << XmlNode.new('StreetLines', location.address2) if location.address2
-          address_node << XmlNode.new('City', location.city) if location.city
-          address_node << XmlNode.new('PostalCode', location.postal_code)
-          address_node << XmlNode.new("CountryCode", location.country_code(:alpha2))
+    def build_version_node(xml, service_id, major, intermediate, minor)
+      xml.Version do
+        xml.ServiceId(service_id)
+        xml.Major(major)
+        xml.Intermediate(intermediate)
+        xml.Minor(minor)
+      end
+    end
 
-          address_node << XmlNode.new("Residential", true) unless location.commercial?
+    def build_location_node(xml, name, location)
+      xml.public_send(name) do
+        xml.Address do
+          xml.StreetLines(location.address1) if location.address1
+          xml.StreetLines(location.address2) if location.address2
+          xml.City(location.city) if location.city
+          xml.PostalCode(location.postal_code)
+          xml.CountryCode(location.country_code(:alpha2))
+          xml.Residential(true) unless location.commercial?
         end
       end
     end
 
     def parse_rate_response(origin, destination, packages, response, options)
-      rate_estimates = []
-
-      xml = build_document(response)
-      root_node = xml.elements['RateReply']
+      xml = build_document(response, 'RateReply')
 
       success = response_success?(xml)
       message = response_message(xml)
 
-      raise ActiveShipping::ResponseContentError.new(StandardError.new('Invalid document'), xml) unless root_node
-
-      root_node.elements.each('RateReplyDetails') do |rated_shipment|
-        service_code = rated_shipment.get_text('ServiceType').to_s
-        is_saturday_delivery = rated_shipment.get_text('AppliedOptions').to_s == 'SATURDAY_DELIVERY'
+      rate_estimates = xml.root.css('> RateReplyDetails').map do |rated_shipment|
+        service_code = rated_shipment.at('ServiceType').text
+        is_saturday_delivery = rated_shipment.at('AppliedOptions').try(:text) == 'SATURDAY_DELIVERY'
         service_type = is_saturday_delivery ? "#{service_code}_SATURDAY_DELIVERY" : service_code
 
-        transit_time = rated_shipment.get_text('TransitTime').to_s if service_code == "FEDEX_GROUND"
-        max_transit_time = rated_shipment.get_text('MaximumTransitTime').to_s if service_code == "FEDEX_GROUND"
+        transit_time = rated_shipment.at('TransitTime').text if service_code == "FEDEX_GROUND"
+        max_transit_time = rated_shipment.at('MaximumTransitTime').try(:text) if service_code == "FEDEX_GROUND"
 
-        delivery_timestamp = rated_shipment.get_text('DeliveryTimestamp').to_s
+        delivery_timestamp = rated_shipment.at('DeliveryTimestamp').try(:text)
 
         delivery_range = delivery_range_from(transit_time, max_transit_time, delivery_timestamp, options)
 
-        currency = rated_shipment.get_text('RatedShipmentDetails/ShipmentRateDetail/TotalNetCharge/Currency').to_s
-        rate_estimates << RateEstimate.new(origin, destination, @@name,
-                                           self.class.service_name_for_code(service_type),
-                                           :service_code => service_code,
-                                           :total_price => rated_shipment.get_text('RatedShipmentDetails/ShipmentRateDetail/TotalNetCharge/Amount').to_s.to_f,
-                                           :currency => currency,
-                                           :packages => packages,
-                                           :delivery_range => delivery_range)
+        currency = rated_shipment.at('RatedShipmentDetails/ShipmentRateDetail/TotalNetCharge/Currency').text
+        RateEstimate.new(origin, destination, @@name,
+             self.class.service_name_for_code(service_type),
+             :service_code => service_code,
+             :total_price => rated_shipment.at('RatedShipmentDetails/ShipmentRateDetail/TotalNetCharge/Amount').text.to_f,
+             :currency => currency,
+             :packages => packages,
+             :delivery_range => delivery_range)
       end
 
       if rate_estimates.empty?
@@ -413,8 +400,7 @@ module ActiveShipping
     end
 
     def parse_tracking_response(response, options)
-      xml = build_document(response)
-      root_node = xml.elements['TrackReply']
+      xml = build_document(response, 'TrackReply')
 
       success = response_success?(xml)
       message = response_message(xml)
@@ -424,23 +410,47 @@ module ActiveShipping
         delivery_signature = nil
         shipment_events = []
 
-        tracking_details = root_node.elements['TrackDetails']
-        tracking_number = tracking_details.get_text('TrackingNumber').to_s
-        status_code = tracking_details.get_text('StatusCode').to_s
-        status_description = tracking_details.get_text('StatusDescription').to_s
-        status = TRACKING_STATUS_CODES[status_code]
+        all_tracking_details = xml.root.xpath('CompletedTrackDetails/TrackDetails')
+        tracking_details = case all_tracking_details.length
+          when 1
+            all_tracking_details.first
+          when 0
+            raise ActiveShipping::Error, "The response did not contain tracking details"
+          else
+            all_unique_identifiers = xml.root.xpath('CompletedTrackDetails/TrackDetails/TrackingNumberUniqueIdentifier').map(&:text)
+            raise ActiveShipping::Error, "Multiple matches were found. Specify a unqiue identifier: #{all_unique_identifiers.join(', ')}"
+        end
+
 
-        if status_code == 'DL' && tracking_details.get_text('SignatureProofOfDeliveryAvailable').to_s == 'true'
-          delivery_signature = tracking_details.get_text('DeliverySignatureName').to_s
+        first_notification = tracking_details.at('Notification')
+        if first_notification.at('Severity').text == 'ERROR'
+          case first_notification.at('Code').text
+          when '9040'
+            raise ActiveShipping::ShipmentNotFound, first_notification.at('Message').text
+          else
+            raise ActiveShipping::ResponseContentError, first_notification.at('Message').text
+          end
         end
 
-        origin_node = tracking_details.elements['OriginLocationAddress']
+        tracking_number = tracking_details.at('TrackingNumber').text
+        status_detail = tracking_details.at('StatusDetail')
+        if status_detail.nil?
+          raise ActiveShipping::Error, "Tracking response does not contain status information"
+        end
+
+        status_code = status_detail.at('Code').text
+        status_description = (status_detail.at('AncillaryDetails/ReasonDescription') || status_detail.at('Description')).text
+        status = TRACKING_STATUS_CODES[status_code]
 
-        if origin_node
+        if status_code == 'DL' && tracking_details.at('AvailableImages').try(:text) == 'SIGNATURE_PROOF_OF_DELIVERY'
+          delivery_signature = tracking_details.at('DeliverySignatureName').text
+        end
+
+        if origin_node = tracking_details.at('OriginLocationAddress')
           origin = Location.new(
-                :country =>     origin_node.get_text('CountryCode').to_s,
-                :province =>    origin_node.get_text('StateOrProvinceCode').to_s,
-                :city =>        origin_node.get_text('City').to_s
+                :country =>     origin_node.at('CountryCode').text,
+                :province =>    origin_node.at('StateOrProvinceCode').text,
+                :city =>        origin_node.at('City').text
           )
         end
 
@@ -451,19 +461,19 @@ module ActiveShipping
         actual_delivery_time = extract_timestamp(tracking_details, 'ActualDeliveryTimestamp')
         scheduled_delivery_time = extract_timestamp(tracking_details, 'EstimatedDeliveryTimestamp')
 
-        tracking_details.elements.each('Events') do |event|
-          address  = event.elements['Address']
+        tracking_details.xpath('Events').each do |event|
+          address  = event.at('Address')
+          next if address.nil? || address.at('CountryCode').nil?
 
-          city     = address.get_text('City').to_s
-          state    = address.get_text('StateOrProvinceCode').to_s
-          zip_code = address.get_text('PostalCode').to_s
-          country  = address.get_text('CountryCode').to_s
-          next if country.blank?
+          city     = address.at('City').try(:text)
+          state    = address.at('StateOrProvinceCode').try(:text)
+          zip_code = address.at('PostalCode').try(:text)
+          country  = address.at('CountryCode').try(:text)
 
           location = Location.new(:city => city, :state => state, :postal_code => zip_code, :country => country)
-          description = event.get_text('EventDescription').to_s
+          description = event.at('EventDescription').text
 
-          time          = Time.parse("#{event.get_text('Timestamp').to_s}")
+          time          = Time.parse(event.at('Timestamp').text)
           zoneless_time = time.utc
 
           shipment_events << ShipmentEvent.new(description, zoneless_time, location)
@@ -501,22 +511,17 @@ module ActiveShipping
       (Time.now + delay_in_hours.hours).to_date
     end
 
-    def response_status_node(document)
-      document.elements['/*/Notifications/']
-    end
-
     def response_success?(document)
-      response_node = response_status_node(document)
-      return false if response_node.nil?
-
-      %w(SUCCESS WARNING NOTE).include? response_node.get_text('Severity').to_s
+      highest_severity = document.root.at('HighestSeverity')
+      return false if highest_severity.nil?
+      %w(SUCCESS WARNING NOTE).include?(highest_severity.text)
     end
 
     def response_message(document)
-      response_node = response_status_node(document)
-      return "" if response_node.nil?
+      notifications = document.root.at('Notifications')
+      return "" if notifications.nil?
 
-      "#{response_node.get_text('Severity')} - #{response_node.get_text('Code')}: #{response_node.get_text('Message')}"
+      "#{notifications.at('Severity').text} - #{notifications.at('Code').text}: #{notifications.at('Message').text}"
     end
 
     def commit(request, test = false)
@@ -535,15 +540,15 @@ module ActiveShipping
     def extract_address(document, possible_node_names)
       node = nil
       possible_node_names.each do |name|
-        node ||= document.elements[name]
+        node = document.at(name)
         break if node
       end
 
-      args = if node && node.elements['CountryCode']
+      args = if node && node.at('CountryCode')
         {
-          :country => node.get_text('CountryCode').to_s,
-          :province => node.get_text('StateOrProvinceCode').to_s,
-          :city => node.get_text('City').to_s
+          :country => node.at('CountryCode').text,
+          :province => node.at('StateOrProvinceCode').text,
+          :city => node.at('City').text
         }
       else
         {
@@ -557,22 +562,23 @@ module ActiveShipping
     end
 
     def extract_timestamp(document, node_name)
-      if timestamp_node = document.elements[node_name]
-        Time.parse(timestamp_node.to_s).utc
+      if timestamp_node = document.at(node_name)
+        if timestamp_node.text =~ /\A(\d{4}-\d{2}-\d{2})T00:00:00\Z/
+          Date.parse($1)
+        else
+          Time.parse(timestamp_node.text)
+        end
       end
     end
 
-    def remove_version_prefix(xml)
-      if xml =~ /xmlns:v[0-9]/
-        xml.gsub(/<(\/)?.*?\:(.*?)>/, '<\1\2>')
-      else
-        xml
+    def build_document(xml, expected_root_tag)
+      document = Nokogiri.XML(xml) { |config| config.strict }
+      document.remove_namespaces!
+      if document.root.nil? || document.root.name != expected_root_tag
+        raise ActiveShipping::ResponseContentError.new(StandardError.new('Invalid document'), xml)
       end
-    end
-
-    def build_document(xml)
-      REXML::Document.new(xml)
-    rescue REXML::ParseException => e
+      document
+    rescue Nokogiri::XML::SyntaxError => e
       raise ActiveShipping::ResponseContentError.new(e, xml)
     end
   end