@montarist/nestpay-api-v2
Version:
Unofficial comprehensive TypeScript API client for Nestpay payment gateway with 3D Secure support
885 lines • 34.3 kB
JavaScript
"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.NestpayClient = void 0;
const axios_1 = __importDefault(require("axios"));
const enums_1 = require("../types/enums");
const errors_1 = require("../utils/errors");
const hash_1 = require("../utils/hash");
const provider_endpoints_1 = require("../utils/provider-endpoints");
const validators_1 = require("../utils/validators");
/**
* Enhanced Nestpay API client class with comprehensive provider support
* Supports all Turkish banks with automatic endpoint management and runtime provider switching
*/
class NestpayClient {
/**
* Initialize enhanced Nestpay client with provider support
* @param config Enhanced Nestpay configuration with provider support
*/
constructor(config) {
this.validateConfig(config);
this.config = this.buildConfig(config);
this.threeDModel = this.config.threeDModel || this.detectModelFromStoreType(this.config.storeType);
// Initialize provider and endpoints
this.currentProvider = this.config.provider || this.detectProviderFromConfig(this.config);
this.currentEndpoints = this.resolveEndpoints();
this.hashUtil = new hash_1.HashUtil(config.hashAlgorithm || enums_1.HashAlgorithm.SHA1, config.encodingType || enums_1.EncodingType.BASE64);
this.apiClient = this.createApiClient();
}
/**
* Process direct payment (without 3D Secure)
*/
async processDirectPayment(request) {
try {
this.validateDirectPaymentRequest(request);
const apiRequest = this.buildDirectPaymentRequest(request);
const response = await this.apiClient.post('', apiRequest);
return this.parseDirectPaymentResponse(response, request);
}
catch (error) {
return {
error: errors_1.ErrorHandler.createErrorResponse(error)
};
}
}
/**
* Initiate 3D Secure payment with model-specific implementation
*/
async initiate3DPayment(request) {
try {
this.validate3DPaymentRequest(request);
// Determine model from request or use client default
const model = this.get3DModelFromRequest(request);
const formData = this.build3DSecureForm(request, model);
return {
data: formData
};
}
catch (error) {
return {
error: errors_1.ErrorHandler.createErrorResponse(error)
};
}
}
/**
* Complete 3D Secure payment after callback
*/
async complete3DPayment(callbackData) {
try {
// Determine model from callback or use default
const model = callbackData.model || this.threeDModel;
this.verify3DCallback(callbackData);
const apiRequest = this.build3DCompletionRequest(callbackData);
const response = await this.apiClient.post('', apiRequest);
return this.parse3DPaymentResponse(response, callbackData, model);
}
catch (error) {
return {
error: errors_1.ErrorHandler.createErrorResponse(error)
};
}
}
/**
* Process refund
*/
async processRefund(request) {
try {
this.validateRefundRequest(request);
const apiRequest = this.buildRefundRequest(request);
const response = await this.apiClient.post('', apiRequest);
return this.parseRefundResponse(response, request);
}
catch (error) {
return {
error: errors_1.ErrorHandler.createErrorResponse(error)
};
}
}
/**
* Process void (cancel)
*/
async processVoid(request) {
try {
this.validateVoidRequest(request);
const apiRequest = this.buildVoidRequest(request);
const response = await this.apiClient.post('', apiRequest);
return this.parseVoidResponse(response, request);
}
catch (error) {
return {
error: errors_1.ErrorHandler.createErrorResponse(error)
};
}
}
/**
* Query transaction status
*/
async queryTransaction(request) {
try {
this.validateQueryRequest(request);
const apiRequest = this.buildQueryRequest(request);
const response = await this.apiClient.post('', apiRequest);
return this.parseQueryResponse(response, request);
}
catch (error) {
return {
error: errors_1.ErrorHandler.createErrorResponse(error)
};
}
}
/**
* Verify 3D Secure callback with primary status validation and optional hash verification
*/
verify3DCallbackHash(callbackData, strictHashValidation = false) {
// Check critical transaction status parameters first
const mdStatus = callbackData.mdStatus;
const response = callbackData.Response;
// Primary validation: mdStatus should be 1 for successful 3D Secure authentication
if (mdStatus !== '1') {
return false;
}
// Secondary validation: Check transaction response if available
if (response !== undefined) {
if (response !== 'Approved' && response !== '00') {
return false;
}
}
// Optional hash verification (disabled by default due to bank-specific implementations)
if (!strictHashValidation) {
return true;
}
// Hash verification (only if strictHashValidation = true)
const receivedHash = callbackData.HASH || callbackData.hash;
if (!receivedHash) {
return true; // If no hash, rely on status validation
}
// Try different parameter combinations
const methods = this.getCallbackHashMethods(callbackData);
for (let i = 0; i < methods.length; i++) {
const method = methods[i];
// Try pipe separator
const verifyPipe = this.hashUtil.verifyHashV3(method.params, receivedHash, this.config.storeKey);
if (verifyPipe) {
return true;
}
// Try semicolon separator
const verifySemicolon = this.hashUtil.verifyHashV3(method.params, receivedHash, this.config.storeKey, ';');
if (verifySemicolon) {
return true;
}
}
return false;
}
/**
* Get current 3D model
*/
get3DModel() {
return this.threeDModel;
}
/**
* Set 3D model (for runtime switching if needed)
*/
set3DModel(model) {
this.threeDModel = model;
}
/**
* Get current provider
*/
getProvider() {
return this.currentProvider;
}
/**
* Get current provider display name
*/
getProviderDisplayName() {
return provider_endpoints_1.ProviderEndpointManager.getProviderDisplayName(this.currentProvider);
}
/**
* Set provider and update endpoints (runtime provider switching)
*/
setProvider(provider, customEndpoints) {
// Validate provider configuration
const validation = provider_endpoints_1.ProviderEndpointManager.validateProvider(provider, customEndpoints);
if (!validation.isValid) {
throw new errors_1.ConfigurationError(`Invalid provider configuration: ${validation.errors.join(', ')}`, { provider, errors: validation.errors });
}
this.currentProvider = provider;
// Update custom endpoints if provided
if (provider === enums_1.BankProvider.CUSTOM && customEndpoints) {
this.config.customEndpoints = customEndpoints;
}
// Resolve new endpoints
this.currentEndpoints = this.resolveEndpoints();
// Update API client with new endpoints
this.apiClient = this.createApiClient();
}
/**
* Get current endpoints
*/
getCurrentEndpoints() {
return { ...this.currentEndpoints };
}
/**
* Test hash generation with bank provided example
*/
testHashWithBankExample() {
return this.hashUtil.testBankExample();
}
/**
* Debug 3D Secure callback validation - shows status and optional hash analysis
*/
debug3DCallbackHash(callbackData) {
// Status-based validation (primary method)
const mdStatus = callbackData.mdStatus || '';
const response = callbackData.Response || '';
const procReturnCode = callbackData.ProcReturnCode || '';
const statusValid = mdStatus === '1' && (response === undefined || response === 'Approved' || response === '00');
const result = {
statusValidation: {
mdStatus,
response,
procReturnCode,
isValid: statusValid
}
};
// Optional hash analysis (if hash exists)
const receivedHash = callbackData.HASH || callbackData.hash;
if (receivedHash) {
try {
const methods = this.getCallbackHashMethods(callbackData);
result.hashAnalysis = this.hashUtil.debugHashVerification(methods[0].params, receivedHash, this.config.storeKey);
}
catch (error) {
result.hashAnalysis = {
error: 'Hash analysis failed: ' + error.message
};
}
}
return result;
}
/**
* Get all available providers
*/
static getAvailableProviders() {
return provider_endpoints_1.ProviderEndpointManager.getAvailableProviders();
}
/**
* Get provider display name
*/
static getProviderDisplayName(provider) {
return provider_endpoints_1.ProviderEndpointManager.getProviderDisplayName(provider);
}
/**
* Auto-detect provider from client ID
*/
static detectProviderFromClientId(clientId) {
return provider_endpoints_1.ProviderEndpointManager.detectProviderFromClientId(clientId);
}
/**
* Detect provider from configuration
*/
detectProviderFromConfig(config) {
// First try explicit provider
if (config.provider) {
return config.provider;
}
// Try auto-detection from client ID
const detected = provider_endpoints_1.ProviderEndpointManager.detectProviderFromClientId(config.clientId);
if (detected) {
return detected;
}
// Check if custom endpoints are provided
if (config.customEndpoints || config.apiEndpoint) {
return enums_1.BankProvider.CUSTOM;
}
// Default fallback to İş Bankası (most common)
return enums_1.BankProvider.ISBANK;
}
/**
* Resolve endpoints based on current provider and configuration
*/
resolveEndpoints() {
// Check for explicit endpoint configuration
if (this.config.apiEndpoint && this.config.threeDEndpoint) {
return {
api: this.config.apiEndpoint,
threeD: this.config.threeDEndpoint
};
}
// Get provider-specific endpoints
return provider_endpoints_1.ProviderEndpointManager.getEndpoints(this.currentProvider, this.config.isTestMode || false, this.config.customEndpoints);
}
/**
* Detect 3D model from store type
*/
detectModelFromStoreType(storeType) {
switch (storeType) {
case enums_1.StoreType.CLASSIC_3D:
return enums_1.ThreeDModel.CLASSIC;
case enums_1.StoreType.PAY_3D:
return enums_1.ThreeDModel.PAY;
case enums_1.StoreType.PAY_HOSTING_3D:
return enums_1.ThreeDModel.PAY_HOSTING;
default:
return enums_1.ThreeDModel.CLASSIC;
}
}
/**
* Get 3D model from request or use default
*/
get3DModelFromRequest(request) {
if ('model' in request) {
return request.model;
}
return this.threeDModel;
}
/**
* Validate configuration
*/
validateConfig(config) {
const validation = validators_1.Validators.validateConfig(config);
if (!validation.isValid) {
throw new errors_1.ConfigurationError('Invalid configuration', { errors: validation.errors });
}
// Validate provider if specified
if (config.provider) {
const providerValidation = provider_endpoints_1.ProviderEndpointManager.validateProvider(config.provider, config.customEndpoints);
if (!providerValidation.isValid) {
throw new errors_1.ConfigurationError(`Invalid provider configuration: ${providerValidation.errors.join(', ')}`, { provider: config.provider, errors: providerValidation.errors });
}
}
}
/**
* Build complete configuration with defaults
*/
buildConfig(config) {
return {
...config,
language: config.language || enums_1.Language.TURKISH,
hashAlgorithm: config.hashAlgorithm || enums_1.HashAlgorithm.SHA1,
encodingType: config.encodingType || enums_1.EncodingType.BASE64,
threeDModel: config.threeDModel || this.detectModelFromStoreType(config.storeType)
};
}
/**
* Create configured axios instance
*/
createApiClient() {
return axios_1.default.create({
baseURL: this.currentEndpoints.api,
timeout: 30000,
headers: {
'Content-Type': 'application/x-www-form-urlencoded',
'User-Agent': '@montarist/nestpay-api-v2',
'X-Provider': this.currentProvider
}
});
}
/**
* Validate direct payment request
*/
validateDirectPaymentRequest(request) {
const errors = [];
const cardValidation = validators_1.Validators.validateCreditCard(request.creditCard);
if (!cardValidation.isValid) {
errors.push(...cardValidation.errors);
}
const amountValidation = validators_1.Validators.validateAmount(request.amount, request.currency);
if (!amountValidation.isValid) {
errors.push(...amountValidation.errors);
}
const orderValidation = validators_1.Validators.validateOrderId(request.orderId);
if (!orderValidation.isValid) {
errors.push(...orderValidation.errors);
}
const installmentValidation = validators_1.Validators.validateInstallment(request.installment);
if (!installmentValidation.isValid) {
errors.push(...installmentValidation.errors);
}
if (request.customer?.email) {
const emailValidation = validators_1.Validators.validateEmail(request.customer.email);
if (!emailValidation.isValid) {
errors.push(...emailValidation.errors);
}
}
if (errors.length > 0) {
throw new errors_1.ValidationError(errors);
}
}
/**
* Build direct payment API request
*/
buildDirectPaymentRequest(request) {
const amount = request.amount.toFixed(2);
const hash = this.hashUtil.generateHashV3({
amount,
clientid: this.config.clientId,
currency: request.currency,
hashAlgorithm: 'ver3',
Instalment: request.installment || '',
islemtipi: request.transactionType || enums_1.TransactionType.SALE,
lang: this.config.language || 'tr',
oid: request.orderId,
rnd: Date.now().toString(),
storetype: this.config.storeType,
TranType: 'Auth'
}, this.config.storeKey);
return {
clientid: this.config.clientId,
amount,
oid: request.orderId,
currency: request.currency,
taksit: request.installment || '',
pan: request.creditCard.pan,
Ecom_Payment_Card_ExpDate_Month: request.creditCard.expiry.substring(0, 2),
Ecom_Payment_Card_ExpDate_Year: request.creditCard.expiry.substring(2, 4),
cv2: request.creditCard.cvv,
hash,
storetype: this.config.storeType,
lang: this.config.language || enums_1.Language.TURKISH,
email: request.customer?.email || '',
tel: request.customer?.phone || '',
islemtipi: request.transactionType || enums_1.TransactionType.SALE
};
}
/**
* Parse direct payment response
*/
parseDirectPaymentResponse(response, request) {
const data = response.data;
const error = errors_1.ErrorHandler.parseApiError(data, response.status);
if (error) {
return { error: errors_1.ErrorHandler.createErrorResponse(error) };
}
const success = data.Response === enums_1.ResponseCode.SUCCESS;
return {
data: {
success,
orderId: request.orderId,
amount: request.amount,
currency: request.currency,
transactionId: data.TransId,
authCode: data.AuthCode,
hostRefNum: data.HostRefNum,
procReturnCode: data.ProcReturnCode,
response: data.Response,
errorMessage: success ? undefined : data.ErrMsg,
hash: data.HASH,
installment: request.installment
},
raw: data
};
}
/**
* Validate 3D payment request
*/
validate3DPaymentRequest(request) {
const errors = [];
try {
this.validateDirectPaymentRequest(request);
}
catch (error) {
if (error instanceof errors_1.ValidationError) {
errors.push(...error.validationErrors);
}
}
const callbackValidation = validators_1.Validators.validateUrl(request.callbackUrl, 'Callback URL');
if (!callbackValidation.isValid) {
errors.push(...callbackValidation.errors);
}
const failureValidation = validators_1.Validators.validateUrl(request.failureUrl, 'Failure URL');
if (!failureValidation.isValid) {
errors.push(...failureValidation.errors);
}
if (errors.length > 0) {
throw new errors_1.ValidationError(errors);
}
}
/**
* Build 3D Secure form data with model-specific implementation
*/
build3DSecureForm(request, model) {
const amount = request.amount.toFixed(2);
// First build form data without hash
const formDataWithoutHash = this.build3DFormDataWithoutHash(request, model, amount);
// Test both separators
const hashResults = this.hashUtil.testSeparators(formDataWithoutHash, this.config.storeKey);
// Use pipe by default (as per documentation) - change to ';' if your bank requires semicolon
const hash = hashResults.pipe;
// Add hash to form data
const formData = { ...formDataWithoutHash, hash };
const html = this.generate3DFormHTML(formData, model, request);
return {
html,
formAction: this.currentEndpoints.threeD,
formData,
model,
refreshTime: this.getRefreshTimeForModel(request, model)
};
}
/**
* Build 3D form data without hash (for hash calculation)
*/
build3DFormDataWithoutHash(request, model, amount) {
const baseFormData = {
clientid: this.config.clientId,
amount,
oid: request.orderId,
currency: request.currency,
taksit: request.installment || '',
pan: request.creditCard.pan,
Ecom_Payment_Card_ExpDate_Month: request.creditCard.expiry.substring(0, 2),
Ecom_Payment_Card_ExpDate_Year: request.creditCard.expiry.substring(2, 4),
cv2: request.creditCard.cvv,
hashAlgorithm: 'ver3',
storetype: this.config.storeType,
lang: this.config.language || 'tr',
okUrl: request.callbackUrl,
failUrl: request.failureUrl,
email: request.customer?.email || '',
tel: request.customer?.phone || '',
islemtipi: request.transactionType || enums_1.TransactionType.SALE,
refreshtime: this.getRefreshTimeForModel(request, model)?.toString() || '1' // Default 1 if not specified
};
// Add model-specific fields
if (model === enums_1.ThreeDModel.PAY_HOSTING) {
const payHostingUrl = this.getPayHostingUrl(request);
if (payHostingUrl) {
baseFormData.payhostingurl = payHostingUrl;
}
}
return baseFormData;
}
/**
* Get different callback hash verification methods to try
*/
getCallbackHashMethods(callbackData) {
// Method 1: Minimal transaction parameters (most common for callbacks)
const method1 = {
oid: callbackData.oid || '',
AuthCode: callbackData.AuthCode || '',
ProcReturnCode: callbackData.ProcReturnCode || '',
Response: callbackData.Response || '',
mdStatus: callbackData.mdStatus || '',
cavv: callbackData.cavv || '',
eci: callbackData.eci || '',
md: callbackData.md || '',
rnd: callbackData.rnd || ''
};
// Method 2: Even more minimal (oid + AuthCode + Response + rnd)
const method2 = {
oid: callbackData.oid || '',
AuthCode: callbackData.AuthCode || '',
Response: callbackData.Response || '',
rnd: callbackData.rnd || ''
};
// Method 3: Original form params
const method3 = {};
const formParams = [
'amount', 'clientid', 'currency', 'taksit',
'Ecom_Payment_Card_ExpDate_Month', 'Ecom_Payment_Card_ExpDate_Year',
'hashAlgorithm', 'storetype', 'lang', 'okUrl', 'failUrl',
'email', 'tel', 'islemtipi', 'refreshtime', 'oid', 'rnd'
];
for (const param of formParams) {
if (callbackData[param] !== undefined) {
method3[param] = callbackData[param];
}
}
// Method 4: Ultra minimal (just oid + rnd)
const method4 = {
oid: callbackData.oid || '',
rnd: callbackData.rnd || ''
};
return [
{ name: 'Transaction Parameters', params: method1 },
{ name: 'Minimal Parameters', params: method2 },
{ name: 'Form Parameters', params: method3 },
{ name: 'Ultra Minimal', params: method4 }
];
}
/**
* Generate 3D form HTML based on model
*/
generate3DFormHTML(formData, model, request) {
const formFields = Object.entries(formData)
.map(([key, value]) => `<input type="hidden" name="${key}" value="${value}">`)
.join('\n');
const providerInfo = `${provider_endpoints_1.ProviderEndpointManager.getProviderDisplayName(this.currentProvider)} - ${model}`;
const autoSubmit = model === enums_1.ThreeDModel.PAY ?
`<script>
setTimeout(() => {
document.getElementById('nestpay-3d-form').submit();
}, ${this.getRefreshTimeForModel(request, model) || 0} * 1000);
</script>` :
`<script>document.getElementById('nestpay-3d-form').submit();</script>`;
return `
<form id="nestpay-3d-form" action="${this.currentEndpoints.threeD}" method="post">
${formFields}
<input type="hidden" name="encoding" value="UTF-8" />
<input type="submit" value="3D Secure ile Öde (${providerInfo})">
</form>
${autoSubmit}
`;
}
/**
* Get refresh time for model
*/
getRefreshTimeForModel(request, model) {
if (model === enums_1.ThreeDModel.PAY) {
if ('refreshTime' in request) {
return request.refreshTime;
}
return this.config.refreshTime;
}
return undefined;
}
/**
* Get pay hosting URL
*/
getPayHostingUrl(request) {
if ('payHostingUrl' in request) {
return request.payHostingUrl;
}
return this.config.payHostingUrl;
}
/**
* Verify 3D callback data with model-specific verification
*/
verify3DCallback(callbackData) {
if (!this.verify3DCallbackHash(callbackData)) {
throw new errors_1.ValidationError(['3D Secure callback validation failed']);
}
// Additional check for ThreeDStatus if available
if (callbackData.status && callbackData.status !== enums_1.ThreeDStatus.SUCCESS) {
throw new errors_1.ValidationError(['3D Secure verification failed']);
}
}
/**
* Build 3D completion request
*/
build3DCompletionRequest(callbackData) {
return {
clientid: this.config.clientId,
oid: callbackData.orderId,
AuthCode: callbackData.authCode,
ProcReturnCode: callbackData.procReturnCode,
TransId: callbackData.transId,
HASH: callbackData.hash
};
}
/**
* Parse 3D payment response with model information
*/
parse3DPaymentResponse(response, callbackData, model) {
const data = response.data;
// For 3D Pay, callback data contains the final transaction result
// Success is determined by callback data, not API response
const callbackSuccess = callbackData.mdStatus === '1' &&
(callbackData.response === 'Approved' || callbackData.response === '00');
// Also check API response if available
const apiSuccess = data.Response === enums_1.ResponseCode.SUCCESS || data.Response === 'Approved';
// Final success: both callback and API should indicate success
const success = callbackSuccess && (apiSuccess || !data.Response);
const error = errors_1.ErrorHandler.parseApiError(data, response.status);
if (error && !callbackSuccess) {
return { error: errors_1.ErrorHandler.createErrorResponse(error) };
}
return {
data: {
success,
orderId: callbackData.orderId,
amount: parseFloat(callbackData.amount) / 100,
currency: callbackData.currency,
threeDStatus: callbackData.status,
transactionId: data.TransId || callbackData.transId,
authCode: data.AuthCode || callbackData.authCode,
hostRefNum: data.HostRefNum || callbackData.hostRefNum,
procReturnCode: data.ProcReturnCode || callbackData.procReturnCode,
response: data.Response || callbackData.response,
errorMessage: success ? undefined : data.ErrMsg || callbackData.errorMessage,
hash: data.HASH || callbackData.hash,
cavv: callbackData.cavv,
eci: callbackData.eci,
xid: callbackData.xid,
mdStatus: callbackData.mdStatus,
model
},
raw: data
};
}
// Implementation methods for refund, void, and query remain the same as before
validateRefundRequest(request) {
const errors = [];
const orderValidation = validators_1.Validators.validateOrderId(request.orderId);
if (!orderValidation.isValid) {
errors.push(...orderValidation.errors);
}
if (request.amount && request.currency) {
const amountValidation = validators_1.Validators.validateAmount(request.amount, request.currency);
if (!amountValidation.isValid) {
errors.push(...amountValidation.errors);
}
}
if (errors.length > 0) {
throw new errors_1.ValidationError(errors);
}
}
buildRefundRequest(request) {
const amount = request.amount ?
request.amount.toFixed(2) : '';
const hash = this.hashUtil.generateHashV3({
amount,
clientid: this.config.clientId,
currency: request.currency || enums_1.Currency.TRY,
hashAlgorithm: 'ver3',
islemtipi: enums_1.TransactionType.REFUND,
lang: this.config.language || 'tr',
oid: request.orderId,
rnd: Date.now().toString(),
storetype: this.config.storeType,
TranType: 'Credit'
}, this.config.storeKey);
const apiRequest = {
clientid: this.config.clientId,
oid: request.orderId,
hash,
storetype: this.config.storeType,
lang: this.config.language || enums_1.Language.TURKISH,
islemtipi: enums_1.TransactionType.REFUND
};
if (request.amount && request.currency) {
apiRequest.amount = amount;
apiRequest.currency = request.currency;
}
return apiRequest;
}
parseRefundResponse(response, request) {
const data = response.data;
const error = errors_1.ErrorHandler.parseApiError(data, response.status);
if (error) {
return { error: errors_1.ErrorHandler.createErrorResponse(error) };
}
const success = data.Response === enums_1.ResponseCode.SUCCESS;
return {
data: {
success,
orderId: data.TransId || request.orderId,
originalOrderId: request.orderId,
refundAmount: request.amount || 0,
currency: request.currency || enums_1.Currency.TRY,
transactionId: data.TransId,
authCode: data.AuthCode,
hostRefNum: data.HostRefNum,
procReturnCode: data.ProcReturnCode,
response: data.Response,
errorMessage: success ? undefined : data.ErrMsg,
hash: data.HASH
},
raw: data
};
}
validateVoidRequest(request) {
const validation = validators_1.Validators.validateOrderId(request.orderId);
if (!validation.isValid) {
throw new errors_1.ValidationError(validation.errors);
}
}
buildVoidRequest(request) {
const hash = this.hashUtil.generateHashV3({
clientid: this.config.clientId,
hashAlgorithm: 'ver3',
islemtipi: enums_1.TransactionType.VOID,
lang: this.config.language || 'tr',
oid: request.orderId,
rnd: Date.now().toString(),
storetype: this.config.storeType,
TranType: 'Void'
}, this.config.storeKey);
return {
clientid: this.config.clientId,
oid: request.orderId,
hash,
storetype: this.config.storeType,
lang: this.config.language || enums_1.Language.TURKISH,
islemtipi: enums_1.TransactionType.VOID
};
}
parseVoidResponse(response, request) {
const data = response.data;
const error = errors_1.ErrorHandler.parseApiError(data, response.status);
if (error) {
return { error: errors_1.ErrorHandler.createErrorResponse(error) };
}
const success = data.Response === enums_1.ResponseCode.SUCCESS;
return {
data: {
success,
orderId: data.TransId || request.orderId,
originalOrderId: request.orderId,
transactionId: data.TransId,
authCode: data.AuthCode,
hostRefNum: data.HostRefNum,
procReturnCode: data.ProcReturnCode,
response: data.Response,
errorMessage: success ? undefined : data.ErrMsg,
hash: data.HASH
},
raw: data
};
}
validateQueryRequest(request) {
const validation = validators_1.Validators.validateOrderId(request.orderId);
if (!validation.isValid) {
throw new errors_1.ValidationError(validation.errors);
}
}
buildQueryRequest(request) {
const hash = this.hashUtil.generateHashV3({
clientid: this.config.clientId,
hashAlgorithm: 'ver3',
islemtipi: 'TRANS_INQUIRY',
lang: this.config.language || 'tr',
oid: request.orderId,
rnd: Date.now().toString(),
storetype: this.config.storeType
}, this.config.storeKey);
return {
clientid: this.config.clientId,
oid: request.orderId,
hash,
storetype: this.config.storeType,
lang: this.config.language || enums_1.Language.TURKISH,
islemtipi: 'TRANS_INQUIRY'
};
}
parseQueryResponse(response, request) {
const data = response.data;
const error = errors_1.ErrorHandler.parseApiError(data, response.status);
if (error) {
return { error: errors_1.ErrorHandler.createErrorResponse(error) };
}
const success = data.Response === enums_1.ResponseCode.SUCCESS;
return {
data: {
success,
orderId: request.orderId,
transactionId: data.TransId,
amount: data.amount ? parseFloat(data.amount) / 100 : undefined,
currency: data.currency,
status: data.Response,
authCode: data.AuthCode,
hostRefNum: data.HostRefNum,
transactionType: data.islemtipi,
transactionDate: data.TransDate,
errorMessage: success ? undefined : data.ErrMsg
},
raw: data
};
}
}
exports.NestpayClient = NestpayClient;
//# sourceMappingURL=nestpay-client.js.map