**Note**: Error responses include the full structure with many empty fields. Focus on the `result`, `status`, and message fields for error handling.
## Code examples```bash
#!/bin/bash
# Example 1: Full refund using tranId
curl -X POST https://your-hyp-environment-url/xpo/Relay \
-H "Content-Type: application/x-www-form-urlencoded" \
-d "user=your_username" \
-d "password=your_password" \
-d "int_in=$(cat <<'EOF'
2000
ENG
refundDeal
118372223
EOF
)"
# Example 2: Partial refund using cgUid with optional terminalNumber
curl -X POST https://your-hyp-environment-url/xpo/Relay \
-H "Content-Type: application/x-www-form-urlencoded" \
-d "user=your_username" \
-d "password=your_password" \
-d "int_in=$(cat <<'EOF'
2000
ENG
refundDeal
118372223
0882819014
5000
EOF
)"
```
```java
import java.io.*;
import java.net.*;
import java.nio.charset.StandardCharsets;
public class RefundDealExample {
public static class RefundResult {
public boolean success;
public String tranId;
public String amount;
public String transactionType;
public String error;
}
public static RefundResult processRefund(String terminalNumber, String cgUid, String refundAmount) throws IOException {
String serverUrl = "https://your-hyp-environment-url/xpo/Relay";
String username = "your_username";
String password = "your_password";
RefundResult result = new RefundResult();
// Build XML payload
StringBuilder xmlPayload = new StringBuilder();
xmlPayload.append("
")
.append("")
.append("2000")
.append("Eng")
.append("")
.append("")
.append("refundDeal")
.append("")
.append("").append(cgUid).append("");
// Optional: add terminal number if provided
if (terminalNumber != null && !terminalNumber.isEmpty()) {
xmlPayload.append("").append(terminalNumber).append("");
}
if (refundAmount != null && !refundAmount.isEmpty()) {
xmlPayload.append("").append(refundAmount).append("");
}
xmlPayload.append("")
.append("")
.append("");
// Build POST data
String postData = "user=" + URLEncoder.encode(username, StandardCharsets.UTF_8) +
"&password=" + URLEncoder.encode(password, StandardCharsets.UTF_8) +
"&int_in=" + URLEncoder.encode(xmlPayload.toString(), StandardCharsets.UTF_8);
// Send request
URL url = new URL(serverUrl);
HttpURLConnection connection = (HttpURLConnection) url.openConnection();
connection.setRequestMethod("POST");
connection.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");
connection.setDoOutput(true);
try (OutputStream os = connection.getOutputStream()) {
os.write(postData.getBytes(StandardCharsets.UTF_8));
}
// Read response
try (BufferedReader reader = new BufferedReader(
new InputStreamReader(connection.getInputStream()))) {
String line;
StringBuilder response = new StringBuilder();
while ((line = reader.readLine()) != null) {
response.append(line);
}
// Parse response (simplified - use proper XML parser in production)
String responseText = response.toString();
if (responseText.contains("
000")) {
result.success = true;
// Extract key fields (use proper XML parsing in production)
result.tranId = extractValue(responseText, "tranId");
result.amount = extractValue(responseText, "total");
result.transactionType = extractValue(responseText, "transactionType");
} else {
result.success = false;
result.error = extractValue(responseText, "userMessage");
}
}
return result;
}
private static String extractValue(String xml, String tagName) {
String startTag = "<" + tagName + ">";
String endTag = "";
int start = xml.indexOf(startTag);
if (start != -1) {
start += startTag.length();
int end = xml.indexOf(endTag, start);
if (end != -1) {
return xml.substring(start, end);
}
}
return "";
}
public static void main(String[] args) throws IOException {
// Full refund example (terminal number is optional, pass null if not needed)
RefundResult result = processRefund(null, "118372223", null);
if (result.success) {
System.out.println("Refund successful!");
System.out.println("New Transaction ID: " + result.tranId);
System.out.println("Amount: " + result.amount);
System.out.println("Type: " + result.transactionType);
} else {
System.out.println("Refund failed: " + result.error);
}
}
}
```
```python
import requests
from urllib.parse import urlencode
from xml.etree import ElementTree as ET
def process_refund(cg_uid, terminal_number=None, refund_amount=None):
"""Process a refund using CG identifier"""
server_url = "https://your-hyp-environment-url/xpo/Relay"
username = "your_username"
password = "your_password"
# Build XML payload
xml_payload = f"""
2000
ENG
refundDeal
{cg_uid}
{f'{terminal_number}' if terminal_number else ''}
{'' + str(refund_amount) + '' if refund_amount else ''}
"""
# Prepare POST data
post_data = {
'user': username,
'password': password,
'int_in': xml_payload.strip()
}
try:
# Send request
response = requests.post(
server_url,
data=post_data,
headers={'Content-Type': 'application/x-www-form-urlencoded'},
timeout=30
)
response.raise_for_status()
# Parse XML response
root = ET.fromstring(response.text)
result_code = root.find('.//result').text
if result_code == '000':
return {
'success': True,
'tran_id': root.find('.//tranId').text,
'amount': root.find('.//refundDeal/total').text,
'transaction_type': root.find('.//refundDeal/transactionType').text,
'message': root.find('.//userMessage').text
}
else:
return {
'success': False,
'error_code': result_code,
'error': root.find('.//userMessage').text
}
except requests.exceptions.RequestException as e:
return {
'success': False,
'error': f"Request failed: {e}"
}
except ET.ParseError as e:
return {
'success': False,
'error': f"XML parsing failed: {e}"
}
# Example usage
if __name__ == "__main__":
# Full refund example (terminal number is optional)
result = process_refund("118372223", terminal_number="0882819014")
if result['success']:
print("Refund successful!")
print(f"New Transaction ID: {result['tran_id']}")
print(f"Amount: {result['amount']}")
print(f"Type: {result['transaction_type']}")
else:
print(f"Refund failed: {result['error']}")
# Partial refund example without terminal number
partial_result = process_refund("118372223", refund_amount="5000")
if partial_result['success']:
print("Partial refund successful!")
print(f"Refunded amount: {partial_result['amount']}")
else:
print(f"Partial refund failed: {partial_result['error']}")
```
```javascript
const https = require('https');
const querystring = require('querystring');
const { parseStringPromise } = require('xml2js');
function processRefund(cgUid, terminalNumber = null, refundAmount = null) {
return new Promise((resolve, reject) => {
const serverUrl = 'https://your-hyp-environment-url/xpo/Relay';
const username = 'your_username';
const password = 'your_password';
// Build XML payload
const totalElement = refundAmount ? `
${refundAmount}` : '';
const xmlPayload = `
2000
ENG
refundDeal
${cgUid}
${terminalNumber ? `${terminalNumber}` : ''}
${totalElement}
`;
// Prepare POST data
const postData = querystring.stringify({
user: username,
password: password,
int_in: xmlPayload.trim()
});
const options = {
method: 'POST',
headers: {
'Content-Type': 'application/x-www-form-urlencoded',
'Content-Length': Buffer.byteLength(postData)
}
};
const req = https.request(serverUrl, options, async (res) => {
let responseData = '';
res.on('data', (chunk) => {
responseData += chunk;
});
res.on('end', async () => {
try {
if (res.statusCode === 200) {
// Parse XML response
const result = await parseStringPromise(responseData);
const response = result.ashrait.response[0];
const resultCode = response.result[0];
if (resultCode === '000') {
const refundData = response.refundDeal[0];
resolve({
success: true,
tranId: response.tranId[0],
amount: refundData.total[0],
transactionType: refundData.transactionType[0]['_'] || refundData.transactionType[0],
message: response.userMessage[0]
});
} else {
resolve({
success: false,
errorCode: resultCode,
error: response.userMessage[0]
});
}
} else {
reject(new Error(`HTTP ${res.statusCode}: ${responseData}`));
}
} catch (parseError) {
reject(new Error(`XML parsing failed: ${parseError.message}`));
}
});
});
req.on('error', (error) => {
reject(error);
});
req.write(postData);
req.end();
});
}
// Example usage
async function example() {
try {
// Full refund example (terminal number is optional)
const result = await processRefund('118372223', '0882819014');
if (result.success) {
console.log('Refund successful!');
console.log(`New Transaction ID: ${result.tranId}`);
console.log(`Amount: ${result.amount}`);
console.log(`Type: ${result.transactionType}`);
} else {
console.log(`Refund failed: ${result.error}`);
}
// Partial refund example without terminal number
const partialResult = await processRefund('118372223', null, '5000');
if (partialResult.success) {
console.log('Partial refund successful!');
console.log(`Refunded amount: ${partialResult.amount}`);
} else {
console.log(`Partial refund failed: ${partialResult.error}`);
}
} catch (error) {
console.error('Operation failed:', error.message);
}
}
example();
```