fedex_ship 0.1.0

data/fedex_ship.gemspec

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require 'fedex_ship/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'fedex_ship'
+  s.version     = FedexShip::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ['Jazmin Schroeder','Shubham Sharma']
+  s.email       = ['shubhamsharma4587@gmail.com']
+  s.homepage    = 'https://github.com/shubhamsharma4587/fedex_ship'
+  s.summary     = %q{Fedex Web Services}
+  s.description = %q{Provides an interface to Upgraded Fedex Web Services}
+
+  s.add_dependency 'httparty',            '>= 0.13.7'
+  s.add_dependency 'nokogiri',            '>= 1.5.6'
+
+  s.add_development_dependency "rspec",   '~> 3.1'
+  s.add_development_dependency 'vcr',     '~> 2.0'
+  s.add_development_dependency 'webmock', '~> 1.8.0'
+  s.add_development_dependency 'pry'
+  s.add_development_dependency 'rake'
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ['lib']
+end

data/lib/fedex_ship.rb

@@ -0,0 +1,55 @@
+require 'fedex_ship/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 = FedexShip::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})
+#
+#    $ <FedexShip::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 FedexShip
+  require 'fedex_ship/version'
+  #Exceptions: FedexShip::RateError
+  class RateError < StandardError; end
+end

data/lib/fedex_ship/address.rb

@@ -0,0 +1,31 @@
+module FedexShip
+  class Address
+
+    attr_reader :changes, :score, :confirmed, :available, :status, :residential,
+                :business, :company, :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]
+
+      @company       = options[:company_name]
+      @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_ship/credentials.rb

@@ -0,0 +1,26 @@
+require 'fedex_ship/helpers'
+
+module FedexShip
+  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 FedexShip::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_ship/document.rb

@@ -0,0 +1,51 @@
+module FedexShip
+  class Document
+    attr_reader :tracking_number, :filenames, :response_details
+
+    # Initialize FedexShip::Document Object
+    # @param [Hash] options
+    def initialize(shipment_details = {})
+      @response_details = shipment_details[:process_shipment_reply]
+      @filenames = shipment_details[:filenames]
+
+      # extract label and tracking number
+      package_details = @response_details[:completed_shipment_detail][:completed_package_details]
+      label = package_details[:label]
+      @tracking_number = package_details[:tracking_ids][:tracking_number]
+
+      # extract shipment documents
+      shipment_documents = @response_details[:completed_shipment_detail][:shipment_documents] || []
+
+      # unify iteration interface
+      unless shipment_documents.kind_of?(Array)
+        shipment_documents = [shipment_documents]
+      end
+
+      # keeps the filenames which actually saved
+      save(@filenames[:label], label)
+
+      # save shipment documents
+      shipment_documents.each do |doc|
+        doc_type = doc[:type].downcase.to_sym
+        save(@filenames[doc_type], doc)
+      end
+    end
+
+    def save(path, content)
+      return unless path && has_image?(content)
+
+      image = Base64.decode64(content[:parts][:image])
+      full_path = Pathname.new(path)
+      File.open(full_path, 'wb') do|f|
+        f.write(image)
+      end
+
+      full_path
+    end
+
+    def has_image?(content)
+      content[:parts] && content[:parts][:image]
+    end
+
+  end
+end

data/lib/fedex_ship/ground_manifest.rb

@@ -0,0 +1,25 @@
+require 'base64'
+require 'pathname'
+
+module FedexShip
+  class GroundManifest
+    attr_reader :manifest_data, :filename
+
+    # Initialize FedexShip::GroundManifest Object
+    # @param [Hash] options
+    def initialize(options = {})
+      puts options
+      @filename = options[:filename]
+      @manifest_data = Base64.decode64(options[:manifest][:file])
+      save
+    end
+
+    def save
+      return if manifest_data.nil? || filename.nil?
+      full_path = Pathname.new(filename)
+      File.open(full_path, 'wb') do |f|
+        f.write(manifest_data)
+      end
+    end
+  end
+end

data/lib/fedex_ship/helpers.rb

@@ -0,0 +1,20 @@
+module FedexShip
+  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_ship/label.rb

@@ -0,0 +1,71 @@
+require 'base64'
+require 'pathname'
+
+module FedexShip
+  class Label
+    attr_accessor :options, :image, :response_details
+
+    # Initialize FedexShip::Label Object
+    # @param [Hash] options
+    def initialize(label_details = {}, associated_shipments = false)
+      if associated_shipments
+        package_details = label_details
+        @options = package_details[:label]
+        @options[:tracking_number] = package_details[:tracking_id]
+      else
+        @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[:tracking_number] = package_details[:tracking_ids][:tracking_number]
+      end
+      @options[:format] = label_details[:format]
+      @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
+
+    def associated_shipments
+      if (label_details = @response_details[:completed_shipment_detail][:associated_shipments])
+        label_details[:format] = format
+        label_details[:file_name] = file_name
+        Label.new(label_details, true)
+      else
+        nil
+      end
+    end
+  end
+end

data/lib/fedex_ship/rate.rb

@@ -0,0 +1,38 @@
+module FedexShip
+  # 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 FedexShip::Rate Object
+    # @param [Hash] options
+    #
+    #
+    # return [FedexShip::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 :service_type, :transit_time, :rate_type, :rate_zone, :total_billing_weight, :total_freight_discounts, :total_net_charge, :total_taxes, :total_net_freight, :total_surcharges, :total_base_charge
+    def initialize(options = {})
+      @service_type = options[:service_type]
+      @transit_time = options[:transit_time]
+      @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_ship/request/address.rb

@@ -0,0 +1,97 @@
+require 'fedex_ship/request/base'
+require 'fedex_ship/address'
+require 'fileutils'
+
+module FedexShip
+  module Request
+    class Address < Base
+      def initialize(credentials, options={})
+        requires!(options, :address)
+        @credentials = credentials
+        @address     = options[:address]
+
+        @address[:address] ||= @address[:street]
+      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]
+          options = options.first if options.is_a? Array
+          FedexShip::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"]}\n--#{api_response["Fault"]["detail"]["fault"]["details"]["ValidationFailureDetail"]["message"].join("\n--")}"
+          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/v#{service[:version]}"){
+            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.CompanyName           @address[:company] unless @address[:company].nil? or @address[:company].empty?
+          xml.Address{
+            Array(@address[:address]).take(2).each do |address_line|
+              xml.StreetLines address_line
+            end
+            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