CnpOnline 9.14.0 → 11.4.0

data/lib/EnvironmentVariables.rb

@@ -16,6 +16,10 @@ module LitleOnline
       @fast_port = ''
       @printxml = false
       @timeout = 65
+      @useEncryption = false
+      @vantivPublicKeyID = ''
+      @passphrase = ''
+      @deleteBatchFies = false
     end
   end
-end
+end

data/lib/LitleBatchRequest.rb

@@ -1,6 +1,5 @@
 =begin
 Copyright (c) 2017 Vantiv eCommerce
-
 Permission is hereby granted, free of charge, to any person
 obtaining a copy of this software and associated documentation
 files (the "Software"), to deal in the Software without
@@ -9,10 +8,8 @@ copy, modify, merge, publish, distribute, sublicense, and/or sell
 copies of the Software, and to permit persons to whom the
 Software is furnished to do so, subject to the following
 conditions:
-
 The above copyright notice and this permission notice shall be
 included in all copies or substantial portions of the Software.
-
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
 OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
@@ -25,9 +22,9 @@ OTHER DEALINGS IN THE SOFTWARE.
 require_relative 'Configuration'
 
 #
-# This class creates a new batch to which Vantiv eCommerce XML transactions are added.
+# This class creates a new batch to which Litle XML transactions are added.
 # The batch is stored in the local file system until it is ready to be sent
-# to Vantiv eCommerce.
+# to Litle.
 #
 module LitleOnline
   class LitleBatchRequest
@@ -45,7 +42,15 @@ module LitleOnline
         :captureGivenAuth=>{ :numCaptureGivenAuths=>0, :captureGivenAuthAmount=>0 },
         :forceCapture=>{ :numForceCaptures=>0, :forceCaptureAmount=>0 },
         :authReversal=>{ :numAuthReversals=>0, :authReversalAmount=>0 },
+        :fastAccessFunding=>{ :numFastAccessFunding=>0, :fastAccessFundingAmount=>0 },
+        #11.0 begin
+        :giftCardAuthReversal=>{ :numGiftCardAuthReversals=>0, :giftCardAuthReversalOriginalAmount=>0 },
+        #end 
         :capture=>{ :numCaptures=>0, :captureAmount=>0 },
+        #11.0 begin
+        :giftCardCapture=>{ :numGiftCardCaptures=>0, :giftCardCaptureAmount=>0 },
+        :giftCardCredit=>{ :numGiftCardCredits=>0, :giftCardCreditAmount=>0 },
+        #end 
         :echeckVerification=>{ :numEcheckVerification=>0, :echeckVerificationAmount=>0 },
         :echeckCredit=>{ :numEcheckCredit=>0, :echeckCreditAmount=>0 },
         :numEcheckRedeposit=>0,
@@ -74,7 +79,9 @@ module LitleOnline
         :load=>{:numLoads=>0, :loadAmount=>0},
         :unload=>{:numUnloads=>0, :unloadAmount=>0},
         :numBalanceInquirys=>0,
-        :merchantSdk=>nil
+        :merchantSdk=>nil,
+        #SDK XML 10
+        :numFundingInstructionVoid=>0
       }
       @litle_txn = LitleTransaction.new
       @path_to_batch = nil
@@ -204,6 +211,27 @@ module LitleOnline
       add_txn_to_batch(transaction, :authReversal, options)
     end
 
+    def gift_card_auth_reversal(options)
+      transaction = @litle_txn.gift_card_auth_reversal(options)
+      @txn_counts[:giftCardAuthReversal][:numGiftCardAuthReversals] += 1
+      @txn_counts[:giftCardAuthReversal][:giftCardAuthReversalOriginalAmount] += options['amount'].to_i
+      add_txn_to_batch(transaction, :giftCardAuthReversal, options)
+    end
+    
+    def gift_card_capture(options)
+      transaction = @litle_txn.gift_card_capture(options)
+      @txn_counts[:giftCardCapture][:numGiftCardCaptures] += 1
+      @txn_counts[:giftCardCapture][:giftCardCaptureAmount] += options['amount'].to_i
+      add_txn_to_batch(transaction, :giftCardCapture, options)
+    end
+
+    def gift_card_credit(options)
+      transaction = @litle_txn.gift_card_credit(options)
+      @txn_counts[:giftCardCredit][:numGiftCardCredits] += 1
+      @txn_counts[:giftCardCredit][:giftCardCreditAmount] += options['amount'].to_i
+      add_txn_to_batch(transaction, :giftCardCredit, options)
+    end
+
     def cancel_subscription(options)
       transaction = @litle_txn.cancel_subscription(options)
       @txn_counts[:numCancelSubscriptions] += 1
@@ -381,6 +409,19 @@ module LitleOnline
 
       add_txn_to_batch(transaction, :physicalCheckCredit, options)
     end
+    
+    
+ # Adding the numfundingInstructionVoid to the batch request
+ # Date: 01-25-2016
+ # Change Type: New
+ # Desc: Change proposed as a part of SDK XML 10 to incorporate the feature of voiding transactions
+ # on request.
+    def funding_txn_void(options)
+      transaction = @litle_txn.funding_txn_void(options)
+      @txn_counts[:numFundingInstructionVoid] += 1
+      
+      add_txn_to_batch(transaction, :fundingInstructionVoid, options)
+    end
 
     def payFac_debit(options)
       transaction = @litle_txn.payFac_debit(options)
@@ -430,6 +471,14 @@ module LitleOnline
       add_txn_to_batch(transaction, :echeckSale, options)
     end
 
+    def fast_access_funding(options)
+      transaction = @litle_txn.fast_access_funding(options)
+      @txn_counts[:fastAccessFunding][:numFastAccessFunding] += 1
+      @txn_counts[:fastAccessFunding][:fastAccessFundingAmount] += options['amount'].to_i
+
+      add_txn_to_batch(transaction, :fastAccessFunding, options)
+    end
+
     def account_update(options)
 
       if(@au_batch == nil) then
@@ -485,8 +534,22 @@ module LitleOnline
       request.forceCaptureAmount       = @txn_counts[:forceCapture][:forceCaptureAmount]
       request.numAuthReversals         = @txn_counts[:authReversal][:numAuthReversals]
       request.authReversalAmount       = @txn_counts[:authReversal][:authReversalAmount]
+      #11.4 begin
+      # request.numFastAccessFunding          = @txn_counts[:fastAccessFunding][:numFastAccessFunding]
+      # request.fastAccessFundingAmount       = @txn_counts[:fastAccessFunding][:fastAccessFundingAmount]
+      # 11.4 end
+      # 11.0 begin
+      request.numGiftCardAuthReversals                 = @txn_counts[:giftCardAuthReversal][:numGiftCardAuthReversals]
+      request.giftCardAuthReversalOriginalAmount       = @txn_counts[:giftCardAuthReversal][:giftCardAuthReversalOriginalAmount]
+      # 11.0 end 
       request.numCaptures              = @txn_counts[:capture][:numCaptures]
       request.captureAmount            = @txn_counts[:capture][:captureAmount]
+      # 11.0 begin
+      request.numGiftCardCaptures      = @txn_counts[:giftCardCapture][:numGiftCardCaptures]
+      request.giftCardCaptureAmount    = @txn_counts[:giftCardCapture][:giftCardCaptureAmount]
+      request.numGiftCardCredits      = @txn_counts[:giftCardCredit][:numGiftCardCredits]
+      request.giftCardCreditAmount    = @txn_counts[:giftCardCredit][:giftCardCreditAmount]
+      # 11.0 end 
       request.numEcheckSales           = @txn_counts[:echeckSale][:numEcheckSales]
       request.echeckSalesAmount        = @txn_counts[:echeckSale][:echeckSalesAmount]
       request.numEcheckRedeposit       = @txn_counts[:numEcheckRedeposit]
@@ -503,7 +566,9 @@ module LitleOnline
       request.vendorCreditAmount        = @txn_counts[:vendorCredit][:vendorCreditAmount]
       request.numPhysicalCheckCredit        = @txn_counts[:physicalCheckCredit][:numPhysicalCheckCredit]
       request.physicalCheckCreditAmount        = @txn_counts[:physicalCheckCredit][:physicalCheckCreditAmount]
-
+      #SDK XML 10
+      request.numFundingInstructionVoid        = @txn_counts[:numFundingInstructionVoid]
+        
       request.numPayFacDebit        = @txn_counts[:payFacDebit][:numPayFacDebit]
       request.payFacDebitAmount        = @txn_counts[:payFacDebit][:payFacDebitAmount]
       request.numSubmerchantDebit        = @txn_counts[:submerchantDebit][:numSubmerchantDebit]

data/lib/LitleListeners.rb

@@ -232,7 +232,23 @@ module LitleOnline
 
   class FraudCheckListener < DefaultLitleListener
     def apply(duck)
-      if(duck["type"] == "advancedFraudResult") then
+      if(duck["type"] == "advancedFraudResults") then
+        @action.call(duck)
+      end
+    end
+  end
+
+  class FastAccessFundingListener < DefaultLitleListener
+    def apply(duck)
+      if(duck["type"] == "fastAccessFundingResponse") then
+        @action.call(duck)
+      end
+    end
+  end
+
+  class ServiceStatusResponse < DefaultLitleListener
+    def apply(duck)
+      if(duck["type"] == "serviceStatusResponse") then
         @action.call(duck)
       end
     end

data/lib/LitleOnline.rb

@@ -54,10 +54,9 @@ require_relative 'LitleRequest'
 require_relative 'LitleListeners'
 require_relative 'Configuration'
 
-# allows attribute values to be in double quotes,
-# required by Vantiv eCommerce Server
-REXML::Attribute.class_eval(%q^
+#allows attribute values to be in double quotes, required by Litle Server
+REXML::Attribute.class_eval( %q^
     def to_string
       %Q[#@expanded_name="#{to_s().gsub(/"/, '"')}"]
     end
-  ^)
+  ^ )

data/lib/LitleOnlineRequest.rb

@@ -25,7 +25,7 @@ OTHER DEALINGS IN THE SOFTWARE.
 require_relative 'Configuration'
 
 #
-# This class handles sending the Vantiv eCommerce online request
+# This class handles sending the Litle online request
 #
 module LitleOnline
 
@@ -107,6 +107,31 @@ module LitleOnline
 
       commit(transaction, :depositReversal, options)
     end
+    
+    #XML 11.0
+    def giftCardAuth_reversal(options)
+      transaction = @litle_transaction.giftCardAuth_reversal(options)
+
+      commit(transaction, :giftCardAuthReversal, options)
+    end
+    
+    def giftCardCapture(options)
+      transaction = @litle_transaction.giftCardCapture(options)
+
+      commit(transaction, :giftCardCapture, options)
+    end
+    
+    def giftCardCredit(options)
+      transaction = @litle_transaction.giftCardCredit(options)
+
+      commit(transaction, :giftCardCredit, options)
+    end
+
+    # def fast_access_funding(options)
+    #   transaction = @litle_transaction.fast_access_funding(options)
+    #
+    #   commit(transaction, :fastAccessFunding, options)
+    # end
 
     def refund_reversal(options)
       transaction = @litle_transaction.refund_reversal(options)
@@ -135,7 +160,7 @@ module LitleOnline
 
     def authorization(options)
       transaction = @litle_transaction.authorization(options)
-
+      
       commit(transaction, :authorization, options)
     end
 
@@ -229,6 +254,12 @@ module LitleOnline
       commit(transaction, :echeckVoid, options)
     end
     
+    def query_Transaction(options)      
+      transaction = @litle_transaction.query_Transaction(options)
+      
+      commit(transaction, :queryTransaction, options)      
+    end
+    
     def fraud_check_request(options)
       transaction = @litle_transaction.fraud_check_request(options)
             
@@ -258,11 +289,10 @@ module LitleOnline
 
       request.authentication  = authentication
       request.merchantId      = get_merchant_id(options)
-      request.version         = '9.14'
+      request.version         = '11.4'
       request.loggedInUser    = get_logged_in_user(options)
-      request.xmlns           = 'http://www.litle.com/schema'
+      request.xmlns           = "http://www.litle.com/schema"
       request.merchantSdk     = get_merchant_sdk(options)
-
       request
     end
 
@@ -289,7 +319,7 @@ module LitleOnline
     end
 
     def get_merchant_sdk(options)
-      options['merchantSdk'] || 'Ruby;9.14.0'
+      options['merchantSdk'] || 'Ruby;11.4'
     end
 
     def get_report_group(options)
@@ -299,7 +329,7 @@ module LitleOnline
     def get_config(field, options)
       options[field.to_s] == nil ? @config_hash[field.to_s] : options[field.to_s]
     end
-
+    
     def get_logged_in_user(options)
       options['loggedInUser'] || nil
     end

data/lib/LitleRequest.rb

@@ -1,6 +1,5 @@
 =begin
 Copyright (c) 2017 Vantiv eCommerce
-
 Permission is hereby granted, free of charge, to any person
 obtaining a copy of this software and associated documentation
 files (the "Software"), to deal in the Software without
@@ -9,10 +8,8 @@ copy, modify, merge, publish, distribute, sublicense, and/or sell
 copies of the Software, and to permit persons to whom the
 Software is furnished to do so, subject to the following
 conditions:
-
 The above copyright notice and this permission notice shall be
 included in all copies or substantial portions of the Software.
-
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
 OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
@@ -27,17 +24,35 @@ require 'net/sftp'
 require 'libxml'
 require 'crack/xml'
 require 'socket'
+require 'iostreams'
+require 'open3'
 
 include Socket::Constants
 #
-# This class handles sending the Litle Request
-# (which is actually a series of batches!)
+# This class handles sending the Litle 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
+SFTP_USE_ENCRYPTION_CONFIG_NAME = :useEncryption
+SFTP_DELETE_BATCH_FILES_CONFIG_NAME = :deleteBatchFiles
+
+REQUEST_PATH_DIR = 'requests/'
+REQUEST_FILE_PREFIX = 'request_'
+ENCRYPTED_PATH_DIR = 'encrypted/'
+ENCRYPTED_FILE_SUFFIX = '.encrypted'
+RESPONSE_PATH_DIR = 'responses/'
+RESPONSE_FILE_PREFIX = 'response_'
+
+SENT_FILE_SUFFIX = '.sent'
+RECEIVED_FILE_SUFFIX = '.received'
+COMPLETE_FILE_SUFFIX = '.complete'
+
 module LitleOnline
   class LitleRequest
-    include XML::Mapping
-
+    #include XML::Mapping
     def initialize(options = {})
       #load configuration data
       @config_hash = Configuration.new.config
@@ -49,7 +64,7 @@ module LitleOnline
       @options = options
       # current time out set to 2 mins
       # this value is in seconds
-      @RESPONSE_TIME_OUT = 360
+      @RESPONSE_TIME_OUT = 520
       @POLL_DELAY = 0
       @responses_expected = 0
     end
@@ -66,11 +81,11 @@ module LitleOnline
         ts += Time::now.usec.to_s
       end
 
-      if (File.file?(path)) then
-        raise 'Entered a file not a path.'
+      if(File.file?(path)) then
+        raise RuntimeError, "Entered a file not a path."
       end
 
-      if (path[-1, 1] != '/' and path[-1, 1] != '\\') then
+      if(path[-1,1] != '/' and path[-1,1] != '\\') then
         path = path + File::SEPARATOR
       end
 
@@ -78,34 +93,33 @@ module LitleOnline
         Dir.mkdir(path)
       end
 
-      @path_to_request = path + 'request_' + ts
+      @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)
+
         return
       end
 
       File.open(@path_to_request, 'a+') do |file|
-        file.write('')
+        file.write("")
       end
       File.open(@path_to_batches, 'a+') do |file|
-        file.write('')
+        file.write("")
       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 LitleRequest. 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 +LitleBatchRequest+ 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
+      path_to_batch = ""
+      #they passed a batch
       if arg.kind_of?(LitleBatchRequest) 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
@@ -114,20 +128,18 @@ module LitleOnline
       elsif arg.kind_of?(String) then
         path_to_batch = arg
       else
-        raise 'You entered neither a path nor a batch. Game over :('
+        raise RuntimeError, "You entered neither a path nor a batch."
       end
-      # the batch isn't closed. let's help a brother out
+      #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.open_existing_batch(path_to_batch)
           new_batch.close_batch()
           path_to_batch = new_batch.get_batch_name
-          # if we passed a path to an AU batch, then new_batch will be a new,
-          # empty batch and the batch we passed
-          # will be in the AU batch variable. thus, we wanna grab that file name
-          # and remove the empty batch.
-          if (new_batch.get_au_batch != nil) then
+          # if we passed a path to an AU batch, then new_batch will be a new, empty batch and the batch we passed
+          # will be in the AU batch variable. thus, we wanna grab that file name and remove the empty batch.
+          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
@@ -146,14 +158,13 @@ module LitleOnline
       if (@num_total_transactions + transactions_in_batch) > @MAX_NUM_TRANSACTIONS then
         finish_request
         initialize(@options)
-        create_new_litle_request
-      else # otherwise, let's add it line by line to the request doc
+        create_new_litle_request    #(path_to_batch)
+      else #otherwise, let's add it line by line to the request doc
         # @num_batch_requests += 1
-        # how long we want to wait around for the
-        # FTP server to get us a response
+        #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)
+        #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)
@@ -168,23 +179,23 @@ module LitleOnline
     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 
+    # 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
     # as key/val pairs.
     # +path+:: optional path to save the new litle request containing the RFRRequest at
     def add_rfr_request(options, path = (File.dirname(@path_to_batches)))
 
       rfrrequest = LitleRFRRequest.new
-      if (options['litleSessionId']) then
+      if(options['litleSessionId']) then
         rfrrequest.litleSessionId = options['litleSessionId']
-      elsif (options['merchantId'] and options['postDay']) then
+      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 litleSessionId for an RFRRequest for batch or a merchantId
         and a postDay for an RFRRequest for account updater."
       end
 
@@ -196,10 +207,10 @@ module LitleOnline
       authentication.password = get_config(:password, options)
 
       litleRequest.authentication = authentication
-      litleRequest.numBatchRequests = '0'
+      litleRequest.numBatchRequests = "0"
 
-      litleRequest.version = '9.14'
-      litleRequest.xmlns = 'http://www.litle.com/schema'
+      litleRequest.version         = '11.4'
+      litleRequest.xmlns           = "http://www.litle.com/schema"
 
 
       xml = litleRequest.save_to_xml.to_s
@@ -210,11 +221,11 @@ module LitleOnline
       rescue NoMethodError # ruby 1.8.7 fix
         ts += Time::now.usec.to_s
       end
-      if File.file?(path) then
-        raise 'Entered a file not a path.'
+      if(File.file?(path)) then
+        raise RuntimeError, "Entered a file not a path."
       end
 
-      if (path[-1, 1] != '/' and path[-1, 1] != '\\') then
+      if(path[-1,1] != '/' and path[-1,1] != '\\') then
         path = path + File::SEPARATOR
       end
 
@@ -222,12 +233,12 @@ module LitleOnline
         Dir.mkdir(path)
       end
 
-      path_to_request = path + 'request_' + ts
+      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.rename(path_to_request, path_to_request + COMPLETE_FILE_SUFFIX)
       @RESPONSE_TIME_OUT += 90
     end
 
@@ -236,51 +247,36 @@ module LitleOnline
     # +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
     # provided, then we use the directory where the current working batches file is stored.
-    # +options+:: An (option) +Hash+ containing the username, password, and URL to attempt to sFTP to.
+    # +options+:: An (option) +Hash+ containing the username, password, useEncryption 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 = {})
-      username = get_config(:sftp_username, options)
-      password = get_config(:sftp_password, 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)
+      delete_batch_files = get_config(SFTP_DELETE_BATCH_FILES_CONFIG_NAME, options)
+      url = get_config(SFTP_URL_CONFIG_NAME, options)
 
-      url = get_config(:sftp_url, options)
-
-      if username == nil or password == nil or url == nil then
-        raise ArgumentError, 'You are not configured to use sFTP for batch processing. Please run /bin/Setup.rb again!'
+      if(username == nil or password == nil or url == nil) then
+        raise ArgumentError, "You are not configured to use sFTP for batch processing. Please run /bin/Setup.rb again!"
       end
+      path = path_to_requests = prepare_for_sftp(path, use_encryption)
 
-      if (path[-1, 1] != '/' && path[-1, 1] != '\\') then
-        path = path + File::SEPARATOR
+      if use_encryption
+        encrypted_path = path_to_requests + ENCRYPTED_PATH_DIR
+        encrypt_request_files(path, encrypted_path, options)
+        path_to_requests = encrypted_path
       end
 
-      begin
-        Net::SFTP.start(url, username, :password => password) do |sftp|
-
-          # our folder is /SHORTNAME/SHORTNAME/INBOUND
-          Dir.foreach(path) do |filename|
-            # we have a complete report according to filename regex
-            if (filename =~ /request_\d+.complete\z/) != nil then
-              # adding .prg extension per the XML 
-              File.rename(path + filename, path + filename + '.prg')
-            end
-          end
-
-          @responses_expected = 0
-          Dir.foreach(path) do |filename|
-            if (filename =~ /request_\d+.complete.prg\z/) != nil then
-              # upload the file
-              sftp.upload!(path + filename, '/inbound/' + filename)
-              @responses_expected += 1
-              # rename now that we're done
-              sftp.rename!('/inbound/'+ filename, '/inbound/' + filename.gsub('prg', 'asc'))
-              File.rename(path + filename, path + filename.gsub('prg', 'sent'))
-            end
-          end
+      @responses_expected = upload_to_sftp(path_to_requests, url, username, password, use_encryption)
+      if delete_batch_files
+        delete_files_in_path(path_to_requests, /#{REQUEST_FILE_PREFIX}\d+#{COMPLETE_FILE_SUFFIX}#{ENCRYPTED_FILE_SUFFIX}?#{SENT_FILE_SUFFIX}\z/)
+        if use_encryption
+          delete_files_in_path(path, /#{REQUEST_FILE_PREFIX}\d+#{COMPLETE_FILE_SUFFIX}#{SENT_FILE_SUFFIX}\z/)
         end
-      rescue Net::SSH::AuthenticationFailed
-        raise ArgumentError, 'The sFTP credentials provided were incorrect. Try again!'
       end
     end
 
+
     # Sends all previously unsent LitleRequests in the specified directory to the Litle 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!
@@ -288,40 +284,43 @@ module LitleOnline
       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.'
+
+      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
 
-      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.'
+      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
 
-      if (path[-1, 1] != '/' && path[-1, 1] != '\\') then
+      if(path[-1,1] != '/' && path[-1,1] != '\\') then
         path = path + File::SEPARATOR
       end
 
-      if (!File.directory?(path + 'responses/')) then
-        Dir.mkdir(path + 'responses/')
+      if (!File.directory?(path + RESPONSE_PATH_DIR)) then
+        Dir.mkdir(path + RESPONSE_PATH_DIR)
       end
 
       Dir.foreach(path) do |filename|
-        if ((filename =~ /request_\d+.complete\z/) != nil) then
+        if((filename =~ /#{REQUEST_FILE_PREFIX}\d+#{COMPLETE_FILE_SUFFIX}\z/) != nil) then
           begin
-            socket = TCPSocket.open(url, port.to_i)
+            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
-            raise 'A connection could not be established. Are you sure you have the correct credentials? Exception: ' + e.message
+            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.open(path + 'responses/' + (filename + '.asc.received').gsub('request', 'response'), 'a+') do |fo|
+          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)
             end
@@ -331,7 +330,6 @@ module LitleOnline
       end
     end
 
-
     # Grabs response files over SFTP from Litle.
     # Params:
     # +args+:: An (optional) +Hash+ containing values for the number of responses expected, the
@@ -339,73 +337,25 @@ module LitleOnline
     # 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 = {})
+      use_encryption = get_config(SFTP_USE_ENCRYPTION_CONFIG_NAME, args)
       @responses_expected = args[:responses_expected] ||= @responses_expected
-      response_path = args[:response_path] ||= (File.dirname(@path_to_batches) + '/responses/')
-      username = get_config(:sftp_username, args)
-      password = get_config(:sftp_password, args)
-      url = get_config(:sftp_url, args)
+      response_path = args[:response_path] ||= (File.dirname(@path_to_batches) + '/' + RESPONSE_PATH_DIR)
+      username = get_config(SFTP_USERNAME_CONFIG_NAME, args)
+      password = get_config(SFTP_PASSWORD_CONFIG_NAME, args)
+      url = get_config(SFTP_URL_CONFIG_NAME, args)
 
-      if (username == nil or password == nil or url == nil) then
-        raise ConfigurationException, 'You are not configured to use sFTP for batch processing. Please run /bin/Setup.rb again!'
+      if(username == nil or password == nil or url == nil) then
+        raise ArgumentError, "You are not configured to use sFTP for batch processing. Please run /bin/Setup.rb again!"
       end
-
-      if (response_path[-1, 1] != '/' && response_path[-1, 1] != '\\') then
-        response_path = response_path + File::SEPARATOR
+      response_path = prepare_for_sftp(response_path, use_encryption)
+      if use_encryption
+        response_path += ENCRYPTED_PATH_DIR
       end
 
-      if (!File.directory?(response_path)) then
-        Dir.mkdir(response_path)
-      end
-      begin
-        responses_grabbed = 0
-        Net::SFTP.start(url, username, :password => password) do |sftp|
-          # clear out the sFTP outbound dir prior to checking for new files, avoids leaving files on the server
-          # if files are left behind we are not counting then towards the expected total
-          sftp.dir.foreach('/outbound/') do |entry|
-            if ((entry.name =~ /request_\d+.complete.asc\z/) != nil) then
-              sftp.download!('/outbound/' + entry.name, response_path + entry.name.gsub('request', 'response') + '.received')
-              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
-        end
-        # 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_\d+.complete.asc\z/) != nil) then
-                sftp.download!('/outbound/' + entry.name, response_path + entry.name.gsub('request', 'response') + '.received')
-                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
-          end
-          # if our timeout timed out, we're having problems
-          if responses_grabbed < @responses_expected then
-            raise '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!'
+      download_from_sftp(response_path, url, username, password)
+
+      if use_encryption
+        decrypt_response_files(response_path, args)
       end
     end
 
@@ -414,35 +364,44 @@ module LitleOnline
     # for a transaction listener (see +DefaultLitleListener+). 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!'
+      #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) + '/responses/')
+      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
 
       Dir.foreach(path_to_responses) do |filename|
-        if (filename =~ /response_\d+.complete.asc.received\z/) != nil then
+        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
+
+      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 
+    # +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    
+    # +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 'Error parsing Litle Request: ' + reader.get_attribute('message')
+      #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")
       end
 
       reader.read
@@ -450,21 +409,21 @@ module LitleOnline
       while true and count < 500001 do
 
         count += 1
-        if reader.node == nil then
+        if(reader.node == nil) then
           return false
         end
 
         case reader.node.name.to_s
-          when 'batchResponse'
+          when "batchResponse"
             reader.read
-          when 'litleResponse'
+          when "litleResponse"
             return false
-          when 'text'
+          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.keys[0]]["type"] = duck.keys[0]
             duck = duck[duck.keys[0]]
             transaction_listener.apply(duck)
             reader.next
@@ -476,24 +435,24 @@ module LitleOnline
       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.
+    # 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.
     def finish_request
+
       File.open(@path_to_request, 'w') do |f|
-        # jam dat header in there
+        #jam dat header in there
         f.puts(build_request_header())
-        # read into the request file from the batches file
+        #read into the request file from the batches file
         File.foreach(@path_to_batches) do |li|
           f.puts li
         end
-        # finally, let's poot in a header, for old time's sake
+        #finally, let's poot in a header, for old time's sake
         f.puts '</litleRequest>'
       end
 
-      # rename the requests file
-      File.rename(@path_to_request, @path_to_request + '.complete')
-      # we don't need the master batch file anymore
+      #rename the requests file
+      File.rename(@path_to_request, @path_to_request + COMPLETE_FILE_SUFFIX)
+      #we don't need the master batch file anymore
       File.delete(@path_to_batches)
     end
 
@@ -507,14 +466,13 @@ module LitleOnline
       authentication.password = get_config(:password, options)
 
       litle_request.authentication = authentication
-      litle_request.version = '9.14'
-      litle_request.xmlns = 'http://www.litle.com/schema'
-      # litle_request.id              = options['sessionId']
-      # grab from options; okay if nil
+      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
 
       xml = litle_request.save_to_xml.to_s
-      xml[/<\/litleRequest>/] = ''
+      xml[/<\/litleRequest>/]=''
       return xml
     end
 
@@ -527,5 +485,176 @@ module LitleOnline
         return options[field]
       end
     end
+
+    def delete_files_in_path(path, pattern)
+      Dir.foreach(path) do |filename|
+        if((filename =~ pattern)) != nil then
+          File.delete(path + filename)
+        end
+      end
+    end
+
+    def prepare_for_sftp(path, use_encryption)
+      if(path[-1,1] != '/' && path[-1,1] != '\\') then
+        path = path + File::SEPARATOR
+      end
+
+      if(!File.directory?(path)) then
+        Dir.mkdir(path)
+      end
+
+      if use_encryption
+        encrypted_path = path + ENCRYPTED_PATH_DIR
+        if !File.directory?(encrypted_path)
+          Dir.mkdir(encrypted_path)
+        end
+      end
+      return path
+    end
+
+
+    def encrypt_request_files(path, encrypted_path, options)
+      Dir.foreach(path) do |filename|
+        if (filename =~ /#{REQUEST_FILE_PREFIX}\d+#{COMPLETE_FILE_SUFFIX}\z/) != nil
+          cipher_filename = encrypted_path + filename + ENCRYPTED_FILE_SUFFIX
+          plain_filename = path + filename
+          encrypt_batch_file_request(cipher_filename, plain_filename, options)
+        end
+      end
+    end
+
+
+    def decrypt_response_files(response_path, args)
+      delete_batch_files = get_config(SFTP_DELETE_BATCH_FILES_CONFIG_NAME, args)
+
+      Dir.foreach(response_path) do |filename|
+        if (filename =~ /#{RESPONSE_FILE_PREFIX}\d+#{COMPLETE_FILE_SUFFIX}#{ENCRYPTED_FILE_SUFFIX}.asc#{RECEIVED_FILE_SUFFIX}\z/) != nil
+          decrypt_batch_file_response(response_path + filename, args)
+        end
+      end
+      if delete_batch_files
+        delete_files_in_path(response_path, /#{RESPONSE_FILE_PREFIX}\d+#{COMPLETE_FILE_SUFFIX}#{ENCRYPTED_FILE_SUFFIX}.asc#{RECEIVED_FILE_SUFFIX}\z/)
+      end
+    end
+
+
+    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
+            end
+          end
+        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
+            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!"
+      end
+    end
+
+    # Encrypt the request file for a PGP enabled account
+    # +cipher_filename+:: Name of File that would contain encrypted batch
+    # +plain_filename+:: Name of File containing batch in XML markup
+    # +options+:: An (option) +Hash+ containing the public key to attempt to encrypt the file.
+    # If not provided, the values will be populated from the configuration file.
+    def encrypt_batch_file_request(cipher_filename, plain_filename, options)
+      pgpkeyID = get_config(:vantivPublicKeyID, options)
+      if pgpkeyID == ""
+        raise RuntimeError, "The public key to encrypt batch file requests is missing from the config"
+      end
+
+      IOStreams::Pgp::Writer.open(
+          cipher_filename,
+          recipient: pgpkeyID
+      ) do |output|
+        File.open(plain_filename, "r").readlines.each do |line|
+          output.puts(line)
+        end
+      end
+
+    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}"
+    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", "")
+    # +args+:: An (arg) +Hash+ containing the passphrase to atempt to decrypt the file
+    # 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_file = File.open(decrypted_response_filename, "w")
+      IOStreams::Pgp::Reader.open(
+          response_filename,
+          passphrase: passphrase
+      ) do |stream|
+        while !stream.eof?
+          decrypted_file.puts(stream.readline())
+          #puts stream.readline()
+        end
+      end
+      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}"
+    end
   end
 end