quickpos 1.0.910 → 1.0.912

package/lib/perfectmoney.js

@@ -0,0 +1,143 @@
+const axios = require('axios');
+const crypto = require('crypto');
+
+class PerfectMoneyClient {
+    constructor(config) {
+        const requiredFields = ['accountId', 'passPhrase'];
+        for (let field of requiredFields) {
+            if (!config[field]) throw new Error(`Missing required field: ${field}`);
+        }
+
+        this.accountId = config.accountId;
+        this.passPhrase = config.passPhrase;
+        this.alternatePassPhrase = config.alternatePassPhrase || this.passPhrase;
+        this.payeeAccount = config.payeeAccount || this.accountId;
+        this.baseURL = 'https://perfectmoney.com/api';
+    }
+
+    generateHash(data) {
+        const hashString = `${data.PAYMENT_ID}:${data.PAYEE_ACCOUNT}:${data.PAYMENT_AMOUNT}:${data.PAYMENT_UNITS}:${data.PAYMENT_BATCH_NUM}:${data.PAYER_ACCOUNT}:${this.alternatePassPhrase}:${data.TIMESTAMPGMT}`;
+        
+        return crypto
+            .createHash('md5')
+            .update(hashString)
+            .digest('hex')
+            .toUpperCase();
+    }
+
+    async createPayment(options) {
+        try {
+            const orderId = options.orderId || `ORDER-${Date.now()}`;
+            
+            const paymentData = {
+                PAYEE_ACCOUNT: this.payeeAccount,
+                PAYEE_NAME: options.payeeName || 'Merchant',
+                PAYMENT_ID: orderId,
+                PAYMENT_AMOUNT: parseFloat(options.amount).toFixed(2),
+                PAYMENT_UNITS: options.currency || 'USD',
+                STATUS_URL: options.callbackUrl || options.callback_link,
+                PAYMENT_URL: options.successUrl || options.callback_link,
+                PAYMENT_URL_METHOD: 'GET',
+                NOPAYMENT_URL: options.failUrl || options.callback_link,
+                NOPAYMENT_URL_METHOD: 'GET',
+                SUGGESTED_MEMO: options.description || options.name || 'Payment',
+                BAGGAGE_FIELDS: `email=${options.email || ''}&name=${options.name || ''}`
+            };
+
+            // Create payment URL
+            const params = new URLSearchParams(paymentData);
+            const paymentUrl = `https://perfectmoney.com/api/step1.asp?${params.toString()}`;
+
+            return {
+                status: 'success',
+                data: {
+                    url: paymentUrl,
+                    orderId: orderId,
+                    amount: paymentData.PAYMENT_AMOUNT,
+                    currency: paymentData.PAYMENT_UNITS,
+                    payeeAccount: this.payeeAccount
+                }
+            };
+        } 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);
+            }
+
+            return {
+                status: 'success',
+                orderId: callbackData.PAYMENT_ID,
+                transactionId: callbackData.PAYMENT_BATCH_NUM,
+                amount: parseFloat(callbackData.PAYMENT_AMOUNT),
+                currency: callbackData.PAYMENT_UNITS,
+                paymentStatus: 'completed',
+                payerAccount: callbackData.PAYER_ACCOUNT,
+                timestampGMT: callbackData.TIMESTAMPGMT
+            };
+        } catch (error) {
+            throw new Error(`Error in Perfect Money callback handling: ${error.message}`);
+        }
+    }
+
+    async verifyCallback(data) {
+        try {
+            const receivedHash = data.V2_HASH;
+            const expectedHash = this.generateHash(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 getBalance(accountId, password) {
+        try {
+            const response = await axios.get('https://perfectmoney.com/acct/balance.asp', {
+                params: {
+                    AccountID: accountId || this.accountId,
+                    PassPhrase: password || this.passPhrase
+                }
+            });
+
+            // Parse response (XML-like format)
+            const balances = {};
+            const matches = response.data.matchAll(/<input name='(.+?)' type='hidden' value='(.+?)'>/g);
+            
+            for (const match of matches) {
+                balances[match[1]] = match[2];
+            }
+
+            return balances;
+        } catch (error) {
+            throw new Error(`Error getting balance: ${error.message}`);
+        }
+    }
+}
+
+module.exports = PerfectMoneyClient;

package/lib/phonepe.js

@@ -0,0 +1,174 @@
+const axios = require('axios');
+const crypto = require('crypto');
+
+class PhonePeClient {
+    constructor(config) {
+        const requiredFields = ['merchantId', 'saltKey', 'saltIndex'];
+        for (let field of requiredFields) {
+            if (!config[field]) throw new Error(`Missing required field: ${field}`);
+        }
+
+        this.merchantId = config.merchantId;
+        this.saltKey = config.saltKey;
+        this.saltIndex = config.saltIndex;
+        this.baseURL = config.sandbox 
+            ? 'https://api-preprod.phonepe.com/apis/pg-sandbox' 
+            : 'https://api.phonepe.com/apis/hermes';
+
+        this.client = axios.create({
+            baseURL: this.baseURL,
+            headers: {
+                'Content-Type': 'application/json'
+            }
+        });
+    }
+
+    generateChecksum(payload) {
+        const base64Payload = Buffer.from(JSON.stringify(payload)).toString('base64');
+        const checksumString = base64Payload + '/pg/v1/pay' + this.saltKey;
+        const checksum = crypto.createHash('sha256').update(checksumString).digest('hex');
+        return checksum + '###' + this.saltIndex;
+    }
+
+    verifyChecksum(base64Response, checksumHeader) {
+        const [receivedChecksum] = checksumHeader.split('###');
+        const checksumString = base64Response + this.saltKey;
+        const expectedChecksum = crypto.createHash('sha256').update(checksumString).digest('hex');
+        
+        return receivedChecksum === expectedChecksum;
+    }
+
+    async createPayment(options) {
+        try {
+            const orderId = options.orderId || `ORDER-${Date.now()}`;
+            const transactionId = `TXN-${Date.now()}`;
+            
+            const payload = {
+                merchantId: this.merchantId,
+                merchantTransactionId: transactionId,
+                merchantUserId: options.userId || `USER-${Date.now()}`,
+                amount: Math.round(parseFloat(options.amount) * 100), // Amount in paise
+                redirectUrl: options.successUrl || options.callback_link,
+                redirectMode: 'POST',
+                callbackUrl: options.callbackUrl || options.callback_link,
+                mobileNumber: options.phone || '',
+                paymentInstrument: {
+                    type: options.paymentType || 'PAY_PAGE' // PAY_PAGE, UPI_COLLECT, etc.
+                }
+            };
+
+            const base64Payload = Buffer.from(JSON.stringify(payload)).toString('base64');
+            const checksum = this.generateChecksum(payload);
+
+            const response = await this.client.post('/pg/v1/pay', {
+                request: base64Payload
+            }, {
+                headers: {
+                    'X-VERIFY': checksum
+                }
+            });
+
+            if (response.data.success) {
+                return {
+                    status: 'success',
+                    data: {
+                        url: response.data.data.instrumentResponse.redirectInfo.url,
+                        transactionId: transactionId,
+                        orderId: orderId,
+                        amount: payload.amount / 100,
+                        currency: 'INR'
+                    }
+                };
+            } 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 base64Response = callbackData.response;
+            const checksumHeader = callbackData['X-VERIFY'];
+            
+            // Verify checksum
+            if (!this.verifyChecksum(base64Response, checksumHeader)) {
+                throw new Error('Invalid checksum');
+            }
+
+            // Decode response
+            const response = JSON.parse(Buffer.from(base64Response, 'base64').toString());
+
+            // Status mapping
+            const statusMapping = {
+                'PAYMENT_SUCCESS': 'success',
+                'PAYMENT_PENDING': 'pending',
+                'PAYMENT_DECLINED': 'failed',
+                'PAYMENT_ERROR': 'failed',
+                'INTERNAL_SERVER_ERROR': 'failed'
+            };
+
+            return {
+                status: statusMapping[response.code] || 'unknown',
+                orderId: response.data.merchantOrderId,
+                transactionId: response.data.merchantTransactionId,
+                amount: response.data.amount / 100,
+                currency: 'INR',
+                paymentStatus: response.code,
+                paymentMethod: response.data.paymentInstrument?.type
+            };
+        } catch (error) {
+            throw new Error(`Error in PhonePe callback handling: ${error.message}`);
+        }
+    }
+
+    async checkStatus(transactionId) {
+        try {
+            const checksumString = `/pg/v1/status/${this.merchantId}/${transactionId}` + this.saltKey;
+            const checksum = crypto.createHash('sha256').update(checksumString).digest('hex') + '###' + this.saltIndex;
+
+            const response = await this.client.get(`/pg/v1/status/${this.merchantId}/${transactionId}`, {
+                headers: {
+                    'X-VERIFY': checksum,
+                    'X-MERCHANT-ID': this.merchantId
+                }
+            });
+
+            return response.data;
+        } catch (error) {
+            throw new Error(`Error checking status: ${error.response?.data?.message || error.message}`);
+        }
+    }
+
+    async refund(transactionId, options = {}) {
+        try {
+            const refundId = `REFUND-${Date.now()}`;
+            
+            const payload = {
+                merchantId: this.merchantId,
+                merchantTransactionId: refundId,
+                originalTransactionId: transactionId,
+                amount: Math.round(parseFloat(options.amount) * 100),
+                callbackUrl: options.callbackUrl
+            };
+
+            const base64Payload = Buffer.from(JSON.stringify(payload)).toString('base64');
+            const checksum = this.generateChecksum(payload);
+
+            const response = await this.client.post('/pg/v1/refund', {
+                request: base64Payload
+            }, {
+                headers: {
+                    'X-VERIFY': checksum
+                }
+            });
+
+            return response.data;
+        } catch (error) {
+            throw new Error(`Error processing refund: ${error.response?.data?.message || error.message}`);
+        }
+    }
+}
+
+module.exports = PhonePeClient;

package/lib/picpay.js

@@ -0,0 +1,119 @@
+const axios = require('axios');
+const crypto = require('crypto');
+
+class PicPayClient {
+    constructor(config) {
+        const requiredFields = ['token', 'sellerToken'];
+        for (let field of requiredFields) {
+            if (!config[field]) throw new Error(`Missing required field: ${field}`);
+        }
+
+        this.token = config.token;
+        this.sellerToken = config.sellerToken;
+        this.baseURL = 'https://appws.picpay.com/ecommerce/public';
+
+        this.client = axios.create({
+            baseURL: this.baseURL,
+            headers: {
+                'Content-Type': 'application/json',
+                'x-picpay-token': this.token,
+                'x-seller-token': this.sellerToken
+            }
+        });
+    }
+
+    async createPayment(options) {
+        try {
+            const orderId = options.orderId || `ORDER-${Date.now()}`;
+            
+            const paymentData = {
+                referenceId: orderId,
+                callbackUrl: options.callbackUrl || options.callback_link,
+                returnUrl: options.successUrl || options.callback_link,
+                value: parseFloat(options.amount),
+                expiresAt: options.expiresAt || new Date(Date.now() + 24*60*60*1000).toISOString(),
+                buyer: {
+                    firstName: options.firstName || options.name?.split(' ')[0] || '',
+                    lastName: options.lastName || options.name?.split(' ').slice(1).join(' ') || '',
+                    document: options.document || '',
+                    email: options.email || '',
+                    phone: options.phone || ''
+                }
+            };
+
+            const response = await this.client.post('/payments', paymentData);
+
+            return {
+                status: 'success',
+                data: {
+                    referenceId: orderId,
+                    paymentUrl: response.data.paymentUrl,
+                    qrcode: response.data.qrcode,
+                    amount: paymentData.value,
+                    currency: 'BRL',
+                    expiresAt: response.data.expiresAt
+                }
+            };
+        } catch (error) {
+            throw new Error(`Payment creation error: ${error.response?.data?.message || error.message}`);
+        }
+    }
+
+    async handleCallback(callbackData) {
+        try {
+            const referenceId = callbackData.referenceId;
+            
+            if (!referenceId) {
+                throw new Error('Reference ID not found in callback data');
+            }
+
+            // Get payment status
+            const payment = await this.getPaymentStatus(referenceId);
+
+            // Status mapping
+            const statusMapping = {
+                'paid': 'success',
+                'completed': 'success',
+                'analysis': 'pending',
+                'created': 'pending',
+                'expired': 'failed',
+                'refunded': 'refunded',
+                'chargeback': 'disputed'
+            };
+
+            return {
+                status: statusMapping[payment.status] || 'unknown',
+                orderId: payment.referenceId,
+                transactionId: payment.authorizationId,
+                amount: parseFloat(payment.value),
+                currency: 'BRL',
+                paymentStatus: payment.status
+            };
+        } catch (error) {
+            throw new Error(`Error in PicPay callback handling: ${error.message}`);
+        }
+    }
+
+    async getPaymentStatus(referenceId) {
+        try {
+            const response = await this.client.get(`/payments/${referenceId}/status`);
+            return response.data;
+        } catch (error) {
+            throw new Error(`Error getting payment status: ${error.response?.data?.message || error.message}`);
+        }
+    }
+
+    async cancelPayment(referenceId, authorizationId) {
+        try {
+            const response = await this.client.post(`/payments/${referenceId}/cancellations`, {
+                authorizationId: authorizationId
+            });
+
+            return response.data;
+        } catch (error) {
+            throw new Error(`Error canceling payment: ${error.response?.data?.message || error.message}`);
+        }
+    }
+}
+
+module.exports = PicPayClient;

package/lib/plisio.js

@@ -0,0 +1,234 @@
+const axios = require('axios');
+const crypto = require('crypto');
+
+class PlisioClient {
+    constructor(config) {
+        const requiredFields = ['apiKey'];
+        for (let field of requiredFields) {
+            if (!config[field]) throw new Error(`Missing required field: ${field}`);
+        }
+
+        this.apiKey = config.apiKey;
+        this.URL = 'https://api.plisio.net/api/v1';
+
+        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(`Plisio API error: ${error.response.data.message || error.message}`);
+            }
+            throw new Error(`Plisio API error: ${error.message}`);
+        });
+    }
+
+    async createPayment(options) {
+        try {
+            const params = {
+                api_key: this.apiKey,
+                order_name: options.orderName || options.name || 'Order',
+                order_number: options.orderNumber || options.orderId || `ORDER-${Date.now()}`,
+                amount: parseFloat(options.amount),
+                currency: options.currency || 'USD',
+                source_currency: options.sourceCurrency || options.currency || 'USD',
+                source_amount: options.sourceAmount || parseFloat(options.amount),
+                callback_url: options.callbackUrl || options.callback_link,
+                email: options.email,
+                language: options.language || 'en_US'
+            };
+
+            // Opsiyonel parametreler
+            if (options.plugin) params.plugin = options.plugin;
+            if (options.version) params.version = options.version;
+            if (options.success_callback) params.success_callback = options.success_callback;
+            if (options.fail_callback) params.fail_callback = options.fail_callback;
+
+            const response = await this.client.get('/invoices/new', { params });
+
+            if (response.data.status !== 'success') {
+                throw new Error(response.data.message || 'Payment creation failed');
+            }
+
+            return {
+                status: 'success',
+                data: {
+                    txnId: response.data.data.txn_id,
+                    url: response.data.data.invoice_url,
+                    amount: response.data.data.amount,
+                    currency: response.data.data.source_currency,
+                    orderId: params.order_number
+                }
+            };
+        } catch (error) {
+            throw new Error(`Payment creation error: ${error.message}`);
+        }
+    }
+
+    async getTransactionDetails(txnId) {
+        try {
+            const params = {
+                api_key: this.apiKey,
+                id: txnId
+            };
+
+            const response = await this.client.get('/operations/invoice', { params });
+            
+            if (response.data.status !== 'success') {
+                throw new Error(response.data.message || 'Failed to get transaction details');
+            }
+
+            return response.data.data;
+        } catch (error) {
+            throw new Error(`Transaction details error: ${error.message}`);
+        }
+    }
+
+    async getBalance(currency) {
+        try {
+            const params = {
+                api_key: this.apiKey,
+                currency: currency || 'BTC'
+            };
+
+            const response = await this.client.get('/balances', { params });
+            
+            if (response.data.status !== 'success') {
+                throw new Error(response.data.message || 'Failed to get balance');
+            }
+
+            return response.data.data;
+        } catch (error) {
+            throw new Error(`Balance 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 = {
+                'completed': 'success',
+                'pending': 'pending',
+                'expired': 'expired',
+                'error': 'failed',
+                'mismatch': 'failed',
+                'cancelled': 'cancelled'
+            };
+
+            return {
+                status: statusMapping[data.status] || 'unknown',
+                orderId: data.order_number,
+                txnId: data.txn_id,
+                amount: parseFloat(data.amount),
+                currency: data.currency,
+                sourceCurrency: data.source_currency,
+                sourceAmount: parseFloat(data.source_amount),
+                paymentStatus: data.status,
+                confirmations: data.confirmations || 0
+            };
+        } catch (error) {
+            throw new Error(`Error in Plisio callback handling: ${error.message}`);
+        }
+    }
+
+    async verifyCallback(data) {
+        try {
+            // Verify hash signature
+            if (data.verify_hash) {
+                const expectedHash = this.generateVerifyHash(data);
+                
+                if (data.verify_hash !== expectedHash) {
+                    return {
+                        status: false,
+                        error: {
+                            code: 401,
+                            message: 'Invalid verify hash'
+                        }
+                    };
+                }
+            }
+
+            // Check if payment is completed
+            if (data.status === 'error' || data.status === 'cancelled') {
+                return {
+                    status: false,
+                    error: {
+                        code: 400,
+                        message: `Payment ${data.status}`
+                    }
+                };
+            }
+
+            return {
+                status: true,
+                data: data
+            };
+        } catch (error) {
+            return {
+                status: false,
+                error: {
+                    code: 500,
+                    message: error.message
+                }
+            };
+        }
+    }
+
+    generateVerifyHash(data) {
+        // Plisio verify hash generation
+        const params = {
+            'currency': data.currency || '',
+            'order_number': data.order_number || '',
+            'order_name': data.order_name || '',
+            'source_currency': data.source_currency || '',
+            'source_rate': data.source_rate || '',
+            'amount': data.amount || '',
+            'status': data.status || '',
+            'tx_urls': data.tx_urls || '',
+            'txn_id': data.txn_id || ''
+        };
+
+        const orderedParams = Object.keys(params)
+            .sort()
+            .map(key => params[key])
+            .join('|');
+
+        return crypto
+            .createHash('sha1')
+            .update(orderedParams + '|' + this.apiKey)
+            .digest('hex');
+    }
+
+    async getSupportedCurrencies() {
+        try {
+            const params = {
+                api_key: this.apiKey
+            };
+
+            const response = await this.client.get('/currencies', { params });
+            
+            if (response.data.status !== 'success') {
+                throw new Error(response.data.message || 'Failed to get currencies');
+            }
+
+            return response.data.data;
+        } catch (error) {
+            throw new Error(`Supported currencies error: ${error.message}`);
+        }
+    }
+}
+
+module.exports = PlisioClient;