quickpos 1.0.911 → 1.0.912

package/lib/epoint.js

@@ -0,0 +1,162 @@
+const axios = require('axios');
+const crypto = require('crypto');
+
+class EpointClient {
+    constructor(config) {
+        const requiredFields = ['merchantId', 'privateKey'];
+        for (let field of requiredFields) {
+            if (!config[field]) throw new Error(`Missing required field: ${field}`);
+        }
+
+        this.merchantId = config.merchantId;
+        this.privateKey = config.privateKey;
+        this.baseURL = 'https://epoint.az/api';
+
+        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.privateKey)
+            .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 || 'AZN',
+                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 || 'az',
+                email: options.email || '',
+                phone: options.phone || ''
+            };
+
+            paymentData.signature = this.generateSignature(paymentData);
+
+            const response = await this.client.post('/payment/create', paymentData);
+
+            if (response.data.success) {
+                return {
+                    status: 'success',
+                    data: {
+                        url: response.data.data.payment_url,
+                        orderId: orderId,
+                        paymentId: response.data.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',
+                'failed': 'failed',
+                'cancelled': 'failed',
+                'pending': 'pending'
+            };
+
+            return {
+                status: statusMapping[data.status] || 'unknown',
+                orderId: data.order_id,
+                transactionId: data.payment_id,
+                amount: parseFloat(data.amount) / 100,
+                currency: data.currency,
+                paymentStatus: data.status,
+                paymentMethod: data.payment_method
+            };
+        } catch (error) {
+            throw new Error(`Error in Epoint 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('/payment/status', data);
+            return response.data;
+        } catch (error) {
+            throw new Error(`Error getting payment status: ${error.response?.data?.message || error.message}`);
+        }
+    }
+}
+
+module.exports = EpointClient;

package/lib/freekassa.js

@@ -0,0 +1,128 @@
+const axios = require('axios');
+const crypto = require('crypto');
+
+class FreeKassaClient {
+    constructor(config) {
+        const requiredFields = ['shopId', 'secretKey1', 'secretKey2'];
+        for (let field of requiredFields) {
+            if (!config[field]) throw new Error(`Missing required field: ${field}`);
+        }
+
+        this.shopId = config.shopId;
+        this.secretKey1 = config.secretKey1; // For payment form signature
+        this.secretKey2 = config.secretKey2; // For callback verification
+        this.baseURL = 'https://pay.freekassa.ru';
+    }
+
+    generateSignature(amount, orderId, secretKey) {
+        const signatureString = `${this.shopId}:${amount}:${secretKey}:${orderId}`;
+        return crypto.createHash('md5').update(signatureString).digest('hex');
+    }
+
+    async createPayment(options) {
+        try {
+            const orderId = options.orderId || `ORDER-${Date.now()}`;
+            const amount = parseFloat(options.amount).toFixed(2);
+            
+            const signature = this.generateSignature(amount, orderId, this.secretKey1);
+
+            const paymentData = {
+                m: this.shopId,
+                oa: amount,
+                currency: options.currency || 'RUB',
+                o: orderId,
+                s: signature,
+                email: options.email || '',
+                phone: options.phone || '',
+                i: options.paymentMethod || '', // Payment system ID
+                us_customer_name: options.name || ''
+            };
+
+            // Create payment URL
+            const params = new URLSearchParams(paymentData);
+            const paymentUrl = `${this.baseURL}/?${params.toString()}`;
+
+            return {
+                status: 'success',
+                data: {
+                    url: paymentUrl,
+                    orderId: orderId,
+                    amount: amount,
+                    currency: paymentData.currency,
+                    signature: signature
+                }
+            };
+        } catch (error) {
+            throw new Error(`Payment creation error: ${error.message}`);
+        }
+    }
+
+    async handleCallback(callbackData) {
+        try {
+            const verification = await this.verifyCallback(callbackData);
+            
+            if (!verification.status) {
+                throw new Error(verification.error.message);
+            }
+
+            return {
+                status: 'success',
+                orderId: callbackData.MERCHANT_ORDER_ID,
+                transactionId: callbackData.intid,
+                amount: parseFloat(callbackData.AMOUNT),
+                currency: callbackData.MERCHANT_CURRENCY || 'RUB',
+                paymentStatus: 'completed',
+                paymentMethod: callbackData.PAYMENT_ID
+            };
+        } catch (error) {
+            throw new Error(`Error in FreeKassa callback handling: ${error.message}`);
+        }
+    }
+
+    async verifyCallback(data) {
+        try {
+            const receivedSign = data.SIGN;
+            const signatureString = `${this.shopId}:${data.AMOUNT}:${this.secretKey2}:${data.MERCHANT_ORDER_ID}`;
+            const expectedSign = crypto.createHash('md5').update(signatureString).digest('hex');
+
+            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 getBalance() {
+        try {
+            // FreeKassa API for balance check
+            const response = await axios.post('https://api.freekassa.ru/v1/balance', {
+                shopId: this.shopId,
+                nonce: Date.now()
+            });
+
+            return response.data;
+        } catch (error) {
+            throw new Error(`Error getting balance: ${error.message}`);
+        }
+    }
+}
+
+module.exports = FreeKassaClient;

package/lib/instamojo.js

@@ -0,0 +1,158 @@
+const axios = require('axios');
+const crypto = require('crypto');
+
+class InstamojoClient {
+    constructor(config) {
+        const requiredFields = ['apiKey', 'authToken'];
+        for (let field of requiredFields) {
+            if (!config[field]) throw new Error(`Missing required field: ${field}`);
+        }
+
+        this.apiKey = config.apiKey;
+        this.authToken = config.authToken;
+        this.baseURL = config.sandbox 
+            ? 'https://test.instamojo.com/api/1.1' 
+            : 'https://www.instamojo.com/api/1.1';
+
+        this.client = axios.create({
+            baseURL: this.baseURL,
+            headers: {
+                'Content-Type': 'application/json',
+                'X-Api-Key': this.apiKey,
+                'X-Auth-Token': this.authToken
+            }
+        });
+    }
+
+    async createPayment(options) {
+        try {
+            const orderId = options.orderId || `ORDER-${Date.now()}`;
+            
+            const paymentData = {
+                purpose: options.purpose || options.name || 'Payment',
+                amount: parseFloat(options.amount).toFixed(2),
+                buyer_name: options.name || options.buyerName || '',
+                email: options.email || '',
+                phone: options.phone || '',
+                send_email: options.sendEmail !== false,
+                send_sms: options.sendSms || false,
+                redirect_url: options.successUrl || options.callback_link,
+                webhook: options.callbackUrl || options.callback_link,
+                allow_repeated_payments: false
+            };
+
+            const response = await this.client.post('/payment-requests/', paymentData);
+
+            if (response.data.success) {
+                return {
+                    status: 'success',
+                    data: {
+                        id: response.data.payment_request.id,
+                        url: response.data.payment_request.longurl,
+                        orderId: orderId,
+                        amount: response.data.payment_request.amount,
+                        currency: 'INR',
+                        status: response.data.payment_request.status
+                    }
+                };
+            } else {
+                throw new Error(response.data.message || 'Payment request creation failed');
+            }
+        } catch (error) {
+            throw new Error(`Payment creation error: ${error.response?.data?.message || error.message}`);
+        }
+    }
+
+    async handleCallback(callbackData) {
+        try {
+            // Get payment details
+            const paymentId = callbackData.payment_id;
+            
+            if (!paymentId) {
+                throw new Error('Payment ID not found in callback data');
+            }
+
+            const payment = await this.getPaymentDetails(paymentId);
+
+            // Status mapping
+            const statusMapping = {
+                'Credit': 'success',
+                'Pending': 'pending',
+                'Failed': 'failed',
+                'Initiated': 'pending'
+            };
+
+            return {
+                status: statusMapping[payment.status] || 'unknown',
+                orderId: payment.payment_request?.id,
+                transactionId: payment.payment_id,
+                amount: parseFloat(payment.amount),
+                currency: payment.currency || 'INR',
+                paymentStatus: payment.status,
+                paymentMethod: payment.instrument_type,
+                fees: parseFloat(payment.fees || 0),
+                buyer: {
+                    name: payment.buyer_name,
+                    email: payment.buyer_email,
+                    phone: payment.buyer_phone
+                }
+            };
+        } catch (error) {
+            throw new Error(`Error in Instamojo callback handling: ${error.message}`);
+        }
+    }
+
+    async getPaymentDetails(paymentId) {
+        try {
+            const response = await this.client.get(`/payments/${paymentId}/`);
+
+            if (response.data.success) {
+                return response.data.payment;
+            } else {
+                throw new Error(response.data.message || 'Failed to get payment details');
+            }
+        } catch (error) {
+            throw new Error(`Error getting payment details: ${error.response?.data?.message || error.message}`);
+        }
+    }
+
+    async getPaymentRequestDetails(requestId) {
+        try {
+            const response = await this.client.get(`/payment-requests/${requestId}/`);
+
+            if (response.data.success) {
+                return response.data.payment_request;
+            } else {
+                throw new Error(response.data.message || 'Failed to get payment request details');
+            }
+        } catch (error) {
+            throw new Error(`Error getting payment request details: ${error.response?.data?.message || error.message}`);
+        }
+    }
+
+    async initiateRefund(paymentId, options = {}) {
+        try {
+            const refundData = {
+                payment_id: paymentId,
+                type: options.type || 'RFD', // RFD or TNR
+                body: options.reason || 'Customer request'
+            };
+
+            if (options.refund_amount) {
+                refundData.refund_amount = parseFloat(options.refund_amount).toFixed(2);
+            }
+
+            const response = await this.client.post('/refunds/', refundData);
+
+            if (response.data.success) {
+                return response.data.refund;
+            } else {
+                throw new Error(response.data.message || 'Refund initiation failed');
+            }
+        } catch (error) {
+            throw new Error(`Error initiating refund: ${error.response?.data?.message || error.message}`);
+        }
+    }
+}
+
+module.exports = InstamojoClient;

package/lib/konnect.js

@@ -0,0 +1,211 @@
+const axios = require('axios');
+
+/**
+ * Konnect Ödeme Entegrasyonu
+ * 
+ * Başlamadan önce:
+ * 1. Konnect hesabı oluşturun:
+ *    - Sandbox (test): https://dashboard.sandbox.konnect.network
+ *    - Üretim: https://dashboard.konnect.network
+ * 2. KYC/KYB doğrulamasını tamamlayın (kimlik ve kurum doğrulama)
+ * 3. API anahtarınızı ve cüzdan ID'nizi alın
+ */
+class KonnectService {
+  constructor(config) {
+    this.config = config || {};
+    const requiredFields = ['apiKey', 'receiverWalletId'];
+    for (let field of requiredFields) {
+      if (!config[field]) throw new Error(`Missing required field: ${field}`);
+    }
+
+    this.apiKey = config.apiKey;
+    this.receiverWalletId = config.receiverWalletId;
+    
+    // Sandbox veya Production modu seçimi
+    this.sandbox = config.sandbox || false;
+    
+    // API URL'ini ortama göre ayarla
+    if (this.sandbox) {
+      this.baseUrl = 'https://api.sandbox.konnect.network/api/v2';
+    } else {
+      this.baseUrl = config.baseUrl || 'https://api.konnect.network/api/v2';
+    }
+    
+    console.log(`Konnect API URL: ${this.baseUrl}`);
+    this.testMode = config.testMode || false;
+  }
+
+  async createPayment(paymentDetails) {
+    try {
+      let requiredData = ['amount', 'token'];
+      for (let data of requiredData) {
+        if (!paymentDetails[data]) throw new Error(`Missing required data: ${data}`);
+      }
+
+      // Temel ödeme verilerini hazırla
+      const paymentData = {
+        receiverWalletId: this.receiverWalletId,
+        token: paymentDetails.token || 'TND',
+        amount: paymentDetails.amount,
+        type: paymentDetails.type || 'immediate',
+        description: paymentDetails.description || 'Ödeme',
+        acceptedPaymentMethods: paymentDetails.acceptedPaymentMethods || ["wallet", "bank_card", "e-DINAR"],
+        lifespan: paymentDetails.lifespan || 60, // varsayılan 60 dakika
+        checkoutForm: paymentDetails.checkoutForm || false,
+        addPaymentFeesToAmount: paymentDetails.addPaymentFeesToAmount || false,
+        orderId: paymentDetails.orderId || `order-${Date.now()}`,
+        theme: paymentDetails.theme || 'light'
+      };
+
+      // Müşteri bilgilerini ekle (varsa)
+      if (paymentDetails.firstName) paymentData.firstName = paymentDetails.firstName;
+      if (paymentDetails.lastName) paymentData.lastName = paymentDetails.lastName;
+      if (paymentDetails.phoneNumber) paymentData.phoneNumber = paymentDetails.phoneNumber;
+      if (paymentDetails.email) paymentData.email = paymentDetails.email;
+      
+      // Webhook URL'ini ekle (varsa)
+      if (paymentDetails.webhook) paymentData.webhook = paymentDetails.webhook;
+      
+      console.log('Konnect ö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}/payments/init-payment`,
+        headers: {
+          'Content-Type': 'application/json',
+          'x-api-key': this.apiKey
+        },
+        data: paymentData
+      });
+
+      const responseData = response.data;
+      console.log('Konnect API yanıtı:', JSON.stringify(responseData, null, 2));
+
+      // QR kod oluştur (isteğe bağlı)
+      let qrCode = null;
+      if (paymentDetails.generateQr) {
+        qrCode = await this.generateQrCode(responseData.payUrl);
+      }
+
+      return {
+        status: 'success',
+        data: {
+          transactionId: responseData.paymentRef,
+          url: responseData.payUrl,
+          id: responseData.paymentRef,
+          qr: qrCode
+        }
+      };
+    } catch (error) {
+      console.error('Konnect 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(`Konnect 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 Konnect API');
+      } else {
+        throw new Error(`Error in Konnect payment creation: ${error.message}`);
+      }
+    }
+  }
+
+  async getPaymentDetails(paymentRef) {
+    try {
+      const response = await axios({
+        method: 'GET',
+        url: `${this.baseUrl}/payments/${paymentRef}`,
+        headers: {
+          'x-api-key': this.apiKey
+        }
+      });
+
+      const paymentData = response.data.payment;
+      
+      // İşlem durumunu belirle
+      let status = 'pending';
+      if (paymentData.status === 'completed') {
+        status = 'success';
+      }
+
+      return {
+        status: status,
+        paymentId: paymentData.id,
+        orderId: paymentData.orderId,
+        amount: paymentData.amount,
+        reachedAmount: paymentData.reachedAmount,
+        token: paymentData.token,
+        type: paymentData.type,
+        description: paymentData.details,
+        expirationDate: paymentData.expirationDate,
+        transactions: paymentData.transactions || [],
+        raw: paymentData
+      };
+    } catch (error) {
+      if (error.response && error.response.status === 404) {
+        throw new Error(`Payment not found: ${paymentRef}`);
+      } else if (error.response) {
+        throw new Error(`Konnect API error: ${error.response.data.message || error.response.statusText}`);
+      } else {
+        throw new Error(`Error fetching payment details: ${error.message}`);
+      }
+    }
+  }
+
+  async handleCallback(callbackData) {
+    try {
+      if (!callbackData.payment_ref) {
+        throw new Error("Missing payment_ref in callback data");
+      }
+
+      // Ödeme detaylarını al
+      const paymentDetails = await this.getPaymentDetails(callbackData.payment_ref);
+      
+      if (paymentDetails.status === 'success') {
+        return {
+          status: 'success',
+          orderId: paymentDetails.orderId,
+          merchant_oid: paymentDetails.paymentId,
+          amount: paymentDetails.amount,
+          currency: paymentDetails.token,
+          paymentType: 'konnect'
+        };
+      } else {
+        return {
+          status: 'failed',
+          orderId: paymentDetails.orderId || callbackData.payment_ref,
+          reason: 'Payment is not completed'
+        };
+      }
+    } catch (error) {
+      throw new Error(`Error in Konnect callback handling: ${error.message}`);
+    }
+  }
+
+  // QR kod 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 = KonnectService;