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

72

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

71

return sn_match[1];

73

return sn_match[1];

72

}

74

}

73

catch(err) {

75

catch(err) {

74

return '';

76

return '';

75

}

77

}

76

}

78

}

77

79

78

function hasSuccessKeywords(message) {

80

function hasSuccessKeywords(message) {

79

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

81

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

80

82

81

var count = keywords.length;

83

var count = keywords.length;

82

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

84

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

83

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

85

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

84

return true;

86

return true;

85

}

87

}

86

}

88

}

87

return false;

89

return false;

88

}

90

}

89

91

90

function supplierRcToST24Rc(rc) {

92

function supplierRcToST24Rc(rc) {

91

var rcs = {

93

var rcs = {

92

'0001': '40',

94

'0001': '40',

93

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

95

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

94

}

96

}

95

97

96

if (rcs[rc]) {

98

if (rcs[rc]) {

97

return rcs[rc];

99

return rcs[rc];

98

} else {

100

} else {

99

return;

101

return;

100

}

102

}

101

}

103

}

102

104

103

function topupResponseHandler(body, task) {

105

function topupResponseHandler(body, task) {

104

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

106

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

105

xml2js(body, function(err, result) {

107

xml2js(body, function(err, result) {

106

if (err) {

108

if (err) {

107

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

109

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

108

}

110

}

109

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

111

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

110

112

111

var rc = '68';

113

var rc = '68';

112

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

114

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

113

115

114

var trxid = 0;

116

var trxid = 0;

115

try {

117

try {

116

trxid = result.ciwaru.reqnum[0];

118

trxid = result.ciwaru.reqnum[0];

117

}

119

}

118

catch(err) {

120

catch(err) {

119

trxid = result.ciwaru.trxid[0];

121

trxid = result.ciwaru.trxid[0];

120

}

122

}

121

123

122

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

124

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

123

rc = '68';

125

rc = '68';

124

}

126

}

125

else if (hasSuccessKeywords(message)) {

127

else if (hasSuccessKeywords(message)) {

126

var sn = getSNFromMessage(result.ciwaru.msg);

128

var sn = getSNFromMessage(result.ciwaru.msg);

127

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

129

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

128

rc = '00';

130

rc = '00';

129

} else {

131

} else {

130

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

132

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

131

if (!rc) {

133

if (!rc) {

132

rc = '68';

134

rc = '68';

133

}

135

}

134

}

136

}

135

137

136

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

138

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

137

callbackReport(trxid, rc, message);

139

callbackReport(trxid, rc, message);

138

} else {

140

} else {

139

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

141

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

140

}

142

}

141

143

142

if (rc == '68') {

144

if (rc == '68') {

143

task.retry--;

145

task.retry--;

144

146

145

if (task.retry) {

147

if (task.retry) {

146

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

148

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

147

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

149

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

148

}

150

}

149

else {

151

else {

150

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

152

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

151

}

153

}

152

}

154

}

153

});

155

});

154

}

156

}

155

157

156

function topupRequest(task, retry) {

158

function topupRequest(task, retry) {

157

159

158

if (retry === undefined) {

160

if (retry === undefined) {

159

task.retry = maxRetry;

161

task.retry = maxRetry;

160

}

162

}

161

163

162

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

164

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

163

165

164

var params = {

166

var params = {

165

trxtype: '01',

167

trxtype: '01',

166

prdcode: remoteProduct[0],

168

prdcode: remoteProduct[0],

167

value: remoteProduct[1],

169

value: remoteProduct[1],

168

msisdn: task.destination,

170

msisdn: task.destination,

169

trxid: task.requestId,

171

trxid: task.requestId,

170

uid: config.h2h_out.userid,

172

uid: config.h2h_out.userid,

171

password: config.h2h_out.password,

173

password: config.h2h_out.password,

172

};

174

};

173

175

174

var postBody = createXmlPayload(params);

176

var postBody = createXmlPayload(params);

175

177

176

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

178

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

177

var postRequest = {

179

var postRequest = {

178

host: partnerUrl.hostname,

180

host: partnerUrl.hostname,

179

path: partnerUrl.path,

181

path: partnerUrl.path,

180

port: partnerUrl.port,

182

port: partnerUrl.port,

181

method: "POST",

183

method: "POST",

182

headers: {

184

headers: {

183

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

185

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

184

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

186

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

185

}

187

}

186

};

188

};

187

189

188

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

190

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

189

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

191

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

190

192

191

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

193

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

192

var buffer = "";

194

var buffer = "";

193

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

195

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

194

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

196

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

195

topupResponseHandler(buffer, task);

197

topupResponseHandler(buffer, task);

196

});

198

});

197

});

199

});

198

200

199

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

201

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

200

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

202

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

201

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

203

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

202

});

204

});

203

205

204

req.write(postBody);

206

req.write(postBody);

205

req.end();

207

req.end();

206

}

208

}

207

209

208

exports.start = start;

210

exports.start = start;

209

exports.topupRequest = topupRequest;

211

exports.topupRequest = topupRequest;

210

exports.calculateSignature = calculateSignature;

212

exports.calculateSignature = calculateSignature;

211

exports.createXmlPayload = createXmlPayload;

213

exports.createXmlPayload = createXmlPayload;

212

exports.getSNFromMessage = getSNFromMessage;

214

exports.getSNFromMessage = getSNFromMessage;

213

215

GITLAB

Reload97 / sate24-to-cjk

verbose on get sn

 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];
     }
     catch(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 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(result.ciwaru.msg);
             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;