strapi-plugin-payone-provider 1.4.2 → 1.5.2

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

@@ -0,0 +1,79 @@
+/**
+ * Google Pay Constants
+ * Based on Google Pay documentation and Payone requirements
+ * https://developers.google.com/pay/api/web/overview
+ * https://docs.payone.com/display/public/PLATFORM/Google+Pay
+ */
+
+// Google Pay supported card networks
+export const GOOGLE_PAY_SUPPORTED_NETWORKS = [
+  { code: "MASTERCARD", name: "Mastercard" },
+  { code: "VISA", name: "Visa" },
+  { code: "AMEX", name: "American Express" },
+  { code: "DISCOVER", name: "Discover" },
+  { code: "JCB", name: "JCB" }
+];
+
+// Google Pay supported authentication methods
+export const GOOGLE_PAY_AUTH_METHODS = [
+  { code: "PAN_ONLY", name: "PAN Only", description: "Basic card authentication" },
+  { code: "CRYPTOGRAM_3DS", name: "3D Secure", description: "3D Secure authentication" }
+];
+
+// Google Pay supported countries
+export const GOOGLE_PAY_SUPPORTED_COUNTRIES = [
+  { code: "US", name: "United States" },
+  { code: "GB", name: "United Kingdom" },
+  { code: "CA", name: "Canada" },
+  { code: "AU", name: "Australia" },
+  { code: "DE", name: "Germany" },
+  { code: "FR", name: "France" },
+  { code: "IT", name: "Italy" },
+  { code: "ES", name: "Spain" },
+  { code: "NL", name: "Netherlands" },
+  { code: "BE", name: "Belgium" },
+  { code: "CH", name: "Switzerland" },
+  { code: "AT", name: "Austria" },
+  { code: "IE", name: "Ireland" },
+  { code: "SE", name: "Sweden" },
+  { code: "NO", name: "Norway" },
+  { code: "DK", name: "Denmark" },
+  { code: "FI", name: "Finland" },
+  { code: "PL", name: "Poland" },
+  { code: "BR", name: "Brazil" },
+  { code: "MX", name: "Mexico" },
+  { code: "JP", name: "Japan" },
+  { code: "SG", name: "Singapore" },
+  { code: "NZ", name: "New Zealand" },
+  { code: "IN", name: "India" }
+];
+
+// Google Pay supported currencies
+export const GOOGLE_PAY_SUPPORTED_CURRENCIES = [
+  { code: "USD", name: "US Dollar", symbol: "$" },
+  { code: "EUR", name: "Euro", symbol: "€" },
+  { code: "GBP", name: "British Pound", symbol: "£" },
+  { code: "CAD", name: "Canadian Dollar", symbol: "C$" },
+  { code: "AUD", name: "Australian Dollar", symbol: "A$" },
+  { code: "JPY", name: "Japanese Yen", symbol: "¥" },
+  { code: "CHF", name: "Swiss Franc", symbol: "CHF" },
+  { code: "SEK", name: "Swedish Krona", symbol: "kr" },
+  { code: "NOK", name: "Norwegian Krone", symbol: "kr" },
+  { code: "DKK", name: "Danish Krone", symbol: "kr" },
+  { code: "PLN", name: "Polish Zloty", symbol: "zł" },
+  { code: "BRL", name: "Brazilian Real", symbol: "R$" },
+  { code: "MXN", name: "Mexican Peso", symbol: "$" },
+  { code: "SGD", name: "Singapore Dollar", symbol: "S$" },
+  { code: "NZD", name: "New Zealand Dollar", symbol: "NZ$" },
+  { code: "INR", name: "Indian Rupee", symbol: "₹" }
+];
+
+// Default Google Pay configuration
+export const DEFAULT_GOOGLE_PAY_CONFIG = {
+  countryCode: "US",
+  currencyCode: "USD",
+  allowedCardNetworks: ["MASTERCARD", "VISA"],
+  allowedAuthMethods: ["PAN_ONLY", "CRYPTOGRAM_3DS"],
+  merchantName: "Your Store Name"
+};
+

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

@@ -1,27 +1,4 @@
-/**
- * Payment Utils - Universal functions for different payment methods and operations
- * Based on Payone v1 API Documentation
- * 
- * This file contains all necessary parameters and validations for:
- * - Preauthorization
- * - Authorization  
- * - Capture
- * - Refund
- * 
- * Supported Payment Methods:
- * - Credit Card (cc)
- * - PayPal (wlt)
- * - Google Pay (gpp)
- * - Apple Pay (apl)
- * - Sofort Banking (sb)
- * - SEPA Direct Debit (elv)
- */
 
-/**
- * Generate order reference number
- * @param {number} sequence - Sequence number (default: 1000)
- * @returns {string} Generated order reference (format: ORD-XXXXX-XXXX)
- */
 export function generateLagOrderNumber(sequence = 1000) {
   const paddedSequence = sequence.toString().padStart(5, '0');
   const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
@@ -32,12 +9,7 @@ export function generateLagOrderNumber(sequence = 1000) {
   return `ORD-${paddedSequence}-${randomPart}`;
 }
 
-/**
- * Get base parameters for all payment methods
- * Based on Payone v1 API Documentation
- * @param {Object} options - Base options
- * @returns {Object} Base parameters with all required fields
- */
+
 export const getBaseParams = (options = {}) => {
   const {
     amount,
@@ -106,13 +78,7 @@ export const getBaseParams = (options = {}) => {
   };
 };
 
-/**
- * Get payment method specific parameters
- * Based on Payone v1 API Documentation
- * @param {string} paymentMethod - Payment method (cc, wlt, sb, elv)
- * @param {Object} options - Additional options
- * @returns {Object} Payment method specific parameters
- */
+
 export const getPaymentMethodParams = (paymentMethod, options = {}) => {
   const {
     cardType,
@@ -191,12 +157,25 @@ export const getPaymentMethodParams = (paymentMethod, options = {}) => {
       return googlePayParams;
 
     case "apl": // Apple Pay
-      return {
+      const applePayParams = {
         clearingtype: "wlt",
         wallettype: "APL", // Apple Pay
         ...getShippingParams()
       };
 
+      if (options.applePayToken) {
+        const gatewayMerchantId = options.settings?.mid || options.settings?.portalid || '';
+        applePayParams["add_paydata[paymentmethod_token_data]"] = options.applePayToken;
+        applePayParams["add_paydata[paymentmethod]"] = "APL";
+        applePayParams["add_paydata[paymentmethod_type]"] = "APPLEPAY";
+        applePayParams["add_paydata[gatewayid]"] = "payonegmbh";
+        if (gatewayMerchantId) {
+          applePayParams["add_paydata[gateway_merchantid]"] = gatewayMerchantId;
+        }
+      }
+
+      return applePayParams;
+
     case "sb": // Sofort Banking
       return {
         clearingtype: "sb",
@@ -225,13 +204,7 @@ export const getPaymentMethodParams = (paymentMethod, options = {}) => {
   }
 };
 
-/**
- * Get preauthorization parameters for specific payment method
- * Based on Payone v1 API Documentation
- * @param {string} paymentMethod - Payment method
- * @param {Object} options - Options including amount, reference, etc.
- * @returns {Object} Complete preauthorization parameters
- */
+
 export const getPreauthorizationParams = (paymentMethod, options = {}) => {
   const baseParams = getBaseParams(options);
   const methodParams = getPaymentMethodParams(paymentMethod, options);
@@ -251,13 +224,7 @@ export const getPreauthorizationParams = (paymentMethod, options = {}) => {
   return params;
 };
 
-/**
- * Get authorization parameters for specific payment method
- * Based on Payone v1 API Documentation
- * @param {string} paymentMethod - Payment method
- * @param {Object} options - Options including amount, reference, etc.
- * @returns {Object} Complete authorization parameters
- */
+
 export const getAuthorizationParams = (paymentMethod, options = {}) => {
   const baseParams = getBaseParams(options);
   const methodParams = getPaymentMethodParams(paymentMethod, options);
@@ -277,13 +244,7 @@ export const getAuthorizationParams = (paymentMethod, options = {}) => {
   return params;
 };
 
-/**
- * Get capture parameters for specific payment method
- * Based on Payone v1 API Documentation
- * @param {string} paymentMethod - Payment method
- * @param {Object} options - Options including txid, amount, captureMode, etc.
- * @returns {Object} Complete capture parameters
- */
+
 export const getCaptureParams = (paymentMethod, options = {}) => {
   const {
     txid,
@@ -339,13 +300,7 @@ export const getCaptureParams = (paymentMethod, options = {}) => {
   };
 };
 
-/**
- * Get refund parameters for specific payment method
- * Based on Payone v1 API Documentation
- * @param {string} paymentMethod - Payment method
- * @param {Object} options - Options including txid, amount, sequencenumber, etc.
- * @returns {Object} Complete refund parameters
- */
+
 export const getRefundParams = (paymentMethod, options = {}) => {
   const {
     txid,
@@ -398,11 +353,7 @@ export const getRefundParams = (paymentMethod, options = {}) => {
   };
 };
 
-/**
- * Get payment method display name
- * @param {string} paymentMethod - Payment method code
- * @returns {string} Display name
- */
+
 export const getPaymentMethodDisplayName = (paymentMethod) => {
   const displayNames = {
     cc: "Credit Card (Visa, Mastercard)",
@@ -416,10 +367,7 @@ export const getPaymentMethodDisplayName = (paymentMethod) => {
   return displayNames[paymentMethod] || "Unknown Payment Method";
 };
 
-/**
- * Get payment method options for dropdown
- * @returns {Array} Array of payment method options
- */
+
 export const getPaymentMethodOptions = () => {
   return [
     { value: "cc", label: "Credit Card (Visa, Mastercard)" },

package/package.json

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

package/server/bootstrap.js

@@ -19,7 +19,11 @@ module.exports = async ({ strapi }) => {
         mid: "",
         key: "",
         mode: "test",
-        api_version: "3.10"
+        api_version: "3.10",
+        merchantName: "",
+        displayName: "",
+        domainName: "",
+        merchantIdentifier: ""
       }
     });
   }

package/server/config/index.js

@@ -10,7 +10,11 @@ module.exports = {
       mid: "",
       key: "",
       mode: "test",
-      api_version: "3.10"
+      api_version: "3.10",
+      merchantName: "",
+      displayName: "",
+      domainName: "",
+      merchantIdentifier: ""
     }
   },
   validator(config) {

package/server/controllers/payone.js

@@ -176,5 +176,15 @@ module.exports = ({ strapi }) => ({
       strapi.log.error("3DS callback error:", error);
       handleError(ctx, error);
     }
+  },
+
+  async validateApplePayMerchant(ctx) {
+    try {
+      const params = ctx.request.body;
+      const result = await getPayoneService(strapi).validateApplePayMerchant(params);
+      ctx.body = { data: result };
+    } catch (error) {
+      handleError(ctx, error);
+    }
   }
 });

package/server/routes/index.js

@@ -75,6 +75,14 @@ module.exports = {
         config: {
           policies: ["admin::isAuthenticatedAdmin"]
         }
+      },
+      {
+        method: "POST",
+        path: "/validate-apple-pay-merchant",
+        handler: "payone.validateApplePayMerchant",
+        config: {
+          policies: ["admin::isAuthenticatedAdmin"]
+        }
       }
     ]
   },
@@ -144,6 +152,15 @@ module.exports = {
           policies: ["plugin::strapi-plugin-payone-provider.is-auth"],
           auth: false
         }
+      },
+      {
+        method: "POST",
+        path: "/validate-apple-pay-merchant",
+        handler: "payone.validateApplePayMerchant",
+        config: {
+          policies: ["plugin::strapi-plugin-payone-provider.is-auth"],
+          auth: false
+        }
       }
     ]
   }

package/server/services/applePayService.js

@@ -0,0 +1,261 @@
+"use strict";
+
+const axios = require("axios");
+const { buildClientRequestParams, toFormData } = require("../utils/requestBuilder");
+const { getSettings, validateSettings } = require("./settingsService");
+
+const POST_GATEWAY_URL = "https://api.pay1.de/post-gateway/";
+
+/**
+ * Initialize Apple Pay session with Payone
+ * According to Payone documentation:
+ * https://docs.payone.com/payment-methods/apple-pay/apple-pay-without-dev
+ * 
+ * Request: genericpayment
+ * Required parameters:
+ * - request="genericpayment"
+ * - clearingtype="wlt"
+ * - wallettype="APL"
+ * - add_paydata[action]="init_applepay_session"
+ * - add_paydata[display_name]="Store Name"
+ * - add_paydata[domain_name]="yourdomain.com"
+ */
+const initializeApplePaySession = async (strapi, params) => {
+  try {
+    strapi.log.info("[Apple Pay] Initializing Apple Pay session with Payone");
+    strapi.log.info("[Apple Pay] Request params:", JSON.stringify(params, null, 2));
+    
+    const settings = await getSettings(strapi);
+
+    if (!validateSettings(settings)) {
+      strapi.log.error("[Apple Pay] Payone settings not configured");
+      throw new Error("Payone settings not configured");
+    }
+
+    strapi.log.info("[Apple Pay] Settings loaded:", {
+      mode: settings.mode,
+      mid: settings.mid,
+      portalid: settings.portalid,
+      hasKey: !!settings.key
+    });
+
+    const {
+      displayName,
+      domainName,
+      mid,
+      portalid
+    } = params;
+
+    // Get merchant data from settings (test or live mode)
+    const merchantName = displayName || settings.merchantName || settings.displayName || "Test Store";
+    const merchantId = mid || settings.mid || settings.merchantIdentifier;
+    const portalId = portalid || settings.portalid;
+    const accountId = settings.aid;
+    const apiKey = settings.key;
+    const mode = settings.mode || "test"; // test or live
+
+    // Get domain from params or settings or server config
+    const domain = domainName || settings.domainName || 
+                   (strapi.config.get("server.url") ? new URL(strapi.config.get("server.url")).hostname : null) ||
+                   "localhost";
+
+    // Build request parameters for Apple Pay session initialization
+    // According to Payone documentation: request="genericpayment"
+    const requestParams = {
+      request: "genericpayment",
+      mid: merchantId,
+      aid: accountId,
+      portalid: portalId,
+      key: apiKey,
+      mode: mode, // Use test or live mode from settings
+      clearingtype: "wlt",
+      wallettype: "APL",
+      currency: "EUR", // Default, can be overridden
+      "add_paydata[action]": "init_applepay_session",
+      "add_paydata[display_name]": merchantName,
+      "add_paydata[domain_name]": domain
+    };
+
+    strapi.log.info("[Apple Pay] Sending request to Payone:", {
+      url: POST_GATEWAY_URL,
+      mode: mode,
+      merchantName: merchantName,
+      domain: domain,
+      merchantId: merchantId,
+      portalId: portalId
+    });
+
+    const formData = toFormData(requestParams);
+
+    const response = await axios.post(POST_GATEWAY_URL, formData, {
+      headers: { "Content-Type": "application/x-www-form-urlencoded" },
+      timeout: 30000
+    });
+
+    strapi.log.info("[Apple Pay] Payone response received:", {
+      status: response.status,
+      statusText: response.statusText
+    });
+
+    // Parse response
+    const responseData = parseResponse(response.data, strapi.log);
+
+    strapi.log.info("[Apple Pay] Session initialization response:", JSON.stringify(responseData, null, 2));
+    strapi.log.info("[Apple Pay] Response status:", responseData.status || responseData.Status);
+    
+    if (responseData.errorcode || responseData.ErrorCode) {
+      strapi.log.warn("[Apple Pay] Response contains error:", {
+        errorcode: responseData.errorcode || responseData.ErrorCode,
+        errormessage: responseData.errormessage || responseData.ErrorMessage
+      });
+    }
+
+    return responseData;
+  } catch (error) {
+    strapi.log.error("[Apple Pay] Session initialization error:", {
+      message: error.message,
+      stack: error.stack,
+      response: error.response?.data
+    });
+    throw error;
+  }
+};
+
+/**
+ * Validate Apple Pay merchant with Payone
+ * This is called when Apple Pay requests merchant validation
+ */
+const validateApplePayMerchant = async (strapi, params) => {
+  try {
+    strapi.log.info("[Apple Pay] Validating merchant with Payone");
+    strapi.log.info("[Apple Pay] Validation params:", JSON.stringify({
+      validationURL: params.validationURL,
+      domain: params.domain,
+      displayName: params.displayName,
+      mid: params.mid,
+      portalid: params.portalid
+    }, null, 2));
+    
+    const settings = await getSettings(strapi);
+
+    if (!validateSettings(settings)) {
+      strapi.log.error("[Apple Pay] Payone settings not configured for merchant validation");
+      throw new Error("Payone settings not configured");
+    }
+
+    const {
+      validationURL,
+      mid,
+      portalid,
+      domain,
+      displayName
+    } = params;
+
+    // Get merchant data from settings (test or live mode)
+    const merchantName = displayName || settings.merchantName || settings.displayName || "Test Store";
+    const merchantId = mid || settings.mid || settings.merchantIdentifier;
+    const portalId = portalid || settings.portalid;
+    
+    // Get domain from params or settings or server config
+    const domainName = domain || settings.domainName || 
+                       (strapi.config.get("server.url") ? new URL(strapi.config.get("server.url")).hostname : null) ||
+                       "localhost";
+
+    // For Payone integration without developer account,
+    // Payone handles merchant validation
+    // We need to initialize the session first
+    const sessionParams = {
+      displayName: merchantName,
+      domainName: domainName,
+      mid: merchantId,
+      portalid: portalId
+    };
+
+    strapi.log.info("[Apple Pay] Initializing session with params:", JSON.stringify(sessionParams, null, 2));
+
+    // Initialize Apple Pay session with Payone
+    const sessionResponse = await initializeApplePaySession(strapi, sessionParams);
+
+    strapi.log.info("[Apple Pay] Session initialization result:", {
+      status: sessionResponse.status || sessionResponse.Status,
+      hasMerchantIdentifier: !!(sessionResponse.merchantIdentifier || sessionResponse.merchantSessionIdentifier)
+    });
+
+    // If session initialization is successful, return merchant session
+    // Payone will provide the merchant identifier and validation data
+    if (sessionResponse.status === "APPROVED" || sessionResponse.status === "REDIRECT") {
+      strapi.log.info("[Apple Pay] Session approved, creating merchant session object");
+      // Get merchant identifier from Payone response or settings
+      const merchantIdentifier = sessionResponse.merchantIdentifier || 
+                                  sessionResponse.merchantSessionIdentifier ||
+                                  settings.merchantIdentifier ||
+                                  settings.mid || 
+                                  settings.portalid ||
+                                  `merchant.${domainName}`;
+
+      // Return merchant session object
+      // In a real implementation, you would get this from Payone's response
+      const merchantSession = {
+        epochTimestamp: Date.now(),
+        expiresAt: Date.now() + (5 * 60 * 1000), // 5 minutes
+        merchantSessionIdentifier: sessionResponse.merchantSessionIdentifier || `merchant.${domainName}`,
+        nonce: sessionResponse.nonce || generateNonce(),
+        merchantIdentifier: merchantIdentifier,
+        domainName: domainName,
+        displayName: merchantName
+      };
+
+      strapi.log.info("[Apple Pay] Merchant session created:", {
+        merchantIdentifier: merchantSession.merchantIdentifier,
+        domainName: merchantSession.domainName,
+        expiresAt: new Date(merchantSession.expiresAt).toISOString()
+      });
+
+      return merchantSession;
+    }
+
+    // If initialization failed, return empty object
+    // Payment Request API will handle it
+    strapi.log.warn("[Apple Pay] Session initialization failed, returning empty object");
+    return {};
+  } catch (error) {
+    strapi.log.error("[Apple Pay] Merchant validation error:", {
+      message: error.message,
+      stack: error.stack,
+      response: error.response?.data
+    });
+    // Return empty object on error - Payone will handle validation
+    return {};
+  }
+};
+
+/**
+ * Parse Payone response
+ */
+const parseResponse = (responseData, logger) => {
+  if (typeof responseData === 'string') {
+    // Parse form-encoded response
+    const params = new URLSearchParams(responseData);
+    const parsed = {};
+    for (const [key, value] of params.entries()) {
+      parsed[key] = value;
+    }
+    return parsed;
+  }
+  return responseData;
+};
+
+/**
+ * Generate nonce for merchant session
+ */
+const generateNonce = () => {
+  return Math.random().toString(36).substring(2, 15) + 
+         Math.random().toString(36).substring(2, 15);
+};
+
+module.exports = {
+  initializeApplePaySession,
+  validateApplePayMerchant
+};
+
+

package/server/services/payone.js

@@ -4,6 +4,7 @@ const settingsService = require("./settingsService");
 const transactionService = require("./transactionService");
 const paymentService = require("./paymentService");
 const testConnectionService = require("./testConnectionService");
+const applePayService = require("./applePayService");
 
 /**
  * Main Payone service - aggregates all sub-services
@@ -52,5 +53,14 @@ module.exports = ({ strapi }) => ({
   // 3D Secure callback handler
   async handle3DSCallback(callbackData, resultType) {
     return await paymentService.handle3DSCallback(strapi, callbackData, resultType);
+  },
+
+  // Apple Pay
+  async validateApplePayMerchant(params) {
+    return await applePayService.validateApplePayMerchant(strapi, params);
+  },
+
+  async initializeApplePaySession(params) {
+    return await applePayService.initializeApplePaySession(strapi, params);
   }
 });

package/server/utils/paymentMethodParams.js

@@ -84,11 +84,28 @@ const addPaymentMethodParams = (params, logger) => {
     }
   });
   
+  // Handle Apple Pay token if present
+  if (updated.applePayToken || updated["add_paydata[paymentmethod_token_data]"]) {
+    const token = updated.applePayToken || updated["add_paydata[paymentmethod_token_data]"];
+    const gatewayMerchantId = updated.mid || updated.portalid || '';
+    
+    updated["add_paydata[paymentmethod_token_data]"] = token;
+    updated["add_paydata[paymentmethod]"] = "APL";
+    updated["add_paydata[paymentmethod_type]"] = "APPLEPAY";
+    updated["add_paydata[gatewayid]"] = "payonegmbh";
+    if (gatewayMerchantId) {
+      updated["add_paydata[gateway_merchantid]"] = gatewayMerchantId;
+    }
+    
+    // Remove applePayToken from params as it's now in add_paydata
+    delete updated.applePayToken;
+  }
+
   // Ensure wallettype is set for wallet payments
   if (updated.clearingtype === "wlt" && !updated.wallettype) {
-    if (clearingtype === "gpp" || updated.paymentMethod === "gpp" || updated["add_paydata[paymentmethod_token_data]"]) {
+    if (clearingtype === "gpp" || updated.paymentMethod === "gpp" || (updated["add_paydata[paymentmethod]"] === "GGP")) {
       updated.wallettype = "GGP";
-    } else if (clearingtype === "apl" || updated.paymentMethod === "apl") {
+    } else if (clearingtype === "apl" || updated.paymentMethod === "apl" || (updated["add_paydata[paymentmethod]"] === "APL")) {
       updated.wallettype = "APL";
     } else {
       updated.wallettype = "PPE";