-H "Content-Type: application/x-www-form-urlencoded"\
-d "sessionId=a1b2c3d4e5f6789012345abcdef67890"\
-d "int\_in=$(cat <<'EOF' 2000 Eng inquireTransactions 0882819014 customer123 EOF )" ``java import java.io.*; import java.net.*; import java.nio.charset.StandardCharsets;
public class GetSessionIdExample {
```
public static class SessionResult {
public boolean success;
public String sessionId;
public String expirationTime;
public String error;
}
public static SessionResult getSessionId(String terminalNumber) throws IOException {
String serverUrl = "https://your-hyp-environment-url/xpo/Relay";
String username = "your_username";
String password = "your_password";
SessionResult result = new SessionResult();
// Build XML payload
String xmlPayload =
"
" +
"" +
"2000" +
"Eng" +
"" +
"" +
"getSessionId" +
"" +
"" + terminalNumber + "" +
"" +
"" +
"";
// Build POST data
String postData = "user=" + URLEncoder.encode(username, StandardCharsets.UTF_8) +
"&password=" + URLEncoder.encode(password, StandardCharsets.UTF_8) +
"&int_in=" + URLEncoder.encode(xmlPayload, 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;
result.sessionId = extractValue(responseText, "sessionId");
result.expirationTime = extractValue(responseText, "expirationTime");
} else {
result.success = false;
result.error = extractValue(responseText, "userMessage");
}
}
return result;
}
public static String makeSessionApiCall(String sessionId, String xmlPayload) throws IOException {
String serverUrl = "https://your-hyp-environment-url/xpo/Relay";
// Build POST data using session ID instead of username/password
String postData = "sessionId=" + URLEncoder.encode(sessionId, StandardCharsets.UTF_8) +
"&int_in=" + URLEncoder.encode(xmlPayload, StandardCharsets.UTF_8);
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));
}
try (BufferedReader reader = new BufferedReader(
new InputStreamReader(connection.getInputStream()))) {
String line;
StringBuilder response = new StringBuilder();
while ((line = reader.readLine()) != null) {
response.append(line);
}
return response.toString();
}
}
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 {
// Get session ID
SessionResult sessionResult = getSessionId("0882819014");
if (sessionResult.success) {
System.out.println("Session created successfully!");
System.out.println("Session ID: " + sessionResult.sessionId);
System.out.println("Expires: " + sessionResult.expirationTime);
// Use session ID for subsequent API call
String inquiryXml =
"
" +
"" +
"2000" +
"Eng" +
"inquireTransactions" +
"" +
"0882819014" +
"customer123" +
"" +
"" +
"";
String inquiryResponse = makeSessionApiCall(sessionResult.sessionId, inquiryXml);
System.out.println("API call with session: " + (inquiryResponse.contains("000") ? "Success" : "Failed"));
} else {
System.out.println("Session creation failed: " + sessionResult.error);
}
}
```
} `
`python import requests from urllib.parse import urlencode from xml.etree import ElementTree as ET
def get\_session\_id(terminal\_number): """Generate a session ID for API authentication"""
```
server_url = "https://your-hyp-environment-url/xpo/Relay"
username = "your_username"
password = "your_password"
# Build XML payload
xml_payload = f"""
2000
Eng
getSessionId
{terminal_number}
"""
# 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':
session_data = root.find('.//getSessionId')
return {
'success': True,
'session_id': session_data.find('sessionId').text if session_data.find('sessionId') is not None else '',
'expiration_time': session_data.find('expirationTime').text if session_data.find('expirationTime') is not None else '',
'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}"
}
```
def make\_session\_api\_call(session\_id, xml\_payload): """Make an API call using session ID authentication"""
```
server_url = "https://your-hyp-environment-url/xpo/Relay"
# Prepare POST data using session ID instead of username/password
post_data = {
'sessionId': session_id,
'int_in': xml_payload.strip()
}
try:
response = requests.post(
server_url,
data=post_data,
headers={'Content-Type': 'application/x-www-form-urlencoded'},
timeout=30
)
response.raise_for_status()
return response.text
except requests.exceptions.RequestException as e:
return f"Request failed: {e}"
```
## Example usage
if **name** == "**main**": # Get session ID session\_result = get\_session\_id("0882819014")
```
if session_result['success']:
print("Session created successfully!")
print(f"Session ID: {session_result['session_id']}")
print(f"Expires: {session_result['expiration_time']}")
# Use session ID for subsequent API call
inquiry_xml = """
2000
Eng
inquireTransactions
0882819014
customer123
"""
inquiry_response = make_session_api_call(session_result['session_id'], inquiry_xml)
success = '000' in inquiry_response
print(f"API call with session: {'Success' if success else 'Failed'}")
if not success:
print(f"Response: {inquiry_response}")
else:
print(f"Session creation failed: {session_result['error']}")
```
`
`javascript const https = require('https'); const querystring = require('querystring'); const { parseStringPromise } = require('xml2js');
function getSessionId(terminalNumber) { return new Promise((resolve, reject) => { const serverUrl = '
'; const username = 'your\_username'; const password = 'your\_password';
```
// Build XML payload
const xmlPayload = `
2000
Eng
getSessionId
${terminalNumber}
`;
// 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 sessionData = response.getSessionId ? response.getSessionId[0] : {};
resolve({
success: true,
sessionId: sessionData.sessionId ? sessionData.sessionId[0] : '',
expirationTime: sessionData.expirationTime ? sessionData.expirationTime[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();
});
```
}
function makeSessionApiCall(sessionId, xmlPayload) { return new Promise((resolve, reject) => { const serverUrl = '';
```
// Prepare POST data using session ID instead of username/password
const postData = querystring.stringify({
sessionId: sessionId,
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, (res) => {
let responseData = '';
res.on('data', (chunk) => {
responseData += chunk;
});
res.on('end', () => {
if (res.statusCode === 200) {
resolve(responseData);
} else {
reject(new Error(`HTTP ${res.statusCode}: ${responseData}`));
}
});
});
req.on('error', (error) => {
reject(error);
});
req.write(postData);
req.end();
});
```
}
// Example usage async function example() { try { // Get session ID const sessionResult = await getSessionId('0882819014');
```
if (sessionResult.success) {
console.log('Session created successfully!');
console.log(`Session ID: ${sessionResult.sessionId}`);
console.log(`Expires: ${sessionResult.expirationTime}`);
// Use session ID for subsequent API call
const inquiryXml = `
2000
Eng
inquireTransactions
0882819014
customer123
`;
const inquiryResponse = await makeSessionApiCall(sessionResult.sessionId, inquiryXml);
const success = inquiryResponse.includes('000');
console.log(`API call with session: ${success ? 'Success' : 'Failed'}`);
if (!success) {
console.log(`Response: ${inquiryResponse}`);
}
} else {
console.log(`Session creation failed: ${sessionResult.error}`);
}
} catch (error) {
console.error('Operation failed:', error.message);
}
```
}
example();
```**Session Usage**: Once you have a session ID, use it in place of username/password by sending `sessionId` as a form parameter instead of `user` and `password` parameters.
**Session Security**: Session IDs should be treated as sensitive credentials. Store them securely and ensure they are not logged or exposed in error messages. Sessions may expire and require renewal.
```
---
# Agent Instructions: Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.
Perform an HTTP GET request on the current page URL with the `ask` query parameter:
```
GET https://developers.hyp.co.il/creditguard/api-reference/getsessionid.md?ask=
```
The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.
Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.