strapi-plugin-payone-provider 4.6.10 → 4.6.12

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.12",
   "description": "Strapi plugin for Payone payment gateway integration",
   "license": "MIT",
   "maintainers": [
@@ -48,4 +48,4 @@
     "kind": "plugin",
     "displayName": "Strapi Payone Provider"
   }
-}
+}

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/content-types/index.js

@@ -0,0 +1,5 @@
+const transactionsContentType = require('./transactions/index.js')
+
+module.exports = {
+  'transaction': transactionsContentType
+}

package/server/content-types/transactions/index.js

@@ -0,0 +1,5 @@
+const schema = require('./schema.json');
+
+module.exports = {
+  schema
+}

package/server/content-types/transactions/schema.json

@@ -0,0 +1,87 @@
+{
+  "kind": "collectionType",
+  "collectionName": "transactions",
+  "info": {
+    "singularName": "transaction",
+    "pluralName": "transactions",
+    "displayName": "Transaction"
+  },
+  "options": {
+    "draftAndPublish": false
+  },
+  "pluginOptions": {
+    "content-manager": {
+      "visible": false
+    },
+    "content-type-builder": {
+      "visible": false
+    }
+  },
+  "attributes": {
+    "txid": {
+      "type": "string",
+      "required": false,
+      "default": "NO TXID"
+    },
+    "reference": {
+      "type": "string",
+      "required": false,
+      "default": "NO REFERENCE"
+    },
+    "invoiceid": {
+      "type": "string",
+      "required": false,
+      "default": "NO INVOICE ID"
+    },
+    "amount": {
+      "type": "string",
+      "required": false,
+      "default": "0"
+    },
+    "currency": {
+      "type": "string",
+      "required": false,
+      "default": "EUR"
+    },
+    "status": {
+      "type": "string",
+      "required": false,
+      "default": "unknown"
+    },
+    "error_code": {
+      "type": "string",
+      "required": false,
+      "default": "NO ERROR CODE"
+    },
+    "request_type": {
+      "type": "string",
+      "required": false,
+      "default": "unknown"
+    },
+    "error_message": {
+      "type": "string",
+      "required": false,
+      "default": "NO ERROR MESSAGE"
+    },
+    "customer_message": {
+      "type": "string",
+      "required": false,
+      "default": "NO CUSTOMER MESSAGE"
+    },
+    "body": {
+      "type": "json",
+      "required": false,
+      "default": {}
+    },
+    "raw_request": {
+      "type": "json",
+      "required": false,
+      "default": {}
+    },
+    "raw_response": {
+      "type": "json",
+      "required": false,
+      "default": {}
+    }
+  }
+}

package/server/controllers/payone.js

@@ -118,9 +118,17 @@ 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 = {}, sort_by, sort_order } = 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 },
+        sort_by: sort_by || undefined,
+        sort_order: sort_order || undefined,
+      });
+      ctx.body = result
     } catch (error) {
       handleError(ctx, error);
     }
@@ -246,5 +254,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/index.js

@@ -8,13 +8,14 @@ const controllers = require("./controllers");
 const routes = require("./routes");
 const services = require("./services");
 const policies = require("./policies");
-
+const contentTypes = require("./content-types");
 module.exports = {
   register,
   bootstrap,
   destroy,
   config,
   controllers,
+  contentTypes,
   routes,
   services,
   policies

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/applePayService.js

@@ -174,8 +174,6 @@ const validateApplePayMerchant = async (strapi, params) => {
 
     const sessionResponse = await initializeApplePaySession(strapi, params);
 
-    // Extract add_paydata[applepay_payment_session] from response
-    // Payone returns this in URL-encoded format: add_paydata[applepay_payment_session]=BASE64_STRING
     const applePaySessionBase64 =
       sessionResponse["add_paydata[applepay_payment_session]"] ||
       sessionResponse["add_paydata_applepay_payment_session"] ||

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,14 @@ module.exports = ({ strapi }) => ({
     return await transactionService.logTransaction(strapi, transactionData);
   },
 
-  async getTransactionHistory(filters = {}) {
-    return await transactionService.getTransactionHistory(strapi, filters);
+
+  async getTransactionHistory({ filters = {}, pagination = {}, sort_by = "createdAt", sort_order = "desc" } = {}) {
+    return await transactionService.getTransactionHistory(strapi, {
+      filters,
+      pagination,
+      sort_by,
+      sort_order,
+    });
   },
 
   // Test connection
@@ -59,5 +65,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,