quickpos 1.0.910 → 1.0.912

package/lib/paysend.js

@@ -0,0 +1,189 @@
+const axios = require('axios');
+
+class PaysendClient {
+    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.isSandbox = config.sandbox || false;
+
+        this.URL = this.isSandbox
+            ? 'https://sandbox.paysend.com/v1'
+            : 'https://api.paysend.com/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(`Paysend API error: ${error.response.data.message || error.message}`);
+            }
+            throw new Error(`Paysend API error: ${error.message}`);
+        });
+    }
+
+    async createPayment(options) {
+        try {
+            const requestData = {
+                amount: parseFloat(options.amount),
+                currency: options.currency || 'USD',
+                recipient: {
+                    type: options.recipientType || 'card',
+                    card_number: options.cardNumber || '',
+                    name: options.recipientName || options.name || 'Recipient'
+                },
+                sender: {
+                    name: options.senderName || 'Sender',
+                    email: options.senderEmail || options.email,
+                    phone: options.senderPhone || options.phone || ''
+                },
+                reference: options.reference || options.orderId || `ORDER-${Date.now()}`,
+                description: options.description || options.name || 'Payment',
+                callback_url: options.callbackUrl || options.callback_link,
+                redirect_url: options.redirectUrl || options.callback_link
+            };
+
+            const response = await this.client.post('/transfers', requestData);
+
+            return {
+                status: 'success',
+                data: {
+                    transferId: response.data.id,
+                    status: response.data.status,
+                    amount: response.data.amount,
+                    currency: response.data.currency,
+                    reference: response.data.reference,
+                    createdAt: response.data.created_at
+                }
+            };
+        } catch (error) {
+            throw new Error(`Payment creation error: ${error.message}`);
+        }
+    }
+
+    async getTransferStatus(transferId) {
+        try {
+            const response = await this.client.get(`/transfers/${transferId}`);
+            return response.data;
+        } catch (error) {
+            throw new Error(`Transfer 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 = {
+                'completed': 'success',
+                'processing': 'pending',
+                'pending': 'pending',
+                'failed': 'failed',
+                'cancelled': 'cancelled'
+            };
+
+            return {
+                status: statusMapping[data.status] || 'unknown',
+                transferId: data.id,
+                orderId: data.reference,
+                amount: parseFloat(data.amount),
+                currency: data.currency,
+                transferStatus: data.status,
+                completedAt: data.completed_at,
+                failureReason: data.failure_reason
+            };
+        } catch (error) {
+            throw new Error(`Error in Paysend callback handling: ${error.message}`);
+        }
+    }
+
+    async verifyCallback(data) {
+        try {
+            if (data.status === 'failed') {
+                return {
+                    status: false,
+                    error: {
+                        code: 400,
+                        message: data.failure_reason || 'Transfer failed'
+                    }
+                };
+            }
+
+            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('/balance');
+            return response.data;
+        } catch (error) {
+            throw new Error(`Balance error: ${error.message}`);
+        }
+    }
+
+    async getExchangeRate(fromCurrency, toCurrency, amount) {
+        try {
+            const response = await this.client.get('/rates', {
+                params: {
+                    from: fromCurrency,
+                    to: toCurrency,
+                    amount: amount
+                }
+            });
+            return response.data;
+        } catch (error) {
+            throw new Error(`Exchange rate error: ${error.message}`);
+        }
+    }
+
+    async getSupportedCountries() {
+        try {
+            const response = await this.client.get('/countries');
+            return response.data;
+        } catch (error) {
+            throw new Error(`Supported countries error: ${error.message}`);
+        }
+    }
+
+    async validateCard(cardNumber) {
+        try {
+            const response = await this.client.post('/cards/validate', {
+                card_number: cardNumber
+            });
+            return response.data;
+        } catch (error) {
+            throw new Error(`Card validation error: ${error.message}`);
+        }
+    }
+}
+
+module.exports = PaysendClient;

package/lib/payspace.js

@@ -0,0 +1,168 @@
+const axios = require('axios');
+const crypto = require('crypto');
+
+class PaySpaceClient {
+    constructor(config) {
+        const requiredFields = ['merchantId', 'apiKey'];
+        for (let field of requiredFields) {
+            if (!config[field]) throw new Error(`Missing required field: ${field}`);
+        }
+
+        this.merchantId = config.merchantId;
+        this.apiKey = config.apiKey;
+        this.baseURL = 'https://api.payspace.com';
+
+        this.client = axios.create({
+            baseURL: this.baseURL,
+            headers: {
+                'Content-Type': 'application/json',
+                'Authorization': `Bearer ${this.apiKey}`
+            }
+        });
+    }
+
+    generateSignature(data) {
+        const signatureString = Object.keys(data)
+            .filter(key => key !== 'signature')
+            .sort()
+            .map(key => `${key}=${data[key]}`)
+            .join('&');
+        
+        return crypto
+            .createHash('sha256')
+            .update(signatureString + this.apiKey)
+            .digest('hex');
+    }
+
+    async createPayment(options) {
+        try {
+            const orderId = options.orderId || `ORDER-${Date.now()}`;
+            
+            const paymentData = {
+                merchant_id: this.merchantId,
+                order_id: orderId,
+                amount: parseFloat(options.amount),
+                currency: options.currency || 'ZAR',
+                description: options.description || options.name || 'Payment',
+                return_url: options.successUrl || options.callback_link,
+                cancel_url: options.failUrl || options.callback_link,
+                notify_url: options.callbackUrl || options.callback_link,
+                customer_email: options.email || '',
+                customer_name: options.name || '',
+                customer_phone: options.phone || ''
+            };
+
+            paymentData.signature = this.generateSignature(paymentData);
+
+            const response = await this.client.post('/v1/payments', paymentData);
+
+            if (response.data.success) {
+                return {
+                    status: 'success',
+                    data: {
+                        url: response.data.payment_url,
+                        orderId: orderId,
+                        paymentId: response.data.payment_id,
+                        amount: paymentData.amount,
+                        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);
+            }
+
+            // Status mapping
+            const statusMapping = {
+                'completed': 'success',
+                'successful': 'success',
+                'failed': 'failed',
+                'cancelled': 'failed',
+                'pending': 'pending',
+                'processing': 'pending'
+            };
+
+            return {
+                status: statusMapping[callbackData.status.toLowerCase()] || 'unknown',
+                orderId: callbackData.order_id,
+                transactionId: callbackData.payment_id || callbackData.transaction_id,
+                amount: parseFloat(callbackData.amount),
+                currency: callbackData.currency,
+                paymentStatus: callbackData.status,
+                paymentMethod: callbackData.payment_method
+            };
+        } catch (error) {
+            throw new Error(`Error in PaySpace 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 response = await this.client.get(`/v1/payments/${paymentId}`);
+            return response.data;
+        } catch (error) {
+            throw new Error(`Error getting payment status: ${error.response?.data?.message || error.message}`);
+        }
+    }
+
+    async refundPayment(paymentId, options = {}) {
+        try {
+            const refundData = {
+                payment_id: paymentId,
+                amount: options.amount,
+                reason: options.reason || 'Customer request'
+            };
+
+            const response = await this.client.post('/v1/refunds', refundData);
+            return response.data;
+        } catch (error) {
+            throw new Error(`Error creating refund: ${error.response?.data?.message || error.message}`);
+        }
+    }
+}
+
+module.exports = PaySpaceClient;

package/lib/payssion.js

@@ -0,0 +1,177 @@
+const axios = require('axios');
+const crypto = require('crypto');
+
+class PayssionClient {
+    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.baseURL = config.sandbox 
+            ? 'https://sandbox.payssion.com/api/v1' 
+            : 'https://www.payssion.com/api/v1';
+
+        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]) acc[key] = params[key];
+            return acc;
+        }, {});
+
+        const signatureString = Object.entries(sorted)
+            .map(([key, value]) => `${key}=${value}`)
+            .join('|');
+
+        return crypto
+            .createHash('md5')
+            .update(signatureString + '|' + this.secretKey)
+            .digest('hex');
+    }
+
+    async createPayment(options) {
+        try {
+            const orderId = options.orderId || `ORDER-${Date.now()}`;
+            
+            const params = {
+                api_key: this.apiKey,
+                pm_id: options.paymentMethod || 'boleto_br', // Payment method ID
+                amount: parseFloat(options.amount).toFixed(2),
+                currency: options.currency || 'USD',
+                description: options.description || options.name || 'Payment',
+                order_id: orderId,
+                return_url: options.successUrl || options.callback_link,
+                notify_url: options.callbackUrl || options.callback_link
+            };
+
+            params.api_sig = this.generateSignature(params);
+
+            const response = await this.client.post('/payment/create', params);
+
+            if (response.data.result_code === 200) {
+                return {
+                    status: 'success',
+                    data: {
+                        transactionId: response.data.transaction.transaction_id,
+                        url: response.data.transaction.redirect_url,
+                        orderId: orderId,
+                        amount: params.amount,
+                        currency: params.currency,
+                        state: response.data.transaction.state
+                    }
+                };
+            } else {
+                throw new Error(response.data.description || 'Payment creation failed');
+            }
+        } catch (error) {
+            throw new Error(`Payment creation error: ${error.response?.data?.description || error.message}`);
+        }
+    }
+
+    async handleCallback(callbackData) {
+        try {
+            const verification = await this.verifyCallback(callbackData);
+            
+            if (!verification.status) {
+                throw new Error(verification.error.message);
+            }
+
+            // Get transaction details
+            const transaction = await this.getTransactionDetails(callbackData.transaction_id);
+
+            // Status mapping
+            const statusMapping = {
+                'completed': 'success',
+                'paid_partial': 'pending',
+                'pending': 'pending',
+                'failed': 'failed',
+                'expired': 'failed',
+                'refund': 'refunded',
+                'cancelled': 'failed'
+            };
+
+            return {
+                status: statusMapping[transaction.state] || 'unknown',
+                orderId: transaction.order_id,
+                transactionId: transaction.transaction_id,
+                amount: parseFloat(transaction.amount),
+                currency: transaction.currency,
+                paymentStatus: transaction.state,
+                paidAmount: parseFloat(transaction.paid || 0)
+            };
+        } catch (error) {
+            throw new Error(`Error in Payssion callback handling: ${error.message}`);
+        }
+    }
+
+    async verifyCallback(data) {
+        try {
+            const receivedSig = data.notify_sig;
+            const params = {
+                api_key: this.apiKey,
+                transaction_id: data.transaction_id,
+                order_id: data.order_id,
+                state: data.state,
+                amount: data.amount,
+                currency: data.currency
+            };
+
+            const expectedSig = this.generateSignature(params);
+
+            if (receivedSig !== expectedSig) {
+                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 getTransactionDetails(transactionId) {
+        try {
+            const params = {
+                api_key: this.apiKey,
+                transaction_id: transactionId
+            };
+
+            params.api_sig = this.generateSignature(params);
+
+            const response = await this.client.post('/payment/details', params);
+
+            if (response.data.result_code === 200) {
+                return response.data.transaction;
+            } else {
+                throw new Error(response.data.description || 'Failed to get transaction details');
+            }
+        } catch (error) {
+            throw new Error(`Error getting transaction details: ${error.response?.data?.description || error.message}`);
+        }
+    }
+}
+
+module.exports = PayssionClient;

package/lib/paytabs.js

@@ -0,0 +1,145 @@
+const axios = require('axios');
+const crypto = require('crypto');
+
+class PayTabsClient {
+    constructor(config) {
+        const requiredFields = ['profileId', 'serverKey'];
+        for (let field of requiredFields) {
+            if (!config[field]) throw new Error(`Missing required field: ${field}`);
+        }
+
+        this.profileId = config.profileId;
+        this.serverKey = config.serverKey;
+        this.region = config.region || 'ARE'; // ARE, SAU, OMN, JOR, EGY, etc.
+        
+        const regionUrls = {
+            'ARE': 'https://secure.paytabs.com',
+            'SAU': 'https://secure.paytabs.sa',
+            'OMN': 'https://secure-oman.paytabs.com',
+            'JOR': 'https://secure-jordan.paytabs.com',
+            'EGY': 'https://secure-egypt.paytabs.com',
+            'global': 'https://secure-global.paytabs.com'
+        };
+
+        this.baseURL = regionUrls[this.region] || regionUrls['global'];
+
+        this.client = axios.create({
+            baseURL: this.baseURL,
+            headers: {
+                'Content-Type': 'application/json',
+                'Authorization': this.serverKey
+            }
+        });
+    }
+
+    async createPayment(options) {
+        try {
+            const orderId = options.orderId || `ORDER-${Date.now()}`;
+            
+            const paymentData = {
+                profile_id: this.profileId,
+                tran_type: options.tranType || 'sale',
+                tran_class: options.tranClass || 'ecom',
+                cart_id: orderId,
+                cart_description: options.description || options.name || 'Payment',
+                cart_currency: options.currency || 'AED',
+                cart_amount: parseFloat(options.amount).toFixed(2),
+                callback: options.callbackUrl || options.callback_link,
+                return: options.successUrl || options.callback_link,
+                customer_details: {
+                    name: options.name || options.customerName || '',
+                    email: options.email || '',
+                    phone: options.phone || '',
+                    street1: options.address || '',
+                    city: options.city || '',
+                    state: options.state || '',
+                    country: options.country || 'AE',
+                    zip: options.zip || ''
+                },
+                hide_shipping: options.hideShipping !== false
+            };
+
+            const response = await this.client.post('/payment/request', paymentData);
+
+            return {
+                status: 'success',
+                data: {
+                    transactionRef: response.data.tran_ref,
+                    url: response.data.redirect_url,
+                    orderId: orderId,
+                    amount: paymentData.cart_amount,
+                    currency: paymentData.cart_currency
+                }
+            };
+        } catch (error) {
+            throw new Error(`Payment creation error: ${error.response?.data?.message || error.message}`);
+        }
+    }
+
+    async handleCallback(callbackData) {
+        try {
+            const transactionRef = callbackData.tran_ref || callbackData.tranRef;
+            
+            if (!transactionRef) {
+                throw new Error('Transaction reference not found in callback data');
+            }
+
+            // Verify payment
+            const payment = await this.verifyPayment(transactionRef);
+
+            // Status mapping
+            const statusMapping = {
+                'A': 'success', // Authorized/Approved
+                'H': 'pending', // On Hold
+                'P': 'pending', // Pending
+                'V': 'pending', // Voided
+                'E': 'failed',  // Error
+                'D': 'failed'   // Declined
+            };
+
+            return {
+                status: statusMapping[payment.payment_result?.response_status] || 'unknown',
+                orderId: payment.cart_id,
+                transactionRef: payment.tran_ref,
+                amount: parseFloat(payment.cart_amount),
+                currency: payment.cart_currency,
+                paymentStatus: payment.payment_result?.response_status,
+                responseCode: payment.payment_result?.response_code,
+                responseMessage: payment.payment_result?.response_message
+            };
+        } catch (error) {
+            throw new Error(`Error in PayTabs callback handling: ${error.message}`);
+        }
+    }
+
+    async verifyPayment(transactionRef) {
+        try {
+            const response = await this.client.post('/payment/query', {
+                profile_id: this.profileId,
+                tran_ref: transactionRef
+            });
+
+            return response.data;
+        } catch (error) {
+            throw new Error(`Error verifying payment: ${error.response?.data?.message || error.message}`);
+        }
+    }
+
+    async refundPayment(transactionRef, options = {}) {
+        try {
+            const response = await this.client.post('/payment/refund', {
+                profile_id: this.profileId,
+                tran_ref: transactionRef,
+                cart_amount: options.amount,
+                cart_description: options.description || 'Refund',
+                cart_id: options.orderId
+            });
+
+            return response.data;
+        } catch (error) {
+            throw new Error(`Error processing refund: ${error.response?.data?.message || error.message}`);
+        }
+    }
+}
+
+module.exports = PayTabsClient;