quickpos 1.0.910 → 1.0.912

package/lib/epoint.js

@@ -0,0 +1,162 @@
+const axios = require('axios');
+const crypto = require('crypto');
+
+class EpointClient {
+    constructor(config) {
+        const requiredFields = ['merchantId', 'privateKey'];
+        for (let field of requiredFields) {
+            if (!config[field]) throw new Error(`Missing required field: ${field}`);
+        }
+
+        this.merchantId = config.merchantId;
+        this.privateKey = config.privateKey;
+        this.baseURL = 'https://epoint.az/api';
+
+        this.client = axios.create({
+            baseURL: this.baseURL,
+            headers: {
+                'Content-Type': 'application/json'
+            }
+        });
+    }
+
+    generateSignature(data) {
+        const signatureString = Object.keys(data)
+            .filter(key => key !== 'signature')
+            .sort()
+            .map(key => `${key}=${data[key]}`)
+            .join('&');
+        
+        return crypto
+            .createHmac('sha256', this.privateKey)
+            .update(signatureString)
+            .digest('hex')
+            .toUpperCase();
+    }
+
+    async createPayment(options) {
+        try {
+            const orderId = options.orderId || `ORDER-${Date.now()}`;
+            const amount = parseFloat(options.amount) * 100; // Convert to cents
+            
+            const paymentData = {
+                merchant_id: this.merchantId,
+                order_id: orderId,
+                amount: amount,
+                currency: options.currency || 'AZN',
+                description: options.description || options.name || 'Payment',
+                success_url: options.successUrl || options.callback_link,
+                fail_url: options.failUrl || options.callback_link,
+                callback_url: options.callbackUrl || options.callback_link,
+                language: options.language || 'az',
+                email: options.email || '',
+                phone: options.phone || ''
+            };
+
+            paymentData.signature = this.generateSignature(paymentData);
+
+            const response = await this.client.post('/payment/create', paymentData);
+
+            if (response.data.success) {
+                return {
+                    status: 'success',
+                    data: {
+                        url: response.data.data.payment_url,
+                        orderId: orderId,
+                        paymentId: response.data.data.payment_id,
+                        amount: amount / 100,
+                        currency: paymentData.currency
+                    }
+                };
+            } 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 verification = await this.verifyCallback(callbackData);
+            
+            if (!verification.status) {
+                throw new Error(verification.error.message);
+            }
+
+            const data = verification.data;
+            
+            // Status mapping
+            const statusMapping = {
+                'success': 'success',
+                'completed': 'success',
+                'failed': 'failed',
+                'cancelled': 'failed',
+                'pending': 'pending'
+            };
+
+            return {
+                status: statusMapping[data.status] || 'unknown',
+                orderId: data.order_id,
+                transactionId: data.payment_id,
+                amount: parseFloat(data.amount) / 100,
+                currency: data.currency,
+                paymentStatus: data.status,
+                paymentMethod: data.payment_method
+            };
+        } catch (error) {
+            throw new Error(`Error in Epoint callback handling: ${error.message}`);
+        }
+    }
+
+    async verifyCallback(data) {
+        try {
+            const receivedSign = data.signature;
+            const dataToVerify = { ...data };
+            delete dataToVerify.signature;
+
+            const expectedSign = this.generateSignature(dataToVerify);
+
+            if (receivedSign !== expectedSign) {
+                return {
+                    status: false,
+                    error: {
+                        code: 401,
+                        message: 'Invalid signature'
+                    }
+                };
+            }
+
+            return {
+                status: true,
+                data: data
+            };
+        } catch (error) {
+            return {
+                status: false,
+                error: {
+                    code: 500,
+                    message: error.message
+                }
+            };
+        }
+    }
+
+    async getPaymentStatus(paymentId) {
+        try {
+            const data = {
+                merchant_id: this.merchantId,
+                payment_id: paymentId
+            };
+            
+            data.signature = this.generateSignature(data);
+            
+            const response = await this.client.post('/payment/status', data);
+            return response.data;
+        } catch (error) {
+            throw new Error(`Error getting payment status: ${error.response?.data?.message || error.message}`);
+        }
+    }
+}
+
+module.exports = EpointClient;

package/lib/freekassa.js

@@ -0,0 +1,128 @@
+const axios = require('axios');
+const crypto = require('crypto');
+
+class FreeKassaClient {
+    constructor(config) {
+        const requiredFields = ['shopId', 'secretKey1', 'secretKey2'];
+        for (let field of requiredFields) {
+            if (!config[field]) throw new Error(`Missing required field: ${field}`);
+        }
+
+        this.shopId = config.shopId;
+        this.secretKey1 = config.secretKey1; // For payment form signature
+        this.secretKey2 = config.secretKey2; // For callback verification
+        this.baseURL = 'https://pay.freekassa.ru';
+    }
+
+    generateSignature(amount, orderId, secretKey) {
+        const signatureString = `${this.shopId}:${amount}:${secretKey}:${orderId}`;
+        return crypto.createHash('md5').update(signatureString).digest('hex');
+    }
+
+    async createPayment(options) {
+        try {
+            const orderId = options.orderId || `ORDER-${Date.now()}`;
+            const amount = parseFloat(options.amount).toFixed(2);
+            
+            const signature = this.generateSignature(amount, orderId, this.secretKey1);
+
+            const paymentData = {
+                m: this.shopId,
+                oa: amount,
+                currency: options.currency || 'RUB',
+                o: orderId,
+                s: signature,
+                email: options.email || '',
+                phone: options.phone || '',
+                i: options.paymentMethod || '', // Payment system ID
+                us_customer_name: options.name || ''
+            };
+
+            // Create payment URL
+            const params = new URLSearchParams(paymentData);
+            const paymentUrl = `${this.baseURL}/?${params.toString()}`;
+
+            return {
+                status: 'success',
+                data: {
+                    url: paymentUrl,
+                    orderId: orderId,
+                    amount: amount,
+                    currency: paymentData.currency,
+                    signature: signature
+                }
+            };
+        } 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.MERCHANT_ORDER_ID,
+                transactionId: callbackData.intid,
+                amount: parseFloat(callbackData.AMOUNT),
+                currency: callbackData.MERCHANT_CURRENCY || 'RUB',
+                paymentStatus: 'completed',
+                paymentMethod: callbackData.PAYMENT_ID
+            };
+        } catch (error) {
+            throw new Error(`Error in FreeKassa callback handling: ${error.message}`);
+        }
+    }
+
+    async verifyCallback(data) {
+        try {
+            const receivedSign = data.SIGN;
+            const signatureString = `${this.shopId}:${data.AMOUNT}:${this.secretKey2}:${data.MERCHANT_ORDER_ID}`;
+            const expectedSign = crypto.createHash('md5').update(signatureString).digest('hex');
+
+            if (receivedSign !== expectedSign) {
+                return {
+                    status: false,
+                    error: {
+                        code: 401,
+                        message: 'Invalid signature'
+                    }
+                };
+            }
+
+            return {
+                status: true,
+                data: data
+            };
+        } catch (error) {
+            return {
+                status: false,
+                error: {
+                    code: 500,
+                    message: error.message
+                }
+            };
+        }
+    }
+
+    async getBalance() {
+        try {
+            // FreeKassa API for balance check
+            const response = await axios.post('https://api.freekassa.ru/v1/balance', {
+                shopId: this.shopId,
+                nonce: Date.now()
+            });
+
+            return response.data;
+        } catch (error) {
+            throw new Error(`Error getting balance: ${error.message}`);
+        }
+    }
+}
+
+module.exports = FreeKassaClient;

package/lib/heleket.js

@@ -129,7 +129,7 @@ class Heleket {
       const data = {...webhookData};
       
       // Process successful payments
-      if (data.status === 'completed' || data.status === 'success') {
+      if (data.status === 'paid') {
         return {
           status: 'success',
           orderId: data.order_id,
@@ -146,6 +146,72 @@ class Heleket {
       throw new Error(`Error in Heleket callback handling: ${error.message}`);
     }
   }
+
+  /**
+   * Test payment webhook
+   * @param {object} params - Test parameters
+   * @param {string} params.url_callback - URL to which webhooks will be sent
+   * @param {string} params.currency - Invoice currency code
+   * @param {string} params.network - Invoice network code
+   * @param {string} [params.uuid] - UUID of the invoice
+   * @param {string} [params.order_id] - Order ID of the invoice
+   * @param {string} [params.status=paid] - Payment status
+   * @returns {Promise} - Promise resolving to test result
+   */
+  testPaymentWebhook(params) {
+    if (!params.url_callback || !params.currency || !params.network) {
+      throw new Error('Missing required parameters: url_callback, currency, network');
+    }
+    
+    // Set default status if not provided
+    params.status = params.status || 'paid';
+    
+    return this.request('/v1/test-webhook/payment', params);
+  }
+
+  /**
+   * Test payout webhook
+   * @param {object} params - Test parameters
+   * @param {string} params.url_callback - URL to which webhooks will be sent
+   * @param {string} params.currency - Payout currency code
+   * @param {string} params.network - Payout network code
+   * @param {string} [params.uuid] - UUID of the payout
+   * @param {string} [params.order_id] - Order ID of the payout
+   * @param {string} [params.status=paid] - Payout status
+   * @returns {Promise} - Promise resolving to test result
+   */
+  testPayoutWebhook(params) {
+    if (!params.url_callback || !params.currency || !params.network) {
+      throw new Error('Missing required parameters: url_callback, currency, network');
+    }
+    
+    // Set default status if not provided
+    params.status = params.status || 'paid';
+    
+    return this.request('/v1/test-webhook/payout', params);
+  }
+
+  /**
+   * Test wallet webhook
+   * @param {object} params - Test parameters
+   * @param {string} params.url_callback - URL to which webhooks will be sent
+   * @param {string} params.currency - Payment currency code
+   * @param {string} params.network - Payment network code
+   * @param {string} [params.uuid] - UUID of business wallet
+   * @param {string} [params.order_id] - Order ID of the invoice
+   * @param {string} [params.status=paid] - Payment status
+   * @returns {Promise} - Promise resolving to test result
+   */
+  testWalletWebhook(params) {
+    if (!params.url_callback || !params.currency || !params.network) {
+      throw new Error('Missing required parameters: url_callback, currency, network');
+    }
+    
+    // Set default status if not provided
+    params.status = params.status || 'paid';
+    
+    return this.request('/v1/test-webhook/wallet', params);
+  }
 }
 
 module.exports = Heleket;

package/lib/instamojo.js

@@ -0,0 +1,158 @@
+const axios = require('axios');
+const crypto = require('crypto');
+
+class InstamojoClient {
+    constructor(config) {
+        const requiredFields = ['apiKey', 'authToken'];
+        for (let field of requiredFields) {
+            if (!config[field]) throw new Error(`Missing required field: ${field}`);
+        }
+
+        this.apiKey = config.apiKey;
+        this.authToken = config.authToken;
+        this.baseURL = config.sandbox 
+            ? 'https://test.instamojo.com/api/1.1' 
+            : 'https://www.instamojo.com/api/1.1';
+
+        this.client = axios.create({
+            baseURL: this.baseURL,
+            headers: {
+                'Content-Type': 'application/json',
+                'X-Api-Key': this.apiKey,
+                'X-Auth-Token': this.authToken
+            }
+        });
+    }
+
+    async createPayment(options) {
+        try {
+            const orderId = options.orderId || `ORDER-${Date.now()}`;
+            
+            const paymentData = {
+                purpose: options.purpose || options.name || 'Payment',
+                amount: parseFloat(options.amount).toFixed(2),
+                buyer_name: options.name || options.buyerName || '',
+                email: options.email || '',
+                phone: options.phone || '',
+                send_email: options.sendEmail !== false,
+                send_sms: options.sendSms || false,
+                redirect_url: options.successUrl || options.callback_link,
+                webhook: options.callbackUrl || options.callback_link,
+                allow_repeated_payments: false
+            };
+
+            const response = await this.client.post('/payment-requests/', paymentData);
+
+            if (response.data.success) {
+                return {
+                    status: 'success',
+                    data: {
+                        id: response.data.payment_request.id,
+                        url: response.data.payment_request.longurl,
+                        orderId: orderId,
+                        amount: response.data.payment_request.amount,
+                        currency: 'INR',
+                        status: response.data.payment_request.status
+                    }
+                };
+            } else {
+                throw new Error(response.data.message || 'Payment request creation failed');
+            }
+        } catch (error) {
+            throw new Error(`Payment creation error: ${error.response?.data?.message || error.message}`);
+        }
+    }
+
+    async handleCallback(callbackData) {
+        try {
+            // Get payment details
+            const paymentId = callbackData.payment_id;
+            
+            if (!paymentId) {
+                throw new Error('Payment ID not found in callback data');
+            }
+
+            const payment = await this.getPaymentDetails(paymentId);
+
+            // Status mapping
+            const statusMapping = {
+                'Credit': 'success',
+                'Pending': 'pending',
+                'Failed': 'failed',
+                'Initiated': 'pending'
+            };
+
+            return {
+                status: statusMapping[payment.status] || 'unknown',
+                orderId: payment.payment_request?.id,
+                transactionId: payment.payment_id,
+                amount: parseFloat(payment.amount),
+                currency: payment.currency || 'INR',
+                paymentStatus: payment.status,
+                paymentMethod: payment.instrument_type,
+                fees: parseFloat(payment.fees || 0),
+                buyer: {
+                    name: payment.buyer_name,
+                    email: payment.buyer_email,
+                    phone: payment.buyer_phone
+                }
+            };
+        } catch (error) {
+            throw new Error(`Error in Instamojo callback handling: ${error.message}`);
+        }
+    }
+
+    async getPaymentDetails(paymentId) {
+        try {
+            const response = await this.client.get(`/payments/${paymentId}/`);
+
+            if (response.data.success) {
+                return response.data.payment;
+            } else {
+                throw new Error(response.data.message || 'Failed to get payment details');
+            }
+        } catch (error) {
+            throw new Error(`Error getting payment details: ${error.response?.data?.message || error.message}`);
+        }
+    }
+
+    async getPaymentRequestDetails(requestId) {
+        try {
+            const response = await this.client.get(`/payment-requests/${requestId}/`);
+
+            if (response.data.success) {
+                return response.data.payment_request;
+            } else {
+                throw new Error(response.data.message || 'Failed to get payment request details');
+            }
+        } catch (error) {
+            throw new Error(`Error getting payment request details: ${error.response?.data?.message || error.message}`);
+        }
+    }
+
+    async initiateRefund(paymentId, options = {}) {
+        try {
+            const refundData = {
+                payment_id: paymentId,
+                type: options.type || 'RFD', // RFD or TNR
+                body: options.reason || 'Customer request'
+            };
+
+            if (options.refund_amount) {
+                refundData.refund_amount = parseFloat(options.refund_amount).toFixed(2);
+            }
+
+            const response = await this.client.post('/refunds/', refundData);
+
+            if (response.data.success) {
+                return response.data.refund;
+            } else {
+                throw new Error(response.data.message || 'Refund initiation failed');
+            }
+        } catch (error) {
+            throw new Error(`Error initiating refund: ${error.response?.data?.message || error.message}`);
+        }
+    }
+}
+
+module.exports = InstamojoClient;