node-paytmpg 7.5.17 → 7.5.19

package/dist/app/controllers/payment.controller.js

@@ -0,0 +1,1128 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PaymentController = void 0;
+const package_json_1 = __importDefault(require("../../package.json"));
+const checksum_1 = __importDefault(require("./checksum/checksum"));
+const PaytmChecksum_1 = __importDefault(require("./checksum/PaytmChecksum"));
+const crypto = __importStar(require("crypto"));
+const path_1 = __importDefault(require("path"));
+const axios_1 = __importDefault(require("axios"));
+const razorpay_1 = __importDefault(require("razorpay"));
+const open_money_1 = __importDefault(require("./adapters/open_money"));
+const payu_1 = __importDefault(require("./adapters/payu"));
+const user_controller_1 = require("./user.controller");
+const utils_1 = require("../utils/utils");
+const loadingsvg_1 = require("./static/loadingsvg");
+const htmlhelper_1 = require("./htmlhelper");
+const buildConfig_1 = require("../utils/buildConfig");
+const IDLEN = 14;
+function makeid(length) {
+    const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+    let result = '';
+    for (let i = 0; i < length; i++) {
+        result += characters.charAt(Math.floor(Math.random() * characters.length));
+    }
+    return result;
+}
+class PaymentController {
+    constructor(baseConfig, db, callbacks, tableNames) {
+        this.tableNames = { USER: 'npusers', TRANSACTION: 'nptransactions' };
+        this.viewPath = '';
+        this.baseConfig = baseConfig;
+        this.callbacks = callbacks;
+        this.db = db;
+        if (tableNames) {
+            this.tableNames = tableNames;
+        }
+        this.useController = new user_controller_1.NPUserController(this.db, this.tableNames.USER);
+        this.configure(baseConfig);
+    }
+    encodeTxnDataForUrl(txnDataJson, req) {
+        const config = (0, buildConfig_1.withClientConfigOverrides)(this.baseConfig, req);
+        // Accept either an object or a JSON string.
+        const payloadStr = typeof txnDataJson === 'string' ? txnDataJson : JSON.stringify(txnDataJson);
+        // Derive a 32-byte key from config.SECRET (fallback to config.KEY).
+        const secret = String(config.SECRET || config.KEY || '');
+        if (!secret) {
+            // No secret available — fallback to url-safe base64 (not secure).
+            return Buffer.from(payloadStr, 'utf8').toString('base64').replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/g, '');
+        }
+        const key = crypto.createHash('sha256').update(secret).digest(); // 32 bytes
+        const iv = crypto.randomBytes(12); // 12 bytes recommended for GCM
+        const cipher = crypto.createCipheriv('aes-256-gcm', key, iv);
+        const encrypted = Buffer.concat([cipher.update(payloadStr, 'utf8'), cipher.final()]);
+        const tag = cipher.getAuthTag();
+        // Store as: iv (12) | tag (16) | ciphertext — then URL-safe base64
+        const out = Buffer.concat([iv, tag, encrypted]).toString('base64').replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/g, '');
+        return out;
+    }
+    decodeTxnDataFromUrl(encodedStr, req) {
+        if (!encodedStr)
+            return '';
+        // Convert back to standard base64 and pad
+        let b64 = encodedStr.replace(/-/g, '+').replace(/_/g, '/');
+        const pad = b64.length % 4;
+        if (pad)
+            b64 += '='.repeat(4 - pad);
+        const raw = Buffer.from(b64, 'base64');
+        // If too short to contain iv+tag, treat as plain base64 payload
+        if (raw.length < 12 + 16 + 1) {
+            try {
+                return raw.toString('utf8');
+            }
+            catch (e) {
+                return '';
+            }
+        }
+        try {
+            const iv = raw.slice(0, 12);
+            const tag = raw.slice(12, 28);
+            const ciphertext = raw.slice(28);
+            const config = (0, buildConfig_1.withClientConfigOverrides)(this.baseConfig, req);
+            const secret = String(config.SECRET || config.KEY || '');
+            if (!secret)
+                return raw.toString('utf8');
+            const key = crypto.createHash('sha256').update(secret).digest();
+            const decipher = crypto.createDecipheriv('aes-256-gcm', key, iv);
+            decipher.setAuthTag(tag);
+            const decrypted = Buffer.concat([decipher.update(ciphertext), decipher.final()]).toString('utf8');
+            return decrypted;
+        }
+        catch (err) {
+            // Fallback: return plain base64-decoded string (best-effort)
+            try {
+                return Buffer.from(b64, 'base64').toString('utf8');
+            }
+            catch (e) {
+                console.log('decodeTxnDataFromUrl error', e);
+                return '';
+            }
+        }
+    }
+    getProviderInstance(providerName, config) {
+        switch (providerName.toLocaleLowerCase()) {
+            case 'PayU'.toLocaleLowerCase():
+                return new payu_1.default(config);
+            case 'OpenMoney'.toLocaleLowerCase():
+                return new open_money_1.default(config);
+            case 'RazorPay'.toLocaleLowerCase():
+                return new razorpay_1.default({ key_id: config.KEY, key_secret: config.SECRET });
+            default:
+                return null;
+        }
+    }
+    configure(config) {
+        const viewRoot = config.templateDir
+            ? config.templateDir
+            : path_1.default.join(__dirname, '..', 'views');
+        this.viewPath = viewRoot.endsWith(path_1.default.sep) ? viewRoot : viewRoot + path_1.default.sep;
+        const sample = {
+            orderId: "string",
+            cusId: "string",
+            time: 1770051201752,
+            timeStamp: 1770051201752,
+            status: "string",
+            name: "string",
+            email: "string",
+            phone: "12345678",
+            amount: 1,
+            pname: "string",
+            extra: "stringlarge",
+            TXNID: "27118670199",
+            returnUrl: "string"
+        };
+        this.db.create(this.tableNames.TRANSACTION, sample).catch(() => { });
+    }
+    async insertTransactionInDb(txnData) {
+        await this.db.insert(this.tableNames.TRANSACTION, txnData);
+        return txnData;
+    }
+    async generateChecksum(params, req) {
+        const config = (0, buildConfig_1.withClientConfigOverrides)(this.baseConfig, req);
+        return await new Promise((resolve, reject) => {
+            checksum_1.default.genchecksum(params, config.KEY, (err, cs) => {
+                if (err || !cs) {
+                    reject(err || new Error('Error generating checksum'));
+                    return;
+                }
+                resolve(cs);
+            });
+        });
+    }
+    home(req, res) {
+        package_json_1.default.repository.url = package_json_1.default.repository.url.replace('git+', '');
+        return (0, htmlhelper_1.renderView)(req, res, this.viewPath + "home.hbs", package_json_1.default);
+    }
+    async init(req, res) {
+        var _a;
+        const callbacks = this.callbacks;
+        const vp = this.viewPath;
+        if (!req.body.ORDER_ID && !req.body.EMAIL && ((_a = req.query) === null || _a === void 0 ? void 0 : _a.to)) {
+            let toData = {};
+            try {
+                toData = JSON.parse(this.decodeTxnDataFromUrl(req.query.to, req));
+            }
+            catch {
+                console.log("Error parsing 'to' query param data");
+            }
+            req.body.NAME = toData.NAME;
+            req.body.EMAIL = toData.EMAIL;
+            req.body.TXN_AMOUNT = toData.TXN_AMOUNT;
+            req.body.MOBILE_NO = toData.MOBILE_NO;
+            req.body.ORDER_ID = toData.ORDER_ID || toData.ORDERID;
+            req.body.PRODUCT_NAME = toData.PRODUCT_NAME;
+            req.body.RETURN_URL = toData.RETURN_URL;
+            req.body.CLIENT_ID = toData.CLIENT_ID;
+            req.body.STATE = toData.STATE;
+        }
+        const config = (0, buildConfig_1.withClientConfigOverrides)(this.baseConfig, req);
+        utils_1.Utils.sanitizeRequest(req.body);
+        let gotAllParams = true;
+        let checkedFields = ['TXN_AMOUNT', 'PRODUCT_NAME',
+            //  'MOBILE_NO', 
+            'NAME', 'EMAIL'];
+        if (req.body !== undefined) {
+            for (var i = 0; i < checkedFields.length; i++) {
+                if (req.body[checkedFields[i]] === undefined) {
+                    gotAllParams = false;
+                    break;
+                }
+            }
+        }
+        else {
+            gotAllParams = false;
+        }
+        // console.log(req.body) 
+        if ((req.body.ORDER_ID !== undefined && req.body.ORDER_ID.length > 2)
+            &&
+                (req.body.CUST_ID !== undefined && req.body.CUST_ID.length > 2)) {
+            //  console.log('redirect')
+            // console.log(req.body)
+            var params = {
+                TXN_AMOUNT: req.body.TXN_AMOUNT,
+            };
+            params['MID'] = req.body.MID;
+            params['WEBSITE'] = req.body.WEBSITE;
+            params['CHANNEL_ID'] = req.body.CHANNEL_ID;
+            params['INDUSTRY_TYPE_ID'] = req.body.INDUSTRY_TYPE_ID;
+            params['ORDER_ID'] = req.body.ORDER_ID || req.body.ORDERID;
+            params['CUST_ID'] = req.body.CUST_ID;
+            params['TXN_AMOUNT'] = req.body.TXN_AMOUNT;
+            params['CALLBACK_URL'] = req.body.CALLBACK_URL + "?order_id=" + req.body.ORDER_ID;
+            params['EMAIL'] = req.body.EMAIL;
+            params['MOBILE_NO'] = req.body.MOBILE_NO;
+            params['PRODUCT_NAME'] = req.body.PRODUCT_NAME;
+            params['NAME'] = req.body.NAME;
+            if (config.paytm_url) {
+                let initTxnbody = {
+                    "requestType": "Payment",
+                    "mid": params['MID'],
+                    "websiteName": params['WEBSITE'],
+                    "orderId": params['ORDER_ID'],
+                    "callbackUrl": params['CALLBACK_URL'],
+                    "txnAmount": {
+                        "value": params['TXN_AMOUNT'],
+                        "currency": params['CURRENCY'] || "INR",
+                    },
+                    "userInfo": {
+                        "custId": params['CUST_ID'],
+                        "mobile": params['MOBILE_NO'],
+                        "firstName": params['NAME'],
+                        "email": params['EMAIL']
+                    }
+                };
+                if (config.mode) {
+                    initTxnbody["enablePaymentMode"] = JSON.parse(config.mode);
+                }
+                let checksum = await PaytmChecksum_1.default.generateSignature(JSON.stringify(initTxnbody), config.KEY);
+                let initTxnUrl = config.paytm_url + `/theia/api/v1/initiateTransaction?mid=${params['MID']}&orderId=${params['ORDER_ID']}`;
+                try {
+                    const resp = await axios_1.default.post(initTxnUrl, {
+                        body: initTxnbody,
+                        head: {
+                            signature: checksum,
+                            channelId: params['CHANNEL_ID']
+                        }
+                    });
+                    const body = resp.data;
+                    if (resp.status === 200 && body && body.body && body.body.resultInfo && body.body.resultInfo.resultStatus === 'S') {
+                        let paytmJsToken = {};
+                        paytmJsToken.CALLBACK_URL = params['CALLBACK_URL'];
+                        paytmJsToken.ORDERID = params['ORDER_ID'];
+                        paytmJsToken.ORDER_ID = params['ORDER_ID'];
+                        paytmJsToken.CANCELLED = 'cancelled';
+                        paytmJsToken.TOKEN = body.body.txnToken;
+                        paytmJsToken.TXN_AMOUNT = params['TXN_AMOUNT'];
+                        paytmJsToken.MID = params['MID'];
+                        paytmJsToken.CALLBACK_URL = params['CALLBACK_URL'];
+                        return (0, htmlhelper_1.renderPaytmJsCheckout)(req, res, paytmJsToken, config);
+                    }
+                    else {
+                        console.log('ERROR:::', resp.status, '\n', body);
+                        res.status(500);
+                        const errorResp = {
+                            TXNID: 'na',
+                            STATUS: 'TXN_FAILURE',
+                            CANCELLED: 'cancelled',
+                            ORDERID: params['ORDER_ID'],
+                            CHECKSUMHASH: checksum
+                        };
+                        return (0, htmlhelper_1.sendAutoPostForm)(req, res, params['CALLBACK_URL'], errorResp);
+                    }
+                }
+                catch (err) {
+                    console.log('ERROR:::', err);
+                    res.status(500);
+                    const errorResp = {
+                        TXNID: 'na',
+                        STATUS: 'TXN_FAILURE',
+                        CANCELLED: 'cancelled',
+                        ORDERID: params['ORDER_ID'],
+                        CHECKSUMHASH: checksum
+                    };
+                    return (0, htmlhelper_1.sendAutoPostForm)(req, res, params['CALLBACK_URL'], errorResp);
+                }
+            }
+            else if (config.razor_url) {
+                return (0, htmlhelper_1.renderRazorpayCheckout)(req, res, params, config, loadingsvg_1.LoadingSVG);
+            }
+            else if (config.payu_url) {
+                const payuInstance = this.getProviderInstance('PayU', config);
+                const payuRequest = payuInstance.generatePaymentRequest(params);
+                payuInstance.renderProcessingPage(params, payuRequest, res, loadingsvg_1.LoadingSVG);
+            }
+            else if (config.open_money_url) {
+                const openMoneyInstance = this.getProviderInstance('OpenMoney', config);
+                try {
+                    let pmttoken = await openMoneyInstance.generatePaymentToken(params);
+                    openMoneyInstance.renderProcessingPage(params, pmttoken, res, loadingsvg_1.LoadingSVG);
+                    var myquery = { orderId: params['ORDER_ID'] };
+                    const objForUpdate = await this.db.getOne(this.tableNames.TRANSACTION, myquery);
+                    if (objForUpdate) {
+                        objForUpdate.extra = JSON.stringify({
+                            layer_pay_token_id: pmttoken.tokenid
+                        });
+                        await this.db.update(this.tableNames.TRANSACTION, myquery, objForUpdate);
+                    }
+                }
+                catch (e) {
+                    openMoneyInstance.renderError(params, e, res);
+                }
+            }
+            if (this.callbacks && typeof this.callbacks.onStart === 'function') {
+                this.callbacks.onStart(params['ORDER_ID'], params);
+            }
+        }
+        else if ((req.body.ORDER_ID !== undefined && req.body.ORDER_ID.length > 2) || gotAllParams) {
+            let user = await this.useController.create({ name: req.body.NAME, email: req.body.EMAIL, phone: req.body.MOBILE_NO });
+            //console.log(user)
+            const onTxn = async (txnData) => {
+                //console.log(txnData)
+                const params = {};
+                params['MID'] = config.MID;
+                params['WEBSITE'] = config.WEBSITE;
+                params['CHANNEL_ID'] = config.CHANNEL_ID;
+                params['INDUSTRY_TYPE_ID'] = config.INDUSTRY_TYPE_ID;
+                params['ORDER_ID'] = txnData.orderId;
+                params['CUST_ID'] = txnData.cusId;
+                params['TXN_AMOUNT'] = JSON.stringify(txnData.amount);
+                params['CALLBACK_URL'] = config.host_url + '/' + config.path_prefix + '/callback';
+                params['EMAIL'] = txnData.email;
+                params['MOBILE_NO'] = txnData.phone;
+                params['NAME'] = txnData.name;
+                params['PRODUCT_NAME'] = txnData.pname;
+                const showConfirmation = (checksum = '') => {
+                    return (0, htmlhelper_1.renderView)(req, res, vp + "init.hbs", {
+                        name: 'ASDASD',
+                        enableConfirmationPage: config.enableConfirmationPage,
+                        theme: config.theme,
+                        path_prefix: config.path_prefix,
+                        action: "/" + config.path_prefix + "/init",
+                        readonly: 'readonly',
+                        BUTTON: 'Pay',
+                        NAME: params['NAME'],
+                        EMAIL: params['EMAIL'],
+                        MOBILE_NO: params['MOBILE_NO'],
+                        PRODUCT_NAME: params['PRODUCT_NAME'],
+                        TXN_AMOUNT: params['TXN_AMOUNT'],
+                        MID: params['MID'],
+                        WEBSITE: params['WEBSITE'],
+                        ORDER_ID: params['ORDER_ID'],
+                        CUST_ID: params['CUST_ID'],
+                        INDUSTRY_TYPE_ID: params['INDUSTRY_TYPE_ID'],
+                        CHANNEL_ID: params['CHANNEL_ID'],
+                        CALLBACK_URL: params['CALLBACK_URL'],
+                        STATE: params['STATE'],
+                        CHECKSUMHASH: checksum,
+                        CLIENT_ID: params['CLIENT_ID'] || txnData.clientId || config.client_id || ''
+                    });
+                };
+                if (config.paytm_url) {
+                    const checksum = await this.generateChecksum(params, req);
+                    showConfirmation(checksum);
+                }
+                else if (config.razor_url || config.payu_url || config.open_money_url) {
+                    showConfirmation();
+                }
+            };
+            const onOrder = async (orderId) => {
+                const txnTask = {
+                    id: orderId,
+                    orderId: orderId,
+                    cusId: user.id,
+                    time: Date.now(),
+                    timeStamp: Date.now(),
+                    status: 'INITIATED',
+                    name: user.name,
+                    email: user.email,
+                    phone: user.phone,
+                    amount: req.body.TXN_AMOUNT,
+                    pname: req.body.PRODUCT_NAME,
+                    extra: '',
+                    returnUrl: req.body.RETURN_URL || '',
+                    webhookUrl: req.body.WEBHOOK_URL || '',
+                    state: req.body.STATE || '',
+                    clientId: req.body.CLIENT_ID || ''
+                };
+                try {
+                    const txn = await this.insertTransactionInDb(txnTask);
+                    await onTxn(txn);
+                }
+                catch (err) {
+                    console.log(err);
+                    if (req.body.RETURN_URL) {
+                        res.redirect(req.body.RETURN_URL + "?status=failed");
+                        return;
+                    }
+                    res.redirect('');
+                }
+            };
+            if ((req.body.ORDER_ID !== undefined && req.body.ORDER_ID.length > 2)) {
+                const myquery = { orderId: req.body.ORDER_ID };
+                const orderData = await this.db.getOne(this.tableNames.TRANSACTION, myquery).catch(() => null);
+                if (!orderData) {
+                    if (gotAllParams) {
+                        console.log("Creating new order for ", req.body.ORDER_ID);
+                        await onOrder(req.body.ORDER_ID);
+                    }
+                    else {
+                        res.send({ message: "Order Not Found or missing required data: " + checkedFields.join(", "), ORDERID: req.body.ORDER_ID });
+                    }
+                }
+                else {
+                    await onTxn(orderData);
+                }
+            }
+            else {
+                let orderId;
+                if (config.paytm_url) {
+                    orderId = "pay_" + makeid(config.id_length || IDLEN);
+                    await onOrder(orderId);
+                }
+                else if (config.razor_url) {
+                    const options = {
+                        amount: req.body.TXN_AMOUNT * 100,
+                        currency: "INR",
+                        receipt: user.id + '_' + Date.now()
+                    };
+                    try {
+                        const razorPayInstance = this.getProviderInstance('RazorPay', config);
+                        const order = await razorPayInstance.orders.create(options);
+                        orderId = order.id;
+                        await onOrder(orderId);
+                    }
+                    catch (err) {
+                        res.send({ message: "An error occurred ! " + ((err === null || err === void 0 ? void 0 : err.description) || (err === null || err === void 0 ? void 0 : err.message) || 'unknown_error') });
+                    }
+                }
+                else if (config.open_money_url) {
+                    orderId = "pay_" + makeid(config.id_length || IDLEN);
+                    await onOrder(orderId);
+                }
+                else if (config.payu_url) {
+                    orderId = "payu_" + makeid(config.id_length || IDLEN);
+                    await onOrder(orderId);
+                }
+            }
+        }
+        else {
+            return (0, htmlhelper_1.renderView)(req, res, this.viewPath + "init.hbs", {
+                name: 'ASDASD',
+                enableConfirmationPage: config.enableConfirmationPage,
+                theme: config.theme,
+                path_prefix: config.path_prefix,
+                action: "/" + config.path_prefix + "/init",
+                readonly: '',
+                check: true,
+                BUTTON: 'Submit',
+                NAME: (req.body.NAME === undefined ? '' : req.body.NAME),
+                EMAIL: (req.body.EMAIL === undefined ? '' : req.body.EMAIL),
+                MOBILE_NO: (req.body.MOBILE_NO === undefined ? '' : req.body.MOBILE_NO),
+                PRODUCT_NAME: (req.body.PRODUCT_NAME === undefined ? '' : req.body.PRODUCT_NAME),
+                TXN_AMOUNT: (req.body.TXN_AMOUNT === undefined ? '' : req.body.TXN_AMOUNT),
+                MID: config.MID,
+                WEBSITE: config.WEBSITE,
+                ORDER_ID: '',
+                CUST_ID: '',
+                INDUSTRY_TYPE_ID: config.INDUSTRY_TYPE_ID,
+                CHANNEL_ID: config.CHANNEL_ID,
+                CALLBACK_URL: config.CALLBACK_URL,
+                CHECKSUMHASH: '',
+                STATE: (req.body.STATE === undefined ? '' : req.body.STATE),
+                CLIENT_ID: config.client_id || req.body.CLIENT_ID || ''
+            });
+        }
+    }
+    async updateTransaction(req, res, fromWebhook = false) {
+        const vp = this.viewPath;
+        const callbacks = this.callbacks;
+        const orderToFind = req.body.ORDERID || req.body.ORDER_ID || req.body.ORDERId || (req.query && req.query.order_id) || req.body.ORDER_ID;
+        const myquery = { orderId: orderToFind };
+        let objForUpdate = null;
+        try {
+            objForUpdate = await this.db.getOne(this.tableNames.TRANSACTION, myquery).catch(() => null);
+            if (!objForUpdate)
+                objForUpdate = await this.db.getOne(this.tableNames.TRANSACTION, { id: orderToFind }).catch(() => null);
+            if (!objForUpdate)
+                objForUpdate = await this.db.getOne(this.tableNames.TRANSACTION, { ORDERID: orderToFind }).catch(() => null);
+        }
+        catch {
+            objForUpdate = objForUpdate || null;
+        }
+        let returnUrl = objForUpdate ? objForUpdate.returnUrl : null;
+        let webhookUrl = objForUpdate ? objForUpdate.webhookUrl : null;
+        if (webhookUrl === 'undefined')
+            webhookUrl = null;
+        if (returnUrl === 'undefined')
+            returnUrl = null;
+        const config = (0, buildConfig_1.withClientConfigOverrides)(this.baseConfig, req, objForUpdate);
+        if (!objForUpdate) {
+            if (webhookUrl) {
+                try {
+                    await axios_1.default.post(webhookUrl, {
+                        status: 'FAILED',
+                        message: 'Transaction Not Found',
+                        ORDERID: req.body.ORDERID,
+                        TXNID: req.body.TXNID
+                    });
+                    console.log("Sent webhook to ", webhookUrl, 'orderId:', req.body.ORDERID, 'txnId:', req.body.TXNID);
+                }
+                catch (e) {
+                    console.log("Error sending webhook to ", webhookUrl, (e === null || e === void 0 ? void 0 : e.message) || e, 'orderId:', req.body.ORDERID, 'txnId:', req.body.TXNID);
+                }
+            }
+            if (returnUrl) {
+                const separator = returnUrl.indexOf('?') > -1 ? '&' : '?';
+                return res.redirect(`${returnUrl}${separator}status=FAILED&message=txn_not_found&ORDERID=${req.body.ORDERID}`);
+            }
+            res.send({ message: "Transaction Not Found !", ORDERID: req.body.ORDERID, TXNID: req.body.TXNID });
+            return;
+        }
+        if (!["INITIATED", "TXN_PENDING", "PENDING"].includes(String(objForUpdate.status))) {
+            objForUpdate.readonly = "readonly";
+            if (webhookUrl) {
+                try {
+                    await axios_1.default.post(webhookUrl, objForUpdate);
+                    console.log("Sent webhook to ", webhookUrl, 'orderId:', req.body.ORDERID, 'txnId:', req.body.TXNID);
+                }
+                catch (e) {
+                    console.log("Error sending webhook to ", webhookUrl, (e === null || e === void 0 ? void 0 : e.message) || e, 'orderId:', req.body.ORDERID, 'txnId:', req.body.TXNID);
+                }
+            }
+            if (!fromWebhook) {
+                if (returnUrl) {
+                    const separator = returnUrl.indexOf('?') > -1 ? '&' : '?';
+                    return res.redirect(`${returnUrl}${separator}status=${objForUpdate.status}&ORDERID=${objForUpdate.orderId}&TXNID=${objForUpdate.txnId}`);
+                }
+                (0, htmlhelper_1.renderView)(req, res, vp + "result.hbs", {
+                    path_prefix: config.path_prefix,
+                    ...objForUpdate
+                });
+            }
+            else {
+                res.send({ message: "Webhook already processed !", ORDERID: req.body.ORDERID, TXNID: req.body.TXNID, status: objForUpdate.status });
+            }
+            return;
+        }
+        if (req.body.status === "paid" && !req.body.STATUS)
+            req.body.STATUS = "TXN_SUCCESS";
+        objForUpdate.status = req.body.STATUS;
+        objForUpdate.txnId = req.body.TXNID;
+        objForUpdate.extra = JSON.stringify(req.body);
+        try {
+            await this.db.update(this.tableNames.TRANSACTION, myquery, objForUpdate);
+        }
+        catch {
+            if (returnUrl) {
+                const separator = returnUrl.indexOf('?') > -1 ? '&' : '?';
+                return res.redirect(`${returnUrl}${separator}status=FAILED&message=update_error&ORDERID=${req.body.ORDERID}`);
+            }
+            res.send({ message: "Error Occured !", ORDERID: req.body.ORDERID, TXNID: req.body.TXNID });
+            return;
+        }
+        if (callbacks && typeof callbacks.onFinish === 'function') {
+            callbacks.onFinish(req.body.ORDERID, objForUpdate);
+        }
+        objForUpdate.readonly = "readonly";
+        if (webhookUrl) {
+            try {
+                await axios_1.default.post(webhookUrl, objForUpdate);
+                console.log("Sent webhook to ", webhookUrl, 'orderId:', req.body.ORDERID, 'txnId:', req.body.TXNID);
+            }
+            catch (e) {
+                console.log("Error sending webhook to ", webhookUrl, (e === null || e === void 0 ? void 0 : e.message) || e, 'orderId:', req.body.ORDERID, 'txnId:', req.body.TXNID);
+            }
+        }
+        if (!fromWebhook) {
+            if (returnUrl) {
+                const separator = returnUrl.indexOf('?') > -1 ? '&' : '?';
+                return res.redirect(`${returnUrl}${separator}status=${objForUpdate.status}&ORDERID=${objForUpdate.orderId}&TXNID=${objForUpdate.txnId}`);
+            }
+            (0, htmlhelper_1.renderView)(req, res, vp + "result.hbs", {
+                theme: config.theme,
+                path_prefix: config.path_prefix,
+                ...objForUpdate
+            });
+        }
+        else {
+            res.send({ message: "Transaction Updated !", ORDERID: req.body.ORDERID, TXNID: req.body.TXNID, status: objForUpdate.status });
+        }
+    }
+    async getOrder(req = { body: {}, query: {} }, orderId) {
+        const orderToFind = orderId || req.body.ORDERID || req.body.ORDER_ID || req.body.ORDER_ID || req.body.ORDERId || req.query.ORDERID || req.query.ORDERId || req.query.ORDER_ID || req.query.order_id;
+        const myquery = { orderId: orderToFind };
+        let objForUpdate = null;
+        try {
+            objForUpdate = await this.db.getOne(this.tableNames.TRANSACTION, myquery).catch(() => null);
+        }
+        catch {
+            objForUpdate = objForUpdate || null;
+        }
+        return objForUpdate;
+    }
+    async callback(req, res) {
+        console.log("request_data ", req.originalUrl, JSON.stringify(req.body));
+        // Normalize common order id and txn id field names (support ORDER_ID, ORDERID, etc.)
+        try {
+            if ((!req.body.ORDERID || req.body.ORDERID === '') && req.body.ORDER_ID) {
+                req.body.ORDERID = req.body.ORDER_ID;
+            }
+            if ((!req.body.TXNID || req.body.TXNID === '') && req.body.TXN_ID) {
+                req.body.TXNID = req.body.TXN_ID;
+            }
+            if ((!req.body.ORDERID || req.body.ORDERID === '') && req.query && req.query.order_id) {
+                req.body.ORDERID = req.query.order_id;
+            }
+        }
+        catch {
+            // ignore
+        }
+        let result = false;
+        let isCancelled = false;
+        const objForUpdate = await this.getOrder(req);
+        const config = (0, buildConfig_1.withClientConfigOverrides)(this.baseConfig, req, objForUpdate);
+        const payuInstance = this.getProviderInstance('PayU', (0, buildConfig_1.withClientConfigOverrides)(config, req, objForUpdate));
+        const openMoneyInstance = this.getProviderInstance('OpenMoney', (0, buildConfig_1.withClientConfigOverrides)(config, req, objForUpdate));
+        if (config.paytm_url) {
+            const checksumhash = req.body.CHECKSUMHASH;
+            if (checksumhash) {
+                result = await checksum_1.default.verifychecksum(req.body, config.KEY, checksumhash);
+            }
+            else {
+                const liveStatus = await this.getStatusFromPaytm({ MID: config.MID, ORDERID: req.body.ORDERID }, req.body.ORDERID, req);
+                // Merge important fields when live status is available
+                if (liveStatus && typeof liveStatus === 'object') {
+                    req.body.STATUS = liveStatus.STATUS || req.body.STATUS;
+                    req.body.TXNID = liveStatus.TXNID || req.body.TXNID;
+                }
+                result = liveStatus && liveStatus.STATUS == req.body.STATUS;
+            }
+            if (req.body.STATUS === 'TXN_FAILURE' && req.body.CANCELLED === "cancelled" && req.body.TXNID) {
+                isCancelled = true;
+            }
+        }
+        else if (config.razor_url) {
+            let orderid = req.body.razorpay_order_id || req.query.ORDERID || req.query.order_id;
+            let liveResonse = null;
+            if (orderid) {
+                liveResonse = await this.getProviderInstance('Razorpay', config).orders.fetch(orderid).catch(() => null);
+                req.body.extras = liveResonse;
+            }
+            if (req.body.razorpay_payment_id) {
+                result = checksum_1.default.checkRazorSignature(req.body.razorpay_order_id, req.body.razorpay_payment_id, config.SECRET, req.body.razorpay_signature);
+                if (result) {
+                    req.body.STATUS = 'TXN_SUCCESS';
+                    req.body.ORDERID = req.body.razorpay_order_id;
+                    req.body.TXNID = req.body.razorpay_payment_id;
+                }
+            }
+            else {
+                if (req.body.error && req.body.error.metadata && JSON.parse(req.body.error.metadata)) {
+                    const orderId = JSON.parse(req.body.error.metadata).order_id;
+                    req.body.razorpay_order_id = orderId;
+                }
+                req.body.STATUS = (liveResonse === null || liveResonse === void 0 ? void 0 : liveResonse.attempts) ? 'TXN_FAILURE' : 'CANCELLED';
+                req.body.ORDERID = req.body.razorpay_order_id || req.query.order_id;
+                isCancelled = true;
+            }
+        }
+        else if (config.payu_url) {
+            const payuRest = await payuInstance.verifyResult(req);
+            result = !!payuRest.STATUS;
+            req.body.STATUS = payuRest.STATUS;
+            req.body.TXNID = payuRest.TXNID;
+            req.body.ORDERID = payuRest.ORDERID || req.query.order_id;
+            req.body.extras = payuRest.data;
+            isCancelled = !!payuRest.cancelled;
+        }
+        else if (config.open_money_url) {
+            const openRest = await openMoneyInstance.verifyResult(req);
+            result = true;
+            req.body.STATUS = openRest.STATUS;
+            req.body.TXNID = openRest.TXNID;
+            req.body.ORDERID = openRest.ORDERID || req.query.order_id;
+            req.body.extras = openRest.data;
+        }
+        console.log("NodePayTMPG::Transaction => ", req.body.ORDERID, req.body.STATUS);
+        if (result || isCancelled) {
+            await this.updateTransaction(req, res);
+        }
+        else {
+            res.send({ message: "Something went wrong ! Please try again later .", ORDERID: req.body.ORDERID, TXNID: req.body.TXNID });
+        }
+    }
+    getServiceUsed(req, baseConfig) {
+        const config = (0, buildConfig_1.withClientConfigOverrides)(baseConfig, req);
+        let serviceUsed = '';
+        if (config.paytm_url)
+            serviceUsed = 'Paytm';
+        if (config.razor_url)
+            serviceUsed = 'Razorpay';
+        if (config.payu_url)
+            serviceUsed = 'PayU';
+        if (config.open_money_url)
+            serviceUsed = 'OpenMoney';
+        // https://razorpay.com/docs/webhooks/?preferred-country=IN
+        if (req.headers["x-razorpay-signature"])
+            serviceUsed = 'Razorpay';
+        // https://business.paytm.com/docs/payment-status/
+        else if (req.body.PAYMENTMODE)
+            serviceUsed = 'Paytm';
+        // https://docs.payu.in/docs/webhooks
+        else if (req.body.payment_source || req.body.merchantTransactionId)
+            serviceUsed = 'PayU';
+        return serviceUsed;
+    }
+    async webhook(req, res) {
+        try {
+            let config = (0, buildConfig_1.withClientConfigOverrides)(this.baseConfig, req);
+            const payuInstance = this.getProviderInstance('PayU', config);
+            const openMoneyInstance = this.getProviderInstance('OpenMoney', config);
+            console.log("request_data ", req.originalUrl, JSON.stringify(req.body));
+            console.log("request_data rawBody", req.originalUrl, req.rawBody);
+            console.log("request_headers ", req.originalUrl, JSON.stringify(req.headers));
+            let serviceUsed = this.getServiceUsed(req, config);
+            if (serviceUsed === 'Paytm') {
+                await this.callback(req, res);
+                return;
+            }
+            if (serviceUsed === 'Razorpay') {
+                const events = ["payment.captured", "payment.pending", "payment.failed"];
+                if (req.body.event && events.indexOf(req.body.event) > -1) {
+                    if (req.body.payload &&
+                        req.body.payload.payment &&
+                        req.body.payload.payment.entity) {
+                        const entity = req.body.payload.payment.entity;
+                        const razorpay_order_id = entity.order_id;
+                        const order = await this.getOrder(undefined, razorpay_order_id);
+                        config = (0, buildConfig_1.withClientConfigOverrides)(this.baseConfig, req, order || undefined);
+                        const razorpay_payment_id = entity.id;
+                        const status = entity.status;
+                        const event = req.body.event;
+                        console.log(`Razorpay webhook payment order=${razorpay_order_id} payid=${razorpay_payment_id} status=${status}`);
+                        const reqBody = req.rawBody;
+                        const signature = req.headers["x-razorpay-signature"];
+                        console.log("Razorpay webhook signature:", signature);
+                        if (signature === undefined) {
+                            res.status(200).send({ message: "Missing Razorpay signature" });
+                            return;
+                        }
+                        let signatureValid;
+                        try {
+                            signatureValid = razorpay_1.default.validateWebhookSignature(reqBody, signature, config.SECRET);
+                        }
+                        catch (e) {
+                            signatureValid = false;
+                        }
+                        if (signatureValid) {
+                            if (event === events[0]) {
+                                req.body.STATUS = "TXN_SUCCESS";
+                            }
+                            else if (event === events[1]) { //pending
+                                req.body.STATUS = "TXN_PENDING";
+                            }
+                            else { // failed
+                                req.body.STATUS = "TXN_FAILURE";
+                            }
+                            req.body.ORDERID = razorpay_order_id;
+                            req.body.TXNID = razorpay_payment_id;
+                            setTimeout(() => {
+                                this.updateTransaction(req, res, true);
+                            }, 3000);
+                        }
+                        else {
+                            res.status(200).send({ message: "Invalid Rzpay signature" });
+                        }
+                    }
+                    else {
+                        res.status(200).send({ message: "Invalid Payload" });
+                    }
+                }
+                else {
+                    res.status(200).send({ message: "Unsupported event : " + req.body.event });
+                }
+                return;
+            }
+            else if (serviceUsed === 'PayU') {
+                await payuInstance.processWebhook(req, res, this.updateTransaction.bind(this), this.getOrder.bind(this));
+            }
+            else if (serviceUsed === 'OpenMoney') {
+                await openMoneyInstance.processWebhook(req, res, this.updateTransaction.bind(this), this.getOrder.bind(this));
+            }
+        }
+        catch (e) {
+            console.error("Error in webhook processing", e);
+            try {
+                res.status(200).send({ message: "Received" });
+            }
+            catch (e) { }
+        }
+    }
+    async createTxn(req, res) {
+        const config = (0, buildConfig_1.withClientConfigOverrides)(this.baseConfig, req);
+        // mandayory field
+        const requiredFields = ['NAME', 'EMAIL',
+            // 'MOBILE_NO', 
+            'TXN_AMOUNT', 'PRODUCT_NAME'];
+        const checkedFields = [];
+        let gotAllParams = true;
+        requiredFields.forEach(field => {
+            if (!req.body[field]) {
+                gotAllParams = false;
+                checkedFields.push(field);
+            }
+        });
+        if (!gotAllParams) {
+            res.status(400).send({ message: "Missing required fields", missing: checkedFields });
+            return;
+        }
+        try {
+            const user = await this.useController.create({ name: req.body.NAME, email: req.body.EMAIL, phone: req.body.MOBILE_NO });
+            let id = '';
+            if (config.paytm_url) {
+                id = "pay_" + makeid(config.id_length || IDLEN);
+            }
+            else if (config.razor_url) {
+                const options = {
+                    amount: req.body.TXN_AMOUNT * 100,
+                    currency: "INR",
+                    receipt: user.id + '_' + Date.now()
+                };
+                const razorPayInstance = this.getProviderInstance('Razorpay', config);
+                const order = await razorPayInstance.orders.create(options);
+                id = order.id;
+            }
+            else if (config.payu_url) {
+                id = "payu_" + makeid(config.id_length || IDLEN);
+            }
+            else if (config.open_money_url) {
+                id = "pay_" + makeid(config.id_length || IDLEN);
+            }
+            const txnTask = {
+                id: id,
+                orderId: id,
+                cusId: user.id,
+                time: Date.now(),
+                status: 'INITIATED',
+                name: user.name,
+                email: user.email,
+                phone: user.phone,
+                amount: req.body.TXN_AMOUNT,
+                pname: req.body.PRODUCT_NAME,
+                returnUrl: req.body.RETURN_URL || '',
+                webhookUrl: req.body.WEBHOOK_URL || '',
+                extra: (req.body.EXTRA || ''),
+                state: req.body.STATE || '',
+                clientId: req.body.CLIENT_ID || ''
+            };
+            const txn = await this.insertTransactionInDb(txnTask);
+            const urlData64 = this.encodeTxnDataForUrl(JSON.stringify({
+                NAME: txn.name,
+                EMAIL: txn.email,
+                MOBILE_NO: txn.phone,
+                ORDER_ID: txn.orderId,
+                RETURN_URL: txn.returnUrl,
+                WEBHOOK_URL: txn.webhookUrl,
+                TXN_AMOUNT: txn.amount,
+                PRODUCT_NAME: txn.pname,
+                clientId: txn.clientId,
+                CLIENT_ID: txn.clientId,
+                STATE: txn.state,
+            }), req);
+            txn.payurl = config.host_url + '/' + config.path_prefix + '/init?to=' + urlData64;
+            if (txn.clientId) {
+                txn.payurl += `&client_id=${txn.clientId}`;
+            }
+            res.send(txn);
+        }
+        catch (err) {
+            console.log(err);
+            res.redirect('');
+        }
+    }
+    ;
+    async createTxnToken(req, res) {
+        return this.createTxn(req, res);
+    }
+    ;
+    // optional user
+    async getTransactions(req, res) {
+        // parameters can be from query or body
+        // MID, MOBILE_NO, PRODUCT_NAME, EMAIL, NAME, limit, offset
+        const params = { ...(req.query || {}), ...(req.body || {}) };
+        // Build query map from incoming fields to db columns
+        const query = {};
+        const fieldMap = {
+            MOBILE_NO: 'phone',
+            PRODUCT_NAME: 'pname',
+            EMAIL: 'email',
+            NAME: 'name',
+            ORDER_ID: 'orderId',
+            ORDERID: 'orderId',
+            STATUS: 'status',
+            email: 'email',
+            phone: 'phone',
+            name: 'name',
+            product_name: 'pname',
+            order_id: 'orderId',
+            status: 'status',
+            mobile_no: 'phone',
+            CLIENT_ID: 'clientId',
+            state: 'state',
+            STATE: 'state',
+            clientId: 'clientId',
+            WEBHOOK_URL: 'webhookUrl',
+            webhookUrl: 'webhookUrl',
+        };
+        Object.keys(fieldMap).forEach((key) => {
+            if (params[key]) {
+                query[fieldMap[key]] = params[key];
+            }
+        });
+        // Pagination
+        const limit = Math.min(parseInt(params.limit, 10) || 20, 100);
+        const offset = Math.max(parseInt(params.offset, 10) || 0, 0);
+        try {
+            const all = await this.db.get(this.tableNames.TRANSACTION, query, {
+                sort: [{ field: 'time', order: 'desc' }],
+                limit: limit,
+                offset: offset
+            });
+            res.send({
+                limit,
+                offset,
+                count: all.length,
+                transactions: all
+            });
+        }
+        catch (err) {
+            console.log('getTransactions error', err);
+            res.status(500).send({ message: 'Failed to fetch transactions', error: (err === null || err === void 0 ? void 0 : err.message) || 'unknown_error' });
+        }
+    }
+    async status(req, res) {
+        if (!req.body.ORDERID && req.query.ORDERID) {
+            req.body.ORDERID = req.query.ORDERID;
+        }
+        if (!req.body.ORDER_ID && req.query.ORDER_ID) {
+            req.body.ORDER_ID = req.query.ORDER_ID;
+        }
+        if (!req.body.ORDER_ID && req.body.ORDERID) {
+            req.body.ORDER_ID = req.body.ORDERID;
+        }
+        if (!req.body.ORDER_ID) {
+            res.status(400).send({ message: "Missing ORDER_ID" });
+            return;
+        }
+        const myquery = { orderId: req.body.ORDER_ID };
+        const orderData = await this.db.getOne(this.tableNames.TRANSACTION, myquery).catch((err) => {
+            res.send(err);
+            return null;
+        });
+        const config = (0, buildConfig_1.withClientConfigOverrides)(this.baseConfig, req, orderData);
+        const callbacks = this.callbacks;
+        const payuInstance = this.getProviderInstance('PayU', config);
+        const openMoneyInstance = this.getProviderInstance('OpenMoney', config);
+        const razorPayInstance = this.getProviderInstance('Razorpay', config);
+        if (!orderData) {
+            if (!res.headersSent) {
+                res.send({ message: "Order Not Found or not initiated yet!", ORDER_ID: req.body.ORDER_ID });
+            }
+            return;
+        }
+        if (orderData.status === "INITIATED") {
+            const params = {};
+            params["MID"] = config.MID;
+            params["ORDERID"] = req.body.ORDER_ID;
+            const onStatusUpdate = async (paytmResponse) => {
+                if (paytmResponse.TXNID && paytmResponse.TXNID.length > 4) {
+                    orderData.status = paytmResponse.STATUS;
+                    orderData.extra = JSON.stringify(paytmResponse);
+                    try {
+                        await this.db.update(this.tableNames.TRANSACTION, myquery, orderData);
+                    }
+                    catch (err) {
+                        res.send({ message: "Error Occured !", ORDERID: paytmResponse.ORDERID, TXNID: paytmResponse.TXNID });
+                        return;
+                    }
+                    if (callbacks && typeof callbacks.onFinish === 'function') {
+                        callbacks.onFinish(req.body.ORDER_ID, orderData);
+                    }
+                    res.send(paytmResponse);
+                }
+                else {
+                    res.send(orderData);
+                }
+            };
+            if (config.paytm_url) {
+                const paytmResponse = await this.getStatusFromPaytm(params, req.body.ORDER_ID, req);
+                await onStatusUpdate(paytmResponse);
+            }
+            else if (config.razor_url) {
+                let result = await razorPayInstance.orders.fetch(req.body.ORDER_ID);
+                result.ORDERID = req.body.ORDER_ID;
+                if (result.status == 'paid' && result.amount_due == 0) {
+                    result.STATUS = 'TXN_SUCCESS';
+                    let payments = await razorPayInstance.orders.fetchPayments(req.body.ORDER_ID);
+                    payments.items.forEach((item) => {
+                        if (item.status == 'captured') {
+                            result.TXNID = item.id;
+                        }
+                    });
+                    result.payments = payments;
+                    await onStatusUpdate(result);
+                }
+                else {
+                    res.send(orderData);
+                }
+            }
+            else if (config.payu_url) {
+                let result = await payuInstance.getPaymentStatus(req.body.ORDER_ID);
+                if (result && result.transaction_details && result.transaction_details[req.body.ORDER_ID]) {
+                    let txn = result.transaction_details[req.body.ORDER_ID];
+                    let status = 'TXN_FAILURE';
+                    if (txn.status == 'success') {
+                        status = 'TXN_SUCCESS';
+                    }
+                    else if (txn.status == 'pending') {
+                        status = 'TXN_PENDING';
+                    }
+                    await onStatusUpdate({
+                        STATUS: status,
+                        ORDERID: req.body.ORDER_ID,
+                        TXNID: txn.mihpayid || txn.txnid,
+                        payu: txn
+                    });
+                }
+                else {
+                    res.send(orderData);
+                }
+            }
+            else if (config.open_money_url) {
+                let extras = JSON.parse(orderData.extra);
+                if (!extras || !extras.layer_pay_token_id) {
+                    res.status(500);
+                    res.send({ message: 'An unexpected error occured. No payment token exists' });
+                    return;
+                }
+                let result = await openMoneyInstance.getPaymentStatus(extras.layer_pay_token_id);
+                result = JSON.parse(result);
+                result.ORDERID = req.body.ORDER_ID;
+                if (result.status == 'paid' || result.status == 'captured') {
+                    result.STATUS = 'TXN_SUCCESS';
+                    result.TXNID = result.id;
+                    await onStatusUpdate(result);
+                }
+                else if (result.status == 'pending' || result.status == 'attempted') {
+                    result.STATUS = 'TXN_PENDING';
+                    result.TXNID = result.id;
+                    await onStatusUpdate(result);
+                }
+                // else if (result.status == 'failed' || result.status == 'cancelled') {
+                //     result.STATUS = 'TXN_FAILED'
+                //     result.TXNID = result.id
+                //     onStatusUpdate(result)
+                // }
+                else {
+                    res.send(orderData);
+                }
+            }
+        }
+        else {
+            res.send(orderData);
+        }
+    }
+    async getStatusFromPaytm(params, orderId, req) {
+        const checksum = await this.generateChecksum(params, req);
+        const config = (0, buildConfig_1.withClientConfigOverrides)(this.baseConfig, req);
+        try {
+            const resp = await axios_1.default.post(`${config.paytm_url}/order/status`, { MID: config.MID, ORDERID: orderId, CHECKSUMHASH: checksum });
+            if (resp.status === 200) {
+                return resp.data;
+            }
+            console.log('ERROR:::', resp.status, '\n', resp.data);
+            return { message: 'Error Occured !', ORDERID: orderId };
+        }
+        catch (err) {
+            console.log('ERROR:::', err);
+            return { message: 'Error Occured !', ORDERID: orderId };
+        }
+    }
+}
+exports.PaymentController = PaymentController;