CnpOnline 11.4.0 → 12.1.0

data/lib/{LitleListeners.rb → CnpListeners.rb}

@@ -24,10 +24,10 @@ OTHER DEALINGS IN THE SOFTWARE.
 =end
 # This file contains the preloaded listeners for parsing the response XML.
 
-module LitleOnline
+module CnpOnline
   # This listener will run the provided closure over every response hash
   # This is the base class for all listeners applied to transaction responses
-  class DefaultLitleListener
+  class DefaultCnpListener
     def initialize(&action)
       @action = action
     end
@@ -38,7 +38,7 @@ module LitleOnline
     end
   end
 
-  class AuthorizationListener < DefaultLitleListener
+  class AuthorizationListener < DefaultCnpListener
     def apply(duck)
       if(duck["type"] == "authorizationResponse") then
         @action.call(duck)
@@ -46,7 +46,7 @@ module LitleOnline
     end
   end
 
-  class CaptureListener < DefaultLitleListener
+  class CaptureListener < DefaultCnpListener
     def apply(duck)
       if(duck["type"] == "captureResponse") then
         @action.call(duck)
@@ -54,7 +54,7 @@ module LitleOnline
     end
   end
 
-  class ForceCaptureListener < DefaultLitleListener
+  class ForceCaptureListener < DefaultCnpListener
     def apply(duck)
       if(duck["type"] == "forceCaptureResponse") then
         @action.call(duck)
@@ -62,7 +62,7 @@ module LitleOnline
     end
   end
 
-  class CaptureGivenAuthListener < DefaultLitleListener
+  class CaptureGivenAuthListener < DefaultCnpListener
     def apply(duck)
       if(duck["type"] == "captureGivenAuthResponse") then
         @action.call(duck)
@@ -70,7 +70,7 @@ module LitleOnline
     end
   end
 
-  class SaleListener < DefaultLitleListener
+  class SaleListener < DefaultCnpListener
     def apply(duck)
       if(duck["type"] == "saleResponse") then
         @action.call(duck)
@@ -78,7 +78,7 @@ module LitleOnline
     end
   end
 
-  class CreditListener < DefaultLitleListener
+  class CreditListener < DefaultCnpListener
     def apply(duck)
       if(duck["type"] == "creditResponse") then
         @action.call(duck)
@@ -86,7 +86,7 @@ module LitleOnline
     end
   end
 
-  class EcheckSaleListener < DefaultLitleListener
+  class EcheckSaleListener < DefaultCnpListener
     def apply(duck)
       if(duck["type"] == "echeckSaleResponse") then
         @action.call(duck)
@@ -94,7 +94,7 @@ module LitleOnline
     end
   end
 
-  class EcheckCreditListener < DefaultLitleListener
+  class EcheckCreditListener < DefaultCnpListener
     def apply(duck)
       if(duck["type"] == "echeckCreditResponse") then
         @action.call(duck)
@@ -102,7 +102,7 @@ module LitleOnline
     end
   end
 
-  class EcheckVerificationListener < DefaultLitleListener
+  class EcheckVerificationListener < DefaultCnpListener
     def apply(duck)
       if(duck["type"] == "echeckVerificationResponse") then
         @action.call(duck)
@@ -110,7 +110,7 @@ module LitleOnline
     end
   end
 
-  class EcheckRedepositListener < DefaultLitleListener
+  class EcheckRedepositListener < DefaultCnpListener
     def apply(duck)
       if(duck["type"] == "echeckRedepositResponse") then
         @action.call(duck)
@@ -118,7 +118,7 @@ module LitleOnline
     end
   end
 
-  class EcheckPreNoteSaleListener < DefaultLitleListener
+  class EcheckPreNoteSaleListener < DefaultCnpListener
     def apply(duck)
       if(duck["type"] == "echeckPreNoteSaleResponse") then
         @action.call(duck)
@@ -126,7 +126,7 @@ module LitleOnline
     end
   end
 
-  class EcheckPreNoteCreditListener < DefaultLitleListener
+  class EcheckPreNoteCreditListener < DefaultCnpListener
     def apply(duck)
       if(duck["type"] == "echeckPreNoteCreditResponse") then
         @action.call(duck)
@@ -134,7 +134,7 @@ module LitleOnline
     end
   end
 
-  class SubmerchantCreditListener < DefaultLitleListener
+  class SubmerchantCreditListener < DefaultCnpListener
     def apply(duck)
       if(duck["type"] == "submerchantCreditResponse") then
         @action.call(duck)
@@ -142,7 +142,7 @@ module LitleOnline
     end
   end
 
-  class PayFacCreditListener < DefaultLitleListener
+  class PayFacCreditListener < DefaultCnpListener
     def apply(duck)
       if(duck["type"] == "payFacCreditResponse") then
         @action.call(duck)
@@ -150,7 +150,7 @@ module LitleOnline
     end
   end
 
-  class ReserveCreditListener < DefaultLitleListener
+  class ReserveCreditListener < DefaultCnpListener
     def apply(duck)
       if(duck["type"] == "reserveCreditResponse") then
         @action.call(duck)
@@ -158,7 +158,7 @@ module LitleOnline
     end
   end
 
-  class VendorCreditListener < DefaultLitleListener
+  class VendorCreditListener < DefaultCnpListener
     def apply(duck)
       if(duck["type"] == "vendorCreditResponse") then
         @action.call(duck)
@@ -166,89 +166,97 @@ module LitleOnline
     end
   end
 
-  class PhysicalCheckCreditListener < DefaultLitleListener
+  class FundingInstructionVoidListener < DefaultCnpListener
     def apply(duck)
-      if(duck["type"] == "physicalCheckCreditResponse") then
+      if(duck["type"] == "FundingInstructionVoidResponse") then
         @action.call(duck)
       end
     end
   end
 
-  class SubmerchantDebitListener < DefaultLitleListener
+  class PinlessDebitListener < DefaultCnpListener
     def apply(duck)
-      if(duck["type"] == "submerchantDebitResponse") then
+      if(duck["type"] == "PinlessDebitResponse") then
         @action.call(duck)
       end
     end
   end
 
-  class PayFacDebitListener < DefaultLitleListener
+  class FastAccessFundingListener < DefaultCnpListener
     def apply(duck)
-      if(duck["type"] == "payFacDebitResponse") then
+      if(duck["type"] == "FastAccessFundingResponse") then
         @action.call(duck)
       end
     end
   end
 
-  class ReserveDebitListener < DefaultLitleListener
+  class PhysicalCheckCreditListener < DefaultCnpListener
     def apply(duck)
-      if(duck["type"] == "reserveDebitResponse") then
+      if(duck["type"] == "physicalCheckCreditResponse") then
         @action.call(duck)
       end
     end
   end
 
-  class VendorDebitListener < DefaultLitleListener
+  class SubmerchantDebitListener < DefaultCnpListener
     def apply(duck)
-      if(duck["type"] == "vendorDebitResponse") then
+      if(duck["type"] == "submerchantDebitResponse") then
         @action.call(duck)
       end
     end
   end
 
-  class PhysicalCheckDebitListener < DefaultLitleListener
+  class PayFacDebitListener < DefaultCnpListener
     def apply(duck)
-      if(duck["type"] == "physicalCheckDebitResponse") then
+      if(duck["type"] == "payFacDebitResponse") then
         @action.call(duck)
       end
     end
   end
 
-  class AuthReversalListener < DefaultLitleListener
+  class ReserveDebitListener < DefaultCnpListener
     def apply(duck)
-      if(duck["type"] == "authReversalResponse") then
+      if(duck["type"] == "reserveDebitResponse") then
         @action.call(duck)
       end
     end
   end
 
-  class RegisterTokenListener < DefaultLitleListener
+  class VendorDebitListener < DefaultCnpListener
     def apply(duck)
-      if(duck["type"] == "registerTokenResponse") then
+      if(duck["type"] == "vendorDebitResponse") then
         @action.call(duck)
       end
     end
   end
 
-  class FraudCheckListener < DefaultLitleListener
+  class PhysicalCheckDebitListener < DefaultCnpListener
     def apply(duck)
-      if(duck["type"] == "advancedFraudResults") then
+      if(duck["type"] == "physicalCheckDebitResponse") then
+        @action.call(duck)
+      end
+    end
+  end
+
+  class AuthReversalListener < DefaultCnpListener
+    def apply(duck)
+      if(duck["type"] == "authReversalResponse") then
         @action.call(duck)
       end
     end
   end
 
-  class FastAccessFundingListener < DefaultLitleListener
+  class RegisterTokenListener < DefaultCnpListener
     def apply(duck)
-      if(duck["type"] == "fastAccessFundingResponse") then
+      if(duck["type"] == "registerTokenResponse") then
         @action.call(duck)
       end
     end
   end
 
-  class ServiceStatusResponse < DefaultLitleListener
+  class FraudCheckListener < DefaultCnpListener
     def apply(duck)
-      if(duck["type"] == "serviceStatusResponse") then
+      if(duck["type"] == "advancedFraudResults") then
         @action.call(duck)
       end
     end

data/lib/{LitleOnline.rb → CnpOnline.rb}

@@ -34,6 +34,7 @@ require 'yaml'
 require 'uri'
 require 'net/https'
 require 'xml/mapping'
+require 'iostreams'
 
 unless Kernel.respond_to?(:require_relative)
   module Kernel
@@ -45,16 +46,16 @@ end
 
 
 require_relative 'Communications'
-require_relative 'LitleXmlMapper'
+require_relative 'CnpXmlMapper'
 require_relative 'XMLFields'
-require_relative 'LitleTransaction'
-require_relative 'LitleBatchRequest'
-require_relative 'LitleOnlineRequest'
-require_relative 'LitleRequest'
-require_relative 'LitleListeners'
+require_relative 'CnpTransaction'
+require_relative 'CnpBatchRequest'
+require_relative 'CnpOnlineRequest'
+require_relative 'CnpRequest'
+require_relative 'CnpListeners'
 require_relative 'Configuration'
 
-#allows attribute values to be in double quotes, required by Litle Server
+#allows attribute values to be in double quotes, required by Cnp Server
 REXML::Attribute.class_eval( %q^
     def to_string
       %Q[#@expanded_name="#{to_s().gsub(/"/, '"')}"]

data/lib/{LitleOnlineRequest.rb → CnpOnlineRequest.rb}

@@ -25,243 +25,243 @@ OTHER DEALINGS IN THE SOFTWARE.
 require_relative 'Configuration'
 
 #
-# This class handles sending the Litle online request
+# This class handles sending the Cnp online request
 #
-module LitleOnline
+module CnpOnline
 
-  class LitleOnlineRequest
+  class CnpOnlineRequest
     def initialize
       #load configuration data
       @config_hash = Configuration.new.config
-      @litle_transaction = LitleTransaction.new
+      @cnp_transaction = CnpTransaction.new
     end
 
     def virtual_giftcard(options)
-       transaction =@litle_transaction.virtual_giftcard(options)
+       transaction =@cnp_transaction.virtual_giftcard(options)
 
        commit(transaction, :virtualGiftCard, options)
     end
 
     def create_plan(options)
-       transaction =@litle_transaction.create_plan(options)
+       transaction =@cnp_transaction.create_plan(options)
 
        commit(transaction, :createPlan, options)
     end
 
     def update_plan(options)
-       transaction =@litle_transaction.update_plan(options)
+       transaction =@cnp_transaction.update_plan(options)
 
        commit(transaction, :updatePlan, options)
     end
 
     def cancel_subscription(options)
-       transaction =@litle_transaction.cancel_subscription(options)
+       transaction =@cnp_transaction.cancel_subscription(options)
 
        commit(transaction, :cancelSubscription, options)
     end
 
     def update_subscription(options)
-       transaction =@litle_transaction.update_subscription(options)
+       transaction =@cnp_transaction.update_subscription(options)
 
        commit(transaction, :updateSubscription, options)
     end
 
     def activate(options)
-      transaction = @litle_transaction.activate(options)
+      transaction = @cnp_transaction.activate(options)
 
       commit(transaction, :activate, options)
     end 
    
     def deactivate(options)
-     transaction = @litle_transaction.deactivate(options)
+     transaction = @cnp_transaction.deactivate(options)
 
       commit(transaction, :deactivate, options)
     end
 
     def load_request(options)
-     transaction = @litle_transaction.load_request(options)
+     transaction = @cnp_transaction.load_request(options)
 
       commit(transaction, :load, options)
     end
 
     def unload_request(options)
-     transaction = @litle_transaction.unload_request(options)
+     transaction = @cnp_transaction.unload_request(options)
 
       commit(transaction, :unload, options)
     end
 
     def balance_inquiry(options)
-      transaction = @litle_transaction.balance_inquiry(options)
+      transaction = @cnp_transaction.balance_inquiry(options)
 
       commit(transaction, :balanceInquiry, options)
     end
 
     def activate_reversal(options)
-      transaction = @litle_transaction.activate_reversal(options)
+      transaction = @cnp_transaction.activate_reversal(options)
 
       commit(transaction, :activateReversal, options)
     end
 
     def deposit_reversal(options)
-      transaction = @litle_transaction.deposit_reversal(options)
+      transaction = @cnp_transaction.deposit_reversal(options)
 
       commit(transaction, :depositReversal, options)
     end
     
-    #XML 11.0
+    #XML 12.0
     def giftCardAuth_reversal(options)
-      transaction = @litle_transaction.giftCardAuth_reversal(options)
+      transaction = @cnp_transaction.giftCardAuth_reversal(options)
 
       commit(transaction, :giftCardAuthReversal, options)
     end
     
     def giftCardCapture(options)
-      transaction = @litle_transaction.giftCardCapture(options)
+      transaction = @cnp_transaction.giftCardCapture(options)
 
       commit(transaction, :giftCardCapture, options)
     end
-    
+
+    def fast_access_funding(options)
+      transaction = @cnp_txn.fast_access_funding(options)
+
+      commit(transaction, :fastAccessFunding, options)
+    end
+
     def giftCardCredit(options)
-      transaction = @litle_transaction.giftCardCredit(options)
+      transaction = @cnp_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)
+      transaction = @cnp_transaction.refund_reversal(options)
 
       commit(transaction, :refundReversal, options)
     end
 
     def deactivate_reversal(options)
-      transaction = @litle_transaction.deactivate_reversal(options)
+      transaction = @cnp_transaction.deactivate_reversal(options)
 
       commit(transaction, :deactivateReversal, options)
     end
 
     def load_reversal(options)
-      transaction = @litle_transaction.load_reversal(options)
+      transaction = @cnp_transaction.load_reversal(options)
 
       commit(transaction, :loadReversal, options)
     end
 
     def unload_reversal(options)
-      transaction = @litle_transaction.unload_reversal(options)
+      transaction = @cnp_transaction.unload_reversal(options)
 
       commit(transaction, :unloadReversal, options)
     end
     
 
     def authorization(options)
-      transaction = @litle_transaction.authorization(options)
+      transaction = @cnp_transaction.authorization(options)
       
       commit(transaction, :authorization, options)
     end
 
     def sale(options)
-      transaction = @litle_transaction.sale(options)
+      transaction = @cnp_transaction.sale(options)
 
       commit(transaction, :sale, options)
     end
 
     def auth_reversal(options)
-      transaction = @litle_transaction.auth_reversal(options)      
+      transaction = @cnp_transaction.auth_reversal(options)      
 
       commit(transaction, :authReversal, options)
     end
 
     def credit(options)
-      transaction = @litle_transaction.credit(options)
+      transaction = @cnp_transaction.credit(options)
       
       commit(transaction, :credit, options)
     end
 
     def register_token_request(options)
-      transaction = @litle_transaction.register_token_request(options)
+      transaction = @cnp_transaction.register_token_request(options)
 
       commit(transaction, :registerTokenRequest, options)
     end
     
     def update_card_validation_num_on_token(options)
-   	  transaction = @litle_transaction.update_card_validation_num_on_token(options)
+   	  transaction = @cnp_transaction.update_card_validation_num_on_token(options)
     	
       commit(transaction, :updateCardValidationNumOnToken, options)
     end
 
     def force_capture(options)
-      transaction = @litle_transaction.force_capture(options)
+      transaction = @cnp_transaction.force_capture(options)
       
       commit(transaction, :forceCapture, options)
     end
 
     def capture(options)
-      transaction = @litle_transaction.capture(options)
+      transaction = @cnp_transaction.capture(options)
       
       commit(transaction, :captureTxn, options)
     end
 
     def capture_given_auth(options)
-      transaction = @litle_transaction.capture_given_auth(options)
+      transaction = @cnp_transaction.capture_given_auth(options)
       
       commit(transaction, :captureGivenAuth, options)
     end
 
     def void(options)
-      transaction = @litle_transaction.void(options)
+      transaction = @cnp_transaction.void(options)
 
       commit(transaction, :void, options)
     end
 
     def echeck_redeposit(options)
-      transaction = @litle_transaction.echeck_redeposit(options)
+      transaction = @cnp_transaction.echeck_redeposit(options)
       
       commit(transaction, :echeckRedeposit, options)
     end
 
     def echeck_sale(options)
-      transaction = @litle_transaction.echeck_sale(options)
+      transaction = @cnp_transaction.echeck_sale(options)
 
       commit(transaction, :echeckSale, options)
     end
 
     def echeck_credit(options)
-      transaction = @litle_transaction.echeck_credit(options)
+      transaction = @cnp_transaction.echeck_credit(options)
 
       begin
         commit(transaction, :echeckCredit, options)
       rescue XML::MappingError => e
-        response = LitleOnlineResponse.new
+        response = CnpOnlineResponse.new
         response.message = "The content of element 'echeckCredit' is not complete"
         return response
       end
     end
 
     def echeck_verification(options)
-      transaction = @litle_transaction.echeck_verification(options)
+      transaction = @cnp_transaction.echeck_verification(options)
 
       commit(transaction, :echeckVerification, options)
     end
 
     def echeck_void(options)
-      transaction = @litle_transaction.echeck_void(options)
+      transaction = @cnp_transaction.echeck_void(options)
       
       commit(transaction, :echeckVoid, options)
     end
     
     def query_Transaction(options)      
-      transaction = @litle_transaction.query_Transaction(options)
+      transaction = @cnp_transaction.query_Transaction(options)
       
       commit(transaction, :queryTransaction, options)      
     end
     
     def fraud_check_request(options)
-      transaction = @litle_transaction.fraud_check_request(options)
+      transaction = @cnp_transaction.fraud_check_request(options)
             
       commit(transaction, :fraudCheck, options)
     end
@@ -289,9 +289,9 @@ module LitleOnline
 
       request.authentication  = authentication
       request.merchantId      = get_merchant_id(options)
-      request.version         = '11.4'
+      request.version         = '12.1'
       request.loggedInUser    = get_logged_in_user(options)
-      request.xmlns           = "http://www.litle.com/schema"
+      request.xmlns           = "http://www.vantivcnp.com/schema"
       request.merchantSdk     = get_merchant_sdk(options)
       request
     end
@@ -305,7 +305,7 @@ module LitleOnline
       request.send(:"#{type}=", transaction)
 
       xml = request.save_to_xml.to_s
-      LitleXmlMapper.request(xml, @config_hash)
+      CnpXmlMapper.request(xml, @config_hash)
     end
 
     def configure_connection(options={})
@@ -319,7 +319,7 @@ module LitleOnline
     end
 
     def get_merchant_sdk(options)
-      options['merchantSdk'] || 'Ruby;11.4'
+      options['merchantSdk'] || 'Ruby;12.1'
     end
 
     def get_report_group(options)