quickpos 1.0.910 → 1.0.912

package/lib/checkout.js

@@ -0,0 +1,248 @@
+const axios = require('axios');
+const crypto = require('crypto');
+
+class CheckoutClient {
+    constructor(config) {
+        const requiredFields = ['secretKey'];
+        for (let field of requiredFields) {
+            if (!config[field]) throw new Error(`Missing required field: ${field}`);
+        }
+
+        this.secretKey = config.secretKey;
+        this.publicKey = config.publicKey || '';
+        this.isSandbox = config.sandbox || false;
+
+        this.URL = this.isSandbox
+            ? 'https://api.sandbox.checkout.com'
+            : 'https://api.checkout.com';
+
+        this.client = axios.create({
+            baseURL: this.URL,
+            headers: {
+                'Authorization': this.secretKey,
+                'Content-Type': 'application/json'
+            }
+        });
+
+        this.client.interceptors.response.use(response => {
+            return response;
+        }, error => {
+            if (error.response) {
+                throw new Error(`Checkout.com API error: ${error.response.data.error_type || error.message}`);
+            }
+            throw new Error(`Checkout.com API error: ${error.message}`);
+        });
+    }
+
+    async createPayment(options) {
+        try {
+            const requestData = {
+                source: {
+                    type: options.sourceType || 'token',
+                    token: options.token
+                },
+                amount: Math.round(parseFloat(options.amount) * 100), // Convert to cents
+                currency: options.currency || 'USD',
+                payment_type: options.paymentType || 'Regular',
+                reference: options.reference || options.orderId || `ORDER-${Date.now()}`,
+                description: options.description || options.name || 'Payment',
+                capture: options.capture !== undefined ? options.capture : true,
+                customer: {
+                    email: options.customerEmail || options.email,
+                    name: options.customerName || options.name || 'Customer'
+                },
+                billing_descriptor: {
+                    name: options.billingName || options.name || 'Product',
+                    city: options.billingCity || 'London'
+                },
+                metadata: {
+                    order_id: options.orderId || `ORDER-${Date.now()}`,
+                    ...options.metadata
+                },
+                success_url: options.successUrl || options.callback_link,
+                failure_url: options.failureUrl || options.callback_link
+            };
+
+            // If using hosted payment page
+            if (options.useHostedPage) {
+                const response = await this.client.post('/payment-links', {
+                    amount: requestData.amount,
+                    currency: requestData.currency,
+                    reference: requestData.reference,
+                    description: requestData.description,
+                    customer: requestData.customer,
+                    billing: {
+                        address: {
+                            country: options.billingCountry || 'GB'
+                        }
+                    },
+                    products: options.products || [{
+                        name: options.name || 'Product',
+                        quantity: 1,
+                        price: requestData.amount
+                    }],
+                    metadata: requestData.metadata,
+                    return_url: options.returnUrl || options.callback_link,
+                    locale: options.locale || 'en-GB'
+                });
+
+                return {
+                    status: 'success',
+                    data: {
+                        id: response.data.id,
+                        url: response.data._links.redirect.href,
+                        reference: requestData.reference,
+                        expiresOn: response.data.expires_on
+                    }
+                };
+            }
+
+            // Direct payment
+            const response = await this.client.post('/payments', requestData);
+
+            return {
+                status: response.data.approved ? 'success' : 'pending',
+                data: {
+                    id: response.data.id,
+                    actionId: response.data.action_id,
+                    amount: response.data.amount,
+                    currency: response.data.currency,
+                    approved: response.data.approved,
+                    status: response.data.status,
+                    reference: response.data.reference,
+                    responseCode: response.data.response_code,
+                    responseMessage: response.data.response_summary,
+                    redirectUrl: response.data._links?.redirect?.href
+                }
+            };
+        } catch (error) {
+            throw new Error(`Payment creation error: ${error.message}`);
+        }
+    }
+
+    async getPaymentDetails(paymentId) {
+        try {
+            const response = await this.client.get(`/payments/${paymentId}`);
+            return response.data;
+        } catch (error) {
+            throw new Error(`Payment details error: ${error.message}`);
+        }
+    }
+
+    async handleCallback(callbackData) {
+        try {
+            const verification = await this.verifyWebhook(callbackData);
+            
+            if (!verification.status) {
+                throw new Error(verification.error.message);
+            }
+
+            const data = verification.data;
+            
+            // Status mapping
+            const statusMapping = {
+                'Authorized': 'success',
+                'Card Verified': 'success',
+                'Pending': 'pending',
+                'Declined': 'failed',
+                'Canceled': 'cancelled',
+                'Expired': 'expired'
+            };
+
+            const eventData = data.data;
+
+            return {
+                status: statusMapping[eventData.status] || 'unknown',
+                paymentId: eventData.id,
+                actionId: eventData.action_id,
+                orderId: eventData.reference,
+                amount: parseFloat(eventData.amount) / 100,
+                currency: eventData.currency,
+                approved: eventData.approved,
+                paymentStatus: eventData.status,
+                responseCode: eventData.response_code,
+                responseMessage: eventData.response_summary,
+                eventType: data.type
+            };
+        } catch (error) {
+            throw new Error(`Error in Checkout.com callback handling: ${error.message}`);
+        }
+    }
+
+    async verifyWebhook(data, signature = null) {
+        try {
+            // Checkout.com webhook signature verification
+            // This is a simplified version - in production, verify the signature
+            
+            if (data.type && data.data) {
+                return {
+                    status: true,
+                    data: data
+                };
+            }
+
+            return {
+                status: false,
+                error: {
+                    code: 400,
+                    message: 'Invalid webhook data'
+                }
+            };
+        } catch (error) {
+            return {
+                status: false,
+                error: {
+                    code: 500,
+                    message: error.message
+                }
+            };
+        }
+    }
+
+    async capturePayment(paymentId, amount = null) {
+        try {
+            const requestData = {};
+            if (amount) {
+                requestData.amount = Math.round(parseFloat(amount) * 100);
+            }
+
+            const response = await this.client.post(`/payments/${paymentId}/captures`, requestData);
+            return response.data;
+        } catch (error) {
+            throw new Error(`Capture payment error: ${error.message}`);
+        }
+    }
+
+    async voidPayment(paymentId, reference = null) {
+        try {
+            const requestData = {};
+            if (reference) {
+                requestData.reference = reference;
+            }
+
+            const response = await this.client.post(`/payments/${paymentId}/voids`, requestData);
+            return response.data;
+        } catch (error) {
+            throw new Error(`Void payment error: ${error.message}`);
+        }
+    }
+
+    async refundPayment(paymentId, amount = null, reference = null) {
+        try {
+            const requestData = {};
+            if (amount) {
+                requestData.amount = Math.round(parseFloat(amount) * 100);
+            }
+            if (reference) {
+                requestData.reference = reference;
+            }
+
+            const response = await this.client.post(`/payments/${paymentId}/refunds`, requestData);
+            return response.data;
+        } catch (error) {
+            throw new Error(`Refund payment error: ${error.message}`);
+        }
+    }
+}
+
+module.exports = CheckoutClient;

package/lib/coinbase.js

@@ -0,0 +1,150 @@
+const axios = require('axios');
+const crypto = require('crypto');
+
+class CoinbaseCommerceClient {
+    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.webhookSecret = config.webhookSecret || '';
+        this.baseURL = 'https://api.commerce.coinbase.com';
+
+        this.client = axios.create({
+            baseURL: this.baseURL,
+            headers: {
+                'Content-Type': 'application/json',
+                'X-CC-Api-Key': this.apiKey,
+                'X-CC-Version': '2018-03-22'
+            }
+        });
+    }
+
+    async createPayment(options) {
+        try {
+            const orderId = options.orderId || `ORDER-${Date.now()}`;
+            
+            const chargeData = {
+                name: options.name || 'Payment',
+                description: options.description || 'Payment description',
+                pricing_type: 'fixed_price',
+                local_price: {
+                    amount: parseFloat(options.amount).toFixed(2),
+                    currency: options.currency || 'USD'
+                },
+                metadata: {
+                    order_id: orderId,
+                    customer_email: options.email || '',
+                    customer_name: options.customerName || ''
+                },
+                redirect_url: options.successUrl || options.callback_link,
+                cancel_url: options.failUrl || options.callback_link
+            };
+
+            const response = await this.client.post('/charges', chargeData);
+
+            return {
+                status: 'success',
+                data: {
+                    id: response.data.data.id,
+                    code: response.data.data.code,
+                    url: response.data.data.hosted_url,
+                    orderId: orderId,
+                    amount: response.data.data.pricing.local.amount,
+                    currency: response.data.data.pricing.local.currency,
+                    addresses: response.data.data.addresses,
+                    expiresAt: response.data.data.expires_at
+                }
+            };
+        } catch (error) {
+            throw new Error(`Payment creation error: ${error.response?.data?.error?.message || error.message}`);
+        }
+    }
+
+    async handleCallback(callbackData, signature) {
+        try {
+            // Verify webhook signature
+            if (this.webhookSecret && signature) {
+                const verification = this.verifyWebhook(callbackData, signature);
+                if (!verification) {
+                    throw new Error('Invalid webhook signature');
+                }
+            }
+
+            const event = callbackData.event;
+            const charge = event.data;
+
+            // Status mapping based on event type
+            const statusMapping = {
+                'charge:confirmed': 'success',
+                'charge:resolved': 'success',
+                'charge:pending': 'pending',
+                'charge:failed': 'failed',
+                'charge:delayed': 'pending'
+            };
+
+            return {
+                status: statusMapping[event.type] || 'unknown',
+                orderId: charge.metadata?.order_id,
+                transactionId: charge.id,
+                code: charge.code,
+                amount: parseFloat(charge.pricing?.local?.amount || 0),
+                currency: charge.pricing?.local?.currency,
+                paymentStatus: event.type,
+                timeline: charge.timeline,
+                payments: charge.payments
+            };
+        } catch (error) {
+            throw new Error(`Error in Coinbase Commerce callback handling: ${error.message}`);
+        }
+    }
+
+    verifyWebhook(payload, signature) {
+        try {
+            const computedSignature = crypto
+                .createHmac('sha256', this.webhookSecret)
+                .update(JSON.stringify(payload))
+                .digest('hex');
+
+            return computedSignature === signature;
+        } catch (error) {
+            return false;
+        }
+    }
+
+    async getCharge(chargeId) {
+        try {
+            const response = await this.client.get(`/charges/${chargeId}`);
+            return response.data.data;
+        } catch (error) {
+            throw new Error(`Error fetching charge: ${error.response?.data?.error?.message || error.message}`);
+        }
+    }
+
+    async listCharges(options = {}) {
+        try {
+            const params = {
+                limit: options.limit || 25,
+                order: options.order || 'desc'
+            };
+
+            const response = await this.client.get('/charges', { params });
+            return response.data;
+        } catch (error) {
+            throw new Error(`Error listing charges: ${error.response?.data?.error?.message || error.message}`);
+        }
+    }
+
+    async cancelCharge(chargeId) {
+        try {
+            const response = await this.client.post(`/charges/${chargeId}/cancel`);
+            return response.data.data;
+        } catch (error) {
+            throw new Error(`Error canceling charge: ${error.response?.data?.error?.message || error.message}`);
+        }
+    }
+}
+
+module.exports = CoinbaseCommerceClient;

package/lib/coingate.js

@@ -0,0 +1,137 @@
+const axios = require('axios');
+const crypto = require('crypto');
+
+class CoinGateClient {
+    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.environment = config.environment || 'live'; // 'sandbox' or 'live'
+        this.baseURL = this.environment === 'sandbox' 
+            ? 'https://api-sandbox.coingate.com/v2' 
+            : 'https://api.coingate.com/v2';
+
+        this.client = axios.create({
+            baseURL: this.baseURL,
+            headers: {
+                'Content-Type': 'application/json',
+                'Authorization': `Token ${this.apiKey}`
+            }
+        });
+    }
+
+    async createPayment(options) {
+        try {
+            const orderId = options.orderId || `ORDER-${Date.now()}`;
+            
+            const orderData = {
+                order_id: orderId,
+                price_amount: parseFloat(options.amount),
+                price_currency: options.currency || 'USD',
+                receive_currency: options.receiveCurrency || options.currency || 'USD',
+                title: options.title || options.name || 'Payment',
+                description: options.description || '',
+                callback_url: options.callbackUrl || options.callback_link,
+                cancel_url: options.failUrl || options.callback_link,
+                success_url: options.successUrl || options.callback_link,
+                purchaser_email: options.email || '',
+                token: options.token || 'DO_NOT_CONVERT'
+            };
+
+            const response = await this.client.post('/orders', orderData);
+
+            return {
+                status: 'success',
+                data: {
+                    id: response.data.id,
+                    url: response.data.payment_url,
+                    orderId: orderId,
+                    amount: response.data.price_amount,
+                    currency: response.data.price_currency,
+                    status: response.data.status,
+                    payAmount: response.data.pay_amount,
+                    payCurrency: response.data.pay_currency
+                }
+            };
+        } catch (error) {
+            throw new Error(`Payment creation error: ${error.response?.data?.message || error.message}`);
+        }
+    }
+
+    async handleCallback(callbackData) {
+        try {
+            const orderId = callbackData.id || callbackData.order_id;
+            
+            if (!orderId) {
+                throw new Error('Order ID not found in callback data');
+            }
+
+            // Get order details for verification
+            const order = await this.getOrder(orderId);
+
+            // Status mapping
+            const statusMapping = {
+                'paid': 'success',
+                'confirmed': 'success',
+                'pending': 'pending',
+                'expired': 'failed',
+                'canceled': 'failed',
+                'refunded': 'refunded',
+                'invalid': 'failed'
+            };
+
+            return {
+                status: statusMapping[order.status] || 'unknown',
+                orderId: order.order_id,
+                transactionId: order.id.toString(),
+                amount: parseFloat(order.price_amount),
+                currency: order.price_currency,
+                paymentStatus: order.status,
+                payAmount: order.pay_amount,
+                payCurrency: order.pay_currency,
+                receiveAmount: order.receive_amount,
+                receiveCurrency: order.receive_currency
+            };
+        } catch (error) {
+            throw new Error(`Error in CoinGate callback handling: ${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 listOrders(options = {}) {
+        try {
+            const params = {
+                sort: options.sort || 'created_at_desc',
+                per_page: options.perPage || 100,
+                page: options.page || 1
+            };
+
+            const response = await this.client.get('/orders', { params });
+            return response.data;
+        } catch (error) {
+            throw new Error(`Error listing orders: ${error.response?.data?.message || error.message}`);
+        }
+    }
+
+    async getExchangeRate(from, to) {
+        try {
+            const response = await this.client.get(`/rates/merchant/${from}/${to}`);
+            return parseFloat(response.data);
+        } catch (error) {
+            throw new Error(`Error getting exchange rate: ${error.response?.data?.message || error.message}`);
+        }
+    }
+}
+
+module.exports = CoinGateClient;