quickpos 1.0.910 → 1.0.912

package/lib/nowpayments.js

@@ -0,0 +1,311 @@
+const axios = require('axios');
+
+/**
+ * NOWPayments Kripto Para Ödeme Entegrasyonu
+ * 
+ * Başlamadan önce:
+ * 1. NOWPayments hesabı oluşturun (https://nowpayments.io/)
+ * 2. API anahtarınızı alın
+ * 3. Webhook URL'inizi ayarlayın
+ */
+class NOWPaymentsService {
+  constructor(config) {
+    this.config = config || {};
+    const requiredFields = ['apiKey'];
+    for (let field of requiredFields) {
+      if (!config[field]) throw new Error(`Missing required field: ${field}`);
+    }
+
+    this.apiKey = config.apiKey;
+    this.ipnSecret = config.ipnSecret || '';
+    this.sandbox = config.sandbox || false;
+    
+    // Sandbox veya Production moduna göre API URL'ini ayarla
+    if (this.sandbox) {
+      this.baseUrl = 'https://api-sandbox.nowpayments.io/v1';
+    } else {
+      this.baseUrl = 'https://api.nowpayments.io/v1';
+    }
+    
+    this.debug = config.debug || false;
+    
+    if (this.debug) {
+      console.log(`NOWPayments API URL: ${this.baseUrl}`);
+    }
+  }
+
+  /**
+   * Ödeme linki oluşturur
+   * 
+   * @param {Object} paymentDetails - Ödeme detayları
+   * @returns {Promise<Object>} Ödeme sonucu
+   */
+  async createPayment(paymentDetails) {
+    try {
+      // Zorunlu alanları kontrol et
+      let requiredData = ['price', 'currency_from', 'order_id'];
+      for (let data of requiredData) {
+        if (!paymentDetails[data]) throw new Error(`Missing required data: ${data}`);
+      }
+
+      // Ödeme verilerini hazırla
+      const paymentData = {
+        price_amount: paymentDetails.price,
+        price_currency: paymentDetails.currency_from,
+        pay_currency: paymentDetails.currency_to || paymentDetails.currency_from,
+        order_id: paymentDetails.order_id,
+        order_description: paymentDetails.description || 'Order payment',
+        ipn_callback_url: paymentDetails.callbackUrl || '',
+        success_url: paymentDetails.successUrl || '',
+        cancel_url: paymentDetails.cancelUrl || ''
+      };
+
+      // Debug modunda istek detaylarını göster
+      if (this.debug) {
+        console.log('NOWPayments ödeme isteği hazırlanıyor:', JSON.stringify(paymentData, null, 2));
+      }
+      
+      // API isteği gönder
+      const response = await axios({
+        method: 'POST',
+        url: `${this.baseUrl}/payment`,
+        headers: {
+          'Content-Type': 'application/json',
+          'x-api-key': this.apiKey
+        },
+        data: paymentData
+      });
+
+      const responseData = response.data;
+
+      // Debug modunda yanıt detaylarını göster
+      if (this.debug) {
+        console.log('NOWPayments API yanıtı:', JSON.stringify(responseData, null, 2));
+      }
+
+      // QR kod oluştur (isteğe bağlı)
+      let qrCode = null;
+      if (paymentDetails.generateQr && responseData.pay_address) {
+        qrCode = await this.generateQrCode(responseData.pay_address);
+      }
+
+      return {
+        status: 'success',
+        data: {
+          transactionId: responseData.payment_id,
+          paymentId: responseData.payment_id,
+          orderId: responseData.order_id,
+          payAddress: responseData.pay_address,
+          payAmount: responseData.pay_amount,
+          payCurrency: responseData.pay_currency,
+          purchaseId: responseData.purchase_id,
+          url: responseData.invoice_url || `https://nowpayments.io/payment/?iid=${responseData.payment_id}`,
+          id: responseData.payment_id,
+          qr: qrCode
+        }
+      };
+    } catch (error) {
+      if (this.debug) {
+        console.error('NOWPayments API hatası:', error);
+      }
+      
+      if (error.response) {
+        console.error('Hata detayları:', {
+          statusCode: error.response.status,
+          statusText: error.response.statusText,
+          data: error.response.data
+        });
+        throw new Error(`NOWPayments API error (${error.response.status}): ${JSON.stringify(error.response.data)}`);
+      } else if (error.request) {
+        console.error('Yanıt alınamadı:', error.request);
+        throw new Error('No response received from NOWPayments API');
+      } else {
+        throw new Error(`Error in NOWPayments payment creation: ${error.message}`);
+      }
+    }
+  }
+
+  /**
+   * Ödeme durumunu kontrol eder
+   * 
+   * @param {string} paymentId - Ödeme ID
+   * @returns {Promise<Object>} İşlem durumu
+   */
+  async checkPaymentStatus(paymentId) {
+    try {
+      if (!paymentId) {
+        throw new Error("Payment ID is required");
+      }
+
+      const response = await axios({
+        method: 'GET',
+        url: `${this.baseUrl}/payment/${paymentId}`,
+        headers: {
+          'x-api-key': this.apiKey
+        }
+      });
+
+      const paymentData = response.data;
+      
+      if (this.debug) {
+        console.log('NOWPayments ödeme durum bilgisi:', JSON.stringify(paymentData, null, 2));
+      }
+
+      // Ödeme durumunu belirle
+      const statusDescription = this.getPaymentStatusDescription(paymentData.payment_status);
+
+      return {
+        status: this.mapPaymentStatus(paymentData.payment_status),
+        payment: {
+          id: paymentData.payment_id,
+          orderId: paymentData.order_id,
+          statusCode: paymentData.payment_status,
+          statusDescription: statusDescription,
+          payAddress: paymentData.pay_address,
+          payAmount: paymentData.pay_amount,
+          payCurrency: paymentData.pay_currency,
+          priceAmount: paymentData.price_amount,
+          priceCurrency: paymentData.price_currency,
+          actualAmount: paymentData.actually_paid,
+          purchaseId: paymentData.purchase_id,
+          createdAt: paymentData.created_at,
+          updatedAt: paymentData.updated_at
+        }
+      };
+    } catch (error) {
+      if (this.debug) {
+        console.error('NOWPayments ödeme durumu sorgulama hatası:', error);
+      }
+      throw new Error(`Error checking payment status: ${error.message}`);
+    }
+  }
+
+  /**
+   * Webhook callback'ini işler
+   * 
+   * @param {Object} webhookData - Webhook verileri
+   * @returns {Promise<Object>} İşlem sonucu
+   */
+  async handleWebhook(webhookData) {
+    try {
+      // Debug modunda webhook verilerini göster
+      if (this.debug) {
+        console.log('NOWPayments webhook verileri:', JSON.stringify(webhookData, null, 2));
+      }
+
+      // Webhook verilerini doğrula
+      if (!webhookData.payment_id || !webhookData.order_id) {
+        throw new Error("Missing required fields in webhook data");
+      }
+      
+      // NOT: NOWPayments sağladığı dokümantasyona göre
+      // ipn_secret değeri payload içinde değil, X-NOWPayments-Sig header'ında
+      // veya alternatif bir doğrulama yöntemi kullanabilir.
+      // Geliştirme aşamasında IPN doğrulamasını atlayalım
+      
+      // IPN Secret kontrolünü, geliştirme/test aşamasında atlayabiliriz
+      if (this.ipnSecret && this.debug === false) {
+        // Gerçek ortamda imza doğrulaması gerekebilir
+        // Bu örnekte geçici olarak atlanıyor
+        console.log('⚠️ NOWPayments IPN doğrulaması atlanıyor! Üretim ortamında kullanılmamalıdır.');
+      }
+
+      // Ödeme durumunu belirle
+      const status = this.mapPaymentStatus(webhookData.payment_status);
+      const statusDescription = this.getPaymentStatusDescription(webhookData.payment_status);
+
+      return {
+        status: status,
+        statusCode: webhookData.payment_status,
+        statusDescription: statusDescription,
+        orderId: webhookData.order_id,
+        merchant_oid: webhookData.payment_id,
+        paymentId: webhookData.payment_id,
+        payAmount: webhookData.pay_amount,
+        payCurrency: webhookData.pay_currency,
+        priceAmount: webhookData.price_amount,
+        priceCurrency: webhookData.price_currency,
+        actualAmount: webhookData.actually_paid || 0,
+        purchaseId: webhookData.purchase_id,
+        paymentType: 'crypto',
+        createdAt: webhookData.created_at,
+        updatedAt: webhookData.updated_at
+      };
+    } catch (error) {
+      if (this.debug) {
+        console.error('NOWPayments webhook işleme hatası:', error);
+      }
+      throw new Error(`Error in NOWPayments webhook handling: ${error.message}`);
+    }
+  }
+
+  /**
+   * NOWPayments durum kodunu anlaşılır ifadelere dönüştürür
+   * 
+   * @param {number} statusCode - NOWPayments durum kodu
+   * @returns {string} Durum açıklaması
+   */
+  getPaymentStatusDescription(statusCode) {
+    const statusMap = {
+      0: 'Waiting for payment',
+      1: 'Confirming payment',
+      2: 'Confirmed payment',
+      3: 'Sending to customer',
+      4: 'Payment finished',
+      5: 'Partially paid',
+      6: 'Failed',
+      7: 'Refunded',
+      8: 'Reserved'
+    };
+    
+    return statusMap[statusCode] || 'Unknown status';
+  }
+
+  /**
+   * NOWPayments durum kodunu standart durumlara eşleştirir
+   * 
+   * @param {number} statusCode - NOWPayments durum kodu
+   * @returns {string} Standart durum
+   */
+  mapPaymentStatus(statusCode) {
+    const statusMap = {
+      0: 'waiting',
+      1: 'confirming',
+      2: 'confirmed',
+      3: 'sending',
+      4: 'success',
+      5: 'partially_paid',
+      6: 'failed',
+      7: 'refunded',
+      8: 'reserved'
+    };
+    
+    return statusMap[statusCode] || 'unknown';
+  }
+
+  /**
+   * Kripto para adresi için QR kod oluşturur
+   * 
+   * @param {string} address - Kripto para adresi
+   * @returns {Promise<string|null>} Base64 formatında QR kod
+   */
+  async generateQrCode(address) {
+    try {
+      const response = await axios.get('https://api.qrserver.com/v1/create-qr-code/', {
+        params: {
+          size: '300x300',
+          data: address
+        },
+        responseType: 'arraybuffer'
+      });
+      
+      const base64Image = Buffer.from(response.data, 'binary').toString('base64');
+      return `data:image/png;base64,${base64Image}`;
+    } catch (error) {
+      console.error('QR kod oluşturma hatası:', error);
+      return null;
+    }
+  }
+}
+
+module.exports = NOWPaymentsService;

package/lib/omise.js

@@ -0,0 +1,150 @@
+const axios = require('axios');
+const crypto = require('crypto');
+
+class OmiseClient {
+    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.baseURL = 'https://api.omise.co';
+
+        this.client = axios.create({
+            baseURL: this.baseURL,
+            auth: {
+                username: this.secretKey,
+                password: ''
+            },
+            headers: {
+                'Content-Type': 'application/json',
+                'Omise-Version': '2019-05-29'
+            }
+        });
+    }
+
+    async createPayment(options) {
+        try {
+            const orderId = options.orderId || `ORDER-${Date.now()}`;
+            
+            // Create charge
+            const chargeData = {
+                amount: Math.round(parseFloat(options.amount) * 100), // Amount in smallest unit (satang for THB)
+                currency: options.currency || 'THB',
+                description: options.description || options.name || 'Payment',
+                metadata: {
+                    order_id: orderId,
+                    customer_name: options.name || ''
+                },
+                return_uri: options.successUrl || options.callback_link
+            };
+
+            // If source token is provided (for card payments)
+            if (options.sourceToken) {
+                chargeData.card = options.sourceToken;
+            } else if (options.sourceType) {
+                // For internet banking, mobile banking, etc.
+                chargeData.source = {
+                    type: options.sourceType // e.g., 'internet_banking_scb', 'mobile_banking_scb', 'promptpay'
+                };
+            }
+
+            const response = await this.client.post('/charges', chargeData);
+
+            return {
+                status: 'success',
+                data: {
+                    id: response.data.id,
+                    url: response.data.authorize_uri,
+                    orderId: orderId,
+                    amount: response.data.amount / 100,
+                    currency: response.data.currency,
+                    status: response.data.status
+                }
+            };
+        } catch (error) {
+            throw new Error(`Payment creation error: ${error.response?.data?.message || error.message}`);
+        }
+    }
+
+    async handleCallback(callbackData) {
+        try {
+            const chargeId = callbackData.id || callbackData.charge_id;
+            
+            if (!chargeId) {
+                throw new Error('Charge ID not found in callback data');
+            }
+
+            // Get charge details
+            const charge = await this.getChargeDetails(chargeId);
+
+            // Status mapping
+            const statusMapping = {
+                'successful': 'success',
+                'pending': 'pending',
+                'failed': 'failed',
+                'reversed': 'refunded',
+                'expired': 'failed'
+            };
+
+            return {
+                status: statusMapping[charge.status] || 'unknown',
+                orderId: charge.metadata?.order_id || '',
+                transactionId: charge.id,
+                amount: charge.amount / 100,
+                currency: charge.currency,
+                paymentStatus: charge.status,
+                refunded: charge.refunded,
+                netAmount: charge.net / 100,
+                fee: charge.fee / 100
+            };
+        } catch (error) {
+            throw new Error(`Error in Omise callback handling: ${error.message}`);
+        }
+    }
+
+    async getChargeDetails(chargeId) {
+        try {
+            const response = await this.client.get(`/charges/${chargeId}`);
+            return response.data;
+        } catch (error) {
+            throw new Error(`Error getting charge details: ${error.response?.data?.message || error.message}`);
+        }
+    }
+
+    async createRefund(chargeId, options = {}) {
+        try {
+            const refundData = {
+                amount: options.amount ? Math.round(parseFloat(options.amount) * 100) : undefined
+            };
+
+            if (options.metadata) {
+                refundData.metadata = options.metadata;
+            }
+
+            const response = await this.client.post(`/charges/${chargeId}/refunds`, refundData);
+            return response.data;
+        } catch (error) {
+            throw new Error(`Error creating refund: ${error.response?.data?.message || error.message}`);
+        }
+    }
+
+    async createCustomer(options) {
+        try {
+            const customerData = {
+                email: options.email,
+                description: options.description || options.name,
+                metadata: options.metadata || {}
+            };
+
+            const response = await this.client.post('/customers', customerData);
+            return response.data;
+        } catch (error) {
+            throw new Error(`Error creating customer: ${error.response?.data?.message || error.message}`);
+        }
+    }
+}
+
+module.exports = OmiseClient;

package/lib/paddle.js

@@ -0,0 +1,180 @@
+const axios = require('axios');
+const crypto = require('crypto');
+
+class PaddleClient {
+    constructor(config) {
+        const requiredFields = ['vendorId', 'apiKey'];
+        for (let field of requiredFields) {
+            if (!config[field]) throw new Error(`Missing required field: ${field}`);
+        }
+
+        this.vendorId = config.vendorId;
+        this.apiKey = config.apiKey;
+        this.publicKey = config.publicKey || '';
+        this.sandbox = config.sandbox || false;
+        
+        this.baseURL = this.sandbox 
+            ? 'https://sandbox-vendors.paddle.com/api' 
+            : 'https://vendors.paddle.com/api';
+
+        this.client = axios.create({
+            baseURL: this.baseURL,
+            headers: {
+                'Content-Type': 'application/json'
+            }
+        });
+    }
+
+    async createPayment(options) {
+        try {
+            const orderId = options.orderId || `ORDER-${Date.now()}`;
+            
+            const payLinkData = {
+                vendor_id: this.vendorId,
+                vendor_auth_code: this.apiKey,
+                title: options.title || options.name || 'Payment',
+                webhook_url: options.callbackUrl || options.callback_link,
+                prices: [
+                    `${options.currency || 'USD'}:${parseFloat(options.amount).toFixed(2)}`
+                ],
+                recurring_prices: options.recurring ? [
+                    `${options.currency || 'USD'}:${parseFloat(options.amount).toFixed(2)}`
+                ] : undefined,
+                customer_email: options.email || '',
+                customer_country: options.country || 'US',
+                custom_message: options.description || '',
+                passthrough: JSON.stringify({
+                    order_id: orderId,
+                    customer_name: options.name || ''
+                }),
+                return_url: options.successUrl || options.callback_link,
+                quantity_variable: options.quantityVariable ? 1 : 0,
+                expires: options.expires || ''
+            };
+
+            const response = await this.client.post('/2.0/product/generate_pay_link', payLinkData);
+
+            if (response.data.success) {
+                return {
+                    status: 'success',
+                    data: {
+                        url: response.data.response.url,
+                        orderId: orderId,
+                        amount: options.amount,
+                        currency: options.currency || 'USD'
+                    }
+                };
+            } else {
+                throw new Error(response.data.error?.message || 'Payment link creation failed');
+            }
+        } catch (error) {
+            throw new Error(`Payment creation error: ${error.response?.data?.error?.message || error.message}`);
+        }
+    }
+
+    async handleCallback(callbackData) {
+        try {
+            // Verify webhook signature if public key is available
+            if (this.publicKey) {
+                const verification = this.verifyWebhook(callbackData);
+                if (!verification) {
+                    throw new Error('Invalid webhook signature');
+                }
+            }
+
+            const passthrough = callbackData.passthrough ? JSON.parse(callbackData.passthrough) : {};
+
+            // Status mapping
+            const statusMapping = {
+                'succeeded': 'success',
+                'completed': 'success',
+                'refunded': 'refunded',
+                'partially_refunded': 'refunded',
+                'disputed': 'disputed',
+                'cancelled': 'failed'
+            };
+
+            return {
+                status: statusMapping[callbackData.status] || 'unknown',
+                orderId: passthrough.order_id || callbackData.order_id,
+                transactionId: callbackData.order_id,
+                checkoutId: callbackData.checkout_id,
+                amount: parseFloat(callbackData.sale_gross || callbackData.balance_gross || 0),
+                currency: callbackData.currency,
+                paymentStatus: callbackData.status,
+                paymentMethod: callbackData.payment_method,
+                customer: {
+                    email: callbackData.email,
+                    country: callbackData.country
+                }
+            };
+        } catch (error) {
+            throw new Error(`Error in Paddle callback handling: ${error.message}`);
+        }
+    }
+
+    verifyWebhook(data) {
+        try {
+            const signature = data.p_signature;
+            const dataToVerify = { ...data };
+            delete dataToVerify.p_signature;
+
+            // Sort keys and create verification string
+            const sorted = Object.keys(dataToVerify).sort().reduce((acc, key) => {
+                acc[key] = dataToVerify[key];
+                return acc;
+            }, {});
+
+            // Serialize
+            const serialized = Object.entries(sorted)
+                .map(([key, value]) => `${key}=${value}`)
+                .join('&');
+
+            // Verify with public key (RSA verification would be needed here)
+            // This is a simplified version
+            return true; // Implement proper RSA verification if needed
+        } catch (error) {
+            return false;
+        }
+    }
+
+    async getOrderDetails(checkoutId) {
+        try {
+            const response = await this.client.post('/2.0/order/details', {
+                vendor_id: this.vendorId,
+                vendor_auth_code: this.apiKey,
+                checkout_id: checkoutId
+            });
+
+            if (response.data.success) {
+                return response.data.response;
+            } else {
+                throw new Error(response.data.error?.message || 'Failed to get order details');
+            }
+        } catch (error) {
+            throw new Error(`Error getting order details: ${error.response?.data?.error?.message || error.message}`);
+        }
+    }
+
+    async refundPayment(orderId, options = {}) {
+        try {
+            const response = await this.client.post('/2.0/payment/refund', {
+                vendor_id: this.vendorId,
+                vendor_auth_code: this.apiKey,
+                order_id: orderId,
+                amount: options.amount,
+                reason: options.reason || 'Customer request'
+            });
+
+            if (response.data.success) {
+                return response.data.response;
+            } else {
+                throw new Error(response.data.error?.message || 'Refund failed');
+            }
+        } catch (error) {
+            throw new Error(`Error processing refund: ${error.response?.data?.error?.message || error.message}`);
+        }
+    }
+}
+
+module.exports = PaddleClient;