ShippingInfo 2.0

data/lib/fedex.rb

@@ -0,0 +1,58 @@
+require 'fedex/shipment'
+
+
+# Get shipping rates trough Fedex Web Services
+#
+# In order to use the API you will need to apply for developer/production credentials,
+# Visit {http://www.fedex.com/us/developer/ Fedex Developer Center} for more information about how to obtain your keys.
+#
+# ===Usage example
+#    #Use your own Fedex Keys
+#    fedex = Fedex::Shipment.new(:key => 'xxx',
+#                               :password => 'xxxx',
+#                               :account_number => 'xxxx',
+#                               :meter => 'xxx',
+#                               :mode=>['production'|'development'])
+#    shipper = {:name => "Sender",
+#               :company => "Company",
+#               :phone_number => "555-555-5555",
+#               :address => "Main Street",
+#               :city => "Harrison",
+#               :state => "AR",
+#               :postal_code => "72601",
+#               :country_code => "US" }
+#
+#    recipient = { :name => "Recipient",
+#                  :company => "Company",
+#                  :phone_number => "555-555-5555",
+#                  :address => "Main Street",
+#                  :city => "City",
+#                  :state => "ST",
+#                  :postal_code => "55555",
+#                  :country_code => "US",
+#                  :residential => "false" }
+#    packages = []
+#    packages << { :weight => {:units => "LB", :value => 2},
+#                 :dimensions => {:length => 10, :width => 5, :height => 4, :units => "IN" } }
+#    packages << { :weight => {:units => "LB", :value => 6},
+#                 :dimensions => {:length => 5, :width => 5, :height => 4, :units => "IN" } }
+#    # "YOUR PACKAGING" and "REGULAR PICKUP" are the default options for all shipments but you can easily change them by passing an extra hash for #    shipping_options
+#    shipping_options = { :packaging_type => "YOUR_PACKAGING", :drop_off_type => "REGULAR_PICKUP" }
+#    rate = fedex.rate({:shipper=>shipper, :recipient => recipient, :packages => packages, :service_type => "FEDEX_GROUND", :shipping_options => #shipping_options})
+#
+#    $ <Fedex::Rate:0x1019ba5f8 @total_net_charge="34.03",
+#        @total_surcharges="1.93",
+#        @total_billing_weight="8.0 LB",
+#        @total_taxes="0.0",
+#        @rate_type="PAYOR_ACCOUNT_PACKAGE",
+#        @total_base_charge="32.1",
+#        @total_freight_discounts=nil,
+#        @total_net_freight="32.1",
+#        @rate_zone="51">
+module Fedex
+  require 'fedex/version'
+  require 'ups/upsinfo'
+  require 'rexml/document'
+  #Exceptions: Fedex::RateError
+  class RateError < StandardError; end
+end

data/lib/fedex/address.rb

@@ -0,0 +1,30 @@
+module Fedex
+  class Address
+
+    attr_reader :changes, :score, :confirmed, :available, :status, :residential,
+                :business, :street_lines, :city, :state, :province_code,
+                :postal_code, :country_code
+
+    def initialize(options)
+      @changes   = options[:changes]
+      @score     = options[:score].to_i
+      @confirmed = options[:delivery_point_validation] == "CONFIRMED"
+      @available = options[:delivery_point_validation] != "UNAVAILABLE"
+
+      @status      = options[:residential_status]
+      @residential = status == "RESIDENTIAL"
+      @business    = status == "BUSINESS"
+
+      address        = options[:address]
+
+      @street_lines  = address[:street_lines]
+      @city          = address[:city]
+      @state         = address[:state_or_province_code]
+      @province_code = address[:state_or_province_code]
+      @postal_code   = address[:postal_code]
+      @country_code  = address[:country_code]
+
+      @options = options
+    end
+  end
+end

data/lib/fedex/credentials.rb

@@ -0,0 +1,26 @@
+require 'fedex/helpers'
+
+module Fedex
+  class Credentials
+    include Helpers
+    attr_reader :key, :password, :account_number, :meter, :mode
+
+    # In order to use Fedex rates API you must first apply for a developer(and later production keys),
+    # Visit {http://www.fedex.com/us/developer/ Fedex Developer Center} for more information about how to obtain your keys.
+    # @param [String] key - Fedex web service key
+    # @param [String] password - Fedex password
+    # @param [String] account_number - Fedex account_number
+    # @param [String] meter - Fedex meter number
+    # @param [String] mode - [development/production]
+    #
+    # return a Fedex::Credentials object
+    def initialize(options={})
+      requires!(options, :key, :password, :account_number, :meter, :mode)
+      @key = options[:key]
+      @password = options[:password]
+      @account_number = options[:account_number]
+      @meter = options[:meter]
+      @mode = options[:mode]
+    end
+  end
+end

data/lib/fedex/helpers.rb

@@ -0,0 +1,20 @@
+module Fedex
+  module Helpers
+
+    private
+    # String or :symbol to CamelCase
+    def camelize(s)
+      # s.to_s.split('_').map { |e| e.capitalize }.join('')
+      s.to_s.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
+    end
+
+    # Helper method to validate required fields
+    def requires!(hash, *params)
+       params.each { |param| raise RateError, "Missing Required Parameter #{param}" if hash[param].nil? }
+    end
+
+    def underscorize(key) #:nodoc:
+      key.to_s.sub(/^(v[0-9]+|ns):/, "").gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').gsub(/([a-z\d])([A-Z])/,'\1_\2').downcase
+    end
+  end
+end

data/lib/fedex/label.rb

@@ -0,0 +1,56 @@
+require 'base64'
+require 'pathname'
+
+module Fedex
+  class Label
+    attr_accessor :options, :image, :response_details
+
+    # Initialize Fedex::Label Object
+    # @param [Hash] options
+    def initialize(label_details = {})
+      @response_details = label_details[:process_shipment_reply]
+      package_details = label_details[:process_shipment_reply][:completed_shipment_detail][:completed_package_details]
+      @options = package_details[:label]
+      @options[:format] = label_details[:format]
+      @options[:tracking_number] = package_details[:tracking_ids][:tracking_number]
+      @options[:file_name] = label_details[:file_name]
+
+      @image = Base64.decode64(options[:parts][:image]) if has_image?
+
+      if file_name = @options[:file_name]
+        save(file_name, false)
+      end
+    end
+
+    def name
+      [tracking_number, format].join('.')
+    end
+
+    def format
+      options[:format]
+    end
+
+    def file_name
+      options[:file_name]
+    end
+
+    def tracking_number
+      options[:tracking_number]
+    end
+
+    def has_image?
+      options[:parts] && options[:parts][:image]
+    end
+
+    def save(path, append_name = true)
+      return unless has_image?
+
+      full_path = Pathname.new(path)
+      full_path = full_path.join(name) if append_name
+
+      File.open(full_path, 'wb') do|f|
+        f.write(@image)
+      end
+    end
+  end
+end

data/lib/fedex/rate.rb

@@ -0,0 +1,36 @@
+module Fedex
+  # Visit {http://www.fedex.com/us/developer/ Fedex Developer Center} for a complete list of values returned from the API
+  #
+  # Rate totals are contained in the node
+  #    response[:rate_reply][:rate_reply_details][:rated_shipment_details]
+  class Rate
+    # Initialize Fedex::Rate Object
+    # @param [Hash] options
+    #
+    #
+    # return [Fedex::Rate Object]
+    #     @rate_type #Type used for this specific set of rate data
+    #     @rate_zone #Indicates the rate zone used(based on origin and destination)
+    #     @total_billing_weight #The weight used to calculate these rates
+    #     @total_freight_discounts #The toal discounts used in the rate calculation
+    #     @total_net_charge #The net charge after applying all discounts and surcharges
+    #     @total_taxes #Total of the transportation-based taxes
+    #     @total_net_freight #The freight charge minus dicounts
+    #     @total_surcharges #The total amount of all surcharges applied to this shipment
+    #     @total_base_charge #The total base charge
+    attr_accessor :rate_type, :rate_zone, :total_bilint_weight, :total_freight_discounts, :total_net_charge, :total_taxes, :total_net_freight, :total_surcharges, :total_base_charge
+    def initialize(options = {})
+      @rate_type = options[:rate_type]
+      @rate_zone = options[:rate_zone]
+      @total_billing_weight = "#{options[:total_billing_weight][:value]} #{options[:total_billing_weight][:units]}"
+      @total_freight_discounts = options[:total_freight_discounts]
+      @total_net_charge = options[:total_net_charge][:amount]
+      @total_taxes = options[:total_taxes][:amount]
+      @total_net_freight = options[:total_net_freight][:amount]
+      @total_surcharges = options[:total_surcharges][:amount]
+      @total_base_charge = options[:total_base_charge][:amount]
+      @total_net_fedex_charge = (options[:total_net_fe_dex_charge]||{})[:amount]
+      @total_rebates = (options[:total_rebates]||{})[:amount]
+    end
+  end
+end

data/lib/fedex/request/address.rb

@@ -0,0 +1,92 @@
+require 'fedex/request/base'
+require 'fedex/address'
+require 'fileutils'
+
+module Fedex
+  module Request
+    class Address < Base
+      def initialize(credentials, options={})
+        requires!(options, :address)
+        @credentials = credentials
+        @address     = options[:address]
+      end
+
+      def process_request
+        api_response = self.class.post(api_url, :body => build_xml)
+        puts api_response if @debug == true
+        response = parse_response(api_response)
+        if success?(response)
+          options = response[:address_validation_reply][:address_results][:proposed_address_details]
+
+          Fedex::Address.new(options)
+        else
+          error_message = if response[:address_validation_reply]
+            [response[:address_validation_reply][:notifications]].flatten.first[:message]
+          else
+            api_response["Fault"]["detail"]["fault"]["reason"]
+          end rescue $1
+          raise RateError, error_message
+        end
+      end
+
+      private
+
+      # Build xml Fedex Web Service request
+      def build_xml
+        builder = Nokogiri::XML::Builder.new do |xml|
+          xml.AddressValidationRequest(:xmlns => "http://fedex.com/ws/addressvalidation/v2"){
+            add_web_authentication_detail(xml)
+            add_client_detail(xml)
+            add_version(xml)
+            add_request_timestamp(xml)
+            add_address_validation_options(xml)
+            add_address_to_validate(xml)
+          }
+        end
+        builder.doc.root.to_xml
+      end
+
+      def add_request_timestamp(xml)
+        timestamp = Time.now
+
+        # Calculate current timezone offset manually.
+        # Ruby <= 1.9.2 does not support this in Time#strftime
+        #
+        utc_offest = "#{timestamp.gmt_offset < 0 ? "-" : "+"}%02d:%02d" %
+                     (timestamp.gmt_offset / 60).abs.divmod(60)
+        timestamp  = timestamp.strftime("%Y-%m-%dT%H:%M:%S") + utc_offest
+
+        xml.RequestTimestamp timestamp
+      end
+
+      def add_address_validation_options(xml)
+        xml.Options{
+          xml.CheckResidentialStatus true
+        }
+      end
+
+      def add_address_to_validate(xml)
+        xml.AddressesToValidate{
+          xml.Address{
+            xml.StreetLines         @address[:street]
+            xml.City                @address[:city]
+            xml.StateOrProvinceCode @address[:state]
+            xml.PostalCode          @address[:postal_code]
+            xml.CountryCode         @address[:country]
+          }
+        }
+      end
+
+      def service
+        { :id => 'aval', :version => 2 }
+      end
+
+      # Successful request
+      def success?(response)
+        response[:address_validation_reply] &&
+          %w{SUCCESS WARNING NOTE}.include?(response[:address_validation_reply][:highest_severity])
+      end
+
+    end
+  end
+end

data/lib/fedex/request/base.rb

@@ -0,0 +1,309 @@
+require 'httparty'
+require 'nokogiri'
+require 'fedex/helpers'
+require 'fedex/rate'
+
+module Fedex
+  module Request
+    class Base
+      include Helpers
+      include HTTParty
+      format :xml
+      # If true the rate method will return the complete response from the Fedex Web Service
+      attr_accessor :debug
+      # Fedex Text URL
+      TEST_URL = "https://gatewaybeta.fedex.com:443/xml/"
+
+      # Fedex Production URL
+      PRODUCTION_URL = "https://gateway.fedex.com:443/xml/"
+
+      # List of available Service Types
+      SERVICE_TYPES = %w(EUROPE_FIRST_INTERNATIONAL_PRIORITY FEDEX_1_DAY_FREIGHT FEDEX_2_DAY FEDEX_2_DAY_AM FEDEX_2_DAY_FREIGHT FEDEX_3_DAY_FREIGHT FEDEX_EXPRESS_SAVER FEDEX_FIRST_FREIGHT FEDEX_FREIGHT_ECONOMY FEDEX_FREIGHT_PRIORITY FEDEX_GROUND FIRST_OVERNIGHT GROUND_HOME_DELIVERY INTERNATIONAL_ECONOMY INTERNATIONAL_ECONOMY_FREIGHT INTERNATIONAL_FIRST INTERNATIONAL_PRIORITY INTERNATIONAL_PRIORITY_FREIGHT PRIORITY_OVERNIGHT SMART_POST STANDARD_OVERNIGHT)
+
+      # List of available Packaging Type
+      PACKAGING_TYPES = %w(FEDEX_10KG_BOX FEDEX_25KG_BOX FEDEX_BOX FEDEX_ENVELOPE FEDEX_PAK FEDEX_TUBE YOUR_PACKAGING)
+
+      # List of available DropOffTypes
+      DROP_OFF_TYPES = %w(BUSINESS_SERVICE_CENTER DROP_BOX REGULAR_PICKUP REQUEST_COURIER STATION)
+
+      # Clearance Brokerage Type
+      CLEARANCE_BROKERAGE_TYPE = %w(BROKER_INCLUSIVE BROKER_INCLUSIVE_NON_RESIDENT_IMPORTER BROKER_SELECT BROKER_SELECT_NON_RESIDENT_IMPORTER BROKER_UNASSIGNED)
+
+      # Recipient Custom ID Type
+      RECIPIENT_CUSTOM_ID_TYPE = %w(COMPANY INDIVIDUAL PASSPORT)
+
+      # In order to use Fedex rates API you must first apply for a developer(and later production keys),
+      # Visit {http://www.fedex.com/us/developer/ Fedex Developer Center} for more information about how to obtain your keys.
+      # @param [String] key - Fedex web service key
+      # @param [String] password - Fedex password
+      # @param [String] account_number - Fedex account_number
+      # @param [String] meter - Fedex meter number
+      # @param [String] mode - [development/production]
+      #
+      # return a Fedex::Request::Base object
+      def initialize(credentials, options={})
+        requires!(options, :shipper, :recipient, :packages, :service_type)
+        @credentials = credentials
+        @shipper, @recipient, @packages, @service_type, @customs_clearance, @debug = options[:shipper], options[:recipient], options[:packages], options[:service_type], options[:customs_clearance], options[:debug]
+        @debug = ENV['DEBUG'] == 'true'
+        @shipping_options =  options[:shipping_options] ||={}
+      end
+
+      # Sends post request to Fedex web service and parse the response.
+      # Implemented by each subclass
+      def process_request
+        raise NotImplementedError, "Override process_request in subclass"
+      end
+
+      private
+      # Add web authentication detail information(key and password) to xml request
+      def add_web_authentication_detail(xml)
+        xml.WebAuthenticationDetail{
+          xml.UserCredential{
+            xml.Key @credentials.key
+            xml.Password @credentials.password
+          }
+        }
+      end
+
+      # Add Client Detail information(account_number and meter_number) to xml request
+      def add_client_detail(xml)
+        xml.ClientDetail{
+          xml.AccountNumber @credentials.account_number
+          xml.MeterNumber @credentials.meter
+          xml.Localization{
+            xml.LanguageCode 'en' # English
+            xml.LocaleCode   'us' # United States
+          }
+        }
+      end
+
+      # Add Version to xml request, using the latest version V10 Sept/2011
+      def add_version(xml)
+        xml.Version{
+          xml.ServiceId service[:id]
+          xml.Major     service[:version]
+          xml.Intermediate 0
+          xml.Minor 0
+        }
+      end
+
+      # Add information for shipments
+      def add_requested_shipment(xml)
+        xml.RequestedShipment{
+          xml.DropoffType @shipping_options[:drop_off_type] ||= "REGULAR_PICKUP"
+          xml.ServiceType service_type
+          xml.PackagingType @shipping_options[:packaging_type] ||= "YOUR_PACKAGING"
+          add_shipper(xml)
+          add_recipient(xml)
+          add_shipping_charges_payment(xml)
+          add_customs_clearance(xml) if @customs_clearance
+          xml.RateRequestTypes "ACCOUNT"
+          add_packages(xml)
+        }
+      end
+
+      # Add shipper to xml request
+      def add_shipper(xml)
+        xml.Shipper{
+          xml.Contact{
+            xml.PersonName @shipper[:name]
+            xml.CompanyName @shipper[:company]
+            xml.PhoneNumber @shipper[:phone_number]
+          }
+          xml.Address {
+            Array(@shipper[:address]).take(2).each do |address_line|
+              xml.StreetLines address_line
+            end
+            xml.City @shipper[:city]
+            xml.StateOrProvinceCode @shipper[:state]
+            xml.PostalCode @shipper[:postal_code]
+            xml.CountryCode @shipper[:country_code]
+          }
+        }
+      end
+
+      # Add recipient to xml request
+      def add_recipient(xml)
+        xml.Recipient{
+          xml.Contact{
+            xml.PersonName @recipient[:name]
+            xml.CompanyName @recipient[:company]
+            xml.PhoneNumber @recipient[:phone_number]
+          }
+          xml.Address {
+            Array(@recipient[:address]).take(2).each do |address_line|
+              xml.StreetLines address_line
+            end
+            xml.City @recipient[:city]
+            xml.StateOrProvinceCode @recipient[:state]
+            xml.PostalCode @recipient[:postal_code]
+            xml.CountryCode @recipient[:country_code]
+            xml.Residential @recipient[:residential]
+          }
+        }
+      end
+
+      # Add shipping charges to xml request
+      def add_shipping_charges_payment(xml)
+        xml.ShippingChargesPayment{
+          xml.PaymentType "SENDER"
+          xml.Payor{
+            xml.AccountNumber @credentials.account_number
+            xml.CountryCode @shipper[:country_code]
+          }
+        }
+      end
+
+      # Add packages to xml request
+      def add_packages(xml)
+        package_count = @packages.size
+        xml.PackageCount package_count
+        @packages.each do |package|
+          xml.RequestedPackageLineItems{
+            xml.GroupPackageCount 1
+            xml.Weight{
+              xml.Units package[:weight][:units]
+              xml.Value package[:weight][:value]
+            }
+            if package[:dimensions]
+              xml.Dimensions{
+                xml.Length package[:dimensions][:length]
+                xml.Width package[:dimensions][:width]
+                xml.Height package[:dimensions][:height]
+                xml.Units package[:dimensions][:units]
+              }
+            end
+            if package[:customer_refrences]
+              xml.CustomerReferences{
+              package[:customer_refrences].each do |value|
+                 xml.CustomerReferenceType 'CUSTOMER_REFERENCE'
+                 xml.Value                 value
+              end
+              }
+            end
+            if package[:special_services_requested] && package[:special_services_requested][:special_service_types]
+              xml.SpecialServicesRequested{
+                if package[:special_services_requested][:special_service_types].is_a? Array
+                  package[:special_services_requested][:special_service_types].each do |type|
+                    xml.SpecialServiceTypes type
+                  end
+                else
+                  xml.SpecialServiceTypes package[:special_services_requested][:special_service_types]
+                end
+                # Handle COD Options
+                if package[:special_services_requested][:cod_detail]
+                  xml.CodDetail{
+                    xml.CodCollectionAmount{
+                      xml.Currency package[:special_services_requested][:cod_detail][:cod_collection_amount][:currency]
+                      xml.Amount package[:special_services_requested][:cod_detail][:cod_collection_amount][:amount]
+                    }
+                    if package[:special_services_requested][:cod_detail][:add_transportation_charges]
+                      xml.AddTransportationCharges package[:special_services_requested][:cod_detail][:add_transportation_charges]
+                    end
+                    xml.CollectionType package[:special_services_requested][:cod_detail][:collection_type]
+                    xml.CodRecipient {
+                      add_shipper(xml)
+                    }
+                    if package[:special_services_requested][:cod_detail][:reference_indicator]
+                      xml.ReferenceIndicator package[:special_services_requested][:cod_detail][:reference_indicator]
+                    end
+                  }
+                end
+                # DangerousGoodsDetail goes here
+                if package[:special_services_requested][:dry_ice_weight]
+                  xml.DryIceWeight{
+                    xml.Units package[:special_services_requested][:dry_ice_weight][:units]
+                    xml.Value package[:special_services_requested][:dry_ice_weight][:value]
+                  }
+                end
+                if package[:special_services_requested][:signature_option_detail]
+                  xml.SignatureOptionDetail{
+                    xml.OptionType package[:special_services_requested][:signature_option_detail][:signature_option_type]
+                  }
+                end
+                if package[:special_services_requested][:priority_alert_detail]
+                  xml.PriorityAlertDetail package[:special_services_requested][:priority_alert_detail]
+                end
+              }
+            end
+          }
+        end
+      end
+
+      # Add customs clearance(for international shipments)
+      def add_customs_clearance(xml)
+        xml.CustomsClearanceDetail{
+          hash_to_xml(xml, @customs_clearance)
+        }
+      end
+
+      # Fedex Web Service Api
+      def api_url
+        @credentials.mode == "production" ? PRODUCTION_URL : TEST_URL
+      end
+
+      # Build xml Fedex Web Service request
+      # Implemented by each subclass
+      def build_xml
+        raise NotImplementedError, "Override build_xml in subclass"
+      end
+
+      # Build xml nodes dynamically from the hash keys and values
+      def hash_to_xml(xml, hash)
+        hash.each do |key, value|
+          element = camelize(key)
+          if value.is_a?(Hash)
+            xml.send element do |x|
+              hash_to_xml(x, value)
+            end
+          elsif value.is_a?(Array)
+            value.each do |v|
+              xml.send element do |x|
+                hash_to_xml(x, v)
+              end  
+            end  
+          else
+            xml.send element, value
+          end
+        end
+      end
+
+      # Parse response, convert keys to underscore symbols
+      def parse_response(response)
+        response = sanitize_response_keys(response)
+      end
+
+      # Recursively sanitizes the response object by cleaning up any hash keys.
+      def sanitize_response_keys(response)
+        if response.is_a?(Hash)
+          response.inject({}) { |result, (key, value)| result[underscorize(key).to_sym] = sanitize_response_keys(value); result }
+        elsif response.is_a?(Array)
+          response.collect { |result| sanitize_response_keys(result) }
+        else
+          response
+        end
+      end
+
+      def service
+        raise NotImplementedError,
+          "Override service in subclass: {:id => 'service', :version => 1}"
+      end
+
+      # Use GROUND_HOME_DELIVERY for shipments going to a residential address within the US.
+      def service_type
+        if @recipient[:residential].to_s =~ /true/i and @service_type =~ /GROUND/i and @recipient[:country_code] =~ /US/i
+          "GROUND_HOME_DELIVERY"
+        else
+          @service_type
+        end
+      end
+
+      # Successful request
+      def success?(response)
+        (!response[:rate_reply].nil? and %w{SUCCESS WARNING NOTE}.include? response[:rate_reply][:highest_severity])
+      end
+
+    end
+  end
+end