Credit Card Processing

Once you have created your client instance, you will then create an object the represents the type of action you wish to perform on the platform (detailed in the following sections). Debit Cards and Credit Cards are both processed the same way through the gateway, both as a BankCard object. Bank Cards are processed on the Base Commerce Platform using the BankCardTransaction object to encapsulate all of the cardholder data, details about the transaction, and the BaseCommercePayClient processBankCardTransaction() method. 

Make sure to check the getMessages() on the response if the transaction fails, as it will indicate what the failure reason is.

Here is an example of processing a SALE transaction:

                Address o_address = new Address( Address.XS_ADDRESS_NAME_BILLING );
                o_address.setLine1( "5055 E. Washington Street");
                o_address.setLine2( "Suite 300");
                o_address.setCity( "Phoenix" );
                o_address.setState( "AZ" );
                o_address.setCountry( "US" );
                o_address.setZipcode( "85034" );
                
                BankCardTransaction o_bc_transaction = new BankCardTransaction();
                o_bc_transaction.setType( BankCardTransaction.XS_BCT_TYPE_SALE );
                o_bc_transaction.setAmount( 5.25 );
                o_bc_transaction.setCardName( "Sample Bank Card Transaction" );
                o_bc_transaction.setCardNumber( "4111111111111111" );
                o_bc_transaction.setCardExpirationMonth( "08" );
                o_bc_transaction.setCardExpirationYear( "2025" );
                o_bc_transaction.setCardCVV2( "111" );
                o_bc_transaction.setBillingAddress( o_address );

                BaseCommerceClient o_client = new BaseCommerceClient( s_username, s_password, s_key );
                o_client.setSandbox( true );
                o_bc_transaction = o_client.processBankCardTransaction( o_bc_transaction );

                if ( o_bc_transaction.isStatus( BankCardTransaction.XS_BCT_STATUS_FAILED ) ) {
                
                    // Transaction failed, look at messages for
                    // reasons why System.out.println( o_bc_transaction.getMessages() );
                } else if ( o_bc_transaction.isStatus( BankCardTransaction.XS_BCT_STATUS_DECLINED ) ) {
                
                    // Transaction declined, look at response code and
                    // response message System.out.println( o_bc_transaction.getResponseCode() );
                    System.out.println( o_bc_transaction.getResponseMessage() );
                } else if ( o_bc_transaction.isStatus( BankCardTransaction.XS_BCT_STATUS_CAPTURED ) ) {
                
                    // Transaction successful
                    System.out.println( o_bc_transaction.getTransactionId() );
                }
            

The following example is authorizing a credit card for one U.S. dollar:

BankCardTransaction o_bc_transaction = new BankCardTransaction(); 
o_bc_transaction.setAmount(1); 
o_bc_transaction.setCardExpirationMonth(“03”); 
o_bc_transaction.setCardExpirationYear(“2024”); 
o_bc_transaction.setCardNumber( "4111111111111111"); 
o_bc_transaction.setCardName( "Test Card"); 
o_bc_transaction.setType( BankCardTransaction.XS_BCT_TYPE_AUTH );

Next, you will invoke the method on the BaseCommerceClient which corresponds to the desired function. This will make the client connect to our platform via SSL and execute your request. Upon completion of the request, the object you passed as a parameter will be updated with the results of the request:

o_bc_transaction = o_client.processBankCardTransaction( o_bc_transaction );

In this example, we want to confirm that the transaction was approved, since it was a transaction of type AUTH not SALE it will comp back in the AUTHORIZED status where as if it was a SALE it would come back as CAPTURED if successful. We will check the status on the BankCardTransaction object then print out the values returned:

if ( o_bc_transaction.isStatus(BankCardTransaction.XS_BCT_STATUS_FAILED) ) { 

       // Transaction failed, look at messages for reasons why 
       System.out.println( o_bc_transaction.getMessages() ); 

} else if ( o_bc_transaction.isStatus(BankCardTransaction.XS_BCT_STATUS_DECLINED) ) { 

       // Transaction declined, look at response code and response message 
       System.out.println( o_bc_transaction.getResponseCode() ); 
       System.out.println( o_bc_transaction.getResponseMessage() ); 

} else if ( o_transaction.isStatus( BankCardTransaction.XO_AUTHORIZED ) { 

       // Transaction was successfully authorized
		System.out.println( o_bc_transaction.getTransactionId() ); //Base Commerce Unique custom ID for every BankCardTransaction
		System.out.println( o_bc_transaction.getAuthorizationCode() ); //The authorization code
		System.out.println( o_bc_transaction.getAVSResponseCode() ); //The AVS response code

 }

This completes the process of authorizing a card and checking the response. In the event you are processing multiple transactions, the same client object can be reused multiple times; however, the BankCardTransaction object should not be reused. When you are done with the client, there is no clean up to do, as all resources are closed and variables are reset (with the exception of the username, password, and key) after each transaction is processed.

In the event that the server is unable to process your request due to invalid credentials (username, password, key), a BaseCommercePayClientException will be thrown, indicating that there is a communication error with the server.

Only the following test cards will return approvals in the SandBox Environment:

Adding a Single Credit Card to Sandbox

In the Developer Dashboard on https://www.my.basecommercesandbox.com under the SDK credentials, there is a text box to enter a credit card number. The number you enter, when processed with, will return a CAPTURED state. This number can also be used for testing if you are using an encrypted card reader since there is no test track data for the test numbers in the above table.

Test Case Scenarios for Approvals / Declines

To simulate real life, you can use any of the aforementioned cards with a valid expiration date. If the date is in the future, the transaction will return an authorization. 

• Transactions that have a cent value of 10 cents will decline for insufficient funds
• Transactions that have a cent value of 20 cents will decline for do not honor
• Transactions that have a cent value of 30 cents will decline for lost/stolen
• Transactions that have a cent value of 40 cents will return response code of 0002 partial authorization. If the Merchant is not configured for this, it will decline.

Test Case Scenarios for CVV and AVS Response Codes

BankCardTransaction Types

Every BankCardTransaction request requires a transaction type be set prior to executing processBankCardTransaction(). The transaction type is set by invoking the setType( ) method on the BankCardTransaction object with one of the following types:

BankCardTransaction Statuses

Every BankCardTransaction that is processed with valid credentials will have a status that should be checked to determine the results of the transaction. The status can be obtained from a BankCardTransaction object by executing the getStats() or isStatus() methods. The status values are as follows:

Required Credit Card Transaction Fields

• Number
• Amount
• Expiration Month
• Expiration Year
• Transaction type
• Voids require the original transaction ID
• Capture/refunds require the original transaction ID and the amount
• CVV is required if merchant has AVS required enabled