strapi-plugin-payone-provider 5.8.29 → 5.8.31

package/admin/src/pages/App/components/transaction-history/TransactionTable.jsx

@@ -14,7 +14,7 @@ import { ChevronDownIcon, ChevronUpIcon } from "../icons";
 import {
   formatAmount,
   formatDate,
-  getPaymentMethodName,
+  getPaymentMethodDisplay,
 } from "../../../utils/transactionTableUtils";
 import TransactionDetails from "./details/TransactionDetails";
 import FiltersPanel from "./FiltersPanel";
@@ -131,19 +131,28 @@ const TransactionTable = () => {
             {formatAmount(transaction.amount, transaction.currency)}
           </Typography>
         );
-      case "paymentMethod":
+      case "paymentMethod": {
+        const clearingtype =
+          transaction.raw_request?.clearingtype ||
+          transaction.body?.raw_request?.clearingtype;
+        const wallettype =
+          transaction.raw_request?.wallettype ||
+          transaction.body?.raw_request?.wallettype;
+        const cardtype =
+          transaction.raw_request?.cardtype ||
+          transaction.body?.raw_request?.cardtype;
+        const { category, subtype } = getPaymentMethodDisplay(
+          clearingtype,
+          wallettype,
+          cardtype
+        );
         return (
           <Typography variant="pi">
-            {getPaymentMethodName(
-              transaction.raw_request?.clearingtype ||
-                transaction.body?.raw_request?.clearingtype,
-              transaction.raw_request?.wallettype ||
-                transaction.body?.raw_request?.wallettype,
-              transaction.raw_request?.cardtype ||
-                transaction.body?.raw_request?.cardtype
-            )}
+            {category}
+            {subtype ? ` / ${subtype}` : ""}
           </Typography>
         );
+      }
       case "type":
         return (
           <Typography variant="pi" fontWeight="semiBold">

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

@@ -69,3 +69,49 @@ export const getCardTypeName = (transaction) => {
       return cardtype || "Unknown";
   }
 };
+
+const CARD_TYPE_LABELS = {
+  V: "Visa",
+  M: "Mastercard",
+  A: "American Express",
+  J: "JCB",
+  D: "Diners",
+  O: "Maestro",
+};
+
+export const getCardTypeLabel = (cardtype) =>
+  CARD_TYPE_LABELS[cardtype] || cardtype || null;
+
+export const getWalletLabel = (wallettype) => {
+  switch (String(wallettype || "").toUpperCase()) {
+    case "PPE":
+      return "PayPal";
+    case "GPY":
+    case "GOOGLEPAY":
+      return "Google Pay";
+    case "APL":
+    case "APPLEPAY":
+      return "Apple Pay";
+    default:
+      return wallettype || null;
+  }
+};
+
+/**
+ * Resolves a transaction's payment method into a category and subtype label.
+ * @returns {{ category: string, subtype: string|null }}
+ */
+export const getPaymentMethodDisplay = (clearingtype, wallettype, cardtype) => {
+  switch (clearingtype) {
+    case "cc":
+      return { category: "Credit Card", subtype: getCardTypeLabel(cardtype) };
+    case "wlt":
+      return { category: "Wallet", subtype: getWalletLabel(wallettype) };
+    case "sb":
+      return { category: "Online Banking", subtype: null };
+    case "elv":
+      return { category: "Direct Debit", subtype: "SEPA" };
+    default:
+      return { category: clearingtype || "Unknown", subtype: null };
+  }
+};

package/package.json

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

package/server/services/transactionService.js

@@ -72,55 +72,10 @@ const buildWhereFromFilters = (filters = {}) => {
     conditions.push({ createdAt: { $lte: dateTo.toISOString() } });
   }
 
-  if (hasFilterValue(filters.payment_method)) {
-    switch (filters.payment_method) {
-      case "credit_card":
-        conditions.push({ raw_request: { $containsi: '"clearingtype":"cc"' } });
-        break;
-      case "paypal":
-        conditions.push({
-          $and: [
-            { raw_request: { $containsi: '"clearingtype":"wlt"' } },
-            { raw_request: { $containsi: '"wallettype":"PPE"' } },
-          ],
-        });
-        break;
-      case "google_pay":
-        conditions.push({
-          $and: [
-            { raw_request: { $containsi: '"clearingtype":"wlt"' } },
-            {
-              $or: [
-                { raw_request: { $containsi: '"wallettype":"GPY"' } },
-                { raw_request: { $containsi: '"wallettype":"GOOGLEPAY"' } },
-              ],
-            },
-          ],
-        });
-        break;
-      case "apple_pay":
-        conditions.push({
-          $and: [
-            { raw_request: { $containsi: '"clearingtype":"wlt"' } },
-            {
-              $or: [
-                { raw_request: { $containsi: '"wallettype":"APL"' } },
-                { raw_request: { $containsi: '"wallettype":"APPLEPAY"' } },
-              ],
-            },
-          ],
-        });
-        break;
-      case "sofort":
-        conditions.push({ raw_request: { $containsi: '"clearingtype":"sb"' } });
-        break;
-      case "sepa":
-        conditions.push({ raw_request: { $containsi: '"clearingtype":"elv"' } });
-        break;
-      default:
-        break;
-    }
-  }
+  // `payment_method` is NOT filtered here: the payment method lives inside the
+  // `raw_request` JSON column, and the query engine cannot reliably filter JSON
+  // columns ($containsi returns empty). It is applied in JS — see
+  // `matchesPaymentMethod` used by getTransactionHistory / getTransactionsForExport.
 
   if (conditions.length === 0) return undefined;
   if (conditions.length === 1) return conditions[0];
@@ -137,24 +92,76 @@ const ALLOWED_SORT_FIELDS = [
   "updatedAt",
 ];
 
+// PayOne wallet (`clearingtype: wlt`) codes per payment method. Google Pay is
+// `GGP` and Apple Pay `APL` — the values the plugin itself writes in
+// `paymentMethodParams.js`; the extra aliases cover legacy rows.
+const WALLET_CODES = {
+  paypal: ["PPE"],
+  google_pay: ["GGP", "GPY", "GOOGLEPAY"],
+  apple_pay: ["APL", "APPLEPAY"],
+};
+
+const PAYMENT_METHOD_MATCHERS = {
+  credit_card: (rr) => rr.clearingtype === "cc",
+  paypal: (rr) => rr.clearingtype === "wlt" && WALLET_CODES.paypal.includes(rr.wallettype),
+  google_pay: (rr) => rr.clearingtype === "wlt" && WALLET_CODES.google_pay.includes(rr.wallettype),
+  apple_pay: (rr) => rr.clearingtype === "wlt" && WALLET_CODES.apple_pay.includes(rr.wallettype),
+  sofort: (rr) => rr.clearingtype === "sb",
+  sepa: (rr) => rr.clearingtype === "elv",
+};
+
+/** Matches a transaction row against a payment_method filter value using its raw_request JSON. */
+const matchesPaymentMethod = (row, method) => {
+  const matcher = PAYMENT_METHOD_MATCHERS[method];
+  if (!matcher) return true;
+  const rr = parseJsonField(row.raw_request);
+  const wallettype = rr.wallettype || rr["add_paydata[paymentmethod]"] || "";
+  return matcher({
+    clearingtype: String(rr.clearingtype || "").toLowerCase(),
+    wallettype: String(wallettype).toUpperCase(),
+  });
+};
+
 const getTransactionHistory = async (
   strapi,
   { filters = {}, pagination = {}, sort_by, sort_order }
 ) => {
   const page = Math.max(1, Number(pagination.page) || 1);
   const pageSize = Math.min(100, Math.max(1, Number(pagination.pageSize) || 10));
-  const offset = (page - 1) * pageSize;
 
   const where = buildWhereFromFilters(filters);
-
   const sortField =
     sort_by && ALLOWED_SORT_FIELDS.includes(sort_by) ? sort_by : "createdAt";
   const order = sort_order === "asc" ? "asc" : "desc";
 
+  const paymentMethod = hasFilterValue(filters.payment_method)
+    ? String(filters.payment_method).trim()
+    : "";
+
+  // payment_method can only be filtered in JS — fetch SQL-filtered rows, then
+  // filter and paginate by payment method here.
+  if (paymentMethod) {
+    const listOptions = { orderBy: { [sortField]: order }, limit: 10000 };
+    if (where !== undefined) listOptions.where = where;
+
+    const allRows = await strapi.db.query(TRANSACTION_UID).findMany(listOptions);
+    const filtered = allRows.filter((row) => matchesPaymentMethod(row, paymentMethod));
+
+    const total = filtered.length;
+    const pageCount = Math.max(1, Math.ceil(total / pageSize));
+    const validPage = Math.min(page, pageCount);
+    const start = (validPage - 1) * pageSize;
+
+    return {
+      data: filtered.slice(start, start + pageSize),
+      pagination: { page: validPage, pageSize, pageCount, total },
+    };
+  }
+
   const queryOptions = {
     orderBy: { [sortField]: order },
     limit: pageSize,
-    offset,
+    offset: (page - 1) * pageSize,
   };
   if (where !== undefined) queryOptions.where = where;
 
@@ -167,12 +174,7 @@ const getTransactionHistory = async (
 
   return {
     data,
-    pagination: {
-      page: validPage,
-      pageSize,
-      pageCount,
-      total,
-    },
+    pagination: { page: validPage, pageSize, pageCount, total },
   };
 };
 
@@ -194,7 +196,12 @@ const getTransactionsForExport = async (
   if (where !== undefined) queryOptions.where = where;
 
   const data = await strapi.db.query(TRANSACTION_UID).findMany(queryOptions);
-  return data;
+  const paymentMethod = hasFilterValue(filters.payment_method)
+    ? String(filters.payment_method).trim()
+    : "";
+  return paymentMethod
+    ? data.filter((row) => matchesPaymentMethod(row, paymentMethod))
+    : data;
 };
 
 const TRANSACTION_ATTRS = [