quickpos 1.0.9 → 1.0.902

package/example-bufpay.js

@@ -0,0 +1,68 @@
+const express = require('express');
+const bodyParser = require('body-parser');
+const QuickPos = require('./app');
+
+const app = express();
+app.use(bodyParser.urlencoded({ extended: true }));
+// app.use(require('multer')().none());
+
+const quickPos = new QuickPos({
+  providers: {
+    bufpay: {
+      appId: 'xxxx',
+      appSecret: 'xxx'
+    }
+  }
+});
+
+app.use(quickPos.middleware());
+
+quickPos.providers['bufpay'].createPayment({
+  name: 'Product Name',
+  payType: 'alipay', 
+  price: '100.00',
+  orderId: 'ORDER123',
+  orderUid: 'user@example.com',
+  notifyUrl: 'https://your-domain.com/webhook'
+})
+.then(response => console.log(response))
+.catch(error => console.error(error));
+
+app.post('/shopierWebhook', quickPos.handleCallback('shopier'), (req, res) => {
+  try {
+    console.log('Payment result:', req.paymentResult.data.chartDetails);
+    /*
+    Payment result: {
+    status: 'success',
+      data: {
+        email: 'fastuptime@gmail.com',
+        orderId: '313758163',
+        currency: 0,
+        price: '1',
+        buyerName: 'Can',
+        buyerSurname: 'Kaya',
+        productId: 31857020,
+        productCount: 1,
+        customerNote: '',
+        productList: '31857020',
+        chartDetails: [ [Object] ],
+        isTest: 1
+      }
+    }
+    */
+    if (!(req.body.res && req.body.hash)) {
+      return res.status(400).send('missing parameter');
+    }
+
+    // İşlem başarılı
+    res.send('success');
+  } catch (error) {
+    console.error('Webhook error:', error);
+    res.status(500).send('error');
+  }
+});
+
+const PORT = 80;
+app.listen(PORT, () => {
+  console.log(`Webhook server running on port ${PORT}`);
+});

package/example.js

@@ -9,9 +9,9 @@ app.use(bodyParser.json());
 const quickPos = new QuickPos({
   providers: {
     paytr: {
-      merchantId: '347042',
-      merchantKey: 'XxXxx',
-      merchantSalt: 'XxxXxxX',
+      merchantId: 'xx',
+      merchantKey: 'xx',
+      merchantSalt: 'xxx',
       mode: 'test',
     }
   },

package/lib/bufpay.js

@@ -0,0 +1,215 @@
+const crypto = require('crypto');
+const axios = require('axios');
+
+class BufPay {
+  constructor(config) {
+    this.config = config || {};
+    const requiredFields = ['appId', 'appSecret'];
+    for (let field of requiredFields) {
+      if (!config[field]) throw new Error(`Missing required field: ${field}`);
+    }
+
+    this.appId = config.appId;
+    this.appSecret = config.appSecret;
+    this.baseUrl = 'https://bufpay.com/api';
+  }
+
+  async createPayment(paymentDetails) {
+    try {
+      // console.log('Creating payment with details:', JSON.stringify(paymentDetails, null, 2));
+
+      let requiredData = ['name', 'payType', 'price', 'orderId', 'orderUid', 'notifyUrl'];
+      for (let data of requiredData) {
+        if (!paymentDetails[data]) throw new Error(`Missing required data: ${data}`);
+      }
+
+      const signature = this.generateToken(
+        paymentDetails.name,
+        paymentDetails.payType,
+        paymentDetails.price,
+        paymentDetails.orderId,
+        paymentDetails.orderUid,
+        paymentDetails.notifyUrl,
+        paymentDetails.returnUrl || '',
+        paymentDetails.feedbackUrl || '',
+        this.appSecret
+      );
+
+      // console.log('Generated signature:', signature);
+
+      const formData = {
+        name: paymentDetails.name,
+        pay_type: paymentDetails.payType,
+        price: paymentDetails.price,
+        order_id: paymentDetails.orderId,
+        order_uid: paymentDetails.orderUid,
+        notify_url: paymentDetails.notifyUrl,
+        return_url: paymentDetails.returnUrl || '',
+        feedback_url: paymentDetails.feedbackUrl || '',
+        sign: signature
+      };
+
+      // console.log('Sending request with form data:', JSON.stringify(formData, null, 2));
+
+      const response = await axios({
+        method: 'POST',
+        url: `${this.baseUrl}/pay/${this.appId}?format=json`,
+        headers: {
+          'Content-Type': 'application/x-www-form-urlencoded'
+        },
+        data: new URLSearchParams(formData).toString()
+      });
+
+      // console.log('Received response:', JSON.stringify(response.data, null, 2));
+
+      if (!response.data) {
+        throw new Error('Empty response received from BufPay API');
+      }
+
+      const responseData = response.data;
+
+      // Log the full response for debugging
+      // console.log('Response status:', responseData.status);
+      // console.log('Full response:', JSON.stringify(responseData, null, 2));
+
+      if (responseData.status === 'success' || responseData.status === 'ok') { 
+        return {
+          status: 'success',
+          data: {
+              aoid: responseData.aoid,
+              pay_type: responseData?.pay_type,
+              price: responseData?.price,
+              qr_price: responseData?.qr_price,
+              qr: responseData?.qr,
+              cid: responseData?.cid,
+              expires_in: responseData?.expires_in,
+              return_url: responseData?.return_url,
+              feedback_url: responseData?.feedback_url
+          }
+        };
+      } else {
+        return {
+          status: 'fail',
+          message: responseData?.status
+        }
+      }
+    } catch (error) {
+      // console.error('Error details:', error);
+
+      if (error.response) {
+        // console.error('API Response Error:', {
+        //   status: error.response.status,
+        //   data: error.response.data,
+        //   headers: error.response.headers
+        // });
+        throw new Error(`BufPay API error: ${JSON.stringify(error.response.data)}`);
+      } else if (error.request) {
+        // console.error('No Response Error:', error.request);
+        throw new Error('No response received from BufPay API');
+      } else {
+        // console.error('Request Setup Error:', error.message);
+        throw new Error(`Error in BufPay payment creation: ${error.message}`);
+      }
+    }
+  }
+
+  generateToken(...params) {
+    try {
+      const concatenated = params
+        .filter(param => param !== undefined && param !== null)
+        .map(param => String(param))
+        .join('');
+
+      // console.log('Generating token with params:', concatenated);
+
+      const token = crypto
+        .createHash('md5')
+        .update(concatenated, 'utf8')
+        .digest('hex')
+        .toUpperCase();
+
+      // console.log('Generated token:', token);
+      return token;
+    } catch (error) {
+      // console.error('Token generation error:', error);
+      throw new Error(`Error generating token: ${error.message}`);
+    }
+  }
+
+  verifyCallback(callbackData) {
+    try {
+      console.log('Verifying callback data:', JSON.stringify(callbackData, null, 2));
+
+      const { aoid, order_id, order_uid, price, pay_price, sign } = callbackData;
+
+      if (!aoid || !order_id || !order_uid || !price || !pay_price || !sign) {
+        console.log('Missing required callback fields');
+        return false;
+      }
+
+      const expectedSignature = this.generateToken(
+        aoid,
+        order_id,
+        order_uid,
+        price,
+        pay_price,
+        this.appSecret
+      );
+
+      console.log('Expected signature:', expectedSignature);
+      console.log('Received signature:', sign);
+
+      return sign === expectedSignature;
+    } catch (error) {
+      console.error('Callback verification error:', error);
+      return false;
+    }
+  }
+
+  async handleCallback(callbackData) {
+    try {
+      console.log('Processing callback data:', JSON.stringify(callbackData, null, 2));
+
+      const isValid = this.verifyCallback(callbackData);
+      if (!isValid) {
+        throw new Error("BufPay notification failed: invalid signature");
+      }
+
+      if (callbackData.status === 'success') {
+        return {
+          status: 'success',
+          orderId: callbackData.order_id,
+          transactionId: callbackData.aoid,
+          amount: parseFloat(callbackData.pay_price),
+          originalAmount: parseFloat(callbackData.price),
+          orderUid: callbackData.order_uid
+        };
+      } else {
+        throw new Error(`Payment failed: ${JSON.stringify(callbackData)}`);
+      }
+    } catch (error) {
+      console.error('Callback handling error:', error);
+      throw new Error(`Error in BufPay callback handling: ${error.message}`);
+    }
+  }
+
+  async queryPayment(aoid) {
+    try {
+      console.log('Querying payment with AOID:', aoid);
+
+      if (!aoid) {
+        throw new Error('Transaction ID (AOID) is required');
+      }
+
+      const response = await axios.get(`${this.baseUrl}/query/${aoid}`);
+      console.log('Query response:', JSON.stringify(response.data, null, 2));
+
+      return response.data;
+    } catch (error) {
+      console.error('Payment query error:', error);
+      throw new Error(`Payment query failed: ${error.message}`);
+    }
+  }
+}
+
+module.exports = BufPay;

package/lib/papara.js

@@ -21,9 +21,9 @@ class PaparaClient {
             return response;
         }, error => {
             if (error.response) {
-                throw new Error(`Papara API error: ${error.response}`);
+                throw new Error(`Papara API error: ${error.response.data.message}`);
             }
-            throw new Error(`Papara API error: ${error}`);
+            throw new Error(`Papara API error: ${error.message}`);
         });
     }
 
@@ -92,11 +92,11 @@ class PaparaClient {
 
             return {
                 status: 'success',
-                orderId: verification.data.referenceId,
-                uuid: verification.data.id,
-                amount: parseFloat(verification.data.amount),
-                currency: verification.data.currency,
-                paymentMethod: verification.data.paymentMethod
+                orderId: verification.data.ReferenceId,
+                uuid: verification.data.Id,
+                amount: parseFloat(verification.data.Amount),
+                currency: verification.data.Currency,
+                paymentMethod: verification.data.PaymentMethod
             };
         } catch (error) {
             throw new Error(`Error in Papara callback handling: ${error.message}`);
@@ -105,17 +105,17 @@ class PaparaClient {
 
     async verifyPaymentCallback(data) {
         try {
-            if (data.status !== 1) {
+            if (data.Status !== 1) {
                 return {
                     status: false,
                     error: {
                         code: data?.errorCode,
-                        message: data?.errorMessage || 'Payment failed'
+                        message: data?.ErrorMessage || 'Payment failed'
                     }
                 };
             }
             
-            if (data.merchantSecretKey !== this.merchantSecretKey) {
+            if (data.MerchantSecretKey !== this.merchantSecretKey) {
                 return {
                     status: false,
                     error: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "quickpos",
-  "version": "1.0.9",
+  "version": "1.0.902",
   "main": "app.js",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"