strapi-plugin-payone-provider 5.6.11 → 5.6.13

package/admin/src/pages/utils/getInputComponent.jsx

@@ -4,14 +4,27 @@ import {
   SingleSelect,
   SingleSelectOption,
   Switch,
-  DesignSystemProvider,
   Tooltip,
   Textarea,
   Toggle,
   Checkbox,
-  Typography,
+  Typography
 } from "@strapi/design-system";
 import { Information } from "@strapi/icons";
+
+const TooltipIcon = ({ tooltipContent }) => {
+  if (!tooltipContent) return null;
+  return (
+    <Tooltip label={tooltipContent ?? ""}>
+      <Information
+        style={{
+          cursor: "pointer"
+        }}
+      />
+    </Tooltip>
+  );
+};
+
 export const InputComponent = ({
   inputType,
   name,
@@ -23,8 +36,6 @@ export const InputComponent = ({
   placeholder = "",
   onLabel = "True",
   offLabel = "False",
-  systemTheme,
-  theme,
   className = "payment-input",
   type = "text",
   ...props
@@ -43,16 +54,7 @@ export const InputComponent = ({
           type={type}
           endAction={
             tooltipContent ? (
-              <DesignSystemProvider theme={theme}>
-                <Tooltip label={tooltipContent ?? ""}>
-                  <Information
-                    style={{
-                      cursor: "pointer",
-                      color: systemTheme === "dark" ? "#fff" : "#000",
-                    }}
-                  />
-                </Tooltip>
-              </DesignSystemProvider>
+              <TooltipIcon tooltipContent={tooltipContent} />
             ) : null
           }
           {...props}
@@ -71,16 +73,7 @@ export const InputComponent = ({
           required={required}
           startAction={
             tooltipContent ? (
-              <DesignSystemProvider theme={theme}>
-                <Tooltip label={tooltipContent ?? ""}>
-                  <Information
-                    style={{
-                      cursor: "pointer",
-                      color: systemTheme === "dark" ? "#fff" : "#000",
-                    }}
-                  />
-                </Tooltip>
-              </DesignSystemProvider>
+              <TooltipIcon tooltipContent={tooltipContent} />
             ) : null
           }
           {...props}
@@ -143,16 +136,7 @@ export const InputComponent = ({
           type="date"
           startAction={
             tooltipContent ? (
-              <DesignSystemProvider theme={theme}>
-                <Tooltip label={tooltipContent ?? ""}>
-                  <Information
-                    style={{
-                      cursor: "pointer",
-                      color: systemTheme === "dark" ? "#fff" : "#000",
-                    }}
-                  />
-                </Tooltip>
-              </DesignSystemProvider>
+              <TooltipIcon tooltipContent={tooltipContent} />
             ) : null
           }
           {...props}
@@ -179,7 +163,7 @@ export const InputComponent = ({
             if (typeof onChange === "function") {
               const syntheticEvent = {
                 target: { value: selectedValue },
-                currentTarget: { value: selectedValue },
+                currentTarget: { value: selectedValue }
               };
               onChange(syntheticEvent);
             }
@@ -188,16 +172,7 @@ export const InputComponent = ({
           placeholder={placeholder}
           startIcon={
             tooltipContent ? (
-              <DesignSystemProvider theme={theme}>
-                <Tooltip label={tooltipContent ?? ""}>
-                  <Information
-                    style={{
-                      cursor: "pointer",
-                      color: systemTheme === "dark" ? "#fff" : "#000",
-                    }}
-                  />
-                </Tooltip>
-              </DesignSystemProvider>
+              <TooltipIcon tooltipContent={tooltipContent} />
             ) : null
           }
           {...props}

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

@@ -31,8 +31,9 @@ export const formatDate = (dateString) => {
 };
 
 export const getPaymentMethodName = (clearingtype, wallettype) => {
+
   switch (clearingtype) {
-    case "cc":
+    case "cc" || "card" | "c":
       return "Credit Card";
     case "sb":
       return "Online Banking";

package/package.json

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

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

@@ -156,12 +156,22 @@ module.exports = ({ strapi }) => ({
 
   async getTransactionHistory(ctx) {
     try {
-      const { filters = {}, pagination = {} } = ctx.query || {};
+      const { filters: rawFilters = {}, pagination = {} } = ctx.query || {};
       const page = parseInt(pagination.page || "1", 10);
       const pageSize = parseInt(pagination.pageSize || "10", 10);
 
+      const filters = {};
+      if (rawFilters && typeof rawFilters === "object") {
+        for (const [key, value] of Object.entries(rawFilters)) {
+          const v = value == null ? "" : String(value).trim();
+          if (v !== "" && v.toLowerCase() !== "all") {
+            filters[key] = value;
+          }
+        }
+      }
+
       const result = await getPayoneService(strapi).getTransactionHistory({
-        filters: filters || {},
+        filters,
         pagination: { page, pageSize }
       });
 
@@ -299,19 +309,20 @@ 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`);
+      if (!ctx.state.payoneAllowed) {
+        console.log("[Payone] Notification ignored (policy failed)");
+      } else {
+        const notificationData = ctx.request.body || {};
+        console.log(notificationData);
+        await getPayoneService(strapi).processTransactionStatus(notificationData);
+      }
     } catch (error) {
-      console.log("[Payone TransactionStatus] Error handling notification:", error);
-      ctx.status = 200;
-      ctx.body = "TSOK";
-      ctx.type = "text/plain";
+      console.log("[Payone TransactionStatus] Error:", error);
     }
+
+    ctx.status = 200;
+    ctx.body = "TSOK";
+    ctx.type = "text/plain";
   }
 
 });

package/server/index.js

@@ -8,6 +8,7 @@ const controllers = require("./controllers");
 const routes = require("./routes");
 const services = require("./services");
 const policies = require("./policies");
+const contentTypes = require("./content-types");
 
 module.exports = {
   register,
@@ -15,6 +16,7 @@ module.exports = {
   destroy,
   config,
   controllers,
+  contentTypes,
   routes,
   services,
   policies

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

@@ -1,30 +1,19 @@
-"use strict";
+module.exports = async (ctx) => {
+  const { request } = ctx;
 
-module.exports = async (policyContext, config, { strapi }) => {
-  const { request } = policyContext;
-  const userAgent = request.header["user-agent"] || request.header["User-Agent"] || "";
-  const clientIp = request.ip || request.connection?.remoteAddress || "";
+  const userAgent = request.headers["user-agent"] || "";
+  const clientIp =
+    request.headers["x-payone-client-ip"]?.trim() ||
+    request.headers["x-forwarded-for"]?.split(",")[0]?.trim() ||
+    request.ip ||
+    "";
 
-  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;
-    }
+  const isValid = userAgent === "PAYONE FinanceGate" && (clientIp.startsWith("185.60.20.") || clientIp === "54.246.203.105");
 
-    if (ip === "54.246.203.105") {
-      return true;
-    }
-    return false;
-  };
+  ctx.state.payoneAllowed = isValid;
 
-  if (!isValidIp(clientIp)) {
-    console.log(`[Payone TransactionStatus] Invalid IP address: ${clientIp}, User-Agent: ${userAgent}`);
-    return false;
+  if (!isValid) {
+    console.log("[Payone] Policy failed", { userAgent, clientIp });
   }
 
   return true;

package/server/services/transactionService.js

@@ -1,139 +1,172 @@
 "use strict";
 
-const { getPluginStore } = require("./settingsService");
+const { sanitizeSensitive } = require("../utils/sanitize");
 
-const logTransaction = async (strapi, transactionData) => {
-  const pluginStore = getPluginStore(strapi);
-  let transactionHistory =
-    (await pluginStore.get({ key: "transactionHistory" })) || [];
-
-  const logEntry = {
-    id: Date.now().toString(),
-    timestamp: new Date().toISOString(),
-    txid: transactionData.txid || null,
-    reference: transactionData.reference || null,
-    invoiceid: transactionData.invoiceid || null,
-    request_type:
-      transactionData.request_type || transactionData.request || "unknown",
-    amount: transactionData.amount || null,
-    currency: transactionData.currency || "EUR",
-    status: transactionData.status || transactionData.Status || "unknown",
-    error_code:
-      transactionData.error_code || transactionData.Error?.ErrorCode || null,
-    error_message:
-      transactionData.error_message ||
-      transactionData.Error?.ErrorMessage ||
-      null,
-    customer_message:
-      transactionData.customer_message ||
-      transactionData.Error?.CustomerMessage ||
-      null,
-    body: transactionData || null,
-    created_at: new Date().toISOString(),
-    updated_at: new Date().toISOString()
-  };
+const TRANSACTION_UID = "plugin::strapi-plugin-payone-provider.transaction";
 
-  transactionHistory.unshift(logEntry);
+const logTransaction = async (strapi, transactionData) => {
+  try {
+    const data = {
+      txid: transactionData.txid || 'NO TXID',
+      reference: transactionData.reference || 'NO REFERENCE',
+      invoiceid: transactionData.raw_request.invoiceid || 'NO INVOICE ID',
+      request_type: transactionData.request_type || "unknown",
+      amount: transactionData.amount || "0",
+      currency: transactionData.currency || "EUR",
+      status: transactionData.status || transactionData.raw_response.Status || "unknown",
+      error_code: transactionData.error_code || "NO ERROR CODE",
+      error_message: transactionData.error_message || "NO ERROR MESSAGE",
+      customer_message: transactionData.customer_message || "NO CUSTOMER MESSAGE",
+      body: transactionData ? { ...transactionData, raw_request: sanitizeSensitive(transactionData.raw_request), raw_response: sanitizeSensitive(transactionData.raw_response) } : {},
+      raw_request: sanitizeSensitive(transactionData.raw_request || {}),
+      raw_response: sanitizeSensitive(transactionData.raw_response || {}),
+    };
+
+    const entry = await strapi.db.query(TRANSACTION_UID).create({ data });
+    console.info("Transaction logged to DB:", {
+      id: entry.id,
+      txid: entry.txid,
+      status: entry.status
+    });
 
-  if (transactionHistory.length > 1000) {
-    transactionHistory = transactionHistory.slice(0, 1000);
+    return entry;
+  } catch (error) {
+    console.error("Failed to log transaction:", error);
   }
+};
 
-  await pluginStore.set({
-    key: "transactionHistory",
-    value: transactionHistory
-  });
 
-  console.log(`Transaction logged: ${logEntry}`);
-};
+const hasFilterValue = (v) =>
+  typeof v === "string" && v.trim() !== "" && v.trim().toLowerCase() !== "all";
 
+const buildWhereFromFilters = (filters = {}) => {
+  const conditions = [];
 
-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 (hasFilterValue(filters.search)) {
+    const search = String(filters.search).trim();
+    conditions.push({
+      $or: [
+        { txid: { $containsi: search } },
+        { reference: { $containsi: search } },
+      ],
     });
   }
 
-  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 (hasFilterValue(filters.status)) {
+    conditions.push({ status: { $eqi: String(filters.status).trim() } });
   }
 
-  if (filters.payment_method) {
-    result = result.filter((t) => {
-      const clearingtype = t.raw_request?.clearingtype;
-      const wallettype = t.raw_request?.wallettype;
-
-      switch (filters.payment_method) {
-        case "credit_card":
-          return clearingtype === "cc";
-        case "paypal":
-          return clearingtype === "wlt" && wallettype === "PPE";
-        case "google_pay":
-          return clearingtype === "wlt" && ["GPY", "GOOGLEPAY"].includes(wallettype);
-        case "apple_pay":
-          return clearingtype === "wlt" && ["APL", "APPLEPAY"].includes(wallettype);
-        case "sofort":
-          return clearingtype === "sb";
-        case "sepa":
-          return clearingtype === "elv";
-        default:
-          return true;
-      }
-    });
+  if (hasFilterValue(filters.request_type)) {
+    conditions.push({ request_type: String(filters.request_type).trim() });
   }
 
-  if (filters.date_from) {
+  if (hasFilterValue(filters.date_from)) {
     const dateFrom = new Date(filters.date_from);
     dateFrom.setHours(0, 0, 0, 0);
-    result = result.filter(
-      (t) => new Date(t.timestamp) >= dateFrom
-    );
+    conditions.push({ createdAt: { $gte: dateFrom.toISOString() } });
   }
 
-  if (filters.date_to) {
+  if (hasFilterValue(filters.date_to)) {
     const dateTo = new Date(filters.date_to);
     dateTo.setHours(23, 59, 59, 999);
-    result = result.filter(
-      (t) => new Date(t.timestamp) <= dateTo
-    );
+    conditions.push({ createdAt: { $lte: dateTo.toISOString() } });
   }
 
-  return result;
-};
+  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;
+    }
+  }
 
-const getTransactionHistory = async (strapi, { filters = {}, pagination = {} }) => {
-  const pluginStore = getPluginStore(strapi);
+  if (conditions.length === 0) return undefined;
+  if (conditions.length === 1) return conditions[0];
+  return { $and: conditions };
+};
 
-  let transactions =
-    (await pluginStore.get({ key: "transactionHistory" })) || [];
+const ALLOWED_SORT_FIELDS = [
+  "txid",
+  "reference",
+  "amount",
+  "request_type",
+  "status",
+  "createdAt",
+  "updatedAt",
+];
+
+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 queryOptions = {
+    orderBy: { [sortField]: order },
+    limit: pageSize,
+    offset,
+  };
+  if (where !== undefined) queryOptions.where = where;
 
-  transactions = applyFilters(transactions, filters);
-  const page = Number(pagination.page) || 1;
-  const pageSize = Number(pagination.pageSize) || 10;
+  const [data, total] = await strapi.db
+    .query(TRANSACTION_UID)
+    .findWithCount(queryOptions);
 
-  const total = transactions.length;
   const pageCount = Math.max(1, Math.ceil(total / pageSize));
-
-  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) : [];
+  const validPage = Math.min(page, pageCount);
 
   return {
-    data: paginatedData,
+    data,
     pagination: {
       page: validPage,
       pageSize,