CnpOnline 11.4.0 → 12.1.0

data/lib/{LitleRequest.rb → CnpRequest.rb}

@@ -29,10 +29,9 @@ require 'open3'
 
 include Socket::Constants
 #
-# This class handles sending the Litle Request (which is actually a series of batches!)
+# This class handles sending the Cnp Request (which is actually a series of batches!)
 #
 
-
 SFTP_USERNAME_CONFIG_NAME = :sftp_username
 SFTP_PASSWORD_CONFIG_NAME = :sftp_password
 SFTP_URL_CONFIG_NAME = :sftp_url
@@ -50,9 +49,9 @@ SENT_FILE_SUFFIX = '.sent'
 RECEIVED_FILE_SUFFIX = '.received'
 COMPLETE_FILE_SUFFIX = '.complete'
 
-module LitleOnline
-  class LitleRequest
-    #include XML::Mapping
+module CnpOnline
+  class CnpRequest
+    include XML::Mapping
     def initialize(options = {})
       #load configuration data
       @config_hash = Configuration.new.config
@@ -64,23 +63,23 @@ module LitleOnline
       @options = options
       # current time out set to 2 mins
       # this value is in seconds
-      @RESPONSE_TIME_OUT = 520
+      @RESPONSE_TIME_OUT = 5200
       @POLL_DELAY = 0
       @responses_expected = 0
     end
 
-    # Creates the necessary files for the LitleRequest at the path specified. path/request_(TIMESTAMP) will be
+    # Creates the necessary files for the CnpRequest at the path specified. path/request_(TIMESTAMP) will be
     # the final XML markup and path/request_(TIMESTAMP) will hold intermediary XML markup
     # Params:
     # +path+:: A +String+ containing the path to the folder on disc to write the files to
-    def create_new_litle_request(path)
+    def create_new_cnp_request(path)
       ts = Time::now.to_i.to_s
       begin
         ts += Time::now.nsec.to_s
       rescue NoMethodError # ruby 1.8.7 fix
         ts += Time::now.usec.to_s
-      end
-
+      end 
+      
       if(File.file?(path)) then
         raise RuntimeError, "Entered a file not a path."
       end
@@ -92,13 +91,12 @@ module LitleOnline
       if !File.directory?(path) then
         Dir.mkdir(path)
       end
-
+      
       @path_to_request = path + REQUEST_FILE_PREFIX + ts
       @path_to_batches = @path_to_request + '_batches'
 
       if File.file?(@path_to_request) or File.file?(@path_to_batches) then
-        create_new_litle_request(path)
-
+        create_new_cnp_request(path)
         return
       end
 
@@ -110,30 +108,30 @@ module LitleOnline
       end
     end
 
-    # Adds a batch to the LitleRequest. If the batch is open when passed, it will be closed prior to being added.
+    # Adds a batch to the CnpRequest. If the batch is open when passed, it will be closed prior to being added.
     # Params:
-    # +arg+:: a +LitleBatchRequest+ containing the transactions you wish to send or a +String+ specifying the
+    # +arg+:: a +CnpBatchRequest+ containing the transactions you wish to send or a +String+ specifying the
     # path to the batch file
     def commit_batch(arg)
       path_to_batch = ""
       #they passed a batch
-      if arg.kind_of?(LitleBatchRequest) then
+      if arg.kind_of?(CnpBatchRequest) then
         path_to_batch = arg.get_batch_name
-        if((au = arg.get_au_batch) != nil) then
+        if((au = arg.get_au_batch) != nil) then 
           # also commit the account updater batch
           commit_batch(au)
         end
-      elsif arg.kind_of?(LitleAUBatch) then
+      elsif arg.kind_of?(CnpAUBatch) then
         path_to_batch = arg.get_batch_name
       elsif arg.kind_of?(String) then
         path_to_batch = arg
       else
-        raise RuntimeError, "You entered neither a path nor a batch."
+        raise RuntimeError, "You entered neither a path nor a batch. Game over :("
       end
       #the batch isn't closed. let's help a brother out
       if (ind = path_to_batch.index(/\.closed/)) == nil then
         if arg.kind_of?(String) then
-          new_batch = LitleBatchRequest.new
+          new_batch = CnpBatchRequest.new
           new_batch.open_existing_batch(path_to_batch)
           new_batch.close_batch()
           path_to_batch = new_batch.get_batch_name
@@ -142,79 +140,79 @@ module LitleOnline
           if(new_batch.get_au_batch != nil) then
             File.remove(path_to_batch)
             path_to_batch = new_batch.get_au_batch.get_batch_name
-          end
-        elsif arg.kind_of?(LitleBatchRequest) then
+          end 
+        elsif arg.kind_of?(CnpBatchRequest) then
           arg.close_batch()
           path_to_batch = arg.get_batch_name
-        elsif arg.kind_of?(LitleAUBatch) then
+        elsif arg.kind_of?(CnpAUBatch) then
           arg.close_batch()
-          path_to_batch = arg.get_batch_name
+          path_to_batch = arg.get_batch_name 
         end
         ind = path_to_batch.index(/\.closed/)
       end
       transactions_in_batch = path_to_batch[ind+8..path_to_batch.length].to_i
 
-      # if the litle request would be too big, let's make another!
+      # if the cnp request would be too big, let's make another!
       if (@num_total_transactions + transactions_in_batch) > @MAX_NUM_TRANSACTIONS then
         finish_request
         initialize(@options)
-        create_new_litle_request    #(path_to_batch)
+        create_new_cnp_request
       else #otherwise, let's add it line by line to the request doc
-        # @num_batch_requests += 1
+       # @num_batch_requests += 1
         #how long we wnat to wait around for the FTP server to get us a response
         @RESPONSE_TIME_OUT += 90 + (transactions_in_batch * 0.25)
         #don't start looking until there could possibly be a response
         @POLL_DELAY += 30 +(transactions_in_batch  * 0.02)
         @num_total_transactions += transactions_in_batch
-        # Don't add empty batches
-        @num_batch_requests += 1 unless transactions_in_batch.eql?(0)
+         # Don't add empty batches
+       @num_batch_requests += 1 unless transactions_in_batch.eql?(0)
         File.open(@path_to_batches, 'a+') do |fo|
           File.foreach(path_to_batch) do |li|
             fo.puts li
           end
         end
-
+        
         File.delete(path_to_batch)
       end
     end
 
-    # Adds an RFRRequest to the LitleRequest.
-    # params:
-    # +options+:: a required +Hash+ containing configuration info for the RFRRequest. If the RFRRequest is for a batch, then the
-    # litleSessionId is required as a key/val pair. If the RFRRequest is for account updater, then merchantId and postDay are required
+    # Adds an RFRRequest to the CnpRequest.
+    # params: 
+    # +options+:: a required +Hash+ containing configuration info for the RFRRequest. If the RFRRequest is for a batch, then the 
+    # cnpSessionId is required as a key/val pair. If the RFRRequest is for account updater, then merchantId and postDay are required
     # as key/val pairs.
-    # +path+:: optional path to save the new litle request containing the RFRRequest at
+    # +path+:: optional path to save the new cnp request containing the RFRRequest at
     def add_rfr_request(options, path = (File.dirname(@path_to_batches)))
-
-      rfrrequest = LitleRFRRequest.new
-      if(options['litleSessionId']) then
-        rfrrequest.litleSessionId = options['litleSessionId']
+     
+      rfrrequest = CnpRFRRequest.new
+      if(options['cnpSessionId']) then
+        rfrrequest.cnpSessionId = options['cnpSessionId']
       elsif(options['merchantId'] and options['postDay']) then
         accountUpdate = AccountUpdateFileRequestData.new
         accountUpdate.merchantId = options['merchantId']
         accountUpdate.postDay = options['postDay']
         rfrrequest.accountUpdateFileRequestData = accountUpdate
       else
-        raise ArgumentError, "For an RFR Request, you must specify either a litleSessionId for an RFRRequest for batch or a merchantId
+        raise ArgumentError, "For an RFR Request, you must specify either a cnpSessionId for an RFRRequest for batch or a merchantId
         and a postDay for an RFRRequest for account updater."
-      end
-
-      litleRequest = LitleRequestForRFR.new
-      litleRequest.rfrRequest = rfrrequest
-
+      end 
+      
+      cnpRequest = CnpRequestForRFR.new
+      cnpRequest.rfrRequest = rfrrequest
+      
       authentication = Authentication.new
       authentication.user = get_config(:user, options)
       authentication.password = get_config(:password, options)
 
-      litleRequest.authentication = authentication
-      litleRequest.numBatchRequests = "0"
-
-      litleRequest.version         = '11.4'
-      litleRequest.xmlns           = "http://www.litle.com/schema"
-
-
-      xml = litleRequest.save_to_xml.to_s
+      cnpRequest.authentication = authentication
+      cnpRequest.numBatchRequests = "0"
+      
+      cnpRequest.version         = '12.1'
+      cnpRequest.xmlns           = "http://www.vantivcnp.com/schema"
 
+      
+      xml = cnpRequest.save_to_xml.to_s
+      
       ts = Time::now.to_i.to_s
       begin
         ts += Time::now.nsec.to_s
@@ -232,24 +230,24 @@ module LitleOnline
       if !File.directory?(path) then
         Dir.mkdir(path)
       end
-
+      
       path_to_request = path + REQUEST_FILE_PREFIX + ts
 
       File.open(path_to_request, 'a+') do |file|
         file.write xml
       end
       File.rename(path_to_request, path_to_request + COMPLETE_FILE_SUFFIX)
-      @RESPONSE_TIME_OUT += 90
+      @RESPONSE_TIME_OUT += 90   
     end
 
-    # FTPs all previously unsent LitleRequests located in the folder denoted by path to the server
+    # FTPs all previously unsent CnpRequests located in the folder denoted by path to the server
     # Params:
-    # +path+:: A +String+ containing the path to the folder on disc where LitleRequests are located.
-    # This should be the same location where the LitleRequests were written to. If no path is explicitly
+    # +path+:: A +String+ containing the path to the folder on disc where CnpRequests are located.
+    # This should be the same location where the CnpRequests were written to. If no path is explicitly
     # provided, then we use the directory where the current working batches file is stored.
-    # +options+:: An (option) +Hash+ containing the username, password, useEncryption and URL to attempt to sFTP to.
+    # +options+:: An (option) +Hash+ containing the username, password, and URL to attempt to sFTP to.
     # If not provided, the values will be populated from the configuration file.
-    def send_to_litle(path = (File.dirname(@path_to_batches)), options = {})
+    def send_to_cnp(path = (File.dirname(@path_to_batches)), options = {})
       use_encryption = get_config(SFTP_USE_ENCRYPTION_CONFIG_NAME, options)
       username = get_config(SFTP_USERNAME_CONFIG_NAME, options)
       password = get_config(SFTP_PASSWORD_CONFIG_NAME, options)
@@ -275,65 +273,64 @@ module LitleOnline
         end
       end
     end
-
-
-    # Sends all previously unsent LitleRequests in the specified directory to the Litle server
+    
+    # Sends all previously unsent CnpRequests in the specified directory to the Cnp server
     # by use of fast batch. All results will be written to disk as we get them. Note that use
     # of fastbatch is strongly discouraged!
-    def send_to_litle_stream(options = {}, path = (File.dirname(@path_to_batches)))
+    def send_to_cnp_stream(options = {}, path = (File.dirname(@path_to_batches)))
       url = get_config(:fast_url, options)
       port = get_config(:fast_port, options)
-
-
+    
+      
       if(url == nil or url == "") then
         raise ArgumentError, "A URL for fastbatch was not specified in the config file or passed options. Reconfigure and try again."
-      end
-
+      end 
+        
       if(port == "" or port == nil) then
         raise ArgumentError, "A port number for fastbatch was not specified in the config file or passed options. Reconfigure and try again."
-      end
-
+      end        
+      
       if(path[-1,1] != '/' && path[-1,1] != '\\') then
         path = path + File::SEPARATOR
       end
-
+      
       if (!File.directory?(path + RESPONSE_PATH_DIR)) then
         Dir.mkdir(path + RESPONSE_PATH_DIR)
       end
-
+          
       Dir.foreach(path) do |filename|
         if((filename =~ /#{REQUEST_FILE_PREFIX}\d+#{COMPLETE_FILE_SUFFIX}\z/) != nil) then
-          begin
+          begin 
             socket = TCPSocket.open(url,port.to_i)
             ssl_context = OpenSSL::SSL::SSLContext.new()
             ssl_context.ssl_version = :SSLv23
             ssl_socket = OpenSSL::SSL::SSLSocket.new(socket, ssl_context)
             ssl_socket.sync_close = true
             ssl_socket.connect
-
-          rescue => e
+                 
+           rescue => e 
             raise "A connection couldn't be established. Are you sure you have the correct credentials? Exception: " + e.message
           end
-
-          File.foreach(path + filename) do |li|
-            ssl_socket.puts li
-
-          end
-          File.rename(path + filename, path + filename + SENT_FILE_SUFFIX)
-          File.open(path + RESPONSE_PATH_DIR + (filename + '.asc' + RECEIVED_FILE_SUFFIX).gsub("request", "response"), 'a+') do |fo|
+            
+            File.foreach(path + filename) do |li|
+              ssl_socket.puts li
+              
+            end
+            File.rename(path + filename, path + filename + SENT_FILE_SUFFIX)
+            File.open(path + RESPONSE_PATH_DIR + (filename + '.asc' + RECEIVED_FILE_SUFFIX).gsub("request", "response"), 'a+') do |fo|
             while line = ssl_socket.gets
-              fo.puts(line)
+                 fo.puts(line)
             end
-          end
-
+           end
         end
-      end
+      end    
     end
-
-    # Grabs response files over SFTP from Litle.
+    
+    
+    # Grabs response files over SFTP from Cnp.
     # Params:
     # +args+:: An (optional) +Hash+ containing values for the number of responses expected, the
-    # path to the folder on disk to write the responses from the Litle server to, the username and
+    # path to the folder on disk to write the responses from the Cnp server to, the username and
     # password with which to connect ot the sFTP server, and the URL to connect over sFTP. Values not
     # provided in the hash will be populate automatically based on our best guess
     def get_responses_from_server(args = {})
@@ -361,84 +358,80 @@ module LitleOnline
 
     # Params:
     # +args+:: A +Hash+ containing arguments for the processing process. This hash MUST contain an entry
-    # for a transaction listener (see +DefaultLitleListener+). It may also include a batch listener and a
+    # for a transaction listener (see +DefaultCnpListener+). It may also include a batch listener and a
     # custom path where response files from the server are located (if it is not provided, we'll guess the position)
     def process_responses(args)
       #the transaction listener is required
       if(!args.has_key?(:transaction_listener)) then
         raise ArgumentError, "The arguments hash must contain an entry for transaction listener!"
       end
-
+      
       transaction_listener = args[:transaction_listener]
       batch_listener = args[:batch_listener] ||= nil
       path_to_responses = args[:path_to_responses] ||= (File.dirname(@path_to_batches) + '/' + RESPONSE_PATH_DIR)
       delete_batch_files = args[:deleteBatchFiles] ||= get_config(:deleteBatchFiles, args)
-
-      if(path_to_responses[-1,1] != '/' && path_to_responses[-1,1] != '\\') then
-        path_to_responses = path_to_responses + File::SEPARATOR
-      end
-
+      #deleteBatchFiles = get_config(:deleteBatchFiles, args)
+      
       Dir.foreach(path_to_responses) do |filename|
         if ((filename =~ /#{RESPONSE_FILE_PREFIX}\d+#{COMPLETE_FILE_SUFFIX}.asc#{RECEIVED_FILE_SUFFIX}\z/) != nil) then
           process_response(path_to_responses + filename, transaction_listener, batch_listener)
           File.rename(path_to_responses + filename, path_to_responses + filename + '.processed')
-        end
+        end 
       end
 
       if delete_batch_files
         delete_files_in_path(path_to_responses, /#{RESPONSE_FILE_PREFIX}\d+#{COMPLETE_FILE_SUFFIX}.asc#{RECEIVED_FILE_SUFFIX}.processed\z/)
       end
     end
-
+    
     # Params:
     # +path_to_response+:: The path to a specific .asc file to process
-    # +transaction_listener+:: A listener to be applied to the hash of each transaction
-    # (see +DefaultLitleListener+)
-    # +batch_listener+:: An (optional) listener to be applied to the hash of each batch.
-    # Note that this will om-nom-nom quite a bit of memory
+    # +transaction_listener+:: A listener to be applied to the hash of each transaction 
+    # (see +DefaultCnpListener+)
+    # +batch_listener+:: An (optional) listener to be applied to the hash of each batch. 
+    # Note that this will om-nom-nom quite a bit of memory    
     def process_response(path_to_response, transaction_listener, batch_listener = nil)
       reader = LibXML::XML::Reader.file(path_to_response)
       reader.read # read into the root node
       #if the response attribute is nil, we're dealing with an RFR and everything is a-okay
       if reader.get_attribute('response') != "0" and reader.get_attribute('response') != nil then
-        raise RuntimeError,  "Error parsing Litle Request: " + reader.get_attribute("message")
+        raise RuntimeError,  "Error parsing Cnp Request: " + reader.get_attribute("message")
       end
-
+      
       reader.read
       count = 0
       while true and count < 500001 do
-
+        
         count += 1
         if(reader.node == nil) then
           return false
-        end
-
+        end 
+        
         case reader.node.name.to_s
-          when "batchResponse"
-            reader.read
-          when "litleResponse"
-            return false
-          when "text"
-            reader.read
-          else
-            xml = reader.read_outer_xml
-            duck = Crack::XML.parse(xml)
-            duck[duck.keys[0]]["type"] = duck.keys[0]
-            duck = duck[duck.keys[0]]
-            transaction_listener.apply(duck)
-            reader.next
+        when "batchResponse"
+          reader.read
+        when "cnpResponse"
+          return false
+        when "text"
+          reader.read
+        else
+          xml = reader.read_outer_xml
+          duck = Crack::XML.parse(xml)
+          duck[duck.keys[0]]["type"] = duck.keys[0]
+          duck = duck[duck.keys[0]]
+          transaction_listener.apply(duck)
+          reader.next
         end
       end
     end
-
+  
     def get_path_to_batches
       return @path_to_batches
     end
 
     # Called when you wish to finish adding batches to your request, this method rewrites the aggregate
-    # batch file to the final LitleRequest xml doc with the appropos LitleRequest tags.
+    # batch file to the final CnpRequest xml doc with the appropos CnpRequest tags.
     def finish_request
-
       File.open(@path_to_request, 'w') do |f|
         #jam dat header in there
         f.puts(build_request_header())
@@ -447,7 +440,7 @@ module LitleOnline
           f.puts li
         end
         #finally, let's poot in a header, for old time's sake
-        f.puts '</litleRequest>'
+        f.puts '</cnpRequest>'
       end
 
       #rename the requests file
@@ -459,33 +452,34 @@ module LitleOnline
     private
 
     def build_request_header(options = @options)
-      litle_request = self
+      cnp_request = self
 
       authentication = Authentication.new
       authentication.user = get_config(:user, options)
       authentication.password = get_config(:password, options)
 
-      litle_request.authentication = authentication
-      litle_request.version         = '11.4'
-      litle_request.xmlns           = "http://www.litle.com/schema"
-      # litle_request.id              = options['sessionId'] #grab from options; okay if nil
-      litle_request.numBatchRequests = @num_batch_requests
+      cnp_request.authentication = authentication
+      cnp_request.version         = '12.1'
+      cnp_request.xmlns           = "http://www.vantivcnp.com/schema"
+      # cnp_request.id              = options['sessionId'] #grab from options; okay if nil
+      cnp_request.numBatchRequests = @num_batch_requests
 
-      xml = litle_request.save_to_xml.to_s
-      xml[/<\/litleRequest>/]=''
+      xml = cnp_request.save_to_xml.to_s
+      xml[/<\/cnpRequest>/]=''
       return xml
     end
 
     def get_config(field, options)
       if options[field.to_s] == nil and options[field] == nil then
         return @config_hash[field.to_s]
-      elsif options[field.to_s] != nil then
+      elsif options[field.to_s] != nil then       
         return options[field.to_s]
-      else
+      else       
         return options[field]
       end
     end
 
+
     def delete_files_in_path(path, pattern)
       Dir.foreach(path) do |filename|
         if((filename =~ pattern)) != nil then
@@ -539,69 +533,69 @@ module LitleOnline
 
 
     def upload_to_sftp(path_to_requests, url, username, password, use_encryption)
-      begin
-        responses_expected = 0
-        Net::SFTP.start(url, username, :password => password) do |sftp|
-          Dir.foreach(path_to_requests) do |filename|
-            if (filename =~ /#{REQUEST_FILE_PREFIX}\d+#{COMPLETE_FILE_SUFFIX}((#{ENCRYPTED_FILE_SUFFIX})?)\z/) != nil
-              new_filename = filename + '.prg'
-              File.rename(path_to_requests + filename, path_to_requests + new_filename)
-              # upload the file
-              sftp.upload!(path_to_requests + new_filename, '/inbound/' + new_filename)
-              responses_expected += 1
-              # rename now that we're done
-              sftp.rename!('/inbound/'+ new_filename, '/inbound/' + new_filename.gsub('prg', 'asc'))
-              File.rename(path_to_requests + new_filename, path_to_requests + new_filename.gsub('prg','sent'))
-              if use_encryption
-                # rename the plain text file too
-                text_filename = (path_to_requests + filename).gsub(ENCRYPTED_PATH_DIR, '').gsub(ENCRYPTED_FILE_SUFFIX, '')
-                File.rename(text_filename, text_filename + SENT_FILE_SUFFIX)
-              end
+    begin
+      responses_expected = 0
+      Net::SFTP.start(url, username, :password => password) do |sftp|
+        Dir.foreach(path_to_requests) do |filename|
+          if (filename =~ /#{REQUEST_FILE_PREFIX}\d+#{COMPLETE_FILE_SUFFIX}((#{ENCRYPTED_FILE_SUFFIX})?)\z/) != nil
+            new_filename = filename + '.prg'
+            File.rename(path_to_requests + filename, path_to_requests + new_filename)
+            # upload the file
+            sftp.upload!(path_to_requests + new_filename, '/inbound/' + new_filename)
+            responses_expected += 1
+            # rename now that we're done
+            sftp.rename!('/inbound/'+ new_filename, '/inbound/' + new_filename.gsub('prg', 'asc'))
+            File.rename(path_to_requests + new_filename, path_to_requests + new_filename.gsub('prg','sent'))
+            if use_encryption
+              # rename the plain text file too
+              text_filename = (path_to_requests + filename).gsub(ENCRYPTED_PATH_DIR, '').gsub(ENCRYPTED_FILE_SUFFIX, '')
+              File.rename(text_filename, text_filename + SENT_FILE_SUFFIX)
             end
           end
         end
-        return responses_expected
-      rescue Net::SSH::AuthenticationFailed
-        raise ArgumentError, "The sFTP credentials provided were incorrect. Try again!"
       end
+      return responses_expected
+    rescue Net::SSH::AuthenticationFailed
+      raise ArgumentError, "The sFTP credentials provided were incorrect. Try again!"
     end
+  end
 
-
-    def download_from_sftp(response_path, url, username, password)
-      responses_grabbed = 0
-      begin
-        #wait until a response has a possibility of being there
-        sleep(@POLL_DELAY)
-        time_begin = Time.now
-        Net::SFTP.start(url, username, :password => password) do |sftp|
-          while((Time.now - time_begin) < @RESPONSE_TIME_OUT  && responses_grabbed < @responses_expected)
-            #sleep for 60 seconds, ¿no es bueno?
-            sleep(60)
-            sftp.dir.foreach('/outbound/') do |entry|
-              if (entry.name =~ /#{REQUEST_FILE_PREFIX}\d+#{COMPLETE_FILE_SUFFIX}((#{ENCRYPTED_FILE_SUFFIX})?).asc\z/) != nil then
-                response_filename = response_path + entry.name.gsub(REQUEST_FILE_PREFIX, RESPONSE_FILE_PREFIX) + RECEIVED_FILE_SUFFIX
-                sftp.download!('/outbound/' + entry.name, response_filename)
-                responses_grabbed += 1
-                3.times{
-                  begin
-                    sftp.remove!('/outbound/' + entry.name)
-                    break
-                  rescue Net::SFTP::StatusException
-                    #try, try, try again
-                    puts "We couldn't remove it! Try again"
-                  end
-                }
-              end
+  def download_from_sftp(response_path, url, username, password)
+    responses_grabbed = 0
+    begin
+      #wait until a response has a possibility of being there?
+      sleep(@POLL_DELAY)
+      time_begin = Time.now
+      Net::SFTP.start(url, username, :password => password) do |sftp|
+        while((Time.now - time_begin) < @RESPONSE_TIME_OUT  && responses_grabbed < @responses_expected)
+          #sleep for 60 seconds, ¿no es bueno?
+          sleep(60)
+          sftp.dir.foreach('/outbound/') do |entry|
+            if (entry.name =~ /#{REQUEST_FILE_PREFIX}\d+#{COMPLETE_FILE_SUFFIX}((#{ENCRYPTED_FILE_SUFFIX})?).asc\z/) != nil then
+              response_filename = response_path + entry.name.gsub(REQUEST_FILE_PREFIX, RESPONSE_FILE_PREFIX) + RECEIVED_FILE_SUFFIX
+              sftp.download!('/outbound/' + entry.name, response_filename)
+              responses_grabbed += 1
+              3.times{
+                begin
+                  sftp.remove!('/outbound/' + entry.name)
+                  break
+                rescue Net::SFTP::StatusException
+                  #try, try, try again
+                  puts "We couldn't remove it! Try again"
+                end
+              }
             end
           end
-          if responses_grabbed < @responses_expected then
-            raise RuntimeError, "We timed out in waiting for a response from the server. :("
-          end
         end
-      rescue Net::SSH::AuthenticationFailed
-        raise ArgumentError, "The sFTP credentials provided were incorrect. Try again!"
+        if responses_grabbed < @responses_expected then
+          raise RuntimeError, "We timed out in waiting for a response from the server. :("
+        end
       end
+    rescue Net::SSH::AuthenticationFailed
+      raise ArgumentError, "The sFTP credentials provided were incorrect. Try again!"
     end
+  end
+
 
     # Encrypt the request file for a PGP enabled account
     # +cipher_filename+:: Name of File that would contain encrypted batch
@@ -625,9 +619,10 @@ module LitleOnline
 
     rescue IOStreams::Pgp::Failure => e
       raise ArgumentError, "Please check if you have entered correct vantivePublicKeyID to config and that " +
-          "vantiv's public key is added to your gpg keyring and is trusted. #{e.message}"
+                           "vantiv's public key is added to your gpg keyring and is trusted. #{e.message}"
     end
 
+
     # Decrypt the encrypted batch response file
     # +response_filename+:: Filename of encrypted batch response file
     #     The decrypted response would be placed in +response_filename+.gsub("encrypted", "")
@@ -635,11 +630,10 @@ module LitleOnline
     # If not provided, the values will be populated from the configuration file.
     def decrypt_batch_file_response(response_filename, args)
       passphrase = get_config(:passphrase, args)
-      delete_batch_files = get_config(:deleteBatchFiles, args)
       if passphrase == ""
         raise RuntimeError, "The passphrase to decrypt the batch file responses is missing from the config"
       end
-      decrypted_response_filename = response_filename.gsub('/encrypted', '').gsub(".encrypted", "")
+      decrypted_response_filename = response_filename.gsub(ENCRYPTED_PATH_DIR, '').gsub(ENCRYPTED_FILE_SUFFIX, "")
 
       decrypted_file = File.open(decrypted_response_filename, "w")
       IOStreams::Pgp::Reader.open(
@@ -647,14 +641,14 @@ module LitleOnline
           passphrase: passphrase
       ) do |stream|
         while !stream.eof?
-          decrypted_file.puts(stream.readline())
+          decrypted_file.puts(stream.readline)
           #puts stream.readline()
         end
       end
-      decrypted_file.close()
+      decrypted_file.close
     rescue IOStreams::Pgp::Failure => e
       raise ArgumentError, "Please check if you have entered correct passphrase to config and that your " +
-          "merchant private key is added to your gpg keyring and is trusted. #{e.message}"
+                           "merchant private key is added to your gpg keyring and is trusted. #{e.message}"
     end
   end
 end