quickpos 1.0.910 → 1.0.912

package/lib/paynettr.js

@@ -0,0 +1,165 @@
+const axios = require('axios');
+const crypto = require('crypto');
+
+class PayNetTRClient {
+    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://api.paynet.com.tr';
+
+        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; // Kuruş cinsine çevir
+            
+            const paymentData = {
+                merchant_id: this.merchantId,
+                order_id: orderId,
+                amount: amount,
+                currency: options.currency || 'TRY',
+                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,
+                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
+            };
+        } catch (error) {
+            throw new Error(`Error in PayNetTR 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}`);
+        }
+    }
+}
+
+module.exports = PayNetTRClient;

package/lib/payoneer.js

@@ -0,0 +1,128 @@
+const axios = require('axios');
+const crypto = require('crypto');
+
+class PayoneerClient {
+    constructor(config) {
+        const requiredFields = ['programId', 'username', 'password'];
+        for (let field of requiredFields) {
+            if (!config[field]) throw new Error(`Missing required field: ${field}`);
+        }
+
+        this.programId = config.programId;
+        this.username = config.username;
+        this.password = config.password;
+        this.baseURL = config.sandbox 
+            ? 'https://api.sandbox.payoneer.com' 
+            : 'https://api.payoneer.com';
+
+        this.client = axios.create({
+            baseURL: this.baseURL,
+            auth: {
+                username: this.username,
+                password: this.password
+            },
+            headers: {
+                'Content-Type': 'application/json'
+            }
+        });
+    }
+
+    async createPayment(options) {
+        try {
+            const payeeId = options.payeeId || options.email;
+            const orderId = options.orderId || `ORDER-${Date.now()}`;
+            
+            const paymentData = {
+                program_id: this.programId,
+                payee_id: payeeId,
+                payment_id: orderId,
+                amount: parseFloat(options.amount),
+                currency: options.currency || 'USD',
+                description: options.description || options.name || 'Payment',
+                payee_email: options.email,
+                payee_first_name: options.firstName || '',
+                payee_last_name: options.lastName || ''
+            };
+
+            const response = await this.client.post('/v2/payments', paymentData);
+
+            return {
+                status: 'success',
+                data: {
+                    paymentId: orderId,
+                    payeeId: payeeId,
+                    amount: paymentData.amount,
+                    currency: paymentData.currency,
+                    status: response.data.status,
+                    paymentStatus: response.data.payment_status
+                }
+            };
+        } catch (error) {
+            throw new Error(`Payment creation error: ${error.response?.data?.error || error.message}`);
+        }
+    }
+
+    async handleCallback(callbackData) {
+        try {
+            // Payoneer typically doesn't use callbacks but status checks
+            const paymentId = callbackData.payment_id || callbackData.paymentId;
+            
+            if (!paymentId) {
+                throw new Error('Payment ID not found in callback data');
+            }
+
+            // Get payment status
+            const payment = await this.getPaymentStatus(paymentId);
+
+            // Status mapping
+            const statusMapping = {
+                'Done': 'success',
+                'Completed': 'success',
+                'Pending': 'pending',
+                'Canceled': 'failed',
+                'Failed': 'failed'
+            };
+
+            return {
+                status: statusMapping[payment.status] || 'unknown',
+                orderId: payment.payment_id,
+                transactionId: payment.payment_id,
+                amount: parseFloat(payment.amount),
+                currency: payment.currency,
+                paymentStatus: payment.status,
+                payeeId: payment.payee_id
+            };
+        } catch (error) {
+            throw new Error(`Error in Payoneer callback handling: ${error.message}`);
+        }
+    }
+
+    async getPaymentStatus(paymentId) {
+        try {
+            const response = await this.client.get(`/v2/payments/${paymentId}`);
+            return response.data;
+        } catch (error) {
+            throw new Error(`Error getting payment status: ${error.response?.data?.error || error.message}`);
+        }
+    }
+
+    async getPayeeDetails(payeeId) {
+        try {
+            const response = await this.client.get(`/v2/payees/${payeeId}`);
+            return response.data;
+        } catch (error) {
+            throw new Error(`Error getting payee details: ${error.response?.data?.error || error.message}`);
+        }
+    }
+
+    async cancelPayment(paymentId) {
+        try {
+            const response = await this.client.delete(`/v2/payments/${paymentId}`);
+            return response.data;
+        } catch (error) {
+            throw new Error(`Error canceling payment: ${error.response?.data?.error || error.message}`);
+        }
+    }
+}
+
+module.exports = PayoneerClient;

package/lib/payop.js

@@ -0,0 +1,256 @@
+/**
+ * Payop - JavaScript client for Payop payment service
+ * Based on documentation: https://github.com/Payop/payop-api-doc
+ */
+class Payop {
+  /**
+   * Create a new Payop client
+   * @param {Object} config - Configuration options
+   * @param {string} config.publicKey - Public key for merchant identification
+   * @param {string} config.secretKey - Secret key for signing requests
+   * @param {string} [config.environment] - API environment ('production' or 'sandbox')
+   */
+  constructor(config) {
+    this.config = {
+      environment: 'production',
+      ...config
+    };
+    
+    this.baseUrl = this.config.environment === 'sandbox' 
+      ? 'https://payop.com/api/v1' 
+      : 'https://payop.com/api/v1';
+  }
+
+  /**
+   * Generate a unique identifier
+   * @returns {string} - Unique ID
+   */
+  generateUniqueId() {
+    return require('crypto').randomBytes(16).toString('hex');
+  }
+
+  /**
+   * Calculate a signature for Payop requests
+   * @param {Object} data - Data to sign
+   * @returns {string} - Signature
+   */
+  createSignature(data) {
+    const stringToSign = this._createStringToSign(data);
+    return require('crypto')
+      .createHash('sha256')
+      .update(stringToSign)
+      .digest('hex');
+  }
+
+  /**
+   * Create string to sign from data object
+   * @param {Object} data - Data object
+   * @returns {string} - String to sign
+   * @private
+   */
+  _createStringToSign(data) {
+    // According to Payop docs, we need to sort the data,
+    // concatenate everything except the 'signature' field,
+    // and then hash it
+    const sortedKeys = Object.keys(data).sort();
+    return sortedKeys
+      .filter(key => key !== 'signature' && data[key] !== null && data[key] !== undefined)
+      .map(key => data[key])
+      .join(':');
+  }
+
+  /**
+   * Make an authenticated API request to Payop
+   * @param {string} endpoint - API endpoint
+   * @param {Object} data - Request data
+   * @param {string} method - HTTP method
+   * @returns {Promise<Object>} - Response data
+   */
+  async makeRequest(endpoint, data = {}, method = 'POST') {
+    try {
+      const url = `${this.baseUrl}${endpoint}`;
+      
+      const options = {
+        method,
+        headers: {
+          'Content-Type': 'application/json',
+          'Accept': 'application/json',
+          'X-API-KEY': this.config.publicKey
+        }
+      };
+
+      if (method !== 'GET' && data) {
+        options.body = JSON.stringify(data);
+      }
+
+      const response = await fetch(url, options);
+      const result = await response.json();
+      
+      if (!response.ok) {
+        throw new Error(`Payop API error: ${JSON.stringify(result)}`);
+      }
+      
+      return result;
+    } catch (error) {
+      throw new Error(`Payop API request failed: ${error.message}`);
+    }
+  }
+
+  /**
+   * Create a checkout invoice
+   * @param {Object} options - Invoice options
+   * @param {string} options.order - Order ID in your system
+   * @param {number} options.amount - Payment amount
+   * @param {string} options.currency - Payment currency (3-letter code)
+   * @param {string} options.description - Payment description
+   * @param {Object} options.customer - Customer information (email, name, etc)
+   * @param {string} options.resultUrl - URL to redirect after payment
+   * @param {string} options.failPath - URL to redirect after failed payment
+   * @param {Object[]} [options.products] - Products information
+   * @returns {Promise<Object>} - Created invoice data
+   */
+  async createInvoice(options) {
+    const data = {
+      publicKey: this.config.publicKey,
+      order: {
+        id: options.order,
+        amount: options.amount,
+        currency: options.currency,
+        description: options.description,
+        items: options.products || []
+      },
+      customer: options.customer,
+      resultUrl: options.resultUrl,
+      failPath: options.failPath
+    };
+
+    // Calculate and add signature
+    const signature = this.createSignature({
+      id: data.order.id,
+      amount: data.order.amount,
+      currency: data.order.currency
+    });
+    
+    data.signature = signature;
+
+    return this.makeRequest('/checkout/create', data);
+  }
+
+  /**
+   * Get invoice status
+   * @param {string} invoiceId - Invoice ID
+   * @returns {Promise<Object>} - Invoice status information
+   */
+  async getInvoice(invoiceId) {
+    return this.makeRequest(`/checkout/invoice/${invoiceId}`, null, 'GET');
+  }
+
+  /**
+   * Get transaction information
+   * @param {string} transactionId - Transaction ID
+   * @returns {Promise<Object>} - Transaction information
+   */
+  async getTransaction(transactionId) {
+    return this.makeRequest(`/transaction/${transactionId}`, null, 'GET');
+  }
+
+  /**
+   * Get available payment methods
+   * @param {string} currency - Currency code (e.g., 'USD')
+   * @returns {Promise<Object>} - Available payment methods
+   */
+  async getPaymentMethods(currency) {
+    return this.makeRequest(`/instrument-settings/payment-methods/${currency}`, null, 'GET');
+  }
+
+  /**
+   * Issue a refund
+   * @param {Object} options - Refund options
+   * @param {string} options.transactionId - Transaction ID
+   * @param {number} options.amount - Refund amount
+   * @param {string} [options.currency] - Refund currency
+   * @param {string} [options.description] - Refund description
+   * @returns {Promise<Object>} - Refund result
+   */
+  async refund(options) {
+    const data = {
+      transactionId: options.transactionId,
+      amount: options.amount
+    };
+
+    if (options.currency) data.currency = options.currency;
+    if (options.description) data.description = options.description;
+
+    return this.makeRequest('/refund/create', data);
+  }
+
+  /**
+   * Verify IPN (Instant Payment Notification) from Payop
+   * @param {Object} notification - Notification data received from Payop
+   * @returns {boolean} - True if notification is valid
+   */
+  verifyNotification(notification) {
+    if (!notification || !notification.signature) {
+      return false;
+    }
+
+    const receivedSignature = notification.signature;
+    const calculatedSignature = this.createSignature({
+      id: notification.transaction.id,
+      amount: notification.transaction.amount,
+      currency: notification.transaction.currency
+    });
+
+    return receivedSignature === calculatedSignature;
+  }
+
+  /**
+   * Create a payout
+   * @param {Object} options - Payout options
+   * @param {string} options.method - Payout method ID
+   * @param {number} options.amount - Payout amount
+   * @param {string} options.currency - Payout currency
+   * @param {Object} options.recipient - Recipient information
+   * @param {string} [options.metadata] - Additional payout metadata
+   * @returns {Promise<Object>} - Payout result
+   */
+  async createPayout(options) {
+    const data = {
+      method: options.method,
+      amount: options.amount,
+      currency: options.currency,
+      recipient: options.recipient
+    };
+
+    if (options.metadata) data.metadata = options.metadata;
+
+    // Calculate and add signature
+    const signature = this.createSignature({
+      amount: data.amount,
+      currency: data.currency
+    });
+    
+    data.signature = signature;
+
+    return this.makeRequest('/payouts/create', data);
+  }
+
+  /**
+   * Get available payout methods
+   * @returns {Promise<Object>} - Available payout methods
+   */
+  async getPayoutMethods() {
+    return this.makeRequest('/payouts/methods', null, 'GET');
+  }
+
+  /**
+   * Check payout status
+   * @param {string} payoutId - Payout ID
+   * @returns {Promise<Object>} - Payout status
+   */
+  async getPayoutStatus(payoutId) {
+    return this.makeRequest(`/payouts/${payoutId}`, null, 'GET');
+  }
+}
+
+module.exports = Payop;