Reload97 / sate24-to-kospinjasa

Compare View

switch
from
...
to
 
Commits (2)

Changes

Showing 1 changed file Inline Diff

partner-kospinjasa.js
Diff comments   View file @ 89c3eca
1 var winston = require('winston'); 1 var winston = require('winston');
2 var soap = require('soap'); 2 var soap = require('soap');
3 var crypto = require('crypto'); 3 var crypto = require('crypto');
4 var strftime = require('strftime'); 4 var strftime = require('strftime');
5 var fs = require("fs"); 5 var fs = require("fs");
6 var http = require("http"); 6 var http = require("http");
7 var url = require("url"); 7 var url = require("url");
8 var mongoClient = require('mongodb').MongoClient; 8 var mongoClient = require('mongodb').MongoClient;
9 var moment = require('moment'); 9 var moment = require('moment');
10 10
11 process.chdir(__dirname); 11 process.chdir(__dirname);
12 12
13 var max_retry = 10; 13 var max_retry = 10;
14 var sleep_before_retry = 5000; 14 var sleep_before_retry = 5000;
15 15
16 var config; 16 var config;
17 var matrix; 17 var matrix;
18 var callbackReport; 18 var callbackReport;
19 var aaa; 19 var aaa;
20 var logger; 20 var logger;
21 var options; 21 var options;
22 var mongodb; 22 var mongodb;
23 23
24 function start(_config, _callbackReport, options) {
25 config = _config; 24 function start(_config, _callbackReport, options) {
26 callbackReport = _callbackReport 25 config = _config;
27 26 callbackReport = _callbackReport
28 if (options && options.aaa) { 27
29 aaa = options.aaa; 28 if (options && options.aaa) {
30 } 29 aaa = options.aaa;
31 30 }
32 if (options && options.logger) { 31
33 logger = options.logger; 32 if (options && options.logger) {
34 } else { 33 logger = options.logger;
35 logger = new winston.Logger({ 34 } else {
36 transports: [ 35 logger = new winston.Logger({
37 new (winston.transports.Console)() 36 transports: [
38 ] 37 new (winston.transports.Console)()
39 }); 38 ]
40 } 39 });
41 40 }
42 if (options && options.matrix) { 41
43 matrix = options.matrix; 42 if (options && options.matrix) {
44 } 43 matrix = options.matrix;
45 44 }
46 initMongoClient(); 45
47 } 46 initMongoClient();
48 47 }
49 function callbackReportWrapper(requestId, responseCode, message, dontIncrement) { 48
50 callbackReport(requestId, responseCode, message); 49 function callbackReportWrapper(requestId, responseCode, message, dontIncrement) {
51 50 callbackReport(requestId, responseCode, message);
52 if (dontIncrement) { 51
53 return; 52 if (dontIncrement) {
54 } 53 return;
55 54 }
56 try { 55
57 aaa.incrementStrikeStatus(responseCode); 56 try {
58 } catch(err) { 57 aaa.incrementStrikeStatus(responseCode);
59 logger.warn("Gagal aaa.incrementStrikeStatus: " + err); 58 } catch(err) {
60 } 59 logger.warn("Gagal aaa.incrementStrikeStatus: " + err);
61 } 60 }
62 61 }
63 function initMongoClient() { 62
64 if (!config || !config.mongodb || !config.mongodb.url) { 63 function initMongoClient() {
65 return; 64 if (!config || !config.mongodb || !config.mongodb.url) {
66 } 65 return;
67 66 }
68 try { 67
69 var url = config.mongodb.url; 68 try {
70 69 var url = config.mongodb.url;
71 mongoClient.connect(url, function(err, db) { 70
72 if (err) { 71 mongoClient.connect(url, function(err, db) {
73 logger.warn('Failed to connect to mongodb', {err: err}); 72 if (err) {
74 return; 73 logger.warn('Failed to connect to mongodb', {err: err});
75 } 74 return;
76 mongodb = db; 75 }
77 logger.info('MongoDB connected'); 76 mongodb = db;
78 }); 77 logger.info('MongoDB connected');
79 } 78 });
80 catch(err) { 79 }
81 logger.warn('Exception when connecting to mongodb', {err: err, url: url}); 80 catch(err) {
82 } 81 logger.warn('Exception when connecting to mongodb', {err: err, url: url});
83 } 82 }
84 83 }
85 function insertTaskToMongoDb(task) { 84
86 if (!isMongoReady()) { return; } 85 function insertTaskToMongoDb(task) {
87 86 if (!isMongoReady()) { return; }
88 task.supplier = config.globals.gateway_name; 87
89 task.rc = '68'; 88 task.supplier = config.globals.gateway_name;
90 89 task.rc = '68';
91 try { 90
92 mongodb.collection(config.mongodb.collection).insertOne(task); 91 try {
93 } 92 mongodb.collection(config.mongodb.collection).insertOne(task);
94 catch(err) { 93 }
95 //logger.warn('Exception when inserting document to mongodb', {err: err, task: task}); 94 catch(err) {
96 } 95 //logger.warn('Exception when inserting document to mongodb', {err: err, task: task});
97 } 96 }
98 97 }
99 function pushResponseToMongoDb(task, response, rc) { 98
100 if (!isMongoReady()) { return; } 99 function pushResponseToMongoDb(task, response, rc) {
101 100 if (!isMongoReady()) { return; }
102 101
103 try { 102
104 if (!response.ts) { 103 try {
105 response.ts = strftime('%Y-%m-%d %H:%M:%S', new Date()); 104 if (!response.ts) {
106 } 105 response.ts = strftime('%Y-%m-%d %H:%M:%S', new Date());
107 106 }
108 mongodb.collection(config.mongodb.collection).updateOne( 107
109 {requestId: task.requestId}, 108 mongodb.collection(config.mongodb.collection).updateOne(
110 { 109 {requestId: task.requestId},
111 $set: { 110 {
112 lastResponse: response, 111 $set: {
113 supplier: config.globals.gateway_name, 112 lastResponse: response,
114 rc: rc 113 supplier: config.globals.gateway_name,
115 }, 114 rc: rc
116 $push: { 115 },
117 responses: response 116 $push: {
118 } 117 responses: response
119 }, 118 }
120 function(err, result) { 119 },
121 if (err) { 120 function(err, result) {
122 logger.warn('Error when pushing response to mongodb', {err: err, task: task, response: response}); 121 if (err) {
123 return; 122 logger.warn('Error when pushing response to mongodb', {err: err, task: task, response: response});
124 } 123 return;
125 } 124 }
126 ); 125 }
127 } 126 );
128 catch(err) { 127 }
129 logger.warn('Exception when pushing response to mongodb', {err: err, task: task, response: response}); 128 catch(err) {
130 } 129 logger.warn('Exception when pushing response to mongodb', {err: err, task: task, response: response});
131 } 130 }
132 131 }
133 function isMongoReady() { 132
134 if (!config.mongodb) { return; } 133 function isMongoReady() {
135 if (!config.mongodb.collection) { return; } 134 if (!config.mongodb) { return; }
136 if (!mongodb) { return; } 135 if (!config.mongodb.collection) { return; }
137 136 if (!mongodb) { return; }
138 return true; 137
139 } 138 return true;
140 139 }
141 function topupRequest(task, retry) { 140
142 141 function topupRequest(task, retry) {
143 try { 142
144 if (config && config.globals && config.globals.reject_on_pending_count && matrix && matrix.strikeStatus && matrix.strikeStatus.pending) { 143 try {
145 144 if (config && config.globals && config.globals.reject_on_pending_count && matrix && matrix.strikeStatus && matrix.strikeStatus.pending) {
146 var pendingCount = matrix.strikeStatus.pending; 145
146 var pendingCount = matrix.strikeStatus.pending;
147 var pendingLimitCount = parseInt(config.globals.reject_on_pending_count);
148
149 if (pendingLimitCount <= matrix.strikeStatus.pending) {
150
151 logger.warn(
152 'Reject trx karena pending terlalu banyak',
153 {pendingCount: pendingCount, pendingLimitCount: pendingLimitCount}
154 );
155
156 callbackReport(task.requestId, '13', 'Reject trx karena pending terlalu banyak');
157 return;
158 }
147 var pendingLimitCount = parseInt(config.globals.reject_on_pending_count); 159 }
148 160 }
161 catch(err) {
162 logger.warn("Exception saat periksa pendingLimit: " + err);
163 }
164
149 if (pendingLimitCount <= matrix.strikeStatus.pending) { 165
150 166 task.ts = moment(task.timestamp, 'YYYYMMDDHHmmss').format('YYYY-MM-DD HH:mm:ss');
151 logger.warn( 167 task.ts_date = moment(task.timestamp, 'YYYYMMDDHHmmss').format('YYYY-MM-DD');
152 'Reject trx karena pending terlalu banyak', 168
153 {pendingCount: pendingCount, pendingLimitCount: pendingLimitCount} 169 insertTaskToMongoDb(task);
154 ); 170 saldoCheck(billpayment, task);
155 171 }
156 callbackReport(task.requestId, '13', 'Reject trx karena pending terlalu banyak'); 172
157 return; 173 function saldoCheck(callback, task) {
158 } 174
159 } 175 var params = {
160 } 176 userName: config.h2h_out.userid,
161 catch(err) { 177 productCode: '00000' ,
162 logger.warn("Exception saat periksa pendingLimit: " + err); 178 terminal: 'H2HIPN10',
163 } 179 transactionType: '61',
164 180 reff: Math.ceil( Math.random() * 99999999 ),
165 181 timeStamp: strftime('%Y-%m-%d %H:%M:%S', new Date())
166 task.ts = moment(task.timestamp, 'YYYYMMDDHHmmss').format('YYYY-MM-DD HH:mm:ss'); 182 }
167 task.ts_date = moment(task.timestamp, 'YYYYMMDDHHmmss').format('YYYY-MM-DD'); 183
168 184 params.signature = createSignatureForSaldoCheck(params, config.h2h_out.password);
169 insertTaskToMongoDb(task); 185
170 saldoCheck(billpayment, task); 186 soap.createClient(config.h2h_out.partner, function(err, soapClient) {
171 } 187
172 188 if (err) {
173 function saldoCheck(callback, task) { 189
174 190 var errorMessage = 'Error creating soap client for saldoCheck: ' + err;
175 var params = { 191
176 userName: config.h2h_out.userid, 192 logger.warn(errorMessage, {err: err});
177 productCode: '00000' , 193 callbackReportWrapper(task.requestId, '40', errorMessage);
178 terminal: 'H2HIPN10', 194 pushResponseToMongoDb(task, {supplier: config.globals.gateway_name, raw: errorMessage}, '40');
179 transactionType: '61', 195
180 reff: Math.ceil( Math.random() * 99999999 ), 196 return;
181 timeStamp: strftime('%Y-%m-%d %H:%M:%S', new Date()) 197 }
182 } 198
183 199 logger.info('Requesting to service', {url: config.h2h_out.partner, params: params});
184 params.signature = createSignatureForSaldoCheck(params, config.h2h_out.password); 200 soapClient.apih2h.apih2hPort.saldoCheck({ inputSaldo: params }, function(err, result) {
185 201
186 soap.createClient(config.h2h_out.partner, function(err, soapClient) { 202 logger.verbose(
187 203 'Got saldoCheck response',
188 if (err) { 204 {
189 205 lastEndpoint: soapClient.lastEndpoint,
190 var errorMessage = 'Error creating soap client for saldoCheck: ' + err; 206 lastRequest: soapClient.lastRequest,
191 207 lastMessage: soapClient.lastMessage,
192 logger.warn(errorMessage, {err: err}); 208 lastResponse: soapClient.lastResponse,
193 callbackReportWrapper(task.requestId, '40', errorMessage); 209 }
194 pushResponseToMongoDb(task, {supplier: config.globals.gateway_name, raw: errorMessage}, '40'); 210 );
195 211
196 return; 212 if (err) {
197 } 213 var errorMessage = 'Error requesting saldoCheck: ' + err;
198 214
199 logger.info('Requesting to service', {url: config.h2h_out.partner, params: params}); 215 logger.warn(errorMessage, {err: err});
200 soapClient.apih2h.apih2hPort.saldoCheck({ inputSaldo: params }, function(err, result) { 216 callbackReportWrapper(task.requestId, '40', errorMessage);
201 217 pushResponseToMongoDb(task, {supplier: config.globals.gateway_name, raw: errorMessage}, '40');
202 logger.verbose( 218 }
203 'Got saldoCheck response', 219
204 { 220 var balance;
205 lastEndpoint: soapClient.lastEndpoint, 221 logger.verbose('saldoCheck result', {result: result});
206 lastRequest: soapClient.lastRequest, 222
207 lastMessage: soapClient.lastMessage, 223 try {
208 lastResponse: soapClient.lastResponse, 224 balance = result.outputParameter.bit61.$value;
209 } 225 }
210 ); 226 catch(e) {
211 227 balance = 'UNKNOWN';
212 if (err) { 228 }
213 var errorMessage = 'Error requesting saldoCheck: ' + err; 229
214 230
215 logger.warn(errorMessage, {err: err}); 231 if (task) {
216 callbackReportWrapper(task.requestId, '40', errorMessage); 232 callback(task, balance);
217 pushResponseToMongoDb(task, {supplier: config.globals.gateway_name, raw: errorMessage}, '40'); 233 }
218 } 234 });
219 235 });
220 var balance; 236
221 logger.verbose('saldoCheck result', {result: result}); 237 }
222 238
223 try { 239 function billpayment(task, balance) {
224 balance = result.outputParameter.bit61.$value; 240
225 } 241 var terminalSuffix = Math.ceil( Math.random() * 20 ) + 10;
226 catch(e) { 242 var remoteProduct = task.remoteProduct.split(',');
227 balance = 'UNKNOWN'; 243
228 } 244 var params = {
229 245 userName: config.h2h_out.userid,
230 246 productCode: remoteProduct[0] ,
231 if (task) { 247 terminal: 'H2HIPN' + terminalSuffix,
232 callback(task, balance); 248 transactionType: '50',
233 } 249 billNumber: createBillNumber(task.destination),
234 }); 250 amount: remoteProduct[1],
235 }); 251 bit61: createBillNumber(task.destination),
236 252 reff: task.requestId,
237 } 253 timeStamp: strftime('%Y-%m-%d %H:%M:%S', new Date())
238 254 }
239 function billpayment(task, balance) { 255
240 256 var signature = createSignature(params, config.h2h_out.password);
241 var terminalSuffix = Math.ceil( Math.random() * 20 ) + 10; 257 params.signature = signature;
242 var remoteProduct = task.remoteProduct.split(','); 258
243 259 soap.createClient(config.h2h_out.partner, function(err, soapClient) {
244 var params = { 260
245 userName: config.h2h_out.userid, 261 var _params = {
246 productCode: remoteProduct[0] , 262 userName: params.userName,
247 terminal: 'H2HIPN' + terminalSuffix, 263 signature: params.signature,
248 transactionType: '50', 264 productCode: params.productCode,
249 billNumber: createBillNumber(task.destination), 265 terminal: params.terminal,
250 amount: remoteProduct[1], 266 transactionType: params.transactionType,
251 bit61: createBillNumber(task.destination), 267 billNumber: params.billNumber,
252 reff: task.requestId, 268 amount: params.amount,
253 timeStamp: strftime('%Y-%m-%d %H:%M:%S', new Date()) 269 bit61: params.bit61,
254 } 270 reff: params.reff,
255 271 timeStamp: params.timeStamp
256 var signature = createSignature(params, config.h2h_out.password); 272 }
257 params.signature = signature; 273
258 274 logger.info('Requesting to service', {url: config.h2h_out.partner, params: _params});
259 soap.createClient(config.h2h_out.partner, function(err, soapClient) { 275
260 276 soapClient.apih2h.apih2hPort.billpayment({ inputCheck: _params }, function(err, result) {
261 var _params = { 277 logger.verbose(
262 userName: params.userName, 278 'Got response',
263 signature: params.signature, 279 {
264 productCode: params.productCode, 280 lastEndpoint: soapClient.lastEndpoint,
265 terminal: params.terminal, 281 lastRequest: soapClient.lastRequest,
266 transactionType: params.transactionType, 282 lastMessage: soapClient.lastMessage,
267 billNumber: params.billNumber, 283 lastResponse: soapClient.lastResponse,
284 lastElapsedTime: soapClient.lastElapsedTime,
268 amount: params.amount, 285 }
269 bit61: params.bit61, 286 );
270 reff: params.reff, 287
271 timeStamp: params.timeStamp 288 if (err) {
272 } 289 var errorMessage = 'Error requesting service: ' + err;
273 290
274 logger.info('Requesting to service', {url: config.h2h_out.partner, params: _params}); 291 logger.warn(errorMessage, {err: err});
275 292 callbackReportWrapper(task.requestId, '68', errorMessage);
276 soapClient.apih2h.apih2hPort.billpayment({ inputCheck: _params }, function(err, result) { 293 pushResponseToMongoDb(task, {supplier: config.globals.gateway_name, raw: soapClient.lastResponse}, '68');
277 logger.verbose( 294
278 'Got response', 295 return;
279 { 296 }
280 lastEndpoint: soapClient.lastEndpoint, 297
281 lastRequest: soapClient.lastRequest, 298 topupResponseHandler(task, result, balance, soapClient.lastResponse);
282 lastMessage: soapClient.lastMessage, 299 }, , {timeout: 120000, time: true});
283 lastResponse: soapClient.lastResponse, 300 });
284 } 301 }
285 ); 302
286 303 function topupResponseHandler(task, response, balance, rawResponse) {
287 if (err) { 304 var st24rc = '68';
288 var errorMessage = 'Error requesting service: ' + err; 305 var st24message = response.outputParameter.resultDesc.$value;
289 306
290 logger.warn(errorMessage, {err: err}); 307 var resultCode = parseInt(response.outputParameter.resultCode.$value);
291 callbackReportWrapper(task.requestId, '68', errorMessage); 308 var bit39 = parseInt(response.outputParameter.bit39.$value);
292 pushResponseToMongoDb(task, {supplier: config.globals.gateway_name, raw: soapClient.lastResponse}, '68'); 309
293 310 var sn = '';
294 return; 311
295 } 312 if ( resultCode == 1 ) {
296 313 // product disabled
297 topupResponseHandler(task, result, balance, soapClient.lastResponse); 314 st24rc = '13';
298 }); 315 }
299 }); 316 else if ( resultCode == 2 ) {
300 } 317 // prodcode disable
301 318 st24rc = '13';
302 function topupResponseHandler(task, response, balance, rawResponse) { 319 }
303 var st24rc = '68'; 320 else if ( resultCode == 3 ) {
304 var st24message = response.outputParameter.resultDesc.$value; 321 // duplicate reff
305 322 st24rc = '55';
306 var resultCode = parseInt(response.outputParameter.resultCode.$value); 323 }
307 var bit39 = parseInt(response.outputParameter.bit39.$value); 324 else if ( resultCode == 4 ) {
308 325 // not enough balance
309 var sn = ''; 326 st24rc = '40';
310 327 }
311 if ( resultCode == 1 ) { 328 else if ( resultCode == 5 ) {
312 // product disabled 329 // username blocked
313 st24rc = '13'; 330 st24rc = '40';
314 } 331 }
315 else if ( resultCode == 2 ) { 332 else if ( resultCode == 6 ) {
316 // prodcode disable 333 // not exists username
317 st24rc = '13'; 334 st24rc = '40';
318 } 335 }
319 else if ( resultCode == 3 ) { 336 else if ( resultCode == 11 ) {
320 // duplicate reff 337 // invalid request
321 st24rc = '55'; 338 st24rc = '40'
322 } 339 }
323 else if ( resultCode == 4 ) { 340 else if ( resultCode == 12 ) {
324 // not enough balance 341 // no route to host
325 st24rc = '40'; 342 st24rc = '40'
326 } 343 }
327 else if ( resultCode == 5 ) { 344 else if ( resultCode == 13 ) {
328 // username blocked 345 // invalid signature
329 st24rc = '40'; 346 st24rc = '40'
330 } 347 }
331 else if ( resultCode == 6 ) { 348 else if ( bit39 == 6 ) {
332 // not exists username 349 st24rc = '40';
333 st24rc = '40'; 350 st24message = 'Error Transaksi ditolak karena terjadi error di H2H dengan response code diluar daftar ini. Silahkan hubungi H2H';
334 } 351 }
335 else if ( resultCode == 11 ) { 352 else if ( bit39 == 12 ) {
336 // invalid request 353 st24rc = '40';
337 st24rc = '40' 354 st24message = 'Invalid Transaction Transaksi ditolak karena flow transaksi tidak valid';
338 } 355 }
339 else if ( resultCode == 12 ) { 356 else if ( bit39 == 13 ) {
340 // no route to host 357 st24rc = '13';
341 st24rc = '40' 358 st24message = 'Invalid voucher nominal';
342 } 359 }
343 else if ( resultCode == 13 ) { 360 else if ( bit39 == 14 ) {
344 // invalid signature 361 st24rc = '14';
345 st24rc = '40' 362 st24message = 'MSISDN tidak ditemukan';
346 } 363 }
347 else if ( bit39 == 6 ) { 364 else if ( bit39 == 30 ) {
348 st24rc = '40'; 365 st24rc = '40';
349 st24message = 'Error Transaksi ditolak karena terjadi error di H2H dengan response code diluar daftar ini. Silahkan hubungi H2H'; 366 st24message = 'Format Error';
350 } 367 }
351 else if ( bit39 == 12 ) { 368 else if ( bit39 == 31 ) {
352 st24rc = '40'; 369 st24rc = '40';
353 st24message = 'Invalid Transaction Transaksi ditolak karena flow transaksi tidak valid'; 370 st24message = 'Kode bank tidak terdaftar';
354 } 371 }
355 else if ( bit39 == 13 ) { 372 else if ( bit39 == 63 ) {
356 st24rc = '13'; 373 st24rc = '40';
357 st24message = 'Invalid voucher nominal'; 374 st24message = 'Reversal denied';
358 } 375 }
359 else if ( bit39 == 14 ) { 376 else if ( bit39 == 68 ) {
360 st24rc = '14'; 377 st24rc = '68';
361 st24message = 'MSISDN tidak ditemukan'; 378 st24message = 'Transaksi sedang dalam proses';
362 } 379 }
363 else if ( bit39 == 30 ) { 380 else if ( bit39 == 69 ) {
364 st24rc = '40'; 381 st24rc = '68';
365 st24message = 'Format Error'; 382 st24message = 'Respon Ok lebih dari 24 detik';
366 } 383 }
367 else if ( bit39 == 31 ) { 384 else if ( bit39 == 70 ) {
368 st24rc = '40'; 385 st24rc = '13';
369 st24message = 'Kode bank tidak terdaftar'; 386 st24message = 'Voucher out of stock';
370 } 387 }
371 else if ( bit39 == 63 ) { 388 else if ( bit39 == 79 ) {
372 st24rc = '40'; 389 st24rc = '14';
373 st24message = 'Reversal denied'; 390 st24message = 'Phone number is blocked by Telkomsel';
374 } 391 }
375 else if ( bit39 == 68 ) { 392 else if ( bit39 == 81 ) {
376 st24rc = '68'; 393 st24rc = '14';
377 st24message = 'Transaksi sedang dalam proses'; 394 st24message = 'Phone number is expired';
378 } 395 }
379 else if ( bit39 == 69 ) { 396 else if ( bit39 == 89 ) {
380 st24rc = '68'; 397 st24rc = '40';
381 st24message = 'Respon Ok lebih dari 24 detik'; 398 st24message = 'Link to billing provider is down';
382 } 399 }
383 else if ( bit39 == 70 ) { 400 else if ( bit39 == 91 ) {
384 st24rc = '13'; 401 st24rc = '40';
385 st24message = 'Voucher out of stock'; 402 st24message = 'Database problem';
386 } 403 }
387 else if ( bit39 == 79 ) { 404 else if ( bit39 == 92 ) {
388 st24rc = '14'; 405 st24rc = '40';
389 st24message = 'Phone number is blocked by Telkomsel'; 406 st24message = 'Unable to route transaction';
390 } 407 }
391 else if ( bit39 == 81 ) { 408 else if ( bit39 == 94 ) {
392 st24rc = '14'; 409 st24rc = '40';
393 st24message = 'Phone number is expired'; 410 st24message = 'Duplicate reversal request';
394 } 411 }
395 else if ( bit39 == 89 ) { 412 else if ( resultCode == 0 && bit39 == 0) {
396 st24rc = '40'; 413
397 st24message = 'Link to billing provider is down'; 414 try {
398 } 415 sn = response.outputParameter.bit61.$value.substring(43);
399 else if ( bit39 == 91 ) { 416 }
400 st24rc = '40'; 417 catch(e) {
401 st24message = 'Database problem'; 418 sn = '';
402 } 419 }
403 else if ( bit39 == 92 ) { 420
404 st24rc = '40'; 421 st24message = 'SN=' + sn + '; ' + st24message;
405 st24message = 'Unable to route transaction'; 422 st24rc = '00';
406 } 423 }
407 else if ( bit39 == 94 ) { 424
408 st24rc = '40'; 425 var message =
409 st24message = 'Duplicate reversal request'; 426 response.outputParameter.resultCode.$value
410 } 427 + " " + response.outputParameter.resultDesc.$value
411 else if ( resultCode == 0 && bit39 == 0) { 428 + "; BIT39: " + response.outputParameter.bit39.$value
412 429 ;
413 try { 430
414 sn = response.outputParameter.bit61.$value.substring(43); 431 if (response.outputParameter.resultDesc.$value != st24message) {
415 } 432 var message = message + " " + st24message;
416 catch(e) { 433 }
417 sn = ''; 434
418 } 435 message = message + ' -- Prev Balance: ' + balance;
419 436
420 st24message = 'SN=' + sn + '; ' + st24message; 437 var parsedResponse = {
421 st24rc = '00'; 438 productCode: response.outputParameter.productCode.$value,
422 } 439 terminal: response.outputParameter.terminal.$value,
423 440 transactionType: response.outputParameter.transactionType.$value,
424 var message = 441 billNumber: response.outputParameter.billNumber.$value,
425 response.outputParameter.resultCode.$value 442 amount: response.outputParameter.amount.$value,
426 + " " + response.outputParameter.resultDesc.$value 443 bit61: response.outputParameter.bit61.$value,
427 + "; BIT39: " + response.outputParameter.bit39.$value 444 reff: response.outputParameter.reff.$value,
428 ; 445 timeStamp: response.outputParameter.timeStamp.$value,
429 446 resultCode: response.outputParameter.resultCode.$value,
430 if (response.outputParameter.resultDesc.$value != st24message) { 447 resultDesc: response.outputParameter.resultDesc.$value,
431 var message = message + " " + st24message; 448 bit39: response.outputParameter.bit39.$value,
432 } 449 prevBalance: balance,
433 450 sn: sn,
434 message = message + ' -- Prev Balance: ' + balance; 451 st24message: st24message,
435 452 }
436 var parsedResponse = { 453
437 productCode: response.outputParameter.productCode.$value, 454 var combinedMessage = '';
438 terminal: response.outputParameter.terminal.$value, 455
439 transactionType: response.outputParameter.transactionType.$value, 456 Object.keys(parsedResponse).forEach(function(key,index) {
440 billNumber: response.outputParameter.billNumber.$value, 457 combinedMessage += key + ': ' + parsedResponse[key] + '; '
441 amount: response.outputParameter.amount.$value, 458 });
442 bit61: response.outputParameter.bit61.$value, 459 combinedMessage = combinedMessage.trim();
443 reff: response.outputParameter.reff.$value, 460
444 timeStamp: response.outputParameter.timeStamp.$value, 461 parsedResponse.MESSAGE = combinedMessage;
445 resultCode: response.outputParameter.resultCode.$value, 462
446 resultDesc: response.outputParameter.resultDesc.$value, 463 logger.info('Got result: ' + message, {response: response});
447 bit39: response.outputParameter.bit39.$value, 464 callbackReportWrapper(task.requestId, st24rc, st24message + ' -- Prev Balance: ' + balance);
448 prevBalance: balance, 465 pushResponseToMongoDb(task, {supplier: config.globals.gateway_name, raw: rawResponse, parsed: parsedResponse}, st24rc);
449 sn: sn, 466 }
450 st24message: st24message, 467
451 } 468 function createSignature(params, password) {
452 469 var passwordHash = crypto.createHash('sha256').update(password).digest().toString('hex');
453 var combinedMessage = ''; 470 var plain =
454 471 params.userName
455 Object.keys(parsedResponse).forEach(function(key,index) { 472 + passwordHash
456 combinedMessage += key + ': ' + parsedResponse[key] + '; ' 473 + params.productCode
457 }); 474 + params.terminal
458 combinedMessage = combinedMessage.trim(); 475 + params.transactionType
459 476 + params.billNumber
460 parsedResponse.MESSAGE = combinedMessage; 477 + params.amount
461 478 + params.reff
462 logger.info('Got result: ' + message, {response: response}); 479 + params.timeStamp;
463 callbackReportWrapper(task.requestId, st24rc, st24message + ' -- Prev Balance: ' + balance); 480
464 pushResponseToMongoDb(task, {supplier: config.globals.gateway_name, raw: rawResponse, parsed: parsedResponse}, st24rc); 481 return crypto.createHash('sha1').update(plain).digest().toString('hex');
465 } 482 }
466 483
467 function createSignature(params, password) { 484 function createSignatureForSaldoCheck(params, password) {
468 var passwordHash = crypto.createHash('sha256').update(password).digest().toString('hex'); 485 var passwordHash = crypto.createHash('sha256').update(password).digest().toString('hex');
469 var plain = 486 var plain =
470 params.userName 487 params.userName
471 + passwordHash 488 + passwordHash
472 + params.productCode 489 + params.productCode
473 + params.terminal 490 + params.terminal
474 + params.transactionType 491 + params.transactionType
475 + params.billNumber 492 + params.reff
476 + params.amount 493 + params.timeStamp;
477 + params.reff 494
478 + params.timeStamp; 495 return crypto.createHash('sha1').update(plain).digest().toString('hex');
479 496 }
480 return crypto.createHash('sha1').update(plain).digest().toString('hex'); 497
481 } 498 function createBillNumber(destination) {
482 499 return ("0000000000000" + destination).slice(-13);
483 function createSignatureForSaldoCheck(params, password) { 500 }
484 var passwordHash = crypto.createHash('sha256').update(password).digest().toString('hex'); 501
485 var plain = 502 exports.start = start;
486 params.userName 503 exports.topupRequest = topupRequest;
487 + passwordHash 504 exports.createSignature = createSignature;
488 + params.productCode 505 exports.createBillNumber = createBillNumber;