omniship 0.1.0

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Donavan White
+
+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 PURPOa AND
+NONINFRINGEMENT. IN NO EVENT SaALL 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.

data/README.markdown

@@ -0,0 +1,91 @@
+[![Code
+Climate](https://codeclimate.com/badge.png)](https://codeclimate.com/github/Digi-Cazter/omniship)
+
+# Omniship 
+
+This gem is under active development, I'm only in the Alpha stage right now, so keep checking back for updates.
+
+This library has been created to make web requests to common shipping carriers using XML.  I created this to be easy to use with a nice Ruby API.  This code was originally forked from the *Shopify/active_shipping* code, I began to strip it down cause I wan't a cleaner API along with the ability to actually create shipment labels with it.  After changing enough code, I created this gem as its own project since it's different enough.
+
+## Supported Shipping Carriers
+
+* [UPS](http://www.ups.com)
+* [USPS](http://www.usps.com) COMING SOON!
+* [FedEx](http://www.fedex.com) COMING SOON!
+
+## Simple example snippets
+### UPS Code Example ###
+To run in test mode during development, pass :test => true as an option
+into create_shipment and accept_shipment.
+
+	  def create_shipment
+	    # If you have created the omniship.yml config file
+	    @config  = OMNISHIP_CONFIG[Rails.env]['ups']
+	    shipment = create_ups_shipment
+	  end
+
+	  def create_ups_shipment
+	    # If using the yml config
+	    ups = Omniship::UPS.new
+	    # Else just pass in the credentials
+	    ups = Omniship::UPS.new(:login => @user, :password => @password, :key => @key)
+	    send_options = {}
+	    send_options[:origin_account] = @config["account"] # Or just put the shipper account here
+	    send_options[:service]        = "03"
+	    response = ups.create_shipment(origin, destination, package, options = send_options)
+	    return ups.accept_shipment(response)
+	  end
+ 
+	  def origin
+	    address = {}
+	    address[:name]     = "My House"
+	    address[:address1] = "555 Diagonal"
+	    address[:city]     = "Saint George"
+	    address[:state]    = "UT"
+	    address[:zip]      = "84770"
+	    address[:country]  = "USA"
+	    return Omniship::Address.new(address)
+	  end
+
+	  def destination
+	    address = {}
+	    address[:company_name] = "Wal-Mart"
+	    address[:address1]     = "555 Diagonal"
+	    address[:city]         = "Saint George"
+	    address[:state]        = "UT"
+	    address[:zip]          = "84770"
+	    address[:country]      = "USA"
+	    return Omniship::Address.new(address)
+	  end
+
+    def packages
+      # UPS can handle a single package or multiple packages
+      pkg_list = []
+      weight = 1
+      length = 1
+      width  = 1
+      height = 1
+      package_type = "02"
+      pkg_list << Omniship::Package.new(weight.to_i,[length.to_i,width.to_i,height.to_i],:units => :imperial, :package_type => package_type)
+      return pkg_list
+    end
+
+## Tests
+
+Currently this is on my TODO list. Check back for updates
+
+## Contributing
+
+Before anyone starts contributing, I want to get a good stable version going and tests to follow, after I get that going then for the features you add, you should have both unit tests and remote tests. It's probably best to start with the remote tests, and then log those requests and responses and use them as the mocks for the unit tests.
+
+To log requests and responses, just set the `logger` on your carrier class to some kind of `Logger` object:
+
+    Omniship::USPS.logger = Logger.new($stdout)
+
+(This logging functionality is provided by the [`PostsData` module](https://github.com/Shopify/active_utils/blob/master/lib/active_utils/common/posts_data.rb) in the `active_utils` dependency.)
+
+After you've pushed your well-tested changes to your github fork, make a pull request and we'll take it from there!
+
+## Legal Mumbo Jumbo
+
+Unless otherwise noted in specific files, all code in the Omniship project is under the copyright and license described in the included MIT-LICENSE file.

data/lib/omniship/address.rb

@@ -0,0 +1,135 @@
+module Omniship #:nodoc:
+  class Address 
+    ADDRESS_TYPES = %w{residential commercial po_box}
+    
+    attr_reader :options,
+                :country,
+                :postal_code,
+                :province,
+                :city,
+                :name,
+         	      :attention_name,
+                :address1,
+                :address2,
+                :address3,
+                :phone,
+                :fax,
+                :address_type,
+                :company_name
+    
+    alias_method :zip, :postal_code
+    alias_method :postal, :postal_code
+    alias_method :state, :province
+    alias_method :territory, :province
+    alias_method :region, :province
+    alias_method :company, :company_name
+    
+    def initialize(options = {})
+      @country = (options[:country].nil? or options[:country].is_a?(ActiveMerchant::Country)) ?
+                    options[:country] :
+                    ActiveMerchant::Country.find(options[:country])
+      @postal_code = options[:postal_code] || options[:postal] || options[:zip]
+      @province = options[:province] || options[:state] || options[:territory] || options[:region]
+      @city = options[:city]
+      @name = options[:name]
+      @address1 = options[:address1]
+      @address2 = options[:address2]
+      @address3 = options[:address3]
+      @phone = options[:phone]
+      @fax = options[:fax]
+      @company_name = options[:company_name] || options[:company]
+
+      self.address_type = options[:address_type]
+    end
+    
+    def self.from(object, options={})
+      return object if object.is_a? Omniship::Address
+      attr_mappings = {
+        :name => [:name],
+        :country => [:country_code, :country],
+        :postal_code => [:postal_code, :zip, :postal],
+        :province => [:province_code, :state_code, :territory_code, :region_code, :province, :state, :territory, :region],
+        :city => [:city, :town],
+        :address1 => [:address1, :address, :street],
+        :address2 => [:address2],
+        :address3 => [:address3],
+        :phone => [:phone, :phone_number],
+        :fax => [:fax, :fax_number],
+        :address_type => [:address_type],
+        :company_name => [:company, :company_name]
+      }
+      attributes = {}
+      hash_access = begin
+        object[:some_symbol]
+        true
+      rescue
+        false
+      end
+      attr_mappings.each do |pair|
+        pair[1].each do |sym|
+          if value = (object[sym] if hash_access) || (object.send(sym) if object.respond_to?(sym) && (!hash_access || !Hash.public_instance_methods.include?(sym.to_s)))
+            attributes[pair[0]] = value
+            break
+          end
+        end
+      end
+      attributes.delete(:address_type) unless ADDRESS_TYPES.include?(attributes[:address_type].to_s)
+      self.new(attributes.update(options))
+    end
+    
+    def country_code(format = :alpha2)
+      @country.nil? ? nil : @country.code(format).value
+    end
+    
+    def residential?; @address_type == 'residential' end
+    def commercial?; @address_type == 'commercial' end
+    def po_box?; @address_type == 'po_box' end
+
+    def address_type=(value)
+      return unless value.present?
+      raise ArgumentError.new("address_type must be one of #{ADDRESS_TYPES.join(', ')}") unless ADDRESS_TYPES.include?(value.to_s)
+      @address_type = value.to_s
+    end
+
+    def to_hash
+      {
+        :country => country_code,
+        :postal_code => postal_code,
+        :province => province,
+        :city => city,
+        :name => name,
+        :address1 => address1,
+        :address2 => address2,
+        :address3 => address3,
+        :phone => phone,
+        :fax => fax,
+        :address_type => address_type,
+        :company_name => company_name
+      }
+    end
+
+    def to_xml(options={})
+      options[:root] ||= "address"
+      to_hash.to_xml(options)
+    end
+
+    def to_s
+      prettyprint.gsub(/\n/, ' ')
+    end
+    
+    def prettyprint
+      chunks = []
+      chunks << [@name, @address1,@address2,@address3].reject {|e| e.blank?}.join("\n")
+      chunks << [@city,@province,@postal_code].reject {|e| e.blank?}.join(', ')
+      chunks << @country
+      chunks.reject {|e| e.blank?}.join("\n")
+    end
+    
+    def inspect
+      string = prettyprint
+      string << "\nPhone: #{@phone}" unless @phone.blank?
+      string << "\nFax: #{@fax}" unless @fax.blank?
+      string
+    end
+  end
+end

data/lib/omniship/base.rb

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

data/lib/omniship/carrier.rb

@@ -0,0 +1,69 @@
+module Omniship 
+  class Carrier
+    
+    include ActiveMerchant::RequiresParameters
+    include ActiveMerchant::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]
+			@config = Omniship.setup
+    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 Omniship::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
+      Address.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

data/lib/omniship/carriers/fedex.rb

@@ -0,0 +1,330 @@
+# FedEx module by Jimmy Baker
+# http://github.com/jimmyebaker
+
+module Omniship
+  # :key is your developer API key
+  # :password is your API password
+  # :account is your FedEx account number
+  # :login is your meter number
+  class FedEx < Carrier
+    self.retry_safe = true
+    
+    cattr_reader :name
+    @@name = "FedEx"
+    
+    TEST_URL = 'https://gatewaybeta.fedex.com:443/xml'
+    LIVE_URL = 'https://gateway.fedex.com:443/xml'
+    
+    CarrierCodes = {
+      "fedex_ground" => "FDXG",
+      "fedex_express" => "FDXE"
+    }
+    
+    ServiceTypes = {
+      "PRIORITY_OVERNIGHT" => "FedEx Priority Overnight",
+      "PRIORITY_OVERNIGHT_SATURDAY_DELIVERY" => "FedEx Priority Overnight Saturday Delivery",
+      "FEDEX_2_DAY" => "FedEx 2 Day",
+      "FEDEX_2_DAY_SATURDAY_DELIVERY" => "FedEx 2 Day Saturday Delivery",
+      "STANDARD_OVERNIGHT" => "FedEx Standard Overnight",
+      "FIRST_OVERNIGHT" => "FedEx First Overnight",
+      "FIRST_OVERNIGHT_SATURDAY_DELIVERY" => "FedEx First Overnight Saturday Delivery",
+      "FEDEX_EXPRESS_SAVER" => "FedEx Express Saver",
+      "FEDEX_1_DAY_FREIGHT" => "FedEx 1 Day Freight",
+      "FEDEX_1_DAY_FREIGHT_SATURDAY_DELIVERY" => "FedEx 1 Day Freight Saturday Delivery",
+      "FEDEX_2_DAY_FREIGHT" => "FedEx 2 Day Freight",
+      "FEDEX_2_DAY_FREIGHT_SATURDAY_DELIVERY" => "FedEx 2 Day Freight Saturday Delivery",
+      "FEDEX_3_DAY_FREIGHT" => "FedEx 3 Day Freight",
+      "FEDEX_3_DAY_FREIGHT_SATURDAY_DELIVERY" => "FedEx 3 Day Freight Saturday Delivery",
+      "INTERNATIONAL_PRIORITY" => "FedEx International Priority",
+      "INTERNATIONAL_PRIORITY_SATURDAY_DELIVERY" => "FedEx International Priority Saturday Delivery",
+      "INTERNATIONAL_ECONOMY" => "FedEx International Economy",
+      "INTERNATIONAL_FIRST" => "FedEx International First",
+      "INTERNATIONAL_PRIORITY_FREIGHT" => "FedEx International Priority Freight",
+      "INTERNATIONAL_ECONOMY_FREIGHT" => "FedEx International Economy Freight",
+      "GROUND_HOME_DELIVERY" => "FedEx Ground Home Delivery",
+      "FEDEX_GROUND" => "FedEx Ground",
+      "INTERNATIONAL_GROUND" => "FedEx International Ground"
+    }
+
+    PackageTypes = {
+      "fedex_envelope" => "FEDEX_ENVELOPE",
+      "fedex_pak" => "FEDEX_PAK",
+      "fedex_box" => "FEDEX_BOX",
+      "fedex_tube" => "FEDEX_TUBE",
+      "fedex_10_kg_box" => "FEDEX_10KG_BOX",
+      "fedex_25_kg_box" => "FEDEX_25KG_BOX",
+      "your_packaging" => "YOUR_PACKAGING"
+    }
+
+    DropoffTypes = {
+      'regular_pickup' => 'REGULAR_PICKUP',
+      'request_courier' => 'REQUEST_COURIER',
+      'dropbox' => 'DROP_BOX',
+      'business_service_center' => 'BUSINESS_SERVICE_CENTER',
+      'station' => 'STATION'
+    }
+
+    PaymentTypes = {
+      'sender' => 'SENDER',
+      'recipient' => 'RECIPIENT',
+      'third_party' => 'THIRDPARTY',
+      'collect' => 'COLLECT'
+    }
+    
+    PackageIdentifierTypes = {
+      'tracking_number' => 'TRACKING_NUMBER_OR_DOORTAG',
+      'door_tag' => 'TRACKING_NUMBER_OR_DOORTAG',
+      'rma' => 'RMA',
+      'ground_shipment_id' => 'GROUND_SHIPMENT_ID',
+      'ground_invoice_number' => 'GROUND_INVOICE_NUMBER',
+      'ground_customer_reference' => 'GROUND_CUSTOMER_REFERENCE',
+      'ground_po' => 'GROUND_PO',
+      'express_reference' => 'EXPRESS_REFERENCE',
+      'express_mps_master' => 'EXPRESS_MPS_MASTER'
+    }
+
+    def self.service_name_for_code(service_code)
+      ServiceTypes[service_code] || begin
+        name = service_code.downcase.split('_').collect{|word| word.capitalize }.join(' ')
+        "FedEx #{name.sub(/Fedex /, '')}"
+      end
+    end
+    
+    def requirements
+      [:key, :password, :account, :login]
+    end
+    
+    def find_rates(origin, destination, packages, options = {})
+      options = @options.update(options)
+      packages = Array(packages)
+      
+      rate_request = build_rate_request(origin, destination, packages, options)
+      
+      response = commit(save_request(rate_request), (options[:test] || false)).gsub(/<(\/)?.*?\:(.*?)>/, '<\1\2>')
+      
+      parse_rate_response(origin, destination, packages, response, options)
+    end
+    
+    def find_tracking_info(tracking_number, options={})
+      options = @options.update(options)
+      
+      tracking_request = build_tracking_request(tracking_number, options)
+      response = commit(save_request(tracking_request), (options[:test] || false)).gsub(/<(\/)?.*?\:(.*?)>/, '<\1\2>')
+      parse_tracking_response(response, options)
+    end
+    
+    protected
+    def build_rate_request(origin, destination, packages, options={})
+      imperial = ['US','LR','MM'].include?(origin.country_code(:alpha2))
+
+      xml_request = XmlNode.new('RateRequest', 'xmlns' => 'http://fedex.com/ws/rate/v6') do |root_node|
+        root_node << build_request_header
+
+        # Version
+        root_node << XmlNode.new('Version') do |version_node|
+          version_node << XmlNode.new('ServiceId', 'crs')
+          version_node << XmlNode.new('Major', '6')
+          version_node << XmlNode.new('Intermediate', '0')
+          version_node << XmlNode.new('Minor', '0')
+        end
+        
+        # Returns delivery dates
+        root_node << XmlNode.new('ReturnTransitAndCommit', true)
+        # Returns saturday delivery shipping options when available
+        root_node << XmlNode.new('VariableOptions', 'SATURDAY_DELIVERY')
+        
+        root_node << XmlNode.new('RequestedShipment') do |rs|
+          rs << XmlNode.new('ShipTimestamp', Time.now)
+          rs << XmlNode.new('DropoffType', options[:dropoff_type] || 'REGULAR_PICKUP')
+          rs << XmlNode.new('PackagingType', options[:packaging_type] || 'YOUR_PACKAGING')
+          
+          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
+          
+          rs << XmlNode.new('RateRequestTypes', 'ACCOUNT')
+          rs << XmlNode.new('PackageCount', packages.size)
+          packages.each do |pkg|
+            rs << XmlNode.new('RequestedPackages') do |rps|
+              rps << 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
+              rps << XmlNode.new('Dimensions') do |dimensions|
+                [: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)
+                end
+                dimensions << XmlNode.new('Units', imperial ? 'IN' : 'CM')
+              end
+            end
+          end
+          
+        end
+      end
+      xml_request.to_s
+    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
+        
+        root_node << XmlNode.new('PackageIdentifier') do |package_node|
+          package_node << XmlNode.new('Value', tracking_number)
+          package_node << XmlNode.new('Type', PackageIdentifierTypes[options['package_identifier_type'] || 'tracking_number'])
+        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)
+      end
+      xml_request.to_s
+    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])
+        end
+      end
+      
+      client_detail = XmlNode.new('ClientDetail') do |cd|
+        cd << XmlNode.new('AccountNumber', @options[:account])
+        cd << XmlNode.new('MeterNumber', @options[:login])
+      end
+      
+      trasaction_detail = XmlNode.new('TransactionDetail') do |td|
+        td << XmlNode.new('CustomerTransactionId', 'ActiveShipping') # TODO: Need to do something better with this..
+      end
+      
+      [web_authentication_detail, client_detail, trasaction_detail]
+    end
+          
+    def build_location_node(name, location)
+      location_node = XmlNode.new(name) do |xml_node|
+        xml_node << XmlNode.new('Address') do |address_node|
+          address_node << XmlNode.new('PostalCode', location.postal_code)
+          address_node << XmlNode.new("CountryCode", location.country_code(:alpha2))
+
+          address_node << XmlNode.new("Residential", true) unless location.commercial?
+        end
+      end
+    end
+    
+    def parse_rate_response(origin, destination, packages, response, options)
+      rate_estimates = []
+      success, message = nil
+      
+      xml = REXML::Document.new(response)
+      root_node = xml.elements['RateReply']
+      
+      success = response_success?(xml)
+      message = response_message(xml)
+      
+      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'
+        service_type = is_saturday_delivery ? "#{service_code}_SATURDAY_DELIVERY" : service_code
+        
+        currency = handle_uk_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 => [rated_shipment.get_text('DeliveryTimestamp').to_s] * 2)
+   end
+
+      if rate_estimates.empty?
+        success = false
+        message = "No shipping rates could be found for the destination address" if message.blank?
+      end
+
+      RateResponse.new(success, message, Hash.from_xml(response), :rates => rate_estimates, :xml => response, :request => last_request, :log_xml => options[:log_xml])
+    end
+    
+    def parse_tracking_response(response, options)
+      xml = REXML::Document.new(response)
+      root_node = xml.elements['TrackReply']
+      
+      success = response_success?(xml)
+      message = response_message(xml)
+      
+      if success
+        tracking_number, origin, destination = nil
+        shipment_events = []
+        
+        tracking_details = root_node.elements['TrackDetails']
+        tracking_number = tracking_details.get_text('TrackingNumber').to_s
+        
+        destination_node = tracking_details.elements['DestinationAddress']
+        destination = Address.new(
+              :country =>     destination_node.get_text('CountryCode').to_s,
+              :province =>    destination_node.get_text('StateOrProvinceCode').to_s,
+              :city =>        destination_node.get_text('City').to_s
+            )
+        
+        tracking_details.elements.each('Events') do |event|
+          address  = event.elements['Address']
+
+          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?
+          
+          location = Address.new(:city => city, :state => state, :postal_code => zip_code, :country => country)
+          description = event.get_text('EventDescription').to_s
+          
+          # for now, just assume UTC, even though it probably isn't
+          time = Time.parse("#{event.get_text('Timestamp').to_s}")
+          zoneless_time = Time.utc(time.year, time.month, time.mday, time.hour, time.min, time.sec)
+          
+          shipment_events << ShipmentEvent.new(description, zoneless_time, location)
+        end
+        shipment_events = shipment_events.sort_by(&:time)
+      end
+      
+      TrackingResponse.new(success, message, Hash.from_xml(response),
+        :xml => response,
+        :request => last_request,
+        :shipment_events => shipment_events,
+        :destination => destination,
+        :tracking_number => tracking_number
+      )
+    end
+          
+    def response_status_node(document)
+      document.elements['/*/Notifications/']
+    end
+    
+    def response_success?(document)
+      %w{SUCCESS WARNING NOTE}.include? response_status_node(document).get_text('Severity').to_s
+    end
+    
+    def response_message(document)
+      response_node = response_status_node(document)
+      "#{response_status_node(document).get_text('Severity').to_s} - #{response_node.get_text('Code').to_s}: #{response_node.get_text('Message').to_s}"
+    end
+    
+    def commit(request, test = false)
+      ssl_post(test ? TEST_URL : LIVE_URL, request.gsub("\n",''))        
+    end
+    
+    def handle_uk_currency(currency)
+      currency =~ /UKL/i ? 'GBP' : currency
+    end
+  end
+end