quickpos 1.0.910 → 1.0.912

package/lib/paycom.js

@@ -0,0 +1,216 @@
+const axios = require('axios');
+
+class PaycomClient {
+    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.URL = 'https://checkout.paycom.uz/api';
+
+        this.client = axios.create({
+            baseURL: this.URL,
+            headers: {
+                'Content-Type': 'application/json',
+                'X-Auth': this.merchantId + ':' + this.secretKey
+            }
+        });
+
+        this.client.interceptors.response.use(response => {
+            return response;
+        }, error => {
+            if (error.response) {
+                throw new Error(`Paycom API error: ${error.response.data.error?.message || error.message}`);
+            }
+            throw new Error(`Paycom API error: ${error.message}`);
+        });
+    }
+
+    async createPayment(options) {
+        try {
+            const orderId = options.orderId || `ORDER-${Date.now()}`;
+            const amount = Math.round(parseFloat(options.amount) * 100); // Convert to tiyin
+
+            // Paycom uses a unique link generation system
+            const params = {
+                m: this.merchantId,
+                ac: {
+                    order_id: orderId
+                },
+                a: amount,
+                c: options.callbackUrl || options.callback_link,
+                l: options.lang || 'ru'
+            };
+
+            // Generate payment URL
+            const encodedParams = Buffer.from(JSON.stringify(params)).toString('base64');
+            const paymentUrl = `https://checkout.paycom.uz/${encodedParams}`;
+
+            return {
+                status: 'success',
+                data: {
+                    url: paymentUrl,
+                    orderId: orderId,
+                    amount: options.amount,
+                    params: encodedParams
+                }
+            };
+        } catch (error) {
+            throw new Error(`Payment creation error: ${error.message}`);
+        }
+    }
+
+    async handleCallback(callbackData) {
+        try {
+            // Paycom uses JSON-RPC 2.0 protocol
+            const method = callbackData.method;
+            const params = callbackData.params;
+            const id = callbackData.id;
+
+            switch (method) {
+                case 'CheckPerformTransaction':
+                    return await this.checkPerformTransaction(params, id);
+                
+                case 'CreateTransaction':
+                    return await this.createTransaction(params, id);
+                
+                case 'PerformTransaction':
+                    return await this.performTransaction(params, id);
+                
+                case 'CancelTransaction':
+                    return await this.cancelTransaction(params, id);
+                
+                case 'CheckTransaction':
+                    return await this.checkTransaction(params, id);
+                
+                default:
+                    throw new Error(`Unknown method: ${method}`);
+            }
+        } catch (error) {
+            throw new Error(`Error in Paycom callback handling: ${error.message}`);
+        }
+    }
+
+    async checkPerformTransaction(params, id) {
+        // Verify that transaction can be performed
+        const orderId = params.account.order_id;
+        const amount = params.amount;
+
+        // You should check if order exists and amount is correct
+        // Return success response
+        return {
+            jsonrpc: '2.0',
+            id: id,
+            result: {
+                allow: true
+            }
+        };
+    }
+
+    async createTransaction(params, id) {
+        // Create transaction in your database
+        const transactionId = params.id;
+        const time = params.time;
+        const amount = params.amount;
+        const orderId = params.account.order_id;
+
+        // Save transaction with state 1 (created)
+        return {
+            jsonrpc: '2.0',
+            id: id,
+            result: {
+                create_time: time,
+                transaction: transactionId.toString(),
+                state: 1
+            }
+        };
+    }
+
+    async performTransaction(params, id) {
+        // Perform the transaction (complete payment)
+        const transactionId = params.id;
+
+        // Update transaction state to 2 (completed)
+        return {
+            jsonrpc: '2.0',
+            id: id,
+            result: {
+                transaction: transactionId.toString(),
+                perform_time: Date.now(),
+                state: 2
+            }
+        };
+    }
+
+    async cancelTransaction(params, id) {
+        // Cancel transaction
+        const transactionId = params.id;
+        const reason = params.reason;
+
+        // Update transaction state to -1 (cancelled) or -2 (cancelled after complete)
+        return {
+            jsonrpc: '2.0',
+            id: id,
+            result: {
+                transaction: transactionId.toString(),
+                cancel_time: Date.now(),
+                state: -1
+            }
+        };
+    }
+
+    async checkTransaction(params, id) {
+        // Check transaction status
+        const transactionId = params.id;
+
+        // Return transaction info from your database
+        return {
+            jsonrpc: '2.0',
+            id: id,
+            result: {
+                create_time: 0,
+                perform_time: 0,
+                cancel_time: 0,
+                transaction: transactionId.toString(),
+                state: 1,
+                reason: null
+            }
+        };
+    }
+
+    async verifyCallback(data) {
+        try {
+            // Verify authorization header
+            const authHeader = data.headers?.['x-auth'];
+            const expectedAuth = this.merchantId + ':' + this.secretKey;
+
+            if (authHeader !== expectedAuth) {
+                return {
+                    status: false,
+                    error: {
+                        code: -32504,
+                        message: 'Insufficient privilege to perform this method'
+                    }
+                };
+            }
+
+            return {
+                status: true,
+                data: data
+            };
+        } catch (error) {
+            return {
+                status: false,
+                error: {
+                    code: 500,
+                    message: error.message
+                }
+            };
+        }
+    }
+}
+
+module.exports = PaycomClient;

package/lib/payid19.js

@@ -0,0 +1,211 @@
+const axios = require('axios');
+const crypto = require('crypto');
+
+class PayID19Client {
+    constructor(config) {
+        const requiredFields = ['apiKey', 'secretKey'];
+        for (let field of requiredFields) {
+            if (!config[field]) throw new Error(`Missing required field: ${field}`);
+        }
+
+        this.apiKey = config.apiKey;
+        this.secretKey = config.secretKey;
+        this.URL = 'https://payid19.com/api/v1';
+
+        this.client = axios.create({
+            baseURL: this.URL,
+            headers: {
+                'Content-Type': 'application/json',
+                'Authorization': `Bearer ${this.apiKey}`
+            }
+        });
+
+        this.client.interceptors.response.use(response => {
+            return response;
+        }, error => {
+            if (error.response) {
+                throw new Error(`PayID19 API error: ${error.response.data.message || error.message}`);
+            }
+            throw new Error(`PayID19 API error: ${error.message}`);
+        });
+    }
+
+    generateSignature(data) {
+        const sortedData = Object.keys(data)
+            .sort()
+            .map(key => `${key}=${data[key]}`)
+            .join('&');
+        
+        return crypto
+            .createHmac('sha256', this.secretKey)
+            .update(sortedData)
+            .digest('hex');
+    }
+
+    async createPayment(options) {
+        try {
+            const orderId = options.orderId || `ORDER-${Date.now()}`;
+            
+            const requestData = {
+                merchant_order_id: orderId,
+                amount: parseFloat(options.amount),
+                currency: options.currency || 'IDR',
+                customer_name: options.customerName || options.name || 'Customer',
+                customer_email: options.customerEmail || options.email,
+                customer_phone: options.customerPhone || options.phone || '',
+                callback_url: options.callbackUrl || options.callback_link,
+                return_url: options.returnUrl || options.callback_link,
+                description: options.description || options.name || 'Payment',
+                payment_method: options.paymentMethod || 'all'
+            };
+
+            // Generate signature
+            const signature = this.generateSignature(requestData);
+            requestData.signature = signature;
+
+            const response = await this.client.post('/payment/create', requestData);
+
+            if (response.data.status === 'success') {
+                return {
+                    status: 'success',
+                    data: {
+                        paymentId: response.data.data.payment_id,
+                        url: response.data.data.payment_url,
+                        orderId: orderId,
+                        qrCode: response.data.data.qr_code,
+                        expiredAt: response.data.data.expired_at
+                    }
+                };
+            } else {
+                throw new Error(response.data.message || 'Payment creation failed');
+            }
+        } catch (error) {
+            throw new Error(`Payment creation error: ${error.message}`);
+        }
+    }
+
+    async getPaymentStatus(paymentId) {
+        try {
+            const response = await this.client.get(`/payment/status/${paymentId}`);
+            
+            if (response.data.status === 'success') {
+                return response.data.data;
+            } else {
+                throw new Error(response.data.message || 'Failed to get payment status');
+            }
+        } catch (error) {
+            throw new Error(`Payment 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 = {
+                'paid': 'success',
+                'pending': 'pending',
+                'expired': 'expired',
+                'failed': 'failed',
+                'cancelled': 'cancelled'
+            };
+
+            return {
+                status: statusMapping[data.payment_status] || 'unknown',
+                paymentId: data.payment_id,
+                orderId: data.merchant_order_id,
+                amount: parseFloat(data.amount),
+                currency: data.currency,
+                paymentMethod: data.payment_method,
+                paymentStatus: data.payment_status,
+                paidAt: data.paid_at,
+                fee: parseFloat(data.fee || 0),
+                netAmount: parseFloat(data.net_amount || data.amount)
+            };
+        } catch (error) {
+            throw new Error(`Error in PayID19 callback handling: ${error.message}`);
+        }
+    }
+
+    async verifyCallback(data) {
+        try {
+            const receivedSignature = data.signature;
+            delete data.signature;
+
+            const expectedSignature = this.generateSignature(data);
+
+            if (receivedSignature !== expectedSignature) {
+                return {
+                    status: false,
+                    error: {
+                        code: 401,
+                        message: 'Invalid signature'
+                    }
+                };
+            }
+
+            if (data.payment_status === 'failed' || data.payment_status === 'cancelled') {
+                return {
+                    status: false,
+                    error: {
+                        code: 400,
+                        message: `Payment ${data.payment_status}`
+                    }
+                };
+            }
+
+            // Restore signature for callback response
+            data.signature = receivedSignature;
+
+            return {
+                status: true,
+                data: data
+            };
+        } catch (error) {
+            return {
+                status: false,
+                error: {
+                    code: 500,
+                    message: error.message
+                }
+            };
+        }
+    }
+
+    async getBalance() {
+        try {
+            const response = await this.client.get('/merchant/balance');
+            
+            if (response.data.status === 'success') {
+                return response.data.data;
+            } else {
+                throw new Error(response.data.message || 'Failed to get balance');
+            }
+        } catch (error) {
+            throw new Error(`Balance error: ${error.message}`);
+        }
+    }
+
+    async getPaymentMethods() {
+        try {
+            const response = await this.client.get('/payment/methods');
+            
+            if (response.data.status === 'success') {
+                return response.data.data;
+            } else {
+                throw new Error(response.data.message || 'Failed to get payment methods');
+            }
+        } catch (error) {
+            throw new Error(`Payment methods error: ${error.message}`);
+        }
+    }
+}
+
+module.exports = PayID19Client;

package/lib/paykun.js

@@ -0,0 +1,144 @@
+const axios = require('axios');
+const crypto = require('crypto');
+
+class PayKunClient {
+    constructor(config) {
+        const requiredFields = ['merchantId', 'accessToken', 'encryptionKey'];
+        for (let field of requiredFields) {
+            if (!config[field]) throw new Error(`Missing required field: ${field}`);
+        }
+
+        this.merchantId = config.merchantId;
+        this.accessToken = config.accessToken;
+        this.encryptionKey = config.encryptionKey;
+        this.baseURL = config.sandbox 
+            ? 'https://sandbox.paykun.com/api' 
+            : 'https://api.paykun.com';
+
+        this.client = axios.create({
+            baseURL: this.baseURL,
+            headers: {
+                'Content-Type': 'application/json',
+                'MerchantId': this.merchantId
+            }
+        });
+    }
+
+    async createPayment(options) {
+        try {
+            const orderId = options.orderId || `ORDER-${Date.now()}`;
+            
+            const paymentData = {
+                merchant_id: this.merchantId,
+                access_token: this.accessToken,
+                order: {
+                    number: orderId,
+                    amount: parseFloat(options.amount).toFixed(2),
+                    currency: options.currency || 'INR'
+                },
+                customer: {
+                    name: options.name || options.customerName || '',
+                    email: options.email || '',
+                    mobile: options.phone || ''
+                },
+                custom_fields: {
+                    field1: options.field1 || '',
+                    field2: options.field2 || ''
+                },
+                success_url: options.successUrl || options.callback_link,
+                failure_url: options.failureUrl || options.callback_link
+            };
+
+            const response = await this.client.post('/payment/initiate', paymentData);
+
+            if (response.data.status && response.data.data) {
+                return {
+                    status: 'success',
+                    data: {
+                        url: response.data.data.url,
+                        transactionId: response.data.data.transaction_id,
+                        orderId: orderId,
+                        amount: paymentData.order.amount,
+                        currency: paymentData.order.currency
+                    }
+                };
+            } else {
+                throw new Error(response.data.errors?.errorMessage || 'Payment creation failed');
+            }
+        } catch (error) {
+            throw new Error(`Payment creation error: ${error.response?.data?.errors?.errorMessage || error.message}`);
+        }
+    }
+
+    async handleCallback(callbackData) {
+        try {
+            const transactionId = callbackData.payment_id || callbackData.transaction_id;
+            
+            if (!transactionId) {
+                throw new Error('Transaction ID not found in callback data');
+            }
+
+            // Verify payment
+            const payment = await this.getTransactionDetails(transactionId);
+
+            // Status mapping
+            const statusMapping = {
+                'Success': 'success',
+                'Pending': 'pending',
+                'Failed': 'failed',
+                'Refund': 'refunded',
+                'Cancelled': 'failed'
+            };
+
+            return {
+                status: statusMapping[payment.transaction.status] || 'unknown',
+                orderId: payment.transaction.order.orderId,
+                transactionId: payment.transaction.payment.id,
+                amount: parseFloat(payment.transaction.order.gross_amount),
+                currency: payment.transaction.order.currency,
+                paymentStatus: payment.transaction.status,
+                paymentMethod: payment.transaction.payment.method?.type
+            };
+        } catch (error) {
+            throw new Error(`Error in PayKun callback handling: ${error.message}`);
+        }
+    }
+
+    async getTransactionDetails(transactionId) {
+        try {
+            const response = await this.client.get(`/payment/${this.merchantId}/${this.accessToken}/${transactionId}`);
+
+            if (response.data.status) {
+                return response.data.data;
+            } else {
+                throw new Error(response.data.errors?.errorMessage || 'Failed to get transaction details');
+            }
+        } catch (error) {
+            throw new Error(`Error getting transaction details: ${error.response?.data?.errors?.errorMessage || error.message}`);
+        }
+    }
+
+    async refundPayment(transactionId, options = {}) {
+        try {
+            const refundData = {
+                merchant_id: this.merchantId,
+                access_token: this.accessToken,
+                transaction_id: transactionId,
+                amount: options.amount,
+                reason: options.reason || 'Customer Request'
+            };
+
+            const response = await this.client.post('/payment/refund', refundData);
+
+            if (response.data.status) {
+                return response.data.data;
+            } else {
+                throw new Error(response.data.errors?.errorMessage || 'Refund failed');
+            }
+        } catch (error) {
+            throw new Error(`Error processing refund: ${error.response?.data?.errors?.errorMessage || error.message}`);
+        }
+    }
+}
+
+module.exports = PayKunClient;