trackerific 0.7.1 → 0.7.2

data/lib/trackerific/builders/usps.rb

@@ -0,0 +1,19 @@
+module Trackerific
+  module Builders
+    class USPS < Base::XML.new(:user_id, :package_id)
+      protected
+
+      def build
+        add_track_request
+      end
+
+      private
+
+      def add_track_request
+        builder.TrackRequest(:USERID => user_id) do |t|
+          t.TrackID(:ID => package_id)
+        end
+      end
+    end
+  end
+end

data/lib/trackerific/environment.rb

@@ -0,0 +1,11 @@
+module Trackerific
+  class << self
+    def env
+      @env || ENV['RAILS_ENV'] || ENV['RACK_ENV'] || 'development'
+    end
+
+    def env=(value)
+      @env = value
+    end
+  end
+end

data/lib/trackerific/error.rb

@@ -1,4 +1,6 @@
 module Trackerific
   # Raised if something other than tracking information is returned.
-  class Error < StandardError; end
+  class Error < StandardError
+    attr_accessor :request, :response
+  end
 end

data/lib/trackerific/parsers/base.rb

@@ -0,0 +1,35 @@
+module Trackerific
+  module Parsers
+    class Base
+      def initialize(package_id, response)
+        @package_id = package_id
+        @response = response
+      end
+
+      def parse
+        @result ||= if response_error
+          response_error
+        else
+          Trackerific::Details.new(@package_id, summary, events)
+        end
+      end
+
+      protected
+
+      def response_error
+        raise NotImplementedError,
+          "Override this method in your parser", caller
+      end
+
+      def summary
+        raise NotImplementedError,
+          "Override this method in your parser", caller
+      end
+
+      def events
+        raise NotImplementedError,
+          "Override this method in your parser", caller
+      end
+    end
+  end
+end

data/lib/trackerific/parsers/fedex.rb

@@ -0,0 +1,59 @@
+module Trackerific
+  module Parsers
+    class FedEx < Parsers::Base
+      protected
+
+      def response_error
+        @response_error ||= if highest_severity == 'ERROR'
+          Trackerific::Error.new(notifications[:message])
+        else
+          false
+        end
+      end
+
+      def summary
+        nil
+      end
+
+      def events
+        track_details.map do |detail|
+          Trackerific::Event.new(parse_date(detail), nil, location(detail))
+        end
+      end
+
+      private
+
+      def location(detail)
+        a = detail[:destination_address]
+        "#{a[:city]}, #{a[:state_or_province_code]} #{a[:country_code]}"
+      end
+
+      def parse_date(detail)
+        detail[:ship_timestamp]
+      end
+
+      def track_reply
+        @response.hash[:envelope][:body][:track_reply]
+      end
+
+      def track_details
+        @track_details ||= begin
+          details = track_reply[:completed_track_details][:track_details]
+          details.select do |d|
+            d[:ship_timestamp].present? && d[:destination_address].present? &&
+            d[:destination_address][:city].present? &&
+            d[:destination_address][:state_or_province_code].present?
+          end
+        end
+      end
+
+      def highest_severity
+        track_reply[:highest_severity]
+      end
+
+      def notifications
+        track_reply[:notifications]
+      end
+    end
+  end
+end

data/lib/trackerific/parsers/ups.rb

@@ -0,0 +1,66 @@
+module Trackerific
+  module Parsers
+    class UPS < Parsers::Base
+      protected
+
+      def response_error
+        @response_error ||= if @response.code != 200
+          Trackerific::Error.new("HTTP returned status #{@response.code}")
+        elsif response_status_code == :error
+          Trackerific::Error.new(error_response)
+        elsif response_status_code == :success
+          false
+        else
+          Trackerific::Error.new("Unknown status code from server.")
+        end
+      end
+
+      def summary
+        description(activity.first)
+      end
+
+      def events
+        activity.map do |a|
+          date = parse_ups_date_time(a['Date'], a['Time'])
+          Trackerific::Event.new(date, description(a), location(a))
+        end
+      end
+
+      private
+
+      def track_response
+        @response['TrackResponse']
+      end
+
+      def response_status_code
+        { "0" => :error,
+          "1" => :success
+        }[track_response['Response']['ResponseStatusCode']]
+      end
+
+      def error_response
+        track_response['Response']['Error']['ErrorDescription']
+      end
+
+      def parse_ups_date_time(date, time)
+        hours, minutes, seconds = time.scan(/.{2}/)
+        DateTime.parse("#{Date.parse(date)} #{hours}:#{minutes}:#{seconds}")
+      end
+
+      def description(a)
+        a['Status']['StatusType']['Description']
+      end
+
+      def location(a)
+        a['ActivityLocation']['Address'].map {|k,v| v}.join(" ")
+      end
+
+      def activity
+        @activity ||= begin
+          a = track_response['Shipment']['Package']['Activity']
+          a.is_a?(Array) ? a : [a]
+        end
+      end
+    end
+  end
+end

data/lib/trackerific/parsers/usps.rb

@@ -0,0 +1,51 @@
+module Trackerific
+  module Parsers
+    class USPS < Parsers::Base
+      protected
+
+      def response_error
+        @response_error ||= if @response.code != 200
+          Trackerific::Error.new("HTTP returned status #{@response.code}")
+        elsif @response['Error']
+          Trackerific::Error.new(@response['Error']['Description'])
+        elsif @response['TrackResponse'].nil? && @response['CityStateLookupResponse'].nil?
+          Trackerific::Error.new("Invalid response from server.")
+        else
+          false
+        end
+      end
+
+      def summary
+        tracking_info['TrackSummary']
+      end
+
+      def events
+        tracking_info.fetch('TrackDetail', []).map do |e|
+          Trackerific::Event.new(date(e), description(e), location(e))
+        end
+      end
+
+      private
+
+      def tracking_info
+        @response['TrackResponse']['TrackInfo']
+      end
+
+      def date(event)
+        d = event.split(" ")
+        DateTime.parse(d[0..3].join(" "))
+      end
+
+      def description(event)
+        d = event.split(" ")
+        d[4..d.length-4].join(" ")
+      end
+
+      def location(event)
+        d = event.gsub(".", "").split(" ")
+        city, state, zip = d.last(3)
+        "#{city}, #{state} #{zip}"
+      end
+    end
+  end
+end

data/lib/trackerific/services/base.rb

@@ -1,6 +1,8 @@
 module Trackerific
   module Services
     class Base
+      @name = nil
+
       class << self
         attr_accessor :name
 
@@ -11,15 +13,26 @@ module Trackerific
           Trackerific::Services[self.name] = self
         end
 
+        # Creates a new instance and calls #track with the given id
+        # @param id The package identifier
+        # @return Either a Trackerific::Details or Trackerific::Error
         def track(id)
-          options = Trackerific.configuration[self.name] || {}
-          new(options).track(id)
+          new.track(id)
+        end
+
+        # Reads the credentials from Trackerific.config
+        # @return [Hash] The service's credentials
+        def credentials
+          Trackerific.config[name]
         end
 
         # Checks if the given package ID can be tracked by this service
         # @param [String] id The package ID
         # @return [Boolean] true when this service can track the given ID
+        # @note This will always be false if no credentials were found for the
+        # service in Trackerific.config
         def can_track?(id)
+          return false if credentials.nil?
           package_id_matchers.each {|m| return true if id =~ m }
           false
         end
@@ -31,15 +44,15 @@ module Trackerific
             "You must implement this method in your service", caller
         end
       end
-    end
 
-    # Gets the tracking information for the package from the server
-    # @param [String] id The package identifier
-    # @return [Trackerific::Details] The tracking details
-    # @api semipublic
-    def track(id)
-      raise NotImplementedError,
-        "You must implement this method in your service", caller
+      def initialize(credentials=self.class.credentials)
+        @credentials = credentials
+
+        if credentials.nil?
+          raise Trackerific::Error,
+            "Missing credentials for #{self.class.name}", caller
+        end
+      end
     end
   end
 end

data/lib/trackerific/services/concerns/soap.rb

@@ -0,0 +1,45 @@
+module Trackerific
+  module Services
+    module Concerns
+      module SOAP
+        extend ActiveSupport::Concern
+
+        included do
+          @soap_track_operation = :track
+          @soap_builder = nil
+          @soap_parser = nil
+          @soap_wsdl = ""
+        end
+
+        module ClassMethods
+          attr_accessor :soap_track_operation
+          attr_accessor :soap_builder
+          attr_accessor :soap_parser
+          attr_accessor :soap_wsdl
+        end
+
+        def track(id)
+          operation = self.class.soap_track_operation
+          request = client.call(operation, message: builder(id).hash)
+          response = self.class.soap_parser.new(id, request).parse
+          response.is_a?(Trackerific::Error) ? raise(response) : response
+        end
+
+        protected
+
+        def builder(id)
+          members = self.class.soap_builder.members - [:package_id]
+          credentials = @credentials.values_at(*members)
+          credentials << id
+          self.class.soap_builder.new(*credentials)
+        end
+
+        def client
+          @client ||= Savon.client(
+            convert_request_keys_to: :camelcase,
+            wsdl: Trackerific::SOAP::WSDL.path(self.class.soap_wsdl))
+        end
+      end
+    end
+  end
+end

data/lib/trackerific/services/concerns/xml.rb

@@ -0,0 +1,44 @@
+module Trackerific
+  module Services
+    module Concerns
+      module XML
+        extend ActiveSupport::Concern
+
+        included do
+          @xml_endpoint = ""
+          @xml_parser = nil
+          @xml_builder = nil
+        end
+
+        module ClassMethods
+          attr_accessor :xml_endpoint
+          attr_accessor :xml_parser
+          attr_accessor :xml_builder
+        end
+
+        # Gets the tracking information for the package from the server
+        # @param [String] id The package identifier
+        # @return [Trackerific::Details] The tracking details
+        # @api semipublic
+        def track(id)
+          response = self.class.xml_parser.new(id, http_response(id)).parse
+          raise(response) if response.is_a?(Trackerific::Error)
+          return response
+        end
+
+        protected
+
+        def http_response(id)
+          self.class.post(self.class.xml_endpoint, body: builder(id).xml)
+        end
+
+        def builder(id)
+          members = self.class.xml_builder.members - [:package_id]
+          credentials = @credentials.values_at(*members)
+          credentials << id
+          self.class.xml_builder.new(*credentials)
+        end
+      end
+    end
+  end
+end

data/lib/trackerific/services/fedex.rb

@@ -1,91 +1,21 @@
-require 'httparty'
-require 'builder'
-
 module Trackerific
   module Services
     class FedEx < Base
-      include ::HTTParty
+      require 'trackerific/builders/fedex'
+      require 'trackerific/parsers/fedex'
+
+      include Concerns::SOAP
 
-      format :xml
-      base_uri "https://gateway.fedex.com"
+      register :fedex
 
-      self.register :fedex
+      self.soap_track_operation = :track
+      self.soap_builder = Builders::FedEx
+      self.soap_parser = Parsers::FedEx
+      self.soap_wsdl = 'fedex/TrackService_v8'
 
-      # An Array of Regexp that matches valid FedEx package IDs
-      # @return [Array, Regexp] the regular expression
-      # @api private
       def self.package_id_matchers
         [ /^[0-9]{15}$/ ]
       end
-
-      def initialize(options={})
-        @options = options
-      end
-
-      # Tracks a FedEx package
-      # @param [String] package_id the package identifier
-      # @return [Trackerific::Details] the tracking details
-      # @raise [Trackerific::Error] raised when the server returns an error (invalid credentials, tracking package, etc.)
-      # @example Track a package
-      #   fedex = Trackerific::FedEx.new :account => 'account', :meter => 'meter'
-      #   details = fedex.track_package("183689015000001")
-      # @api public
-      def track(package_id)
-        # request tracking information from FedEx via HTTParty
-        http_response = self.class.post "/GatewayDC", body: build_xml_request
-        # raise any HTTP errors
-        http_response.error! unless http_response.code == 200
-        # get the tracking information from the reply
-        track_reply = http_response["FDXTrack2Reply"]
-        # raise a Trackerific::Error if there is an error in the reply
-        raise Trackerific::Error, track_reply["Error"]["Message"] unless track_reply["Error"].nil?
-        # get the details from the reply
-        details = track_reply["Package"]
-        # convert them into Trackerific::Events
-        events = []
-        details["Event"].each do |e|
-          date = Time.parse("#{e["Date"]} #{e["Time"]}")
-          desc = e["Description"]
-          addr = e["Address"]
-          loc = "#{addr["StateOrProvinceCode"]} #{addr["PostalCode"]}"
-          events << Trackerific::Event.new(date, desc, loc)
-        end
-        # Return a Trackerific::Details containing all the events
-        Trackerific::Details.new(
-          details["TrackingNumber"], details["StatusDescription"], events
-        )
-      end
-
-      private
-
-      # Builds the XML request to send to FedEx
-      # @return [String] a FDXTrack2Request XML
-      # @api private
-      def build_xml_request
-        xml = ""
-        # the API namespace
-        xmlns_api = "http://www.fedex.com/fsmapi"
-        # the XSI namespace
-        xmlns_xsi = "http://www.w3.org/2001/XMLSchema-instance"
-        # the XSD namespace
-        xsi_noNSL = "FDXTrack2Request.xsd"
-        # create a new Builder to generate the XML
-        builder = ::Builder::XmlMarkup.new(:target => xml)
-        # add the XML header
-        builder.instruct! :xml, :version => "1.0", :encoding => "UTF-8"
-        # Build, and return the request
-        builder.FDXTrack2Request "xmlns:api"=>xmlns_api, "xmlns:xsi"=>xmlns_xsi, "xsi:noNamespaceSchemaLocation" => xsi_noNSL do |r|
-          r.RequestHeader do |rh|
-            rh.AccountNumber @options[:account]
-            rh.MeterNumber @options[:meter]
-          end
-          r.PackageIdentifier do |pi|
-            pi.Value @package_id
-          end
-          r.DetailScans true
-        end
-        xml
-      end
     end
   end
 end