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) 


187
188
189
190
191
192
193
194
195
196
197
 
# File 'lib/active_shipping/carriers/usps.rb', line 187

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 



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

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

Instance Method Details

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



252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
 
# File 'lib/active_shipping/carriers/usps.rb', line 252

def build_tracking_request(tracking_number, 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') }
      xml.TrackID('ID' => tracking_number) do
        xml.DestinationZipCode { xml.text(strip_zip(@options[:destination_zip]))} if @options[:destination_zip]
        if @options[:mailing_date]
          formatted_date = @options[:mailing_date].strftime('%Y-%m-%d')
          xml.MailingDate { xml.text(formatted_date)} 
        end
      end
    end
  end
  xml_builder.to_xml
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.



310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
 
# File 'lib/active_shipping/carriers/usps.rb', line 310

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.



357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
 
# File 'lib/active_shipping/carriers/usps.rb', line 357

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) 


283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
 
# File 'lib/active_shipping/carriers/usps.rb', line 283

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

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



615
616
617
 
# File 'lib/active_shipping/carriers/usps.rb', line 615

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

#error_description_node(document) ⇒ Object (protected) 



589
590
591
 
# File 'lib/active_shipping/carriers/usps.rb', line 589

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

#extract_event_details(node) ⇒ Object 



227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
 
# File 'lib/active_shipping/carriers/usps.rb', line 227

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 



203
204
205
206
207
208
209
210
211
212
213
214
215
216
 
# File 'lib/active_shipping/carriers/usps.rb', line 203

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, options)
end

#has_error?(document) ⇒ Boolean (protected)

Returns:

  • (Boolean) 


599
600
601
 
# File 'lib/active_shipping/carriers/usps.rb', line 599

def has_error?(document)
  !document.at('Error').nil?
end

#maximum_weight ⇒ Object 



223
224
225
 
# File 'lib/active_shipping/carriers/usps.rb', line 223

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

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



528
529
530
531
532
533
534
535
536
537
 
# File 'lib/active_shipping/carriers/usps.rb', line 528

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) 



472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
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
 
# File 'lib/active_shipping/carriers/usps.rb', line 472

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) 



395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
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
 
# File 'lib/active_shipping/carriers/usps.rb', line 395

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_response(response, options) ⇒ Object (protected) 



539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
 
# File 'lib/active_shipping/carriers/usps.rb', line 539

def parse_tracking_response(response, options)
  actual_delivery_date, status = nil
  xml = Nokogiri.XML(response)

  success = response_success?(xml)
  message = response_message(xml)

  if success
    destination = nil
    shipment_events = []
    tracking_details = xml.root.xpath('TrackInfo/TrackDetail')
    tracking_details << xml.root.at('TrackInfo/TrackSummary')

    tracking_number = xml.root.at('TrackInfo').attributes['ID'].value
    prediction_node = xml.root.at('PredictedDeliveryDate') || xml.root.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

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



438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
 
# File 'lib/active_shipping/carriers/usps.rb', line 438

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) 



619
620
621
622
623
624
 
# File 'lib/active_shipping/carriers/usps.rb', line 619

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 



199
200
201
 
# File 'lib/active_shipping/carriers/usps.rb', line 199

def requirements
  [:login]
end

#response_message(document) ⇒ Object (protected) 



611
612
613
 
# File 'lib/active_shipping/carriers/usps.rb', line 611

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

#response_status_node(document) ⇒ Object (protected) 



593
594
595
596
597
 
# File 'lib/active_shipping/carriers/usps.rb', line 593

def response_status_node(document)
   summary = track_summary_node(document)
   return summary unless summary.empty?
   error_description_node(document)
end

#response_success?(document) ⇒ Boolean (protected)

Returns:

  • (Boolean) 


607
608
609
 
# File 'lib/active_shipping/carriers/usps.rb', line 607

def response_success?(document)
  !(has_error?(document) || tracking_info_error?(document))
end

#strip_zip(zip) ⇒ Object (protected) 



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

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

#track_summary_node(document) ⇒ Object (protected) 



585
586
587
 
# File 'lib/active_shipping/carriers/usps.rb', line 585

def track_summary_node(document)
  document.root.xpath('TrackInfo/StatusSummary')
end

#tracking_info_error?(document) ⇒ Boolean (protected)

Returns:

  • (Boolean) 


603
604
605
 
# File 'lib/active_shipping/carriers/usps.rb', line 603

def tracking_info_error?(document)
  !document.root.at('TrackInfo/Error').nil?
end

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



270
271
272
273
274
 
# File 'lib/active_shipping/carriers/usps.rb', line 270

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) 


218
219
220
221
 
# File 'lib/active_shipping/carriers/usps.rb', line 218

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) 



276
277
278
279
280
 
# File 'lib/active_shipping/carriers/usps.rb', line 276

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