quickpos 1.0.910 → 1.0.912

package/lib/coinpayments.js

@@ -0,0 +1,245 @@
+const axios = require('axios');
+const crypto = require('crypto');
+
+class CoinPaymentsClient {
+    constructor(config) {
+        const requiredFields = ['publicKey', 'privateKey'];
+        for (let field of requiredFields) {
+            if (!config[field]) throw new Error(`Missing required field: ${field}`);
+        }
+
+        this.publicKey = config.publicKey;
+        this.privateKey = config.privateKey;
+        this.URL = 'https://www.coinpayments.net/api.php';
+        this.ipnSecret = config.ipnSecret || '';
+
+        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(`CoinPayments API error: ${error.response.data.error || error.message}`);
+            }
+            throw new Error(`CoinPayments API error: ${error.message}`);
+        });
+    }
+
+    generateHMAC(params) {
+        const paramString = new URLSearchParams(params).toString();
+        return crypto
+            .createHmac('sha512', this.privateKey)
+            .update(paramString)
+            .digest('hex');
+    }
+
+    async apiCall(cmd, params = {}) {
+        try {
+            const requestParams = {
+                version: 1,
+                cmd: cmd,
+                key: this.publicKey,
+                format: 'json',
+                ...params
+            };
+
+            const hmac = this.generateHMAC(requestParams);
+            const formData = new URLSearchParams(requestParams);
+
+            const response = await axios.post(this.URL, formData, {
+                headers: {
+                    'HMAC': hmac,
+                    'Content-Type': 'application/x-www-form-urlencoded'
+                }
+            });
+
+            if (response.data.error !== 'ok') {
+                throw new Error(response.data.error || 'API call failed');
+            }
+
+            return response.data.result;
+        } catch (error) {
+            throw new Error(`API call error: ${error.message}`);
+        }
+    }
+
+    async createPayment(options) {
+        try {
+            const params = {
+                amount: parseFloat(options.amount),
+                currency1: options.currency1 || options.currency || 'USD',
+                currency2: options.currency2 || 'BTC',
+                buyer_email: options.buyerEmail || options.email,
+                buyer_name: options.buyerName || options.name || 'Customer',
+                item_name: options.itemName || options.name || 'Product',
+                item_number: options.itemNumber || options.orderId || `ORDER-${Date.now()}`,
+                invoice: options.invoice || options.orderId || `INV-${Date.now()}`,
+                custom: options.custom || '',
+                ipn_url: options.ipnUrl || options.callback_link
+            };
+
+            const result = await this.apiCall('create_transaction', params);
+
+            return {
+                status: 'success',
+                data: {
+                    txnId: result.txn_id,
+                    address: result.address,
+                    amount: result.amount,
+                    confirmsNeeded: result.confirms_needed,
+                    timeout: result.timeout,
+                    statusUrl: result.status_url,
+                    qrcodeUrl: result.qrcode_url,
+                    url: result.checkout_url || result.status_url
+                }
+            };
+        } catch (error) {
+            throw new Error(`Payment creation error: ${error.message}`);
+        }
+    }
+
+    async getTransactionInfo(txnId) {
+        try {
+            const result = await this.apiCall('get_tx_info', { txid: txnId });
+            return result;
+        } catch (error) {
+            throw new Error(`Transaction info error: ${error.message}`);
+        }
+    }
+
+    async getCallbackAddress(currency) {
+        try {
+            const result = await this.apiCall('get_callback_address', {
+                currency: currency,
+                ipn_url: this.ipnUrl
+            });
+            return result;
+        } catch (error) {
+            throw new Error(`Callback address error: ${error.message}`);
+        }
+    }
+
+    async handleCallback(callbackData) {
+        try {
+            const verification = await this.verifyIPNCallback(callbackData);
+            
+            if (!verification.status) {
+                throw new Error(verification.error.message);
+            }
+
+            const data = verification.data;
+            
+            // Status mapping
+            // Status >= 100 or status == 2 means payment is complete
+            const status = parseInt(data.status);
+            let paymentStatus = 'pending';
+            
+            if (status >= 100 || status === 2) {
+                paymentStatus = 'success';
+            } else if (status < 0) {
+                paymentStatus = 'failed';
+            }
+
+            return {
+                status: paymentStatus,
+                txnId: data.txn_id,
+                orderId: data.item_number || data.invoice,
+                amount: parseFloat(data.amount1 || data.amount),
+                currency: data.currency1,
+                receivedAmount: parseFloat(data.amount2 || 0),
+                receivedCurrency: data.currency2,
+                fee: parseFloat(data.fee || 0),
+                statusCode: status,
+                statusText: data.status_text
+            };
+        } catch (error) {
+            throw new Error(`Error in CoinPayments callback handling: ${error.message}`);
+        }
+    }
+
+    async verifyIPNCallback(data) {
+        try {
+            // Verify HMAC signature if available
+            if (this.ipnSecret && data.hmac) {
+                const merchant = data.merchant;
+                delete data.hmac;
+                delete data.merchant;
+
+                const paramString = new URLSearchParams(
+                    Object.keys(data)
+                        .sort()
+                        .reduce((obj, key) => {
+                            obj[key] = data[key];
+                            return obj;
+                        }, {})
+                ).toString();
+
+                const expectedHmac = crypto
+                    .createHmac('sha512', this.ipnSecret)
+                    .update(paramString)
+                    .digest('hex');
+
+                if (data.hmac !== expectedHmac) {
+                    return {
+                        status: false,
+                        error: {
+                            code: 401,
+                            message: 'Invalid IPN HMAC signature'
+                        }
+                    };
+                }
+
+                data.merchant = merchant;
+            }
+
+            const status = parseInt(data.status);
+            if (status < 0) {
+                return {
+                    status: false,
+                    error: {
+                        code: 400,
+                        message: `Payment failed: ${data.status_text}`
+                    }
+                };
+            }
+
+            return {
+                status: true,
+                data: data
+            };
+        } catch (error) {
+            return {
+                status: false,
+                error: {
+                    code: 500,
+                    message: error.message
+                }
+            };
+        }
+    }
+
+    async getRates(short = 1, accepted = 1) {
+        try {
+            const result = await this.apiCall('rates', { short, accepted });
+            return result;
+        } catch (error) {
+            throw new Error(`Get rates error: ${error.message}`);
+        }
+    }
+
+    async getBasicInfo() {
+        try {
+            const result = await this.apiCall('get_basic_info');
+            return result;
+        } catch (error) {
+            throw new Error(`Get basic info error: ${error.message}`);
+        }
+    }
+}
+
+module.exports = CoinPaymentsClient;

package/lib/doku.js

@@ -0,0 +1,173 @@
+const axios = require('axios');
+const crypto = require('crypto');
+
+class DokuClient {
+    constructor(config) {
+        const requiredFields = ['clientId', 'secretKey'];
+        for (let field of requiredFields) {
+            if (!config[field]) throw new Error(`Missing required field: ${field}`);
+        }
+
+        this.clientId = config.clientId;
+        this.secretKey = config.secretKey;
+        this.sharedKey = config.sharedKey || this.secretKey;
+        this.baseURL = config.sandbox 
+            ? 'https://sandbox.doku.com' 
+            : 'https://api.doku.com';
+
+        this.client = axios.create({
+            baseURL: this.baseURL,
+            headers: {
+                'Content-Type': 'application/json',
+                'Client-Id': this.clientId
+            }
+        });
+    }
+
+    generateSignature(data, timestamp) {
+        const digest = crypto.createHash('sha256')
+            .update(JSON.stringify(data))
+            .digest('hex');
+        
+        const signatureComponents = `${this.clientId}:${timestamp}:${digest}`;
+        
+        return crypto
+            .createHmac('sha256', this.secretKey)
+            .update(signatureComponents)
+            .digest('base64');
+    }
+
+    async createPayment(options) {
+        try {
+            const orderId = options.orderId || `ORDER-${Date.now()}`;
+            const timestamp = new Date().toISOString();
+            
+            const paymentData = {
+                order: {
+                    invoice_number: orderId,
+                    amount: parseFloat(options.amount)
+                },
+                payment: {
+                    payment_due_date: options.dueDate || new Date(Date.now() + 24*60*60*1000).toISOString().split('T')[0]
+                },
+                customer: {
+                    name: options.name || options.customerName || '',
+                    email: options.email || '',
+                    phone: options.phone || ''
+                },
+                callback_url: options.callbackUrl || options.callback_link,
+                return_url: options.successUrl || options.callback_link
+            };
+
+            const signature = this.generateSignature(paymentData, timestamp);
+
+            const response = await this.client.post('/v1/payment-code', paymentData, {
+                headers: {
+                    'Request-Timestamp': timestamp,
+                    'Signature': signature
+                }
+            });
+
+            return {
+                status: 'success',
+                data: {
+                    orderId: orderId,
+                    paymentCode: response.data.payment_code,
+                    amount: paymentData.order.amount,
+                    expiredDate: response.data.expired_date,
+                    virtualAccount: response.data.virtual_account_info
+                }
+            };
+        } catch (error) {
+            throw new Error(`Payment creation error: ${error.response?.data?.error?.message || 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',
+                'PAID': 'success',
+                'PENDING': 'pending',
+                'FAILED': 'failed',
+                'EXPIRED': 'failed'
+            };
+
+            return {
+                status: statusMapping[callbackData.transaction.status] || 'unknown',
+                orderId: callbackData.order.invoice_number,
+                transactionId: callbackData.transaction.id,
+                amount: parseFloat(callbackData.order.amount),
+                currency: 'IDR',
+                paymentStatus: callbackData.transaction.status,
+                paymentChannel: callbackData.payment_channel
+            };
+        } catch (error) {
+            throw new Error(`Error in Doku callback handling: ${error.message}`);
+        }
+    }
+
+    async verifyCallback(data) {
+        try {
+            const receivedSignature = data.signature;
+            const timestamp = data.timestamp;
+            
+            const callbackData = { ...data };
+            delete callbackData.signature;
+            delete callbackData.timestamp;
+
+            const expectedSignature = this.generateSignature(callbackData, timestamp);
+
+            if (receivedSignature !== expectedSignature) {
+                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 checkPaymentStatus(invoiceNumber) {
+        try {
+            const timestamp = new Date().toISOString();
+            const requestData = { invoice_number: invoiceNumber };
+            const signature = this.generateSignature(requestData, timestamp);
+
+            const response = await this.client.get(`/v1/payment-code/${invoiceNumber}`, {
+                headers: {
+                    'Request-Timestamp': timestamp,
+                    'Signature': signature
+                }
+            });
+
+            return response.data;
+        } catch (error) {
+            throw new Error(`Error checking payment status: ${error.response?.data?.error?.message || error.message}`);
+        }
+    }
+}
+
+module.exports = DokuClient;

package/lib/epay.js

@@ -0,0 +1,175 @@
+const axios = require('axios');
+const crypto = require('crypto');
+
+class EpayClient {
+    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 = 'https://epay.bg';
+
+        this.client = axios.create({
+            baseURL: this.baseURL,
+            headers: {
+                'Content-Type': 'application/x-www-form-urlencoded'
+            }
+        });
+    }
+
+    generateChecksum(data) {
+        const fields = [
+            data.MIN,
+            data.INVOICE,
+            data.AMOUNT,
+            data.EXP_TIME,
+            data.DESCR
+        ];
+        
+        const dataString = fields.join('');
+        const hmac = crypto.createHmac('sha1', this.secretKey);
+        hmac.update(dataString);
+        return hmac.digest('hex');
+    }
+
+    async createPayment(options) {
+        try {
+            const orderId = options.orderId || `ORDER-${Date.now()}`;
+            const amount = parseFloat(options.amount).toFixed(2);
+            const expirationTime = options.expirationTime || this.getExpirationTime(24); // 24 hours
+            
+            const paymentData = {
+                MIN: this.merchantId,
+                INVOICE: orderId,
+                AMOUNT: amount,
+                EXP_TIME: expirationTime,
+                DESCR: options.description || options.name || 'Payment',
+                ENCODING: 'UTF-8'
+            };
+
+            paymentData.CHECKSUM = this.generateChecksum(paymentData);
+
+            // Create payment URL
+            const params = new URLSearchParams(paymentData);
+            const paymentUrl = `${this.baseURL}/ezp/reg_bill.php?${params.toString()}`;
+
+            return {
+                status: 'success',
+                data: {
+                    url: paymentUrl,
+                    orderId: orderId,
+                    amount: amount,
+                    expirationTime: expirationTime
+                }
+            };
+        } 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 = {
+                'PAID': 'success',
+                'DENIED': 'failed',
+                'EXPIRED': 'failed'
+            };
+
+            return {
+                status: statusMapping[callbackData.STATUS] || 'unknown',
+                orderId: callbackData.INVOICE,
+                transactionId: callbackData.STAN,
+                amount: parseFloat(callbackData.AMOUNT),
+                currency: 'BGN',
+                paymentStatus: callbackData.STATUS,
+                paymentDate: callbackData.PAY_TIME,
+                cardBrand: callbackData.CARD
+            };
+        } catch (error) {
+            throw new Error(`Error in ePay callback handling: ${error.message}`);
+        }
+    }
+
+    async verifyCallback(data) {
+        try {
+            const encoded = data.encoded || data.ENCODED;
+            
+            if (!encoded) {
+                return {
+                    status: false,
+                    error: {
+                        code: 400,
+                        message: 'Encoded data not found'
+                    }
+                };
+            }
+
+            // Decode base64
+            const decoded = Buffer.from(encoded, 'base64').toString('utf-8');
+            
+            // Parse data
+            const params = {};
+            decoded.split(':').forEach(pair => {
+                const [key, value] = pair.split('=');
+                if (key && value) {
+                    params[key] = value;
+                }
+            });
+
+            // Verify checksum
+            const receivedChecksum = params.CHECKSUM;
+            delete params.CHECKSUM;
+            
+            const calculatedChecksum = this.generateChecksum(params);
+            
+            if (receivedChecksum !== calculatedChecksum) {
+                return {
+                    status: false,
+                    error: {
+                        code: 401,
+                        message: 'Invalid checksum'
+                    }
+                };
+            }
+
+            return {
+                status: true,
+                data: params
+            };
+        } catch (error) {
+            return {
+                status: false,
+                error: {
+                    code: 500,
+                    message: error.message
+                }
+            };
+        }
+    }
+
+    getExpirationTime(hours = 24) {
+        const date = new Date();
+        date.setHours(date.getHours() + hours);
+        
+        const year = date.getFullYear();
+        const month = String(date.getMonth() + 1).padStart(2, '0');
+        const day = String(date.getDate()).padStart(2, '0');
+        const hour = String(date.getHours()).padStart(2, '0');
+        const minute = String(date.getMinutes()).padStart(2, '0');
+        const second = String(date.getSeconds()).padStart(2, '0');
+        
+        return `${year}${month}${day}${hour}${minute}${second}`;
+    }
+}
+
+module.exports = EpayClient;