copious-fedex 1.1.0

data/.gitignore

@@ -0,0 +1,6 @@
+.DS_Store
+.svn
+lib/wsdl
+*.sw?
+fedex.gemspec
+pkg/

data/MIT-LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2007 Joseph Jaramillo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,157 @@
+= fedex
+
+== Description
+
+This Rails[http://www.rubyonrails.org] plugin will enable you to integrate with Fedex's Web Services platform for the purpose of obtaining shipping rate quotes, generating shipping labels, and cancelling shipments.  Web Services is Fedex's new web service platform that replaces Web Integration. It is quite robust. The plugin we're providing here attempts to make using this new system as simple as you've come to expect from Rails itself.  It does not implement Web Services in its entirety, but it provides the two core services (Rate and Ship) most applicable to e-commerce.
+
+This is a fork of {Mighty Interactive's Fedex plugin}[http://mightyinteractive.com/ruby-on-rails/fedex/] that has been updated to be compatible with the latest version (v7 as of 10/22/2009) of the Fedex API.
+
+=== Using as a gem
+
+(I'll be revising the Installation section below, but this is how to do it now:)
+
+Insert this in config/environment.rb, just like when using this as a plugin:
+
+  config.gem "soap4r", :lib => "soap/soap", :version => ">= 1.5.8"
+
+And also this:
+  
+  config.gem "fedex"
+
+Get your hands on the v8 WSDL files and toss them in lib/fedex_wsdl/ in your application. You'll need to use an initializer to tell the gem where to look.
+
+  mkdir config/initializers
+  cat >> config/initializers/fedex_wsdl.rb
+  Fedex::Base::WSDL_PATHS.merge!({
+  	:rate => "#{RAILS_ROOT}/lib/fedex_wsdl/RateService_v8.wsdl",
+  	:ship => "#{RAILS_ROOT}/lib/fedex_wsdl/ShipService_v8.wsdl",
+  })
+  ^D
+
+That should do it.
+
+=== Installation
+
+This plugin depends upon NaHi's[http://dev.ctor.org/soap4r/wiki/NaHi] excellent SOAP4R[http://dev.ctor.org/soap4r] library. Just add this line to <tt>config/environment.rb</tt>:
+
+  config.gem "soap4r", :lib => "soap/soap", :version => ">= 1.5.8"
+  
+and then run:
+
+  $ sudo rake gems:install
+  
+and then if you want to:
+
+  $ rake gems:unpack
+
+To install the plugin itself, simply navigate to your project directory and run:
+
+  script/plugin install git://github.com/mcmire/fedex.git
+
+Due to copyright reasons we cannot distribute the associated WSDL files; you will need to apply for a {developer account}[http://www.fedex.com/developer] with Fedex to begin working on your integration.  Once you've created your account, head to the "Get Started" section, where you can find documentation and the individual WSDLs for all of the available services.  For our purposes you need only two: Rate (<tt>RateService_v7.wsdl</tt> as of 10/22/2009) and Ship (<tt>ShipService_v7.wsdl</tt> as of 10/22/2009). Download these WSDLs and put them in the <tt>vendor/plugins/fedex/lib/wsdl/</tt> directory.
+
+== Usage
+
+Using the plugin is straightforward:
+
+Start out by defining constants to hold the authentication parameters.  To use Fedex Web Services you will need four pieces of information: Account Number, Authorization Key, Security Code, and Meter Number.  You will receive all four when you create your developer account. An ideal place to put these constants is in an initializer under <tt>config/initializers</tt>.
+
+  AUTH_KEY       = 'YOUR_AUTHORIZATION_KEY'
+  SECURITY_CODE  = 'YOUR_SECURITY_CODE'
+  ACCOUNT_NUMBER = 'YOUR_ACCOUNT_NUMBER'
+  METER_NUMBER   = 'YOUR_METER_NUMBER'
+
+Before you can get a rate or create a label, you must first create a Fedex object. Here you pass in the constants you just created, along with any other options that apply (see <tt>lib/fedex.rb</tt>).
+
+  fedex = Fedex::Base.new(
+    :auth_key => AUTH_KEY,
+    :security_code => SECURITY_CODE,
+    :account_number => ACCOUNT_NUMBER,
+    :meter_number => METER_NUMBER
+  )
+
+Note that leaving out one or more required pieces of information for any method will result in an exception being thrown:
+
+  > fedex = Fedex::Base.new
+  Fedex::MissingInformationError: Missing :auth_key, :security_code, :account_number, :meter_number
+         from ./lib/fedex.rb:204:in `check_required_options'
+         from ./lib/fedex.rb:37:in `initialize'
+ 
+For the purpose of demonstration we're using the PDF label type, which is the default.  PDFs are nice because they'll print onto a regular 8.5"x11" sheet of paper exactly the way Fedex needs them.  Additional options for printing are available.  See <tt>Fedex::LabelSpecificationImageTypes</tt> (defined in <tt>lib/{rate|ship}_constants.rb</tt>) for a list, which includes PNG and special formats designed for thermal printers.
+
+Now let's get a Rate quote.  Define your origin, destination, number of packages, total weight, and shipping method.
+
+  shipper = {
+    :name => "Your Name",
+    :phone_number => '5205551212'
+  }
+  recipient = {
+    :name => "Fedex",
+    :phone_number => '9013693600'
+  }
+  origin = {
+    :street => '80 E. Rio Salado Pkwy. #711', # Off Madison Ave
+    :city => 'Tempe',
+    :state => 'AZ',
+    :zip => '85281',
+    :country => 'US'
+  }
+  destination = {
+    :street => '942 South Shady Grove Road',  # Fedex
+    :city => 'Memphis',
+    :state => 'TN',
+    :zip => '38120',
+    :country => 'US',
+    :residential => false
+  }
+  pkg_count = 1
+  weight = 10
+  service_type = Fedex::ServiceTypes::STANDARD_OVERNIGHT
+
+Pass these to your Fedex object:
+
+  price = fedex.price(
+    :shipper => { :contact => shipper, :address => origin },
+    :recipient => { :contact => recipient, :address => destination },
+    :count => pkg_count,
+    :weight => weight,
+    :service_type => service_type
+  )
+  price #=> 8644
+
+Note that rate quotes are returned as whole integers in cents (so the charge in this case is $86.44).
+
+Shipping is just as easy:
+ 
+  price, label, tracking_number = fedex.label(
+    :shipper => { :contact => shipper, :address => origin },
+    :recipient => { :contact => recipient, :address => destination },
+    :count => pkg_count,
+    :weight => weight,
+    :service_type => service_type
+  )
+
+If everything goes well, +price+, +label+, and +tracking_number+ will all be populated accordingly.  +label+ is the Base64-decoded label as returned from Fedex.  By default the Fedex plugin requests the label to be returned as a PDF file suitable for laser printing.  Store this in a <tt>:binary</tt> column in your database, or write it out to a file.
+
+And that's it!  There are quite a few additional configuration options which you can find by looking in the documentation in the source code itself, but this should be enough to get you started.
+
+== Support
+
+I (Elliot) use this plugin at work and right now we are only using the 'price' feature of this plugin. However, I realize that other people may be using the other features. If you encounter any bugs while using this, I am happy to fix the plugin for you; however, I rely on you to give me as much information as possible to do so. You can help me by:
+
+* going to the 'Issues' tab in Github[http://github.com/mcmire/fedex] and adding an issue
+* creating the patch yourself and sending me a pull request
+* sending me an email (elliot.winkler [at] gmail [dot] com)
+
+== Author/Contributors
+
+* Joseph Jamarillo, josephj [at] offmadisonave [dot] com (original author)
+* Elliot Winkler, elliot.winkler [at] gmail [dot] com (fork for v5 compatibility)
+* Laurence A. Lee, lalee [at] pobox [dot] com (additional fixes for v5 compatibility)
+* Matthew Boeh, matt [at] copiousinc [dot] com (janitorial work)
+
+== Copyright/License
+
+Copyright (c) 2007 Joseph Jaramillo
+
+This plugin is made available under the MIT license.

data/Rakefile

@@ -0,0 +1,37 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'Test the fedex plugin.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+desc 'Generate documentation for the fedex plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Fedex'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+begin
+  require 'rubygems'
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "copious-fedex"
+    gemspec.summary = "Retrieve shipping quotes, generate labels, and cancel shipments with the FedEx v8 web service."
+    gemspec.description = "Retrieve shipping quotes, generate labels, and cancel shipments with the FedEx v8 web service."
+    gemspec.email = "matt@copiousinc.com"
+    gemspec.homepage = "http://github.com/copious/fedex"
+    gemspec.authors = ["Joseph Jamarillo", "Elliot Winkler", "Laurence A. Lee", "Matthew Boeh"]
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: gem install jeweler"
+end

data/VERSION

@@ -0,0 +1 @@
+1.1.0

data/lib/fedex.rb

@@ -0,0 +1,475 @@
+# Copyright (c) 2007 Joseph Jaramillo
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+require 'fedex/rate_constants'
+require 'fedex/ship_constants'
+
+module Fedex #:nodoc:
+  
+  class MissingInformationError < StandardError; end #:nodoc:
+  class FedexError < StandardError; end #:nodoc
+  
+  # Provides access to Fedex Web Services
+  class Base
+    
+    # Defines the required parameters for various methods
+    REQUIRED_OPTIONS = {
+      :base        => [ :auth_key, :security_code, :account_number, :meter_number ],
+      :price       => [ :shipper, :recipient, :weight ],
+      :label       => [ :shipper, :recipient, :weight, :service_type ],
+      :contact     => [ :name, :phone_number ],
+      :address     => [ :country, :street, :city, :state, :zip ],
+      :ship_cancel => [ :tracking_number ]
+    }
+    
+    # Defines the relative path to the WSDL files.  Defaults assume lib/wsdl under plugin directory.
+    WSDL_PATHS = {
+      :rate => 'wsdl/RateService_v8.wsdl',
+      :ship => 'wsdl/ShipService_v8.wsdl',
+    }
+    
+    # Defines the Web Services version implemented.
+    WS_VERSION = { :Major => 8, :Intermediate => 0, :Minor => 0 }
+    
+    SUCCESSFUL_RESPONSES = ['SUCCESS', 'WARNING', 'NOTE'] #:nodoc:
+    
+    DIR = File.dirname(__FILE__)
+    
+    attr_accessor :auth_key,
+                  :security_code,
+                  :account_number,
+                  :meter_number,
+                  :dropoff_type,
+                  :service_type,
+                  :units,
+                  :packaging_type,
+                  :sender,
+                  :debug
+    
+    # Initializes the Fedex::Base class, setting defaults where necessary.
+    # 
+    #  fedex = Fedex::Base.new(options = {})
+    #
+    # === Example:
+    #   fedex = Fedex::Base.new(:auth_key       => AUTH_KEY,
+    #                           :security_code  => SECURITY_CODE
+    #                           :account_number => ACCOUNT_NUMBER,
+    #                           :meter_number   => METER_NUMBER)
+    #
+    # === Required options for new
+    #   :auth_key       - Your Fedex Authorization Key
+    #   :security_code  - Your Fedex Security Code
+    #   :account_number - Your Fedex Account Number
+    #   :meter_number   - Your Fedex Meter Number
+    #
+    # === Additional options
+    #   :dropoff_type       - One of Fedex::DropoffTypes.  Defaults to DropoffTypes::REGULAR_PICKUP
+    #   :packaging_type     - One of Fedex::PackagingTypes.  Defaults to PackagingTypes::YOUR_PACKAGING
+    #   :label_type         - One of Fedex::LabelFormatTypes.  Defaults to LabelFormatTypes::COMMON2D.  You'll only need to change this
+    #                         if you're generating completely custom labels with a format of your own design.  If printing to Fedex stock
+    #                         leave this alone.
+    #   :label_image_type   - One of Fedex::LabelSpecificationImageTypes.  Defaults to LabelSpecificationImageTypes::PDF.
+    #   :rate_request_type  - One of Fedex::RateRequestTypes.  Defaults to RateRequestTypes::ACCOUNT
+    #   :payment            - One of Fedex::PaymentTypes.  Defaults to PaymentTypes::SENDER
+    #   :units              - One of Fedex::WeightUnits.  Defaults to WeightUnits::LB
+    #   :currency           - One of Fedex::CurrencyTypes.  Defaults to CurrencyTypes::USD
+    #   :debug              - Enable or disable debug (wiredump) output.  Defaults to false.
+    def initialize(options = {})
+      check_required_options(:base, options)
+      
+      @auth_key           = options[:auth_key]
+      @security_code      = options[:security_code]
+      @account_number     = options[:account_number]
+      @meter_number       = options[:meter_number]
+                        
+      @dropoff_type       = options[:dropoff_type]      || DropoffTypes::REGULAR_PICKUP
+      @packaging_type     = options[:packaging_type]    || PackagingTypes::YOUR_PACKAGING
+      @label_type         = options[:label_type]        || LabelFormatTypes::COMMON2D
+      @label_image_type   = options[:label_image_type]  || LabelSpecificationImageTypes::PDF
+      @rate_request_type  = options[:rate_request_type] || RateRequestTypes::LIST
+      @payment_type       = options[:payment]           || PaymentTypes::SENDER
+      @units              = options[:units]             || WeightUnits::LB
+      @currency           = options[:currency]          || CurrencyTypes::USD
+      @debug              = options[:debug]             || false
+    end
+    
+    # Gets a rate quote from Fedex.
+    #
+    #   fedex = Fedex::Base.new(options)
+    #   
+    #   single_price = fedex.price(
+    #     :shipper => { ... },
+    #     :recipient => { ... },
+    #     :weight => 1,
+    #     :service_type => 'STANDARD_OVERNIGHT'
+    #   }
+    #   single_price #=> 1315
+    #
+    #   multiple_prices = fedex.price(
+    #     :shipper => { ... },
+    #     :recipient => { ... },
+    #     :weight => 1
+    #   )
+    #   multiple_prices #=> { 'STANDARD_OVERNIGHT' => 1315, 'PRIORITY_OVERNIGHT' => 2342, ... }
+    #
+    # === Required options for price
+    #   :shipper              - A hash containing contact information and an address for the shipper.  (See below.)
+    #   :recipient            - A hash containing contact information and an address for the recipient.  (See below.)
+    #   :weight               - The total weight of the shipped package.
+    #
+    # === Optional options
+    #   :count                - How many packages are in the shipment. Defaults to 1.
+    #   :service_type         - One of Fedex::ServiceTypes. If not specified, Fedex gives you rates for all
+    #                           of the available service types (and you will receive a hash of prices instead of a
+    #                           single price).
+    #
+    # === Address format
+    # The 'shipper' and 'recipient' address values should be hashes. Like this:
+    #
+    #  address = {
+    #    :country => 'US',
+    #    :street => '1600 Pennsylvania Avenue NW'
+    #    :city => 'Washington',
+    #    :state => 'DC',
+    #    :zip => '20500'
+    #  }
+    def price(options = {})
+      puts options.inspect if $DEBUG
+
+      # Check overall options
+      check_required_options(:price, options)
+
+      # Check Address Options
+      check_required_options(:contact, options[:shipper][:contact])
+      check_required_options(:address, options[:shipper][:address])
+
+      # Check Contact Options
+      check_required_options(:contact, options[:recipient][:contact])
+      check_required_options(:address, options[:recipient][:address])
+
+      # Build shipment options
+      options = build_shipment_options(:crs, options) 
+
+      # Process the rate request 
+      driver = create_driver(:rate)
+      result = driver.getRates(options)
+
+      extract_price = proc do |reply_detail|
+        shipment_details = reply_detail.ratedShipmentDetails
+        price = nil
+        for shipment_detail in shipment_details
+          rate_detail = shipment_detail.shipmentRateDetail
+          if rate_detail.rateType == "PAYOR_#{@rate_request_type}"
+            price = (rate_detail.totalNetCharge.amount.to_f * 100).to_i
+            break
+          end
+        end
+        if price
+          return price
+        else
+          raise "Couldn't find Fedex price in response!"
+        end
+      end
+
+      msg = error_msg(result, false)
+      if successful?(result) && msg !~ /There are no valid services available/
+        reply_details = result.rateReplyDetails
+        if reply_details.respond_to?(:ratedShipmentDetails)
+          price = extract_price.call(reply_details)
+          service_type ? price : { reply_details.serviceType => price }
+        else
+          reply_details.inject({}) {|h,r| h[r.serviceType] = extract_price.call(r); h }
+        end
+      else
+        raise FedexError.new("Unable to retrieve price from Fedex: #{msg}")
+      end
+    end
+
+    # Generate a new shipment and return associated data, including price, tracking number, and the label itself.
+    #
+    #  fedex = Fedex::Base.new(options)
+    #  price, label, tracking_number = fedex.label(fields)
+    #
+    # Returns the actual price for the label, the Base64-decoded label in the format specified in Fedex::Base,
+    # and the tracking_number for the shipment.
+    #
+    # === Required options for label
+    #   :shipper      - A hash containing contact information and an address for the shipper.  (See below.)
+    #   :recipient    - A hash containing contact information and an address for the recipient.  (See below.)
+    #   :weight       - The total weight of the shipped package.
+    #   :service_type - One of Fedex::ServiceTypes
+    #
+    # === Address format
+    # The 'shipper' and 'recipient' address values should be hashes. Like this:
+    #
+    #  shipper = {:contact => {:name => 'John Doe',
+    #                          :phone_number => '4805551212'},
+    #             :address => address} # See "Address" for under price.
+    def label(options = {})
+      puts options.inspect if $DEBUG
+
+      # Check overall options
+      check_required_options(:label, options)
+
+      # Check Address Options
+      check_required_options(:contact, options[:shipper][:contact])
+      check_required_options(:address, options[:shipper][:address])
+
+      # Check Contact Options
+      check_required_options(:contact, options[:recipient][:contact])
+      check_required_options(:address, options[:recipient][:address])
+
+      # Build shipment options
+      options = build_shipment_options(:ship, options)
+
+     # Process the shipment request
+      driver = create_driver(:ship)
+      result = driver.processShipment(options)
+      successful = successful?(result)
+
+      msg = error_msg(result, false)
+      if successful && msg !~ /There are no valid services available/
+        pre = result.completedShipmentDetail.shipmentRating.shipmentRateDetails
+        charge = ((pre.class == Array ? pre[0].totalNetCharge.amount.to_f : pre.totalNetCharge.amount.to_f) * 100).to_i
+        label = Base64.decode64(result.completedShipmentDetail.completedPackageDetails.label.parts.image)
+        tracking_number = result.completedShipmentDetail.completedPackageDetails.trackingIds.trackingNumber
+        [charge, label, tracking_number]
+      else
+        raise FedexError.new("Unable to get label from Fedex: #{msg}")
+      end
+    end
+
+    # Cancel a shipment
+    #
+    #  fedex = Fedex::Base.new(options)
+    #  result = fedex.cancel(options)
+    #
+    # Returns a boolean indicating whether or not the operation was successful
+    #
+    # === Required options for cancel
+    #   :tracking_number - The Fedex-provided tracking number you wish to cancel
+    def cancel(options = {})
+      check_required_options(:ship_cancel, options)
+
+      tracking_number = options[:tracking_number]
+      #carrier_code    = options[:carrier_code] || carrier_code_for_tracking_number(tracking_number)
+
+      driver = create_driver(:ship)
+
+      result = driver.deleteShipment(common_options(:ship).merge(
+        :TrackingNumber => tracking_number
+      ))
+
+      return successful?(result)
+    end
+
+    private
+
+    # Options that go along with each request
+    # service - :crs or :ship
+    def common_options(service)
+      {
+        :WebAuthenticationDetail => { :UserCredential => { :Key => @auth_key, :Password => @security_code } },
+        :ClientDetail => { :AccountNumber => @account_number, :MeterNumber => @meter_number },
+        :Version => WS_VERSION.merge({:ServiceId => service.to_s})
+      }
+    end
+
+    # Checks the supplied options for a given method or field and throws an exception if anything is missing
+    def check_required_options(option_set_name, options = {})
+      required_options = REQUIRED_OPTIONS[option_set_name]
+      missing = []
+      required_options.each{|option| missing << option if options[option].nil?}
+
+      unless missing.empty?
+        raise MissingInformationError.new("Missing #{missing.collect{|m| ":#{m}"}.join(', ')}")
+      end
+    end
+
+    # Creates and returns a driver for the requested action
+    def create_driver(name)
+      path = WSDL_PATHS[name]
+      unless path =~ /^\//
+        path = File.expand_path(DIR + '/' + WSDL_PATHS[name])
+      end
+      wsdl = SOAP::WSDLDriverFactory.new(path)
+      driver = wsdl.create_rpc_driver
+      # /s+(1000|0|9c9|fcc)\s+/ => ""
+      driver.wiredump_dev = STDOUT if @debug
+
+      driver
+    end
+
+    # Resolves the ground+residential discrepancy.  If a package is shipped
+    # via Fedex Groundto an address marked as residential the service type must
+    # be set to ServiceTypes::GROUND_HOME_DELIVERY and not ServiceTypes::FEDEX_GROUND.
+    def resolve_service_type(service_type, residential)
+      if residential && (service_type == ServiceTypes::FEDEX_GROUND)
+        ServiceTypes::GROUND_HOME_DELIVERY
+      else
+        service_type
+      end
+    end
+
+    # Returns a boolean determining whether a request was successful.
+    def successful?(result)
+      if defined?(result.cancelPackageReply)
+        SUCCESSFUL_RESPONSES.any? {|r| r == result.cancelPackageReply.highestSeverity }
+      else
+        SUCCESSFUL_RESPONSES.any? {|r| r == result.highestSeverity }
+      end
+    end
+
+    # Returns the error message contained in the SOAP response, if one exists.
+    def error_msg(result, return_nothing_if_successful=true)
+      return "" if successful?(result) && return_nothing_if_successful
+      notes = result.notifications
+      notes.respond_to?(:message) ? notes.message : notes.first.message
+    end
+
+    # Attempts to determine the carrier code for a tracking number based upon its length.
+    # Currently supports Fedex Ground and Fedex Express
+    def carrier_code_for_tracking_number(tracking_number)
+      case tracking_number.length
+      when 12
+        'FDXE'
+      when 15
+        'FDXG'
+      end
+    end
+
+    def build_shipment_options(service, options)
+      # Prepare variables
+      order_number        = options[:order_number] || ''
+
+      shipper             = options[:shipper]
+      recipient           = options[:recipient]
+
+      shipper_contact     = shipper[:contact]
+      shipper_address     = shipper[:address]
+
+      recipient_contact   = recipient[:contact]
+      recipient_address   = recipient[:address]
+
+      count               = options[:count] || 1
+      weight              = options[:weight]
+
+      time                = options[:time] || Time.now
+      time                = time.to_time.iso8601 if time.is_a?(Time)
+
+      residential         = !!recipient_address[:residential]
+
+      service_type        = options[:service_type]
+      service_type        = resolve_service_type(service_type, residential) if service_type
+
+      common_options(service||:crs).merge(
+        :RequestedShipment => {
+          :Shipper => {
+            :Contact => {
+              :PersonName => shipper_contact[:name],
+              :PhoneNumber => shipper_contact[:phone_number]
+            },
+            :Address => {
+              :CountryCode => shipper_address[:country],
+              :StreetLines => shipper_address[:street],
+              :City => shipper_address[:city],
+              :StateOrProvinceCode => shipper_address[:state],
+              :PostalCode => shipper_address[:zip]
+            }
+          },
+          :Recipient => {
+            :Contact => {
+              :PersonName => recipient_contact[:name],
+              :PhoneNumber => recipient_contact[:phone_number]
+            },
+            :Address => {
+              :CountryCode => recipient_address[:country],
+              :StreetLines => recipient_address[:street],
+              :City => recipient_address[:city],
+              :StateOrProvinceCode => recipient_address[:state],
+              :PostalCode => recipient_address[:zip],
+              :Residential => residential
+            }
+          },
+          :ShippingChargesPayment => {
+            :PaymentType => @payment_type,
+            :Payor => {
+              :AccountNumber => @account_number,
+              :CountryCode => shipper_address[:country]
+            }
+          },
+          :LabelSpecification => {
+            :LabelFormatType => @label_type,
+            :ImageType => @label_image_type
+          },
+          :RateRequestTypes => @rate_request_type,
+          :PackageCount => count,
+          :ShipTimestamp => time,
+          :DropoffType => @dropoff_type,
+          :ServiceType => service_type,
+          :PackagingType => @packaging_type,
+          :PackageDetail => RequestedPackageDetailTypes::INDIVIDUAL_PACKAGES,
+          :PackageDetailSpecified => true,
+          :TotalWeight => { :Units => @units, :Value => weight },
+          :PreferredCurrency => @currency,
+          :RequestedPackageLineItems => package_line_items(options)
+        }
+      )
+    end
+
+    def package_line_items(options)
+      line_items = {
+        :SequenceNumber => 1,
+        :Weight => {
+          :Units => @units,
+          :Value => options[:weight]
+        },
+        :SpecialServicesRequested => {
+          :SpecialServiceTypes => []
+        }
+      }
+      
+      if options[:dry_ice]
+        dry_ice_type = options[:dry_ice_type] || PackageSpecialServiceTypes::DRY_ICE
+        line_items[:SpecialServicesRequested][:SpecialServiceTypes] << dry_ice_type
+
+        line_items[:SpecialServicesRequested].merge!(
+          :DryIceWeight => {
+            :Units => options[:dry_ice_weight_units] || WeightUnits::KG,
+            :Value => options[:dry_ice_weight]
+          }
+        )
+      end
+      if options[:dangerous_goods]
+        dangerous_goods_type = options[:dangerous_goods_type] || PackageSpecialServiceTypes::DANGEROUS_GOODS
+        line_items[:SpecialServicesRequested][:SpecialServiceTypes] << dangerous_goods_type
+
+        line_items[:SpecialServicesRequested].merge!(
+          :DangerousGoodsDetail => {
+            :Accessibility => options[:dangerous_goods_accessibility] || DangerousGoodsAccessibilityTypes::INACCESSIBLE
+          }
+        )
+      end
+
+      [line_items]
+    end
+
+  end
+end