quickpos 1.0.911 → 1.0.913

package/lib/paytabs.js

@@ -0,0 +1,145 @@
+const axios = require('axios');
+const crypto = require('crypto');
+
+class PayTabsClient {
+    constructor(config) {
+        const requiredFields = ['profileId', 'serverKey'];
+        for (let field of requiredFields) {
+            if (!config[field]) throw new Error(`Missing required field: ${field}`);
+        }
+
+        this.profileId = config.profileId;
+        this.serverKey = config.serverKey;
+        this.region = config.region || 'ARE'; // ARE, SAU, OMN, JOR, EGY, etc.
+        
+        const regionUrls = {
+            'ARE': 'https://secure.paytabs.com',
+            'SAU': 'https://secure.paytabs.sa',
+            'OMN': 'https://secure-oman.paytabs.com',
+            'JOR': 'https://secure-jordan.paytabs.com',
+            'EGY': 'https://secure-egypt.paytabs.com',
+            'global': 'https://secure-global.paytabs.com'
+        };
+
+        this.baseURL = regionUrls[this.region] || regionUrls['global'];
+
+        this.client = axios.create({
+            baseURL: this.baseURL,
+            headers: {
+                'Content-Type': 'application/json',
+                'Authorization': this.serverKey
+            }
+        });
+    }
+
+    async createPayment(options) {
+        try {
+            const orderId = options.orderId || `ORDER-${Date.now()}`;
+            
+            const paymentData = {
+                profile_id: this.profileId,
+                tran_type: options.tranType || 'sale',
+                tran_class: options.tranClass || 'ecom',
+                cart_id: orderId,
+                cart_description: options.description || options.name || 'Payment',
+                cart_currency: options.currency || 'AED',
+                cart_amount: parseFloat(options.amount).toFixed(2),
+                callback: options.callbackUrl || options.callback_link,
+                return: options.successUrl || options.callback_link,
+                customer_details: {
+                    name: options.name || options.customerName || '',
+                    email: options.email || '',
+                    phone: options.phone || '',
+                    street1: options.address || '',
+                    city: options.city || '',
+                    state: options.state || '',
+                    country: options.country || 'AE',
+                    zip: options.zip || ''
+                },
+                hide_shipping: options.hideShipping !== false
+            };
+
+            const response = await this.client.post('/payment/request', paymentData);
+
+            return {
+                status: 'success',
+                data: {
+                    transactionRef: response.data.tran_ref,
+                    url: response.data.redirect_url,
+                    orderId: orderId,
+                    amount: paymentData.cart_amount,
+                    currency: paymentData.cart_currency
+                }
+            };
+        } catch (error) {
+            throw new Error(`Payment creation error: ${error.response?.data?.message || error.message}`);
+        }
+    }
+
+    async handleCallback(callbackData) {
+        try {
+            const transactionRef = callbackData.tran_ref || callbackData.tranRef;
+            
+            if (!transactionRef) {
+                throw new Error('Transaction reference not found in callback data');
+            }
+
+            // Verify payment
+            const payment = await this.verifyPayment(transactionRef);
+
+            // Status mapping
+            const statusMapping = {
+                'A': 'success', // Authorized/Approved
+                'H': 'pending', // On Hold
+                'P': 'pending', // Pending
+                'V': 'pending', // Voided
+                'E': 'failed',  // Error
+                'D': 'failed'   // Declined
+            };
+
+            return {
+                status: statusMapping[payment.payment_result?.response_status] || 'unknown',
+                orderId: payment.cart_id,
+                transactionRef: payment.tran_ref,
+                amount: parseFloat(payment.cart_amount),
+                currency: payment.cart_currency,
+                paymentStatus: payment.payment_result?.response_status,
+                responseCode: payment.payment_result?.response_code,
+                responseMessage: payment.payment_result?.response_message
+            };
+        } catch (error) {
+            throw new Error(`Error in PayTabs callback handling: ${error.message}`);
+        }
+    }
+
+    async verifyPayment(transactionRef) {
+        try {
+            const response = await this.client.post('/payment/query', {
+                profile_id: this.profileId,
+                tran_ref: transactionRef
+            });
+
+            return response.data;
+        } catch (error) {
+            throw new Error(`Error verifying payment: ${error.response?.data?.message || error.message}`);
+        }
+    }
+
+    async refundPayment(transactionRef, options = {}) {
+        try {
+            const response = await this.client.post('/payment/refund', {
+                profile_id: this.profileId,
+                tran_ref: transactionRef,
+                cart_amount: options.amount,
+                cart_description: options.description || 'Refund',
+                cart_id: options.orderId
+            });
+
+            return response.data;
+        } catch (error) {
+            throw new Error(`Error processing refund: ${error.response?.data?.message || error.message}`);
+        }
+    }
+}
+
+module.exports = PayTabsClient;

package/lib/paytm.js

@@ -0,0 +1,253 @@
+const axios = require('axios');
+const crypto = require('crypto');
+
+class PaytmClient {
+    constructor(config) {
+        const requiredFields = ['merchantId', 'merchantKey', 'websiteName'];
+        for (let field of requiredFields) {
+            if (!config[field]) throw new Error(`Missing required field: ${field}`);
+        }
+
+        this.merchantId = config.merchantId;
+        this.merchantKey = config.merchantKey;
+        this.websiteName = config.websiteName;
+        this.industryType = config.industryType || 'Retail';
+        this.channelId = config.channelId || 'WEB';
+        this.isSandbox = config.sandbox || false;
+
+        this.URL = this.isSandbox
+            ? 'https://securegw-stage.paytm.in'
+            : 'https://securegw.paytm.in';
+
+        this.client = axios.create({
+            baseURL: this.URL,
+            headers: {
+                'Content-Type': 'application/json'
+            }
+        });
+
+        this.client.interceptors.response.use(response => {
+            return response;
+        }, error => {
+            if (error.response) {
+                throw new Error(`Paytm API error: ${error.response.data.message || error.message}`);
+            }
+            throw new Error(`Paytm API error: ${error.message}`);
+        });
+    }
+
+    generateChecksum(params, key) {
+        const data = JSON.stringify(params);
+        const salt = crypto.randomBytes(4).toString('hex');
+        const checksum = crypto
+            .createHash('sha256')
+            .update(data + salt)
+            .digest('hex');
+        
+        return checksum + salt;
+    }
+
+    verifyChecksum(params, key, checksumReceived) {
+        const data = JSON.stringify(params);
+        const salt = checksumReceived.substr(checksumReceived.length - 8);
+        const checksum = crypto
+            .createHash('sha256')
+            .update(data + salt)
+            .digest('hex');
+        
+        return (checksum + salt) === checksumReceived;
+    }
+
+    async createPayment(options) {
+        try {
+            const orderId = options.orderId || `ORDER-${Date.now()}`;
+            const customerId = options.customerId || `CUST-${Date.now()}`;
+
+            const paytmParams = {
+                body: {
+                    requestType: 'Payment',
+                    mid: this.merchantId,
+                    websiteName: this.websiteName,
+                    orderId: orderId,
+                    txnAmount: {
+                        value: parseFloat(options.amount).toFixed(2),
+                        currency: options.currency || 'INR'
+                    },
+                    userInfo: {
+                        custId: customerId,
+                        email: options.email || '',
+                        mobile: options.mobile || options.phone || ''
+                    },
+                    callbackUrl: options.callbackUrl || options.callback_link
+                }
+            };
+
+            // Generate checksum
+            const checksum = this.generateChecksum(paytmParams.body, this.merchantKey);
+
+            const requestData = {
+                ...paytmParams,
+                head: {
+                    signature: checksum
+                }
+            };
+
+            const response = await this.client.post('/theia/api/v1/initiateTransaction?mid=' + this.merchantId + '&orderId=' + orderId, requestData);
+
+            if (response.data.body.resultInfo.resultStatus === 'S') {
+                const txnToken = response.data.body.txnToken;
+                
+                return {
+                    status: 'success',
+                    data: {
+                        txnToken: txnToken,
+                        orderId: orderId,
+                        url: `${this.URL}/theia/api/v1/showPaymentPage?mid=${this.merchantId}&orderId=${orderId}`,
+                        amount: options.amount
+                    }
+                };
+            } else {
+                throw new Error(response.data.body.resultInfo.resultMsg || 'Payment creation failed');
+            }
+        } catch (error) {
+            throw new Error(`Payment creation error: ${error.message}`);
+        }
+    }
+
+    async getTransactionStatus(orderId) {
+        try {
+            const paytmParams = {
+                body: {
+                    mid: this.merchantId,
+                    orderId: orderId
+                }
+            };
+
+            const checksum = this.generateChecksum(paytmParams.body, this.merchantKey);
+
+            const requestData = {
+                ...paytmParams,
+                head: {
+                    signature: checksum
+                }
+            };
+
+            const response = await this.client.post('/v3/order/status', requestData);
+            return response.data;
+        } catch (error) {
+            throw new Error(`Transaction status error: ${error.message}`);
+        }
+    }
+
+    async handleCallback(callbackData) {
+        try {
+            const verification = await this.verifyCallback(callbackData);
+            
+            if (!verification.status) {
+                throw new Error(verification.error.message);
+            }
+
+            const data = verification.data;
+            
+            // Status mapping
+            const statusMapping = {
+                'TXN_SUCCESS': 'success',
+                'TXN_FAILURE': 'failed',
+                'PENDING': 'pending'
+            };
+
+            return {
+                status: statusMapping[data.STATUS] || 'unknown',
+                orderId: data.ORDERID,
+                txnId: data.TXNID,
+                txnAmount: parseFloat(data.TXNAMOUNT),
+                currency: data.CURRENCY || 'INR',
+                bankTxnId: data.BANKTXNID,
+                paymentMode: data.PAYMENTMODE,
+                bankName: data.BANKNAME,
+                txnDate: data.TXNDATE,
+                gatewayName: data.GATEWAYNAME,
+                respCode: data.RESPCODE,
+                respMsg: data.RESPMSG,
+                paymentStatus: data.STATUS
+            };
+        } catch (error) {
+            throw new Error(`Error in Paytm callback handling: ${error.message}`);
+        }
+    }
+
+    async verifyCallback(data) {
+        try {
+            const checksumReceived = data.CHECKSUMHASH;
+            delete data.CHECKSUMHASH;
+
+            const isValidChecksum = this.verifyChecksum(data, this.merchantKey, checksumReceived);
+
+            if (!isValidChecksum) {
+                return {
+                    status: false,
+                    error: {
+                        code: 401,
+                        message: 'Invalid checksum'
+                    }
+                };
+            }
+
+            if (data.STATUS === 'TXN_FAILURE') {
+                return {
+                    status: false,
+                    error: {
+                        code: 400,
+                        message: data.RESPMSG || 'Transaction failed'
+                    }
+                };
+            }
+
+            return {
+                status: true,
+                data: data
+            };
+        } catch (error) {
+            return {
+                status: false,
+                error: {
+                    code: 500,
+                    message: error.message
+                }
+            };
+        }
+    }
+
+    async refundTransaction(orderId, refundAmount, txnId) {
+        try {
+            const refId = `REFUND-${Date.now()}`;
+            
+            const paytmParams = {
+                body: {
+                    mid: this.merchantId,
+                    orderId: orderId,
+                    txnId: txnId,
+                    refId: refId,
+                    refundAmount: parseFloat(refundAmount).toFixed(2),
+                    txnType: 'REFUND'
+                }
+            };
+
+            const checksum = this.generateChecksum(paytmParams.body, this.merchantKey);
+
+            const requestData = {
+                ...paytmParams,
+                head: {
+                    signature: checksum
+                }
+            };
+
+            const response = await this.client.post('/refund/apply', requestData);
+            return response.data;
+        } catch (error) {
+            throw new Error(`Refund transaction error: ${error.message}`);
+        }
+    }
+}
+
+module.exports = PaytmClient;

package/lib/payuindia.js

@@ -0,0 +1,162 @@
+const axios = require('axios');
+const crypto = require('crypto');
+
+class PayUIndiaClient {
+    constructor(config) {
+        const requiredFields = ['merchantKey', 'salt'];
+        for (let field of requiredFields) {
+            if (!config[field]) throw new Error(`Missing required field: ${field}`);
+        }
+
+        this.merchantKey = config.merchantKey;
+        this.salt = config.salt;
+        this.baseURL = config.sandbox 
+            ? 'https://test.payu.in' 
+            : 'https://secure.payu.in';
+
+        this.client = axios.create({
+            baseURL: this.baseURL,
+            headers: {
+                'Content-Type': 'application/x-www-form-urlencoded'
+            }
+        });
+    }
+
+    generateHash(params) {
+        const hashString = `${this.merchantKey}|${params.txnid}|${params.amount}|${params.productinfo}|${params.firstname}|${params.email}|||||||||||${this.salt}`;
+        return crypto.createHash('sha512').update(hashString).digest('hex');
+    }
+
+    generateVerificationHash(params) {
+        const hashString = `${this.salt}|${params.status}|||||||||||${params.email}|${params.firstname}|${params.productinfo}|${params.amount}|${params.txnid}|${this.merchantKey}`;
+        return crypto.createHash('sha512').update(hashString).digest('hex');
+    }
+
+    async createPayment(options) {
+        try {
+            const txnid = options.orderId || `TXN${Date.now()}`;
+            const amount = parseFloat(options.amount).toFixed(2);
+            
+            const params = {
+                key: this.merchantKey,
+                txnid: txnid,
+                amount: amount,
+                productinfo: options.productInfo || options.name || 'Payment',
+                firstname: options.firstname || options.name || '',
+                email: options.email || '',
+                phone: options.phone || '',
+                surl: options.successUrl || options.callback_link,
+                furl: options.failUrl || options.callback_link,
+                udf1: options.udf1 || '',
+                udf2: options.udf2 || '',
+                udf3: options.udf3 || '',
+                udf4: options.udf4 || '',
+                udf5: options.udf5 || ''
+            };
+
+            params.hash = this.generateHash(params);
+
+            // Create payment URL
+            const formParams = new URLSearchParams(params);
+            const paymentUrl = `${this.baseURL}/_payment`;
+
+            return {
+                status: 'success',
+                data: {
+                    url: paymentUrl,
+                    orderId: txnid,
+                    amount: amount,
+                    params: params,
+                    method: 'POST'
+                }
+            };
+        } catch (error) {
+            throw new Error(`Payment creation error: ${error.message}`);
+        }
+    }
+
+    async handleCallback(callbackData) {
+        try {
+            const verification = await this.verifyCallback(callbackData);
+            
+            if (!verification.status) {
+                throw new Error(verification.error.message);
+            }
+
+            // Status mapping
+            const statusMapping = {
+                'success': 'success',
+                'pending': 'pending',
+                'failure': 'failed',
+                'bounced': 'failed',
+                'cancelled': 'failed'
+            };
+
+            return {
+                status: statusMapping[callbackData.status] || 'unknown',
+                orderId: callbackData.txnid,
+                transactionId: callbackData.mihpayid,
+                amount: parseFloat(callbackData.amount),
+                currency: 'INR',
+                paymentStatus: callbackData.status,
+                paymentMode: callbackData.mode,
+                bankRefNum: callbackData.bank_ref_num,
+                cardNumber: callbackData.cardnum
+            };
+        } catch (error) {
+            throw new Error(`Error in PayU India callback handling: ${error.message}`);
+        }
+    }
+
+    async verifyCallback(data) {
+        try {
+            const receivedHash = data.hash;
+            const expectedHash = this.generateVerificationHash(data);
+
+            if (receivedHash !== expectedHash) {
+                return {
+                    status: false,
+                    error: {
+                        code: 401,
+                        message: 'Invalid hash'
+                    }
+                };
+            }
+
+            return {
+                status: true,
+                data: data
+            };
+        } catch (error) {
+            return {
+                status: false,
+                error: {
+                    code: 500,
+                    message: error.message
+                }
+            };
+        }
+    }
+
+    async verifyPayment(txnid) {
+        try {
+            const command = 'verify_payment';
+            const hashString = `${this.merchantKey}|${command}|${txnid}|${this.salt}`;
+            const hash = crypto.createHash('sha512').update(hashString).digest('hex');
+
+            const params = new URLSearchParams({
+                key: this.merchantKey,
+                command: command,
+                var1: txnid,
+                hash: hash
+            });
+
+            const response = await this.client.post('/merchant/postservice.php?form=2', params);
+            return response.data;
+        } catch (error) {
+            throw new Error(`Error verifying payment: ${error.response?.data || error.message}`);
+        }
+    }
+}
+
+module.exports = PayUIndiaClient;