active_fulfillment 2.1.9 → 3.0.0.pre2

data/lib/active_fulfillment/fulfillment/services/shipwire.rb

@@ -1,268 +0,0 @@
-require 'cgi'
-
-module ActiveMerchant
-  module Fulfillment
-    class ShipwireService < Service
-
-      SERVICE_URLS = { :fulfillment  => 'https://api.shipwire.com/exec/FulfillmentServices.php',
-                       :inventory    => 'https://api.shipwire.com/exec/InventoryServices.php',
-                       :tracking     => 'https://api.shipwire.com/exec/TrackingServices.php'
-                     }
-
-      SCHEMA_URLS = { :fulfillment => 'http://www.shipwire.com/exec/download/OrderList.dtd',
-                      :inventory   => 'http://www.shipwire.com/exec/download/InventoryUpdate.dtd',
-                      :tracking    => 'http://www.shipwire.com/exec/download/TrackingUpdate.dtd'
-                    }
-
-      POST_VARS = { :fulfillment => 'OrderListXML',
-                    :inventory   => 'InventoryUpdateXML',
-                    :tracking    => 'TrackingUpdateXML'
-                  }
-
-      WAREHOUSES = { 'CHI' => 'Chicago',
-                     'LAX' => 'Los Angeles',
-                     'REN' => 'Reno',
-                     'VAN' => 'Vancouver',
-                     'TOR' => 'Toronto',
-                     'UK'  => 'United Kingdom'
-                   }
-
-      INVALID_LOGIN = /(Error with Valid Username\/EmailAddress and Password Required)|(Could not verify Username\/EmailAddress and Password combination)/
-
-      class_attribute :affiliate_id
-
-      # The first is the label, and the last is the code
-      def self.shipping_methods
-        [ ['1 Day Service',   '1D'],
-          ['2 Day Service',   '2D'],
-          ['Ground Service',  'GD'],
-          ['Freight Service', 'FT'],
-          ['International', 'INTL']
-        ].inject(ActiveSupport::OrderedHash.new){|h, (k,v)| h[k] = v; h}
-      end
-
-      # Pass in the login and password for the shipwire account.
-      # Optionally pass in the :test => true to force test mode
-      def initialize(options = {})
-        requires!(options, :login, :password)
-
-        super
-      end
-
-      def fulfill(order_id, shipping_address, line_items, options = {})
-        commit :fulfillment, build_fulfillment_request(order_id, shipping_address, line_items, options)
-      end
-
-      def fetch_stock_levels(options = {})
-        commit :inventory, build_inventory_request(options)
-      end
-
-      def fetch_tracking_data(order_ids, options = {})
-        commit :tracking, build_tracking_request(order_ids)
-      end
-
-      def valid_credentials?
-        response = fetch_tracking_numbers([])
-        response.message !~ INVALID_LOGIN
-      end
-
-      def test_mode?
-        true
-      end
-
-      def include_pending_stock?
-        @options[:include_pending_stock]
-      end
-
-      def include_empty_stock?
-        @options[:include_empty_stock]
-      end
-
-      private
-      def build_fulfillment_request(order_id, shipping_address, line_items, options)
-        xml = Builder::XmlMarkup.new :indent => 2
-        xml.instruct!
-        xml.declare! :DOCTYPE, :OrderList, :SYSTEM, SCHEMA_URLS[:fulfillment]
-        xml.tag! 'OrderList' do
-          add_credentials(xml)
-          xml.tag! 'Referer', 'Active Fulfillment'
-          add_order(xml, order_id, shipping_address, line_items, options)
-        end
-        xml.target!
-      end
-
-      def build_inventory_request(options)
-        xml = Builder::XmlMarkup.new :indent => 2
-        xml.instruct!
-        xml.declare! :DOCTYPE, :InventoryStatus, :SYSTEM, SCHEMA_URLS[:inventory]
-        xml.tag! 'InventoryUpdate' do
-          add_credentials(xml)
-          xml.tag! 'Warehouse', WAREHOUSES[options[:warehouse]]
-          xml.tag! 'ProductCode', options[:sku]
-          xml.tag! 'IncludeEmpty' if include_empty_stock?
-        end
-      end
-
-      def build_tracking_request(order_ids)
-        xml = Builder::XmlMarkup.new
-        xml.instruct!
-        xml.declare! :DOCTYPE, :InventoryStatus, :SYSTEM, SCHEMA_URLS[:inventory]
-        xml.tag! 'TrackingUpdate' do
-          add_credentials(xml)
-          xml.tag! 'Server', test? ? 'Test' : 'Production'
-          order_ids.each do |o_id|
-            xml.tag! 'OrderNo', o_id
-          end
-        end
-      end
-
-      def add_credentials(xml)
-        xml.tag! 'EmailAddress', @options[:login]
-        xml.tag! 'Password', @options[:password]
-        xml.tag! 'Server', test? ? 'Test' : 'Production'
-        xml.tag! 'AffiliateId', affiliate_id if affiliate_id.present?
-      end
-
-      def add_order(xml, order_id, shipping_address, line_items, options)
-        xml.tag! 'Order', :id => order_id do
-          xml.tag! 'Warehouse', options[:warehouse] || '00'
-
-          add_address(xml, shipping_address, options)
-          xml.tag! 'Shipping', options[:shipping_method] unless options[:shipping_method].blank?
-
-          Array(line_items).each_with_index do |line_item, index|
-            add_item(xml, line_item, index)
-          end
-          xml.tag! 'Note' do
-            xml.cdata! options[:note] unless options[:note].blank?
-          end
-        end
-      end
-
-      def add_address(xml, address, options)
-        xml.tag! 'AddressInfo', :type => 'Ship' do
-          xml.tag! 'Name' do
-            xml.tag! 'Full', address[:name]
-          end
-
-          xml.tag! 'Address1', address[:address1]
-          xml.tag! 'Address2', address[:address2]
-
-          xml.tag! 'Company', address[:company]
-
-          xml.tag! 'City', address[:city]
-          xml.tag! 'State', address[:state] unless address[:state].blank?
-          xml.tag! 'Country', address[:country]
-
-          xml.tag! 'Zip', address[:zip]
-          xml.tag! 'Phone', address[:phone] unless address[:phone].blank?
-          xml.tag! 'Email', options[:email] unless options[:email].blank?
-        end
-      end
-
-      # Code is limited to 12 characters
-      def add_item(xml, item, index)
-        xml.tag! 'Item', :num => index do
-          xml.tag! 'Code', item[:sku]
-          xml.tag! 'Quantity', item[:quantity]
-        end
-      end
-
-      def commit(action, request)
-        data = ssl_post(SERVICE_URLS[action], "#{POST_VARS[action]}=#{CGI.escape(request)}")
-
-        response = parse_response(action, data)
-        Response.new(response[:success], response[:message], response, :test => test?)
-      end
-
-      def parse_response(action, data)
-        case action
-        when :fulfillment
-          parse_fulfillment_response(data)
-        when :inventory
-          parse_inventory_response(data)
-        when :tracking
-          parse_tracking_response(data)
-        else
-          raise ArgumentError, "Unknown action #{action}"
-        end
-      end
-
-      def parse_fulfillment_response(xml)
-        response = {}
-
-        document = REXML::Document.new(xml)
-        document.root.elements.each do |node|
-          response[node.name.underscore.to_sym] = text_content(node)
-        end
-
-        response[:success] = response[:status] == '0'
-        response[:message] = response[:success] ? "Successfully submitted the order" : message_from(response[:error_message])
-        response
-      end
-
-      def parse_inventory_response(xml)
-        response = {}
-        response[:stock_levels] = {}
-
-        document = REXML::Document.new(xml)
-        document.root.elements.each do |node|
-          if node.name == 'Product'
-            to_check = ['quantity']
-            to_check << 'pending' if include_pending_stock?
-
-            amount = to_check.sum { |a| node.attributes[a].to_i }
-            response[:stock_levels][node.attributes['code']] = amount
-          else
-            response[node.name.underscore.to_sym] = text_content(node)
-          end
-        end
-
-        response[:success] = test? ? response[:status] == 'Test' : response[:status] == '0'
-        response[:message] = response[:success] ? "Successfully received the stock levels" : message_from(response[:error_message])
-
-        response
-      end
-
-      def parse_tracking_response(xml)
-        response = {}
-        response[:tracking_numbers] = {}
-        response[:tracking_companies] = {}
-        response[:tracking_urls] = {}
-
-        document = REXML::Document.new(xml)
-        document.root.elements.each do |node|
-          if node.name == 'Order'
-            if node.attributes["shipped"] == "YES" && node.elements['TrackingNumber']
-              tracking_number = node.elements['TrackingNumber'].text.strip
-              response[:tracking_numbers][node.attributes['id']] = [tracking_number]
-
-              tracking_company = node.elements['TrackingNumber'].attributes['carrier']
-              response[:tracking_companies][node.attributes['id']] = [tracking_company.strip] if tracking_company
-
-              tracking_url = node.elements['TrackingNumber'].attributes['href']
-              response[:tracking_urls][node.attributes['id']] = [tracking_url.strip] if tracking_url
-            end
-          else
-            response[node.name.underscore.to_sym] = text_content(node)
-          end
-        end
-
-        response[:success] = test? ? (response[:status] == '0' || response[:status] == 'Test') : response[:status] == '0'
-        response[:message] = response[:success] ? "Successfully received the tracking numbers" : message_from(response[:error_message])
-        response
-      end
-
-      def message_from(string)
-        return if string.blank?
-        string.gsub("\n", '').squeeze(" ")
-      end
-
-      def text_content(xml_node)
-        text = xml_node.text
-        text = xml_node.cdatas.join if text.blank?
-        text
-      end
-    end
-  end
-end

data/lib/active_fulfillment/fulfillment/services/shopify_api.rb

@@ -1,125 +0,0 @@
-module ActiveMerchant
-  module Fulfillment
-    class ShopifyAPIService < Service
-
-      OrderIdCutoffDate = Date.iso8601("2015-03-01")
-
-      RESCUABLE_CONNECTION_ERRORS = [
-        Net::ReadTimeout,
-        Net::OpenTimeout,
-        TimeoutError,
-        Errno::ETIMEDOUT,
-        Timeout::Error,
-        IOError,
-        EOFError,
-        SocketError,
-        Errno::ECONNRESET,
-        Errno::ECONNABORTED,
-        Errno::EPIPE,
-        Errno::ECONNREFUSED,
-        Errno::EAGAIN,
-        Errno::EHOSTUNREACH,
-        Errno::ENETUNREACH,
-        Resolv::ResolvError,
-        Net::HTTPBadResponse,
-        Net::HTTPHeaderSyntaxError,
-        Net::ProtocolError,
-        ActiveMerchant::ConnectionError,
-        ActiveMerchant::ResponseError,
-        ActiveMerchant::InvalidResponseError
-      ]
-
-      def initialize(options = {})
-        @name = options[:name]
-        @callback_url = options[:callback_url]
-        @format = options[:format]
-      end
-
-      def fulfill(order_id, shipping_address, line_items, options = {})
-        raise NotImplementedError.new("Shopify API Service must listen to fulfillment/create Webhooks")
-      end
-
-      def fetch_stock_levels(options = {})
-        response = send_app_request('fetch_stock', options.delete(:headers), options)
-        if response
-          stock_levels = parse_response(response, 'StockLevels', 'Product', 'Sku', 'Quantity') { |p| p.to_i }
-          Response.new(true, "API stock levels", {:stock_levels => stock_levels})
-        else
-          Response.new(false, "Unable to fetch remote stock levels")
-        end
-      end
-
-      def fetch_tracking_data(order_numbers, options = {})
-        options.merge!({:order_ids => order_numbers, :order_names => order_numbers})
-        response = send_app_request('fetch_tracking_numbers', options.delete(:headers), options)
-        if response
-          tracking_numbers = parse_response(response, 'TrackingNumbers', 'Order', 'ID', 'Tracking') { |o| o }
-          Response.new(true, "API tracking_numbers", {:tracking_numbers => tracking_numbers,
-                                                      :tracking_companies => {},
-                                                      :tracking_urls => {}})
-        else
-          Response.new(false, "Unable to fetch remote tracking numbers #{order_numbers.inspect}")
-        end
-      end
-
-      private
-
-      def request_uri(action, data)
-        URI.parse "#{@callback_url}/#{action}.#{@format}?#{data.to_param}"
-      end
-
-      def send_app_request(action, headers, data)
-        uri = request_uri(action, data)
-
-        logger.info "[" + @name.upcase + " APP] Post #{uri}"
-
-        response = nil
-        realtime = Benchmark.realtime do
-          begin
-            Timeout.timeout(20.seconds) do
-              response = ssl_get(uri, headers)
-            end
-          rescue *(RESCUABLE_CONNECTION_ERRORS) => e
-            logger.warn "[#{self}] Error while contacting fulfillment service error =\"#{e.message}\""
-          end
-        end
-
-        line = "[" + @name.upcase + "APP] Response from #{uri} --> "
-        line << "#{response} #{"%.4fs" % realtime}"
-        logger.info line
-
-        response
-      end
-
-      def parse_response(response, root, type, key, value)
-        case @format
-        when 'json'
-          response_data = ActiveSupport::JSON.decode(response)
-          return {} unless response_data.is_a?(Hash)
-          response_data[root.underscore] || response_data
-        when 'xml'
-          response_data = {}
-          document = REXML::Document.new(response)
-          document.elements[root].each do |node|
-            if node.name == type
-              response_data[node.elements[key].text] = node.elements[value].text
-            end
-          end
-          response_data
-        end
-
-      rescue ActiveSupport::JSON.parse_error, REXML::ParseException
-        {}
-      end
-
-      def encode_payload(payload, root)
-        case @format
-        when 'json'
-          {root => payload}.to_json
-        when 'xml'
-          payload.to_xml(:root => root)
-        end
-      end
-    end
-  end
-end

data/lib/active_fulfillment/fulfillment/services/webgistix.rb

@@ -1,338 +0,0 @@
-module ActiveMerchant
-  module Fulfillment
-    class WebgistixService < Service
-      SERVICE_URLS = {
-        :fulfillment => 'https://www.webgistix.com/XML/CreateOrder.asp',
-        :inventory   => 'https://www.webgistix.com/XML/GetInventory.asp',
-        :tracking    => 'https://www.webgistix.com/XML/GetTracking.asp'
-      }
-      TEST_URLS = SERVICE_URLS.merge({
-        :fulfillment => 'https://www.webgistix.com/XML/CreateOrderTest.asp'
-      })
-
-      SUCCESS, DUPLICATE, FAILURE = 'True', 'Duplicate', 'False'
-
-      SUCCESS_MESSAGE = 'Successfully submitted the order'
-      FAILURE_MESSAGE = 'Failed to submit the order'
-      DUPLICATE_MESSAGE = 'This order has already been successfully submitted'
-
-      INVALID_LOGIN = 'Invalid Credentials'
-      NOT_SHIPPED = 'Not Shipped'
-
-      TRACKING_COMPANIES = %w(UPS FedEx USPS)
-
-      # If a request is detected as a duplicate only the original data will be
-      # used by Webgistix, and the subsequent responses will have a
-      # :duplicate parameter set in the params hash.
-      self.retry_safe = true
-
-      # The first is the label, and the last is the code
-      def self.shipping_methods
-        [
-          ["UPS Ground Shipping", "Ground"],
-          ["UPS Ground", "Ground"],
-          ["UPS Standard Shipping (Canada Only)", "Standard"],
-          ["UPS Standard Shipping (CA & MX Only)", "Standard"],
-          ["UPS 3-Business Day", "3-Day Select"],
-          ["UPS 2-Business Day", "2nd Day Air"],
-          ["UPS 2-Business Day AM", "2nd Day Air AM"],
-          ["UPS Next Day", "Next Day Air"],
-          ["UPS Next Day Saver", "Next Day Air Saver"],
-          ["UPS Next Day Early AM", "Next Day Air Early AM"],
-          ["UPS Worldwide Express (Next Day)", "Worldwide Express"],
-          ["UPS Worldwide Expedited (2nd Day)", "Worldwide Expedited"],
-          ["UPS Worldwide Express Saver", "Worldwide Express Saver"],
-          ["FedEx Priority Overnight", "FedEx Priority Overnight"],
-          ["FedEx Standard Overnight", "FedEx Standard Overnight"],
-          ["FedEx First Overnight", "FedEx First Overnight"],
-          ["FedEx 2nd Day", "FedEx 2nd Day"],
-          ["FedEx Express Saver", "FedEx Express Saver"],
-          ["FedEx International Priority", "FedEx International Priority"],
-          ["FedEx International Economy", "FedEx International Economy"],
-          ["FedEx International First", "FedEx International First"],
-          ["FedEx Ground", "FedEx Ground"],
-          ["USPS Priority Mail", "Priority Mail"],
-          ["USPS Priority Mail International", "Priority Mail International"],
-          ["USPS Priority Mail Small Flat Rate Box", "Priority Mail Small Flat Rate Box"],
-          ["USPS Priority Mail Medium Flat Rate Box", "Priority Mail Medium Flat Rate Box"],
-          ["USPS Priority Mail Large Flat Rate Box", "Priority Mail Large Flat Rate Box"],
-          ["USPS Priority Mail Flat Rate Envelope", "Priority Mail Flat Rate Envelope"],
-          ["USPS First Class Mail", "First Class"],
-          ["USPS First Class International", "First Class International"],
-          ["USPS Express Mail", "Express"],
-          ["USPS Express Mail International", "Express Mail International"],
-          ["USPS Parcel Post", "Parcel"],
-          ["USPS Media Mail", "Media Mail"]
-        ].inject(ActiveSupport::OrderedHash.new){|h, (k,v)| h[k] = v; h}
-      end
-
-      # Pass in the login and password for the shipwire account.
-      # Optionally pass in the :test => true to force test mode
-      def initialize(options = {})
-        requires!(options, :login, :password)
-        super
-      end
-
-      def fulfill(order_id, shipping_address, line_items, options = {})
-        requires!(options, :shipping_method)
-        commit :fulfillment, build_fulfillment_request(order_id, shipping_address, line_items, options)
-      end
-
-      def fetch_stock_levels(options = {})
-        commit :inventory, build_inventory_request(options)
-      end
-
-      def fetch_tracking_data(order_ids, options = {})
-        commit :tracking, build_tracking_request(order_ids, options)
-      end
-
-      def valid_credentials?
-        response = fulfill('', {}, [], :shipping_method => '')
-        response.message != INVALID_LOGIN
-      end
-
-      def test_mode?
-        true
-      end
-
-      private
-      #<?xml version="1.0"?>
-      # <OrderXML>
-      #   <Password>Webgistix</Password>
-      #   <CustomerID>3</CustomerID>
-      #   <Order>
-      #     <ReferenceNumber></ReferenceNumber>
-      #     <Company>Test Company</Company>
-      #     <Name>Joe Smith</Name>
-      #     <Address1>123 Main St.</Address1>
-      #     <Address2></Address2>
-      #     <Address3></Address3>
-      #     <City>Olean</City>
-      #     <State>NY</State>
-      #     <ZipCode>14760</ZipCode>
-      #     <Country>United States</Country>
-      #     <Email>info@webgistix.com</Email>
-      #     <Phone>1-123-456-7890</Phone>
-      #     <ShippingInstructions>Ground</ShippingInstructions>
-      #     <OrderComments>Test Order</OrderComments>
-      #     <Approve>0</Approve>
-      #     <Item>
-      #      <ItemID>testitem</ItemID>
-      #      <ItemQty>2</ItemQty>
-      #     </Item>
-      #   </Order>
-      # </OrderXML>
-      def build_fulfillment_request(order_id, shipping_address, line_items, options)
-        xml = Builder::XmlMarkup.new :indent => 2
-        xml.instruct!
-        xml.tag! 'OrderXML' do
-          add_credentials(xml)
-          add_order(xml, order_id, shipping_address, line_items, options)
-        end
-        xml.target!
-      end
-
-      #<?xml version="1.0"?>
-      # <InventoryXML>
-      #   <Password>Webgistix</Password>
-      #   <CustomerID>3</CustomerID>
-      # </InventoryXML>
-      def build_inventory_request(options)
-        xml = Builder::XmlMarkup.new :indent => 2
-        xml.instruct!
-        xml.tag! 'InventoryXML' do
-          add_credentials(xml)
-        end
-      end
-
-      #<?xml version="1.0"?>
-      # <TrackingXML>
-      #   <Password>Webgistix</Password>
-      #   <CustomerID>3</CustomerID>
-      #   <Tracking>
-      #     <Order>AB12345</Order>
-      #   </Tracking>
-      #   <Tracking>
-      #     <Order>XY4567</Order>
-      #   </Tracking>
-      # </TrackingXML>
-      def build_tracking_request(order_ids, options)
-        xml = Builder::XmlMarkup.new :indent => 2
-        xml.instruct!
-        xml.tag! 'TrackingXML' do
-          add_credentials(xml)
-
-          order_ids.each do |o_id|
-            xml.tag! 'Tracking' do
-              xml.tag! 'Order', o_id
-            end
-          end
-        end
-      end
-
-      def add_credentials(xml)
-        xml.tag! 'CustomerID', @options[:login]
-        xml.tag! 'Password', @options[:password]
-      end
-
-      def add_order(xml, order_id, shipping_address, line_items, options)
-        xml.tag! 'Order' do
-          xml.tag! 'ReferenceNumber', order_id
-          xml.tag! 'ShippingInstructions', options[:shipping_method]
-          xml.tag! 'Approve', 1
-          xml.tag! 'OrderComments', options[:comment] unless options[:comment].blank?
-
-          add_address(xml, shipping_address, options)
-
-          Array(line_items).each_with_index do |line_item, index|
-            add_item(xml, line_item, index)
-          end
-        end
-      end
-
-      def add_address(xml, address, options)
-        xml.tag! 'Name', address[:name]
-        xml.tag! 'Address1', address[:address1]
-        xml.tag! 'Address2', address[:address2] unless address[:address2].blank?
-        xml.tag! 'Address3', address[:address3] unless address[:address3].blank?
-        xml.tag! 'City', address[:city]
-        xml.tag! 'State', address[:state]
-        xml.tag! 'ZipCode', address[:zip]
-        xml.tag! 'Company', address[:company]
-
-        unless address[:country].blank?
-          country = Country.find(address[:country])
-          xml.tag! 'Country', country.name
-        end
-
-        xml.tag! 'Phone', address[:phone]
-        xml.tag! 'Email', options[:email] unless options[:email].blank?
-      end
-
-      def add_item(xml, item, index)
-        xml.tag! 'Item' do
-          xml.tag! 'ItemID', item[:sku] unless item[:sku].blank?
-          xml.tag! 'ItemQty', item[:quantity] unless item[:quantity].blank?
-        end
-      end
-
-      def commit(action, request)
-        url = test? ? TEST_URLS[action] : SERVICE_URLS[action]
-
-        data = ssl_post(url, request,
-          'EndPointURL'  => url,
-          'Content-Type' => 'text/xml; charset="utf-8"'
-        )
-
-        response = parse_response(action, data)
-        Response.new(success?(response), message_from(response), response, :test => test?)
-      end
-
-      def success?(response)
-        response[:success] == SUCCESS || response[:success] == DUPLICATE
-      end
-
-      def message_from(response)
-        if response[:duplicate]
-          DUPLICATE_MESSAGE
-        elsif success?(response)
-          SUCCESS_MESSAGE
-        elsif response[:error_0] == INVALID_LOGIN
-          INVALID_LOGIN
-        else
-          FAILURE_MESSAGE
-        end
-      end
-
-      def parse_response(action, xml)
-        begin
-          document = REXML::Document.new("<response>#{xml}</response>")
-        rescue REXML::ParseException
-          return {:success => FAILURE}
-        end
-
-        case action
-        when :fulfillment
-          parse_fulfillment_response(document)
-        when :inventory
-          parse_inventory_response(document)
-        when :tracking
-          parse_tracking_response(document)
-        else
-          raise ArgumentError, "Unknown action #{action}"
-        end
-      end
-
-      def parse_fulfillment_response(document)
-        response = parse_errors(document)
-
-        # Check if completed
-        if completed = REXML::XPath.first(document, '//Completed')
-          completed.elements.each do |e|
-            response[e.name.underscore.to_sym] = e.text
-          end
-        else
-          response[:success] = FAILURE
-        end
-
-        response[:duplicate] = response[:success] == DUPLICATE
-
-        response
-      end
-
-      def parse_inventory_response(document)
-        response = parse_errors(document)
-        response[:stock_levels] = {}
-
-        document.root.each_element('//Item') do |node|
-          # {ItemID => 'SOME-ID', ItemQty => '101'}
-          params = node.elements.to_a.each_with_object({}) {|elem, hash| hash[elem.name] = elem.text}
-
-          response[:stock_levels][params['ItemID']] = params['ItemQty'].to_i
-        end
-
-        response
-      end
-
-      def parse_tracking_response(document)
-        response = parse_errors(document)
-        response[:tracking_numbers] = {}
-        response[:tracking_companies] = {}
-        response[:tracking_urls] = {}
-
-        document.root.each_element('//Shipment') do |node|
-          # {InvoiceNumber => 'SOME-ID', ShipmentTrackingNumber => 'SOME-TRACKING-NUMBER'}
-          params = node.elements.to_a.each_with_object({}) {|elem, hash| hash[elem.name] = elem.text}
-
-          tracking = params['ShipmentTrackingNumber']
-
-          unless tracking == NOT_SHIPPED
-            response[:tracking_numbers][params['InvoiceNumber']] ||= []
-            response[:tracking_numbers][params['InvoiceNumber']] << tracking
-          end
-
-          company = params['Method'].split[0] if params['Method']
-          if TRACKING_COMPANIES.include? company
-            response[:tracking_companies][params['InvoiceNumber']] ||= []
-            response[:tracking_companies][params['InvoiceNumber']] << company
-          end
-        end
-
-        response
-      end
-
-      def parse_errors(document)
-        response = {}
-
-        REXML::XPath.match(document, "//Errors/Error").to_a.each_with_index do |e, i|
-          response["error_#{i}".to_sym] = e.text
-        end
-
-        response[:success] = response.empty? ? SUCCESS : FAILURE
-        response
-      end
-    end
-  end
-end
-
-