active_shipping 0.0.1

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

@@ -0,0 +1,368 @@
+# -*- encoding: utf-8 -*-
+
+module ActiveMerchant
+  module Shipping
+    class UPS < Carrier
+      self.retry_safe = true
+      
+      cattr_accessor :default_options
+      cattr_reader :name
+      @@name = "UPS"
+      
+      TEST_URL = 'https://wwwcie.ups.com'
+      LIVE_URL = 'https://www.ups.com'
+      
+      RESOURCES = {
+        :rates => 'ups.app/xml/Rate',
+        :track => 'ups.app/xml/Track'
+      }
+      
+      PICKUP_CODES = {
+        :daily_pickup => "01",
+        :customer_counter => "03", 
+        :one_time_pickup => "06",
+        :on_call_air => "07",
+        :suggested_retail_rates => "11",
+        :letter_center => "19",
+        :air_service_center => "20"
+      }
+      
+      DEFAULT_SERVICES = {
+        "01" => "UPS Next Day Air",
+        "02" => "UPS Second Day Air",
+        "03" => "UPS Ground",
+        "07" => "UPS Worldwide Express",
+        "08" => "UPS Worldwide Expedited",
+        "11" => "UPS Standard",
+        "12" => "UPS Three-Day Select",
+        "13" => "UPS Next Day Air Saver",
+        "14" => "UPS Next Day Air Early A.M.",
+        "54" => "UPS Worldwide Express Plus",
+        "59" => "UPS Second Day Air A.M.",
+        "65" => "UPS Saver",
+        "82" => "UPS Today Standard",
+        "83" => "UPS Today Dedicated Courier",
+        "84" => "UPS Today Intercity",
+        "85" => "UPS Today Express",
+        "86" => "UPS Today Express Saver"
+      }
+      
+      CANADA_ORIGIN_SERVICES = {
+        "01" => "UPS Express",
+        "02" => "UPS Expedited",
+        "14" => "UPS Express Early A.M."
+      }
+      
+      MEXICO_ORIGIN_SERVICES = {
+        "07" => "UPS Express",
+        "08" => "UPS Expedited",
+        "54" => "UPS Express Plus"
+      }
+      
+      EU_ORIGIN_SERVICES = {
+        "07" => "UPS Express",
+        "08" => "UPS Expedited"
+      }
+      
+      OTHER_NON_US_ORIGIN_SERVICES = {
+        "07" => "UPS Express"
+      }
+      
+      # From http://en.wikipedia.org/w/index.php?title=European_Union&oldid=174718707 (Current as of November 30, 2007)
+      EU_COUNTRY_CODES = ["GB", "AT", "BE", "BG", "CY", "CZ", "DK", "EE", "FI", "FR", "DE", "GR", "HU", "IE", "IT", "LV", "LT", "LU", "MT", "NL", "PL", "PT", "RO", "SK", "SI", "ES", "SE"]
+      
+      US_TERRITORIES_TREATED_AS_COUNTRIES = ["AS", "FM", "GU", "MH", "MP", "PW", "PR", "VI"]
+      
+      def requirements
+        [:key, :login, :password]
+      end
+      
+      def find_rates(origin, destination, packages, options={})
+        origin, destination = upsified_location(origin), upsified_location(destination)
+        options = @options.merge(options)
+        packages = Array(packages)
+        access_request = build_access_request
+        rate_request = build_rate_request(origin, destination, packages, options)
+        response = commit(:rates, save_request(access_request + rate_request), (options[:test] || false))
+        parse_rate_response(origin, destination, packages, response, options)
+      end
+      
+      def find_tracking_info(tracking_number, options={})
+        options = @options.update(options)
+        access_request = build_access_request
+        tracking_request = build_tracking_request(tracking_number, options)
+        response = commit(:track, save_request(access_request + tracking_request), (options[:test] || false))
+        parse_tracking_response(response, options)
+      end
+      
+      protected
+      
+      def upsified_location(location)
+        if location.country_code == 'US' && US_TERRITORIES_TREATED_AS_COUNTRIES.include?(location.state)
+          atts = {:country => location.state}
+          [:zip, :city, :address1, :address2, :address3, :phone, :fax, :address_type].each do |att|
+            atts[att] = location.send(att)
+          end
+          Location.new(atts)
+        else
+          location
+        end
+      end
+      
+      def build_access_request
+        xml_request = XmlNode.new('AccessRequest') do |access_request|
+          access_request << XmlNode.new('AccessLicenseNumber', @options[:key])
+          access_request << XmlNode.new('UserId', @options[:login])
+          access_request << XmlNode.new('Password', @options[:password])
+        end
+        xml_request.to_s
+      end
+      
+      def build_rate_request(origin, destination, packages, options={})
+        packages = Array(packages)
+        xml_request = XmlNode.new('RatingServiceSelectionRequest') do |root_node|
+          root_node << XmlNode.new('Request') do |request|
+            request << XmlNode.new('RequestAction', 'Rate')
+            request << XmlNode.new('RequestOption', 'Shop')
+            # not implemented: 'Rate' RequestOption to specify a single service query
+            # request << XmlNode.new('RequestOption', ((options[:service].nil? or options[:service] == :all) ? 'Shop' : 'Rate'))
+          end
+          root_node << XmlNode.new('PickupType') do |pickup_type|
+            pickup_type << XmlNode.new('Code', PICKUP_CODES[options[:pickup_type] || :daily_pickup])
+            # not implemented: PickupType/PickupDetails element
+          end
+          # not implemented: CustomerClassification element
+          root_node << XmlNode.new('Shipment') do |shipment|
+            # not implemented: Shipment/Description element
+            shipment << build_location_node('Shipper', (options[:shipper] || origin), options)
+            shipment << build_location_node('ShipTo', destination, options)
+            if options[:shipper] and options[:shipper] != origin
+              shipment << build_location_node('ShipFrom', origin, options)
+            end
+            
+            # not implemented:  * Shipment/ShipmentWeight element
+            #                   * Shipment/ReferenceNumber element                    
+            #                   * Shipment/Service element                            
+            #                   * Shipment/PickupDate element                         
+            #                   * Shipment/ScheduledDeliveryDate element              
+            #                   * Shipment/ScheduledDeliveryTime element              
+            #                   * Shipment/AlternateDeliveryTime element              
+            #                   * Shipment/DocumentsOnly element                      
+            
+            packages.each do |package|
+              debugger if package.nil?
+              
+              
+              imperial = ['US','LR','MM'].include?(origin.country_code(:alpha2))
+              
+              shipment << XmlNode.new("Package") do |package_node|
+                
+                # not implemented:  * Shipment/Package/PackagingType element
+                #                   * Shipment/Package/Description element
+                
+                package_node << XmlNode.new("PackagingType") do |packaging_type|
+                  packaging_type << XmlNode.new("Code", '02')
+                end
+                
+                package_node << XmlNode.new("Dimensions") do |dimensions|
+                  dimensions << XmlNode.new("UnitOfMeasurement") do |units|
+                    units << XmlNode.new("Code", imperial ? 'IN' : 'CM')
+                  end
+                  [:length,:width,:height].each do |axis|
+                    value = ((imperial ? package.inches(axis) : package.cm(axis)).to_f*1000).round/1000.0 # 3 decimals
+                    dimensions << XmlNode.new(axis.to_s.capitalize, [value,0.1].max)
+                  end
+                end
+              
+                package_node << XmlNode.new("PackageWeight") do |package_weight|
+                  package_weight << XmlNode.new("UnitOfMeasurement") do |units|
+                    units << XmlNode.new("Code", imperial ? 'LBS' : 'KGS')
+                  end
+                  
+                  value = ((imperial ? package.lbs : package.kgs).to_f*1000).round/1000.0 # 3 decimals
+                  package_weight << XmlNode.new("Weight", [value,0.1].max)
+                end
+              
+                # not implemented:  * Shipment/Package/LargePackageIndicator element
+                #                   * Shipment/Package/ReferenceNumber element
+                #                   * Shipment/Package/PackageServiceOptions element
+                #                   * Shipment/Package/AdditionalHandling element  
+              end
+              
+            end
+            
+            # not implemented:  * Shipment/ShipmentServiceOptions element
+            #                   * Shipment/RateInformation element
+            
+          end
+          
+        end
+        xml_request.to_s
+      end
+      
+      def build_tracking_request(tracking_number, options={})
+        xml_request = XmlNode.new('TrackRequest') do |root_node|
+          root_node << XmlNode.new('Request') do |request|
+            request << XmlNode.new('RequestAction', 'Track')
+            request << XmlNode.new('RequestOption', '1')
+          end
+          root_node << XmlNode.new('TrackingNumber', tracking_number.to_s)
+        end
+        xml_request.to_s
+      end
+      
+      def build_location_node(name,location,options={})
+        # not implemented:  * Shipment/Shipper/Name element
+        #                   * Shipment/(ShipTo|ShipFrom)/CompanyName element
+        #                   * Shipment/(Shipper|ShipTo|ShipFrom)/AttentionName element
+        #                   * Shipment/(Shipper|ShipTo|ShipFrom)/TaxIdentificationNumber element
+        location_node = XmlNode.new(name) do |location_node|
+          location_node << XmlNode.new('PhoneNumber', location.phone.gsub(/[^\d]/,'')) unless location.phone.blank?
+          location_node << XmlNode.new('FaxNumber', location.fax.gsub(/[^\d]/,'')) unless location.fax.blank?
+          
+          if name == 'Shipper' and (origin_account = @options[:origin_account] || options[:origin_account])
+            location_node << XmlNode.new('ShipperNumber', origin_account)
+          elsif name == 'ShipTo' and (destination_account = @options[:destination_account] || options[:destination_account])
+            location_node << XmlNode.new('ShipperAssignedIdentificationNumber', destination_account)
+          end
+          
+          location_node << XmlNode.new('Address') do |address|
+            address << XmlNode.new("AddressLine1", location.address1) unless location.address1.blank?
+            address << XmlNode.new("AddressLine2", location.address2) unless location.address2.blank?
+            address << XmlNode.new("AddressLine3", location.address3) unless location.address3.blank?
+            address << XmlNode.new("City", location.city) unless location.city.blank?
+            address << XmlNode.new("StateProvinceCode", location.province) unless location.province.blank?
+              # StateProvinceCode required for negotiated rates but not otherwise, for some reason
+            address << XmlNode.new("PostalCode", location.postal_code) unless location.postal_code.blank?
+            address << XmlNode.new("CountryCode", location.country_code(:alpha2)) unless location.country_code(:alpha2).blank?
+            address << XmlNode.new("ResidentialAddressIndicator", true) unless location.commercial? # the default should be that UPS returns residential rates for destinations that it doesn't know about
+            # not implemented: Shipment/(Shipper|ShipTo|ShipFrom)/Address/ResidentialAddressIndicator element
+          end
+        end
+      end
+      
+      def parse_rate_response(origin, destination, packages, response, options={})
+        rates = []
+        
+        xml = REXML::Document.new(response)
+        success = response_success?(xml)
+        message = response_message(xml)
+        
+        if success
+          rate_estimates = []
+          
+          xml.elements.each('/*/RatedShipment') do |rated_shipment|
+            service_code = rated_shipment.get_text('Service/Code').to_s
+            rate_estimates << RateEstimate.new(origin, destination, @@name,
+                                service_name_for(origin, service_code),
+                                :total_price => rated_shipment.get_text('TotalCharges/MonetaryValue').to_s.to_f,
+                                :currency => rated_shipment.get_text('TotalCharges/CurrencyCode').to_s,
+                                :service_code => service_code,
+                                :packages => packages)
+          end
+        end
+        RateResponse.new(success, message, Hash.from_xml(response).values.first, :rates => rate_estimates, :xml => response, :request => last_request)
+      end
+      
+      def parse_tracking_response(response, options={})
+        xml = REXML::Document.new(response)
+        success = response_success?(xml)
+        message = response_message(xml)
+        
+        if success
+          tracking_number, origin, destination = nil
+          shipment_events = []
+          
+          first_shipment = xml.elements['/*/Shipment']
+          first_package = first_shipment.elements['Package']
+          tracking_number = first_shipment.get_text('ShipmentIdentificationNumber | Package/TrackingNumber').to_s
+          
+          origin, destination = %w{Shipper ShipTo}.map do |location|
+            location_from_address_node(first_shipment.elements["#{location}/Address"])
+          end
+          
+          activities = first_package.get_elements('Activity')
+          unless activities.empty?
+            shipment_events = activities.map do |activity|
+              description = activity.get_text('Status/StatusType/Description').to_s
+              zoneless_time = if (time = activity.get_text('Time')) &&
+                                 (date = activity.get_text('Date'))
+                time, date = time.to_s, date.to_s
+                hour, minute, second = time.scan(/\d{2}/)
+                year, month, day = date[0..3], date[4..5], date[6..7]
+                Time.utc(year, month, day, hour, minute, second)
+              end
+              location = location_from_address_node(activity.elements['ActivityLocation/Address'])
+              ShipmentEvent.new(description, zoneless_time, location)
+            end
+            
+            shipment_events = shipment_events.sort_by(&:time)
+            
+            if origin
+              first_event = shipment_events[0]
+              same_country = origin.country_code(:alpha2) == first_event.location.country_code(:alpha2)
+              same_or_blank_city = first_event.location.city.blank? or first_event.location.city == origin.city
+              origin_event = ShipmentEvent.new(first_event.name, first_event.time, origin)
+              if same_country and same_or_blank_city
+                shipment_events[0] = origin_event
+              else
+                shipment_events.unshift(origin_event)
+              end
+            end
+            if shipment_events.last.name.downcase == 'delivered'
+              shipment_events[-1] = ShipmentEvent.new(shipment_events.last.name, shipment_events.last.time, destination)
+            end
+          end
+          
+        end
+        TrackingResponse.new(success, message, Hash.from_xml(response).values.first,
+          :xml => response,
+          :request => last_request,
+          :shipment_events => shipment_events,
+          :origin => origin,
+          :destination => destination,
+          :tracking_number => tracking_number)
+      end
+      
+      def location_from_address_node(address)
+        return nil unless address
+        Location.new(
+                :country =>     node_text_or_nil(address.elements['CountryCode']),
+                :postal_code => node_text_or_nil(address.elements['PostalCode']),
+                :province =>    node_text_or_nil(address.elements['StateProvinceCode']),
+                :city =>        node_text_or_nil(address.elements['City']),
+                :address1 =>    node_text_or_nil(address.elements['AddressLine1']),
+                :address2 =>    node_text_or_nil(address.elements['AddressLine2']),
+                :address3 =>    node_text_or_nil(address.elements['AddressLine3'])
+              )
+      end
+      
+      def response_success?(xml)
+        xml.get_text('/*/Response/ResponseStatusCode').to_s == '1'
+      end
+      
+      def response_message(xml)
+        xml.get_text('/*/Response/ResponseStatusDescription | /*/Response/Error/ErrorDescription').to_s
+      end
+      
+      def commit(action, request, test = false)
+        ssl_post("#{test ? TEST_URL : LIVE_URL}/#{RESOURCES[action]}", request)
+      end
+      
+      
+      def service_name_for(origin, code)
+        origin = origin.country_code(:alpha2)
+        
+        name = case origin
+        when "CA" then CANADA_ORIGIN_SERVICES[code]
+        when "MX" then MEXICO_ORIGIN_SERVICES[code]
+        when *EU_COUNTRY_CODES then EU_ORIGIN_SERVICES[code]
+        end
+        
+        name ||= OTHER_NON_US_ORIGIN_SERVICES[code] unless name == 'US'
+        name ||= DEFAULT_SERVICES[code]
+      end
+      
+    end
+  end
+end

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

@@ -0,0 +1,496 @@
+# -*- encoding: utf-8 -*-
+require 'cgi'
+
+module ActiveMerchant
+  module Shipping
+    
+    # After getting an API login from USPS (looks like '123YOURNAME456'),
+    # run the following test:
+    # 
+    # usps = USPS.new(:login => '123YOURNAME456', :test => true)
+    # usps.valid_credentials?
+    #
+    # This will send a test request to the USPS test servers, which they ask you
+    # to do before they put your API key in production mode.
+    class USPS < Carrier
+      self.retry_safe = true
+      
+      cattr_reader :name
+      @@name = "USPS"
+      
+      LIVE_DOMAIN = 'production.shippingapis.com'
+      LIVE_RESOURCE = 'ShippingAPI.dll'
+      
+      TEST_DOMAINS = { #indexed by security; e.g. TEST_DOMAINS[USE_SSL[:rates]]
+        true => 'secure.shippingapis.com',
+        false => 'testing.shippingapis.com'
+      }
+      
+      TEST_RESOURCE = 'ShippingAPITest.dll'
+      
+      API_CODES = {
+        :us_rates => 'RateV3',
+        :track => 'TrackV2',
+        :world_rates => 'IntlRate',
+        :test => 'CarrierPickupAvailability'
+      }
+      USE_SSL = {
+        :us_rates => false,
+        :world_rates => false,
+        :track => false,
+        :test => true
+      }
+      CONTAINERS = {
+        :envelope => 'Flat Rate Envelope',
+        :box => 'Flat Rate Box'
+      }
+      MAIL_TYPES = {
+        :package => 'Package',
+        :postcard => 'Postcards or aerogrammes',
+        :matter_for_the_blind => 'Matter for the blind',
+        :envelope => 'Envelope'
+      }
+      PACKAGE_PROPERTIES = {
+        'ZipOrigination' => :origin_zip,
+        'ZipDestination' => :destination_zip,
+        'Pounds' => :pounds,
+        'Ounces' => :ounces,
+        'Container' => :container,
+        'Size' => :size,
+        'Machinable' => :machinable,
+        'Zone' => :zone,
+        'Postage' => :postage,
+        'Restrictions' => :restrictions
+      }
+      POSTAGE_PROPERTIES = {
+        'MailService' => :service,
+        'Rate' => :rate
+      }
+      US_SERVICES = {
+        :first_class => 'FIRST CLASS',
+        :priority => 'PRIORITY',
+        :express => 'EXPRESS',
+        :bpm => 'BPM',
+        :parcel => 'PARCEL',
+        :media => 'MEDIA',
+        :library => 'LIBRARY',
+        :all => 'ALL'
+      }
+      
+      # TODO: get rates for "U.S. possessions and Trust Territories" like Guam, etc. via domestic rates API: http://www.usps.com/ncsc/lookups/abbr_state.txt
+      # TODO: figure out how USPS likes to say "Ivory Coast"
+      #
+      # Country names:
+      # http://pe.usps.gov/text/Imm/immctry.htm
+      COUNTRY_NAME_CONVERSIONS = {
+        "BA" => "Bosnia-Herzegovina",
+        "CD" => "Congo, Democratic Republic of the",
+        "CG" => "Congo (Brazzaville),Republic of the",
+        "CI" => "Côte d'Ivoire (Ivory Coast)",
+        "CK" => "Cook Islands (New Zealand)",
+        "FK" => "Falkland Islands",
+        "GB" => "Great Britain and Northern Ireland",
+        "GE" => "Georgia, Republic of",
+        "IR" => "Iran",
+        "KN" => "Saint Kitts (St. Christopher and Nevis)",
+        "KP" => "North Korea (Korea, Democratic People's Republic of)",
+        "KR" => "South Korea (Korea, Republic of)",
+        "LA" => "Laos",
+        "LY" => "Libya",
+        "MC" => "Monaco (France)",
+        "MD" => "Moldova",
+        "MK" => "Macedonia, Republic of",
+        "MM" => "Burma",
+        "PN" => "Pitcairn Island",
+        "RU" => "Russia",
+        "SK" => "Slovak Republic",
+        "TK" => "Tokelau (Union) Group (Western Samoa)",
+        "TW" => "Taiwan",
+        "TZ" => "Tanzania",
+        "VA" => "Vatican City",
+        "VG" => "British Virgin Islands",
+        "VN" => "Vietnam",
+        "WF" => "Wallis and Futuna Islands",
+        "WS" => "Western Samoa"
+      }
+
+      def self.size_code_for(package)
+        total = package.inches(:length) + package.inches(:girth)
+        if total <= 84
+          return 'REGULAR'
+        elsif total <= 108
+          return 'LARGE'
+        else # <= 130
+          return 'OVERSIZE'
+        end
+      end
+      
+      # from info at http://www.usps.com/businessmail101/mailcharacteristics/parcels.htm
+      # 
+      # package.options[:books] -- 25 lb. limit instead of 35 for books or other printed matter.
+      #                             Defaults to false.
+      def self.package_machinable?(package, options={})
+        at_least_minimum =  package.inches(:length) >= 6.0 &&
+                            package.inches(:width) >= 3.0 &&
+                            package.inches(:height) >= 0.25 &&
+                            package.ounces >= 6.0
+        at_most_maximum  =  package.inches(:length) <= 34.0 &&
+                            package.inches(:width) <= 17.0 &&
+                            package.inches(:height) <= 17.0 &&
+                            package.pounds <= (package.options[:books] ? 25.0 : 35.0)
+        at_least_minimum && at_most_maximum
+      end
+      
+      def requirements
+        [:login]
+      end
+      
+      def find_rates(origin, destination, packages, options = {})
+        options = @options.merge(options)
+        
+        origin = Location.from(origin)
+        destination = Location.from(destination)
+        packages = Array(packages)
+        
+        #raise ArgumentError.new("USPS packages must originate in the U.S.") unless ['US',nil].include?(origin.country_code(:alpha2))
+        
+        
+        # domestic or international?
+        
+        response = if ['US',nil].include?(destination.country_code(:alpha2))
+          us_rates(origin, destination, packages, options)
+        else
+          world_rates(origin, destination, packages, options)
+        end
+      end
+      
+      def find_tracking_info(tracking_numbers, options={})
+        options = @options.update(options)
+        tracking_numbers = [tracking_numbers] unless tracking_numbers.is_a?(Array)
+        tracking_request = build_tracking_request(tracking_numbers)
+        response = commit(:track, save_request(tracking_request), (options[:test] || false))
+        parse_tracking_response(response, options)
+      end
+      
+      def valid_credentials?
+        # Cannot test with find_rates because USPS doesn't allow that in test mode
+        test_mode? ? canned_address_verification_works? : super
+      end
+      
+      def maximum_weight
+        Mass.new(70, :pounds)
+      end
+      
+      protected
+      
+      def us_rates(origin, destination, packages, options={})
+        request = build_us_rate_request(packages, origin.zip, destination.zip, options)
+         # never use test mode; rate requests just won't work on test servers
+        parse_rate_response origin, destination, packages, commit(:us_rates,request,false), options
+      end
+      
+      def world_rates(origin, destination, packages, options={})
+        request = build_world_rate_request(packages, destination.country)
+         # never use test mode; rate requests just won't work on test servers
+        parse_rate_response origin, destination, packages, commit(:world_rates,request,false), options
+      end
+      
+      # Once the address verification API is implemented, remove this and have valid_credentials? build the request using that instead.
+      def canned_address_verification_works?
+        request = "%3CCarrierPickupAvailabilityRequest%20USERID=%22#{URI.encode(@options[:login])}%22%3E%20%0A%3CFirmName%3EABC%20Corp.%3C/FirmName%3E%20%0A%3CSuiteOrApt%3ESuite%20777%3C/SuiteOrApt%3E%20%0A%3CAddress2%3E1390%20Market%20Street%3C/Address2%3E%20%0A%3CUrbanization%3E%3C/Urbanization%3E%20%0A%3CCity%3EHouston%3C/City%3E%20%0A%3CState%3ETX%3C/State%3E%20%0A%3CZIP5%3E77058%3C/ZIP5%3E%20%0A%3CZIP4%3E1234%3C/ZIP4%3E%20%0A%3C/CarrierPickupAvailabilityRequest%3E%0A"
+        # expected_hash = {"CarrierPickupAvailabilityResponse"=>{"City"=>"HOUSTON", "Address2"=>"1390 Market Street", "FirmName"=>"ABC Corp.", "State"=>"TX", "Date"=>"3/1/2004", "DayOfWeek"=>"Monday", "Urbanization"=>nil, "ZIP4"=>"1234", "ZIP5"=>"77058", "CarrierRoute"=>"C", "SuiteOrApt"=>"Suite 777"}}
+        xml = REXML::Document.new(commit(:test, request, true))
+        xml.get_text('/CarrierPickupAvailabilityResponse/City').to_s == 'HOUSTON' &&
+        xml.get_text('/CarrierPickupAvailabilityResponse/Address2').to_s == '1390 Market Street'
+      end
+      
+      def build_tracking_request(tracking_numbers)
+        request = XmlNode.new('TrackFieldRequest', :USERID => @options[:login]) do |tracking_request|
+          tracking_numbers.each { |i| tracking_request << XmlNode.new('TrackID', :ID => i)  }
+        end
+        
+        URI.encode(save_request(request.to_s))
+      end
+      
+      # options[:service] --    One of [:first_class, :priority, :express, :bpm, :parcel,
+      #                          :media, :library, :all]. defaults to :all.
+      # options[:container] --  One of [:envelope, :box]. defaults to neither (this field has
+      #                          special meaning in the USPS API).
+      # options[:books] --      Either true or false. Packages of books or other printed matter
+      #                          have a lower weight limit to be considered machinable.
+      # package.options[:machinable] -- Either true or false. Overrides the detection of
+      #                                  "machinability" entirely.
+      def build_us_rate_request(packages, origin_zip, destination_zip, options={})
+        packages = Array(packages)
+        request = XmlNode.new('RateV3Request', :USERID => @options[:login]) do |rate_request|
+          packages.each_with_index do |p,id|
+            rate_request << XmlNode.new('Package', :ID => id.to_s) do |package|
+              package << XmlNode.new('Service', US_SERVICES[options[:service] || :all])
+              package << XmlNode.new('ZipOrigination', strip_zip(origin_zip))
+              package << XmlNode.new('ZipDestination', strip_zip(destination_zip))
+              package << XmlNode.new('Pounds', 0)
+              package << XmlNode.new('Ounces', "%0.1f" % [p.ounces,1].max)
+              if p.options[:container] and [nil,:all,:express,:priority].include? p.service
+                package << XmlNode.new('Container', CONTAINERS[p.options[:container]])
+              end
+              package << XmlNode.new('Size', USPS.size_code_for(p))
+              package << XmlNode.new('Width', p.inches(:width))
+              package << XmlNode.new('Length', p.inches(:length))
+              package << XmlNode.new('Height', p.inches(:height))
+              package << XmlNode.new('Girth', p.inches(:girth))
+              is_machinable = if p.options.has_key?(:machinable)
+                p.options[:machinable] ? true : false
+              else
+                USPS.package_machinable?(p)
+              end
+              package << XmlNode.new('Machinable', is_machinable.to_s.upcase)
+            end
+          end
+        end
+        URI.encode(save_request(request.to_s))
+      end
+      
+      # important difference with international rate requests:
+      # * services are not given in the request
+      # * package sizes are not given in the request
+      # * services are returned in the response along with restrictions of size
+      # * the size restrictions are returned AS AN ENGLISH SENTENCE (!?)
+      #
+      # 
+      # package.options[:mail_type] -- one of [:package, :postcard, :matter_for_the_blind, :envelope].
+      #                                 Defaults to :package.
+      def build_world_rate_request(packages, destination_country)
+        country = COUNTRY_NAME_CONVERSIONS[destination_country.code(:alpha2).first.value] || destination_country.name
+        request = XmlNode.new('IntlRateRequest', :USERID => @options[:login]) do |rate_request|
+          packages.each_index do |id|
+            p = packages[id]
+            rate_request << XmlNode.new('Package', :ID => id.to_s) do |package|
+              package << XmlNode.new('Pounds', 0)
+              package << XmlNode.new('Ounces', [p.ounces,1].max.ceil) #takes an integer for some reason, must be rounded UP
+              package << XmlNode.new('MailType', MAIL_TYPES[p.options[:mail_type]] || 'Package')
+              package << XmlNode.new('ValueOfContents', p.value / 100.0) if p.value && p.currency == 'USD'
+              package << XmlNode.new('Country') do |node|
+                node.cdata = country
+              end
+            end
+          end
+        end
+        URI.encode(save_request(request.to_s))
+      end
+      
+      def parse_tracking_response(response, options = {})
+        xml = REXML::Document.new(response)
+        shipment_events = []
+        if success = response_success?(xml)
+          info = xml.root.get_elements('TrackInfo')
+          unless info.empty?
+            responses = info.map do |i|
+              tracking_number = i.attributes['ID']
+
+              track_details = i.get_elements('TrackDetail')
+              unless track_details.empty?
+                shipment_events = track_details.map do |track_detail|
+                  name = track_detail.get_text('Event').to_s
+                  if (time = track_detail.get_text('EventTime')) && 
+                    (date = track_detail.get_text('EventDate'))
+                    
+                    event_time = Time.parse("#{date} #{time}")
+                  end
+
+                  location = Location.new(
+                    :city => node_string_or_nil(track_detail.elements['EventCity']),
+                    :state => node_string_or_nil(track_detail.elements['EventState']),
+                    :postal_code => node_string_or_nil(track_detail.elements['EventZIPCode']),
+                    :country => node_string_or_nil(track_detail.elements['EventCountry'])
+                  )
+                  
+                  ShipmentEvent.new(name, event_time, location)
+                  
+                end
+              end
+              TrackingResponse.new(success, response_message(xml), 
+                Hash.from_xml(response).values.first,
+                :xml => response,
+                :request => last_request,
+                :shipment_events => shipment_events,
+                :tracking_number => tracking_number
+              )
+            end
+          end
+        end
+      end
+
+        
+
+      def response_success?(xml)
+        xml.elements['/Error'].nil?
+      end
+
+      def response_message(xml)
+        if error = xml.elements['/Error']
+          message = error.elements['Description'].text
+        else
+          message = ''
+        end
+
+        message
+      end
+
+      def parse_rate_response(origin, destination, packages, response, options={})
+        success = true
+        message = ''
+        rate_hash = {}
+        
+        xml = REXML::Document.new(response)
+        
+        if error = xml.elements['/Error']
+          success = false
+          message = error.elements['Description'].text
+        else
+          xml.elements.each('/*/Package') do |package|
+            if package.elements['Error']
+              success = false
+              message = package.get_text('Error/Description').to_s
+              break
+            end
+          end
+          
+          if success
+            rate_hash = rates_from_response_node(xml, packages)
+            unless rate_hash
+              success = false
+              message = "Unknown root node in XML response: '#{root_node_name}'"
+            end
+          end
+          
+        end
+        
+        rate_estimates = rate_hash.keys.map do |service_name|
+          RateEstimate.new(origin,destination,@@name,"USPS #{service_name}",
+                                    :package_rates => rate_hash[service_name][:package_rates],
+                                    :service_code => rate_hash[service_name][:service_code],
+                                    :currency => 'USD')
+        end
+        rate_estimates.reject! {|e| e.package_count != packages.length}
+        rate_estimates = rate_estimates.sort_by(&:total_price)
+        
+        RateResponse.new(success, message, Hash.from_xml(response), :rates => rate_estimates, :xml => response, :request => last_request)
+      end
+      
+      def rates_from_response_node(response_node, packages)
+        rate_hash = {}
+        return false unless (root_node = response_node.elements['/IntlRateResponse | /RateV3Response'])
+        domestic = (root_node.name == 'RateV3Response')
+        
+        domestic_elements = ['Postage', 'CLASSID', 'MailService', 'Rate']
+        international_elements = ['Service', 'ID', 'SvcDescription', 'Postage']
+        service_node, service_code_node, service_name_node, rate_node = domestic ? domestic_elements : international_elements
+        
+        root_node.each_element('Package') do |package_node|
+          package_index = package_node.attributes['ID'].to_i
+          
+          package_node.each_element(service_node) do |service_response_node|
+            service_name = service_response_node.get_text(service_name_node).to_s
+            
+            # aggregate specific package rates into a service-centric RateEstimate
+            # first package with a given service name will initialize these;
+            # later packages with same service will add to them
+            this_service = rate_hash[service_name] ||= {}
+            this_service[:service_code] ||= service_response_node.attributes[service_code_node]
+            package_rates = this_service[:package_rates] ||= []
+            this_package_rate = {:package => (this_package = packages[package_index]),
+                                 :rate => Package.cents_from(service_response_node.get_text(rate_node).to_s.to_f)}
+            
+            package_rates << this_package_rate if package_valid_for_service(this_package,service_response_node)
+          end
+        end
+        rate_hash
+      end
+      
+      def package_valid_for_service(package, service_node)
+        return true if service_node.elements['MaxWeight'].nil?
+        max_weight = service_node.get_text('MaxWeight').to_s.to_f
+        name = service_node.get_text('SvcDescription | MailService').to_s.downcase
+        
+        if name =~ /flat.rate.box/ #domestic or international flat rate box
+          # flat rate dimensions from http://www.usps.com/shipping/flatrate.htm
+          return (package_valid_for_max_dimensions(package,
+                      :weight => max_weight, #domestic apparently has no weight restriction
+                      :length => 11.0,
+                      :width => 8.5,
+                      :height => 5.5) or
+                 package_valid_for_max_dimensions(package,
+                      :weight => max_weight,
+                      :length => 13.625,
+                      :width => 11.875,
+                      :height => 3.375))
+        elsif name =~ /flat.rate.envelope/
+          return package_valid_for_max_dimensions(package,
+                      :weight => max_weight,
+                      :length => 12.5,
+                      :width => 9.5,
+                      :height => 0.75)
+        elsif service_node.elements['MailService'] # domestic non-flat rates
+          return true
+        else #international non-flat rates
+          # Some sample english that this is required to parse:
+          #
+          # 'Max. length 46", width 35", height 46" and max. length plus girth 108"'
+          # 'Max. length 24", Max. length, height, depth combined 36"'
+          # 
+          sentence = CGI.unescapeHTML(service_node.get_text('MaxDimensions').to_s)
+          tokens = sentence.downcase.split(/[^\d]*"/).reject {|t| t.empty?}
+          max_dimensions = {:weight => max_weight}
+          single_axis_values = []
+          tokens.each do |token|
+            axis_sum = [/length/,/width/,/height/,/depth/].sum {|regex| (token =~ regex) ? 1 : 0}
+            unless axis_sum == 0
+              value = token[/\d+$/].to_f 
+              if axis_sum == 3
+                max_dimensions[:length_plus_width_plus_height] = value
+              elsif token =~ /girth/ and axis_sum == 1
+                max_dimensions[:length_plus_girth] = value
+              else
+                single_axis_values << value
+              end
+            end
+          end
+          single_axis_values.sort!.reverse!
+          [:length, :width, :height].each_with_index do |axis,i|
+            max_dimensions[axis] = single_axis_values[i] if single_axis_values[i]
+          end
+          return package_valid_for_max_dimensions(package, max_dimensions)
+        end
+      end
+      
+      def package_valid_for_max_dimensions(package,dimensions)
+        valid = ((not ([:length,:width,:height].map {|dim| dimensions[dim].nil? || dimensions[dim].to_f >= package.inches(dim).to_f}.include?(false))) and
+                (dimensions[:weight].nil? || dimensions[:weight] >= package.pounds) and
+                (dimensions[:length_plus_girth].nil? or
+                    dimensions[:length_plus_girth].to_f >=
+                    package.inches(:length) + package.inches(:girth)) and
+                (dimensions[:length_plus_width_plus_height].nil? or
+                    dimensions[:length_plus_width_plus_height].to_f >=
+                    package.inches(:length) + package.inches(:width) + package.inches(:height)))
+
+        return valid
+      end
+      
+      def commit(action, request, test = false)
+        ssl_get(request_url(action, request, test))
+      end
+      
+      def request_url(action, request, test)
+        scheme = USE_SSL[action] ? 'https://' : 'http://'
+        host = test ? TEST_DOMAINS[USE_SSL[action]] : LIVE_DOMAIN
+        resource = test ? TEST_RESOURCE : LIVE_RESOURCE
+        "#{scheme}#{host}/#{resource}?API=#{API_CODES[action]}&XML=#{request}"
+      end
+      
+      def strip_zip(zip)
+        zip.to_s.scan(/\d{5}/).first || zip
+      end
+      
+    end
+  end
+end