quickpos 1.0.910 → 1.0.912

package/lib/payme.js

@@ -0,0 +1,302 @@
+const axios = require('axios');
+
+/**
+ * PayMe Ödeme Entegrasyonu
+ * 
+ * Başlamadan önce:
+ * 1. PayMe hesabı oluşturun
+ * 2. API anahtarınızı alın (seller_payme_id)
+ * 3. Gerekli webhook URL'lerini ayarlayın
+ */
+class PayMeService {
+  constructor(config) {
+    this.config = config || {};
+    const requiredFields = ['sellerPaymeId'];
+    for (let field of requiredFields) {
+      if (!config[field]) throw new Error(`Missing required field: ${field}`);
+    }
+
+    this.sellerPaymeId = config.sellerPaymeId;
+    
+    // Sandbox veya Production modu seçimi
+    this.sandbox = config.sandbox || false;
+    
+    // API URL'ini ortama göre ayarla
+    if (this.sandbox) {
+      this.baseUrl = 'https://sandbox.payme.io/api';
+    } else {
+      this.baseUrl = 'https://live.payme.io/api';
+    }
+    
+    // Debug modu
+    this.debug = config.debug || false;
+    console.log(`PayMe API URL: ${this.baseUrl}`);
+  }
+
+  /**
+   * Yeni bir ödeme linki oluşturur
+   * 
+   * @param {Object} paymentDetails - Ödeme detayları
+   * @returns {Promise<Object>} Ödeme sonucu
+   */
+  async createPayment(paymentDetails) {
+    try {
+      // Zorunlu alanları kontrol et
+      let requiredData = ['name', 'amount', 'currency'];
+      for (let data of requiredData) {
+        if (!paymentDetails[data]) throw new Error(`Missing required data: ${data}`);
+      }
+
+      // PayMe için fiyat formatını ayarla (kuruş/cents cinsinden)
+      const salePrice = Math.round(paymentDetails.amount * 100);
+      
+      // Temel ödeme verilerini hazırla
+      const paymentData = {
+        seller_payme_id: this.sellerPaymeId,
+        sale_price: salePrice,
+        currency: paymentDetails.currency || 'ILS',
+        product_name: paymentDetails.name,
+        transaction_id: paymentDetails.orderId || `order-${Date.now()}`,
+        installments: paymentDetails.installments || '1',
+        market_fee: paymentDetails.marketFee || 0,
+        sale_send_notification: paymentDetails.sendNotification || false,
+        sale_type: paymentDetails.saleType || 'sale',
+        sale_payment_method: paymentDetails.paymentMethod || 'credit-card',
+        language: paymentDetails.language || 'he'  // Varsayılan dil: İbranice (he)
+      };
+
+      // İsteğe bağlı alanları ekle
+      if (paymentDetails.callbackUrl) paymentData.sale_callback_url = paymentDetails.callbackUrl;
+      if (paymentDetails.returnUrl) paymentData.sale_return_url = paymentDetails.returnUrl;
+      if (paymentDetails.email) paymentData.sale_email = paymentDetails.email;
+      if (paymentDetails.phone) paymentData.sale_mobile = paymentDetails.phone;
+      if (paymentDetails.buyerName) paymentData.sale_name = paymentDetails.buyerName;
+      if (paymentDetails.layout) paymentData.layout = paymentDetails.layout;
+      
+      // Buyer token kaydetme
+      if (paymentDetails.captureBuyer === true) {
+        paymentData.capture_buyer = '1';
+      }
+
+      // Debug modunda istek detaylarını göster
+      if (this.debug) {
+        console.log('PayMe ö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}/generate-sale`,
+        headers: {
+          'Content-Type': 'application/json',
+          'Accept': 'application/json'
+        },
+        data: paymentData
+      });
+
+      const responseData = response.data;
+
+      // Debug modunda yanıt detaylarını göster
+      if (this.debug) {
+        console.log('PayMe API yanıtı:', JSON.stringify(responseData, null, 2));
+      }
+
+      // Hata kontrolü
+      if (responseData.status_code !== 0) {
+        throw new Error(`PayMe API error: ${responseData.status_error_details || 'Unknown error'}`);
+      }
+
+      // QR kod oluştur (isteğe bağlı)
+      let qrCode = null;
+      if (paymentDetails.generateQr) {
+        qrCode = await this.generateQrCode(responseData.sale_url);
+      }
+
+      return {
+        status: 'success',
+        data: {
+          transactionId: responseData.transaction_id,
+          paymeId: responseData.payme_sale_id,
+          paymeCode: responseData.payme_sale_code,
+          url: responseData.sale_url,
+          id: responseData.payme_sale_id,
+          qr: qrCode
+        }
+      };
+    } catch (error) {
+      if (this.debug) {
+        console.error('PayMe 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(`PayMe 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 PayMe API');
+      } else {
+        throw new Error(`Error in PayMe payment creation: ${error.message}`);
+      }
+    }
+  }
+
+  /**
+   * Webhook callback'ini işler
+   * 
+   * @param {Object} callbackData - Callback verileri
+   * @returns {Promise<Object>} İşlem sonucu
+   */
+  async handleCallback(callbackData) {
+    try {
+      // Debug modunda callback verilerini göster
+      if (this.debug) {
+        console.log('PayMe callback verileri:', JSON.stringify(callbackData, null, 2));
+      }
+
+      // PayMe'den gelen önemli alanları kontrol et
+      if (!callbackData.payme_sale_id || !callbackData.status_code) {
+        throw new Error("Missing required fields in callback data");
+      }
+
+      // Signature doğrulaması (tam implementasyon için PayMe ile kontrol gerekebilir)
+      if (callbackData.payme_signature) {
+        // İleri düzey implementasyon: Signature doğrulaması
+        console.log('PayMe signature:', callbackData.payme_signature);
+      }
+
+      // Bildirim türü
+      const notifyType = callbackData.notify_type || '';
+      const saleStatus = callbackData.sale_status || '';
+      
+      // Ödeme durumunu notifyType ve saleStatus'a göre belirle
+      if (notifyType === 'sale-complete' || saleStatus === 'completed') {
+        // Başarılı ödeme
+        return {
+          status: 'success',
+          orderId: callbackData.transaction_id || '',
+          merchant_oid: callbackData.payme_sale_id,
+          amount: parseFloat(callbackData.price) / 100, // Kuruş/cents'ten ana birime çevirme
+          currency: callbackData.currency || '',
+          paymentType: 'payme',
+          card: {
+            cardMask: callbackData.buyer_card_mask || '',
+            cardExp: callbackData.buyer_card_exp || '',
+            cardBrand: callbackData.payme_transaction_card_brand || ''
+          },
+          buyer: {
+            name: callbackData.buyer_name || '',
+            email: callbackData.buyer_email || '',
+            phone: callbackData.buyer_phone || '',
+            socialId: callbackData.buyer_social_id || '',
+            buyerKey: callbackData.buyer_key || ''  // Token için kullanılabilir
+          },
+          sale: {
+            id: callbackData.payme_sale_id,
+            code: callbackData.payme_sale_code || '',
+            transactionId: callbackData.payme_transaction_id || '',
+            authNumber: callbackData.payme_transaction_auth_number || '',
+            installments: callbackData.installments || '1',
+            createDate: callbackData.sale_created || '',
+            paidDate: callbackData.sale_paid_date || '',
+            releaseDate: callbackData.sale_release_date || '',
+            isTokenSale: callbackData.is_token_sale === '1',
+            invoiceUrl: callbackData.sale_invoice_url || ''
+          }
+        };
+      } else if (notifyType === 'sale-authorized') {
+        // Yetkilendirilmiş ödeme (para henüz çekilmemiş)
+        return {
+          status: 'authorized',
+          orderId: callbackData.transaction_id || '',
+          merchant_oid: callbackData.payme_sale_id,
+          amount: parseFloat(callbackData.price) / 100,
+          currency: callbackData.currency || '',
+          paymentType: 'payme',
+          authNumber: callbackData.payme_transaction_auth_number || ''
+        };
+      } else if (notifyType === 'refund' || saleStatus === 'refunded' || saleStatus === 'partial-refund') {
+        // İade edilen ödeme
+        return {
+          status: 'refunded',
+          orderId: callbackData.transaction_id || '',
+          merchant_oid: callbackData.payme_sale_id,
+          amount: parseFloat(callbackData.price) / 100,
+          currency: callbackData.currency || '',
+          isPartial: saleStatus === 'partial-refund'
+        };
+      } else if (notifyType === 'sale-chargeback' || saleStatus === 'chargeback' || saleStatus === 'partial-chargeback') {
+        // Chargeback - müşteri bankasından geri ödeme talebi
+        return {
+          status: 'chargeback',
+          orderId: callbackData.transaction_id || '',
+          merchant_oid: callbackData.payme_sale_id,
+          amount: parseFloat(callbackData.price) / 100,
+          currency: callbackData.currency || '',
+          isPartial: saleStatus === 'partial-chargeback'
+        };
+      } else if (notifyType === 'sale-chargeback-refund') {
+        // Chargeback geri alındı
+        return {
+          status: 'chargeback-refund',
+          orderId: callbackData.transaction_id || '',
+          merchant_oid: callbackData.payme_sale_id,
+          amount: parseFloat(callbackData.price) / 100,
+          currency: callbackData.currency || ''
+        };
+      } else if (notifyType === 'sale-failure' || saleStatus === 'failed' || saleStatus === 'canceled') {
+        // Başarısız ödeme
+        return {
+          status: 'failed',
+          orderId: callbackData.transaction_id || '',
+          merchant_oid: callbackData.payme_sale_id,
+          reason: callbackData.status_error_details || 'Payment failed or canceled'
+        };
+      } else {
+        // Diğer durumlar
+        return {
+          status: 'other',
+          type: notifyType,
+          saleStatus: saleStatus,
+          orderId: callbackData.transaction_id || '',
+          merchant_oid: callbackData.payme_sale_id,
+          rawData: callbackData
+        };
+      }
+    } catch (error) {
+      if (this.debug) {
+        console.error('PayMe callback işleme hatası:', error);
+      }
+      throw new Error(`Error in PayMe callback handling: ${error.message}`);
+    }
+  }
+
+  /**
+   * Ödeme bağlantısı için QR kod oluşturur
+   * 
+   * @param {string} paymentUrl - Ödeme URL'i
+   * @returns {Promise<string|null>} Base64 formatında QR kod
+   */
+  async generateQrCode(paymentUrl) {
+    try {
+      const response = await axios.get('https://api.qrserver.com/v1/create-qr-code/', {
+        params: {
+          size: '300x300',
+          data: paymentUrl
+        },
+        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 = PayMeService;

package/lib/paymentwall.js

@@ -0,0 +1,205 @@
+const Paymentwall = require('paymentwall');
+const axios = require('axios');
+
+class PaymentwallService {
+  constructor(config) {
+    this.config = config || {};
+    const requiredFields = ['appKey', 'secretKey'];
+    for (let field of requiredFields) {
+      if (!config[field]) throw new Error(`Missing required field: ${field}`);
+    }
+
+    // Paymentwall SDK'sını yapılandır
+    Paymentwall.Configure(
+      Paymentwall.Base.API_GOODS,
+      config.appKey,
+      config.secretKey
+    );
+    
+    this.testMode = config.testMode || false;
+  }
+
+  async createPayment(paymentDetails) {
+    try {
+      let requiredData = ['name', 'amount', 'currency', 'email'];
+      for (let data of requiredData) {
+        if (!paymentDetails[data]) throw new Error(`Missing required data: ${data}`);
+      }
+
+      // Benzersiz bir ürün ve işlem ID'si oluştur
+      const productId = paymentDetails.productId || 'product_' + Date.now();
+      const orderId = paymentDetails.orderId || 'order_' + Date.now();
+      
+      // Ürünü tek seferlik (one-time) ödeme olarak yapılandır
+      const product = new Paymentwall.Product(
+        productId,
+        paymentDetails.amount,
+        paymentDetails.currency,
+        paymentDetails.name,
+        Paymentwall.Product.TYPE_FIXED // Tek seferlik ödeme tipi
+      );
+
+      // Kullanıcı bilgilerini oluştur
+      const userId = paymentDetails.userId || 'user_' + Date.now();
+      const userInfo = {
+        'email': paymentDetails.email,
+        'order_id': orderId
+      };
+      
+      if (paymentDetails.userName) userInfo.name = paymentDetails.userName;
+      
+      // Tüm extra parametreleri toplayalım
+      const extraParams = {};
+      
+      // Custom parametreleri ekle (varsa)
+      if (paymentDetails.customParams) {
+        Object.entries(paymentDetails.customParams).forEach(([key, value]) => {
+          extraParams[key] = value;
+        });
+      }
+
+      // Webhook URL'ini ayarla (varsa)
+      if (paymentDetails.pingback_url) {
+        extraParams['pingback_url'] = paymentDetails.pingback_url;
+      }
+
+      // Dönüş URL'ini ayarla (varsa)
+      if (paymentDetails.successUrl) {
+        extraParams['success_url'] = paymentDetails.successUrl;
+      }
+      
+      // Ödeme Widget'ını oluştur
+      const widgetCode = paymentDetails.widgetCode || 'p1_1';
+      const widget = new Paymentwall.Widget(
+        userId,
+        widgetCode,
+        [product],
+        {...userInfo, ...extraParams}
+      );
+
+      // Widget URL'sini al
+      const widgetUrl = widget.getUrl();
+
+      // QR kod oluştur (isteğe bağlı)
+      let qrCode = null;
+      if (paymentDetails.generateQr) {
+        qrCode = await this.generateQrCode(widgetUrl);
+      }
+
+      return {
+        status: 'success',
+        data: {
+          transactionId: orderId,
+          url: widgetUrl,
+          id: orderId,
+          qr: qrCode
+        }
+      };
+    } catch (error) {
+      throw new Error(`Error in Paymentwall payment creation: ${error.message}`);
+    }
+  }
+
+  async handleCallback(callbackData, ipAddress) {
+    try {
+      console.log('🔍 Paymentwall callback işleniyor:', callbackData);
+      
+      // Test modu kontrolü
+      if (callbackData.is_test === 1 || callbackData.is_test === '1' || callbackData.test_mode === 1) {
+        console.log('🧪 Test modu callback algılandı');
+        
+        // Test callback işleme - gerçek data doğrulama yapmadan test için
+        return {
+          status: 'success',
+          orderId: callbackData.order_id || callbackData.uid || 'test-order',
+          merchant_oid: callbackData.ref || 'test-ref',
+          amount: callbackData.amount || '199.99',
+          currency: callbackData.currency || 'TRY',
+          paymentType: 'paymentwall-test'
+        };
+      }
+      
+      // Paymentwall pingback nesnesi oluştur
+      const pingback = new Paymentwall.Pingback(
+        callbackData,
+        ipAddress,
+        this.testMode
+      );
+      
+      console.log('🔍 Pingback oluşturuldu, doğrulanıyor...');
+
+      // Pingback'in geçerli olup olmadığını kontrol et
+      if (pingback.validate()) {
+        console.log('✅ Pingback doğrulandı. Tip:', pingback.getType());
+        
+        // Callback verileri direkt olarak kullanılacak
+        let amount = callbackData.amount || '0';
+        let currency = callbackData.currency || 'TRY';
+        
+        // Callback veri yapısına göre doğru alan isimlerini kullan
+        if (callbackData.goodsid) {
+          console.log('✅ Ürün ID tespit edildi:', callbackData.goodsid);
+        }
+        
+        // Ödeme başarılı mı kontrolü
+        if (pingback.isDeliverable()) {
+          console.log('✅ Ödeme başarılı (deliverable)');
+          // Tek seferlik ödeme başarılı
+          return {
+            status: 'success',
+            orderId: callbackData.order_id || callbackData.uid || '',
+            merchant_oid: callbackData.ref || '',
+            amount: amount,
+            currency: currency,
+            paymentType: 'paymentwall',
+            raw: callbackData // Tüm veriyi de ekleyelim
+          };
+        } else if (pingback.isCancelable()) {
+          console.log('❌ Ödeme iptal edildi (cancelable)');
+          return {
+            status: 'failed',
+            orderId: callbackData.order_id || callbackData.uid || '',
+            reason: 'Payment was cancelled',
+            raw: callbackData
+          };
+        } else {
+          console.log('ℹ️ Diğer pingback tipi:', pingback.getType());
+          return {
+            status: 'other',
+            type: pingback.getType(),
+            orderId: callbackData.order_id || callbackData.uid || '',
+            raw: callbackData
+          };
+        }
+      } else {
+        const errorCode = pingback.getErrorCode();
+        console.error('❌ Geçersiz pingback:', errorCode);
+        throw new Error('Invalid pingback: ' + errorCode);
+      }
+    } catch (error) {
+      console.error('❌ Callback işleme hatası:', error);
+      throw new Error(`Error in Paymentwall callback handling: ${error.message}`);
+    }
+  }
+
+  // QR code oluşturmak için yardımcı fonksiyon
+  async generateQrCode(paymentUrl) {
+    try {
+      const response = await axios.get('https://api.qrserver.com/v1/create-qr-code/', {
+        params: {
+          size: '300x300',
+          data: paymentUrl
+        },
+        responseType: 'arraybuffer'
+      });
+      
+      const base64Image = Buffer.from(response.data, 'binary').toString('base64');
+      return `data:image/png;base64,${base64Image}`;
+    } catch (error) {
+      console.error('QR code generation failed:', error);
+      return null;
+    }
+  }
+}
+
+module.exports = PaymentwallService;

package/lib/paynet.js

@@ -0,0 +1,186 @@
+const axios = require('axios');
+const crypto = require('crypto');
+
+class PayNetClient {
+    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 = 'https://paynet.md/acquiring';
+
+        this.client = axios.create({
+            baseURL: this.baseURL,
+            headers: {
+                'Content-Type': 'application/json'
+            }
+        });
+    }
+
+    generateSignature(data) {
+        const signatureString = Object.keys(data)
+            .filter(key => key !== 'signature')
+            .sort()
+            .map(key => `${key}=${data[key]}`)
+            .join('&');
+        
+        return crypto
+            .createHmac('sha256', this.secretKey)
+            .update(signatureString)
+            .digest('hex')
+            .toUpperCase();
+    }
+
+    async createPayment(options) {
+        try {
+            const orderId = options.orderId || `ORDER-${Date.now()}`;
+            const amount = parseFloat(options.amount) * 100; // Convert to cents
+            
+            const paymentData = {
+                merchant_id: this.merchantId,
+                order_id: orderId,
+                amount: amount,
+                currency: options.currency || 'MDL',
+                description: options.description || options.name || 'Payment',
+                success_url: options.successUrl || options.callback_link,
+                fail_url: options.failUrl || options.callback_link,
+                callback_url: options.callbackUrl || options.callback_link,
+                language: options.language || 'ro',
+                customer_email: options.email || '',
+                customer_name: options.name || '',
+                customer_phone: options.phone || ''
+            };
+
+            paymentData.signature = this.generateSignature(paymentData);
+
+            const response = await this.client.post('/api/v1/payment', paymentData);
+
+            if (response.data.success) {
+                return {
+                    status: 'success',
+                    data: {
+                        url: response.data.payment_url,
+                        orderId: orderId,
+                        paymentId: response.data.payment_id,
+                        amount: amount / 100,
+                        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);
+            }
+
+            const data = verification.data;
+            
+            // Status mapping
+            const statusMapping = {
+                'success': 'success',
+                'completed': 'success',
+                'approved': 'success',
+                'failed': 'failed',
+                'declined': 'failed',
+                'cancelled': 'failed',
+                'pending': 'pending',
+                'processing': 'pending'
+            };
+
+            return {
+                status: statusMapping[data.status] || 'unknown',
+                orderId: data.order_id,
+                transactionId: data.payment_id || data.transaction_id,
+                amount: parseFloat(data.amount) / 100,
+                currency: data.currency,
+                paymentStatus: data.status,
+                paymentMethod: data.payment_method,
+                rrn: data.rrn,
+                approvalCode: data.approval_code
+            };
+        } catch (error) {
+            throw new Error(`Error in PayNet 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 data = {
+                merchant_id: this.merchantId,
+                payment_id: paymentId
+            };
+            
+            data.signature = this.generateSignature(data);
+            
+            const response = await this.client.post('/api/v1/payment/status', data);
+            return response.data;
+        } catch (error) {
+            throw new Error(`Error getting payment status: ${error.response?.data?.message || error.message}`);
+        }
+    }
+
+    async refundPayment(paymentId, options = {}) {
+        try {
+            const data = {
+                merchant_id: this.merchantId,
+                payment_id: paymentId,
+                amount: options.amount ? parseFloat(options.amount) * 100 : undefined,
+                reason: options.reason || 'Customer request'
+            };
+            
+            data.signature = this.generateSignature(data);
+            
+            const response = await this.client.post('/api/v1/payment/refund', data);
+            return response.data;
+        } catch (error) {
+            throw new Error(`Error creating refund: ${error.response?.data?.message || error.message}`);
+        }
+    }
+}
+
+module.exports = PayNetClient;