quickpos 1.0.911 → 1.0.913

package/lib/primepayments.js

@@ -0,0 +1,338 @@
+/**
+ * PrimePayments - JavaScript client for PrimePayments payment service
+ */
+class PrimePayments {
+  /**
+   * Create a new PrimePayments client
+   * @param {Object} config - Configuration options
+   * @param {string} config.projectId - Project ID
+   * @param {string} config.secretWord1 - Secret word 1 for signing requests
+   * @param {string} config.secretWord2 - Secret word 2 for verifying notifications
+   * @param {string} config.payoutKey - Key for payout operations
+   */
+  constructor(config) {
+    this.config = config;
+    this.apiUrl = 'https://pay.primepayments.io/API/v2/';
+  }
+
+  /**
+   * Calculate MD5 hash
+   * @param {string} str - Input string
+   * @returns {string} - MD5 hash
+   */
+  md5(str) {
+    return require('crypto').createHash('md5').update(str).digest('hex');
+  }
+
+  /**
+   * Make an API request to PrimePayments
+   * @param {Object} data - Request data
+   * @returns {Promise<Object>} - Response data
+   */
+  async makeRequest(data) {
+    const queryString = Object.entries(data)
+      .map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`)
+      .join('&');
+
+    try {
+      const response = await fetch(this.apiUrl, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/x-www-form-urlencoded',
+        },
+        body: queryString
+      });
+
+      const result = await response.json();
+      return result;
+    } catch (error) {
+      throw new Error(`PrimePayments API request failed: ${error.message}`);
+    }
+  }
+
+  /**
+   * Initialize a payment and get payment form URL
+   * @param {Object} options - Payment options
+   * @param {number} options.sum - Payment amount
+   * @param {string} options.currency - Payment currency (RUB, UAH, USD, EUR)
+   * @param {string} options.innerID - Internal ID in your system
+   * @param {string} options.email - Customer email
+   * @param {string} [options.payWay] - Preferred payment method (1-cards, 2-Yandex, etc.)
+   * @param {string} [options.comment] - Payment description
+   * @param {boolean} [options.needFailNotice] - Send notification on payment failure
+   * @param {string} [options.lang] - Form language
+   * @param {boolean} [options.strict_payWay] - Force specified payment method
+   * @param {boolean} [options.block_payWay] - Block other payment methods
+   * @param {boolean} [options.directPay] - Direct payment without intermediate page
+   * @returns {Promise<Object>} - Response with payment URL
+   */
+  async initPayment(options) {
+    const data = {
+      action: 'initPayment',
+      project: this.config.projectId,
+      sum: options.sum,
+      currency: options.currency,
+      innerID: options.innerID,
+      email: options.email,
+    };
+
+    if (options.payWay) data.payWay = options.payWay;
+    if (options.comment) data.comment = options.comment;
+    if (options.needFailNotice) data.needFailNotice = options.needFailNotice;
+    if (options.lang) data.lang = options.lang;
+    if (options.strict_payWay) data.strict_payWay = options.strict_payWay;
+    if (options.block_payWay) data.block_payWay = options.block_payWay;
+    if (options.directPay) data.directPay = options.directPay;
+
+    // Calculate signature
+    let signString = this.config.secretWord1 + data.action + data.project + 
+                     data.sum + data.currency + data.innerID + data.email;
+    
+    if (data.payWay) signString += data.payWay;
+    
+    data.sign = this.md5(signString);
+
+    return this.makeRequest(data);
+  }
+
+  /**
+   * Initialize a payout
+   * @param {Object} options - Payout options
+   * @param {number} options.sum - Payout amount
+   * @param {string} options.currency - Payout currency
+   * @param {string} options.payWay - Payout method
+   * @param {string} options.email - Recipient email
+   * @param {string} options.purse - Card number or wallet
+   * @param {string} [options.comment] - Payout description
+   * @param {string} [options.cardholder] - Card holder name
+   * @param {string} [options.SBP_id] - SBP bank identifier
+   * @param {string} [options.needUnique] - Unique identifier for the payout
+   * @returns {Promise<Object>} - Response with payout ID
+   */
+  async initPayout(options) {
+    const data = {
+      action: 'initPayout',
+      project: this.config.projectId,
+      sum: options.sum,
+      currency: options.currency,
+      payWay: options.payWay,
+      email: options.email,
+      purse: options.purse
+    };
+
+    if (options.comment) data.comment = options.comment;
+    if (options.cardholder) data.cardholder = options.cardholder;
+    if (options.SBP_id) data.SBP_id = options.SBP_id;
+    if (options.needUnique) data.needUnique = options.needUnique;
+
+    // Calculate signature
+    const signString = this.config.payoutKey + data.action + data.project + 
+                       data.sum + data.currency + data.payWay + data.email + data.purse;
+    
+    data.sign = this.md5(signString);
+
+    return this.makeRequest(data);
+  }
+
+  /**
+   * Get order information
+   * @param {string} orderID - Order ID
+   * @returns {Promise<Object>} - Order information
+   */
+  async getOrderInfo(orderID) {
+    const data = {
+      action: 'getOrderInfo',
+      project: this.config.projectId,
+      orderID: orderID
+    };
+
+    // Calculate signature
+    data.sign = this.md5(this.config.secretWord1 + data.action + data.project + data.orderID);
+
+    return this.makeRequest(data);
+  }
+
+  /**
+   * Refund a payment
+   * @param {string} orderID - Order ID to refund
+   * @returns {Promise<Object>} - Refund result
+   */
+  async refund(orderID) {
+    const data = {
+      action: 'refund',
+      orderID: orderID
+    };
+
+    // Calculate signature
+    data.sign = this.md5(this.config.secretWord1 + data.action + data.orderID);
+
+    return this.makeRequest(data);
+  }
+
+  /**
+   * Get project balance
+   * @returns {Promise<Object>} - Project balance information
+   */
+  async getProjectBalance() {
+    const data = {
+      action: 'getProjectBalance',
+      project: this.config.projectId
+    };
+
+    // Calculate signature
+    data.sign = this.md5(this.config.secretWord1 + data.action + data.project);
+
+    return this.makeRequest(data);
+  }
+
+  /**
+   * Get payout information
+   * @param {string} payoutID - Payout ID
+   * @returns {Promise<Object>} - Payout information
+   */
+  async getPayoutInfo(payoutID) {
+    const data = {
+      action: 'getPayoutInfo',
+      project: this.config.projectId,
+      payoutID: payoutID
+    };
+
+    // Calculate signature
+    data.sign = this.md5(this.config.secretWord1 + data.action + data.project + data.payoutID);
+
+    return this.makeRequest(data);
+  }
+
+  /**
+   * Get project information
+   * @returns {Promise<Object>} - Project information and available payment methods
+   */
+  async getProjectInfo() {
+    const data = {
+      action: 'getProjectInfo',
+      project: this.config.projectId
+    };
+
+    // Calculate signature
+    data.sign = this.md5(this.config.secretWord1 + data.action + data.project);
+
+    return this.makeRequest(data);
+  }
+
+  /**
+   * Get exchange rates
+   * @returns {Promise<Object>} - Exchange rates information
+   */
+  async getExchangeRates() {
+    const data = {
+      action: 'getExchangeRates'
+    };
+
+    return this.makeRequest(data);
+  }
+
+  /**
+   * Verify payment notification
+   * @param {Object} postData - POST data from notification
+   * @returns {boolean} - True if signature is valid
+   */
+  verifyPaymentNotification(postData) {
+    if (postData.action === 'order_payed') {
+      const hash = this.md5(this.config.secretWord2 + postData.orderID + 
+                          postData.payWay + postData.innerID + 
+                          postData.sum + postData.webmaster_profit);
+      
+      return hash === postData.sign;
+    } else if (postData.action === 'order_cancel') {
+      const hash = this.md5(this.config.secretWord2 + postData.orderID + postData.innerID);
+      
+      return hash === postData.sign;
+    }
+    
+    return false;
+  }
+
+  /**
+   * Create payment (wrapper for initPayment)
+   * @param {Object} paymentData - Payment data
+   * @returns {Promise<Object>} - Payment result
+   */
+  async createPayment(paymentData) {
+    try {
+      const result = await this.initPayment({
+        amount: paymentData.amount,
+        currency: paymentData.currency || 'USD',
+        description: paymentData.description || 'Payment',
+        order_id: paymentData.orderId,
+        success_url: paymentData.callback_link,
+        fail_url: paymentData.fail_link
+      });
+
+      if (result.result === 'ok') {
+        return {
+          success: true,
+          paymentUrl: result.payment_url,
+          transactionId: result.order_id,
+          amount: paymentData.amount,
+          currency: paymentData.currency
+        };
+      } else {
+        throw new Error(result.message || 'Payment creation failed');
+      }
+    } catch (error) {
+      throw new Error(`PrimePayments payment creation failed: ${error.message}`);
+    }
+  }
+
+  /**
+   * Handle callback/notification
+   * @param {Object} callbackData - Callback data
+   * @returns {Promise<Object>} - Callback result
+   */
+  async handleCallback(callbackData) {
+    try {
+      // Verify notification with secret word 2
+      const isValid = this.verifyNotification(callbackData);
+      
+      if (!isValid) {
+        return {
+          success: false,
+          status: 'invalid',
+          rawData: callbackData
+        };
+      }
+
+      const orderStatus = callbackData.status;
+      const orderId = callbackData.order_id;
+
+      if (orderStatus === 'success') {
+        return {
+          success: true,
+          transactionId: orderId,
+          status: 'completed',
+          amount: parseFloat(callbackData.amount),
+          currency: callbackData.currency,
+          rawData: callbackData
+        };
+      } else if (orderStatus === 'fail') {
+        return {
+          success: false,
+          status: 'failed',
+          transactionId: orderId,
+          rawData: callbackData
+        };
+      } else {
+        return {
+          success: false,
+          status: 'pending',
+          transactionId: orderId,
+          rawData: callbackData
+        };
+      }
+    } catch (error) {
+      throw new Error(`PrimePayments callback handling failed: ${error.message}`);
+    }
+  }
+}
+
+module.exports = PrimePayments;

package/lib/razorpay.js

@@ -0,0 +1,205 @@
+const axios = require('axios');
+const crypto = require('crypto');
+
+class RazorpayClient {
+    constructor(config) {
+        const requiredFields = ['keyId', 'keySecret'];
+        for (let field of requiredFields) {
+            if (!config[field]) throw new Error(`Missing required field: ${field}`);
+        }
+
+        this.keyId = config.keyId;
+        this.keySecret = config.keySecret;
+        this.baseURL = 'https://api.razorpay.com/v1';
+
+        this.client = axios.create({
+            baseURL: this.baseURL,
+            auth: {
+                username: this.keyId,
+                password: this.keySecret
+            },
+            headers: {
+                'Content-Type': 'application/json'
+            }
+        });
+    }
+
+    async createPayment(options) {
+        try {
+            const orderId = options.orderId || `ORDER-${Date.now()}`;
+            
+            // Create Razorpay order
+            const orderData = {
+                amount: Math.round(parseFloat(options.amount) * 100), // Amount in paise
+                currency: options.currency || 'INR',
+                receipt: orderId,
+                notes: {
+                    description: options.description || options.name || 'Payment',
+                    customer_name: options.name || '',
+                    customer_email: options.email || '',
+                    customer_phone: options.phone || ''
+                }
+            };
+
+            const response = await this.client.post('/orders', orderData);
+
+            // For Razorpay, you need to use Checkout.js on frontend
+            // This returns the order details needed for checkout
+            return {
+                status: 'success',
+                data: {
+                    orderId: response.data.id,
+                    orderIdCustom: orderId,
+                    amount: response.data.amount / 100,
+                    currency: response.data.currency,
+                    status: response.data.status,
+                    // These are needed for Razorpay Checkout.js
+                    keyId: this.keyId,
+                    name: options.merchantName || 'Your Business',
+                    description: options.description || 'Payment',
+                    prefill: {
+                        name: options.name || '',
+                        email: options.email || '',
+                        contact: options.phone || ''
+                    },
+                    callback_url: options.callbackUrl || options.callback_link,
+                    redirect: options.redirect !== false
+                }
+            };
+        } catch (error) {
+            throw new Error(`Payment creation error: ${error.response?.data?.error?.description || error.message}`);
+        }
+    }
+
+    async handleCallback(callbackData) {
+        try {
+            // Verify payment signature
+            const verification = await this.verifyPaymentSignature(callbackData);
+            
+            if (!verification.status) {
+                throw new Error(verification.error.message);
+            }
+
+            // Get payment details
+            const payment = await this.getPaymentDetails(callbackData.razorpay_payment_id);
+
+            // Status mapping
+            const statusMapping = {
+                'captured': 'success',
+                'authorized': 'success',
+                'refunded': 'refunded',
+                'failed': 'failed'
+            };
+
+            return {
+                status: statusMapping[payment.status] || 'unknown',
+                orderId: payment.notes?.order_id || payment.order_id,
+                paymentId: payment.id,
+                amount: payment.amount / 100,
+                currency: payment.currency,
+                paymentStatus: payment.status,
+                method: payment.method,
+                email: payment.email,
+                contact: payment.contact,
+                fee: payment.fee / 100,
+                tax: payment.tax / 100
+            };
+        } catch (error) {
+            throw new Error(`Error in Razorpay callback handling: ${error.message}`);
+        }
+    }
+
+    async verifyPaymentSignature(data) {
+        try {
+            const expectedSignature = crypto
+                .createHmac('sha256', this.keySecret)
+                .update(data.razorpay_order_id + '|' + data.razorpay_payment_id)
+                .digest('hex');
+
+            if (expectedSignature !== data.razorpay_signature) {
+                return {
+                    status: false,
+                    error: {
+                        code: 401,
+                        message: 'Invalid payment signature'
+                    }
+                };
+            }
+
+            return {
+                status: true,
+                data: data
+            };
+        } catch (error) {
+            return {
+                status: false,
+                error: {
+                    code: 500,
+                    message: error.message
+                }
+            };
+        }
+    }
+
+    async getPaymentDetails(paymentId) {
+        try {
+            const response = await this.client.get(`/payments/${paymentId}`);
+            return response.data;
+        } catch (error) {
+            throw new Error(`Error getting payment details: ${error.response?.data?.error?.description || error.message}`);
+        }
+    }
+
+    async getOrderDetails(orderId) {
+        try {
+            const response = await this.client.get(`/orders/${orderId}`);
+            return response.data;
+        } catch (error) {
+            throw new Error(`Error getting order details: ${error.response?.data?.error?.description || error.message}`);
+        }
+    }
+
+    async capturePayment(paymentId, amount) {
+        try {
+            const response = await this.client.post(`/payments/${paymentId}/capture`, {
+                amount: Math.round(parseFloat(amount) * 100),
+                currency: 'INR'
+            });
+
+            return response.data;
+        } catch (error) {
+            throw new Error(`Error capturing payment: ${error.response?.data?.error?.description || error.message}`);
+        }
+    }
+
+    async createRefund(paymentId, options = {}) {
+        try {
+            const refundData = {
+                amount: options.amount ? Math.round(parseFloat(options.amount) * 100) : undefined,
+                speed: options.speed || 'normal', // normal or optimum
+                notes: options.notes || {},
+                receipt: options.receipt
+            };
+
+            const response = await this.client.post(`/payments/${paymentId}/refund`, refundData);
+            return response.data;
+        } catch (error) {
+            throw new Error(`Error creating refund: ${error.response?.data?.error?.description || error.message}`);
+        }
+    }
+
+    async verifyWebhookSignature(webhookBody, webhookSignature, webhookSecret) {
+        try {
+            const expectedSignature = crypto
+                .createHmac('sha256', webhookSecret)
+                .update(webhookBody)
+                .digest('hex');
+
+            return expectedSignature === webhookSignature;
+        } catch (error) {
+            return false;
+        }
+    }
+}
+
+module.exports = RazorpayClient;

package/lib/senangpay.js

@@ -0,0 +1,130 @@
+const axios = require('axios');
+const crypto = require('crypto');
+
+class SenangPayClient {
+    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 = config.sandbox 
+            ? 'https://sandbox.senangpay.my/payment' 
+            : 'https://app.senangpay.my/payment';
+    }
+
+    generateHash(detail, amount, orderId) {
+        const hashString = this.secretKey + detail + amount + orderId;
+        return crypto.createHash('md5').update(hashString).digest('hex');
+    }
+
+    async createPayment(options) {
+        try {
+            const orderId = options.orderId || `ORDER-${Date.now()}`;
+            const amount = parseFloat(options.amount).toFixed(2);
+            const detail = options.description || options.name || 'Payment';
+            
+            const hash = this.generateHash(detail, amount, orderId);
+
+            const paymentData = {
+                detail: detail,
+                amount: amount,
+                order_id: orderId,
+                name: options.name || options.customerName || '',
+                email: options.email || '',
+                phone: options.phone || '',
+                hash: hash
+            };
+
+            // Create payment URL
+            const params = new URLSearchParams(paymentData);
+            const paymentUrl = `${this.baseURL}/${this.merchantId}?${params.toString()}`;
+
+            return {
+                status: 'success',
+                data: {
+                    url: paymentUrl,
+                    orderId: orderId,
+                    amount: amount,
+                    currency: 'MYR',
+                    hash: hash
+                }
+            };
+        } 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 = {
+                '1': 'success',  // Success
+                '0': 'failed'    // Failed
+            };
+
+            return {
+                status: statusMapping[callbackData.status_id] || 'unknown',
+                orderId: callbackData.order_id,
+                transactionId: callbackData.transaction_id,
+                amount: parseFloat(callbackData.amount),
+                currency: 'MYR',
+                paymentStatus: callbackData.status_id === '1' ? 'completed' : 'failed',
+                message: callbackData.msg
+            };
+        } catch (error) {
+            throw new Error(`Error in SenangPay callback handling: ${error.message}`);
+        }
+    }
+
+    async verifyCallback(data) {
+        try {
+            const receivedHash = data.hash;
+            const hashString = this.secretKey + data.status_id + data.order_id + data.transaction_id + data.msg;
+            const expectedHash = crypto.createHash('md5').update(hashString).digest('hex');
+
+            if (receivedHash !== expectedHash) {
+                return {
+                    status: false,
+                    error: {
+                        code: 401,
+                        message: 'Invalid hash'
+                    }
+                };
+            }
+
+            return {
+                status: true,
+                data: data
+            };
+        } catch (error) {
+            return {
+                status: false,
+                error: {
+                    code: 500,
+                    message: error.message
+                }
+            };
+        }
+    }
+
+    async getTransactionStatus(orderId) {
+        try {
+            // SenangPay doesn't have a standard API for checking transaction status
+            // This would need to be implemented based on their specific API if available
+            throw new Error('Transaction status check not available in standard SenangPay integration');
+        } catch (error) {
+            throw new Error(`Error getting transaction status: ${error.message}`);
+        }
+    }
+}
+
+module.exports = SenangPayClient;