quickpos 1.0.910 → 1.0.912

package/lib/senangpay.js

@@ -0,0 +1,130 @@
+const axios = require('axios');
+const crypto = require('crypto');
+
+class SenangPayClient {
+    constructor(config) {
+        const requiredFields = ['merchantId', 'secretKey'];
+        for (let field of requiredFields) {
+            if (!config[field]) throw new Error(`Missing required field: ${field}`);
+        }
+
+        this.merchantId = config.merchantId;
+        this.secretKey = config.secretKey;
+        this.baseURL = config.sandbox 
+            ? 'https://sandbox.senangpay.my/payment' 
+            : 'https://app.senangpay.my/payment';
+    }
+
+    generateHash(detail, amount, orderId) {
+        const hashString = this.secretKey + detail + amount + orderId;
+        return crypto.createHash('md5').update(hashString).digest('hex');
+    }
+
+    async createPayment(options) {
+        try {
+            const orderId = options.orderId || `ORDER-${Date.now()}`;
+            const amount = parseFloat(options.amount).toFixed(2);
+            const detail = options.description || options.name || 'Payment';
+            
+            const hash = this.generateHash(detail, amount, orderId);
+
+            const paymentData = {
+                detail: detail,
+                amount: amount,
+                order_id: orderId,
+                name: options.name || options.customerName || '',
+                email: options.email || '',
+                phone: options.phone || '',
+                hash: hash
+            };
+
+            // Create payment URL
+            const params = new URLSearchParams(paymentData);
+            const paymentUrl = `${this.baseURL}/${this.merchantId}?${params.toString()}`;
+
+            return {
+                status: 'success',
+                data: {
+                    url: paymentUrl,
+                    orderId: orderId,
+                    amount: amount,
+                    currency: 'MYR',
+                    hash: hash
+                }
+            };
+        } 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 = {
+                '1': 'success',  // Success
+                '0': 'failed'    // Failed
+            };
+
+            return {
+                status: statusMapping[callbackData.status_id] || 'unknown',
+                orderId: callbackData.order_id,
+                transactionId: callbackData.transaction_id,
+                amount: parseFloat(callbackData.amount),
+                currency: 'MYR',
+                paymentStatus: callbackData.status_id === '1' ? 'completed' : 'failed',
+                message: callbackData.msg
+            };
+        } catch (error) {
+            throw new Error(`Error in SenangPay callback handling: ${error.message}`);
+        }
+    }
+
+    async verifyCallback(data) {
+        try {
+            const receivedHash = data.hash;
+            const hashString = this.secretKey + data.status_id + data.order_id + data.transaction_id + data.msg;
+            const expectedHash = crypto.createHash('md5').update(hashString).digest('hex');
+
+            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 getTransactionStatus(orderId) {
+        try {
+            // SenangPay doesn't have a standard API for checking transaction status
+            // This would need to be implemented based on their specific API if available
+            throw new Error('Transaction status check not available in standard SenangPay integration');
+        } catch (error) {
+            throw new Error(`Error getting transaction status: ${error.message}`);
+        }
+    }
+}
+
+module.exports = SenangPayClient;

package/lib/shurjopay.js

@@ -0,0 +1,159 @@
+const axios = require('axios');
+const crypto = require('crypto');
+
+class ShurjoPayClient {
+    constructor(config) {
+        const requiredFields = ['username', 'password', 'prefix'];
+        for (let field of requiredFields) {
+            if (!config[field]) throw new Error(`Missing required field: ${field}`);
+        }
+
+        this.username = config.username;
+        this.password = config.password;
+        this.prefix = config.prefix;
+        this.baseURL = config.sandbox 
+            ? 'https://sandbox.shurjopayment.com' 
+            : 'https://engine.shurjopayment.com';
+        
+        this.token = null;
+
+        this.client = axios.create({
+            baseURL: this.baseURL,
+            headers: {
+                'Content-Type': 'application/json'
+            }
+        });
+    }
+
+    async authenticate() {
+        try {
+            const response = await this.client.post('/api/get_token', {
+                username: this.username,
+                password: this.password
+            });
+
+            if (response.data.token) {
+                this.token = response.data.token;
+                this.client.defaults.headers['Authorization'] = `Bearer ${this.token}`;
+                return this.token;
+            } else {
+                throw new Error('Authentication failed');
+            }
+        } catch (error) {
+            throw new Error(`Authentication error: ${error.response?.data?.message || error.message}`);
+        }
+    }
+
+    async createPayment(options) {
+        try {
+            if (!this.token) {
+                await this.authenticate();
+            }
+
+            const orderId = options.orderId || `${this.prefix}${Date.now()}`;
+            
+            const paymentData = {
+                prefix: this.prefix,
+                token: this.token,
+                return_url: options.successUrl || options.callback_link,
+                cancel_url: options.failUrl || options.callback_link,
+                store_id: this.prefix,
+                amount: parseFloat(options.amount),
+                order_id: orderId,
+                currency: options.currency || 'BDT',
+                customer_name: options.name || options.customerName || '',
+                customer_address: options.address || '',
+                customer_city: options.city || 'Dhaka',
+                customer_phone: options.phone || '',
+                customer_email: options.email || '',
+                client_ip: options.clientIp || '127.0.0.1',
+                intent: 'sale',
+                discsount_amount: options.discount || 0,
+                disc_percent: options.discountPercent || 0
+            };
+
+            const response = await this.client.post('/api/secret-pay', paymentData);
+
+            if (response.data.checkout_url) {
+                return {
+                    status: 'success',
+                    data: {
+                        url: response.data.checkout_url,
+                        orderId: orderId,
+                        amount: paymentData.amount,
+                        currency: paymentData.currency,
+                        sp_order_id: response.data.sp_order_id
+                    }
+                };
+            } else {
+                throw new Error(response.data.message || 'Payment creation failed');
+            }
+        } catch (error) {
+            throw new Error(`Payment creation error: ${error.response?.data?.message || error.message}`);
+        }
+    }
+
+    async handleCallback(callbackData) {
+        try {
+            const orderId = callbackData.order_id;
+            
+            if (!orderId) {
+                throw new Error('Order ID not found in callback data');
+            }
+
+            // Verify payment
+            const verification = await this.verifyPayment(orderId);
+
+            // Status mapping
+            const statusMapping = {
+                'success': 'success',
+                'Success': 'success',
+                'failed': 'failed',
+                'Failed': 'failed',
+                'pending': 'pending',
+                'Pending': 'pending',
+                'cancel': 'failed',
+                'Cancel': 'failed'
+            };
+
+            return {
+                status: statusMapping[verification[0].sp_status] || 'unknown',
+                orderId: verification[0].order_id,
+                transactionId: verification[0].bank_trx_id,
+                amount: parseFloat(verification[0].amount),
+                currency: verification[0].currency,
+                paymentStatus: verification[0].sp_status,
+                method: verification[0].method,
+                bankStatus: verification[0].bank_status
+            };
+        } catch (error) {
+            throw new Error(`Error in ShurjoPay callback handling: ${error.message}`);
+        }
+    }
+
+    async verifyPayment(orderId) {
+        try {
+            if (!this.token) {
+                await this.authenticate();
+            }
+
+            const response = await this.client.post('/api/verification', {
+                order_id: orderId
+            });
+
+            return response.data;
+        } catch (error) {
+            throw new Error(`Error verifying payment: ${error.response?.data?.message || error.message}`);
+        }
+    }
+
+    async getPaymentStatus(orderId) {
+        try {
+            return await this.verifyPayment(orderId);
+        } catch (error) {
+            throw new Error(`Error getting payment status: ${error.message}`);
+        }
+    }
+}
+
+module.exports = ShurjoPayClient;

package/lib/toyyibpay.js

@@ -0,0 +1,151 @@
+const axios = require('axios');
+const crypto = require('crypto');
+
+class ToyyibPayClient {
+    constructor(config) {
+        const requiredFields = ['secretKey', 'categoryCode'];
+        for (let field of requiredFields) {
+            if (!config[field]) throw new Error(`Missing required field: ${field}`);
+        }
+
+        this.secretKey = config.secretKey;
+        this.categoryCode = config.categoryCode;
+        this.URL = 'https://dev.toyyibpay.com';
+
+        this.client = axios.create({
+            baseURL: this.URL,
+            headers: {
+                'Content-Type': 'application/x-www-form-urlencoded'
+            }
+        });
+
+        this.client.interceptors.response.use(response => {
+            return response;
+        }, error => {
+            if (error.response) {
+                throw new Error(`ToyyibPay API error: ${error.response.data.message || error.message}`);
+            }
+            throw new Error(`ToyyibPay API error: ${error.message}`);
+        });
+    }
+
+    async createPayment(options) {
+        try {
+            const params = new URLSearchParams();
+            params.append('userSecretKey', this.secretKey);
+            params.append('categoryCode', this.categoryCode);
+            params.append('billName', options.billName || options.name || 'Bill');
+            params.append('billDescription', options.billDescription || options.description || 'Payment');
+            params.append('billPriceSetting', '1');
+            params.append('billPayorInfo', '1');
+            params.append('billAmount', Math.round(parseFloat(options.amount) * 100));
+            params.append('billReturnUrl', options.returnUrl || options.callback_link);
+            params.append('billCallbackUrl', options.callbackUrl || options.callback_link);
+            params.append('billExternalReferenceNo', options.referenceNo || options.orderId || `ORDER-${Date.now()}`);
+            params.append('billTo', options.billTo || options.customerName || options.name || 'Customer');
+            params.append('billEmail', options.billEmail || options.email);
+            params.append('billPhone', options.billPhone || options.phone || '60123456789');
+            params.append('billSplitPayment', '0');
+            params.append('billSplitPaymentArgs', '');
+            params.append('billPaymentChannel', options.paymentChannel || '0');
+            params.append('billContentEmail', options.contentEmail || 'Thank you for your payment');
+            
+            if (options.billChargeToCustomer) {
+                params.append('billChargeToCustomer', options.billChargeToCustomer);
+            }
+
+            const response = await this.client.post('/index.php/api/createBill', params);
+
+            if (response.data[0].BillCode) {
+                return {
+                    status: 'success',
+                    data: {
+                        billCode: response.data[0].BillCode,
+                        url: `${this.URL}/${response.data[0].BillCode}`,
+                        referenceNo: options.referenceNo || options.orderId
+                    }
+                };
+            } else {
+                throw new Error(response.data[0].error || 'Payment creation failed');
+            }
+        } catch (error) {
+            throw new Error(`Payment creation error: ${error.message}`);
+        }
+    }
+
+    async getBillTransactions(billCode) {
+        try {
+            const params = new URLSearchParams();
+            params.append('billCode', billCode);
+
+            const response = await this.client.post('/index.php/api/getBillTransactions', params);
+            return response.data;
+        } catch (error) {
+            throw new Error(`Bill transactions 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: 1 = success, 2 = pending, 3 = failed
+            const statusMapping = {
+                '1': 'success',
+                '2': 'pending',
+                '3': 'failed'
+            };
+
+            return {
+                status: statusMapping[data.status_id] || 'unknown',
+                billCode: data.billcode,
+                orderId: data.order_id || data.billExternalReferenceNo,
+                amount: parseFloat(data.amount) / 100,
+                transactionId: data.transaction_id,
+                paymentStatus: data.status_id,
+                transactionTime: data.transaction_time,
+                payerName: data.billpayorname,
+                payerEmail: data.billpayoremail,
+                payerPhone: data.billpayorphone
+            };
+        } catch (error) {
+            throw new Error(`Error in ToyyibPay callback handling: ${error.message}`);
+        }
+    }
+
+    async verifyCallback(data) {
+        try {
+            // ToyyibPay uses hash verification
+            if (data.status_id === '3') {
+                return {
+                    status: false,
+                    error: {
+                        code: 400,
+                        message: 'Payment failed'
+                    }
+                };
+            }
+
+            return {
+                status: true,
+                data: data
+            };
+        } catch (error) {
+            return {
+                status: false,
+                error: {
+                    code: 500,
+                    message: error.message
+                }
+            };
+        }
+    }
+}
+
+module.exports = ToyyibPayClient;

package/lib/tripay.js

@@ -0,0 +1,220 @@
+const axios = require('axios');
+const crypto = require('crypto');
+
+class TripayClient {
+    constructor(config) {
+        const requiredFields = ['apiKey', 'privateKey', 'merchantCode'];
+        for (let field of requiredFields) {
+            if (!config[field]) throw new Error(`Missing required field: ${field}`);
+        }
+
+        this.apiKey = config.apiKey;
+        this.privateKey = config.privateKey;
+        this.merchantCode = config.merchantCode;
+        this.isProduction = config.isProduction || false;
+
+        this.URL = this.isProduction 
+            ? 'https://tripay.co.id/api' 
+            : 'https://tripay.co.id/api-sandbox';
+
+        this.client = axios.create({
+            baseURL: this.URL,
+            headers: {
+                'Authorization': `Bearer ${this.apiKey}`,
+                'Content-Type': 'application/json'
+            }
+        });
+
+        this.client.interceptors.response.use(response => {
+            return response;
+        }, error => {
+            if (error.response) {
+                throw new Error(`Tripay API error: ${error.response.data.message || error.message}`);
+            }
+            throw new Error(`Tripay API error: ${error.message}`);
+        });
+    }
+
+    async getPaymentChannels() {
+        try {
+            const response = await this.client.get('/merchant/payment-channel');
+            return response.data;
+        } catch (error) {
+            throw new Error(`Payment channels error: ${error.message}`);
+        }
+    }
+
+    async createPayment(options) {
+        try {
+            const merchantRef = options.merchantRef || options.orderId || `ORDER-${Date.now()}`;
+            const amount = parseInt(options.amount);
+
+            // Generate signature
+            const signature = crypto
+                .createHmac('sha256', this.privateKey)
+                .update(this.merchantCode + merchantRef + amount)
+                .digest('hex');
+
+            const requestData = {
+                method: options.paymentMethod || 'BRIVA',
+                merchant_ref: merchantRef,
+                amount: amount,
+                customer_name: options.customerName || options.name || 'Customer',
+                customer_email: options.customerEmail || options.email,
+                customer_phone: options.customerPhone || options.phone || '08123456789',
+                order_items: options.orderItems || [{
+                    sku: 'ITEM-001',
+                    name: options.itemName || options.name || 'Product',
+                    price: amount,
+                    quantity: 1
+                }],
+                callback_url: options.callbackUrl || options.callback_link,
+                return_url: options.returnUrl || options.callbackUrl || options.callback_link,
+                expired_time: options.expiredTime || (Math.floor(Date.now() / 1000) + (24 * 60 * 60)),
+                signature: signature
+            };
+
+            const response = await this.client.post('/transaction/create', requestData);
+
+            if (!response.data.success) {
+                throw new Error(response.data.message || 'Payment creation failed');
+            }
+
+            return {
+                status: 'success',
+                data: {
+                    reference: response.data.data.reference,
+                    merchantRef: response.data.data.merchant_ref,
+                    paymentUrl: response.data.data.checkout_url,
+                    qrUrl: response.data.data.qr_url,
+                    amount: response.data.data.amount,
+                    fee: response.data.data.total_fee,
+                    totalAmount: response.data.data.amount_received,
+                    expiredTime: response.data.data.expired_time,
+                    paymentMethod: response.data.data.payment_method,
+                    paymentName: response.data.data.payment_name,
+                    instructions: response.data.data.instructions
+                }
+            };
+        } catch (error) {
+            throw new Error(`Payment creation error: ${error.message}`);
+        }
+    }
+
+    async getTransactionDetail(reference) {
+        try {
+            const response = await this.client.get(`/transaction/detail?reference=${reference}`);
+            
+            if (!response.data.success) {
+                throw new Error(response.data.message || 'Failed to get transaction detail');
+            }
+
+            return response.data.data;
+        } catch (error) {
+            throw new Error(`Transaction detail 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 = {
+                'PAID': 'success',
+                'UNPAID': 'pending',
+                'EXPIRED': 'expired',
+                'FAILED': 'failed',
+                'REFUND': 'refunded'
+            };
+
+            return {
+                status: statusMapping[data.status] || 'unknown',
+                reference: data.reference,
+                merchantRef: data.merchant_ref,
+                orderId: data.merchant_ref,
+                amount: parseInt(data.amount),
+                totalAmount: parseInt(data.amount_received),
+                fee: parseInt(data.total_fee),
+                paymentMethod: data.payment_method,
+                paymentName: data.payment_name,
+                customerName: data.customer_name,
+                customerEmail: data.customer_email,
+                customerPhone: data.customer_phone,
+                paymentStatus: data.status,
+                paidAt: data.paid_at
+            };
+        } catch (error) {
+            throw new Error(`Error in Tripay callback handling: ${error.message}`);
+        }
+    }
+
+    async verifyCallback(data) {
+        try {
+            const callbackSignature = data.signature || '';
+            const privateKey = this.privateKey;
+
+            // Calculate signature
+            const json = JSON.stringify(data);
+            const expectedSignature = crypto
+                .createHmac('sha256', privateKey)
+                .update(json)
+                .digest('hex');
+
+            if (callbackSignature !== expectedSignature) {
+                return {
+                    status: false,
+                    error: {
+                        code: 401,
+                        message: 'Invalid callback signature'
+                    }
+                };
+            }
+
+            if (data.status === 'FAILED') {
+                return {
+                    status: false,
+                    error: {
+                        code: 400,
+                        message: 'Payment failed'
+                    }
+                };
+            }
+
+            return {
+                status: true,
+                data: data
+            };
+        } catch (error) {
+            return {
+                status: false,
+                error: {
+                    code: 500,
+                    message: error.message
+                }
+            };
+        }
+    }
+
+    async getFeeCalculator(amount, code) {
+        try {
+            const response = await this.client.get(`/merchant/fee-calculator?amount=${amount}&code=${code}`);
+            
+            if (!response.data.success) {
+                throw new Error(response.data.message || 'Failed to calculate fee');
+            }
+
+            return response.data.data;
+        } catch (error) {
+            throw new Error(`Fee calculator error: ${error.message}`);
+        }
+    }
+}
+
+module.exports = TripayClient;