quickpos 1.0.911 → 1.0.913

package/lib/shopier_card.js

@@ -0,0 +1,188 @@
+const crypto = require('crypto');
+
+class Shopier {
+  /**
+   * @param {Object} config
+   * @param {string} config.apiKey - Shopier API Key
+   * @param {string} config.apiSecret - Shopier API Secret
+   */
+  constructor(config) {
+    this.config = config || {};
+    const requiredFields = ['apiKey', 'apiSecret', 'website'];
+    
+    for (let field of requiredFields) {
+      if (!config[field]) throw new Error(`Shopier: Missing required config field: ${field}`);
+    }
+
+    this.apiKey = config.apiKey;
+    this.websiteIndex = Number(config.website);
+    this.apiSecret = config.apiSecret;
+    this.paymentUrl = 'https://www.shopier.com/ShowProduct/api_pay4.php';
+    this.moduleVersion = '1.0.4';
+  }
+
+  /**
+   * Ödeme Formunu Oluşturur
+   * @param {Object} paymentDetails
+   * @param {number} paymentDetails.amount - Ödenecek tutar (Örn: 15.50)
+   * @param {string} paymentDetails.currency - Para birimi (TRY, USD, EUR) varsayılan: TRY
+   * @param {string} paymentDetails.orderId - Sipariş numarası (Benzersiz olmalı)
+   * @param {Object} paymentDetails.buyer - Alıcı bilgileri { first_name, last_name, email, phone, id_nr }
+   * @param {Object} paymentDetails.billingAddress - Fatura adresi { address, city, country, postcode }
+   * @param {Object} paymentDetails.shippingAddress - Teslimat adresi { address, city, country, postcode }
+   */
+  createPayment(paymentDetails) {
+    try {
+      // 1. Temel Doğrulamalar
+      if (!paymentDetails.amount) throw new Error('Shopier: Amount is required');
+      if (!paymentDetails.buyer) throw new Error('Shopier: Buyer information is required');
+      if (!paymentDetails.billingAddress) throw new Error('Shopier: Billing address is required');
+      if (!paymentDetails.shippingAddress) throw new Error('Shopier: Shipping address is required');
+
+      const currency = paymentDetails.currency || 'TRY';
+      const currentLang = 0; // 0: TR, 1: EN (Otomatik TR ayarlandı, isteğe göre parametreye bağlanabilir)
+      const randomNr = Math.floor(Math.random() * (999999 - 100000 + 1)) + 100000;
+      
+      // Sipariş ID yoksa rastgele oluştur
+      const platformOrderId = paymentDetails.orderId || `Ord-${randomNr}`;
+
+      // 2. Shopier İçin Argümanları Hazırla
+      const args = {
+        API_key: this.apiKey,
+        website_index: this.websiteIndex || 0,
+        platform_order_id: platformOrderId,
+        product_name: paymentDetails.product_name || 'Balance Payment',
+        product_type: 0, // 0: Reel nesne, 1: Sanal
+        buyer_name: paymentDetails.buyer.first_name,
+        buyer_surname: paymentDetails.buyer.last_name,
+        buyer_email: paymentDetails.buyer.email,
+        buyer_account_age: 0,
+        buyer_id_nr: paymentDetails.buyer.id_nr || '0', // Opsiyonel ID
+        buyer_phone: paymentDetails.buyer.phone,
+        
+        // Fatura
+        billing_address: paymentDetails.billingAddress.address,
+        billing_city: paymentDetails.billingAddress.city,
+        billing_country: paymentDetails.billingAddress.country,
+        billing_postcode: paymentDetails.billingAddress.postcode,
+        
+        // Teslimat
+        shipping_address: paymentDetails.shippingAddress.address,
+        shipping_city: paymentDetails.shippingAddress.city,
+        shipping_country: paymentDetails.shippingAddress.country,
+        shipping_postcode: paymentDetails.shippingAddress.postcode,
+        
+        total_order_value: paymentDetails.amount,
+        currency: this._mapCurrency(currency),
+        platform: 0,
+        is_in_frame: 0,
+        current_language: currentLang,
+        modul_version: this.moduleVersion,
+        random_nr: randomNr
+      };
+
+      // 3. Eksik Alan Kontrolü
+      Object.keys(args).forEach(key => {
+        if (args[key] === undefined || args[key] === null) {
+           // Opsiyonel alanlar için esneklik sağlanabilir ama kritik alanlar için hata fırlatıyoruz
+           // throw new Error(`Shopier: Parameter ${key} is missing`);
+        }
+      });
+
+      // 4. İmza Oluşturma (Native Crypto)
+      const dataToSign = args.random_nr + args.platform_order_id + args.total_order_value + args.currency;
+      const signature = crypto.createHmac('sha256', this.apiSecret)
+                              .update(dataToSign)
+                              .digest('base64');
+
+      args.signature = signature;
+
+      // 5. HTML Formunu Oluştur
+      const formHtml = this._generateHtml(args);
+
+      return {
+        status: 'success',
+        data: {
+          orderId: platformOrderId,
+          amount: paymentDetails.amount,
+          html: formHtml // Frontend'de bu HTML'i ekrana basıp formu submit edeceksin
+        }
+      };
+
+    } catch (error) {
+       throw new Error(`Error in Shopier payment creation: ${error.message}`);
+    }
+  }
+
+  /**
+   * Callback (Geri Dönüş) İşleme
+   * @param {Object} body - POST request body
+   */
+  handleCallback(body) {
+    try {
+      const data = body.random_nr + body.platform_order_id;
+      // Gelen imza base64, bunu normal stringe çevirip karşılaştırmalıyız ya da direkt ürettiğimizi karşılaştırmalıyız.
+      // Shopier dökümantasyonuna göre: HmacSHA256(random_nr + platform_order_id, secret) == signature (base64)
+      
+      const expectedSignature = crypto.createHmac('sha256', this.apiSecret)
+                                      .update(data)
+                                      .digest('base64');
+
+      if (body.signature === expectedSignature) {
+        if (body.status === 'success') {
+          return {
+            success: true,
+            order_id: body.platform_order_id,
+            payment_id: body.payment_id,
+            installment: body.installment,
+            random_nr: body.random_nr
+          };
+        } else {
+          return { success: false, message: "Shopier: Payment status is not success." };
+        }
+      } else {
+        throw new Error('Shopier: Signature mismatch. Invalid callback.');
+      }
+    } catch (error) {
+      throw new Error(`Error in Shopier callback handling: ${error.message}`);
+    }
+  }
+
+  // --- Private Helpers ---
+
+  _generateHtml(args) {
+    let inputs = '';
+    Object.keys(args).forEach(key => {
+      inputs += `<input type="hidden" name="${key}" value="${args[key]}">`;
+    });
+
+    return `<!doctype html>
+    <html lang="tr">
+    <head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, user-scalable=no, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0">
+    <title>Ödeme Yapılıyor...</title>
+    </head>
+    <body>
+      <form id="shopier_payment_form" method="post" action="${this.paymentUrl}">
+        ${inputs}
+      </form>
+      <script type="text/javascript">
+        document.getElementById("shopier_payment_form").submit();
+      </script>
+    </body>
+    </html>`;
+  }
+
+  _mapCurrency(currency) {
+    switch(currency) {
+      case 'TL':
+      case 'TRY': return 0;
+      case 'USD': return 1;
+      case 'EUR': return 2;
+      default: return 0;
+    }
+  }
+}
+
+module.exports = Shopier;

package/lib/shurjopay.js

@@ -0,0 +1,159 @@
+const axios = require('axios');
+const crypto = require('crypto');
+
+class ShurjoPayClient {
+    constructor(config) {
+        const requiredFields = ['username', 'password', 'prefix'];
+        for (let field of requiredFields) {
+            if (!config[field]) throw new Error(`Missing required field: ${field}`);
+        }
+
+        this.username = config.username;
+        this.password = config.password;
+        this.prefix = config.prefix;
+        this.baseURL = config.sandbox 
+            ? 'https://sandbox.shurjopayment.com' 
+            : 'https://engine.shurjopayment.com';
+        
+        this.token = null;
+
+        this.client = axios.create({
+            baseURL: this.baseURL,
+            headers: {
+                'Content-Type': 'application/json'
+            }
+        });
+    }
+
+    async authenticate() {
+        try {
+            const response = await this.client.post('/api/get_token', {
+                username: this.username,
+                password: this.password
+            });
+
+            if (response.data.token) {
+                this.token = response.data.token;
+                this.client.defaults.headers['Authorization'] = `Bearer ${this.token}`;
+                return this.token;
+            } else {
+                throw new Error('Authentication failed');
+            }
+        } catch (error) {
+            throw new Error(`Authentication error: ${error.response?.data?.message || error.message}`);
+        }
+    }
+
+    async createPayment(options) {
+        try {
+            if (!this.token) {
+                await this.authenticate();
+            }
+
+            const orderId = options.orderId || `${this.prefix}${Date.now()}`;
+            
+            const paymentData = {
+                prefix: this.prefix,
+                token: this.token,
+                return_url: options.successUrl || options.callback_link,
+                cancel_url: options.failUrl || options.callback_link,
+                store_id: this.prefix,
+                amount: parseFloat(options.amount),
+                order_id: orderId,
+                currency: options.currency || 'BDT',
+                customer_name: options.name || options.customerName || '',
+                customer_address: options.address || '',
+                customer_city: options.city || 'Dhaka',
+                customer_phone: options.phone || '',
+                customer_email: options.email || '',
+                client_ip: options.clientIp || '127.0.0.1',
+                intent: 'sale',
+                discsount_amount: options.discount || 0,
+                disc_percent: options.discountPercent || 0
+            };
+
+            const response = await this.client.post('/api/secret-pay', paymentData);
+
+            if (response.data.checkout_url) {
+                return {
+                    status: 'success',
+                    data: {
+                        url: response.data.checkout_url,
+                        orderId: orderId,
+                        amount: paymentData.amount,
+                        currency: paymentData.currency,
+                        sp_order_id: response.data.sp_order_id
+                    }
+                };
+            } 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 orderId = callbackData.order_id;
+            
+            if (!orderId) {
+                throw new Error('Order ID not found in callback data');
+            }
+
+            // Verify payment
+            const verification = await this.verifyPayment(orderId);
+
+            // Status mapping
+            const statusMapping = {
+                'success': 'success',
+                'Success': 'success',
+                'failed': 'failed',
+                'Failed': 'failed',
+                'pending': 'pending',
+                'Pending': 'pending',
+                'cancel': 'failed',
+                'Cancel': 'failed'
+            };
+
+            return {
+                status: statusMapping[verification[0].sp_status] || 'unknown',
+                orderId: verification[0].order_id,
+                transactionId: verification[0].bank_trx_id,
+                amount: parseFloat(verification[0].amount),
+                currency: verification[0].currency,
+                paymentStatus: verification[0].sp_status,
+                method: verification[0].method,
+                bankStatus: verification[0].bank_status
+            };
+        } catch (error) {
+            throw new Error(`Error in ShurjoPay callback handling: ${error.message}`);
+        }
+    }
+
+    async verifyPayment(orderId) {
+        try {
+            if (!this.token) {
+                await this.authenticate();
+            }
+
+            const response = await this.client.post('/api/verification', {
+                order_id: orderId
+            });
+
+            return response.data;
+        } catch (error) {
+            throw new Error(`Error verifying payment: ${error.response?.data?.message || error.message}`);
+        }
+    }
+
+    async getPaymentStatus(orderId) {
+        try {
+            return await this.verifyPayment(orderId);
+        } catch (error) {
+            throw new Error(`Error getting payment status: ${error.message}`);
+        }
+    }
+}
+
+module.exports = ShurjoPayClient;

package/lib/toyyibpay.js

@@ -0,0 +1,151 @@
+const axios = require('axios');
+const crypto = require('crypto');
+
+class ToyyibPayClient {
+    constructor(config) {
+        const requiredFields = ['secretKey', 'categoryCode'];
+        for (let field of requiredFields) {
+            if (!config[field]) throw new Error(`Missing required field: ${field}`);
+        }
+
+        this.secretKey = config.secretKey;
+        this.categoryCode = config.categoryCode;
+        this.URL = 'https://dev.toyyibpay.com';
+
+        this.client = axios.create({
+            baseURL: this.URL,
+            headers: {
+                'Content-Type': 'application/x-www-form-urlencoded'
+            }
+        });
+
+        this.client.interceptors.response.use(response => {
+            return response;
+        }, error => {
+            if (error.response) {
+                throw new Error(`ToyyibPay API error: ${error.response.data.message || error.message}`);
+            }
+            throw new Error(`ToyyibPay API error: ${error.message}`);
+        });
+    }
+
+    async createPayment(options) {
+        try {
+            const params = new URLSearchParams();
+            params.append('userSecretKey', this.secretKey);
+            params.append('categoryCode', this.categoryCode);
+            params.append('billName', options.billName || options.name || 'Bill');
+            params.append('billDescription', options.billDescription || options.description || 'Payment');
+            params.append('billPriceSetting', '1');
+            params.append('billPayorInfo', '1');
+            params.append('billAmount', Math.round(parseFloat(options.amount) * 100));
+            params.append('billReturnUrl', options.returnUrl || options.callback_link);
+            params.append('billCallbackUrl', options.callbackUrl || options.callback_link);
+            params.append('billExternalReferenceNo', options.referenceNo || options.orderId || `ORDER-${Date.now()}`);
+            params.append('billTo', options.billTo || options.customerName || options.name || 'Customer');
+            params.append('billEmail', options.billEmail || options.email);
+            params.append('billPhone', options.billPhone || options.phone || '60123456789');
+            params.append('billSplitPayment', '0');
+            params.append('billSplitPaymentArgs', '');
+            params.append('billPaymentChannel', options.paymentChannel || '0');
+            params.append('billContentEmail', options.contentEmail || 'Thank you for your payment');
+            
+            if (options.billChargeToCustomer) {
+                params.append('billChargeToCustomer', options.billChargeToCustomer);
+            }
+
+            const response = await this.client.post('/index.php/api/createBill', params);
+
+            if (response.data[0].BillCode) {
+                return {
+                    status: 'success',
+                    data: {
+                        billCode: response.data[0].BillCode,
+                        url: `${this.URL}/${response.data[0].BillCode}`,
+                        referenceNo: options.referenceNo || options.orderId
+                    }
+                };
+            } else {
+                throw new Error(response.data[0].error || 'Payment creation failed');
+            }
+        } catch (error) {
+            throw new Error(`Payment creation error: ${error.message}`);
+        }
+    }
+
+    async getBillTransactions(billCode) {
+        try {
+            const params = new URLSearchParams();
+            params.append('billCode', billCode);
+
+            const response = await this.client.post('/index.php/api/getBillTransactions', params);
+            return response.data;
+        } catch (error) {
+            throw new Error(`Bill transactions 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: 1 = success, 2 = pending, 3 = failed
+            const statusMapping = {
+                '1': 'success',
+                '2': 'pending',
+                '3': 'failed'
+            };
+
+            return {
+                status: statusMapping[data.status_id] || 'unknown',
+                billCode: data.billcode,
+                orderId: data.order_id || data.billExternalReferenceNo,
+                amount: parseFloat(data.amount) / 100,
+                transactionId: data.transaction_id,
+                paymentStatus: data.status_id,
+                transactionTime: data.transaction_time,
+                payerName: data.billpayorname,
+                payerEmail: data.billpayoremail,
+                payerPhone: data.billpayorphone
+            };
+        } catch (error) {
+            throw new Error(`Error in ToyyibPay callback handling: ${error.message}`);
+        }
+    }
+
+    async verifyCallback(data) {
+        try {
+            // ToyyibPay uses hash verification
+            if (data.status_id === '3') {
+                return {
+                    status: false,
+                    error: {
+                        code: 400,
+                        message: 'Payment failed'
+                    }
+                };
+            }
+
+            return {
+                status: true,
+                data: data
+            };
+        } catch (error) {
+            return {
+                status: false,
+                error: {
+                    code: 500,
+                    message: error.message
+                }
+            };
+        }
+    }
+}
+
+module.exports = ToyyibPayClient;