strapi-plugin-payone-provider 4.6.10 → 4.6.11

package/admin/src/pages/utils/transactionTableUtils.js

@@ -0,0 +1,60 @@
+export const getStatusColor = (status) => {
+  switch (status) {
+    case "APPROVED":
+      return "success200";
+    case "ERROR":
+      return "danger200";
+    case "PENDING":
+      return "warning200";
+    case "REDIRECT":
+      return "success100";
+    default:
+      return "success100";
+  }
+};
+
+export const formatAmount = (amount, currency) => {
+  if (amount === null || amount === undefined) return "N/A";
+  return `${(amount / 100).toFixed(2)} ${currency || "EUR"}`;
+};
+
+export const formatDate = (dateString) => {
+  if (!dateString) return "N/A";
+  return new Date(dateString).toLocaleString("de-DE", {
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+  });
+};
+
+export const getPaymentMethodName = (clearingtype, wallettype, cardtype) => {
+  switch (clearingtype) {
+    case "cc":
+      return cardtype ? `CC / ${cardtype}` : "Credit Card";
+    case "sb":
+      return "Online Banking";
+    case "wlt":
+      return wallettype === "PPE" ? "PayPal" : "Wallet";
+    case "elv":
+      return "Direct Debit (SEPA)";
+    default:
+      return clearingtype || "Unknown";
+  }
+};
+
+export const getCardTypeName = (cardtype) => {
+  switch (cardtype) {
+    case "V":
+      return "Visa";
+    case "M":
+      return "Mastercard";
+    case "A":
+      return "American Express";
+    default:
+      return cardtype || "Unknown";
+  }
+};
+
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "strapi-plugin-payone-provider",
-  "version": "4.6.10",
+  "version": "4.6.11",
   "description": "Strapi plugin for Payone payment gateway integration",
   "license": "MIT",
   "maintainers": [

package/server/bootstrap.js

@@ -22,12 +22,12 @@ module.exports = async ({ strapi }) => {
         displayName: "",
         domainName: "",
         merchantIdentifier: "",
-        enableCreditCard: true,
-        enablePayPal: true,
-        enableGooglePay: true,
-        enableApplePay: true,
-        enableSofort: true,
-        enableSepaDirectDebit: true
+        enable3DSecure: false,
+        enableCreditCard: false,
+        enablePayPal: false,
+        enableGooglePay: false,
+        enableApplePay: false,
+        enableSepaDirectDebit: false
       }
     });
   }

package/server/controllers/payone.js

@@ -118,9 +118,15 @@ module.exports = ({ strapi }) => ({
 
   async getTransactionHistory(ctx) {
     try {
-      const filters = ctx.query || {};
-      const history = await getPayoneService(strapi).getTransactionHistory(filters);
-      ctx.body = { data: history };
+      const { filters = {}, pagination = {} } = ctx.query || {};
+      const page = parseInt(pagination.page || "1", 10);
+      const pageSize = parseInt(pagination.pageSize || "10", 10);
+
+      const result = await getPayoneService(strapi).getTransactionHistory({
+        filters: filters || {},
+        pagination: { page, pageSize }
+      });
+      ctx.body = result
     } catch (error) {
       handleError(ctx, error);
     }
@@ -246,5 +252,23 @@ module.exports = ({ strapi }) => ({
         }
       };
     }
+  },
+
+  async handleTransactionStatus(ctx) {
+    try {
+      const notificationData = ctx.request.body || {};
+      await getPayoneService(strapi).processTransactionStatus(notificationData);
+
+      ctx.status = 200;
+      ctx.body = "TSOK";
+      ctx.type = "text/plain";
+      console.log(`[Payone TransactionStatus] Responded TSOK`);
+    } catch (error) {
+      console.log("[Payone TransactionStatus] Error handling notification:", error);
+      ctx.status = 200;
+      ctx.body = "TSOK";
+      ctx.type = "text/plain";
+    }
   }
+
 });

package/server/policies/index.js

@@ -2,5 +2,6 @@
 
 module.exports = {
   "is-auth": require("./is-auth"),
-  "is-super-admin": require("./isSuperAdmin")
+  "is-super-admin": require("./isSuperAdmin"),
+  "is-payone-notification": require("./is-payone-notification")
 };

package/server/policies/is-payone-notification.js

@@ -0,0 +1,31 @@
+"use strict";
+
+module.exports = async (ctx, config, { strapi }) => {
+  const { request } = ctx;
+  const userAgent = request.header["user-agent"] || request.header["User-Agent"] || "";
+  const clientIp = request.ip || request.connection?.remoteAddress || "";
+
+  if (userAgent !== "PAYONE FinanceGate") {
+    console.log(`[Payone TransactionStatus] Invalid User-Agent: ${userAgent}, IP: ${clientIp}`);
+    return false;
+  }
+
+
+  const isValidIp = (ip) => {
+    if (ip.startsWith("185.60.20.")) {
+      return true;
+    }
+
+    if (ip === "54.246.203.105") {
+      return true;
+    }
+    return false;
+  };
+
+  if (!isValidIp(clientIp)) {
+    console.log(`[Payone TransactionStatus] Invalid IP address: ${clientIp}, User-Agent: ${userAgent}`);
+    return false;
+  }
+
+  return true;
+};

package/server/routes/index.js

@@ -162,6 +162,16 @@ module.exports = {
           auth: false
         }
       },
+
+      {
+        method: "POST",
+        path: "/transaction-status",
+        handler: "payone.handleTransactionStatus",
+        config: {
+          policies: ["plugin::strapi-plugin-payone-provider.is-payone-notification"],
+          auth: false
+        }
+      },
     ]
   }
 };

package/server/services/payone.js

@@ -5,7 +5,7 @@ const transactionService = require("./transactionService");
 const paymentService = require("./paymentService");
 const testConnectionService = require("./testConnectionService");
 const applePayService = require("./applePayService");
-
+const transactionStatusService = require("./transactionStatusService");
 module.exports = ({ strapi }) => ({
   // Settings
   async getSettings() {
@@ -38,8 +38,9 @@ module.exports = ({ strapi }) => ({
     return await transactionService.logTransaction(strapi, transactionData);
   },
 
-  async getTransactionHistory(filters = {}) {
-    return await transactionService.getTransactionHistory(strapi, filters);
+
+  async getTransactionHistory({ filters = {}, pagination = {} }) {
+    return await transactionService.getTransactionHistory(strapi, { filters, pagination });
   },
 
   // Test connection
@@ -59,5 +60,11 @@ module.exports = ({ strapi }) => ({
 
   async initializeApplePaySession(params) {
     return await applePayService.initializeApplePaySession(strapi, params);
-  }
+  },
+
+  // TransactionStatus Notification
+  async processTransactionStatus(notificationData) {
+    return await transactionStatusService.processTransactionStatus(strapi, notificationData);
+  },
+
 });

package/server/services/settingsService.js

@@ -17,11 +17,17 @@ const getSettings = async (strapi) => {
 
 const updateSettings = async (strapi, settings) => {
   const pluginStore = getPluginStore(strapi);
+  const currentSettings = await getSettings(strapi) || {};
+  const mergedSettings = {
+    ...currentSettings,
+    ...settings
+  };
+
   await pluginStore.set({
     key: "settings",
-    value: settings
+    value: mergedSettings
   });
-  return settings;
+  return mergedSettings;
 };
 
 const validateSettings = (settings) => {

package/server/services/testConnectionService.js

@@ -55,81 +55,18 @@ const testConnection = async (strapi) => {
 
     const result = parseResponse(response.data, strapi.log);
     const status = result.status || result.Status || result.STATUS;
-    const errorMessage =
-      result.errormessage ||
-      result.Errormessage ||
-      result.ERRORMESSAGE ||
-      result.error ||
-      result.Error?.ErrorMessage ||
-      "";
-    const errorCode =
-      result.errorcode ||
-      result.Errorcode ||
-      result.ERRORCODE ||
-      result.Error?.ErrorCode ||
-      "";
-    const customErrorMessage =
-      result.customerrormessage ||
-      result.Customerrormessage ||
-      result.CUSTOMERRORMESSAGE ||
-      result.Error?.CustomerMessage ||
-      "";
+    const errorMessage = result?.Error?.ErrorMessage;
+    const errorCode = result?.Error?.ErrorCode;
+    const customErrorMessage = result?.Error?.CustomerMessage;
 
     if (status === "ERROR" || status === "error") {
-      if (["2006", "920", "921", "922", "401", "403"].includes(errorCode)) {
-        return {
-          success: false,
-          message: `Authentication failed: ${customErrorMessage || errorMessage || "Invalid credentials"}`,
-          errorcode: errorCode
-        };
-      }
-
-      const errorMessageStr = typeof errorMessage === "string" ? errorMessage : JSON.stringify(errorMessage);
-      const errorMessageLower = (errorMessageStr || "").toLowerCase();
-      const authErrorKeywords = [
-        "key incorrect",
-        "invalid key",
-        "portal key",
-        "unauthorized",
-        "not authorized",
-        "unknown aid",
-        "unknown account",
-        "unknown portal",
-        "unknown merchant",
-        "invalid aid",
-        "invalid mid",
-        "invalid portalid"
-      ];
-
-      if (authErrorKeywords.some((keyword) => errorMessageLower.includes(keyword))) {
-        return {
-          success: false,
-          message: `Authentication failed: ${errorMessageStr}`,
-          errorcode: errorCode || "AUTH"
-        };
-      }
-
-      if (errorCode === "911") {
-        return {
-          success: true,
-          message: "Connection successful! Your Payone credentials are valid.",
-          details: {
-            mode: settings.mode,
-            aid: settings.aid,
-            portalid: settings.portalid,
-            mid: settings.mid
-          }
-        };
-      }
-
       return {
         success: false,
-        message: `Connection failed: ${customErrorMessage || errorMessageStr || "Unknown error"}`,
-        errorcode: errorCode,
-        details: {
-          status,
-          errorCode,
-          rawResponse: JSON.stringify(result).substring(0, 200)
+        message: `Test connection failed: ${errorCode}`,
+        error: {
+          ErrorCode: errorCode,
+          ErrorMessage: errorMessage,
+          CustomerMessage: customErrorMessage
         }
       };
     }
@@ -147,6 +84,7 @@ const testConnection = async (strapi) => {
       };
     }
 
+
     return {
       success: false,
       message: "Unexpected response format from Payone API",
@@ -157,11 +95,12 @@ const testConnection = async (strapi) => {
         rawResponse: JSON.stringify(result).substring(0, 200)
       }
     };
+
   } catch (error) {
     strapi.log.error("Payone test connection error:", error);
     return {
       success: false,
-      message: `Connection error: ${error.message || "Unknown error"}`,
+      message: `Test connection error: ${error.message || "Unknown error"}`,
       error: error.toString(),
       details: {
         errorType: error.constructor.name,

package/server/services/transactionService.js

@@ -65,36 +65,32 @@ const logTransaction = async (strapi, transactionData) => {
   strapi.log.info("Transaction logged:", logEntry);
 };
 
-const getTransactionHistory = async (strapi, filters = {}) => {
-  const pluginStore = getPluginStore(strapi);
-  let transactionHistory =
-    (await pluginStore.get({ key: "transactionHistory" })) || [];
-
-  if (filters.search) {
-    const searchLower = filters.search.toLowerCase().trim();
-    transactionHistory = transactionHistory.filter((transaction) => {
-      const status = (transaction.status || "").toLowerCase();
-      const txid = (transaction.txid || "").toLowerCase();
-      const reference = (transaction.reference || "").toLowerCase();
-
-      return (
-        status.includes(searchLower) ||
-        txid.includes(searchLower) ||
-        reference.includes(searchLower)
-      );
+const applyFilters = (transactions, filters = {}) => {
+  let result = [...transactions];
+
+  if (filters.search && typeof filters.search === 'string' && filters.search.trim() !== '') {
+    const search = filters.search.toLowerCase().trim();
+    result = result.filter((t) => {
+      const txid = (t.txid || "").toString().toLowerCase();
+      const reference = (t.reference || "").toString().toLowerCase();
+      return txid.includes(search) || reference.includes(search);
     });
   }
 
-  if (filters.request_type) {
-    transactionHistory = transactionHistory.filter(
-      (transaction) => transaction.request_type === filters.request_type
+  if (filters.status) {
+    result = result.filter(
+      (t) => (t.status || "").toUpperCase() === filters.status.toUpperCase()
     );
   }
 
+  if (filters.request_type) {
+    result = result.filter((t) => t.request_type === filters.request_type);
+  }
+
   if (filters.payment_method) {
-    transactionHistory = transactionHistory.filter((transaction) => {
-      const clearingtype = transaction.raw_request?.clearingtype || "";
-      const wallettype = transaction.raw_request?.wallettype || "";
+    result = result.filter((t) => {
+      const clearingtype = t.raw_request?.clearingtype;
+      const wallettype = t.raw_request?.wallettype;
 
       switch (filters.payment_method) {
         case "credit_card":
@@ -102,82 +98,66 @@ const getTransactionHistory = async (strapi, filters = {}) => {
         case "paypal":
           return clearingtype === "wlt" && wallettype === "PPE";
         case "google_pay":
-          return clearingtype === "wlt" && (wallettype === "GPY" || wallettype === "GOOGLEPAY");
+          return clearingtype === "wlt" && ["GPY", "GOOGLEPAY"].includes(wallettype);
         case "apple_pay":
-          return clearingtype === "wlt" && (wallettype === "APL" || wallettype === "APPLEPAY");
+          return clearingtype === "wlt" && ["APL", "APPLEPAY"].includes(wallettype);
         case "sofort":
           return clearingtype === "sb";
         case "sepa":
           return clearingtype === "elv";
         default:
-          return false;
+          return true;
       }
     });
   }
 
   if (filters.date_from) {
-    transactionHistory = transactionHistory.filter(
-      (transaction) =>
-        new Date(transaction.timestamp) >= new Date(filters.date_from)
+    const dateFrom = new Date(filters.date_from);
+    dateFrom.setHours(0, 0, 0, 0);
+    result = result.filter(
+      (t) => new Date(t.timestamp || t.created_at) >= dateFrom
     );
   }
 
   if (filters.date_to) {
-    transactionHistory = transactionHistory.filter(
-      (transaction) =>
-        new Date(transaction.timestamp) <= new Date(filters.date_to)
+    const dateTo = new Date(filters.date_to);
+    dateTo.setHours(23, 59, 59, 999);
+    result = result.filter(
+      (t) => new Date(t.timestamp || t.created_at) <= dateTo
     );
   }
 
-  if (filters.status) {
-    transactionHistory = transactionHistory.filter(
-      (transaction) => transaction.status === filters.status
-    );
-  }
+  return result;
+};
 
-  // Apply sorting
-  if (filters.sort_by && filters.sort_order) {
-    const sortOrder = filters.sort_order === "desc" ? -1 : 1;
-    
-    transactionHistory.sort((a, b) => {
-      let aValue, bValue;
-
-      switch (filters.sort_by) {
-        case "amount":
-          aValue = a.amount || 0;
-          bValue = b.amount || 0;
-          break;
-        case "created_at":
-          aValue = new Date(a.created_at || a.timestamp || 0).getTime();
-          bValue = new Date(b.created_at || b.timestamp || 0).getTime();
-          break;
-        case "status":
-          aValue = (a.status || "").toLowerCase();
-          bValue = (b.status || "").toLowerCase();
-          break;
-        case "reference":
-          aValue = (a.reference || "").toLowerCase();
-          bValue = (b.reference || "").toLowerCase();
-          break;
-        case "method":
-          const aClearingType = a.raw_request?.clearingtype || "";
-          const bClearingType = b.raw_request?.clearingtype || "";
-          const aWalletType = a.raw_request?.wallettype || "";
-          const bWalletType = b.raw_request?.wallettype || "";
-          aValue = `${aClearingType}_${aWalletType}`.toLowerCase();
-          bValue = `${bClearingType}_${bWalletType}`.toLowerCase();
-          break;
-        default:
-          return 0;
-      }
+const getTransactionHistory = async (strapi, { filters = {}, pagination = {} }) => {
+  const pluginStore = getPluginStore(strapi);
 
-      if (aValue < bValue) return -1 * sortOrder;
-      if (aValue > bValue) return 1 * sortOrder;
-      return 0;
-    });
-  }
+  let transactions =
+    (await pluginStore.get({ key: "transactionHistory" })) || [];
+
+  transactions = applyFilters(transactions, filters);
+  const page = Number(pagination.page) || 1;
+  const pageSize = Number(pagination.pageSize) || 10;
+
+  const total = transactions.length;
+  const pageCount = Math.max(1, Math.ceil(total / pageSize));
 
-  return transactionHistory;
+  const validPage = Math.min(Math.max(1, page), pageCount);
+
+  const start = (validPage - 1) * pageSize;
+  const end = Math.min(start + pageSize, total);
+
+  const paginatedData = start < total ? transactions.slice(start, end) : [];
+  return {
+    data: paginatedData,
+    pagination: {
+      page: validPage,
+      pageSize,
+      pageCount,
+      total,
+    },
+  };
 };
 
 module.exports = {

package/server/services/transactionStatusService.js

@@ -0,0 +1,87 @@
+"use strict";
+
+const crypto = require("crypto");
+const { getPluginStore, getSettings } = require("./settingsService");
+
+const verifyHash = (notificationData, portalKey) => {
+  const {
+    portalid = "",
+    aid = "",
+    txid = "",
+    sequencenumber = "",
+    price = "",
+    currency = "",
+    mode = "",
+  } = notificationData;
+
+  const hashString = `${portalid}${aid}${txid}${sequencenumber}${price}${currency}${mode}${portalKey}`;
+  const expectedHash = crypto.createHash("md5").update(hashString).digest("hex");
+
+  return expectedHash.toLowerCase() === (notificationData.key || "").toLowerCase();
+};
+
+const processTransactionStatus = async (strapi, notificationData) => {
+  try {
+    const settings = await getSettings(strapi);
+    const txid = notificationData.txid;
+
+    if (!settings || !settings.key) {
+      console.log("[Payone TransactionStatus] Settings not found or key missing");
+      return;
+    }
+
+    const isValid = verifyHash(notificationData, settings.key);
+    if (!isValid) {
+      console.log(`[Payone TransactionStatus] Hash verification failed txid: ${txid}`);
+      return;
+    }
+
+    if (notificationData.portalid !== settings.portalid || notificationData.aid !== settings.aid) {
+      console.log(`[Payone TransactionStatus] Portal ID or AID mismatch txid: ${txid}`);
+      return;
+    }
+
+    const pluginStore = getPluginStore(strapi);
+    let transactionHistory = (await pluginStore.get({ key: "transactionHistory" })) || [];
+
+    const transaction = transactionHistory.find((t) => t.txid === txid || t.id === txid);
+
+    if (transaction) {
+      Object.assign(transaction, {
+        ...notificationData,
+        status: notificationData?.transaction_status,
+        txaction: notificationData?.txaction,
+        txtime: notificationData?.txtime,
+        sequencenumber: notificationData?.sequencenumber,
+        balance: notificationData?.balance,
+        receivable: notificationData?.receivable,
+        price: notificationData?.price,
+        amount: notificationData?.price ? parseFloat(notificationData?.price) * 100 : transaction?.amount,
+        userid: notificationData?.userid,
+        updated_at: new Date().toISOString(),
+        body: {
+          ...transaction?.body,
+          ...notificationData,
+          status: notificationData?.transaction_status
+        }
+      });
+
+      await pluginStore.set({
+        key: "transactionHistory",
+        value: transactionHistory,
+      });
+
+      console.log(`[Payone TransactionStatus] Successfully updated transaction txid: ${txid}`);
+    } else {
+      console.log(`[Payone TransactionStatus] Transaction ${txid} not found in history. Notification ignored.`);
+    }
+
+  } catch (error) {
+    console.log(`[Payone TransactionStatus] Error processing notification: ${error}`);
+  }
+};
+
+module.exports = {
+  verifyHash,
+  processTransactionStatus,
+};