quickpos 1.0.910 → 1.0.912

package/lib/xendit.js

@@ -0,0 +1,206 @@
+const axios = require('axios');
+const crypto = require('crypto');
+
+class XenditClient {
+    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.webhookToken = config.webhookToken;
+        this.baseURL = 'https://api.xendit.co';
+
+        this.client = axios.create({
+            baseURL: this.baseURL,
+            auth: {
+                username: this.apiKey,
+                password: ''
+            },
+            headers: {
+                'Content-Type': 'application/json'
+            }
+        });
+    }
+
+    async createPayment(options) {
+        try {
+            const orderId = options.orderId || `ORDER-${Date.now()}`;
+            
+            // Xendit supports multiple payment methods
+            const paymentMethod = options.paymentMethod || 'invoice'; // invoice, ewallet, va, qr, card
+
+            let response;
+
+            if (paymentMethod === 'invoice') {
+                response = await this.createInvoice(options, orderId);
+            } else if (paymentMethod === 'ewallet') {
+                response = await this.createEWallet(options, orderId);
+            } else if (paymentMethod === 'va') {
+                response = await this.createVirtualAccount(options, orderId);
+            } else {
+                throw new Error(`Unsupported payment method: ${paymentMethod}`);
+            }
+
+            return response;
+        } catch (error) {
+            throw new Error(`Payment creation error: ${error.response?.data?.message || error.message}`);
+        }
+    }
+
+    async createInvoice(options, orderId) {
+        const invoiceData = {
+            external_id: orderId,
+            amount: parseFloat(options.amount),
+            payer_email: options.email || '',
+            description: options.description || options.name || 'Payment',
+            currency: options.currency || 'IDR',
+            success_redirect_url: options.successUrl || options.callback_link,
+            failure_redirect_url: options.failureUrl || options.callback_link,
+            customer: {
+                given_names: options.name || '',
+                email: options.email || '',
+                mobile_number: options.phone || ''
+            },
+            items: options.items || [{
+                name: options.name || 'Payment',
+                quantity: 1,
+                price: parseFloat(options.amount)
+            }]
+        };
+
+        const response = await this.client.post('/v2/invoices', invoiceData);
+
+        return {
+            status: 'success',
+            data: {
+                id: response.data.id,
+                url: response.data.invoice_url,
+                orderId: orderId,
+                amount: response.data.amount,
+                currency: response.data.currency,
+                status: response.data.status
+            }
+        };
+    }
+
+    async createEWallet(options, orderId) {
+        const ewalletData = {
+            reference_id: orderId,
+            currency: options.currency || 'IDR',
+            amount: parseFloat(options.amount),
+            checkout_method: 'ONE_TIME_PAYMENT',
+            channel_code: options.ewalletType || 'ID_OVO', // ID_OVO, ID_DANA, ID_LINKAJA, PH_GCASH, etc.
+            channel_properties: {
+                success_redirect_url: options.successUrl || options.callback_link,
+                failure_redirect_url: options.failureUrl || options.callback_link,
+                mobile_number: options.phone || ''
+            },
+            metadata: {
+                order_id: orderId
+            }
+        };
+
+        const response = await this.client.post('/ewallets/charges', ewalletData);
+
+        return {
+            status: 'success',
+            data: {
+                id: response.data.id,
+                url: response.data.actions?.desktop_web_checkout_url || response.data.actions?.mobile_web_checkout_url,
+                orderId: orderId,
+                amount: response.data.charge_amount,
+                currency: response.data.currency,
+                status: response.data.status
+            }
+        };
+    }
+
+    async createVirtualAccount(options, orderId) {
+        const vaData = {
+            external_id: orderId,
+            bank_code: options.bankCode || 'BNI', // BNI, BRI, MANDIRI, PERMATA, etc.
+            name: options.name || 'Customer',
+            expected_amount: parseFloat(options.amount),
+            is_closed: true,
+            expiration_date: options.expirationDate || new Date(Date.now() + 24*60*60*1000).toISOString()
+        };
+
+        const response = await this.client.post('/callback_virtual_accounts', vaData);
+
+        return {
+            status: 'success',
+            data: {
+                id: response.data.id,
+                accountNumber: response.data.account_number,
+                bankCode: response.data.bank_code,
+                orderId: orderId,
+                amount: response.data.expected_amount,
+                currency: 'IDR'
+            }
+        };
+    }
+
+    async handleCallback(callbackData) {
+        try {
+            // Verify webhook token if provided
+            if (this.webhookToken && callbackData.callback_token !== this.webhookToken) {
+                throw new Error('Invalid webhook token');
+            }
+
+            // Different callback structures for different payment methods
+            let orderId, transactionId, amount, currency, paymentStatus;
+
+            if (callbackData.external_id) {
+                // Invoice or VA callback
+                orderId = callbackData.external_id;
+                transactionId = callbackData.id;
+                amount = parseFloat(callbackData.amount || callbackData.paid_amount);
+                currency = callbackData.currency || 'IDR';
+                paymentStatus = callbackData.status;
+            } else if (callbackData.reference_id) {
+                // E-wallet callback
+                orderId = callbackData.data?.reference_id || callbackData.reference_id;
+                transactionId = callbackData.id || callbackData.data?.id;
+                amount = parseFloat(callbackData.data?.charge_amount || callbackData.charge_amount);
+                currency = callbackData.data?.currency || callbackData.currency || 'IDR';
+                paymentStatus = callbackData.data?.status || callbackData.status;
+            }
+
+            // Status mapping
+            const statusMapping = {
+                'PAID': 'success',
+                'SETTLED': 'success',
+                'SUCCEEDED': 'success',
+                'PENDING': 'pending',
+                'ACTIVE': 'pending',
+                'EXPIRED': 'failed',
+                'FAILED': 'failed',
+                'VOIDED': 'failed'
+            };
+
+            return {
+                status: statusMapping[paymentStatus] || 'unknown',
+                orderId: orderId,
+                transactionId: transactionId,
+                amount: amount,
+                currency: currency,
+                paymentStatus: paymentStatus
+            };
+        } catch (error) {
+            throw new Error(`Error in Xendit callback handling: ${error.message}`);
+        }
+    }
+
+    async getInvoice(invoiceId) {
+        try {
+            const response = await this.client.get(`/v2/invoices/${invoiceId}`);
+            return response.data;
+        } catch (error) {
+            throw new Error(`Error getting invoice: ${error.response?.data?.message || error.message}`);
+        }
+    }
+}
+
+module.exports = XenditClient;

package/lib/yallapay.js

@@ -0,0 +1,279 @@
+const axios = require('axios');
+
+/**
+ * YallaPay Ödeme Entegrasyonu
+ * 
+ * Başlamadan önce:
+ * 1. YallaPay hesabı oluşturun
+ * 2. Merchant Dashboard'dan private key alın
+ * 3. Webhook URL'inizi ayarlayın
+ */
+class YallaPayService {
+  constructor(config) {
+    this.config = config || {};
+    const requiredFields = ['privateKey', 'currency'];
+    for (let field of requiredFields) {
+      if (!config[field]) throw new Error(`Missing required field: ${field}`);
+    }
+
+    this.privateKey = config.privateKey;
+    this.currency = config.currency;
+    this.baseUrl = config.baseUrl || 'https://yallapay.net/api';
+    this.webhookSecret = config.webhookSecret || '';
+    this.debug = config.debug || false;
+  }
+
+  /**
+   * Ödeme bağlantısı oluşturur
+   * 
+   * @param {Object} paymentDetails - Ödeme detayları
+   * @returns {Promise<Object>} Ödeme sonucu
+   */
+  async createPayment(paymentDetails) {
+    try {
+      // Zorunlu alanları kontrol et
+      let requiredData = ['amount', 'purpose', 'external_id'];
+      for (let data of requiredData) {
+        if (!paymentDetails[data]) throw new Error(`Missing required data: ${data}`);
+      }
+
+      // Form verilerini hazırla
+      const formData = new FormData();
+      formData.append('private_key', this.privateKey);
+      formData.append('currency', paymentDetails.currency || this.currency);
+      formData.append('amount', paymentDetails.amount);
+      formData.append('purpose', paymentDetails.purpose);
+      formData.append('external_id', paymentDetails.external_id);
+      
+      // İsteğe bağlı parametreler
+      if (paymentDetails.is_fallback) {
+        formData.append('is_fallback', paymentDetails.is_fallback);
+        if (paymentDetails.is_fallback === '1' && paymentDetails.fallback_url) {
+          formData.append('fallback_url', paymentDetails.fallback_url);
+        }
+      }
+      
+      if (paymentDetails.store_id) {
+        formData.append('store_id', paymentDetails.store_id);
+      }
+
+      // Debug modunda istek detaylarını göster
+      if (this.debug) {
+        console.log('YallaPay ödeme isteği hazırlanıyor:', Object.fromEntries(formData));
+      }
+      
+      // API isteği gönder
+      const response = await axios({
+        method: 'POST',
+        url: `${this.baseUrl}/request`,
+        headers: {
+          'Accept': 'application/json',
+          'Content-Type': 'application/json'
+        },
+        data: Object.fromEntries(formData)
+      });
+
+      const responseData = response.data;
+
+      // Debug modunda yanıt detaylarını göster
+      if (this.debug) {
+        console.log('YallaPay API yanıtı:', responseData);
+      }
+
+      // Hata kontrolü
+      if (responseData.status !== "success") {
+        throw new Error(`YallaPay API error: ${responseData.message || 'Unknown error'}`);
+      }
+
+      // QR kod oluştur (isteğe bağlı)
+      let qrCode = null;
+      if (paymentDetails.generateQr && responseData.data.checkout_url) {
+        qrCode = await this.generateQrCode(responseData.data.checkout_url);
+      }
+
+      // Başarılı yanıt
+      return {
+        status: 'success',
+        data: {
+          transactionId: responseData.data.transaction_id,
+          url: responseData.data.checkout_url,
+          fallbackUrl: responseData.data.fallback_url || null,
+          id: responseData.data.transaction_id,
+          qr: qrCode
+        }
+      };
+    } catch (error) {
+      if (this.debug) {
+        console.error('YallaPay 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(`YallaPay 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 YallaPay API');
+      } else {
+        throw new Error(`Error in YallaPay payment creation: ${error.message}`);
+      }
+    }
+  }
+
+  /**
+   * İşlem durumunu doğrular
+   * 
+   * @param {string} transactionId - YallaPay işlem ID'si
+   * @returns {Promise<Object>} İşlem durumu
+   */
+  async verifyTransaction(transactionId) {
+    try {
+      if (!transactionId) {
+        throw new Error("Transaction ID is required");
+      }
+
+      // Form verilerini hazırla
+      const formData = new FormData();
+      formData.append('private_key', this.privateKey);
+      formData.append('trx_id', transactionId);
+
+      // API isteği gönder
+      const response = await axios({
+        method: 'POST',
+        url: `${this.baseUrl}/transaction/verify`,
+        headers: {
+          'Accept': 'application/json',
+          'Content-Type': 'application/json'
+        },
+        data: Object.fromEntries(formData)
+      });
+
+      const responseData = response.data;
+
+      // Debug modunda yanıt detaylarını göster
+      if (this.debug) {
+        console.log('YallaPay doğrulama yanıtı:', responseData);
+      }
+
+      // Hata kontrolü
+      if (responseData.status !== "success") {
+        throw new Error(`YallaPay verification error: ${responseData.message || 'Unknown error'}`);
+      }
+
+      // İşlem durumunu belirle
+      let status = this.mapTransactionStatus(responseData.data.status);
+
+      return {
+        status: status,
+        transaction: {
+          id: responseData.data.transaction_id,
+          external_id: responseData.data.external_id,
+          amount: responseData.data.amount,
+          net_amount: responseData.data.net_amount,
+          currency: responseData.data.currency,
+          payment_method: responseData.data.payment_method,
+          payment_date: responseData.data.payment_date,
+          status_code: responseData.data.status,
+          status: status
+        }
+      };
+    } catch (error) {
+      if (this.debug) {
+        console.error('YallaPay doğrulama hatası:', error);
+      }
+      throw new Error(`Error in YallaPay transaction verification: ${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('YallaPay webhook verileri:', webhookData);
+      }
+
+      // Webhook verilerini doğrula
+      if (!webhookData.transaction_id || !webhookData.webhook_secret) {
+        throw new Error("Missing required fields in webhook data");
+      }
+
+      // Webhook secret'ı doğrula
+      if (this.webhookSecret && webhookData.webhook_secret !== this.webhookSecret) {
+        throw new Error("Invalid webhook secret");
+      }
+
+      // İşlem durumunu belirle
+      let status = this.mapTransactionStatus(webhookData.status);
+
+      // İşlem durumuna göre yanıt döndür
+      return {
+        status: status,
+        orderId: webhookData.external_id,
+        merchant_oid: webhookData.transaction_id,
+        amount: webhookData.amount,
+        net_amount: webhookData.net_amount,
+        currency: webhookData.currency,
+        paymentType: webhookData.payment_method,
+        payment_date: webhookData.payment_date
+      };
+    } catch (error) {
+      if (this.debug) {
+        console.error('YallaPay webhook işleme hatası:', error);
+      }
+      throw new Error(`Error in YallaPay webhook handling: ${error.message}`);
+    }
+  }
+
+  /**
+   * YallaPay durum kodunu anlaşılır ifadelere dönüştürür
+   * 
+   * @param {number} statusCode - YallaPay durum kodu
+   * @returns {string} Durum açıklaması
+   */
+  mapTransactionStatus(statusCode) {
+    const statusMap = {
+      0: 'failed',
+      1: 'success',
+      3: 'refunded',
+      4: 'disputed',
+      5: 'initiated'
+    };
+    
+    return statusMap[statusCode] || 'unknown';
+  }
+
+  /**
+   * Ö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 = YallaPayService;

package/lib/yookassa.js

@@ -0,0 +1,193 @@
+const axios = require('axios');
+const crypto = require('crypto');
+
+class YooKassaClient {
+    constructor(config) {
+        const requiredFields = ['shopId', 'secretKey'];
+        for (let field of requiredFields) {
+            if (!config[field]) throw new Error(`Missing required field: ${field}`);
+        }
+
+        this.shopId = config.shopId;
+        this.secretKey = config.secretKey;
+        this.baseURL = 'https://api.yookassa.ru/v3';
+
+        this.client = axios.create({
+            baseURL: this.baseURL,
+            auth: {
+                username: this.shopId,
+                password: this.secretKey
+            },
+            headers: {
+                'Content-Type': 'application/json',
+                'Idempotence-Key': this.generateIdempotenceKey()
+            }
+        });
+    }
+
+    generateIdempotenceKey() {
+        return crypto.randomBytes(16).toString('hex');
+    }
+
+    async createPayment(options) {
+        try {
+            const orderId = options.orderId || `ORDER-${Date.now()}`;
+            
+            const paymentData = {
+                amount: {
+                    value: parseFloat(options.amount).toFixed(2),
+                    currency: options.currency || 'RUB'
+                },
+                confirmation: {
+                    type: 'redirect',
+                    return_url: options.successUrl || options.callback_link
+                },
+                capture: options.autoCapture !== false,
+                description: options.description || options.name || 'Payment',
+                metadata: {
+                    order_id: orderId
+                },
+                receipt: options.receipt || undefined
+            };
+
+            // Customer info
+            if (options.email || options.phone) {
+                paymentData.receipt = {
+                    customer: {
+                        email: options.email,
+                        phone: options.phone
+                    },
+                    items: options.items || [{
+                        description: paymentData.description,
+                        quantity: '1.00',
+                        amount: paymentData.amount,
+                        vat_code: options.vatCode || 1
+                    }]
+                };
+            }
+
+            const response = await this.client.post('/payments', paymentData, {
+                headers: {
+                    'Idempotence-Key': this.generateIdempotenceKey()
+                }
+            });
+
+            return {
+                status: 'success',
+                data: {
+                    id: response.data.id,
+                    url: response.data.confirmation.confirmation_url,
+                    orderId: orderId,
+                    amount: response.data.amount.value,
+                    currency: response.data.amount.currency,
+                    status: response.data.status
+                }
+            };
+        } catch (error) {
+            throw new Error(`Payment creation error: ${error.response?.data?.description || error.message}`);
+        }
+    }
+
+    async handleCallback(callbackData) {
+        try {
+            const payment = callbackData.object;
+            
+            if (!payment || !payment.id) {
+                throw new Error('Invalid callback data');
+            }
+
+            // Verify payment
+            const verifiedPayment = await this.getPaymentDetails(payment.id);
+
+            // Status mapping
+            const statusMapping = {
+                'succeeded': 'success',
+                'pending': 'pending',
+                'waiting_for_capture': 'pending',
+                'canceled': 'failed'
+            };
+
+            return {
+                status: statusMapping[verifiedPayment.status] || 'unknown',
+                orderId: verifiedPayment.metadata?.order_id || '',
+                transactionId: verifiedPayment.id,
+                amount: parseFloat(verifiedPayment.amount.value),
+                currency: verifiedPayment.amount.currency,
+                paymentStatus: verifiedPayment.status,
+                paymentMethod: verifiedPayment.payment_method?.type,
+                paid: verifiedPayment.paid,
+                refundable: verifiedPayment.refundable
+            };
+        } catch (error) {
+            throw new Error(`Error in YooKassa callback handling: ${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?.description || error.message}`);
+        }
+    }
+
+    async capturePayment(paymentId, options = {}) {
+        try {
+            const captureData = {
+                amount: options.amount ? {
+                    value: parseFloat(options.amount).toFixed(2),
+                    currency: options.currency || 'RUB'
+                } : undefined
+            };
+
+            const response = await this.client.post(`/payments/${paymentId}/capture`, captureData, {
+                headers: {
+                    'Idempotence-Key': this.generateIdempotenceKey()
+                }
+            });
+
+            return response.data;
+        } catch (error) {
+            throw new Error(`Error capturing payment: ${error.response?.data?.description || error.message}`);
+        }
+    }
+
+    async cancelPayment(paymentId) {
+        try {
+            const response = await this.client.post(`/payments/${paymentId}/cancel`, {}, {
+                headers: {
+                    'Idempotence-Key': this.generateIdempotenceKey()
+                }
+            });
+
+            return response.data;
+        } catch (error) {
+            throw new Error(`Error canceling payment: ${error.response?.data?.description || error.message}`);
+        }
+    }
+
+    async createRefund(paymentId, options = {}) {
+        try {
+            const refundData = {
+                payment_id: paymentId,
+                amount: {
+                    value: parseFloat(options.amount).toFixed(2),
+                    currency: options.currency || 'RUB'
+                }
+            };
+
+            const response = await this.client.post('/refunds', refundData, {
+                headers: {
+                    'Idempotence-Key': this.generateIdempotenceKey()
+                }
+            });
+
+            return response.data;
+        } catch (error) {
+            throw new Error(`Error creating refund: ${error.response?.data?.description || error.message}`);
+        }
+    }
+}
+
+module.exports = YooKassaClient;