quickpos 1.0.910 → 1.0.912

package/lib/unitpay.js

@@ -0,0 +1,223 @@
+const axios = require('axios');
+const crypto = require('crypto');
+
+class UnitpayClient {
+    constructor(config) {
+        const requiredFields = ['publicKey', 'secretKey'];
+        for (let field of requiredFields) {
+            if (!config[field]) throw new Error(`Missing required field: ${field}`);
+        }
+
+        this.publicKey = config.publicKey;
+        this.secretKey = config.secretKey;
+        this.domain = config.domain || 'unitpay.ru';
+        this.baseURL = `https://${this.domain}/api`;
+
+        this.client = axios.create({
+            baseURL: this.baseURL,
+            headers: {
+                'Content-Type': 'application/json'
+            }
+        });
+    }
+
+    generateSignature(params) {
+        const sorted = Object.keys(params).sort().reduce((acc, key) => {
+            if (params[key] !== undefined && params[key] !== null) {
+                acc[key] = params[key];
+            }
+            return acc;
+        }, {});
+
+        const signatureString = Object.entries(sorted)
+            .map(([key, value]) => value)
+            .join('{up}');
+
+        return crypto
+            .createHash('sha256')
+            .update(signatureString + '{up}' + this.secretKey)
+            .digest('hex');
+    }
+
+    async createPayment(options) {
+        try {
+            const orderId = options.orderId || `ORDER-${Date.now()}`;
+            
+            const params = {
+                account: options.account || orderId,
+                sum: parseFloat(options.amount).toFixed(2),
+                desc: options.description || options.name || 'Payment',
+                currency: options.currency || 'RUB',
+                resultUrl: options.callbackUrl || options.callback_link,
+                successUrl: options.successUrl || options.callback_link,
+                errorUrl: options.failureUrl || options.callback_link,
+                customerEmail: options.email || '',
+                customerPhone: options.phone || '',
+                locale: options.locale || 'ru'
+            };
+
+            params.signature = this.generateSignature({
+                account: params.account,
+                currency: params.currency,
+                desc: params.desc,
+                sum: params.sum
+            });
+
+            // Create payment URL
+            const paymentUrl = `https://${this.domain}/pay/${this.publicKey}?` + 
+                new URLSearchParams(params).toString();
+
+            return {
+                status: 'success',
+                data: {
+                    url: paymentUrl,
+                    orderId: orderId,
+                    account: params.account,
+                    amount: params.sum,
+                    currency: params.currency
+                }
+            };
+        } catch (error) {
+            throw new Error(`Payment creation error: ${error.message}`);
+        }
+    }
+
+    async handleCallback(callbackData) {
+        try {
+            const method = callbackData.method;
+            const params = callbackData.params || callbackData;
+
+            // Verify signature
+            const verification = await this.verifyCallback(params, method);
+            
+            if (!verification.status) {
+                throw new Error(verification.error.message);
+            }
+
+            // Handle different methods
+            if (method === 'check') {
+                // Payment check - validate order
+                return {
+                    status: 'pending',
+                    orderId: params.account,
+                    message: 'Order validation'
+                };
+            } else if (method === 'pay') {
+                // Payment successful
+                return {
+                    status: 'success',
+                    orderId: params.account,
+                    transactionId: params.unitpayId,
+                    amount: parseFloat(params.orderSum),
+                    currency: params.orderCurrency || 'RUB',
+                    paymentStatus: 'completed',
+                    paymentType: params.paymentType,
+                    profit: parseFloat(params.profit || 0)
+                };
+            } else if (method === 'error') {
+                // Payment error
+                return {
+                    status: 'failed',
+                    orderId: params.account,
+                    message: params.message || 'Payment failed'
+                };
+            } else if (method === 'refund') {
+                // Refund notification
+                return {
+                    status: 'refunded',
+                    orderId: params.account,
+                    transactionId: params.unitpayId,
+                    amount: parseFloat(params.orderSum)
+                };
+            }
+
+            throw new Error(`Unknown method: ${method}`);
+        } catch (error) {
+            throw new Error(`Error in Unitpay callback handling: ${error.message}`);
+        }
+    }
+
+    async verifyCallback(params, method) {
+        try {
+            const receivedSignature = params.signature;
+            
+            let signatureParams;
+            if (method === 'check') {
+                signatureParams = {
+                    account: params.account,
+                    orderSum: params.orderSum,
+                    orderCurrency: params.orderCurrency,
+                    method: method
+                };
+            } else if (method === 'pay') {
+                signatureParams = {
+                    account: params.account,
+                    orderSum: params.orderSum,
+                    orderCurrency: params.orderCurrency,
+                    profit: params.profit,
+                    method: method
+                };
+            } else if (method === 'refund') {
+                signatureParams = {
+                    account: params.account,
+                    orderSum: params.orderSum,
+                    method: method
+                };
+            } else {
+                signatureParams = params;
+            }
+
+            const expectedSignature = this.generateSignature(signatureParams);
+
+            if (receivedSignature !== expectedSignature) {
+                return {
+                    status: false,
+                    error: {
+                        code: 401,
+                        message: 'Invalid signature'
+                    }
+                };
+            }
+
+            return {
+                status: true,
+                data: params
+            };
+        } catch (error) {
+            return {
+                status: false,
+                error: {
+                    code: 500,
+                    message: error.message
+                }
+            };
+        }
+    }
+
+    async initPayment(options) {
+        try {
+            // API method to init payment and get payment ID
+            const params = {
+                account: options.account || options.orderId || `ORDER-${Date.now()}`,
+                sum: parseFloat(options.amount).toFixed(2),
+                projectId: this.publicKey,
+                desc: options.description || 'Payment',
+                currency: options.currency || 'RUB',
+                resultUrl: options.callbackUrl || options.callback_link,
+                secretKey: this.secretKey
+            };
+
+            const response = await this.client.get('/initPayment', { params });
+
+            if (response.data.result) {
+                return response.data.result;
+            } else {
+                throw new Error(response.data.error?.message || 'Payment initialization failed');
+            }
+        } catch (error) {
+            throw new Error(`Error initializing payment: ${error.response?.data?.error?.message || error.message}`);
+        }
+    }
+}
+
+module.exports = UnitpayClient;

package/lib/urway.js

@@ -0,0 +1,182 @@
+const axios = require('axios');
+const crypto = require('crypto');
+
+class URWayClient {
+    constructor(config) {
+        const requiredFields = ['terminalId', 'password', 'merchantKey'];
+        for (let field of requiredFields) {
+            if (!config[field]) throw new Error(`Missing required field: ${field}`);
+        }
+
+        this.terminalId = config.terminalId;
+        this.password = config.password;
+        this.merchantKey = config.merchantKey;
+        this.baseURL = config.testMode 
+            ? 'https://payments-dev.urway-tech.com/URWAYPGService/transaction/jsonProcess/JSONrequest' 
+            : 'https://payments.urway-tech.com/URWAYPGService/transaction/jsonProcess/JSONrequest';
+
+        this.client = axios.create({
+            headers: {
+                'Content-Type': 'application/json'
+            }
+        });
+    }
+
+    generateHash(trackId, amount, currency) {
+        const hashString = `${trackId}|${this.terminalId}|${this.password}|${this.merchantKey}|${amount}|${currency}`;
+        return crypto.createHash('sha256').update(hashString).digest('hex');
+    }
+
+    async createPayment(options) {
+        try {
+            const orderId = options.orderId || `ORDER-${Date.now()}`;
+            const trackId = options.trackId || orderId;
+            const amount = parseFloat(options.amount).toFixed(2);
+            const currency = options.currency || 'SAR';
+            
+            const requestHash = this.generateHash(trackId, amount, currency);
+
+            const paymentData = {
+                trackid: trackId,
+                terminalId: this.terminalId,
+                customerEmail: options.email || '',
+                action: '1', // Purchase action
+                merchantIp: options.merchantIp || '',
+                password: this.password,
+                currency: currency,
+                country: options.country || 'SA',
+                amount: amount,
+                requestHash: requestHash,
+                udf1: options.udf1 || '',
+                udf2: options.udf2 || orderId,
+                udf3: options.udf3 || '',
+                udf4: options.udf4 || '',
+                udf5: options.udf5 || '',
+                tokenizationType: options.tokenization || '0'
+            };
+
+            const response = await this.client.post(this.baseURL, paymentData);
+
+            if (response.data.responseCode === '000') {
+                return {
+                    status: 'success',
+                    data: {
+                        url: response.data.paymentUrl || response.data.targetUrl,
+                        trackId: trackId,
+                        orderId: orderId,
+                        amount: amount,
+                        currency: currency,
+                        payid: response.data.payid
+                    }
+                };
+            } else {
+                throw new Error(response.data.responseMessage || 'Payment creation failed');
+            }
+        } catch (error) {
+            throw new Error(`Payment creation error: ${error.response?.data?.responseMessage || error.message}`);
+        }
+    }
+
+    async handleCallback(callbackData) {
+        try {
+            const trackId = callbackData.trackid || callbackData.TrackId;
+            
+            if (!trackId) {
+                throw new Error('Track ID not found in callback data');
+            }
+
+            // Verify transaction hash
+            const verification = await this.verifyTransaction(callbackData);
+            
+            if (!verification.status) {
+                throw new Error(verification.error.message);
+            }
+
+            // Status mapping
+            const statusMapping = {
+                '000': 'success', // Approved
+                '001': 'pending', // In progress
+                '100': 'failed',  // Declined
+                '400': 'failed',  // Error
+                '401': 'failed'   // Invalid
+            };
+
+            return {
+                status: statusMapping[callbackData.responseCode] || 'unknown',
+                orderId: callbackData.udf2 || trackId,
+                trackId: trackId,
+                transactionId: callbackData.TranId || callbackData.tranid,
+                amount: parseFloat(callbackData.amount),
+                currency: callbackData.currency || 'SAR',
+                paymentStatus: callbackData.result,
+                responseCode: callbackData.responseCode,
+                responseMessage: callbackData.responseMessage,
+                authCode: callbackData.auth,
+                paymentId: callbackData.payid
+            };
+        } catch (error) {
+            throw new Error(`Error in URWay callback handling: ${error.message}`);
+        }
+    }
+
+    async verifyTransaction(data) {
+        try {
+            const receivedHash = data.responseHash;
+            const trackId = data.trackid || data.TrackId;
+            const amount = data.amount;
+            const currency = data.currency || 'SAR';
+            
+            const expectedHash = this.generateHash(trackId, amount, currency);
+
+            if (receivedHash && receivedHash !== expectedHash) {
+                return {
+                    status: false,
+                    error: {
+                        code: 401,
+                        message: 'Invalid transaction hash'
+                    }
+                };
+            }
+
+            return {
+                status: true,
+                data: data
+            };
+        } catch (error) {
+            return {
+                status: false,
+                error: {
+                    code: 500,
+                    message: error.message
+                }
+            };
+        }
+    }
+
+    async refund(trackId, options = {}) {
+        try {
+            const amount = parseFloat(options.amount).toFixed(2);
+            const currency = options.currency || 'SAR';
+            
+            const requestHash = this.generateHash(trackId, amount, currency);
+
+            const refundData = {
+                trackid: trackId,
+                terminalId: this.terminalId,
+                password: this.password,
+                action: '2', // Refund action
+                amount: amount,
+                currency: currency,
+                requestHash: requestHash
+            };
+
+            const response = await this.client.post(this.baseURL, refundData);
+
+            return response.data;
+        } catch (error) {
+            throw new Error(`Error processing refund: ${error.response?.data?.responseMessage || error.message}`);
+        }
+    }
+}
+
+module.exports = URWayClient;

package/lib/volet.js

@@ -0,0 +1,147 @@
+const axios = require('axios');
+const crypto = require('crypto');
+
+class VoletClient {
+    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://volet.com/sci';
+
+        this.client = axios.create({
+            baseURL: this.URL,
+            headers: {
+                'Content-Type': 'application/x-www-form-urlencoded'
+            }
+        });
+    }
+
+    generateSignature(data) {
+        const signatureString = Object.keys(data)
+            .sort()
+            .map(key => `${key}=${data[key]}`)
+            .join(':');
+        
+        return crypto
+            .createHash('md5')
+            .update(signatureString + ':' + this.secretKey)
+            .digest('hex');
+    }
+
+    async createPayment(options) {
+        try {
+            const orderId = options.orderId || `ORDER-${Date.now()}`;
+            
+            const paymentData = {
+                v_merchant_id: this.merchantId,
+                v_amount: parseFloat(options.amount),
+                v_currency: options.currency || 'USD',
+                v_description: options.description || options.name || 'Payment',
+                v_order_id: orderId,
+                v_success_url: options.successUrl || options.callback_link,
+                v_fail_url: options.failUrl || options.callback_link,
+                v_status_url: options.callbackUrl || options.callback_link,
+                v_email: options.email || '',
+                v_phone: options.phone || ''
+            };
+
+            // Generate signature
+            paymentData.v_sign = this.generateSignature(paymentData);
+
+            // Create payment URL
+            const params = new URLSearchParams(paymentData);
+            const paymentUrl = `${this.URL}?${params.toString()}`;
+
+            return {
+                status: 'success',
+                data: {
+                    url: paymentUrl,
+                    orderId: orderId,
+                    merchantId: this.merchantId
+                }
+            };
+        } 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);
+            }
+
+            const data = verification.data;
+            
+            // Status mapping
+            const statusMapping = {
+                'SUCCESS': 'success',
+                'PENDING': 'pending',
+                'FAIL': 'failed'
+            };
+
+            return {
+                status: statusMapping[data.v_status] || 'unknown',
+                orderId: data.v_order_id,
+                transactionId: data.v_transaction_id,
+                amount: parseFloat(data.v_amount),
+                currency: data.v_currency,
+                paymentStatus: data.v_status,
+                paymentMethod: data.v_payment_method
+            };
+        } catch (error) {
+            throw new Error(`Error in Volet callback handling: ${error.message}`);
+        }
+    }
+
+    async verifyCallback(data) {
+        try {
+            const receivedSign = data.v_sign;
+            const dataToVerify = { ...data };
+            delete dataToVerify.v_sign;
+
+            const expectedSign = this.generateSignature(dataToVerify);
+
+            if (receivedSign !== expectedSign) {
+                return {
+                    status: false,
+                    error: {
+                        code: 401,
+                        message: 'Invalid signature'
+                    }
+                };
+            }
+
+            if (data.v_status === 'FAIL') {
+                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 = VoletClient;