node-paytmpg 4.1.0 → 5.1.3

package/README.MD

@@ -1,11 +1,12 @@
 ## Node JS Payments Easy Integration
 
-[![NPM Publish](https://github.com/shiveshnavin/node_paytm/actions/workflows/nodejs.yml/badge.svg)](https://github.com/shiveshnavin/node_paytm/actions/workflows/npm-publish.yml)
+[![NPM Publish](https://github.com/shiveshnavin/node_paytm/actions/workflows/npm-publish.yml/badge.svg)](https://github.com/shiveshnavin/node_paytm/actions/workflows/npm-publish.yml)
 [![Node.js CI](https://github.com/shiveshnavin/node_paytm/actions/workflows/nodejs.yml/badge.svg)](https://github.com/shiveshnavin/node_paytm/actions/workflows/nodejs.yml)
 
 Support for : 
  - Paytm
  - RazorPay
+ - Open Money
  
 Does all the hardwork for you while integrating payments in any express app. Comes with inbuilt UI and REST APIs for lightning fast development and prototyping .
 
@@ -22,7 +23,7 @@ Example App Sourcecode : https://github.com/shiveshnavin/payment-gateway-example
 ### Requirments
 
 1. MongoDB / Firestore / SQlite
-2. Your Paytm Credentials 
+2. Your Merchant Credentials 
 3. Express . This only works with NodeJS express server
 
 You can get your paytm credentials here
@@ -78,8 +79,25 @@ homepage : Homepage of your website where user can go after payment confirmation
 path_prefix : All node_paytm_pg apis/pages will be available relative to this path prefix
 db_url : Your MongoDB url in case you want to use legacy mongodb connection . You can use multidborm to support MongoDB/Firestore/Sqlite
 id_length: Length of Order ID and User ID
+
+```
+
+### For Open Money
+In case you want to use Open Money https://app.open.money/settings/developer-api/api . Use the below configuration
+```
+host_url : Host URL of your server . This will be used to redirect user after payment
+view_path : Ignore and dont change unless you know what you are doing . This is the useful in case you want to modify payment init page UI from node_paytm_pg library
+open_money_url : SANDBOX https://sandbox-icp-api.bankopen.co/api OR LIVE https://icp-api.bankopen.co/api
+KEY : Your generated API Key
+SECRET : Your API secret
+homepage : Homepage of your website where user can go after payment confirmation page
+path_prefix : All node_paytm_pg apis/pages will be available relative to this path prefix
+db_url : Your MongoDB url in case you want to use legacy mongodb connection . You can use multidborm to support MongoDB/Firestore/Sqlite
+id_length: Length of Order ID and User ID (Optional)
+
 ```
 
+
 Place these 2 statements in your main nodejs file before calling app.listen(..)
 
 ```javascript
@@ -206,13 +224,6 @@ var User=PayTMPG.User;
 
 Webhooks can issued at at `/_pay/api/webhook` and are useful for payments captured late.
 
-If you are using `bodyparser` , make sure to remove these from your express app since the body parsers will be already added with the library .
-```
-    Comment these if present in your app
-    app.use(bodyParser.json());
-    app.use(bodyParser.urlencoded({ extended: true }));
-```
-
 #### For razorpay webhook
 Make sure to use the same secret in your webhook as the merchant secret.
 https://razorpay.com/docs/webhooks/
@@ -221,6 +232,9 @@ https://razorpay.com/docs/webhooks/
 Nothing extra needed
 https://developer.paytm.com/docs/callback-and-webhook/?ref=callbackWebhook
 
+#### For Open Money
+Nothing extra needed
+https://docs.bankopen.com/reference/webhook-url
 
 
 License : GPL

package/app/controllers/adapters/open_money.js

@@ -0,0 +1,514 @@
+var crypto = require('crypto');
+const { resolve } = require('path');
+var reqpost = require('request');
+
+class OpenMoney {
+    config
+    constructor(npconfig) {
+        npconfig.accesskey = npconfig.KEY
+        npconfig.secretkey = npconfig.SECRET
+        npconfig.url = npconfig.open_money_url
+        npconfig.script_url = (npconfig.url.indexOf("sandbox") == -1) ? "https://payments.open.money/layer" : "https://sandbox-payments.open.money/layer"
+        this.config = npconfig;
+
+    }
+
+    generatePaymentToken(params) {
+
+        let config = this.config;
+        return new Promise((resolve, reject) => {
+            var payment_token_data;
+            let open_txn = {
+                "amount": params['TXN_AMOUNT'],
+                "currency": params['CURRENCY'] || "INR",
+                "name": params['NAME'],
+                "email_id": params['EMAIL'],
+                "contact_number": ("" + params['MOBILE_NO']).replace("+91", ""),
+                "mtx": params['ORDER_ID']
+            }
+            create_payment_token(open_txn,
+                config.accesskey,
+                config.secretkey,
+                config.url, function (layer_payment_token_data) {
+                    /*Object.keys(layer_payment_token_data).forEach(function(key) {
+                        console.log(key + layer_payment_token_data[key]);
+                    });*/
+
+                    if (typeof layer_payment_token_data['error'] != 'undefined')
+                        return reject(JSON.stringify('E55 Payment error. ' + layer_payment_token_data['error']));
+
+                    if (typeof layer_payment_token_data["id"] == 'undefined' || !layer_payment_token_data["id"])
+                        return reject(JSON.stringify('Payment error. ' + 'Layer token ID cannot be empty.'));
+
+                    if (typeof layer_payment_token_data["id"] != 'undefined') {
+
+                        get_payment_token(layer_payment_token_data["id"], config.accesskey, config.secretkey, config.url, function (payment_token_data) {
+
+                            if (payment_token_data.error) {
+                                return reject({
+                                    error: payment_token_data.error
+                                })
+                            }
+                            payment_token_data = JSON.parse(payment_token_data);
+
+                            if (typeof payment_token_data['error'] != 'undefined')
+                                return reject({ error: (JSON.stringify('E56 Payment error. ' + payment_token_data['error'])) })
+                            if (typeof payment_token_data['status'] != 'undefined' && payment_token_data['status'] == "paid")
+                                return reject({ error: (JSON.stringify("Layer: this order has already been paid.")) })
+                            if (parseFloat(payment_token_data['amount']) != parseFloat(params['TXN_AMOUNT']))
+                                return reject({ error: (JSON.stringify("Layer: an amount mismatch occurred.")) })
+
+                            var hash = create_hash({
+                                'layer_pay_token_id': payment_token_data['id'],
+                                'layer_order_amount': payment_token_data['amount'],
+                                'tranid': params['ORDER_ID'],
+                            }, config.accesskey, config.secretkey);
+                            params['CHECKSUM'] = hash;
+
+                            var html = `<form action='${params['CALLBACK_URL']}' method='post' style='display: none' name='layer_payment_int_form'>`;
+                            html += "<input type='hidden' name='layer_pay_token_id' value='" + payment_token_data['id'] + "'>";
+                            html += "<input type='hidden' name='tranid' value='" + params['ORDER_ID'] + "'>";
+                            html += "<input type='hidden' name='layer_order_amount' value='" + payment_token_data['amount'] + "'>";
+                            html += "<input type='hidden' id='layer_payment_id' name='layer_payment_id' value=''>";
+                            html += "<input type='hidden' id='fallback_url' name='fallback_url' value=''>";
+                            html += "<input type='hidden' name='hash' value='" + hash + "'></form>";
+                            html += "<script>";
+                            html += "var layer_params = {payment_token_id:'" + payment_token_data['id'] + "',accesskey:'" + config.accesskey + "'};";
+                            html += "</script>";
+                            html += `<script src="layer_checkout.js"></script>`;
+
+                            return resolve({
+                                html: html,
+                                params: params,
+                                data: config,
+                                tokenid: payment_token_data['id'],
+                                amount: payment_token_data['amount'],
+                                hash: hash
+                            })
+                        });
+                    }
+                });
+        })
+    }
+
+    verifyResult(req) {
+        let config = this.config;
+        return new Promise((resolve, reje) => {
+
+            var txnid = "";
+            var amount = "";
+            var status = "";
+            var msg = "";
+            var tokenid = "";
+            var paymentid = "";
+            var payment_data = {};
+
+            if (!req.body.layer_payment_id) {
+                return resolve({
+                    STATUS: 'TXN_FAILURE',
+                    ORDERID: txnid,
+                    TXNID: paymentid,
+                    reason: 'invalid response'
+                })
+            }
+            else {
+                txnid = req.body.tranid;
+                amount = req.body.layer_order_amount;
+                tokenid = req.body.layer_pay_token_id;
+                paymentid = req.body.layer_payment_id;
+            }
+            var data = {
+                'layer_pay_token_id': tokenid,
+                'layer_order_amount': amount,
+                'tranid': txnid,
+            };
+
+            if (verify_hash(data, req.body.hash, config.accesskey, config.secretkey, config.url)) {
+                get_payment_details(paymentid, config.accesskey, config.secretkey, config.url, function (response) {
+                    if (response === "{}") {
+
+                        return resolve({
+                            STATUS: 'TXN_FAILURE',
+                            ORDERID: txnid,
+                            TXNID: paymentid,
+                            message: 'Invalid Response',
+                            data: payment_data
+                        })
+
+                    }
+                    else {
+                        payment_data = JSON.parse(response);
+                        if (!payment_data['payment_token'] || payment_data['payment_token']['id'] != tokenid) {
+                            return resolve({
+                                STATUS: 'TXN_FAILURE',
+                                ORDERID: txnid,
+                                TXNID: paymentid,
+                                message: 'received layer_pay_token_id and collected layer_pay_token_id doesnt match',
+                                data: payment_data
+                            })
+                        }
+                        else {
+                            let status = ""
+                            if (payment_data.status == "captured" ||
+                                payment_data.status == "late_authorized") {
+                                status = 'TXN_SUCCESS'
+                            }
+                            else if (payment_data.status == "pending") {
+                                status = 'TXN_PENDING'
+                            }
+                            else {
+                                status = 'TXN_FAILURE'
+                            }
+
+                            return resolve({
+                                STATUS: status,
+                                ORDERID: txnid,
+                                TXNID: paymentid,
+                                data: (payment_data)
+                            })
+                        }
+                    }
+                });
+
+            }
+            else {
+                return resolve({
+                    STATUS: 'TXN_FAILURE',
+                    ORDERID: txnid,
+                    TXNID: paymentid,
+                    message: 'Invalid Response'
+                })
+            }
+        })
+    }
+
+    processWebhook(req, res, updateTransaction) {
+        let config = this.config;
+        let events = [
+            "payment_captured", "payment_pending", 
+            "payment_failed",
+            "payment_cancelled"]
+        if (req.body.event && events.indexOf(req.body.event) > -1) {
+            if (req.body.payment_token) {
+
+                let payment_token = req.body.payment_token;
+                let orderId = payment_token.mtx
+                let paymentid = req.body.id
+                let tokenid = payment_token.id
+                let payment_data = {}
+                let amount = req.body.amount;
+
+                setTimeout(() => {
+
+                    req.body.layer_pay_token_id = tokenid;
+                    // var data = {
+                    //     'layer_pay_token_id': tokenid,
+                    //     'layer_order_amount': amount,
+                    //     'tranid': orderId,
+                    // };
+
+                    // if (verify_hash(data, req.headers['x-webhook-signature'], config.accesskey, config.secretkey, config.url)) {
+                    //     console.log('TODO verify signature')
+                    // }
+                    get_payment_details(paymentid, config.accesskey, config.secretkey, config.url, function (response) {
+                        if (response === "{}") {
+                            req.body.STATUS = 'TXN_FAILURE';
+                            req.body.ORDERID = orderId;
+                            req.body.TXNID = paymentid;
+                        }
+                        else {
+                            payment_data = JSON.parse(response);
+                            if (!payment_data['payment_token'] || payment_data['payment_token']['id'] != tokenid) {
+                                req.body.STATUS = 'TXN_FAILURE';
+                                req.body.ORDERID = orderId;
+                                req.body.TXNID = paymentid;
+                            }
+                            else {
+                                let status = "INITIATED"
+                                if (payment_data.status == "captured" ||
+                                    payment_data.status == "late_authorized") {
+                                    status = 'TXN_SUCCESS'
+                                }
+                                else if (payment_data.status == "pending") {
+                                    status = 'TXN_PENDING'
+                                }
+                                // else {
+                                //     status = 'TXN_FAILURE'
+                                // }
+
+                                if (status != 'TXN_SUCCESS') {
+                                    if (req.body.status == "paid" || req.body.status == 'captured') {
+                                        status = 'TXN_SUCCESS'
+                                    }
+                                    // else if (req.body.status == 'failed') {
+                                    //     status = 'TXN_FAILURE'
+                                    // }
+                                    else if (req.body.status == 'pending') {
+                                        status = 'TXN_PENDING'
+                                    }
+                                }
+                                console.log(`Open Money ${req.body.event} webhook for order=${payment_token.mtx} payid=${paymentid} status=${req.body.status} || ${status}`)
+
+                                req.body.STATUS = status;
+                                req.body.ORDERID = orderId;
+                                req.body.TXNID = paymentid;
+                            }
+
+                        }
+                        updateTransaction(req, res)
+
+                    });
+                }, 3000)
+            }
+            else {
+                res.status(401)
+                res.send({ message: "Missing payment_token" })
+            }
+        }
+        else {
+            res.status(201)
+            res.send({ message: "Webhook not supported" })
+        }
+    }
+
+    getPaymentStatus(paymentTokenId, cb) {
+        return new Promise((resolve, reject) => {
+            get_payment_token_details(paymentTokenId, this.config.accesskey, this.config.secretkey, this.config.url, (data) => {
+                resolve(data)
+                if (cb) {
+                    cb(data)
+                }
+            })
+        })
+    }
+
+    renderProcessingPage(params, pmttoken, res) {
+        res.writeHead(200, { 'Content-Type': 'text/html' });
+        res.write(`<html><head><title>Merchant Checkout Page</title>
+        <script src="${this.config.script_url}"></script>
+        </head><body><center><h1>Processing ! Please do not refresh this page...</h1><br>${pmttoken.html}<br></center><script>triggerLayer();</script></body></html>`);
+        res.end();
+    }
+
+    renderError(params, error, res) {
+
+        console.log('ERROR:::', error, '\n');
+        res.status(500)
+        var form_fields = "";
+        let errorResp = {
+            TXNID: "na",
+            STATUS: "TXN_FAILURE",
+            CANCELLED: "cancelled",
+            ORDERID: params["ORDER_ID"]
+        }
+        for (var x in errorResp) {
+            form_fields += "<input type='hidden' name='" + x + "' value='" + errorResp[x] + "' >";
+        }
+        form_fields += "<input type='hidden' name='CHECKSUMHASH' value='" + params["CHECKSUM"] + "' >";
+
+        res.writeHead(200, { 'Content-Type': 'text/html' });
+        res.write(`<html>
+
+                    <head>
+                        <title>Merchant Checkout Error</title>
+                    </head>
+                    
+                    <body>
+                        <center>
+                            <h1>Something went wrong. Please wait you will be redirected automatically...</h1>
+                        </center>
+                        <form method="post" action="${params['CALLBACK_URL']}" name="f1">${form_fields}</form>
+                        <script type="text/javascript">document.f1.submit();</script>
+                    </body>
+        
+        </html>`);
+        res.end();
+
+    }
+
+
+}
+
+
+
+//Layer functions
+function create_payment_token(data, accesskey, secretkey, baseurl, callback) {
+    try {
+        var pay_token_request_data = {
+            'amount': (data['amount']) ? data['amount'] : null,
+            'currency': (data['currency']) ? data['currency'] : null,
+            'name': (data['name']) ? data['name'] : null,
+            'email_id': (data['email_id']) ? data['email_id'] : null,
+            'contact_number': (data['contact_number']) ? data['contact_number'] : null,
+            'mtx': (data['mtx']) ? data['mtx'] : null,
+            'udf': (data['udf']) ? data['udf'] : null,
+        };
+        http_post(pay_token_request_data, "payment_token", accesskey, secretkey, baseurl, function (response) {
+            return callback(response);
+        });
+
+    } catch (e) {
+        return callback({
+            'error': e
+        });
+    }
+}
+
+function get_payment_token(payment_token_id, accesskey, secretkey, url, callback) {
+    if (!payment_token_id) {
+        throw new Error("payment_token_id cannot be empty");
+    }
+
+    try {
+        http_get("payment_token/" + payment_token_id, accesskey, secretkey, url, function (response) {
+            return callback(response);
+        });
+    } catch (e) {
+        return callback({
+            'error': e
+        });
+    }
+}
+
+function get_payment_token_details(payment_tokenid, accesskey, secretkey, baseurl, callback) {
+
+    if (!payment_tokenid) {
+        throw new Error("payment_id cannot be empty");
+    }
+    try {
+        http_get("payment_token/" + payment_tokenid + '/payment', accesskey, secretkey, baseurl, function (response) {
+            return callback(response);
+        });
+    } catch (e) {
+        callback({
+            'error': e
+        })
+    }
+}
+
+function get_payment_details(payment_id, accesskey, secretkey, baseurl, callback) {
+
+    if (!payment_id) {
+        throw new Error("payment_id cannot be empty");
+    }
+    try {
+        http_get("payment/" + payment_id, accesskey, secretkey, baseurl, function (response) {
+            return callback(response);
+        });
+    } catch (e) {
+        callback({
+            'error': e
+        })
+    }
+}
+
+function http_post(data, route, accesskey, secretkey, baseurl, callback) {
+    Object.keys(data).forEach(function (key) {
+        if (data[key] === null)
+            delete data[key];
+    });
+
+    var url = baseurl + "/" + route;
+
+    var options = {
+        method: 'POST',
+        uri: url,
+        json: true,
+        form: {
+            amount: data['amount'],
+            currency: data['currency'],
+            name: data['name'],
+            email_id: data['email_id'],
+            contact_number: data['contact_number'],
+            mtx: data['mtx']
+        },
+        headers: {
+            'Content-Type': 'application/json',
+            'Authorization': 'Bearer ' + accesskey + ':' + secretkey
+        }
+    };
+
+    reqpost(options)
+        .on('response', function (resp) {
+            //console.log('STATUS:'+resp.statusCode);
+            resp.setEncoding('utf8');
+            resp.on('data', function (chunk) {
+                var data = JSON.parse(chunk);
+                var rdata = "";
+                if ("error" in data) {
+                    Object.keys(data).forEach(function (key) {
+                        if (key == "error_data") {
+                            var obj = data[key];
+                            Object.keys(obj).forEach(function (k) {
+                                rdata += obj[k] + ' ';
+                            });
+                        }
+                    });
+                    return callback({ "error": rdata });
+                }
+                else
+                    return callback(data);
+
+            });
+        })
+        .on('error', function (err) {
+            return callback(err);
+        });
+}
+
+function http_get(route, accesskey, secretkey, baseurl, callback) {
+
+    var url = baseurl + "/" + route;
+
+    var options = {
+        method: 'GET',
+        uri: url,
+        headers: {
+            'Content-Type': 'application/json',
+            'Authorization': 'Bearer ' + accesskey + ':' + secretkey
+        }
+    };
+
+    reqpost(options)
+        .on('response', function (resp) {
+            resp.setEncoding('utf8');
+            resp.on('data', function (chunk) {
+                return callback(chunk);
+            });
+        })
+        .on('error', function (err) {
+            return callback(err);
+        });
+}
+
+function create_hash(data, accesskey, secretkey) {
+    data = ksort(data);
+    hash_string = accesskey;
+    Object.keys(data).forEach(function (key) {
+        hash_string += '|' + data[key];
+    });
+    var cryp = crypto.createHash('sha256', secretkey);
+    cryp.update(hash_string);
+    return cryp.digest('hex');
+}
+
+function verify_hash(data, rec_hash, accesskey, secretkey) {
+    var gen_hash = create_hash(data, accesskey, secretkey);
+    if (gen_hash === rec_hash) {
+        return true;
+    }
+    return false;
+}
+
+function ksort(obj) {
+    var keys = Object.keys(obj).sort(), sortedObj = {};
+
+    for (var i in keys) {
+        sortedObj[keys[i]] = obj[keys[i]];
+    }
+
+    return sortedObj;
+}
+
+
+module.exports = OpenMoney;

package/app/controllers/payment_controller.js

@@ -5,8 +5,10 @@ var Transaction;
 var IDLEN = 10;
 var nodeBase64 = require('nodejs-base64-converter');
 var RazorPay = require('razorpay');
+var OpenMoney = require('./adapters/open_money')
 const PaytmChecksum = require('./checksum/PaytmChecksum.js');
 const { stat } = require('fs');
+const { config } = require('process');
 
 
 function sanitizeRequest(body) {
@@ -21,8 +23,14 @@ module.exports = function (app, callbacks) {
     var config = (app.get('np_config'))
     var useController = require('./np_user.controller.js')(app, callbacks);
 
+    var razorPayInstance;
+    var openMoneyInstance = new OpenMoney(config);
+
     if (config.razor_url)
-        var razorPayInstance = new RazorPay({ key_id: config.KEY, key_secret: config.SECRET })
+        razorPayInstance = new RazorPay({ key_id: config.KEY, key_secret: config.SECRET })
+    if (config.open_money_url) {
+        openMoneyInstance = new OpenMoney(config);
+    }
 
     let usingMultiDbOrm = false;
     if (config.db_url) {
@@ -358,8 +366,6 @@ module.exports = function (app, callbacks) {
             }
             else if (config.razor_url) {
 
-
-
                 let fail = `<div style="display:none">
                 
                 <form method="post" action="${params['CALLBACK_URL']}" id="fail">
@@ -402,6 +408,29 @@ module.exports = function (app, callbacks) {
                 res.end();
 
             }
+            else if (config.open_money_url) {
+                try {
+                    let pmttoken = await openMoneyInstance.generatePaymentToken(params);
+                    openMoneyInstance.renderProcessingPage(params, pmttoken, res);
+
+                    var myquery = { orderId: params['ORDER_ID'] };
+                    Transaction.findOne(myquery, function (err, objForUpdate) {
+
+                        objForUpdate.extra = JSON.stringify({
+                            layer_pay_token_id: pmttoken.tokenid
+                        });
+
+                        var newvalues = { $set: objForUpdate };
+                        Transaction.updateOne(myquery, newvalues, function (err, saveRes) {
+                            let status = 'Updated TXNID'
+                        });
+
+                    }, usingMultiDbOrm ? Transaction : undefined)
+
+                } catch (e) {
+                    openMoneyInstance.renderError(params, e, res)
+                }
+            }
             if (callbacks !== undefined)
                 callbacks.onStart(params['ORDER_ID'], params);
         }
@@ -460,6 +489,8 @@ module.exports = function (app, callbacks) {
                             checksum_lib.genchecksum(params, config.KEY, showConfirmation);
                         else if (config.razor_url) {
                             showConfirmation()
+                        } else if (config.open_money_url) {
+                            showConfirmation()
                         }
 
                     };
@@ -470,9 +501,9 @@ module.exports = function (app, callbacks) {
 
 
                         var myquery = { orderId: req.body.ORDER_ID };
-                        Transaction.findOne(myquery, function (err, objForUpdate) {
+                        Transaction.findOne(myquery, function (err, orderData) {
 
-                            onTxn(objForUpdate);
+                            onTxn(orderData);
 
                         }, usingMultiDbOrm ? Transaction : undefined);
 
@@ -532,6 +563,10 @@ module.exports = function (app, callbacks) {
                                 onOrder(orderId)
                             })
                         }
+                        else if (config.open_money_url) {
+                            orderId = "pay_" + makeid(config.id_length || IDLEN)
+                            onOrder(orderId)
+                        }
 
 
 
@@ -585,7 +620,11 @@ module.exports = function (app, callbacks) {
                 return;
             }
             if (objForUpdate.status != ("INITIATED") && objForUpdate.status != ("TXN_PENDING")) {
-                res.send({ message: "Transaction already processed", status: objForUpdate.status, ORDERID: objForUpdate.orderId, TXNID: objForUpdate.TXNID, TXNID: req.body.TXNID })
+                objForUpdate.readonly = "readonly"
+                objForUpdate.action = config.homepage
+                res.render(vp + "result.hbs", objForUpdate);
+                console.log("Transaction already processed ", req.body.ORDERID)
+                // res.send({ message: "Transaction already processed", status: objForUpdate.status, ORDERID: objForUpdate.orderId, TXNID: objForUpdate.TXNID, TXNID: req.body.TXNID })
                 return;
             }
             if (req.body.status == "paid" && !req.body.STATUS) {
@@ -614,7 +653,7 @@ module.exports = function (app, callbacks) {
         }, usingMultiDbOrm ? Transaction : undefined)
     }
 
-    module.callback = (req, res) => {
+    module.callback = async (req, res) => {
 
         var result = false;
         let isCancelled = false;
@@ -649,6 +688,15 @@ module.exports = function (app, callbacks) {
                 isCancelled = true;
             }
         }
+        else if (config.open_money_url) {
+            let 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("Checksum Result => ", result, "\n");
         console.log("NodePayTMPG::Transaction => ", req.body.ORDERID, req.body.STATUS);
@@ -689,7 +737,7 @@ module.exports = function (app, callbacks) {
 
                     result = RazorPay.validateWebhookSignature(reqBody, req.headers['x-razorpay-signature'], config.SECRET)
                     req.signatureVerified = result;
-                    if (true) {
+                    if (result) {
                         if (event == events[0]) {
                             req.body.STATUS = "TXN_SUCCESS";
                         }
@@ -720,6 +768,9 @@ module.exports = function (app, callbacks) {
                 res.send({ message: "Unsupported event : " + req.body.event })
             }
         }
+        else if (config.open_money_url) {
+            openMoneyInstance.processWebhook(req, res, updateTransaction)
+        }
     }
 
     module.createTxn = (req, res) => {
@@ -743,6 +794,9 @@ module.exports = function (app, callbacks) {
                     let order = await razorPayInstance.orders.create(options);
                     id = order.id;
                 }
+                else if(config.open_money_url){
+                    id = "pay_" + makeid(config.id_length || IDLEN)
+                }
 
                 var txnTask = new Transaction({
                     id: id,
@@ -788,15 +842,18 @@ module.exports = function (app, callbacks) {
 
     module.status = (req, res) => {
 
+        if (!req.body.ORDER_ID && req.query.ORDER_ID) {
+            req.body.ORDER_ID = req.query.ORDER_ID
+        }
         var myquery = { orderId: req.body.ORDER_ID };
-        Transaction.findOne(myquery, async function (err, objForUpdate) {
+        Transaction.findOne(myquery, async function (err, orderData) {
 
 
             if (err) {
                 res.send(err)
                 return
             }
-            if (objForUpdate.status === "INITIATED") {
+            if (orderData.status === "INITIATED") {
 
                 var params = {}
                 params["MID"] = config.MID;
@@ -804,10 +861,10 @@ module.exports = function (app, callbacks) {
 
                 async function onStatusUpdate(paytmResponse) {
                     if (paytmResponse.TXNID.length > 4) {
-                        objForUpdate.status = paytmResponse.STATUS;
-                        objForUpdate.extra = JSON.stringify(paytmResponse);
+                        orderData.status = paytmResponse.STATUS;
+                        orderData.extra = JSON.stringify(paytmResponse);
 
-                        var newvalues = { $set: objForUpdate };
+                        var newvalues = { $set: orderData };
                         Transaction.updateOne(myquery, newvalues, function (err, saveRes) {
 
                             if (err) {
@@ -815,13 +872,13 @@ module.exports = function (app, callbacks) {
                             }
                             else {
                                 if (callbacks !== undefined)
-                                    callbacks.onFinish(req.body.ORDER_ID, objForUpdate);
+                                    callbacks.onFinish(req.body.ORDER_ID, orderData);
                                 res.send(paytmResponse)
                             }
                         });
                     }
                     else {
-                        res.send(objForUpdate)
+                        res.send(orderData)
 
                     }
                 }
@@ -864,13 +921,41 @@ module.exports = function (app, callbacks) {
                         onStatusUpdate(result)
                     }
                     else {
-                        res.send(objForUpdate);
+                        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)
+                        return res.send({ message: 'An unexpected error occured. No payment token exists' })
+                    }
+                    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
+                        onStatusUpdate(result)
+                    }
+                    else if (result.status == 'pending' || result.status == 'attempted') {
+                        result.STATUS = 'TXN_PENDING'
+                        result.TXNID = result.id
+                        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(objForUpdate);
+                res.send(orderData);
             }
 
 

package/app/views/init.hbs

@@ -60,8 +60,18 @@
     {{/if}}
 
     <li>
-      <button type="submit" class="button">{{BUTTON}}</button>
+      <button id="show_button" type="submit" class="button">{{BUTTON}}</button>
     </li>
+
+  <script>
+          var button = document.getElementById('show_button')
+          button.addEventListener('click',hideshow,false);
+
+          function hideshow() {
+              document.getElementById('show_button').style.display = 'none'; 
+          }   
+    </script>
+
   </ul>
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-paytmpg",
-  "version": "4.1.0",
+  "version": "5.1.3",
   "description": "Payment Gateway Integration using NodeJS",
   "main": "index.js",
   "scripts": {

package/public/layer_checkout.js

@@ -0,0 +1,38 @@
+function triggerLayer() {
+
+    Layer.checkout(
+        {
+            token: layer_params.payment_token_id,
+            accesskey: layer_params.accesskey,			
+        },
+        function (response) {
+            console.log(response)
+            if(response !== null || response.length > 0 ){
+
+                if(response.payment_id !== undefined){
+
+                    document.getElementById('layer_payment_id').value = response.payment_id;
+
+                }
+
+            }
+
+            document.layer_payment_int_form.submit();
+        },
+        function (err) {
+            alert(err.message);
+        }
+    );
+}
+/*
+var checkExist = setInterval(function() {
+	if (typeof Layer !== 'undefined') {
+		console.log('Layer Loaded...');
+		clearInterval(checkExist);
+		triggerLayer();
+	}
+	else {
+		console.log('Layer undefined...');
+	}
+}, 1000);
+*/