Reload97 / sate24-to-sate24

Download as
Browse Code ยป

Commit ee8f9a71b9b8ae65fe69a9a58f36e9f871f07098

Authored by Adhidarma Hadiwinoto
1 parent 617f92525e
Exists in master

resendDelay pakai dari module sate24

Showing 2 changed files with 10 additions and 111 deletions Inline Diff

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