Card Increment
Overview
An Increment transaction is a critical method for managing payments in various physical settings. This process involves adding an additional amount to an already authorized transaction, facilitating real-time, immediate adjustments to a customer's credit or debit card charge at the point of sale. It is ideal for scenarios where additional charges need to be added to an initial authorization. This type of transaction is a staple in environments such as hotels, car rental agencies, and restaurants, where additional services or fees may be incurred after the initial authorization. By using Increment transactions, merchants can ensure that all charges are captured accurately and promptly, maintaining a seamless payment experience for the customer.
Create an Instore Card Increment Transaction Request
// Import necessary classes
import com.pxpfinancial.sdk.pos.TransactionRequest
import com.pxpfinancial.sdk.pos.PointOfInteraction
import com.pxpfinancial.sdk.pos.Amounts
import com.pxpfinancial.sdk.pos.TransactionMethod
import java.text.SimpleDateFormat
import java.util.Date
// Define merchant and transaction details
val merchant = "MERCHANT-1"
val site = "SITE-1"
val merchantOrderId = "This_is_my_merchant_order_id"
val merchantTransactionId = "This_is_my_merchant_transaction_id"
val merchantTransactionDate = SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSSXXX").format(Date())
val systemTransactionId = "This_is_my_system_transaction_id"
// Transaction amount details
val amounts = Amounts(
currencyCode = "GBP",
transaction = 20.00
)
// Function to build transaction request
fun buildTransactionRequest(): TransactionRequest {
return TransactionRequest(
systemTransactionId = systemTransactionId,
amounts = amounts,
merchant = merchant,
merchantOrderId = merchantOrderId,
merchantTransactionId = merchantTransactionId,
merchantTransactionDate = merchantTransactionDate,
operation = "Incremental",
site = site
)
}
Handle an Instore Card Increment Transaction Response
// Import necessary classes
import com.pxpfinancial.sdk.pos.TransactionResponse
import kotlinx.coroutines.*
import java.text.SimpleDateFormat
import java.util.Date
// Function to handle transaction response
private fun handleTransactionResponse(response: TransactionResponse?) {
response ?: run {
println("Transaction timed out or no response received.")
return
}
// Accessing fields in the base response
val state = response.state
val approvalCode = response.approvalCode
val merchantOrderId = response.merchantOrderId
val merchantTransactionId = response.merchantTransactionId
val systemTransactionId = response.systemTransactionId
val providerTransactionId = response.providerTransactionId
// Accessing fields in card response
val cardScheme = response.card.cardScheme
val cardScheme = response.card.gatewayTokenId
// Accessing fields in provider response
val provider = response.provider.provider
val providerCode = response.provider.code
val providerMessage = response.provider.message
// Accessing fields for receipt data
val merchantId = response.receiptData.merchantId
val maskedPrimaryAccountNumber = response.receiptData.maskedPrimaryAccountNumber
val expiryDateMonth = response.receiptData.expiryDateMonth
val expiryDateYear = response.receiptData.expiryDateYear
// Additional business logic based on the transaction state
when (state) {
"Authorised" -> {
// Handle authorised transaction
println("Transaction authorised successfully.")
// Perform further actions like updating UI, saving transaction details, etc.
}
"Declined" -> {
// Handle declined transaction
println("Transaction declined.")
// Perform actions based on the declined state
}
else -> {
// Handle other transaction states if necessary
println("Transaction state: $state")
}
}
}
// Simulated usage of request and response handling
fun main() {
// Build transaction request
val transactionRequest = buildTransactionRequest()
// Simulate async processing and response handling
CoroutineScope(Dispatchers.Default).launch {
val pxpPosSdk = com.pxpfinancial.sdk.pos.Transaction("http://127.0.0.1:8080", "YOUR_API_KEY")
// Process the transaction
val result = withTimeoutOrNull(10000L) { // 10 seconds timeout
suspendCancellableCoroutine<TransactionResponse?> { continuation ->
pxpPosSdk.processTransaction(transactionRequest) { response ->
continuation.resume(response, onCancellation = null)
}
}
}
// Handle the transaction response
handleTransactionResponse(result)
}
}
Updated 5 months ago