Reload97 / sate24-to-sate24

Download as
Browse Code ยป

Commit 28c20ce6e9d26fa728876a29f9211813a7987c40

Authored by Adhidarma Hadiwinoto
1 parent d6bc9c5dc7
Exists in master

http.globalAgent.maxSockets = Infinity;

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

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