strapi-plugin-payone-provider 1.1.2 → 1.2.4

package/admin/src/pages/hooks/useTransactionHistory.js

@@ -0,0 +1,87 @@
+import { useState, useEffect } from "react";
+import { useNotification } from "@strapi/helper-plugin";
+import payoneRequests from "../utils/api";
+
+const PAGE_SIZE = 10;
+
+const useTransactionHistory = () => {
+  const toggleNotification = useNotification();
+  const [transactionHistory, setTransactionHistory] = useState([]);
+  const [isLoadingHistory, setIsLoadingHistory] = useState(false);
+  const [selectedTransaction, setSelectedTransaction] = useState(null);
+  const [currentPage, setCurrentPage] = useState(1);
+  const [filters, setFilters] = useState({
+    status: "",
+    request_type: "",
+    txid: "",
+    reference: "",
+    date_from: "",
+    date_to: ""
+  });
+
+  useEffect(() => {
+    loadTransactionHistory();
+  }, []);
+
+  const loadTransactionHistory = async () => {
+    setIsLoadingHistory(true);
+    try {
+      const result = await payoneRequests.getTransactionHistory(filters);
+      setTransactionHistory(result.data || []);
+      setCurrentPage(1);
+    } catch (error) {
+      toggleNotification({
+        type: "warning",
+        message: "Failed to load transaction history"
+      });
+    } finally {
+      setIsLoadingHistory(false);
+    }
+  };
+
+  const handleFilterChange = (field, value) => {
+    setFilters((prev) => ({ ...prev, [field]: value }));
+  };
+
+  const handleFilterApply = () => {
+    loadTransactionHistory();
+  };
+
+  const handleTransactionSelect = (transaction) => {
+    if (selectedTransaction?.id === transaction?.id) {
+      setSelectedTransaction(null);
+    } else {
+      setSelectedTransaction(transaction);
+    }
+  };
+
+  const handlePageChange = (page) => {
+    setCurrentPage(page);
+    setSelectedTransaction(null);
+  };
+
+  // Pagination calculations
+  const totalPages = Math.ceil(transactionHistory.length / PAGE_SIZE);
+  const startIndex = (currentPage - 1) * PAGE_SIZE;
+  const endIndex = startIndex + PAGE_SIZE;
+  const paginatedTransactions = transactionHistory.slice(startIndex, endIndex);
+
+  return {
+    transactionHistory,
+    paginatedTransactions,
+    isLoadingHistory,
+    selectedTransaction,
+    filters,
+    currentPage,
+    totalPages,
+    pageSize: PAGE_SIZE,
+    handleFilterChange,
+    handleFilterApply,
+    handleTransactionSelect,
+    handlePageChange,
+    loadTransactionHistory
+  };
+};
+
+export default useTransactionHistory;
+

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

@@ -69,6 +69,16 @@ const payoneRequests = {
         "Content-Type": "application/json"
       }
     });
+  },
+
+  handle3DSCallback: (data) => {
+    return request(`/${pluginId}/3ds-callback`, {
+      method: "POST",
+      body: data,
+      headers: {
+        "Content-Type": "application/json"
+      }
+    });
   }
 };
 

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

@@ -0,0 +1,31 @@
+export const injectGooglePayScript = () => {
+  const scriptUrl = "https://pay.google.com/gp/p/js/pay.js";
+
+  if (document.querySelector(`script[src="${scriptUrl}"]`)) {
+    if (typeof window !== 'undefined' && typeof window.google !== 'undefined' && window.google.payments?.api?.PaymentsClient) {
+      window.dispatchEvent(new CustomEvent("googlePayScriptLoaded"));
+    }
+    return;
+  }
+
+  const script = document.createElement("script");
+  script.src = scriptUrl;
+  script.async = true;
+  
+  script.onload = () => {
+    setTimeout(() => {
+      if (typeof window !== 'undefined' && typeof window.google !== 'undefined' && window.google.payments?.api?.PaymentsClient) {
+        window.dispatchEvent(new CustomEvent("googlePayScriptLoaded"));
+      } else {
+        window.dispatchEvent(new CustomEvent("googlePayScriptLoaded"));
+      }
+    }, 500);
+  };
+
+  script.onerror = () => {
+    window.dispatchEvent(new CustomEvent("googlePayScriptError"));
+  };
+
+  document.head.appendChild(script);
+};
+

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

@@ -11,6 +11,8 @@
  * Supported Payment Methods:
  * - Credit Card (cc)
  * - PayPal (wlt)
+ * - Google Pay (gpp)
+ * - Apple Pay (apl)
  * - Sofort Banking (sb)
  * - SEPA Direct Debit (elv)
  */
@@ -45,8 +47,18 @@ export const getBaseParams = (options = {}) => {
     backurl = "https://www.example.com/back"
   } = options;
 
-  // Generate unique customer ID if not provided
-  const finalCustomerId = customerid || `CUST-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+  const generateCustomerId = () => {
+    const timestamp = Date.now().toString().slice(-10);
+    const random = Math.random().toString(36).substring(2, 6).toUpperCase();
+    const id = `${timestamp}${random}`.slice(0, 17);
+    return id;
+  };
+
+  let finalCustomerId = customerid || generateCustomerId();
+
+  if (finalCustomerId && finalCustomerId.length > 17) {
+    finalCustomerId = finalCustomerId.slice(0, 17);
+  }
 
   return {
     // Required core parameters (Payone v1)
@@ -95,9 +107,33 @@ export const getPaymentMethodParams = (paymentMethod, options = {}) => {
     cardcvc2,
     iban,
     bic,
-    bankaccountholder
+    bankaccountholder,
+    // Shipping address for wallet payments (Google Pay, Apple Pay, PayPal)
+    shipping_firstname,
+    shipping_lastname,
+    shipping_street,
+    shipping_zip,
+    shipping_city,
+    shipping_country,
+    // Billing address (used as fallback for shipping)
+    firstname,
+    lastname,
+    street,
+    zip,
+    city,
+    country
   } = options;
 
+  // Helper to get shipping params for wallet payments
+  const getShippingParams = () => ({
+    shipping_firstname: shipping_firstname || firstname || "John",
+    shipping_lastname: shipping_lastname || lastname || "Doe",
+    shipping_street: shipping_street || street || "Test Street 123",
+    shipping_zip: shipping_zip || zip || "12345",
+    shipping_city: shipping_city || city || "Test City",
+    shipping_country: (shipping_country || country || "DE").toUpperCase()
+  });
+
   switch (paymentMethod) {
     case "cc": // Credit Card (Visa, Mastercard, Amex)
       return {
@@ -112,12 +148,34 @@ export const getPaymentMethodParams = (paymentMethod, options = {}) => {
       return {
         clearingtype: "wlt",
         wallettype: "PPE", // PayPal Express
-        shipping_firstname: "John",
-        shipping_lastname: "Doe",
-        shipping_street: "Test Street 123",
-        shipping_zip: "12345",
-        shipping_city: "Test City",
-        shipping_country: "DE"
+        ...getShippingParams()
+      };
+
+    case "gpp":
+      const googlePayParams = {
+        clearingtype: "wlt",
+        wallettype: "GGP",
+        ...getShippingParams()
+      };
+
+      if (options.googlePayToken) {
+        const gatewayMerchantId = options.settings?.mid || options.settings?.portalid || '';
+        googlePayParams["add_paydata[paymentmethod_token_data]"] = options.googlePayToken;
+        googlePayParams["add_paydata[paymentmethod]"] = "GGP";
+        googlePayParams["add_paydata[paymentmethod_type]"] = "GOOGLEPAY";
+        googlePayParams["add_paydata[gatewayid]"] = "payonegmbh";
+        if (gatewayMerchantId) {
+          googlePayParams["add_paydata[gateway_merchantid]"] = gatewayMerchantId;
+        }
+      }
+
+      return googlePayParams;
+
+    case "apl": // Apple Pay
+      return {
+        clearingtype: "wlt",
+        wallettype: "APL", // Apple Pay
+        ...getShippingParams()
       };
 
     case "sb": // Sofort Banking
@@ -159,11 +217,19 @@ export const getPreauthorizationParams = (paymentMethod, options = {}) => {
   const baseParams = getBaseParams(options);
   const methodParams = getPaymentMethodParams(paymentMethod, options);
 
-  return {
+  const params = {
     ...baseParams,
     ...methodParams,
     request: "preauthorization" // Required for Payone API
   };
+
+  // Add 3D Secure parameters for credit card payments if enabled
+  if (paymentMethod === "cc" && options.enable3DSecure !== false) {
+    params["3dsecure"] = "yes";
+    params.ecommercemode = options.ecommercemode || "internet";
+  }
+
+  return params;
 };
 
 /**
@@ -177,11 +243,19 @@ export const getAuthorizationParams = (paymentMethod, options = {}) => {
   const baseParams = getBaseParams(options);
   const methodParams = getPaymentMethodParams(paymentMethod, options);
 
-  return {
+  const params = {
     ...baseParams,
     ...methodParams,
     request: "authorization" // Required for Payone API
   };
+
+  // Add 3D Secure parameters for credit card payments if enabled
+  if (paymentMethod === "cc" && options.enable3DSecure !== false) {
+    params["3dsecure"] = "yes";
+    params.ecommercemode = options.ecommercemode || "internet";
+  }
+
+  return params;
 };
 
 /**
@@ -220,6 +294,8 @@ export const getCaptureParams = (paymentMethod, options = {}) => {
       break;
 
     case "wlt": // PayPal
+    case "gpp": // Google Pay
+    case "apl": // Apple Pay
       methodParams = {
         capturemode: captureMode // full or partial
       };
@@ -279,7 +355,9 @@ export const getRefundParams = (paymentMethod, options = {}) => {
       break;
 
     case "wlt": // PayPal
-      // PayPal specific refund parameters (if needed)
+    case "gpp": // Google Pay
+    case "apl": // Apple Pay
+      // Wallet payment specific refund parameters (if needed)
       break;
 
     case "sb": // Sofort Banking
@@ -310,6 +388,8 @@ export const getPaymentMethodDisplayName = (paymentMethod) => {
   const displayNames = {
     cc: "Credit Card (Visa, Mastercard)",
     wlt: "PayPal",
+    gpp: "Google Pay",
+    apl: "Apple Pay",
     sb: "Sofort Banking",
     elv: "SEPA Direct Debit"
   };
@@ -325,6 +405,8 @@ export const getPaymentMethodOptions = () => {
   return [
     { value: "cc", label: "Credit Card (Visa, Mastercard)" },
     { value: "wlt", label: "PayPal" },
+    { value: "gpp", label: "Google Pay" },
+    { value: "apl", label: "Apple Pay" },
     { value: "sb", label: "Sofort Banking" },
     { value: "elv", label: "SEPA Direct Debit" }
   ];
@@ -336,7 +418,7 @@ export const getPaymentMethodOptions = () => {
  * @returns {boolean} True if supports capture mode
  */
 export const supportsCaptureMode = (paymentMethod) => {
-  return paymentMethod === "wlt"; // Only PayPal supports capture mode
+  return paymentMethod === "wlt" || paymentMethod === "gpp" || paymentMethod === "apl"; // PayPal, Google Pay, and Apple Pay support capture mode
 };
 
 /**
@@ -487,6 +569,24 @@ export const validatePaymentParams = (operation, paymentMethod, params) => {
       }
       break;
 
+    case "gpp":
+      if (!params.wallettype) {
+        errors.push("Wallet type is required for Google Pay payments");
+      }
+      if (params.wallettype && params.wallettype !== "GGP") {
+        errors.push("Wallet type must be GGP for Google Pay payments");
+      }
+      break;
+
+    case "apl":
+      if (!params.wallettype) {
+        errors.push("Wallet type is required for Apple Pay payments");
+      }
+      if (params.wallettype && params.wallettype !== "APL") {
+        errors.push("Wallet type must be APL for Apple Pay payments");
+      }
+      break;
+
     case "sb":
       if (!params.bankcountry) {
         errors.push("Bank country is required for Sofort payments");

package/package.json

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

package/server/controllers/payone.js

@@ -1,62 +1,72 @@
 "use strict";
 
+const PLUGIN_NAME = "strapi-plugin-payone-provider";
+
+/**
+ * Get Payone service
+ * @param {Object} strapi - Strapi instance
+ * @returns {Object} Payone service
+ */
+const getPayoneService = (strapi) => {
+  return strapi.plugin(PLUGIN_NAME).service("payone");
+};
+
+/**
+ * Handle error response
+ * @param {Object} ctx - Koa context
+ * @param {Error} error - Error object
+ */
+const handleError = (ctx, error) => {
+  strapi.log.error("Payone controller error:", error);
+  ctx.throw(500, error);
+};
+
+/**
+ * Hide sensitive key in settings
+ * @param {Object} settings - Settings object
+ * @returns {Object} Settings with hidden key
+ */
+const hideKey = (settings) => {
+  if (settings && settings.key) {
+    settings.key = "***HIDDEN***";
+  }
+  return settings;
+};
+
 module.exports = ({ strapi }) => ({
   async getSettings(ctx) {
     try {
-      const settings = await strapi
-        .plugin("strapi-plugin-payone-provider")
-        .service("payone")
-        .getSettings();
-
-      if (settings && settings.key) {
-        settings.key = "***HIDDEN***";
-      }
-
-      ctx.body = { data: settings };
+      const settings = await getPayoneService(strapi).getSettings();
+      ctx.body = { data: hideKey(settings) };
     } catch (error) {
-      ctx.throw(500, error);
+      handleError(ctx, error);
     }
   },
 
   async updateSettings(ctx) {
     try {
       const { body } = ctx.request;
+      const currentSettings = await getPayoneService(strapi).getSettings();
 
-      const currentSettings = await strapi
-        .plugin("strapi-plugin-payone-provider")
-        .service("payone")
-        .getSettings();
-
+      // Preserve existing key if hidden or not provided
       if (body.key === "***HIDDEN***" || !body.key) {
-        body.key = currentSettings.key;
+        body.key = currentSettings?.key;
       }
 
-      const settings = await strapi
-        .plugin("strapi-plugin-payone-provider")
-        .service("payone")
-        .updateSettings(body);
-
-      if (settings && settings.key) {
-        settings.key = "***HIDDEN***";
-      }
-
-      ctx.body = { data: settings };
+      const settings = await getPayoneService(strapi).updateSettings(body);
+      ctx.body = { data: hideKey(settings) };
     } catch (error) {
-      ctx.throw(500, error);
+      handleError(ctx, error);
     }
   },
 
   async preauthorization(ctx) {
     try {
       const params = ctx.request.body;
-      const result = await strapi
-        .plugin("strapi-plugin-payone-provider")
-        .service("payone")
-        .preauthorization(params);
-
+      const result = await getPayoneService(strapi).preauthorization(params);
       ctx.body = { data: result };
     } catch (error) {
-      ctx.throw(500, error);
+      handleError(ctx, error);
     }
   },
 
@@ -64,71 +74,68 @@ module.exports = ({ strapi }) => ({
     try {
       const params = ctx.request.body;
       strapi.log.info("Payone authorization controller called with:", params);
-
-      const result = await strapi
-        .plugin("strapi-plugin-payone-provider")
-        .service("payone")
-        .authorization(params);
-
+      const result = await getPayoneService(strapi).authorization(params);
       ctx.body = { data: result };
     } catch (error) {
       strapi.log.error("Payone authorization error:", error);
-      ctx.throw(500, error);
+      handleError(ctx, error);
     }
   },
 
   async capture(ctx) {
     try {
       const params = ctx.request.body;
-      const result = await strapi
-        .plugin("strapi-plugin-payone-provider")
-        .service("payone")
-        .capture(params);
-
+      const result = await getPayoneService(strapi).capture(params);
       ctx.body = { data: result };
     } catch (error) {
-      ctx.throw(500, error);
+      handleError(ctx, error);
     }
   },
 
   async refund(ctx) {
     try {
       const params = ctx.request.body;
-      const result = await strapi
-        .plugin("strapi-plugin-payone-provider")
-        .service("payone")
-        .refund(params);
-
+      const result = await getPayoneService(strapi).refund(params);
       ctx.body = { data: result };
     } catch (error) {
-      ctx.throw(500, error);
+      handleError(ctx, error);
     }
   },
 
   async getTransactionHistory(ctx) {
     try {
       const filters = ctx.query || {};
-      const history = await strapi
-        .plugin("strapi-plugin-payone-provider")
-        .service("payone")
-        .getTransactionHistory(filters);
-
+      const history = await getPayoneService(strapi).getTransactionHistory(filters);
       ctx.body = { data: history };
     } catch (error) {
-      ctx.throw(500, error);
+      handleError(ctx, error);
     }
   },
 
   async testConnection(ctx) {
     try {
-      const result = await strapi
-        .plugin("strapi-plugin-payone-provider")
-        .service("payone")
-        .testConnection();
+      const result = await getPayoneService(strapi).testConnection();
+      ctx.body = { data: result };
+    } catch (error) {
+      handleError(ctx, error);
+    }
+  },
+
+  /**
+   * Handle 3D Secure callback from Payone
+   * This endpoint receives the callback after customer completes 3DS authentication
+   */
+  async handle3DSCallback(ctx) {
+    try {
+      strapi.log.info("3DS callback received:", ctx.request.body);
+
+      const callbackData = ctx.request.body;
+      const result = await getPayoneService(strapi).handle3DSCallback(callbackData);
 
       ctx.body = { data: result };
     } catch (error) {
-      ctx.throw(500, error);
+      strapi.log.error("3DS callback error:", error);
+      handleError(ctx, error);
     }
   }
 });

package/server/routes/index.js

@@ -67,6 +67,14 @@ module.exports = {
         config: {
           policies: ["admin::isAuthenticatedAdmin"]
         }
+      },
+      {
+        method: "POST",
+        path: "/3ds-callback",
+        handler: "payone.handle3DSCallback",
+        config: {
+          policies: ["admin::isAuthenticatedAdmin"]
+        }
       }
     ]
   },
@@ -118,6 +126,15 @@ module.exports = {
           policies: ["plugin::strapi-plugin-payone-provider.is-auth"],
           auth: false
         }
+      },
+      {
+        method: "POST",
+        path: "/3ds-callback",
+        handler: "payone.handle3DSCallback",
+        config: {
+          policies: ["plugin::strapi-plugin-payone-provider.is-auth"],
+          auth: false
+        }
       }
     ]
   }