quickpos 1.0.910 → 1.0.912

package/lib/amazonpay.js

@@ -0,0 +1,161 @@
+const axios = require('axios');
+const crypto = require('crypto');
+
+class AmazonPayClient {
+    constructor(config) {
+        const requiredFields = ['merchantId', 'accessKey', 'secretKey'];
+        for (let field of requiredFields) {
+            if (!config[field]) throw new Error(`Missing required field: ${field}`);
+        }
+
+        this.merchantId = config.merchantId;
+        this.accessKey = config.accessKey;
+        this.secretKey = config.secretKey;
+        this.region = config.region || 'us'; // us, eu, jp
+        this.sandbox = config.sandbox || false;
+        
+        const regionUrls = {
+            us: this.sandbox ? 'https://pay-api.amazon.com/sandbox' : 'https://pay-api.amazon.com/live',
+            eu: this.sandbox ? 'https://pay-api.amazon.eu/sandbox' : 'https://pay-api.amazon.eu/live',
+            jp: this.sandbox ? 'https://pay-api.amazon.jp/sandbox' : 'https://pay-api.amazon.jp/live'
+        };
+
+        this.baseURL = regionUrls[this.region];
+
+        this.client = axios.create({
+            baseURL: this.baseURL,
+            headers: {
+                'Content-Type': 'application/json'
+            }
+        });
+    }
+
+    generateSignature(payload) {
+        return crypto
+            .createHmac('sha256', this.secretKey)
+            .update(payload)
+            .digest('base64');
+    }
+
+    async createPayment(options) {
+        try {
+            const orderId = options.orderId || `ORDER-${Date.now()}`;
+            const timestamp = new Date().toISOString();
+            
+            const payloadData = {
+                webCheckoutDetails: {
+                    checkoutReviewReturnUrl: options.successUrl || options.callback_link
+                },
+                storeId: this.merchantId,
+                chargePermissionType: 'OneTime',
+                recurringMetadata: null,
+                paymentDetails: {
+                    paymentIntent: 'Authorize',
+                    chargeAmount: {
+                        amount: parseFloat(options.amount).toFixed(2),
+                        currencyCode: options.currency || 'USD'
+                    }
+                },
+                merchantMetadata: {
+                    merchantReferenceId: orderId,
+                    merchantStoreName: options.storeName || 'Store',
+                    noteToBuyer: options.description || ''
+                }
+            };
+
+            const payload = JSON.stringify(payloadData);
+            const signature = this.generateSignature(payload);
+
+            const response = await this.client.post('/v2/checkoutSessions', payloadData, {
+                headers: {
+                    'x-amz-pay-date': timestamp,
+                    'x-amz-pay-region': this.region,
+                    'Authorization': `AMZN-PAY-RSASSA-PSS ${signature}`
+                }
+            });
+
+            return {
+                status: 'success',
+                data: {
+                    checkoutSessionId: response.data.checkoutSessionId,
+                    webCheckoutDetails: response.data.webCheckoutDetails,
+                    url: response.data.webCheckoutDetails?.amazonPayRedirectUrl,
+                    orderId: orderId,
+                    amount: payloadData.paymentDetails.chargeAmount.amount,
+                    currency: payloadData.paymentDetails.chargeAmount.currencyCode
+                }
+            };
+        } catch (error) {
+            throw new Error(`Payment creation error: ${error.response?.data?.message || error.message}`);
+        }
+    }
+
+    async handleCallback(callbackData) {
+        try {
+            const checkoutSessionId = callbackData.amazonCheckoutSessionId;
+            
+            if (!checkoutSessionId) {
+                throw new Error('Checkout session ID not found in callback data');
+            }
+
+            // Get checkout session details
+            const session = await this.getCheckoutSession(checkoutSessionId);
+
+            // Status mapping
+            const statusMapping = {
+                'Open': 'pending',
+                'Completed': 'success',
+                'Canceled': 'failed',
+                'Expired': 'failed'
+            };
+
+            return {
+                status: statusMapping[session.statusDetails?.state] || 'unknown',
+                orderId: session.merchantMetadata?.merchantReferenceId,
+                transactionId: checkoutSessionId,
+                amount: parseFloat(session.chargeAmount?.amount || 0),
+                currency: session.chargeAmount?.currencyCode,
+                paymentStatus: session.statusDetails?.state,
+                buyer: session.buyer
+            };
+        } catch (error) {
+            throw new Error(`Error in Amazon Pay callback handling: ${error.message}`);
+        }
+    }
+
+    async getCheckoutSession(checkoutSessionId) {
+        try {
+            const timestamp = new Date().toISOString();
+            
+            const response = await this.client.get(`/v2/checkoutSessions/${checkoutSessionId}`, {
+                headers: {
+                    'x-amz-pay-date': timestamp,
+                    'x-amz-pay-region': this.region
+                }
+            });
+
+            return response.data;
+        } catch (error) {
+            throw new Error(`Error fetching checkout session: ${error.response?.data?.message || error.message}`);
+        }
+    }
+
+    async updateCheckoutSession(checkoutSessionId, updates) {
+        try {
+            const timestamp = new Date().toISOString();
+            
+            const response = await this.client.patch(`/v2/checkoutSessions/${checkoutSessionId}`, updates, {
+                headers: {
+                    'x-amz-pay-date': timestamp,
+                    'x-amz-pay-region': this.region
+                }
+            });
+
+            return response.data;
+        } catch (error) {
+            throw new Error(`Error updating checkout session: ${error.response?.data?.message || error.message}`);
+        }
+    }
+}
+
+module.exports = AmazonPayClient;

package/lib/bitpay.js

@@ -0,0 +1,122 @@
+const axios = require('axios');
+const crypto = require('crypto');
+
+class BitPayClient {
+    constructor(config) {
+        const requiredFields = ['apiToken'];
+        for (let field of requiredFields) {
+            if (!config[field]) throw new Error(`Missing required field: ${field}`);
+        }
+
+        this.apiToken = config.apiToken;
+        this.environment = config.environment || 'test'; // 'test' or 'prod'
+        this.baseURL = this.environment === 'prod' 
+            ? 'https://bitpay.com' 
+            : 'https://test.bitpay.com';
+
+        this.client = axios.create({
+            baseURL: this.baseURL,
+            headers: {
+                'Content-Type': 'application/json',
+                'X-Accept-Version': '2.0.0',
+                'Authorization': `Bearer ${this.apiToken}`
+            }
+        });
+    }
+
+    async createPayment(options) {
+        try {
+            const orderId = options.orderId || `ORDER-${Date.now()}`;
+            
+            const invoiceData = {
+                price: parseFloat(options.amount),
+                currency: options.currency || 'USD',
+                orderId: orderId,
+                itemDesc: options.description || options.name || 'Payment',
+                notificationURL: options.callbackUrl || options.callback_link,
+                redirectURL: options.successUrl || options.callback_link,
+                buyer: {
+                    email: options.email || '',
+                    name: options.name || ''
+                }
+            };
+
+            const response = await this.client.post('/invoices', invoiceData);
+
+            return {
+                status: 'success',
+                data: {
+                    invoiceId: response.data.data.id,
+                    url: response.data.data.url,
+                    orderId: orderId,
+                    amount: response.data.data.price,
+                    currency: response.data.data.currency,
+                    status: response.data.data.status
+                }
+            };
+        } catch (error) {
+            throw new Error(`Payment creation error: ${error.response?.data?.error || error.message}`);
+        }
+    }
+
+    async handleCallback(callbackData) {
+        try {
+            const invoiceId = callbackData.id || callbackData.data?.id;
+            
+            if (!invoiceId) {
+                throw new Error('Invoice ID not found in callback data');
+            }
+
+            // Get invoice details
+            const invoice = await this.getInvoice(invoiceId);
+
+            // Status mapping
+            const statusMapping = {
+                'confirmed': 'success',
+                'complete': 'success',
+                'paid': 'success',
+                'new': 'pending',
+                'expired': 'failed',
+                'invalid': 'failed'
+            };
+
+            return {
+                status: statusMapping[invoice.status.toLowerCase()] || 'unknown',
+                orderId: invoice.orderId,
+                transactionId: invoice.id,
+                amount: parseFloat(invoice.price),
+                currency: invoice.currency,
+                paymentStatus: invoice.status,
+                exceptionStatus: invoice.exceptionStatus
+            };
+        } catch (error) {
+            throw new Error(`Error in BitPay callback handling: ${error.message}`);
+        }
+    }
+
+    async getInvoice(invoiceId) {
+        try {
+            const response = await this.client.get(`/invoices/${invoiceId}`);
+            return response.data.data;
+        } catch (error) {
+            throw new Error(`Error fetching invoice: ${error.response?.data?.error || error.message}`);
+        }
+    }
+
+    async refundInvoice(invoiceId, options = {}) {
+        try {
+            const refundData = {
+                amount: options.amount,
+                currency: options.currency,
+                preview: options.preview || false
+            };
+
+            const response = await this.client.post(`/invoices/${invoiceId}/refunds`, refundData);
+            return response.data.data;
+        } catch (error) {
+            throw new Error(`Error creating refund: ${error.response?.data?.error || error.message}`);
+        }
+    }
+}
+
+module.exports = BitPayClient;

package/lib/cardcom.js

@@ -0,0 +1,193 @@
+const axios = require('axios');
+
+class CardcomClient {
+    constructor(config) {
+        const requiredFields = ['terminalNumber', 'userName'];
+        for (let field of requiredFields) {
+            if (!config[field]) throw new Error(`Missing required field: ${field}`);
+        }
+
+        this.terminalNumber = config.terminalNumber;
+        this.userName = config.userName;
+        this.apiName = config.apiName || this.userName;
+        this.URL = 'https://secure.cardcom.solutions/api/v11';
+
+        this.client = axios.create({
+            baseURL: this.URL,
+            headers: {
+                'Content-Type': 'application/json'
+            }
+        });
+
+        this.client.interceptors.response.use(response => {
+            return response;
+        }, error => {
+            if (error.response) {
+                throw new Error(`Cardcom API error: ${error.response.data.ResponseMessage || error.message}`);
+            }
+            throw new Error(`Cardcom API error: ${error.message}`);
+        });
+    }
+
+    async createPayment(options) {
+        try {
+            const requestData = {
+                TerminalNumber: this.terminalNumber,
+                UserName: this.userName,
+                APILevel: 10,
+                Operation: {
+                    Type: 2, // Create Invoice
+                    SumToBill: parseFloat(options.amount),
+                    Currency: options.currency || 'ILS',
+                    Description: options.description || options.name || 'Payment',
+                    InvoiceHead: {
+                        CustName: options.customerName || options.name || 'Customer',
+                        SendByEmail: true,
+                        CustEmail: options.email,
+                        CustMobile: options.mobile || options.phone || '',
+                        ExtendedInvoiceType: 1,
+                        InvoiceType: options.invoiceType || 1,
+                        Language: options.language || 'he'
+                    }
+                },
+                ReturnValue: options.returnUrl || options.callback_link,
+                IndicatorUrl: options.callbackUrl || options.callback_link,
+                InternalDealNumber: options.internalDealNumber || options.orderId || `ORDER-${Date.now()}`
+            };
+
+            if (options.items && Array.isArray(options.items)) {
+                requestData.Operation.InvoiceLines = {
+                    InvoiceLine: options.items
+                };
+            }
+
+            const response = await this.client.post('/LowProfile/CreateInvoice', requestData);
+
+            if (response.data.ResponseCode === 0) {
+                return {
+                    status: 'success',
+                    data: {
+                        lowProfileId: response.data.LowProfileId,
+                        lowProfileCode: response.data.LowProfileCode,
+                        url: response.data.Url,
+                        internalDealNumber: requestData.InternalDealNumber
+                    }
+                };
+            } else {
+                throw new Error(response.data.ResponseMessage || 'Payment creation failed');
+            }
+        } catch (error) {
+            throw new Error(`Payment creation error: ${error.message}`);
+        }
+    }
+
+    async getInvoiceDetails(lowProfileId) {
+        try {
+            const requestData = {
+                TerminalNumber: this.terminalNumber,
+                UserName: this.userName,
+                LowProfileId: lowProfileId
+            };
+
+            const response = await this.client.post('/LowProfile/GetLowProfileIndicator', requestData);
+            return response.data;
+        } catch (error) {
+            throw new Error(`Invoice details 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 based on OperationResponse
+            const statusMapping = {
+                '0': 'success',
+                '1': 'failed'
+            };
+
+            return {
+                status: statusMapping[data.OperationResponse] || 'unknown',
+                lowProfileId: data.LowProfileId,
+                internalDealNumber: data.InternalDealNumber,
+                orderId: data.InternalDealNumber,
+                operationResponse: data.OperationResponse,
+                operationResponseText: data.OperationResponseText,
+                extendedResponseText: data.ExtendedResponseText
+            };
+        } catch (error) {
+            throw new Error(`Error in Cardcom callback handling: ${error.message}`);
+        }
+    }
+
+    async verifyCallback(data) {
+        try {
+            if (data.OperationResponse !== '0') {
+                return {
+                    status: false,
+                    error: {
+                        code: 400,
+                        message: data.ExtendedResponseText || 'Payment failed'
+                    }
+                };
+            }
+
+            return {
+                status: true,
+                data: data
+            };
+        } catch (error) {
+            return {
+                status: false,
+                error: {
+                    code: 500,
+                    message: error.message
+                }
+            };
+        }
+    }
+
+    async chargeCard(options) {
+        try {
+            const requestData = {
+                TerminalNumber: this.terminalNumber,
+                UserName: this.userName,
+                APILevel: 10,
+                CardNumber: options.cardNumber,
+                DateMMYY: options.expiryDate, // MMYY format
+                CVV: options.cvv,
+                SumToBill: parseFloat(options.amount),
+                Currency: options.currency || 'ILS',
+                CustomerName: options.customerName || options.name || 'Customer',
+                CustomerEmail: options.email,
+                InternalDealNumber: options.internalDealNumber || options.orderId || `ORDER-${Date.now()}`,
+                IndicatorUrl: options.callbackUrl || options.callback_link
+            };
+
+            const response = await this.client.post('/DealWasSuccessful', requestData);
+
+            if (response.data.ResponseCode === 0) {
+                return {
+                    status: 'success',
+                    data: {
+                        dealResponse: response.data.DealResponse,
+                        internalDealNumber: response.data.InternalDealNumber,
+                        confirmationNumber: response.data.ConfirmationNumber
+                    }
+                };
+            } else {
+                throw new Error(response.data.ResponseMessage || 'Card charge failed');
+            }
+        } catch (error) {
+            throw new Error(`Card charge error: ${error.message}`);
+        }
+    }
+}
+
+module.exports = CardcomClient;

package/lib/cashfree.js

@@ -0,0 +1,184 @@
+const axios = require('axios');
+const crypto = require('crypto');
+
+class CashfreeClient {
+    constructor(config) {
+        const requiredFields = ['appId', 'secretKey'];
+        for (let field of requiredFields) {
+            if (!config[field]) throw new Error(`Missing required field: ${field}`);
+        }
+
+        this.appId = config.appId;
+        this.secretKey = config.secretKey;
+        this.environment = config.environment || 'production'; // 'sandbox' or 'production'
+        this.baseURL = this.environment === 'sandbox' 
+            ? 'https://sandbox.cashfree.com/pg' 
+            : 'https://api.cashfree.com/pg';
+
+        this.client = axios.create({
+            baseURL: this.baseURL,
+            headers: {
+                'Content-Type': 'application/json',
+                'x-client-id': this.appId,
+                'x-client-secret': this.secretKey,
+                'x-api-version': '2023-08-01'
+            }
+        });
+    }
+
+    async createPayment(options) {
+        try {
+            const orderId = options.orderId || `order_${Date.now()}`;
+            
+            const orderData = {
+                order_id: orderId,
+                order_amount: parseFloat(options.amount),
+                order_currency: options.currency || 'INR',
+                customer_details: {
+                    customer_id: options.customerId || `customer_${Date.now()}`,
+                    customer_email: options.email || '',
+                    customer_phone: options.phone || '',
+                    customer_name: options.name || options.customerName || ''
+                },
+                order_meta: {
+                    return_url: options.successUrl || options.callback_link,
+                    notify_url: options.callbackUrl || options.callback_link
+                },
+                order_note: options.description || ''
+            };
+
+            const response = await this.client.post('/orders', orderData);
+
+            if (response.data.order_status === 'ACTIVE') {
+                return {
+                    status: 'success',
+                    data: {
+                        orderId: orderId,
+                        paymentSessionId: response.data.payment_session_id,
+                        orderStatus: response.data.order_status,
+                        amount: orderData.order_amount,
+                        currency: orderData.order_currency,
+                        // Payment link construction
+                        url: `${this.baseURL}/checkout?order_id=${orderId}&payment_session_id=${response.data.payment_session_id}`
+                    }
+                };
+            } else {
+                throw new Error('Order 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 orderId = callbackData.order_id || callbackData.orderId;
+            
+            // Get order details
+            const order = await this.getOrder(orderId);
+
+            // Status mapping
+            const statusMapping = {
+                'PAID': 'success',
+                'ACTIVE': 'pending',
+                'EXPIRED': 'failed',
+                'TERMINATED': 'failed',
+                'PENDING': 'pending'
+            };
+
+            return {
+                status: statusMapping[order.order_status] || 'unknown',
+                orderId: order.order_id,
+                transactionId: order.cf_order_id,
+                amount: parseFloat(order.order_amount),
+                currency: order.order_currency,
+                paymentStatus: order.order_status,
+                paymentMethod: order.payment_method
+            };
+        } catch (error) {
+            throw new Error(`Error in Cashfree callback handling: ${error.message}`);
+        }
+    }
+
+    async verifyCallback(data) {
+        try {
+            // Verify signature if present
+            if (data.signature) {
+                const { signature, ...callbackData } = data;
+                const signatureString = Object.keys(callbackData)
+                    .sort()
+                    .map(key => `${key}=${callbackData[key]}`)
+                    .join('&');
+                
+                const expectedSignature = crypto
+                    .createHmac('sha256', this.secretKey)
+                    .update(signatureString)
+                    .digest('hex');
+
+                if (signature !== 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 getOrder(orderId) {
+        try {
+            const response = await this.client.get(`/orders/${orderId}`);
+            return response.data;
+        } catch (error) {
+            throw new Error(`Error fetching order: ${error.response?.data?.message || error.message}`);
+        }
+    }
+
+    async getPayments(orderId) {
+        try {
+            const response = await this.client.get(`/orders/${orderId}/payments`);
+            return response.data;
+        } catch (error) {
+            throw new Error(`Error fetching payments: ${error.response?.data?.message || error.message}`);
+        }
+    }
+
+    async refundPayment(orderId, options = {}) {
+        try {
+            const refundData = {
+                refund_amount: options.amount,
+                refund_id: options.refundId || `refund_${Date.now()}`,
+                refund_note: options.note || 'Refund'
+            };
+
+            const response = await this.client.post(`/orders/${orderId}/refunds`, refundData);
+            return response.data;
+        } catch (error) {
+            throw new Error(`Error creating refund: ${error.response?.data?.message || error.message}`);
+        }
+    }
+}
+
+module.exports = CashfreeClient;