Class: ActiveShipping::USPS

Inherits:
Carrier
  • Object
show all
Defined in:
lib/active_shipping/carriers/usps.rb

Overview

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.

Defined Under Namespace

Classes: EventDetails

Constant Summary collapse

ONLY_PREFIX_EVENTS = 
['DELIVERED','OUT FOR DELIVERY']
LIVE_DOMAIN = 
'production.shippingapis.com'
LIVE_RESOURCE = 
'ShippingAPI.dll'
TEST_DOMAINS =

indexed by security; e.g. TEST_DOMAINS[USE_SSL[:rates]]

{ # 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 => 'RateV4',
  :world_rates => 'IntlRateV2',
  :test => 'CarrierPickupAvailability',
  :track => 'TrackV2'
}
USE_SSL = 
{
  :us_rates => false,
  :world_rates => false,
  :test => true,
  :track => false
}
CONTAINERS = 
{
  rectangular: 'RECTANGULAR',
  variable: 'VARIABLE',
  box: 'FLAT RATE BOX',
  box_large: 'LG FLAT RATE BOX',
  box_medium: 'MD FLAT RATE BOX',
  box_small: 'SM FLAT RATE BOX',
  envelope: 'FLAT RATE ENVELOPE',
  envelope_legal: 'LEGAL FLAT RATE ENVELOPE',
  envelope_padded: 'PADDED FLAT RATE ENVELOPE',
  envelope_gift_card: 'GIFT CARD FLAT RATE ENVELOPE',
  envelope_window: 'WINDOW FLAT RATE ENVELOPE',
  envelope_small: 'SM FLAT RATE ENVELOPE',
  package_service: 'PACKAGE SERVICE'
}
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',
  :online => 'ONLINE',
  :plus => 'PLUS',
  :all => 'ALL'
}
DEFAULT_SERVICE = 
Hash.new(:all).update(
  :base => :online,
  :plus => :plus
)
DOMESTIC_RATE_FIELD = 
Hash.new('Rate').update(
  :base => 'CommercialRate',
  :plus => 'CommercialPlusRate'
)
INTERNATIONAL_RATE_FIELD = 
Hash.new('Postage').update(
  :base => 'CommercialPostage',
  :plus => 'CommercialPlusPostage'
)
COMMERCIAL_FLAG_NAME = 
{
  :base => 'CommercialFlag',
  :plus => 'CommercialPlusFlag'
}
FIRST_CLASS_MAIL_TYPES = 
{
  :letter => 'LETTER',
  :flat => 'FLAT',
  :parcel => 'PARCEL',
  :post_card => 'POSTCARD',
  :package_service => 'PACKAGESERVICE'
}
US_POSSESSIONS =

Array of U.S. possessions according to USPS: https://www.usps.com/ship/official-abbreviations.htm

%w(AS FM GU MH MP PW PR VI)
COUNTRY_NAME_CONVERSIONS =

TODO: figure out how USPS likes to say "Ivory Coast"

Country names: http://pe.usps.gov/text/Imm/immctry.htm

{
  "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"
}
RESPONSE_ERROR_MESSAGES = 
[
  /There is no record of that mail item/,
  /This Information has not been included in this Test Server\./,
  /Delivery status information is not available/
]
ESCAPING_AND_SYMBOLS = 
/<\S*>/
LEADING_USPS = 
/^USPS /
TRAILING_ASTERISKS = 
/\*+$/
SERVICE_NAME_SUBSTITUTIONS = 
/#{ESCAPING_AND_SYMBOLS}|#{LEADING_USPS}|#{TRAILING_ASTERISKS}/
@@name = 
"USPS"

Instance Attribute Summary

Attributes inherited from Carrier

#last_request, #test_mode

Class Method Summary collapse

Instance Method Summary collapse

Methods inherited from Carrier

#create_shipment, default_location, #initialize, #save_request, #timestamp_from_business_day

Constructor Details

This class inherits a constructor from ActiveShipping::Carrier

Class Method Details

.package_machinable?(package, options = {}) ⇒ Boolean

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.

Returns:

  • (Boolean) 


194
195
196
197
198
199
200
201
202
203
204
 
# File 'lib/active_shipping/carriers/usps.rb', line 194

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

.size_code_for(package) ⇒ Object 



182
183
184
185
186
187
188
 
# File 'lib/active_shipping/carriers/usps.rb', line 182

def self.size_code_for(package)
  if package.inches(:max) <= 12
    'REGULAR'
  else
    'LARGE'
  end
end

Instance Method Details

#batch_find_tracking_info(tracking_infos, options = {}) ⇒ Object 



175
176
177
178
179
180
 
# File 'lib/active_shipping/carriers/usps.rb', line 175

def batch_find_tracking_info(tracking_infos, options = {})
  options = @options.update(options)
  tracking_request = build_tracking_batch_request(tracking_infos, options)
  response = commit(:track, tracking_request, options[:test] || false)
  parse_tracking_response(response, fault_tolerant: true)
end

#build_tracking_batch_request(tracking_infos, options) ⇒ Object (protected) 



267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
 
# File 'lib/active_shipping/carriers/usps.rb', line 267

def build_tracking_batch_request(tracking_infos, options)
  xml_builder = Nokogiri::XML::Builder.new do |xml|
    xml.TrackFieldRequest('USERID' => options[:login]) do
      xml.Revision { xml.text('1') }
      xml.ClientIp { xml.text(options[:client_ip] || '127.0.0.1') }
      xml.SourceId { xml.text(options[:source_id] || 'active_shipping') }
      tracking_infos.each do |info|
        xml.TrackID('ID' => info[:number]) do
          xml.DestinationZipCode { xml.text(strip_zip(info[:destination_zip]))} if info[:destination_zip]
          if info[:mailing_date]
            formatted_date = info[:mailing_date].strftime('%Y-%m-%d')
            xml.MailingDate { xml.text(formatted_date)}
          end
        end
      end
    end
  end
  xml_builder.to_xml
end

#build_tracking_request(tracking_number, options = {}) ⇒ Object (protected) 



259
260
261
262
263
264
265
 
# File 'lib/active_shipping/carriers/usps.rb', line 259

def build_tracking_request(tracking_number, options = {})
  build_tracking_batch_request([{
    number: tracking_number,
    destination_zip: options[:destination_zip],
    mailing_date: options[:mailing_date]
  }], options)
end

#build_us_rate_request(packages, origin_zip, destination_zip, options = {}) ⇒ Object (protected)

options[:service] -- One of [:first_class, :priority, :express, :bpm, :parcel, :media, :library, :online, :plus, :all]. defaults to :all. options[:books] -- Either true or false. Packages of books or other printed matter have a lower weight limit to be considered machinable. package.options[:container] -- Can be :rectangular, :variable, or a flat rate container defined in CONTAINERS. package.options[:machinable] -- Either true or false. Overrides the detection of "machinability" entirely.



327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
 
# File 'lib/active_shipping/carriers/usps.rb', line 327

def build_us_rate_request(packages, origin_zip, destination_zip, options = {})
  xml_builder = Nokogiri::XML::Builder.new do |xml|
    xml.RateV4Request('USERID' => @options[:login]) do
      Array(packages).each_with_index do |package, id|
        xml.Package('ID' => id) do
          commercial_type = commercial_type(options)
          default_service = DEFAULT_SERVICE[commercial_type]
          service         = options.fetch(:service, default_service).to_sym

          if commercial_type && service != default_service
            raise ArgumentError, "Commercial #{commercial_type} rates are only provided with the #{default_service.inspect} service."
          end

          xml.Service(US_SERVICES[service])
          xml.FirstClassMailType(FIRST_CLASS_MAIL_TYPES[options[:first_class_mail_type].try(:to_sym)])
          xml.ZipOrigination(strip_zip(origin_zip))
          xml.ZipDestination(strip_zip(destination_zip))
          xml.Pounds(0)
          xml.Ounces("%0.1f" % [package.ounces, 1].max)
          xml.Container(CONTAINERS[package.options[:container]] || (package.cylinder? ? 'NONRECTANGULAR' : 'RECTANGULAR'))
          xml.Size(USPS.size_code_for(package))
          xml.Width("%0.2f" % package.inches(:width))
          xml.Length("%0.2f" % package.inches(:length))
          xml.Height("%0.2f" % package.inches(:height))
          xml.Girth("%0.2f" % package.inches(:girth))
          is_machinable = if package.options.has_key?(:machinable)
            package.options[:machinable] ? true : false
          else
            USPS.package_machinable?(package)
          end
          xml.Machinable(is_machinable.to_s.upcase)
        end
      end
    end
  end
  save_request(xml_builder.to_xml)
end

#build_world_rate_request(packages, destination, options) ⇒ Object (protected)

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.



374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
 
# File 'lib/active_shipping/carriers/usps.rb', line 374

def build_world_rate_request(packages, destination, options)
  country = COUNTRY_NAME_CONVERSIONS[destination.country.code(:alpha2).value] || destination.country.name
  xml_builder = Nokogiri::XML::Builder.new do |xml|
    xml.IntlRateV2Request('USERID' => @options[:login]) do
      Array(packages).each_with_index do |package, id|
        xml.Package('ID' => id) do
          xml.Pounds(0)
          xml.Ounces([package.ounces, 1].max.ceil) # takes an integer for some reason, must be rounded UP
          xml.MailType(MAIL_TYPES[package.options[:mail_type]] || 'Package')
          xml.GXG do
            xml.POBoxFlag(destination.po_box? ? 'Y' : 'N')
            xml.GiftFlag(package.gift? ? 'Y' : 'N')
          end

          value = if package.value && package.value > 0 && package.currency && package.currency != 'USD'
            0.0
          else
            (package.value || 0) / 100.0
          end
          xml.ValueOfContents(value)

          xml.Country(country)
          xml.Container(package.cylinder? ? 'NONRECTANGULAR' : 'RECTANGULAR')
          xml.Size(USPS.size_code_for(package))
          xml.Width("%0.2f" % [package.inches(:width), 0.01].max)
          xml.Length("%0.2f" % [package.inches(:length), 0.01].max)
          xml.Height("%0.2f" % [package.inches(:height), 0.01].max)
          xml.Girth("%0.2f" % [package.inches(:girth), 0.01].max)
          if commercial_type = commercial_type(options)
            xml.public_send(COMMERCIAL_FLAG_NAME.fetch(commercial_type), 'Y')
          end
        end
      end
    end
  end
  save_request(xml_builder.to_xml)
end

#canned_address_verification_works? ⇒ Boolean (protected)

Once the address verification API is implemented, remove this and have valid_credentials? build the request using that instead.

Returns:

  • (Boolean) 


300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
 
# File 'lib/active_shipping/carriers/usps.rb', line 300

def canned_address_verification_works?
  return false unless @options[:login]
  request = <<-EOF
  <?xml version="1.0" encoding="UTF-8"?>
  <CarrierPickupAvailabilityRequest USERID="#{URI.encode(@options[:])}">
    <FirmName>Shopifolk</FirmName>
    <SuiteOrApt>Suite 0</SuiteOrApt>
    <Address2>18 Fair Ave</Address2>
    <Urbanization />
    <City>San Francisco</City>
    <State>CA</State>
    <ZIP5>94110</ZIP5>
    <ZIP4>9411</ZIP4>
  </CarrierPickupAvailabilityRequest>
  EOF
  xml = Nokogiri.XML(commit(:test, request, true)) { |config| config.strict }
  xml.at('/CarrierPickupAvailabilityResponse/City').try(:text) == 'SAN FRANCISCO' && xml.at('/CarrierPickupAvailabilityResponse/Address2').try(:text) == '18 FAIR AVE'
end

#commit(action, request, test = false) ⇒ Object (protected) 



641
642
643
 
# File 'lib/active_shipping/carriers/usps.rb', line 641

def commit(action, request, test = false)
  ssl_get(request_url(action, request, test))
end

#error_description_node(node) ⇒ Object (protected) 



625
626
627
 
# File 'lib/active_shipping/carriers/usps.rb', line 625

def error_description_node(node)
  node.xpath('//Error/Description')
end

#extract_event_details(node) ⇒ Object 



234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
 
# File 'lib/active_shipping/carriers/usps.rb', line 234

def extract_event_details(node)
  description = node.at('Event').text.upcase

  if prefix = ONLY_PREFIX_EVENTS.find { |p| description.starts_with?(p) }
    description = prefix
  end

  timestamp = "#{node.at('EventDate').text}, #{node.at('EventTime').text}"
  event_code = node.at('EventCode').text
  city = node.at('EventCity').try(:text)
  state = node.at('EventState').try(:text)
  zip_code = node.at('EventZIPCode').try(:text)

  country_node = node.at('EventCountry')
  country = country_node ? country_node.text : ''
  country = 'USA' if country.empty?

  time = Time.parse(timestamp)
  zoneless_time = Time.utc(time.year, time.month, time.mday, time.hour, time.min, time.sec)
  location = Location.new(city: city, state: state, postal_code: zip_code, country: country)
  EventDetails.new(description, time, zoneless_time, location, event_code)
end

#find_rates(origin, destination, packages, options = {}) ⇒ Object 



210
211
212
213
214
215
216
217
218
219
220
221
222
223
 
# File 'lib/active_shipping/carriers/usps.rb', line 210

def find_rates(origin, destination, packages, options = {})
  options = @options.merge(options)

  origin = Location.from(origin)
  destination = Location.from(destination)
  packages = Array(packages)

  domestic_codes = US_POSSESSIONS + ['US', nil]
  if domestic_codes.include?(destination.country_code(:alpha2))
    us_rates(origin, destination, packages, options)
  else
    world_rates(origin, destination, packages, options)
  end
end

#find_tracking_info(tracking_number, options = {}) ⇒ Object 



168
169
170
171
172
173
 
# File 'lib/active_shipping/carriers/usps.rb', line 168

def find_tracking_info(tracking_number, options = {})
  options = @options.update(options)
  tracking_request = build_tracking_request(tracking_number, options)
  response = commit(:track, tracking_request, options[:test] || false)
  parse_tracking_response(response).first
end

#has_error?(node) ⇒ Boolean (protected)

Returns:

  • (Boolean) 


633
634
635
 
# File 'lib/active_shipping/carriers/usps.rb', line 633

def has_error?(node)
  node.xpath('Error').length > 0
end

#maximum_weight ⇒ Object 



230
231
232
 
# File 'lib/active_shipping/carriers/usps.rb', line 230

def maximum_weight
  Mass.new(70, :pounds)
end

#package_valid_for_max_dimensions(package, dimensions) ⇒ Object (protected) 



545
546
547
548
549
550
551
552
553
554
 
# File 'lib/active_shipping/carriers/usps.rb', line 545

def package_valid_for_max_dimensions(package, dimensions)
  ((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)))
end

#package_valid_for_service(package, service_node) ⇒ Object (protected) 



489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
 
# File 'lib/active_shipping/carriers/usps.rb', line 489

def package_valid_for_service(package, service_node)
  return true if service_node.at('MaxWeight').nil?
  max_weight = service_node.at('MaxWeight').text.to_f
  name = service_node.at_xpath('SvcDescription | MailService').text.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.at('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.at('MaxDimensions').text)
    tokens = sentence.downcase.split(/[^\d]*"/).reject(&: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
    package_valid_for_max_dimensions(package, max_dimensions)
  end
end

#parse_rate_response(origin, destination, packages, response, options = {}) ⇒ Object (protected) 



412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
 
# File 'lib/active_shipping/carriers/usps.rb', line 412

def parse_rate_response(origin, destination, packages, response, options = {})
  success = true
  message = ''
  rate_hash = {}

  xml = Nokogiri.XML(response)

  if error = xml.at('/Error')
    success = false
    message = error.at('Description').text
  else
    xml.root.xpath('Package').each do |package|
      if package.at('Error')
        success = false
        message = package.at('Error/Description').text
        break
      end
    end

    if success
      rate_hash = rates_from_response_node(xml, packages, options)
      unless rate_hash
        success = false
        message = "Unknown root node in XML response: '#{xml.root.name}'"
      end
    end

  end

  if success
    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)
  end

  RateResponse.new(success, message, Hash.from_xml(response), :rates => rate_estimates, :xml => response, :request => last_request)
end

#parse_tracking_info(response, node) ⇒ Object (protected) 



582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
 
# File 'lib/active_shipping/carriers/usps.rb', line 582

def parse_tracking_info(response, node)
  success = !has_error?(node)
  message = response_message(node)

  if success
    destination = nil
    shipment_events = []
    tracking_details = node.xpath('TrackDetail')
    tracking_details << node.at('TrackSummary')

    tracking_number = node.attributes['ID'].value
    prediction_node = node.at('PredictedDeliveryDate') || node.at('ExpectedDeliveryDate')
    scheduled_delivery = prediction_node ? Time.parse(prediction_node.text) : nil

    tracking_details.each do |event|
      details = extract_event_details(event)
      if details.location
        shipment_events << ShipmentEvent.new(details.description, details.zoneless_time,
          details.location, details.description, details.event_code)
      end
    end

    shipment_events = shipment_events.sort_by(&:time)

    if last_shipment = shipment_events.last
      status = last_shipment.status
      actual_delivery_date = last_shipment.time if last_shipment.delivered?
    end
  end

  TrackingResponse.new(success, message, Hash.from_xml(response),
                       :carrier => @@name,
                       :xml => response,
                       :request => last_request,
                       :shipment_events => shipment_events,
                       :destination => destination,
                       :tracking_number => tracking_number,
                       :status => status,
                       :actual_delivery_date => actual_delivery_date,
                       :scheduled_delivery_date => scheduled_delivery
  )
end

#parse_tracking_response(response, options = {}) ⇒ Object (protected) 



556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
 
# File 'lib/active_shipping/carriers/usps.rb', line 556

def parse_tracking_response(response, options = {})
  xml = Nokogiri.XML(response)

  if has_error?(xml)
    message = error_description_node(xml).text
    # actually raises instead of returning by nature of TrackingResponse#initialize
    return TrackingResponse.new(false, message, Hash.from_xml(response),
      carrier: @@name, xml: response, request: last_request)
  end

  # Responses are always returned in the order originally given.
  if options[:fault_tolerant]
    xml.root.xpath('TrackInfo').map do |info|
      # Don't let one failure wreck the whole batch
      begin
        parse_tracking_info(response, info)
      rescue ResponseError => e
        e.response
      end
    end
  else
    xml.root.xpath('TrackInfo').map { |info| parse_tracking_info(response, info) }
  end
end

#rates_from_response_node(response_node, packages, options = {}) ⇒ Object (protected) 



455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
 
# File 'lib/active_shipping/carriers/usps.rb', line 455

def rates_from_response_node(response_node, packages, options = {})
  rate_hash = {}
  return false unless (root_node = response_node.at_xpath('/IntlRateV2Response | /RateV4Response'))

  commercial_type = commercial_type(options)
  service_node, service_code_node, service_name_node, rate_node = if root_node.name == 'RateV4Response'
    %w(Postage CLASSID MailService) << DOMESTIC_RATE_FIELD[commercial_type]
  else
    %w(Service ID SvcDescription)   << INTERNATIONAL_RATE_FIELD[commercial_type]
  end

  root_node.xpath('Package').each do |package_node|
    this_package = packages[package_node['ID'].to_i]

    package_node.xpath(service_node).each do |service_response_node|
      service_name = service_response_node.at(service_name_node).text

      service_name.gsub!(SERVICE_NAME_SUBSTITUTIONS, '')

      # 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].value
      package_rates = this_service[:package_rates] ||= []
      this_package_rate = {:package => this_package,
                           :rate => Package.cents_from(rate_value(rate_node, service_response_node, commercial_type))}

      package_rates << this_package_rate if package_valid_for_service(this_package, service_response_node)
    end
  end
  rate_hash
end

#request_url(action, request, test) ⇒ Object (protected) 



645
646
647
648
649
650
 
# File 'lib/active_shipping/carriers/usps.rb', line 645

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=#{URI.encode(request)}"
end

#requirements ⇒ Object 



206
207
208
 
# File 'lib/active_shipping/carriers/usps.rb', line 206

def requirements
  [:login]
end

#response_message(document) ⇒ Object (protected) 



637
638
639
 
# File 'lib/active_shipping/carriers/usps.rb', line 637

def response_message(document)
  response_status_node(document).text
end

#response_status_node(node) ⇒ Object (protected) 



629
630
631
 
# File 'lib/active_shipping/carriers/usps.rb', line 629

def response_status_node(node)
  node.at('StatusSummary') || error_description_node(node)
end

#strip_zip(zip) ⇒ Object (protected) 



652
653
654
 
# File 'lib/active_shipping/carriers/usps.rb', line 652

def strip_zip(zip)
  zip.to_s.scan(/\d{5}/).first || zip
end

#us_rates(origin, destination, packages, options = {}) ⇒ Object (protected) 



287
288
289
290
291
 
# File 'lib/active_shipping/carriers/usps.rb', line 287

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

#valid_credentials? ⇒ Boolean

Returns:

  • (Boolean) 


225
226
227
228
 
# File 'lib/active_shipping/carriers/usps.rb', line 225

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

#world_rates(origin, destination, packages, options = {}) ⇒ Object (protected) 



293
294
295
296
297
 
# File 'lib/active_shipping/carriers/usps.rb', line 293

def world_rates(origin, destination, packages, options = {})
  request = build_world_rate_request(packages, destination, options)
  # 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