Reload97 / sate24-to-sate24

Download as
Browse Code ยป

Commit ffcd4b5664e632c76fd6974bf8d77bd9acae9af5

Authored by Adhidarma Hadiwinoto
1 parent a40af911ec
Exists in master

close after request

Showing 1 changed file with 2 additions and 0 deletions Inline Diff

1 var http = require('http'); 1 var http = require('http');
2 var xmlrpc = require('xmlrpc'); 2 var xmlrpc = require('xmlrpc');
3 var url = require('url'); 3 var url = require('url');
4 var math = require('mathjs'); 4 var math = require('mathjs');
5 var winston = require('winston'); 5 var winston = require('winston');
6 var redis = require('redis'); 6 var redis = require('redis');
7 var resendDelay = require('sate24/resend-delay.js'); 7 var resendDelay = require('sate24/resend-delay.js');
8 var LRU = require('lru-cache'); 8 var LRU = require('lru-cache');
9 9
10 var aaa; 10 var aaa;
11 var logger; 11 var logger;
12 var config; 12 var config;
13 var _callbackReport; 13 var _callbackReport;
14 var redisClient; 14 var redisClient;
15 15
16 var taskHistory = LRU({max: 500, maxAge: 1000 * 3600 * 2}); 16 var taskHistory = LRU({max: 500, maxAge: 1000 * 3600 * 2});
17 17
18 process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0'; 18 process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';
19 http.globalAgent.maxSockets = Infinity; 19 http.globalAgent.maxSockets = Infinity;
20 20
21 function callbackReport(requestId, responseCode, message, dontResendDelay, raw) { 21 function callbackReport(requestId, responseCode, message, dontResendDelay, raw) {
22 var responseToSave = { 22 var responseToSave = {
23 parsed: { 23 parsed: {
24 MESSAGE: message, 24 MESSAGE: message,
25 } 25 }
26 }; 26 };
27 27
28 if (raw) { 28 if (raw) {
29 responseToSave.raw = raw; 29 responseToSave.raw = raw;
30 } else { 30 } else {
31 responseToSave.raw = message; 31 responseToSave.raw = message;
32 } 32 }
33 33
34 if (responseCode != '68' || dontResendDelay) { 34 if (responseCode != '68' || dontResendDelay) {
35 resendDelay.cancel(requestId); 35 resendDelay.cancel(requestId);
36 } else { 36 } else {
37 getTaskFromHistory(requestId, function(err, archivedTask) { 37 getTaskFromHistory(requestId, function(err, archivedTask) {
38 if (archivedTask) { 38 if (archivedTask) {
39 logger.verbose('DEBUG', {archivedTask: archivedTask}); 39 logger.verbose('DEBUG', {archivedTask: archivedTask});
40 resendDelay.register(archivedTask); 40 resendDelay.register(archivedTask);
41 } 41 }
42 }); 42 });
43 } 43 }
44 44
45 _callbackReport(requestId, responseCode, message, null, responseToSave); 45 _callbackReport(requestId, responseCode, message, null, responseToSave);
46 } 46 }
47 47
48 function createRedisClient(host, port) { 48 function createRedisClient(host, port) {
49 if (!host && !port) { 49 if (!host && !port) {
50 logger.info('Not creating redis client because unspecified host or port'); 50 logger.info('Not creating redis client because unspecified host or port');
51 return; 51 return;
52 } 52 }
53 53
54 try { 54 try {
55 redisClient = redis.createClient(port, host); 55 redisClient = redis.createClient(port, host);
56 } catch(err) { 56 } catch(err) {
57 logger.warn("Error creating redis client to " + host + ':' + port); 57 logger.warn("Error creating redis client to " + host + ':' + port);
58 } 58 }
59 } 59 }
60 60
61 function topupRequest(task) { 61 function topupRequest(task) {
62 aaa.insertTaskToMongoDb(task); 62 aaa.insertTaskToMongoDb(task);
63 63
64 getTaskFromHistory(task, function(err, archivedTask) { 64 getTaskFromHistory(task, function(err, archivedTask) {
65 putTaskToHistory(task); 65 putTaskToHistory(task);
66 66
67 if (archivedTask) { 67 if (archivedTask) {
68 logger.info('Task has been executed before, going to checkStatus', {task: task, archivedTask: archivedTask}); 68 logger.info('Task has been executed before, going to checkStatus', {task: task, archivedTask: archivedTask});
69 checkStatus(task); 69 checkStatus(task);
70 } else { 70 } else {
71 _topupRequest(task); 71 _topupRequest(task);
72 } 72 }
73 }); 73 });
74 } 74 }
75 75
76 function _topupRequest(task, pendingOnConnectError) { 76 function _topupRequest(task, pendingOnConnectError) {
77 77
78 if (!aaa.isTodayTrx(task)) { 78 if (!aaa.isTodayTrx(task)) {
79 callbackReport(task.requestId, '68', 'Terdeteksi transaksi beda hari, batal kirim ke supplier. Silahkan cek webreport', true); 79 callbackReport(task.requestId, '68', 'Terdeteksi transaksi beda hari, batal kirim ke supplier. Silahkan cek webreport', true);
80 return; 80 return;
81 } 81 }
82 82
83 var partnerUrl = url.parse(config.h2h_out.partner); 83 var partnerUrl = url.parse(config.h2h_out.partner);
84 var clientOptions = { 84 var clientOptions = {
85 host: partnerUrl.hostname, 85 host: partnerUrl.hostname,
86 port: partnerUrl.port, 86 port: partnerUrl.port,
87 path: partnerUrl.pathname 87 path: partnerUrl.pathname
88 }; 88 };
89 89
90 var client; 90 var client;
91 if (partnerUrl.protocol == 'https:') { 91 if (partnerUrl.protocol == 'https:') {
92 client = xmlrpc.createSecureClient(clientOptions); 92 client = xmlrpc.createSecureClient(clientOptions);
93 } else { 93 } else {
94 client = xmlrpc.createClient(clientOptions); 94 client = xmlrpc.createClient(clientOptions);
95 } 95 }
96 96
97 var params = { 97 var params = {
98 MSISDN: config.h2h_out.userid, 98 MSISDN: config.h2h_out.userid,
99 REQUESTID: task['requestId'], 99 REQUESTID: task['requestId'],
100 PIN: config.h2h_out.password, 100 PIN: config.h2h_out.password,
101 NOHP: task['destination'], 101 NOHP: task['destination'],
102 NOM: task['remoteProduct'] 102 NOM: task['remoteProduct']
103 }; 103 };
104 104
105 var methodName = 'topUpRequest'; 105 var methodName = 'topUpRequest';
106 logger.info('Preparing XMLRPC request', {methodname: methodName, params: params, partnerUrl: partnerUrl.href}); 106 logger.info('Preparing XMLRPC request', {methodname: methodName, params: params, partnerUrl: partnerUrl.href});
107 107
108 client.methodCall(methodName, [ params ], function (error, value) { 108 client.methodCall(methodName, [ params ], function (error, value) {
109 109
110 // Results of the method response 110 // Results of the method response
111 111
112 if (error) { 112 if (error) {
113 var rc = '68'; 113 var rc = '68';
114 var msg = 'XMLRPC Client Error: ' + error; 114 var msg = 'XMLRPC Client Error: ' + error;
115 115
116 if (!pendingOnConnectError && (error.code == 'ECONNREFUSED' || error.code == 'EHOSTUNREACH')) { 116 if (!pendingOnConnectError && (error.code == 'ECONNREFUSED' || error.code == 'EHOSTUNREACH')) {
117 rc = '91'; 117 rc = '91';
118 msg = 'XMLRPC Client Error on connecting'; 118 msg = 'XMLRPC Client Error on connecting';
119 } else if (!pendingOnConnectError && error.code == 'ETIMEDOUT' && error.syscall == "connect") { 119 } else if (!pendingOnConnectError && error.code == 'ETIMEDOUT' && error.syscall == "connect") {
120 rc = '91'; 120 rc = '91';
121 msg = 'XMLRPC Client Error on connecting'; 121 msg = 'XMLRPC Client Error on connecting';
122 } 122 }
123 123
124 logger.warn('XMLRPC Client Error', {methodName: methodName, task: task, err:error}); 124 logger.warn('XMLRPC Client Error', {methodName: methodName, task: task, err:error});
125 125
126 callbackReport(task['requestId'], rc, msg, null, JSON.stringify({methodName: methodName, error: error.toString(), body: error.body})); 126 callbackReport(task['requestId'], rc, msg, null, JSON.stringify({methodName: methodName, error: error.toString(), body: error.body}));
127 return; 127 return;
128 } 128 }
129 129
130 logger.info('Got XMLRPC response from partner for', {methodName: methodName, response_message: value}); 130 logger.info('Got XMLRPC response from partner for', {methodName: methodName, response_message: value});
131 131
132 if (value['RESPONSECODE'] == '94') { 132 if (value['RESPONSECODE'] == '94') {
133 logger.info('Change RC 94 to 68'); 133 logger.info('Change RC 94 to 68');
134 value['RESPONSECODE'] = '68'; 134 value['RESPONSECODE'] = '68';
135 } 135 }
136 136
137 var msg = prefixMessageWithSN(value); 137 var msg = prefixMessageWithSN(value);
138 138
139 callbackReport( 139 callbackReport(
140 task.requestId, value['RESPONSECODE'], msg, null, JSON.stringify({methodName: methodName, response: value}) 140 task.requestId, value['RESPONSECODE'], msg, null, JSON.stringify({methodName: methodName, response: value})
141 ); 141 );
142 }); 142 });
143 } 143 }
144 144
145 function prefixMessageWithSN(data) { 145 function prefixMessageWithSN(data) {
146 146
147 if (data['RESPONSECODE'] != '00') { 147 if (data['RESPONSECODE'] != '00') {
148 return data['MESSAGE']; 148 return data['MESSAGE'];
149 } 149 }
150 150
151 if (data['MESSAGE'].search(/^SN=.+;/) == -1) { 151 if (data['MESSAGE'].search(/^SN=.+;/) == -1) {
152 if (data['SN'] && data['SN'].trim()) { 152 if (data['SN'] && data['SN'].trim()) {
153 return 'SN=' + data['SN'].trim() + '; ' + data['MESSAGE']; 153 return 'SN=' + data['SN'].trim() + '; ' + data['MESSAGE'];
154 } 154 }
155 else if (config.h2h_out.parse_sn == 'YES') { 155 else if (config.h2h_out.parse_sn == 'YES') {
156 return 'SN=' + parseSN(data['MESSAGE']) + '; ' + data['MESSAGE']; 156 return 'SN=' + parseSN(data['MESSAGE']) + '; ' + data['MESSAGE'];
157 } 157 }
158 } 158 }
159 159
160 return data['MESSAGE']; 160 return data['MESSAGE'];
161 } 161 }
162 162
163 function createServer() { 163 function createServer() {
164 164
165 logger.info('Creating XML-RPC server on port ' + config.h2h_out.listen_port); 165 logger.info('Creating XML-RPC server on port ' + config.h2h_out.listen_port);
166 var serverOptions = { 166 var serverOptions = {
167 port: config.h2h_out.listen_port 167 port: config.h2h_out.listen_port
168 }; 168 };
169 169
170 var server = xmlrpc.createServer(serverOptions); 170 var server = xmlrpc.createServer(serverOptions);
171 171
172 server.on('NotFound', function (method, params) { 172 server.on('NotFound', function (method, params) {
173 logger.warn('Unknown method recevied on XMLRPC server', {xmlrpc_method: method, xmlrpc_params: params}); 173 logger.warn('Unknown method recevied on XMLRPC server', {xmlrpc_method: method, xmlrpc_params: params});
174 }); 174 });
175 175
176 server.on('topUpReport', function (err, params, callback) { 176 server.on('topUpReport', function (err, params, callback) {
177 177
178 logger.info('Got XMLRPC topUpReport request from partner', {xmlrpc_method: 'topUpReport', xmlrpc_params: params}); 178 logger.info('Got XMLRPC topUpReport request from partner', {xmlrpc_method: 'topUpReport', xmlrpc_params: params});
179 179
180 var paramscount = params.length; 180 var paramscount = params.length;
181 for (var i = 0; i < paramscount; i++) { 181 for (var i = 0; i < paramscount; i++) {
182 var value = params[i]; 182 var value = params[i];
183 183
184 if (value['RESPONSECODE'] == '94') { 184 if (value['RESPONSECODE'] == '94') {
185 logger.info('Change RC 94 to 68'); 185 logger.info('Change RC 94 to 68');
186 value['RESPONSECODE'] = '68'; 186 value['RESPONSECODE'] = '68';
187 } 187 }
188 188
189 var msg = prefixMessageWithSN(value); 189 var msg = prefixMessageWithSN(value);
190 190
191 callbackReport( 191 callbackReport(
192 value['REQUESTID'], value['RESPONSECODE'], msg, null, JSON.stringify({methodName: 'topUpReport', msg: value}) 192 value['REQUESTID'], value['RESPONSECODE'], msg, null, JSON.stringify({methodName: 'topUpReport', msg: value})
193 ); 193 );
194 } 194 }
195 195
196 callback(null, 'ACK REPORT OK'); 196 callback(null, 'ACK REPORT OK');
197 }) 197 })
198 198
199 } 199 }
200 200
201 function createPlainHttpServer() { 201 function createPlainHttpServer() {
202 logger.info('Creating IRS HTTP server on port ' + config.h2h_out.listen_port); 202 logger.info('Creating IRS HTTP server on port ' + config.h2h_out.listen_port);
203 203
204 var httpServer = http.createServer(function(request, response) { 204 var httpServer = http.createServer(function(request, response) {
205 205
206 var qs = url.parse(request.url, true).query; 206 var qs = url.parse(request.url, true).query;
207 logger.info('Got reverse report from gateway', {qs: qs}); 207 logger.info('Got reverse report from gateway', {qs: qs});
208 208
209 var request_id = qs.clientid; 209 var request_id = qs.clientid;
210 210
211 var rc = '68'; 211 var rc = '68';
212 if (qs.statuscode == '2') { 212 if (qs.statuscode == '2') {
213 rc = '40'; 213 rc = '40';
214 } 214 }
215 else if (qs.statuscode == '3') { 215 else if (qs.statuscode == '3') {
216 rc = '40'; 216 rc = '40';
217 } 217 }
218 else if (qs.statuscode == '4') { 218 else if (qs.statuscode == '4') {
219 rc = '00'; 219 rc = '00';
220 } 220 }
221 221
222 var msg = qs.msg; 222 var msg = qs.msg;
223 223
224 if (rc == '00' && qs.sn) { 224 if (rc == '00' && qs.sn) {
225 msg = 'SN=' + qs.sn.trim() + '; ' + msg; 225 msg = 'SN=' + qs.sn.trim() + '; ' + msg;
226 } 226 }
227 227
228 response.end('OK');
229
228 callbackReport(request_id, rc, msg); 230 callbackReport(request_id, rc, msg);
229 231
230 }); 232 });
231 233
232 httpServer.listen(config.h2h_out.listen_port, function() { 234 httpServer.listen(config.h2h_out.listen_port, function() {
233 logger.info('HTTP Reverse/Report server listen on port ' + config.h2h_out.listen_port); 235 logger.info('HTTP Reverse/Report server listen on port ' + config.h2h_out.listen_port);
234 }); 236 });
235 } 237 }
236 238
237 function getBalanceFromMessage(message, balance_regex) { 239 function getBalanceFromMessage(message, balance_regex) {
238 if (!balance_regex) { 240 if (!balance_regex) {
239 if (config && config.globals && config.globals.balance_regex) { 241 if (config && config.globals && config.globals.balance_regex) {
240 balance_regex = config.globals.balance_regex; 242 balance_regex = config.globals.balance_regex;
241 } 243 }
242 } 244 }
243 245
244 if (!balance_regex) { 246 if (!balance_regex) {
245 return; 247 return;
246 } 248 }
247 249
248 try { 250 try {
249 var re = new RegExp(balance_regex); 251 var re = new RegExp(balance_regex);
250 var matches = message.match(re); 252 var matches = message.match(re);
251 253
252 var result = matches[1]; 254 var result = matches[1];
253 result = result.replace(/\./g, ''); 255 result = result.replace(/\./g, '');
254 result = result.replace(/,/g, ''); 256 result = result.replace(/,/g, '');
255 257
256 258
257 return Number(result); 259 return Number(result);
258 } 260 }
259 catch(err) { 261 catch(err) {
260 return; 262 return;
261 } 263 }
262 } 264 }
263 265
264 function updateBalance(message) { 266 function updateBalance(message) {
265 var balance = getBalanceFromMessage(message); 267 var balance = getBalanceFromMessage(message);
266 if (balance) { 268 if (balance) {
267 logger.info('Balance: ' + balance); 269 logger.info('Balance: ' + balance);
268 aaa.updateBalance(balance); 270 aaa.updateBalance(balance);
269 } 271 }
270 } 272 }
271 273
272 function checkStatus(task) { 274 function checkStatus(task) {
273 275
274 if (Number(config.globals.topup_request_on_check_status)) { 276 if (Number(config.globals.topup_request_on_check_status)) {
275 _topupRequest(task, true); 277 _topupRequest(task, true);
276 return; 278 return;
277 } 279 }
278 280
279 var partnerUrl = url.parse(config.h2h_out.partner); 281 var partnerUrl = url.parse(config.h2h_out.partner);
280 var clientOptions = { 282 var clientOptions = {
281 host: partnerUrl.hostname 283 host: partnerUrl.hostname
282 , port: partnerUrl.port 284 , port: partnerUrl.port
283 , path: partnerUrl.pathname 285 , path: partnerUrl.pathname
284 }; 286 };
285 logger.info('XMLRPC client options:'); 287 logger.info('XMLRPC client options:');
286 logger.info(clientOptions); 288 logger.info(clientOptions);
287 289
288 var client; 290 var client;
289 if (partnerUrl.protocol == 'https:') { 291 if (partnerUrl.protocol == 'https:') {
290 client = xmlrpc.createSecureClient(clientOptions); 292 client = xmlrpc.createSecureClient(clientOptions);
291 } else { 293 } else {
292 client = xmlrpc.createClient(clientOptions); 294 client = xmlrpc.createClient(clientOptions);
293 } 295 }
294 296
295 var methodName = 'topUpInquiry'; 297 var methodName = 'topUpInquiry';
296 298
297 var params = { 299 var params = {
298 REQUESTID: task['requestId'], 300 REQUESTID: task['requestId'],
299 MSISDN: config.h2h_out.userid, 301 MSISDN: config.h2h_out.userid,
300 PIN: config.h2h_out.password, 302 PIN: config.h2h_out.password,
301 NOHP: task['destination'] 303 NOHP: task['destination']
302 }; 304 };
303 305
304 logger.info('Requesting topUpInquiry', {params: params}); 306 logger.info('Requesting topUpInquiry', {params: params});
305 307
306 client.methodCall(methodName, [ params ], function (error, value) { 308 client.methodCall(methodName, [ params ], function (error, value) {
307 // Results of the method response 309 // Results of the method response
308 if (error) { 310 if (error) {
309 logger.warn('Error requesting topUpInquiry: ', {err: error, params: params}); 311 logger.warn('Error requesting topUpInquiry: ', {err: error, params: params});
310 callbackReport( 312 callbackReport(
311 task.requestId, '68', 'Error requesting topUpInquiry: ' + error, null, JSON.stringify({methodName: methodName, error: error}) 313 task.requestId, '68', 'Error requesting topUpInquiry: ' + error, null, JSON.stringify({methodName: methodName, error: error})
312 ); 314 );
313 return; 315 return;
314 } 316 }
315 logger.info('Method response for \'' + methodName, {response: value}); 317 logger.info('Method response for \'' + methodName, {response: value});
316 318
317 callbackReport(task.requestId, value['RESPONSECODE'], value['MESSAGE'], null, JSON.stringify({methodName: methodName, response: value})); 319 callbackReport(task.requestId, value['RESPONSECODE'], value['MESSAGE'], null, JSON.stringify({methodName: methodName, response: value}));
318 }); 320 });
319 } 321 }
320 322
321 function start(options) { 323 function start(options) {
322 if (!options) { 324 if (!options) {
323 console.log('Undefined options, terminating....'); 325 console.log('Undefined options, terminating....');
324 process.exit(1); 326 process.exit(1);
325 } 327 }
326 328
327 if (options.config) { 329 if (options.config) {
328 config = options.config; 330 config = options.config;
329 } else { 331 } else {
330 console.log('Undefined options.config, terminating....') 332 console.log('Undefined options.config, terminating....')
331 process.exit(1); 333 process.exit(1);
332 } 334 }
333 335
334 if (options.aaa) { 336 if (options.aaa) {
335 aaa = options.aaa; 337 aaa = options.aaa;
336 _callbackReport = options.aaa.callbackReportWithPushToMongoDb; 338 _callbackReport = options.aaa.callbackReportWithPushToMongoDb;
337 } else { 339 } else {
338 console.log('Undefined options.aaa, terminating....') 340 console.log('Undefined options.aaa, terminating....')
339 process.exit(1); 341 process.exit(1);
340 } 342 }
341 343
342 if (options && options.logger) { 344 if (options && options.logger) {
343 logger = options.logger; 345 logger = options.logger;
344 } else { 346 } else {
345 logger = new winston.Logger({ 347 logger = new winston.Logger({
346 transports: [ 348 transports: [
347 new (winston.transports.Console)() 349 new (winston.transports.Console)()
348 ] 350 ]
349 }); 351 });
350 } 352 }
351 353
352 createRedisClient(config.globals.redis_host, config.globals.redis_port); 354 createRedisClient(config.globals.redis_host, config.globals.redis_port);
353 355
354 if (!Number(config.h2h_out.irs_mode)) { 356 if (!Number(config.h2h_out.irs_mode)) {
355 createServer(); 357 createServer();
356 } 358 }
357 else { 359 else {
358 createPlainHttpServer(); 360 createPlainHttpServer();
359 } 361 }
360 362
361 363
362 var resendDelayOptions = { 364 var resendDelayOptions = {
363 config: config, 365 config: config,
364 topupRequest: checkStatus, 366 topupRequest: checkStatus,
365 logger: logger 367 logger: logger
366 }; 368 };
367 369
368 if (Number(config.globals.topup_request_on_resend_delay)) { 370 if (Number(config.globals.topup_request_on_resend_delay)) {
369 resendDelayOptions.topupRequest = topupRequest; 371 resendDelayOptions.topupRequest = topupRequest;
370 } 372 }
371 373
372 resendDelay.init(resendDelayOptions); 374 resendDelay.init(resendDelayOptions);
373 } 375 }
374 376
375 function parseSN(message, _config) { 377 function parseSN(message, _config) {
376 378
377 if (!_config) { 379 if (!_config) {
378 _config = config; 380 _config = config;
379 } 381 }
380 382
381 var sn_regex = new RegExp(_config.h2h_out.sn_pattern); 383 var sn_regex = new RegExp(_config.h2h_out.sn_pattern);
382 var sn_match = message.match(sn_regex); 384 var sn_match = message.match(sn_regex);
383 385
384 if (sn_match <= 0) { 386 if (sn_match <= 0) {
385 logger.info('SN Not found: ' + message); 387 logger.info('SN Not found: ' + message);
386 return ''; 388 return '';
387 } 389 }
388 390
389 var match_index = 0; 391 var match_index = 0;
390 if (_config.h2h_out.sn_match_index) { 392 if (_config.h2h_out.sn_match_index) {
391 match_index = Number(_config.h2h_out.sn_match_index); 393 match_index = Number(_config.h2h_out.sn_match_index);
392 } 394 }
393 395
394 var sn = sn_match[match_index]; 396 var sn = sn_match[match_index];
395 397
396 if (_config.h2h_out.sn_remove_whitespace) { 398 if (_config.h2h_out.sn_remove_whitespace) {
397 sn = sn.replace(/\s/g, ''); 399 sn = sn.replace(/\s/g, '');
398 } 400 }
399 401
400 var sn_remove_patterns = []; 402 var sn_remove_patterns = [];
401 if (_config.h2h_out.sn_remove_patterns && _config.h2h_out.sn_remove_patterns_separator) { 403 if (_config.h2h_out.sn_remove_patterns && _config.h2h_out.sn_remove_patterns_separator) {
402 sn_remove_patterns = _config.h2h_out.sn_remove_patterns.split(_config.h2h_out.sn_remove_patterns_separator); 404 sn_remove_patterns = _config.h2h_out.sn_remove_patterns.split(_config.h2h_out.sn_remove_patterns_separator);
403 } 405 }
404 var count = sn_remove_patterns.length; 406 var count = sn_remove_patterns.length;
405 407
406 for(var i = 0; i < count; i++) { 408 for(var i = 0; i < count; i++) {
407 409
408 //sn = sn.replace(sn_remove_patterns[i], ''); 410 //sn = sn.replace(sn_remove_patterns[i], '');
409 411
410 var re = new RegExp(sn_remove_patterns[i], 'g'); 412 var re = new RegExp(sn_remove_patterns[i], 'g');
411 sn = sn.replace(re, ''); 413 sn = sn.replace(re, '');
412 } 414 }
413 415
414 //sn = paddingSN(sn, _config); 416 //sn = paddingSN(sn, _config);
415 417
416 return sn.trim(); 418 return sn.trim();
417 } 419 }
418 420
419 function getTaskKey(task, chipInfo) { 421 function getTaskKey(task, chipInfo) {
420 var requestId; 422 var requestId;
421 423
422 if (typeof task === 'string') { 424 if (typeof task === 'string') {
423 requestId = task; 425 requestId = task;
424 } else { 426 } else {
425 try { 427 try {
426 requestId = task.requestId; 428 requestId = task.requestId;
427 } 429 }
428 catch(e) { 430 catch(e) {
429 logger.warn('Something wrong', {task: task}); 431 logger.warn('Something wrong', {task: task});
430 console.trace('Cekidot'); 432 console.trace('Cekidot');
431 process.exit(1); 433 process.exit(1);
432 } 434 }
433 435
434 } 436 }
435 437
436 if (!chipInfo && config && config.globals && config.globals.gateway_name) { 438 if (!chipInfo && config && config.globals && config.globals.gateway_name) {
437 chipInfo = config.globals.gateway_name; 439 chipInfo = config.globals.gateway_name;
438 } 440 }
439 441
440 return chipInfo + '.hitachi.rid:' + requestId; 442 return chipInfo + '.hitachi.rid:' + requestId;
441 } 443 }
442 444
443 445
444 function putTaskToHistory(task, cb) { 446 function putTaskToHistory(task, cb) {
445 if (Number(config.globals.no_dupe_check)) { 447 if (Number(config.globals.no_dupe_check)) {
446 if (cb) { cb(); } 448 if (cb) { cb(); }
447 return; 449 return;
448 } 450 }
449 var key = getTaskKey(task, config.globals.gateway_name); 451 var key = getTaskKey(task, config.globals.gateway_name);
450 logger.verbose('Saving task to history LRU', {key: key, task: task}); 452 logger.verbose('Saving task to history LRU', {key: key, task: task});
451 453
452 try { 454 try {
453 taskHistory.set(key, JSON.parse(JSON.stringify(task))); 455 taskHistory.set(key, JSON.parse(JSON.stringify(task)));
454 } catch (e) { } 456 } catch (e) { }
455 457
456 putTaskToRedis(task, cb); 458 putTaskToRedis(task, cb);
457 } 459 }
458 460
459 function putTaskToRedis(task, cb) { 461 function putTaskToRedis(task, cb) {
460 if (!redisClient) { 462 if (!redisClient) {
461 logger.verbose('Not saving to redis because of undefined redisClient') 463 logger.verbose('Not saving to redis because of undefined redisClient')
462 if (cb) { cb(); } 464 if (cb) { cb(); }
463 return; 465 return;
464 } 466 }
465 467
466 var key = getTaskKey(task, config.globals.gateway_name); 468 var key = getTaskKey(task, config.globals.gateway_name);
467 logger.verbose('Saving task to redis', {key: key, task: task}); 469 logger.verbose('Saving task to redis', {key: key, task: task});
468 470
469 redisClient.set(key, JSON.stringify(task), function() { 471 redisClient.set(key, JSON.stringify(task), function() {
470 redisClient.expire(key, 3600*24*30); 472 redisClient.expire(key, 3600*24*30);
471 if (cb) { 473 if (cb) {
472 cb(); 474 cb();
473 } 475 }
474 }); 476 });
475 } 477 }
476 478
477 function getTaskFromHistory(task, cb) { 479 function getTaskFromHistory(task, cb) {
478 logger.verbose('Getting task from history', {task: task}); 480 logger.verbose('Getting task from history', {task: task});
479 var key = getTaskKey(task, config.globals.gateway_name); 481 var key = getTaskKey(task, config.globals.gateway_name);
480 var archive = taskHistory.get(key); 482 var archive = taskHistory.get(key);
481 483
482 if (archive) { 484 if (archive) {
483 if (cb) { cb(null, archive); } 485 if (cb) { cb(null, archive); }
484 } 486 }
485 else { 487 else {
486 getTaskFromRedis(task, cb); 488 getTaskFromRedis(task, cb);
487 } 489 }
488 } 490 }
489 491
490 function getTaskFromRedis(task, cb) { 492 function getTaskFromRedis(task, cb) {
491 if (!redisClient) { 493 if (!redisClient) {
492 if (cb) { cb(null, null); } 494 if (cb) { cb(null, null); }
493 return; 495 return;
494 } 496 }
495 497
496 var key = getTaskKey(task, config.globals.gateway_name); 498 var key = getTaskKey(task, config.globals.gateway_name);
497 redisClient.get(key, function(err, result) { 499 redisClient.get(key, function(err, result) {
498 if (err) { 500 if (err) {
499 logger.warn('Error retrieving task from redis', {err: err}); 501 logger.warn('Error retrieving task from redis', {err: err});
500 cb(err, null); 502 cb(err, null);
501 return; 503 return;
502 } 504 }
503 505
504 var task; 506 var task;
505 try { 507 try {
506 task = JSON.parse(result); 508 task = JSON.parse(result);
507 } 509 }
508 catch(e) { 510 catch(e) {
509 logger.warn('Exception on parsing redis result as a json', {err: e}); 511 logger.warn('Exception on parsing redis result as a json', {err: e});
510 } 512 }
511 513
512 cb(null, task); 514 cb(null, task);
513 }) 515 })
514 } 516 }
515 517
516 exports.start = start; 518 exports.start = start;
517 exports.topupRequest = topupRequest; 519 exports.topupRequest = topupRequest;
518 exports.getBalanceFromMessage = getBalanceFromMessage; 520 exports.getBalanceFromMessage = getBalanceFromMessage;
519 exports.checkStatus = checkStatus; 521 exports.checkStatus = checkStatus;
520 522