strapi-plugin-payone-provider 1.1.3 → 1.3.0

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)
@@ -88,21 +100,49 @@ export const getBaseParams = (options = {}) => {
  */
 export const getPaymentMethodParams = (paymentMethod, options = {}) => {
   const {
-    cardType = "V",
+    cardType,
+    cardtype,
     captureMode = "full",
     cardpan,
     cardexpiredate,
     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;
 
+  // Use cardtype if provided, otherwise fall back to cardType, otherwise default to "V"
+  const finalCardType = cardtype || cardType || "V";
+
+  // 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 {
         clearingtype: "cc",
-        cardtype: cardType, // V = Visa, M = Mastercard, A = Amex
+        cardtype: finalCardType, // V = Visa, M = Mastercard, A = Amex
         cardpan: cardpan || "4111111111111111", // Test Visa card
         cardexpiredate: cardexpiredate || "2512", // MMYY format
         cardcvc2: cardcvc2 || "123" // 3-digit security code
@@ -112,12 +152,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 +221,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 +247,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 +298,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 +359,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 +392,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 +409,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 +422,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 +573,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.3",
+  "version": "1.3.0",
   "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
+        }
       }
     ]
   }