Reload97 / sate24-to-komodo

1

"use strict";

1

"use strict";

2

3

process.env.NODE_TLS_REJECT_UNAUTHORIZED = "0";

3

process.env.NODE_TLS_REJECT_UNAUTHORIZED = "0";

4

5

const http = require('http');

5

const http = require('http');

6

const url = require('url');

6

const url = require('url');

7

const request = require('request');

7

const request = require('request');

8

const resendDelay = require('sate24/resend-delay')

8

const resendDelay = require('sate24/resend-delay')

9

10

const komodoRc = {

10

const komodoRc = {

11

'00': '00',

11

'00': '00',

12

'03': '40',

12

'03': '40',

13

'13': '13',

13

'13': '13',

14

'14': '14',

14

'14': '14',

15

'30': '40',

15

'30': '40',

16

'40': '40',

16

'40': '40',

17

'68': '68',

17

'68': '68',

18

'55': '55',

18

'55': '55',

19

'91': '91',

19

'91': '91',

20

'92': '40',

20

'92': '40',

21

'96': '68'

21

'96': '68'

22

}

22

}

23

24

var config;

24

var config;

25

var aaa;

25

var aaa;

26

var logger;

26

var logger;

27

28

function start(options) {

28

function start(options) {

29

if (!options) {

29

if (!options) {

30

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

30

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

31

process.exit(1);

31

process.exit(1);

32

}

32

}

33

34

if (options.config) {

34

if (options.config) {

35

config = options.config;

35

config = options.config;

36

} else {

36

} else {

37

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

37

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

38

process.exit(1);

38

process.exit(1);

39

}

39

}

40

41

if (options.aaa) {

41

if (options.aaa) {

42

aaa = options.aaa;

42

aaa = options.aaa;

43

} else {

43

} else {

44

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

44

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

45

process.exit(1);

45

process.exit(1);

46

}

46

}

47

48

if (options && options.logger) {

48

if (options && options.logger) {

49

logger = options.logger;

49

logger = options.logger;

50

} else {

50

} else {

51

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

51

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

52

process.exit(1);

52

process.exit(1);

53

}

53

}

54

55

resendDelay.init({config: config, logger: logger, topupRequest: topupAdvice});

55

resendDelay.init({config: config, logger: logger, topupRequest: topupAdvice});

56

57

createReverseHttpServer();

57

createReverseHttpServer();

58

59

}

59

}

60

61

function callbackReport(requestId, rc, message, options) {

61

function callbackReport(requestId, rc, message, options) {

62

aaa.callbackReportWithPushToMongoDb(requestId, rc, message);

62

aaa.callbackReportWithPushToMongoDb(requestId, rc, message);

63

64

if (!options || !options.task) {

64

if (!options || !options.task) {

65

return;

65

return;

66

}

66

}

67

68

if (rc == '68') {

68

if (rc == '68') {

69

resendDelay.register(options.task);

69

resendDelay.register(options.task);

70

} else {

70

} else {

71

resendDelay.cancel(options.task)

71

resendDelay.cancel(options.task)

72

}

72

}

73

}

73

}

74

75

function topupRequest(task, pendingOnConnectError) {

75

function topupRequest(task, pendingOnConnectError) {

76

aaa.insertTaskToMongoDb(task);

76

aaa.insertTaskToMongoDb(task);

77

78

const requestOptions = {

78

const requestOptions = {

79

url: config.h2h_out.partner,

79

url: config.h2h_out.partner,

80

qs: {

80

qs: {

81

terminal_name: config.h2h_out.terminal_name,

81

terminal_name: config.h2h_out.terminal_name,

82

password: config.h2h_out.password,

82

password: config.h2h_out.password,

83

product_name: task.remoteProduct,

83

product_name: task.remoteProduct,

84

destination: task.destination,

84

destination: task.destination,

85

request_id: task.requestId,

85

request_id: task.requestId,

86

reverse_url: config.h2h_out.reverse_url

86

reverse_url: config.h2h_out.reverse_url

87

}

87

}

88

}

88

}

89

90

logger.verbose('Requesting to partner', {request_options: requestOptions});

90

logger.verbose('Requesting to partner', {request_options: requestOptions});

91

92

request(requestOptions, function(err, response, body) {

92

request(requestOptions, function(err, response, body) {

93

if (err) {

93

if (err) {

94

logger.warn('Error requesting to partner', {err: err});

94

logger.warn('Error requesting to partner', {err: err});

95

96

let rc = '68';

96

let rc = '68';

97

98

if (err.syscall == 'connect' && !pendingOnConnectError) {

98

if (err.syscall == 'connect' && !pendingOnConnectError) {

99

rc = '91';

99

rc = '91';

100

}

100

}

101

callbackReport(task.requestId, rc, 'Error requesting to partner: ' + err, {task: task});

101

callbackReport(task.requestId, rc, 'Error requesting to partner: ' + err, {task: task});

102

return;

102

return;

103

}

103

}

104

105

if (response.statusCode != 200) {

105

if (response.statusCode != 200) {

106

let rc = '68';

106

let rc = '68';

107

108

callbackReport(task.requestId, rc, 'Partner returning HTTP status code ' + response.statusCode + ', not 200', {task: task});

108

callbackReport(task.requestId, rc, 'Partner returning HTTP status code ' + response.statusCode + ', not 200', {task: task});

109

return;

109

return;

110

}

110

}

111

112

logger.verbose('Got response from partner', {task: task, body: body});

113

112

let result = parsePartnerMessage(body);

114

let result = parsePartnerMessage(body);

113

115

114

if (!result) {

116

if (!result) {

115

callbackReport(task.requestId, '40', 'Error parsing response from partner. Partner response: ' + body, {task: task});

117

callbackReport(task.requestId, '40', 'Error parsing response from partner. Partner response: ' + body, {task: task});

116

return;

118

return;

117

}

119

}

118

120

119

processPartnerResponse(result, task);

121

processPartnerResponse(result, task);

120

122

121

})

123

})

122

}

124

}

123

125

124

function topupAdvice(task) {

126

function topupAdvice(task) {

125

topupRequest(task, true);

127

topupRequest(task, true);

126

}

128

}

127

129

128

function processPartnerResponse(resObj, task) {

130

function processPartnerResponse(resObj, task) {

129

let st24Rc = '40';

131

let st24Rc = '40';

130

132

131

if (!resObj || !resObj.rc) {

133

if (!resObj || !resObj.rc) {

132

st24Rc = '68';

134

st24Rc = '68';

133

}

135

}

134

else if (komodoRc[resObj.rc]) {

136

else if (komodoRc[resObj.rc]) {

135

st24Rc = komodoRc[resObj.rc];

137

st24Rc = komodoRc[resObj.rc];

136

}

138

}

137

139

138

let st24Message = resObj.message;

140

let st24Message = resObj.message;

139

if (resObj.sn) {

141

if (resObj.sn) {

140

st24Message = 'SN=' + resObj.sn + '; ' + st24Message;

142

st24Message = 'SN=' + resObj.sn + '; ' + st24Message;

141

}

143

}

142

144

143

callbackReport(resObj.request_id, st24Rc, st24Message, {task: task});

145

callbackReport(resObj.request_id, st24Rc, st24Message, {task: task});

144

}

146

}

145

147

146

function parsePartnerMessage(partner_message) {

148

function parsePartnerMessage(partner_message) {

147

let result;

149

let result;

148

try {

150

try {

149

result = JSON.parse(partner_message);

151

result = JSON.parse(partner_message);

150

152

151

}

153

}

152

catch(e) {

154

catch(e) {

153

logger.verbose('Exception on parsing partner message: ' + partner_message);

155

logger.verbose('Exception on parsing partner message: ' + partner_message);

154

result = null;

156

result = null;

155

}

157

}

156

158

157

return result;

159

return result;

158

}

160

}

159

161

160

function createReverseHttpServer() {

162

function createReverseHttpServer() {

161

let listenPort = config.h2h_out.listen_port;

163

let listenPort = config.h2h_out.listen_port;

162

164

163

http.createServer(onReverseReport).listen(listenPort, function() {

165

http.createServer(onReverseReport).listen(listenPort, function() {

164

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

166

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

165

});

167

});

166

}

168

}

167

169

168

function onReverseReport(request, response) {

170

function onReverseReport(request, response) {

169

response.end('OK');

171

response.end('OK');

170

172

171

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

173

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

172

logger.verbose('Got reverse report from partner', {qs: qs});

174

logger.verbose('Got reverse report from partner', {qs: qs});

173

processPartnerResponse(qs);

175

processPartnerResponse(qs);

174

}

176

}

175

177

176

178

177

exports.start = start;

179

exports.start = start;

178

exports.topupRequest = topupRequest;

180

exports.topupRequest = topupRequest;

179

exports.topupAdvice = topupAdvice;

181

exports.topupAdvice = topupAdvice;

180

182

GITLAB

Reload97 / sate24-to-komodo

log partner response

 "use strict";
 process.env.NODE_TLS_REJECT_UNAUTHORIZED = "0";
 const http = require('http');
 const url = require('url');
 const request = require('request');
 const resendDelay = require('sate24/resend-delay')
 const komodoRc = {
     '00': '00',
     '03': '40',
     '13': '13',
     '14': '14',
     '30': '40',
     '40': '40',
     '68': '68',
     '55': '55',
     '91': '91',
     '92': '40',
     '96': '68'
 }
 var config;
 var aaa;
 var logger;
 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;
     } else {
         console.log('Undefined options.aaa, terminating....')
         process.exit(1);
     }
     if (options && options.logger) {
         logger = options.logger;
     } else {
         console.log('Undefined options.logger, terminating....')
         process.exit(1);
     }
     resendDelay.init({config: config, logger: logger, topupRequest: topupAdvice});
     createReverseHttpServer();
 }
 function callbackReport(requestId, rc, message, options) {
     aaa.callbackReportWithPushToMongoDb(requestId, rc, message);
     if (!options || !options.task) {
         return;
     }
     if (rc == '68') {
         resendDelay.register(options.task);
     } else {
         resendDelay.cancel(options.task)
     }
 }
 function topupRequest(task, pendingOnConnectError) {
     aaa.insertTaskToMongoDb(task);
     const requestOptions = {
         url: config.h2h_out.partner,
         qs: {
             terminal_name: config.h2h_out.terminal_name,
             password: config.h2h_out.password,
             product_name: task.remoteProduct,
             destination: task.destination,
             request_id: task.requestId,
             reverse_url: config.h2h_out.reverse_url
         }
     }
     logger.verbose('Requesting to partner', {request_options: requestOptions});
     request(requestOptions, function(err, response, body) {
         if (err) {
             logger.warn('Error requesting to partner', {err: err});
             let rc = '68';
             if (err.syscall == 'connect' && !pendingOnConnectError) {
                 rc = '91';
             }
             callbackReport(task.requestId, rc, 'Error requesting to partner: ' + err, {task: task});
             return;
         }
         if (response.statusCode != 200) {
             let rc = '68';
             callbackReport(task.requestId, rc, 'Partner returning HTTP status code ' + response.statusCode + ', not 200', {task: task});
             return;
         }
+        logger.verbose('Got response from partner', {task: task, body: body});
         let result = parsePartnerMessage(body);
         if (!result) {
             callbackReport(task.requestId, '40', 'Error parsing response from partner. Partner response: ' + body, {task: task});
             return;
         }
         processPartnerResponse(result, task);
     })
 }
 function topupAdvice(task) {
     topupRequest(task, true);
 }
 function processPartnerResponse(resObj, task) {
     let st24Rc = '40';
     if (!resObj || !resObj.rc) {
         st24Rc = '68';
     }
     else if (komodoRc[resObj.rc]) {
         st24Rc = komodoRc[resObj.rc];
     }
     let st24Message = resObj.message;
     if (resObj.sn) {
         st24Message = 'SN=' + resObj.sn + '; ' + st24Message;
     }
     callbackReport(resObj.request_id, st24Rc, st24Message, {task: task});
 }
 function parsePartnerMessage(partner_message) {
     let result;
     try {
         result = JSON.parse(partner_message);
     }
     catch(e) {
         logger.verbose('Exception on parsing partner message: ' + partner_message);
         result = null;
     }
     return result;
 }
 function createReverseHttpServer() {
     let listenPort = config.h2h_out.listen_port;
     http.createServer(onReverseReport).listen(listenPort, function() {
         logger.info('HTTP Reverse/Report server listen on port ' + listenPort);
     });
 }
 function onReverseReport(request, response) {
     response.end('OK');
     const qs = url.parse(request.url, true).query;
     logger.verbose('Got reverse report from partner', {qs: qs});
     processPartnerResponse(qs);
 }
 exports.start = start;
 exports.topupRequest = topupRequest;
 exports.topupAdvice = topupAdvice;