Reload97 / sate24-to-sate24

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

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

16

var taskHistory = LRU({max: 500, maxAge: 1000 * 3600 * 2});

16

var taskHistory = LRU({max: 500, maxAge: 1000 * 3600 * 2});

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

21

var irsRc = {

21

var irsRc = {

22

'0': '00',

22

'0': '00',

23

'00': '00',

23

'00': '00',

24

'1': '00',

24

'1': '00',

25

'2': '14',

25

'2': '14',

26

'17': '40',

26

'17': '40',

27

'63': '40',

27

'63': '40',

28

'89': '40',

28

'89': '40',

29

'68': '68',

29

'68': '68',

30

'94': '68',

30

'94': '68',

31

'05': '40',

31

'05': '40',

32

'30': '40',

32

'30': '40',

33

'51': '40',

33

'51': '40',

34

'13': '40',

34

'13': '40',

35

'14': '14',

35

'14': '14',

36

'91': '40',

36

'91': '40',

37

'40': '40',

37

'40': '40',

38

'49': '40',

38

'49': '40',

39

'53': '40',

39

'53': '40',

40

'54': '40',

40

'54': '40',

41

'914': '55',

41

'914': '55',

42

'55': '55',

42

'55': '55',

43

'06': '40',

43

'06': '40',

44

'92': '40'

44

'92': '40'

45

}

45

}

46

47

function callbackReport(requestId, responseCode, message, dontResendDelay, raw) {

47

function callbackReport(requestId, responseCode, message, dontResendDelay, raw) {

48

var responseToSave = {

48

var responseToSave = {

49

parsed: {

49

parsed: {

50

MESSAGE: message,

50

MESSAGE: message,

51

}

51

}

52

};

52

};

53

54

if (raw) {

54

if (raw) {

55

responseToSave.raw = raw;

55

responseToSave.raw = raw;

56

} else {

56

} else {

57

responseToSave.raw = message;

57

responseToSave.raw = message;

58

}

58

}

59

60

if (responseCode != '68' || dontResendDelay) {

60

if (responseCode != '68' || dontResendDelay) {

61

resendDelay.cancel(requestId);

61

resendDelay.cancel(requestId);

62

} else {

62

} else {

63

getTaskFromHistory(requestId, function(err, archivedTask) {

63

getTaskFromHistory(requestId, function(err, archivedTask) {

64

if (archivedTask) {

64

if (archivedTask) {

65

logger.verbose('DEBUG', {archivedTask: archivedTask});

65

logger.verbose('DEBUG', {archivedTask: archivedTask});

66

resendDelay.register(archivedTask);

66

resendDelay.register(archivedTask);

67

}

67

}

68

});

68

});

69

}

69

}

70

71

_callbackReport(requestId, responseCode, message, null, responseToSave);

71

_callbackReport(requestId, responseCode, message, null, responseToSave);

72

}

72

}

73

74

function createRedisClient(host, port) {

74

function createRedisClient(host, port) {

75

if (!host && !port) {

75

if (!host && !port) {

76

logger.info('Not creating redis client because unspecified host or port');

76

logger.info('Not creating redis client because unspecified host or port');

77

return;

77

return;

78

}

78

}

79

80

try {

80

try {

81

redisClient = redis.createClient(port, host);

81

redisClient = redis.createClient(port, host);

82

} catch(err) {

82

} catch(err) {

83

logger.warn("Error creating redis client to " + host + ':' + port);

83

logger.warn("Error creating redis client to " + host + ':' + port);

84

}

84

}

85

}

85

}

86

87

function topupRequest(task) {

87

function topupRequest(task) {

88

aaa.insertTaskToMongoDb(task);

88

aaa.insertTaskToMongoDb(task);

89

90

getTaskFromHistory(task, function(err, archivedTask) {

90

getTaskFromHistory(task, function(err, archivedTask) {

91

putTaskToHistory(task);

91

putTaskToHistory(task);

92

93

if (archivedTask) {

93

if (archivedTask) {

94

logger.info('Task has been executed before, going to checkStatus', {task: task, archivedTask: archivedTask});

94

logger.info('Task has been executed before, going to checkStatus', {task: task, archivedTask: archivedTask});

95

checkStatus(task);

95

checkStatus(task);

96

} else {

96

} else {

97

_topupRequest(task);

97

_topupRequest(task);

98

}

98

}

99

});

99

});

100

}

100

}

101

102

function _topupRequest(task, pendingOnConnectError) {

102

function _topupRequest(task, pendingOnConnectError) {

103

104

if (!aaa.isTodayTrx(task)) {

104

if (!aaa.isTodayTrx(task)) {

105

callbackReport(task.requestId, '68', 'Terdeteksi transaksi beda hari, batal kirim ke supplier. Silahkan cek webreport', true);

105

callbackReport(task.requestId, '68', 'Terdeteksi transaksi beda hari, batal kirim ke supplier. Silahkan cek webreport', true);

106

return;

106

return;

107

}

107

}

108

109

var partnerUrl = url.parse(config.h2h_out.partner);

109

var partnerUrl = url.parse(config.h2h_out.partner);

110

var clientOptions = {

110

var clientOptions = {

111

host: partnerUrl.hostname,

111

host: partnerUrl.hostname,

112

port: partnerUrl.port,

112

port: partnerUrl.port,

113

path: partnerUrl.pathname

113

path: partnerUrl.pathname

114

};

114

};

115

116

var client;

116

var client;

117

if (partnerUrl.protocol == 'https:') {

117

if (partnerUrl.protocol == 'https:') {

118

client = xmlrpc.createSecureClient(clientOptions);

118

client = xmlrpc.createSecureClient(clientOptions);

119

} else {

119

} else {

120

client = xmlrpc.createClient(clientOptions);

120

client = xmlrpc.createClient(clientOptions);

121

}

121

}

122

123

var params = {

123

var params = {

124

MSISDN: config.h2h_out.userid,

124

MSISDN: config.h2h_out.userid,

125

REQUESTID: task['requestId'],

125

REQUESTID: task['requestId'],

126

PIN: config.h2h_out.password,

126

PIN: config.h2h_out.password,

127

NOHP: task['destination'],

127

NOHP: task['destination'],

128

NOM: task['remoteProduct']

128

NOM: task['remoteProduct']

129

};

129

};

130

131

var methodName = 'topUpRequest';

131

var methodName = 'topUpRequest';

132

logger.info('Preparing XMLRPC request', {methodname: methodName, params: params, partnerUrl: partnerUrl.href});

132

logger.info('Preparing XMLRPC request', {methodname: methodName, params: params, partnerUrl: partnerUrl.href});

133

134

client.methodCall(methodName, [ params ], function (error, value) {

134

client.methodCall(methodName, [ params ], function (error, value) {

135

136

// Results of the method response

136

// Results of the method response

137

138

if (error) {

138

if (error) {

139

var rc = '68';

139

var rc = '68';

140

var msg = 'XMLRPC Client Error: ' + error;

140

var msg = 'XMLRPC Client Error: ' + error;

141

142

if (!pendingOnConnectError && (error.code == 'ECONNREFUSED' || error.code == 'EHOSTUNREACH')) {

142

if (!pendingOnConnectError && (error.code == 'ECONNREFUSED' || error.code == 'EHOSTUNREACH')) {

143

rc = '91';

143

rc = '91';

144

msg = 'XMLRPC Client Error on connecting';

144

msg = 'XMLRPC Client Error on connecting';

145

} else if (!pendingOnConnectError && error.code == 'ETIMEDOUT' && error.syscall == "connect") {

145

} else if (!pendingOnConnectError && error.code == 'ETIMEDOUT' && error.syscall == "connect") {

146

rc = '91';

146

rc = '91';

147

msg = 'XMLRPC Client Error on connecting';

147

msg = 'XMLRPC Client Error on connecting';

148

}

148

}

149

150

logger.warn('XMLRPC Client Error', {methodName: methodName, task: task, err:error});

150

logger.warn('XMLRPC Client Error', {methodName: methodName, task: task, err:error});

151

152

callbackReport(task['requestId'], rc, msg, null, JSON.stringify({methodName: methodName, error: error.toString(), body: error.body}));

152

callbackReport(task['requestId'], rc, msg, null, JSON.stringify({methodName: methodName, error: error.toString(), body: error.body}));

153

return;

153

return;

154

}

154

}

155

156

logger.info('Got XMLRPC response from partner for', {methodName: methodName, response_message: value});

156

logger.info('Got XMLRPC response from partner for', {methodName: methodName, response_message: value});

157

158

if (value['RESPONSECODE'] == '94') {

158

if (value['RESPONSECODE'] == '94') {

159

logger.info('Change RC 94 to 68');

159

logger.info('Change RC 94 to 68');

160

value['RESPONSECODE'] = '68';

160

value['RESPONSECODE'] = '68';

161

}

161

}

162

163

var msg = prefixMessageWithSN(value);

163

var msg = prefixMessageWithSN(value);

164

165

callbackReport(

165

callbackReport(

166

task.requestId, value['RESPONSECODE'], msg, null, JSON.stringify({methodName: methodName, response: value})

166

task.requestId, value['RESPONSECODE'], msg, null, JSON.stringify({methodName: methodName, response: value})

167

);

167

);

168

});

168

});

169

}

169

}

170

171

function snSanitizer(sn) {

172

if (!sn && typeof sn === 'string') {

173

return;

174

}

175

176

sn = sn.replace(/[^A-Z0-9\/]/g, '-');

177

sn = sn.replace(/-+/g, '-');

178

sn = sn.replace(/^-+/, '');

179

sn = sn.replace(/-+$/, '');

180

sn = sn.trim();

181

182

return sn;

183

}

184

185

function msgSanitizer(msg) {

186

return msg.replace(/;\s*SN=.+?;/, '; ').trim();

187

}

188

171

function prefixMessageWithSN(data) {

189

function prefixMessageWithSN(data) {

172

190

173

if (data['RESPONSECODE'] != '00') {

191

if (data['RESPONSECODE'] != '00') {

174

return data['MESSAGE'];

192

return data['MESSAGE'];

175

}

193

}

176

194

177

sn = '';

195

sn = '';

178

196

179

if (data.SN && data.SN.trim()) {

197

if (data.SN && data.SN.trim()) {

180

sn = data['SN'].trim();

198

sn = data['SN'].trim();

181

}

199

}

182

else if (data['MESSAGE'].search(/^SN=.+;/) == -1) {

200

else if (data['MESSAGE'].search(/^SN=.+;/) == -1) {

183

if (data['SN'] && data['SN'].trim()) {

201

if (data['SN'] && data['SN'].trim()) {

184

sn = data['SN'].trim();

202

sn = data['SN'].trim();

185

}

203

}

186

else if (config.h2h_out.parse_sn == 'YES') {

204

else if (config.h2h_out.parse_sn == 'YES') {

187

sn = parseSN(data['MESSAGE']);

205

sn = parseSN(data['MESSAGE']);

188

}

206

}

189

}

207

}

190

208

209

sn = snSanitizer(sn);

210

191

if (sn) {

211

if (sn) {

192

//sn = sn.replace(/ /g, '-');

212

msg = 'SN=' + sn + '; ' + data['MESSAGE'];

193

//sn = sn.replace(/[\()]/g, '-');

213

return msgSanitizer(msg);

194

sn = sn.replace(/[^A-Z0-9\/]/g, '-');

195

sn = sn.replace(/-+/g, '-');

196

sn = sn.replace(/^-+/, '');

197

sn = sn.replace(/-+$/, '');

198

sn = sn.replace(/;\s*SN=.+?;/, '; ');

199

sn = sn.trim();

200

return 'SN=' + sn + '; ' + data['MESSAGE'];

201

}

214

}

202

215

203

return data['MESSAGE'];

216

return data['MESSAGE'];

204

}

217

}

205

218

206

function createServer() {

219

function createServer() {

207

220

208

logger.info('Creating XML-RPC server on port ' + config.h2h_out.listen_port);

221

logger.info('Creating XML-RPC server on port ' + config.h2h_out.listen_port);

209

var serverOptions = {

222

var serverOptions = {

210

port: config.h2h_out.listen_port

223

port: config.h2h_out.listen_port

211

};

224

};

212

225

213

var server = xmlrpc.createServer(serverOptions);

226

var server = xmlrpc.createServer(serverOptions);

214

227

215

server.on('NotFound', function (method, params) {

228

server.on('NotFound', function (method, params) {

216

logger.warn('Unknown method recevied on XMLRPC server', {xmlrpc_method: method, xmlrpc_params: params});

229

logger.warn('Unknown method recevied on XMLRPC server', {xmlrpc_method: method, xmlrpc_params: params});

217

});

230

});

218

231

219

server.on('topUpReport', function (err, params, callback) {

232

server.on('topUpReport', function (err, params, callback) {

220

233

221

logger.info('Got XMLRPC topUpReport request from partner', {xmlrpc_method: 'topUpReport', xmlrpc_params: params});

234

logger.info('Got XMLRPC topUpReport request from partner', {xmlrpc_method: 'topUpReport', xmlrpc_params: params});

222

235

223

var paramscount = params.length;

236

var paramscount = params.length;

224

for (var i = 0; i < paramscount; i++) {

237

for (var i = 0; i < paramscount; i++) {

225

var value = params[i];

238

var value = params[i];

226

239

227

if (value['RESPONSECODE'] == '94') {

240

if (value['RESPONSECODE'] == '94') {

228

logger.info('Change RC 94 to 68');

241

logger.info('Change RC 94 to 68');

229

value['RESPONSECODE'] = '68';

242

value['RESPONSECODE'] = '68';

230

}

243

}

231

244

232

var msg = prefixMessageWithSN(value);

245

var msg = prefixMessageWithSN(value);

233

246

234

callbackReport(

247

callbackReport(

235

value['REQUESTID'], value['RESPONSECODE'], msg, null, JSON.stringify({methodName: 'topUpReport', msg: value})

248

value['REQUESTID'], value['RESPONSECODE'], msg, null, JSON.stringify({methodName: 'topUpReport', msg: value})

236

);

249

);

237

}

250

}

238

251

239

callback(null, 'ACK REPORT OK');

252

callback(null, 'ACK REPORT OK');

240

})

253

})

241

254

242

}

255

}

243

256

244

function createPlainHttpServer() {

257

function createPlainHttpServer() {

245

logger.info('Creating IRS HTTP server on port ' + config.h2h_out.listen_port);

258

logger.info('Creating IRS HTTP server on port ' + config.h2h_out.listen_port);

246

259

247

var httpServer = http.createServer(function(request, response) {

260

var httpServer = http.createServer(function(request, response) {

248

261

249

var qs = url.parse(request.url, true).query;

262

var qs = url.parse(request.url, true).query;

250

logger.info('Got reverse report from gateway', {qs: qs});

263

logger.info('Got reverse report from gateway', {qs: qs});

251

264

252

var request_id = qs.clientid;

265

var request_id = qs.clientid;

253

266

254

var rc = irsRc[qs.statuscode] || '68';

267

var rc = irsRc[qs.statuscode] || '68';

255

268

256

var msg = qs.msg + '. STATUSCODE:' + qs.statuscode;

269

var msg = qs.msg + '. STATUSCODE:' + qs.statuscode;

257

270

258

if (rc == '00' && qs.sn) {

271

if (rc == '00' && qs.sn) {

259

msg = 'SN=' + qs.sn.replace(/ /g, '-').trim() + '; ' + msg;

272

msg = 'SN=' + qs.sn.replace(/ /g, '-').trim() + '; ' + msg;

260

}

273

}

261

274

262

response.end('OK');

275

response.end('OK');

263

276

264

callbackReport(request_id, rc, msg);

277

callbackReport(request_id, rc, msg);

265

278

266

});

279

});

267

280

268

httpServer.listen(config.h2h_out.listen_port, function() {

281

httpServer.listen(config.h2h_out.listen_port, function() {

269

logger.info('HTTP Reverse/Report server listen on port ' + config.h2h_out.listen_port);

282

logger.info('HTTP Reverse/Report server listen on port ' + config.h2h_out.listen_port);

270

});

283

});

271

}

284

}

272

285

273

function getBalanceFromMessage(message, balance_regex) {

286

function getBalanceFromMessage(message, balance_regex) {

274

if (!balance_regex) {

287

if (!balance_regex) {

275

if (config && config.globals && config.globals.balance_regex) {

288

if (config && config.globals && config.globals.balance_regex) {

276

balance_regex = config.globals.balance_regex;

289

balance_regex = config.globals.balance_regex;

277

}

290

}

278

}

291

}

279

292

280

if (!balance_regex) {

293

if (!balance_regex) {

281

return;

294

return;

282

}

295

}

283

296

284

try {

297

try {

285

var re = new RegExp(balance_regex);

298

var re = new RegExp(balance_regex);

286

var matches = message.match(re);

299

var matches = message.match(re);

287

300

288

var result = matches[1];

301

var result = matches[1];

289

result = result.replace(/\./g, '');

302

result = result.replace(/\./g, '');

290

result = result.replace(/,/g, '');

303

result = result.replace(/,/g, '');

291

304

292

305

293

return Number(result);

306

return Number(result);

294

}

307

}

295

catch(err) {

308

catch(err) {

296

return;

309

return;

297

}

310

}

298

}

311

}

299

312

300

function updateBalance(message) {

313

function updateBalance(message) {

301

var balance = getBalanceFromMessage(message);

314

var balance = getBalanceFromMessage(message);

302

if (balance) {

315

if (balance) {

303

logger.info('Balance: ' + balance);

316

logger.info('Balance: ' + balance);

304

aaa.updateBalance(balance);

317

aaa.updateBalance(balance);

305

}

318

}

306

}

319

}

307

320

308

function checkStatus(task) {

321

function checkStatus(task) {

309

322

310

if (Number(config.globals.topup_request_on_check_status)) {

323

if (Number(config.globals.topup_request_on_check_status)) {

311

_topupRequest(task, true);

324

_topupRequest(task, true);

312

return;

325

return;

313

}

326

}

314

327

315

var partnerUrl = url.parse(config.h2h_out.partner);

328

var partnerUrl = url.parse(config.h2h_out.partner);

316

var clientOptions = {

329

var clientOptions = {

317

host: partnerUrl.hostname

330

host: partnerUrl.hostname

318

, port: partnerUrl.port

331

, port: partnerUrl.port

319

, path: partnerUrl.pathname

332

, path: partnerUrl.pathname

320

};

333

};

321

logger.info('XMLRPC client options:');

334

logger.info('XMLRPC client options:');

322

logger.info(clientOptions);

335

logger.info(clientOptions);

323

336

324

var client;

337

var client;

325

if (partnerUrl.protocol == 'https:') {

338

if (partnerUrl.protocol == 'https:') {

326

client = xmlrpc.createSecureClient(clientOptions);

339

client = xmlrpc.createSecureClient(clientOptions);

327

} else {

340

} else {

328

client = xmlrpc.createClient(clientOptions);

341

client = xmlrpc.createClient(clientOptions);

329

}

342

}

330

343

331

var methodName = 'topUpInquiry';

344

var methodName = 'topUpInquiry';

332

345

333

var params = {

346

var params = {

334

REQUESTID: task['requestId'],

347

REQUESTID: task['requestId'],

335

MSISDN: config.h2h_out.userid,

348

MSISDN: config.h2h_out.userid,

336

PIN: config.h2h_out.password,

349

PIN: config.h2h_out.password,

337

NOHP: task['destination']

350

NOHP: task['destination']

338

};

351

};

339

352

340

logger.info('Requesting topUpInquiry', {params: params});

353

logger.info('Requesting topUpInquiry', {params: params});

341

354

342

client.methodCall(methodName, [ params ], function (error, value) {

355

client.methodCall(methodName, [ params ], function (error, value) {

343

// Results of the method response

356

// Results of the method response

344

if (error) {

357

if (error) {

345

logger.warn('Error requesting topUpInquiry: ', {err: error, params: params});

358

logger.warn('Error requesting topUpInquiry: ', {err: error, params: params});

346

callbackReport(

359

callbackReport(

347

task.requestId, '68', 'Error requesting topUpInquiry: ' + error, null, JSON.stringify({methodName: methodName, error: error})

360

task.requestId, '68', 'Error requesting topUpInquiry: ' + error, null, JSON.stringify({methodName: methodName, error: error})

348

);

361

);

349

return;

362

return;

350

}

363

}

351

logger.info('Method response for \'' + methodName, {response: value});

364

logger.info('Method response for \'' + methodName, {response: value});

352

365

353

callbackReport(task.requestId, value['RESPONSECODE'], value['MESSAGE'], null, JSON.stringify({methodName: methodName, response: value}));

366

callbackReport(task.requestId, value['RESPONSECODE'], value['MESSAGE'], null, JSON.stringify({methodName: methodName, response: value}));

354

});

367

});

355

}

368

}

356

369

357

function start(options) {

370

function start(options) {

358

if (!options) {

371

if (!options) {

359

console.log('Undefined options, terminating....');

372

console.log('Undefined options, terminating....');

360

process.exit(1);

373

process.exit(1);

361

}

374

}

362

375

363

if (options.config) {

376

if (options.config) {

364

config = options.config;

377

config = options.config;

365

} else {

378

} else {

366

console.log('Undefined options.config, terminating....')

379

console.log('Undefined options.config, terminating....')

367

process.exit(1);

380

process.exit(1);

368

}

381

}

369

382

370

if (options.aaa) {

383

if (options.aaa) {

371

aaa = options.aaa;

384

aaa = options.aaa;

372

_callbackReport = options.aaa.callbackReportWithPushToMongoDb;

385

_callbackReport = options.aaa.callbackReportWithPushToMongoDb;

373

} else {

386

} else {

374

console.log('Undefined options.aaa, terminating....')

387

console.log('Undefined options.aaa, terminating....')

375

process.exit(1);

388

process.exit(1);

376

}

389

}

377

390

378

if (options && options.logger) {

391

if (options && options.logger) {

379

logger = options.logger;

392

logger = options.logger;

380

} else {

393

} else {

381

logger = new winston.Logger({

394

logger = new winston.Logger({

382

transports: [

395

transports: [

383

new (winston.transports.Console)()

396

new (winston.transports.Console)()

384

]

397

]

385

});

398

});

386

}

399

}

387

400

388

createRedisClient(config.globals.redis_host, config.globals.redis_port);

401

createRedisClient(config.globals.redis_host, config.globals.redis_port);

389

402

390

if (!Number(config.h2h_out.irs_mode)) {

403

if (!Number(config.h2h_out.irs_mode)) {

391

createServer();

404

createServer();

392

}

405

}

393

else {

406

else {

394

createPlainHttpServer();

407

createPlainHttpServer();

395

}

408

}

396

409

397

410

398

var resendDelayOptions = {

411

var resendDelayOptions = {

399

config: config,

412

config: config,

400

topupRequest: checkStatus,

413

topupRequest: checkStatus,

401

logger: logger

414

logger: logger

402

};

415

};

403

416

404

if (Number(config.globals.topup_request_on_resend_delay)) {

417

if (Number(config.globals.topup_request_on_resend_delay)) {

405

resendDelayOptions.topupRequest = topupRequest;

418

resendDelayOptions.topupRequest = topupRequest;

406

}

419

}

407

420

408

resendDelay.init(resendDelayOptions);

421

resendDelay.init(resendDelayOptions);

409

}

422

}

410

423

411

function parseSN(message, _config) {

424

function parseSN(message, _config) {

412

425

413

if (!_config) {

426

if (!_config) {

414

_config = config;

427

_config = config;

415

}

428

}

416

429

417

var sn_regex = new RegExp(_config.h2h_out.sn_pattern);

430

var sn_regex = new RegExp(_config.h2h_out.sn_pattern);

418

var sn_match = message.match(sn_regex);

431

var sn_match = message.match(sn_regex);

419

432

420

if (sn_match <= 0) {

433

if (sn_match <= 0) {

421

logger.info('SN Not found: ' + message);

434

logger.info('SN Not found: ' + message);

422

return '';

435

return '';

423

}

436

}

424

437

425

var match_index = 0;

438

var match_index = 0;

426

if (_config.h2h_out.sn_match_index) {

439

if (_config.h2h_out.sn_match_index) {

427

match_index = Number(_config.h2h_out.sn_match_index);

440

match_index = Number(_config.h2h_out.sn_match_index);

428

}

441

}

429

442

430

var sn = sn_match[match_index];

443

var sn = sn_match[match_index];

431

444

432

if (_config.h2h_out.sn_remove_whitespace) {

445

if (_config.h2h_out.sn_remove_whitespace) {

433

sn = sn.replace(/\s/g, '');

446

sn = sn.replace(/\s/g, '');

434

}

447

}

435

448

436

var sn_remove_patterns = [];

449

var sn_remove_patterns = [];

437

if (_config.h2h_out.sn_remove_patterns && _config.h2h_out.sn_remove_patterns_separator) {

450

if (_config.h2h_out.sn_remove_patterns && _config.h2h_out.sn_remove_patterns_separator) {

438

sn_remove_patterns = _config.h2h_out.sn_remove_patterns.split(_config.h2h_out.sn_remove_patterns_separator);

451

sn_remove_patterns = _config.h2h_out.sn_remove_patterns.split(_config.h2h_out.sn_remove_patterns_separator);

439

}

452

}

440

var count = sn_remove_patterns.length;

453

var count = sn_remove_patterns.length;

441

454

442

for(var i = 0; i < count; i++) {

455

for(var i = 0; i < count; i++) {

443

456

444

//sn = sn.replace(sn_remove_patterns[i], '');

457

//sn = sn.replace(sn_remove_patterns[i], '');

445

458

446

var re = new RegExp(sn_remove_patterns[i], 'g');

459

var re = new RegExp(sn_remove_patterns[i], 'g');

447

sn = sn.replace(re, '');

460

sn = sn.replace(re, '');

448

}

461

}

449

462

450

//sn = paddingSN(sn, _config);

463

//sn = paddingSN(sn, _config);

451

464

452

return sn.trim();

465

return sn.trim();

453

}

466

}

454

467

455

function getTaskKey(task, chipInfo) {

468

function getTaskKey(task, chipInfo) {

456

var requestId;

469

var requestId;

457

470

458

if (typeof task === 'string') {

471

if (typeof task === 'string') {

459

requestId = task;

472

requestId = task;

460

} else {

473

} else {

461

try {

474

try {

462

requestId = task.requestId;

475

requestId = task.requestId;

463

}

476

}

464

catch(e) {

477

catch(e) {

465

logger.warn('Something wrong', {task: task});

478

logger.warn('Something wrong', {task: task});

466

console.trace('Cekidot');

479

console.trace('Cekidot');

467

process.exit(1);

480

process.exit(1);

468

}

481

}

469

482

470

}

483

}

471

484

472

if (!chipInfo && config && config.globals && config.globals.gateway_name) {

485

if (!chipInfo && config && config.globals && config.globals.gateway_name) {

473

chipInfo = config.globals.gateway_name;

486

chipInfo = config.globals.gateway_name;

474

}

487

}

475

488

476

return chipInfo + '.hitachi.rid:' + requestId;

489

return chipInfo + '.hitachi.rid:' + requestId;

477

}

490

}

478

491

479

492

480

function putTaskToHistory(task, cb) {

493

function putTaskToHistory(task, cb) {

481

if (Number(config.globals.no_dupe_check)) {

494

if (Number(config.globals.no_dupe_check)) {

482

if (cb) { cb(); }

495

if (cb) { cb(); }

483

return;

496

return;

484

}

497

}

485

var key = getTaskKey(task, config.globals.gateway_name);

498

var key = getTaskKey(task, config.globals.gateway_name);

486

logger.verbose('Saving task to history LRU', {key: key, task: task});

499

logger.verbose('Saving task to history LRU', {key: key, task: task});

487

500

488

try {

501

try {

489

taskHistory.set(key, JSON.parse(JSON.stringify(task)));

502

taskHistory.set(key, JSON.parse(JSON.stringify(task)));

490

} catch (e) { }

503

} catch (e) { }

491

504

492

putTaskToRedis(task, cb);

505

putTaskToRedis(task, cb);

493

}

506

}

494

507

495

function putTaskToRedis(task, cb) {

508

function putTaskToRedis(task, cb) {

496

if (!redisClient) {

509

if (!redisClient) {

497

logger.verbose('Not saving to redis because of undefined redisClient')

510

logger.verbose('Not saving to redis because of undefined redisClient')

498

if (cb) { cb(); }

511

if (cb) { cb(); }

499

return;

512

return;

500

}

513

}

501

514

502

var key = getTaskKey(task, config.globals.gateway_name);

515

var key = getTaskKey(task, config.globals.gateway_name);

503

logger.verbose('Saving task to redis', {key: key, task: task});

516

logger.verbose('Saving task to redis', {key: key, task: task});

504

517

505

redisClient.set(key, JSON.stringify(task), function() {

518

redisClient.set(key, JSON.stringify(task), function() {

506

redisClient.expire(key, 3600*24*30);

519

redisClient.expire(key, 3600*24*30);

507

if (cb) {

520

if (cb) {

508

cb();

521

cb();

509

}

522

}

510

});

523

});

511

}

524

}

512

525

513

function getTaskFromHistory(task, cb) {

526

function getTaskFromHistory(task, cb) {

514

logger.verbose('Getting task from history', {task: task});

527

logger.verbose('Getting task from history', {task: task});

515

var key = getTaskKey(task, config.globals.gateway_name);

528

var key = getTaskKey(task, config.globals.gateway_name);

516

var archive = taskHistory.get(key);

529

var archive = taskHistory.get(key);

517

530

518

if (archive) {

531

if (archive) {

519

if (cb) { cb(null, archive); }

532

if (cb) { cb(null, archive); }

520

}

533

}

521

else {

534

else {

522

getTaskFromRedis(task, cb);

535

getTaskFromRedis(task, cb);

523

}

536

}

524

}

537

}

525

538

526

function getTaskFromRedis(task, cb) {

539

function getTaskFromRedis(task, cb) {

527

if (!redisClient) {

540

if (!redisClient) {

528

if (cb) { cb(null, null); }

541

if (cb) { cb(null, null); }

529

return;

542

return;

530

}

543

}

531

544

532

var key = getTaskKey(task, config.globals.gateway_name);

545

var key = getTaskKey(task, config.globals.gateway_name);

533

redisClient.get(key, function(err, result) {

546

redisClient.get(key, function(err, result) {

534

if (err) {

547

if (err) {

535

logger.warn('Error retrieving task from redis', {err: err});

548

logger.warn('Error retrieving task from redis', {err: err});

536

cb(err, null);

549

cb(err, null);

537

return;

550

return;

538

}

551

}

539

552

540

var task;

553

var task;

541

try {

554

try {

542

task = JSON.parse(result);

555

task = JSON.parse(result);

543

}

556

}

544

catch(e) {

557

catch(e) {

545

logger.warn('Exception on parsing redis result as a json', {err: e});

558

logger.warn('Exception on parsing redis result as a json', {err: e});

546

}

559

}

547

560

548

cb(null, task);

561

cb(null, task);

549

})

562

})

GITLAB

Reload97 / sate24-to-sate24

snSanitizer dan msgSanitizer

 var http = require('http');
 var xmlrpc = require('xmlrpc');
 var url = require('url');
 var math = require('mathjs');
 var winston = require('winston');
 var redis = require('redis');
 var resendDelay = require('sate24/resend-delay.js');
 var LRU = require('lru-cache');
 var aaa;
 var logger;
 var config;
 var _callbackReport;
 var redisClient;
 var taskHistory = LRU({max: 500, maxAge: 1000 * 3600 * 2});
 process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';
 http.globalAgent.maxSockets = Infinity;
 var irsRc = {
     '0': '00',
     '00': '00',
     '1': '00',
     '2': '14',
     '17': '40',
     '63': '40',
     '89': '40',
     '68': '68',
     '94': '68',
     '05': '40',
     '30': '40',
     '51': '40',
     '13': '40',
     '14': '14',
     '91': '40',
     '40': '40',
     '49': '40',
     '53': '40',
     '54': '40',
     '914': '55',
     '55': '55',
     '06': '40',
     '92': '40'
 }
 function callbackReport(requestId, responseCode, message, dontResendDelay, raw) {
     var responseToSave = {
         parsed: {
             MESSAGE: message,
         }
     };
     if (raw) {
         responseToSave.raw = raw;
     } else {
         responseToSave.raw = message;
     }
     if (responseCode != '68' || dontResendDelay) {
         resendDelay.cancel(requestId);
     } else {
         getTaskFromHistory(requestId, function(err, archivedTask) {
             if (archivedTask) {
                 logger.verbose('DEBUG', {archivedTask: archivedTask});
                 resendDelay.register(archivedTask);
             }
         });
     }
     _callbackReport(requestId, responseCode, message, null, responseToSave);
 }
 function createRedisClient(host, port) {
     if (!host && !port) {
         logger.info('Not creating redis client because unspecified host or port');
         return;
     }
     try {
         redisClient = redis.createClient(port, host);
     } catch(err) {
         logger.warn("Error creating redis client to " + host + ':' + port);
     }
 }
 function topupRequest(task) {
     aaa.insertTaskToMongoDb(task);
     getTaskFromHistory(task, function(err, archivedTask) {
         putTaskToHistory(task);
         if (archivedTask) {
             logger.info('Task has been executed before, going to checkStatus', {task: task, archivedTask: archivedTask});
             checkStatus(task);
         } else {
             _topupRequest(task);
         }
     });
 }
 function _topupRequest(task, pendingOnConnectError) {
     if (!aaa.isTodayTrx(task)) {
         callbackReport(task.requestId, '68', 'Terdeteksi transaksi beda hari, batal kirim ke supplier. Silahkan cek webreport', true);
         return;
     }
     var partnerUrl = url.parse(config.h2h_out.partner);
     var clientOptions = {
         host: partnerUrl.hostname,
         port: partnerUrl.port,
         path: partnerUrl.pathname
     };
     var client;
     if (partnerUrl.protocol == 'https:') {
         client = xmlrpc.createSecureClient(clientOptions);
     } else {
         client = xmlrpc.createClient(clientOptions);
     }
     var params = {
         MSISDN: config.h2h_out.userid,
         REQUESTID: task['requestId'],
         PIN: config.h2h_out.password,
         NOHP: task['destination'],
         NOM: task['remoteProduct']
     };
     var methodName = 'topUpRequest';
     logger.info('Preparing XMLRPC request', {methodname: methodName, params: params, partnerUrl: partnerUrl.href});
     client.methodCall(methodName, [ params ], function (error, value) {
         // Results of the method response
         if (error) {
             var rc = '68';
             var msg = 'XMLRPC Client Error: ' + error;
             if (!pendingOnConnectError && (error.code == 'ECONNREFUSED' || error.code == 'EHOSTUNREACH')) {
                 rc = '91';
                 msg = 'XMLRPC Client Error on connecting';
             } else if (!pendingOnConnectError && error.code == 'ETIMEDOUT' && error.syscall == "connect") {
                 rc = '91';
                 msg = 'XMLRPC Client Error on connecting';
             }
             logger.warn('XMLRPC Client Error', {methodName: methodName, task: task, err:error});
             callbackReport(task['requestId'], rc, msg, null, JSON.stringify({methodName: methodName, error: error.toString(), body: error.body}));
             return;
         }
         logger.info('Got XMLRPC response from partner for', {methodName: methodName, response_message: value});
         if (value['RESPONSECODE'] == '94') {
             logger.info('Change RC 94 to 68');
             value['RESPONSECODE'] = '68';
         }
         var msg = prefixMessageWithSN(value);
         callbackReport(
             task.requestId, value['RESPONSECODE'], msg, null, JSON.stringify({methodName: methodName, response: value})
         );
     });
 }
+function snSanitizer(sn) {
+    if (!sn && typeof sn === 'string') {
+        return;
+    }
+    sn = sn.replace(/[^A-Z0-9\/]/g, '-');
+    sn = sn.replace(/-+/g, '-');
+    sn = sn.replace(/^-+/, '');
+    sn = sn.replace(/-+$/, '');
+    sn = sn.trim();
+    return sn;
+}
+function msgSanitizer(msg) {
+    return msg.replace(/;\s*SN=.+?;/, '; ').trim();
+}
 function prefixMessageWithSN(data) {
     if (data['RESPONSECODE'] != '00') {
         return data['MESSAGE'];
     }
     sn = '';
     if (data.SN && data.SN.trim()) {
         sn = data['SN'].trim();
     }
     else if (data['MESSAGE'].search(/^SN=.+;/) == -1) {
         if (data['SN'] && data['SN'].trim()) {
             sn = data['SN'].trim();
         }
         else if (config.h2h_out.parse_sn == 'YES') {
             sn = parseSN(data['MESSAGE']);
         }
     }
+    sn = snSanitizer(sn);
     if (sn) {
-        //sn = sn.replace(/ /g, '-');
+        msg = 'SN=' + sn + '; ' + data['MESSAGE'];
-        //sn = sn.replace(/[\()]/g, '-');
+        return msgSanitizer(msg);
-        sn = sn.replace(/[^A-Z0-9\/]/g, '-');
-        sn = sn.replace(/-+/g, '-');
-        sn = sn.replace(/^-+/, '');
-        sn = sn.replace(/-+$/, '');
-        sn = sn.replace(/;\s*SN=.+?;/, '; ');
-        sn = sn.trim();
-        return 'SN=' + sn + '; ' + data['MESSAGE'];
     }
     return data['MESSAGE'];
 }
 function createServer() {
     logger.info('Creating XML-RPC server on port ' + config.h2h_out.listen_port);
     var serverOptions = {
         port: config.h2h_out.listen_port
     };
     var server = xmlrpc.createServer(serverOptions);
     server.on('NotFound', function (method, params) {
         logger.warn('Unknown method recevied on XMLRPC server', {xmlrpc_method: method, xmlrpc_params: params});
     });
     server.on('topUpReport', function (err, params, callback) {
         logger.info('Got XMLRPC topUpReport request from partner', {xmlrpc_method: 'topUpReport', xmlrpc_params: params});
         var paramscount = params.length;
         for (var i = 0; i < paramscount; i++) {
             var value = params[i];
             if (value['RESPONSECODE'] == '94') {
                 logger.info('Change RC 94 to 68');
                 value['RESPONSECODE'] = '68';
             }
             var msg = prefixMessageWithSN(value);
             callbackReport(
                 value['REQUESTID'], value['RESPONSECODE'], msg, null, JSON.stringify({methodName: 'topUpReport', msg: value})
             );
         }
         callback(null, 'ACK REPORT OK');
     })
 }
 function createPlainHttpServer() {
     logger.info('Creating IRS HTTP server on port ' + config.h2h_out.listen_port);
     var httpServer = http.createServer(function(request, response) {
         var qs = url.parse(request.url, true).query;
         logger.info('Got reverse report from gateway', {qs: qs});
         var request_id = qs.clientid;
         var rc = irsRc[qs.statuscode] || '68';
         var msg = qs.msg + '. STATUSCODE:' + qs.statuscode;
         if (rc == '00' && qs.sn) {
             msg = 'SN=' + qs.sn.replace(/ /g, '-').trim() + '; ' + msg;
         }
         response.end('OK');
         callbackReport(request_id, rc, msg);
     });
     httpServer.listen(config.h2h_out.listen_port, function() {
         logger.info('HTTP Reverse/Report server listen on port ' + config.h2h_out.listen_port);
     });
 }
 function getBalanceFromMessage(message, balance_regex) {
     if (!balance_regex) {
         if (config && config.globals && config.globals.balance_regex) {
             balance_regex = config.globals.balance_regex;
         }
     }
     if (!balance_regex) {
         return;
     }
     try {
         var re = new RegExp(balance_regex);
         var matches = message.match(re);
         var result = matches[1];
         result = result.replace(/\./g, '');
         result = result.replace(/,/g, '');
         return Number(result);
     }
     catch(err) {
         return;
     }
 }
 function updateBalance(message) {
     var balance = getBalanceFromMessage(message);
     if (balance) {
         logger.info('Balance: ' + balance);
         aaa.updateBalance(balance);
     }
 }
 function checkStatus(task) {
     if (Number(config.globals.topup_request_on_check_status)) {
         _topupRequest(task, true);
         return;
     }
     var partnerUrl = url.parse(config.h2h_out.partner);
     var clientOptions = {
         host: partnerUrl.hostname
         , port: partnerUrl.port
         , path: partnerUrl.pathname
     };
     logger.info('XMLRPC client options:');
     logger.info(clientOptions);
     var client;
     if (partnerUrl.protocol == 'https:') {
         client = xmlrpc.createSecureClient(clientOptions);
     } else {
         client = xmlrpc.createClient(clientOptions);
     }
     var methodName = 'topUpInquiry';
     var params = {
         REQUESTID: task['requestId'],
         MSISDN: config.h2h_out.userid,
         PIN: config.h2h_out.password,
         NOHP: task['destination']
     };
     logger.info('Requesting topUpInquiry', {params: params});
     client.methodCall(methodName, [ params ], function (error, value) {
         // Results of the method response
         if (error) {
             logger.warn('Error requesting topUpInquiry: ', {err: error, params: params});
             callbackReport(
                 task.requestId, '68', 'Error requesting topUpInquiry: ' + error, null, JSON.stringify({methodName: methodName, error: error})
             );
             return;
         }
         logger.info('Method response for \'' + methodName, {response: value});
         callbackReport(task.requestId, value['RESPONSECODE'], value['MESSAGE'], null, JSON.stringify({methodName: methodName, response: value}));
     });
 }
 function start(options) {
     if (!options) {
         console.log('Undefined options, terminating....');
         process.exit(1);
     }
     if (options.config) {
         config = options.config;
     } else {
         console.log('Undefined options.config, terminating....')
         process.exit(1);
     }
     if (options.aaa) {
         aaa = options.aaa;
         _callbackReport = options.aaa.callbackReportWithPushToMongoDb;
     } else {
         console.log('Undefined options.aaa, terminating....')
         process.exit(1);
     }
     if (options && options.logger) {
         logger = options.logger;
     } else {
         logger = new winston.Logger({
             transports: [
               new (winston.transports.Console)()
             ]
         });
     }
     createRedisClient(config.globals.redis_host, config.globals.redis_port);
     if (!Number(config.h2h_out.irs_mode)) {
         createServer();
     }
     else {
         createPlainHttpServer();
     }
     var resendDelayOptions = {
         config: config,
         topupRequest: checkStatus,
         logger: logger
     };
     if (Number(config.globals.topup_request_on_resend_delay)) {
         resendDelayOptions.topupRequest = topupRequest;
     }
     resendDelay.init(resendDelayOptions);
 }
 function parseSN(message, _config) {
     if (!_config) {
         _config = config;
     }
     var sn_regex = new RegExp(_config.h2h_out.sn_pattern);
     var sn_match = message.match(sn_regex);
     if (sn_match <= 0) {
         logger.info('SN Not found: ' + message);
         return '';
     }
     var match_index = 0;
     if (_config.h2h_out.sn_match_index) {
         match_index = Number(_config.h2h_out.sn_match_index);
     }
     var sn = sn_match[match_index];
     if (_config.h2h_out.sn_remove_whitespace) {
         sn = sn.replace(/\s/g, '');
     }
     var sn_remove_patterns = [];
     if (_config.h2h_out.sn_remove_patterns && _config.h2h_out.sn_remove_patterns_separator) {
         sn_remove_patterns = _config.h2h_out.sn_remove_patterns.split(_config.h2h_out.sn_remove_patterns_separator);
     }
     var count = sn_remove_patterns.length;
     for(var i = 0; i < count; i++) {
         //sn = sn.replace(sn_remove_patterns[i], '');
         var re = new RegExp(sn_remove_patterns[i], 'g');
         sn = sn.replace(re, '');
     }
     //sn = paddingSN(sn, _config);
     return sn.trim();
 }
 function getTaskKey(task, chipInfo) {
     var requestId;
     if (typeof task === 'string') {
         requestId = task;
     } else {
         try {
             requestId = task.requestId;
         }
         catch(e) {
             logger.warn('Something wrong', {task: task});
             console.trace('Cekidot');
             process.exit(1);
         }
     }
     if (!chipInfo && config && config.globals && config.globals.gateway_name) {
         chipInfo = config.globals.gateway_name;
     }
     return chipInfo + '.hitachi.rid:' + requestId;
 }
 function putTaskToHistory(task, cb) {
     if (Number(config.globals.no_dupe_check)) {
         if (cb) { cb(); }
         return;
     }
     var key = getTaskKey(task, config.globals.gateway_name);
     logger.verbose('Saving task to history LRU', {key: key, task: task});
     try {
         taskHistory.set(key, JSON.parse(JSON.stringify(task)));
     } catch (e) { }
     putTaskToRedis(task, cb);
 }
 function putTaskToRedis(task, cb) {
     if (!redisClient) {
         logger.verbose('Not saving to redis because of undefined redisClient')
         if (cb) { cb(); }
         return;
     }
     var key = getTaskKey(task, config.globals.gateway_name);
     logger.verbose('Saving task to redis', {key: key, task: task});
     redisClient.set(key, JSON.stringify(task), function() {
         redisClient.expire(key, 3600*24*30);
         if (cb) {
             cb();
         }
     });
 }
 function getTaskFromHistory(task, cb) {
     logger.verbose('Getting task from history', {task: task});
     var key = getTaskKey(task, config.globals.gateway_name);
     var archive = taskHistory.get(key);
     if (archive) {
         if (cb) { cb(null, archive); }
     }
     else {
         getTaskFromRedis(task, cb);
     }
 }
 function getTaskFromRedis(task, cb) {
     if (!redisClient) {
         if (cb) { cb(null, null); }
         return;
     }
     var key = getTaskKey(task, config.globals.gateway_name);
     redisClient.get(key, function(err, result) {
         if (err) {
             logger.warn('Error retrieving task from redis', {err: err});
             cb(err, null);
             return;
         }
         var task;
         try {
             task = JSON.parse(result);
         }
         catch(e) {
             logger.warn('Exception on parsing redis result as a json', {err: e});
         }
         cb(null, task);
     })