Komodo / komodo-gw-komodo-httpgex

Browse Code »

Commit 9e5ff94708752350082eaa68139aba98915147c3

Authored by Adhidarma Hadiwinoto 11 months ago

1 parent a99d67bf64

Exists in master

Experimental POST-JSON

Showing 2 changed files with 19 additions and 5 deletions Inline Diff

lib/hit/dump-req-res.js
lib/hit/prepaid-topup.js

lib/hit/dump-req-res.js

Diff comments View file @ 9e5ff94

 const MODULE_NAME = 'DUMP-REQ-RES';
 const querystring = require('querystring');
 const fs = require('fs');
 const path = require('path');
 const fsPromise = require('fs').promises;
 const moment = require('moment');
 const config = require('komodo-sdk/config');
 const logger = require('tektrans-logger');
 const baseDumpDir = 'dump';
 const requestDumpDir = path.join(baseDumpDir, 'request');
 if (!fs.existsSync(baseDumpDir)) {
     logger.verbose(`${MODULE_NAME} 51105314: Creating base dump dir`);
     fs.mkdirSync(baseDumpDir);
 }
 if (!fs.existsSync(requestDumpDir)) {
     logger.verbose(`${MODULE_NAME} 8A52891B: Creating request dump dir`);
     fs.mkdirSync(requestDumpDir);
 }
 module.exports = async (
     xid, task, httpMethod, endpointUrl, params, responseBody, responseStatus, isAdvice,
 ) => {
     if (
         !config
         || !config.partner
         || !config.partner.dump_request
     ) {
         return;
     }
     const data = `--------
 XID: ${xid}
 PID: ${process.pid}
 DATE: ${moment().format('YYYY-MM-DD HH:mm:ss.SSS')}
 TASK:
 ${JSON.stringify(task, null, 2)}
 IS-ADVICE: ${!!isAdvice}
 HTTP-METHOD: ${httpMethod}
 URL: ${endpointUrl}
 PARAMS:
 ${
     params && (
         (typeof params === 'string' && params)
         || JSON.stringify(params, null, 2)
     )
 }
-${httpMethod === 'GET' ? `FULL URL: ${endpointUrl}?${querystring.stringify(params)}` : `FORM DATA: ${new URLSearchParams(params).toString()}`}
+${
+    (httpMethod === 'GET' && `FULL URL: ${endpointUrl}?${querystring.stringify(params)}`)
+    || (httpMethod === 'POST' && `FORM DATA: ${new URLSearchParams(params).toString()}`)
+    || ''
+}
 RESPONSE-STATUS: ${responseStatus}
 RESPONSE-BODY:
 ${
     responseBody && (
         (typeof responseBody === 'string' && responseBody)
         || JSON.stringify(responseBody, null, 2)
     )
 }
 `;
     const dumpDir = path.join(
         requestDumpDir,
         moment().format('YYYY-MM-DD'),
     );
     try {
         await fsPromise.stat(dumpDir);
     } catch {
         await fsPromise.mkdir(dumpDir, { recursive: true });
     }
     await fsPromise.appendFile(
         path.join(
             dumpDir,
             `trx_${task.trx_id}`,
         ),
         data,
     );
     await fsPromise.writeFile(
         path.join(requestDumpDir, 'last'),
         data,
     );
 };

lib/hit/prepaid-topup.js

Diff comments View file @ 9e5ff94

 const MODULE_NAME = 'HIT.PREPAID-TOPUP';
 const axios = require('axios');
 const urljoin = require('url-join');
 const querystring = require('querystring');
 const config = require('komodo-sdk/config');
 const logger = require('tektrans-logger');
 const report = require('../report/prepaid');
 const translateRc = require('../translate-rc');
 const composeCallbackUrl = require('./compose-callback-url');
 const dumpReqRes = require('./dump-req-res');
 const axiosErrorIsSafe = require('./axios-error-is-safe');
 module.exports = async (xid, task) => {
     logger.verbose(`${MODULE_NAME} 2272F01F: Processing task`, {
         xid,
         task,
     });
     const params = {
         request_id: task.trx_id,
         terminal_name: config.partner.terminal_name,
         password: config.partner.password,
         destination: task.destination,
         product_name: task.remote_product,
         reverse_url: composeCallbackUrl(xid, task, false),
     };
     const endpointUrl = urljoin(config.partner.url, '/topup');
     const fullEndpointUrl = urljoin(
         endpointUrl,
         [
             '?',
             querystring.stringify(params),
         ].join(''),
     );
     let lastResponse = null;
     try {
         logger.verbose(`${MODULE_NAME} 4AAD4F99: Going to HIT prepaid endpoint`, {
             xid,
             endpointUrl,
             params,
             fullEndpointUrl: (!config.partner.method || config.partner.method === 'GET')
                 ? fullEndpointUrl
                 : endpointUrl,
         });
         report(xid, {
             trx_id: task.trx_id,
             rc: '68',
             message: {
                 xid,
                 msg: 'Sending request to partner',
                 method: config.partner.method || 'GET',
                 endpointUrl,
             },
         });
-        const response = config.partner.method === 'POST'
+        let response;
-            ? await axios.post(endpointUrl, new URLSearchParams(params), {
+        if (config.partner.method === 'POST') {
+            response = await axios.post(endpointUrl, new URLSearchParams(params), {
                 headers: {
                     'User-Agent': 'KOMODO-GW-HTTPGETX',
                 },
                 timeout: config.partner.hit_timeout_ms || 60 * 1000,
-            })
+            });
-            : await axios.get(endpointUrl, {
+        } else if (config.partner.method === 'POST-JSON') {
+            response = await axios.post(endpointUrl, params, {
+                headers: {
+                    'User-Agent': 'KOMODO-GW-HTTPGETX',
+                },
+                timeout: config.partner.hit_timeout_ms || 60 * 1000,
+            });
+        } else {
+            response = await axios.get(endpointUrl, {
                 headers: {
                     'User-Agent': 'KOMODO-GW-HTTPGETX',
                 },
                 timeout: config.partner.hit_timeout_ms || 60 * 1000,
                 params,
             });
+        }
         if (!response) {
             const e = new Error(`${MODULE_NAME} 8CF4E04D: Empty response`);
             e.rc = '68';
             e.response = response;
             throw e;
         }
         if (!response.data) {
             const e = new Error(`${MODULE_NAME} E72B5A53: Empty response data`);
             e.rc = '68';
             e.response = response;
             throw e;
         }
         if (typeof response.data !== 'object') {
             const e = new Error(`${MODULE_NAME} 507680AB: Response data is not a JSON`);
             e.rc = '68';
             e.response = response;
             throw e;
         }
         lastResponse = response;
         logger.verbose(`${MODULE_NAME} E51AFBBA: Got a direct response`, {
             xid,
             responseBody: response.data,
         });
         report(xid, {
             trx_id: task.trx_id,
             rc: response.data.rc ? translateRc[response.data.rc] || response.data.rc
                 : '68',
             sn: response.data.sn || null,
             amount: Number(response.data.amount) || undefined,
             balance: Number(response.data.ending_balance) || undefined,
             message: {
                 xid,
                 'DIRECT-RESPONSE': response.data,
             },
         });
     } catch (e) {
         const rc = e.rc
             || (axiosErrorIsSafe(e) && '91')
             || '68';
         logger.warn(`${MODULE_NAME} 8E8E49F5: Exception`, {
             xid,
             eCode: e.code,
             eMessage: e.message,
             eRc: e.rc,
             rc,
             responseHttpStatus: e.response && e.response.status,
             responseBody: e.response && e.response.data,
         });
         lastResponse = e.response;
         report(xid, {
             trx_id: task.trx_id,
             rc,
             message: {
                 xid,
                 'KOMODO-GW-ERROR': {
                     eCode: e.code,
                     eMessage: e.message,
                     responseHttpStatus: e.response && e.response.status,
                     responseBody: e.response && e.response.data,
                 },
             },
         });
     } finally {
         dumpReqRes(
             xid,
             task,
             config.partner.method || 'GET',
             endpointUrl,
             params,
             lastResponse && lastResponse.data,
             lastResponse && lastResponse.status,
             lastResponse,
             false,
         );
     }
 };