Reload97 / sate24-to-cjk

1

var winston = require('winston');

1

var winston = require('winston');

2

var crypto = require('crypto');

2

var crypto = require('crypto');

3

var xml = require('xml');

3

var xml = require('xml');

4

var url = require('url');

4

var url = require('url');

5

var http = require('http');

5

var http = require('http');

6

var xml2js = require('xml2js').parseString;

6

var xml2js = require('xml2js').parseString;

7

8

var config;

8

var config;

9

var callbackReport;

9

var callbackReport;

10

var aaa;

10

var aaa;

11

var logger;

11

var logger;

12

var options;

12

var options;

13

14

var maxRetry = 10;

14

var maxRetry = 10;

15

var sleepBeforeRetry = 30;

15

var sleepBeforeRetry = 30;

16

17

function start(_config, _callbackReport, options) {

17

function start(_config, _callbackReport, options) {

18

config = _config;

18

config = _config;

19

callbackReport = _callbackReport

19

callbackReport = _callbackReport

20

21

if (options && options.aaa) {

21

if (options && options.aaa) {

22

aaa = options.aaa;

22

aaa = options.aaa;

23

}

23

}

24

25

if (options && options.logger) {

25

if (options && options.logger) {

26

logger = options.logger;

26

logger = options.logger;

27

} else {

27

} else {

28

logger = new winston.Logger({

28

logger = new winston.Logger({

29

transports: [

29

transports: [

30

new (winston.transports.Console)()

30

new (winston.transports.Console)()

31

]

31

]

32

});

32

});

33

}

33

}

34

}

34

}

35

36

function calculateSignature(params) {

36

function calculateSignature(params) {

37

var passwordHash = crypto.createHash('sha1').update(params.password).digest().toString('hex');

37

var passwordHash = crypto.createHash('sha1').update(params.password).digest().toString('hex');

38

var plain = params.trxtype + params.prdcode + params.value + params.msisdn + params.trxid + params.uid + passwordHash;

38

var plain = params.trxtype + params.prdcode + params.value + params.msisdn + params.trxid + params.uid + passwordHash;

39

var signature = crypto.createHash('sha256').update(plain).digest().toString('hex');

39

var signature = crypto.createHash('sha256').update(plain).digest().toString('hex');

40

41

try {

41

try {

42

logger.verbose('Signature calculated', {plain: plain, signature: signature});

42

logger.verbose('Signature calculated', {plain: plain, signature: signature});

43

}

43

}

44

catch(err) {}

44

catch(err) {}

45

46

return signature;

46

return signature;

47

}

47

}

48

49

function createXmlPayload(params) {

49

function createXmlPayload(params) {

50

var payload = "<?xml version=\"1.0\" ?>\n" + xml({

50

var payload = "<?xml version=\"1.0\" ?>\n" + xml({

51

ciwaru: [

51

ciwaru: [

52

{trxtype: params.trxtype},

52

{trxtype: params.trxtype},

53

{prdcode: params.prdcode},

53

{prdcode: params.prdcode},

54

{value: params.value},

54

{value: params.value},

55

{msisdn: params.msisdn},

55

{msisdn: params.msisdn},

56

{trxid: params.trxid},

56

{trxid: params.trxid},

57

{uid: params.uid},

57

{uid: params.uid},

58

{hash: calculateSignature(params)}

58

{hash: calculateSignature(params)}

59

]

59

]

60

});

60

});

61

62

try { logger.verbose("Payload: " + payload); }

62

try { logger.verbose("Payload: " + payload); }

63

catch(errLog) {}

63

catch(errLog) {}

64

65

return payload;

65

return payload;

66

}

66

}

67

68

function getSNFromMessage(message) {

68

function getSNFromMessage(message) {

69

try {

69

try {

70

var sn_match = message.match(/SN: (\w+)/);

70

var sn_match = message.match(/SN: (\w+)/);

71

logger.verbose('Got SN: ' + sn_match[1]);

71

logger.verbose('Got SN: ' + sn_match[1]);

72

return sn_match[1];

72

return sn_match[1].trim();

73

}

73

}

74

catch(err) {

74

catch(err) {

75

logger.verbose('Exception on getting sn from message', {err: err});

75

logger.verbose('Exception on getting sn from message', {err: err});

76

return '';

76

return '';

77

}

77

}

78

}

78

}

79

80

function hasSuccessKeywords(message) {

80

function hasSuccessKeywords(message) {

81

var keywords = ['SUKSES', 'Finish'];

81

var keywords = ['SUKSES', 'Finish'];

82

83

var count = keywords.length;

83

var count = keywords.length;

84

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

84

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

85

if (message.indexOf(keywords[i]) >= 0) {

85

if (message.indexOf(keywords[i]) >= 0) {

86

return true;

86

return true;

87

}

87

}

88

}

88

}

89

return false;

89

return false;

90

}

90

}

91

92

function supplierRcToST24Rc(rc) {

92

function supplierRcToST24Rc(rc) {

93

var rcs = {

93

var rcs = {

94

'0001': '40',

94

'0001': '40',

95

'0019': '13', // produk tidak tersedia

95

'0019': '13', // produk tidak tersedia

96

}

96

}

97

98

if (rcs[rc]) {

98

if (rcs[rc]) {

99

return rcs[rc];

99

return rcs[rc];

100

} else {

100

} else {

101

return;

101

return;

102

}

102

}

103

}

103

}

104

105

function getSNFromResponseObject(respObj) {

106

try {

107

return respObj.ciwaru.sn[0].trim();

108

}

109

catch(err) {

110

return;

111

}

112

}

113

105

function topupResponseHandler(body, task) {

114

function topupResponseHandler(body, task) {

106

//logger.info('Got reply from partner', {body: body});

115

//logger.info('Got reply from partner', {body: body});

107

xml2js(body, function(err, result) {

116

xml2js(body, function(err, result) {

108

if (err) {

117

if (err) {

109

logger.warn('Got invalid XML from partner', {err: err, body: body, task: task});

118

logger.warn('Got invalid XML from partner', {err: err, body: body, task: task});

110

}

119

}

111

logger.info('XML message from partner', {result: result});

120

logger.info('XML message from partner', {result: result});

112

121

113

var rc = '68';

122

var rc = '68';

114

var message = result.ciwaru.msg[0];

123

var message = result.ciwaru.msg[0];

115

124

116

var trxid = 0;

125

var trxid = 0;

117

try {

126

try {

118

trxid = result.ciwaru.reqnum[0];

127

trxid = result.ciwaru.reqnum[0];

119

}

128

}

120

catch(err) {

129

catch(err) {

121

trxid = result.ciwaru.trxid[0];

130

trxid = result.ciwaru.trxid[0];

122

}

131

}

123

132

124

if (message.toUpperCase().indexOf('PENDING') >= 0) {

133

if (message.toUpperCase().indexOf('PENDING') >= 0) {

125

rc = '68';

134

rc = '68';

126

}

135

}

127

else if (hasSuccessKeywords(message)) {

136

else if (hasSuccessKeywords(message)) {

128

var sn = getSNFromMessage(message);

137

var sn = getSNFromResponseObject(result);

138

if (!sn) {

139

sn = getSNFromMessage(message);

140

}

141

129

message = 'SN=' + sn + '; ' + message;

142

message = 'SN=' + sn + '; ' + message;

130

rc = '00';

143

rc = '00';

144

131

} else {

145

} else {

132

rc = supplierRcToST24Rc(result.ciwaru.rc[0]);

146

rc = supplierRcToST24Rc(result.ciwaru.rc[0]);

133

if (!rc) {

147

if (!rc) {

134

rc = '68';

148

rc = '68';

135

}

149

}

136

}

150

}

137

151

138

if ((task.retry == maxRetry) || (rc != '68')) {

152

if ((task.retry == maxRetry) || (rc != '68')) {

139

callbackReport(trxid, rc, message);

153

callbackReport(trxid, rc, message);

140

} else {

154

} else {

141

logger.info('Not reporting to AAA for duplicate 68', {task: task});

155

logger.info('Not reporting to AAA for duplicate 68', {task: task});

142

}

156

}

143

157

144

if (rc == '68') {

158

if (rc == '68') {

145

task.retry--;

159

task.retry--;

146

160

147

if (task.retry) {

161

if (task.retry) {

148

logger.info('Got pending status, retrying in ' + sleepBeforeRetry + 's');

162

logger.info('Got pending status, retrying in ' + sleepBeforeRetry + 's');

149

setTimeout(topupRequest, sleepBeforeRetry * 1000, task, task.retry);

163

setTimeout(topupRequest, sleepBeforeRetry * 1000, task, task.retry);

150

}

164

}

151

else {

165

else {

152

logger.warn('Maximum retry for pending status exceeded', {task: task});

166

logger.warn('Maximum retry for pending status exceeded', {task: task});

153

}

167

}

154

}

168

}

155

});

169

});

156

}

170

}

157

171

158

function topupRequest(task, retry) {

172

function topupRequest(task, retry) {

159

173

160

if (retry === undefined) {

174

if (retry === undefined) {

161

task.retry = maxRetry;

175

task.retry = maxRetry;

162

}

176

}

163

177

164

var remoteProduct = task.remoteProduct.split(',');

178

var remoteProduct = task.remoteProduct.split(',');

165

179

166

var params = {

180

var params = {

167

trxtype: '01',

181

trxtype: '01',

168

prdcode: remoteProduct[0],

182

prdcode: remoteProduct[0],

169

value: remoteProduct[1],

183

value: remoteProduct[1],

170

msisdn: task.destination,

184

msisdn: task.destination,

171

trxid: task.requestId,

185

trxid: task.requestId,

172

uid: config.h2h_out.userid,

186

uid: config.h2h_out.userid,

173

password: config.h2h_out.password,

187

password: config.h2h_out.password,

174

};

188

};

175

189

176

var postBody = createXmlPayload(params);

190

var postBody = createXmlPayload(params);

177

191

178

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

192

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

179

var postRequest = {

193

var postRequest = {

180

host: partnerUrl.hostname,

194

host: partnerUrl.hostname,

181

path: partnerUrl.path,

195

path: partnerUrl.path,

182

port: partnerUrl.port,

196

port: partnerUrl.port,

183

method: "POST",

197

method: "POST",

184

headers: {

198

headers: {

185

'Content-Type': 'text/xml',

199

'Content-Type': 'text/xml',

186

'Content-Length': Buffer.byteLength(postBody)

200

'Content-Length': Buffer.byteLength(postBody)

187

}

201

}

188

};

202

};

189

203

190

logger.info('POST to partner', {postRequest: postRequest});

204

logger.info('POST to partner', {postRequest: postRequest});

191

var req = http.request(postRequest, function( res ) {

205

var req = http.request(postRequest, function( res ) {

192

206

193

logger.info('Status code: ' + res.statusCode );

207

logger.info('Status code: ' + res.statusCode );

194

var buffer = "";

208

var buffer = "";

195

res.on( "data", function( data ) { buffer = buffer + data; } );

209

res.on( "data", function( data ) { buffer = buffer + data; } );

196

res.on( "end", function( data ) {

210

res.on( "end", function( data ) {

197

topupResponseHandler(buffer, task);

211

topupResponseHandler(buffer, task);

198

});

212

});

199

});

213

});

200

214

201

req.on('error', function(e) {

215

req.on('error', function(e) {

202

logger.warn('problem with request: ' + e.message);

216

logger.warn('problem with request: ' + e.message);

203

callbackReport(task['requestId'], '40', e.message);

217

callbackReport(task['requestId'], '40', e.message);

204

});

218

});

205

219

206

req.write(postBody);

220

req.write(postBody);

207

req.end();

221

req.end();

208

}

222

}

209

223

210

exports.start = start;

224

exports.start = start;

211

exports.topupRequest = topupRequest;

225

exports.topupRequest = topupRequest;

212

exports.calculateSignature = calculateSignature;

226

exports.calculateSignature = calculateSignature;

213

exports.createXmlPayload = createXmlPayload;

227

exports.createXmlPayload = createXmlPayload;

214

exports.getSNFromMessage = getSNFromMessage;

228

exports.getSNFromMessage = getSNFromMessage;

215

229

 var winston = require('winston');
 var crypto = require('crypto');
 var xml = require('xml');
 var url = require('url');
 var http = require('http');
 var xml2js = require('xml2js').parseString;
 var config;
 var callbackReport;
 var aaa;
 var logger;
 var options;
 var maxRetry = 10;
 var sleepBeforeRetry = 30;
 function start(_config, _callbackReport, options) {
     config = _config;
     callbackReport = _callbackReport
     if (options && options.aaa) {
             aaa = options.aaa;
     }
     if (options && options.logger) {
         logger = options.logger;
     } else {
         logger = new winston.Logger({
             transports: [
               new (winston.transports.Console)()
             ]
         });
     }
 }
 function calculateSignature(params) {
     var passwordHash = crypto.createHash('sha1').update(params.password).digest().toString('hex');
     var plain = params.trxtype + params.prdcode + params.value + params.msisdn + params.trxid + params.uid + passwordHash;
     var signature = crypto.createHash('sha256').update(plain).digest().toString('hex');
     try {
         logger.verbose('Signature calculated', {plain: plain, signature: signature});
     }
     catch(err) {}
     return signature;
 }
 function createXmlPayload(params) {
     var payload = "<?xml version=\"1.0\" ?>\n" + xml({
         ciwaru: [
             {trxtype: params.trxtype},
             {prdcode: params.prdcode},
             {value: params.value},
             {msisdn: params.msisdn},
             {trxid: params.trxid},
             {uid: params.uid},
             {hash: calculateSignature(params)}
         ]
     });
     try { logger.verbose("Payload: " + payload); }
     catch(errLog) {}
     return payload;
 }
 function getSNFromMessage(message) {
     try {
         var sn_match = message.match(/SN: (\w+)/);
         logger.verbose('Got SN: ' + sn_match[1]);
-        return sn_match[1];
+        return sn_match[1].trim();
     }
     catch(err) {
         logger.verbose('Exception on getting sn from message', {err: err});
         return '';
     }
 }
 function hasSuccessKeywords(message) {
     var keywords = ['SUKSES', 'Finish'];
     var count = keywords.length;
     for (var i=0; i < count; i++) {
         if (message.indexOf(keywords[i]) >= 0) {
             return true;
         }
     }
     return false;
 }
 function supplierRcToST24Rc(rc) {
     var rcs = {
         '0001': '40',
         '0019': '13', // produk tidak tersedia
     }
     if (rcs[rc]) {
         return rcs[rc];
     } else {
         return;
     }
 }
+function getSNFromResponseObject(respObj) {
+    try {
+        return respObj.ciwaru.sn[0].trim();
+    }
+    catch(err) {
+        return;
+    }
+}
 function topupResponseHandler(body, task) {
     //logger.info('Got reply from partner', {body: body});
     xml2js(body, function(err, result) {
         if (err) {
             logger.warn('Got invalid XML from partner', {err: err, body: body, task: task});
         }
         logger.info('XML message from partner', {result: result});
         var rc = '68';
         var message = result.ciwaru.msg[0];
         var trxid = 0;
         try {
             trxid = result.ciwaru.reqnum[0];
         }
         catch(err) {
             trxid = result.ciwaru.trxid[0];
         }
         if (message.toUpperCase().indexOf('PENDING') >= 0) {
             rc = '68';
         }
         else if (hasSuccessKeywords(message)) {
-            var sn = getSNFromMessage(message);
+            var sn = getSNFromResponseObject(result);
+            if (!sn) {
+                sn = getSNFromMessage(message);
+            }
             message = 'SN=' + sn + '; ' + message;
             rc = '00';
         } else {
             rc  = supplierRcToST24Rc(result.ciwaru.rc[0]);
             if (!rc) {
                 rc = '68';
             }
         }
         if ((task.retry == maxRetry) || (rc != '68')) {
             callbackReport(trxid, rc, message);
         } else {
             logger.info('Not reporting to AAA for duplicate 68', {task: task});
         }
         if (rc == '68') {
             task.retry--;
             if (task.retry) {
                 logger.info('Got pending status, retrying in ' +  sleepBeforeRetry + 's');
                 setTimeout(topupRequest, sleepBeforeRetry * 1000, task, task.retry);
             }
             else {
                 logger.warn('Maximum retry for pending status exceeded', {task: task});
             }
         }
     });
 }
 function topupRequest(task, retry) {
     if (retry === undefined) {
         task.retry = maxRetry;
     }
     var remoteProduct = task.remoteProduct.split(',');
     var params = {
         trxtype: '01',
         prdcode: remoteProduct[0],
         value: remoteProduct[1],
         msisdn: task.destination,
         trxid: task.requestId,
         uid: config.h2h_out.userid,
         password: config.h2h_out.password,
     };
     var postBody = createXmlPayload(params);
     var partnerUrl = url.parse(config.h2h_out.partner);
     var postRequest = {
         host: partnerUrl.hostname,
         path: partnerUrl.path,
         port: partnerUrl.port,
         method: "POST",
         headers: {
             'Content-Type': 'text/xml',
             'Content-Length': Buffer.byteLength(postBody)
         }
     };
     logger.info('POST to partner', {postRequest: postRequest});
     var req = http.request(postRequest, function( res ) {
         logger.info('Status code: ' + res.statusCode );
         var buffer = "";
         res.on( "data", function( data ) { buffer = buffer + data; } );
         res.on( "end", function( data ) {
                 topupResponseHandler(buffer, task);
         });
     });
     req.on('error', function(e) {
         logger.warn('problem with request: ' + e.message);
         callbackReport(task['requestId'], '40', e.message);
     });
     req.write(postBody);
     req.end();
 }
 exports.start = start;
 exports.topupRequest = topupRequest;
 exports.calculateSignature = calculateSignature;
 exports.createXmlPayload = createXmlPayload;
 exports.getSNFromMessage = getSNFromMessage;