strapi-plugin-payone-provider 1.6.6 → 4.6.9

package/server/bootstrap.js

@@ -21,7 +21,13 @@ module.exports = async ({ strapi }) => {
         merchantName: "",
         displayName: "",
         domainName: "",
-        merchantIdentifier: ""
+        merchantIdentifier: "",
+        enableCreditCard: true,
+        enablePayPal: true,
+        enableGooglePay: true,
+        enableApplePay: true,
+        enableSofort: true,
+        enableSepaDirectDebit: true
       }
     });
   }
@@ -56,8 +62,8 @@ module.exports = async ({ strapi }) => {
 
     router.get('/.well-known/apple-developer-merchantid-domain-association', async (ctx) => {
       try {
-        const publicPath = path.join(process.cwd(), 'public');
-        const wellKnownPath = path.join(publicPath, '.well-known');
+        const pluginRoot = path.resolve(__dirname, '..');
+        const wellKnownPath = path.join(pluginRoot, '.well-known');
         const possiblePaths = [
           path.join(wellKnownPath, 'apple-developer-merchantid-domain-association'),
           path.join(wellKnownPath, 'apple-developer-merchantid-domain-association.txt'),

package/server/controllers/payone.js

@@ -45,6 +45,14 @@ module.exports = ({ strapi }) => ({
           portalid: settings?.portalid || null,
           accountId: settings?.aid || null,
           portalKey: settings?.key || null,
+          paymentMethods: {
+            creditCard: settings?.enableCreditCard,
+            paypal: settings?.enablePayPal,
+            googlePay: settings?.enableGooglePay,
+            applePay: settings?.enableApplePay,
+            sofort: settings?.enableSofort,
+            sepa: settings?.enableSepaDirectDebit,
+          },
         }
       };
     } catch (error) {

package/server/services/applePayService.js

@@ -8,13 +8,35 @@ const POST_GATEWAY_URL = "https://api.pay1.de/post-gateway/";
 
 const parseResponse = (responseData) => {
   if (typeof responseData === 'string') {
+    if (responseData.trim().startsWith('{')) {
+      try {
+        return JSON.parse(responseData);
+      } catch (e) {
+        // Fall through to URL-encoded parsing
+      }
+    }
+
     const params = new URLSearchParams(responseData);
     const parsed = {};
     for (const [key, value] of params.entries()) {
       parsed[key] = value;
+      const normalizedKey = key.toLowerCase().replace(/\[/g, '_').replace(/\]/g, '');
+      if (normalizedKey !== key.toLowerCase()) {
+        parsed[normalizedKey] = value;
+      }
     }
     return parsed;
   }
+
+  if (typeof responseData === 'object' && responseData !== null) {
+    const result = { ...responseData };
+    if (result['add_paydata[applepay_payment_session]']) {
+      result.add_paydata = result.add_paydata || {};
+      result.add_paydata.applepay_payment_session = result['add_paydata[applepay_payment_session]'];
+    }
+    return result;
+  }
+
   return responseData;
 };
 
@@ -45,8 +67,6 @@ const initializeApplePaySession = async (strapi, params) => {
 
     const applePayConfig = settings?.applePayConfig || {};
     const currency = params.currency || applePayConfig.currencyCode || "EUR";
-    const countryCode = params.countryCode || applePayConfig.countryCode || "DE";
-
     const merchantName = params.displayName || settings?.merchantName || "Store";
     const domain = params.domain || params.domainName || "localhost";
 
@@ -63,18 +83,14 @@ const initializeApplePaySession = async (strapi, params) => {
     const requestParams = buildClientRequestParams(settings, baseParams, strapi.log);
     const formData = toFormData(requestParams);
 
-    let response;
-    try {
-      response = await axios.post(`${POST_GATEWAY_URL}Genericpayment`, formData, {
-        headers: { "Content-Type": "application/x-www-form-urlencoded" },
-        timeout: 30000,
-        validateStatus: function (status) {
-          return status >= 200 && status < 600;
-        }
-      });
-    } catch (axiosError) {
-      throw axiosError;
-    }
+    const response = await axios.post(`${POST_GATEWAY_URL}Genericpayment`, formData, {
+      headers: { "Content-Type": "application/x-www-form-urlencoded" },
+      timeout: 30000,
+      validateStatus: function (status) {
+        return status >= 200 && status < 600;
+      }
+    });
+
 
     if (response.status === 403) {
       const responseData = parseResponse(response.data);
@@ -88,12 +104,7 @@ const initializeApplePaySession = async (strapi, params) => {
 
       const detailedError = new Error("403 Forbidden: Authentication failed with Payone API. " +
         (errorCode ? `Error Code: ${errorCode}. ` : "") +
-        (errorMessage ? `Error: ${errorMessage}. ` : "") +
-        "Please check: 1) Your Payone credentials (aid, portalid, mid, key) in plugin settings, " +
-        "2) Mode is set to 'live' (Apple Pay only works in live mode), " +
-        "3) Your domain is registered with Payone Merchant Services, " +
-        "4) Merchant ID (mid) matches your merchantIdentifier in PMI, " +
-        "5) Apple Pay is enabled for your portal in PMI.");
+        (errorMessage ? `Error: ${errorMessage}. ` : ""));
       Object.assign(detailedError, { status: 403, response: response });
       throw detailedError;
     }
@@ -138,71 +149,7 @@ const initializeApplePaySession = async (strapi, params) => {
 
     return responseData;
   } catch (error) {
-    const errorStatus = error.response?.status || error.status;
-    const errorResponseData = error.response?.data;
-
-    // Provide more specific error messages
-    if (errorStatus === 403 || error.message?.includes('403')) {
-      let responseData = {};
-      let errorCode = null;
-      let errorMessage = null;
-
-      if (errorResponseData) {
-        try {
-          responseData = parseResponse(errorResponseData);
-          errorCode = responseData.errorcode || responseData.ErrorCode;
-          errorMessage = responseData.errormessage || responseData.ErrorMessage || responseData.customermessage || responseData.CustomerMessage;
-        } catch (parseErr) {
-          if (typeof errorResponseData === 'string') {
-            errorMessage = errorResponseData;
-          }
-        }
-      }
-
-      if (errorCode || errorMessage) {
-        strapi.log.error("[Apple Pay] 403 Forbidden from Payone:", {
-          errorcode: errorCode,
-          errormessage: errorMessage
-        });
-      }
-
-      let detailedMessage = "403 Forbidden: Authentication failed with Payone API. ";
-
-      if (errorCode) {
-        detailedMessage += `Error Code: ${errorCode}. `;
-      }
-
-      if (errorMessage) {
-        detailedMessage += `Error: ${errorMessage}. `;
-      }
-
-      detailedMessage += "Please check:\n" +
-        "1. Your Payone credentials (aid, portalid, mid, key) in plugin settings\n" +
-        "2. Mode is set to 'live' (Apple Pay only works in live mode according to Payone docs)\n" +
-        "3. Your domain is registered with Payone Merchant Services\n" +
-        "4. Merchant ID (mid) matches your merchantIdentifier in PMI\n" +
-        "5. Apple Pay is enabled for your portal in PMI (CONFIGURATION → PAYMENT PORTALS → [Your Portal] → Payment type configuration tab)";
-
-      throw new Error(detailedMessage);
-    } else if (errorStatus === 401 || error.message?.includes('401')) {
-      if (errorResponseData) {
-        const responseData = parseResponse(errorResponseData);
-        strapi.log.error("[Apple Pay] 401 Unauthorized from Payone:", {
-          errorcode: responseData.errorcode || responseData.ErrorCode,
-          errormessage: responseData.errormessage || responseData.ErrorMessage
-        });
-      }
-      throw new Error("401 Unauthorized: Invalid credentials. Please verify your Payone key in plugin settings.");
-    } else if (errorStatus && errorStatus >= 500) {
-      const responseData = errorResponseData ? parseResponse(errorResponseData) : {};
-      strapi.log.error("[Apple Pay] Payone server error:", {
-        status: error.response?.status,
-        errorcode: responseData.errorcode || responseData.ErrorCode,
-        errormessage: responseData.errormessage || responseData.ErrorMessage
-      });
-      throw new Error(`Payone server error (${error.response?.status}): ${error.response?.statusText || 'Internal server error'}`);
-    }
-
+    strapi.log.error("[Apple Pay] Error:", error instanceof Error ? error.message : error);
     throw error;
   }
 };
@@ -215,28 +162,89 @@ const validateApplePayMerchant = async (strapi, params) => {
       throw new Error("Payone settings are not properly configured. Please check your plugin settings (aid, portalid, mid, key).");
     }
 
-    // Get currency and country from Apple Pay config
     const applePayConfig = settings?.applePayConfig || {};
-    const currency = params.currency || applePayConfig.currencyCode || "EUR";
-    const countryCode = params.countryCode || applePayConfig.countryCode || "DE";
 
-    // Update params with config values
     if (!params.currency && applePayConfig.currencyCode) {
       params.currency = applePayConfig.currencyCode;
     }
+
     if (!params.countryCode && applePayConfig.countryCode) {
       params.countryCode = applePayConfig.countryCode;
     }
 
     const sessionResponse = await initializeApplePaySession(strapi, params);
 
-    const applePaySessionBase64 = sessionResponse["add_paydata[applepay_payment_session]"] ||
-      sessionResponse.add_paydata?.applepay_payment_session;
+    // Extract add_paydata[applepay_payment_session] from response
+    // Payone returns this in URL-encoded format: add_paydata[applepay_payment_session]=BASE64_STRING
+    const applePaySessionBase64 =
+      sessionResponse["add_paydata[applepay_payment_session]"] ||
+      sessionResponse["add_paydata_applepay_payment_session"] ||
+      sessionResponse.add_paydata?.applepay_payment_session ||
+      (sessionResponse.add_paydata && typeof sessionResponse.add_paydata === 'object'
+        ? sessionResponse.add_paydata["applepay_payment_session"]
+        : null);
+
+    strapi.log.info("[Apple Pay] Genericpayment response:", {
+      status: sessionResponse.status,
+      workorderid: sessionResponse.workorderid,
+      hasApplePaySession: !!applePaySessionBase64,
+      applePaySessionLength: applePaySessionBase64 ? applePaySessionBase64.length : 0,
+      responseKeys: Object.keys(sessionResponse),
+      hasAddPaydataKey: !!sessionResponse["add_paydata[applepay_payment_session]"],
+      hasAddPaydataObject: !!sessionResponse.add_paydata,
+      addPaydataKeys: sessionResponse.add_paydata ? Object.keys(sessionResponse.add_paydata) : null
+    });
+
+    if (!applePaySessionBase64) {
+      strapi.log.error("[Apple Pay] Missing applepay_payment_session in response:", {
+        status: sessionResponse.status,
+        responseKeys: Object.keys(sessionResponse),
+        responseSample: JSON.stringify(sessionResponse).substring(0, 1000),
+        addPaydataKeys: sessionResponse.add_paydata ? Object.keys(sessionResponse.add_paydata) : null
+      });
+      throw new Error("Missing applepay_payment_session in Payone response. Please check your Payone Apple Pay configuration in PMI.");
+    }
 
     if (sessionResponse.status === "OK" && applePaySessionBase64 && applePaySessionBase64.length > 0) {
       try {
-        const merchantSessionJson = Buffer.from(applePaySessionBase64, 'base64').toString('utf-8');
-        const merchantSession = JSON.parse(merchantSessionJson);
+        strapi.log.info("[Apple Pay] Extracting merchant session from Base64:", {
+          base64Length: applePaySessionBase64.length,
+          base64Preview: applePaySessionBase64.substring(0, 100) + "...",
+          base64End: applePaySessionBase64.substring(Math.max(0, applePaySessionBase64.length - 50))
+        });
+
+        // Decode Base64 to get merchant session JSON
+        let merchantSessionJson;
+        try {
+          merchantSessionJson = Buffer.from(applePaySessionBase64, 'base64').toString('utf-8');
+          strapi.log.info("[Apple Pay] Base64 decoded successfully, JSON length:", merchantSessionJson.length);
+        } catch (decodeError) {
+          strapi.log.error("[Apple Pay] Failed to decode Base64:", {
+            error: decodeError.message,
+            base64Length: applePaySessionBase64.length
+          });
+          throw new Error(`Failed to decode Base64 merchant session: ${decodeError.message}`);
+        }
+
+        // Parse JSON merchant session
+        let merchantSession;
+        try {
+          merchantSession = JSON.parse(merchantSessionJson);
+          strapi.log.info("[Apple Pay] Merchant session JSON parsed successfully");
+        } catch (parseError) {
+          strapi.log.error("[Apple Pay] Failed to parse merchant session JSON:", {
+            error: parseError.message,
+            jsonPreview: merchantSessionJson.substring(0, 500)
+          });
+          throw new Error(`Failed to parse merchant session JSON: ${parseError.message}`);
+        }
+
+        strapi.log.info("[Apple Pay] Merchant session extracted successfully:", {
+          hasMerchantIdentifier: !!merchantSession.merchantIdentifier,
+          hasEpochTimestamp: !!merchantSession.epochTimestamp,
+          hasExpiresAt: !!merchantSession.expiresAt,
+          merchantSessionKeys: Object.keys(merchantSession)
+        });
 
         if (merchantSession.epochTimestamp && merchantSession.epochTimestamp > 1000000000000) {
           merchantSession.epochTimestamp = Math.floor(merchantSession.epochTimestamp / 1000);
@@ -274,7 +282,9 @@ const validateApplePayMerchant = async (strapi, params) => {
     throw new Error(
       `Payone Apple Pay initialization failed: ${errorCode ? `Error ${errorCode}` : 'Unknown error'} - ${errorMessage || 'Please check your Payone Apple Pay configuration in PMI'}`
     );
+
   } catch (error) {
+    strapi.log.error("[Apple Pay] Error:", error instanceof Error ? error.message : error);
     throw error;
   }
 };

package/server/services/transactionService.js

@@ -2,6 +2,20 @@
 
 const { getPluginStore } = require("./settingsService");
 
+const sanitizeRawRequest = (rawRequest) => {
+  if (!rawRequest || typeof rawRequest !== "object") return rawRequest
+  const sanitized = { ...rawRequest };
+  const sensitiveFields = ["cardpan", "cardexpiredate", "cardcvc2"];
+
+  sensitiveFields.forEach((field) => {
+    if (sanitized[field] && typeof sanitized[field] === "string") {
+      sanitized[field] = "*".repeat(sanitized[field].length);
+    }
+  });
+
+  return sanitized;
+};
+
 const logTransaction = async (strapi, transactionData) => {
   const pluginStore = getPluginStore(strapi);
   let transactionHistory =
@@ -28,17 +42,19 @@ const logTransaction = async (strapi, transactionData) => {
       transactionData.customer_message ||
       transactionData.Error?.CustomerMessage ||
       null,
-    body: transactionData || null,
-    raw_request: transactionData.raw_request || null,
-    raw_response: transactionData.raw_response || transactionData,
+    body: transactionData ? { ...transactionData, raw_request: sanitizeRawRequest(transactionData.raw_request) } : null,
+    raw_request: transactionData.raw_request
+      ? sanitizeRawRequest(transactionData.raw_request)
+      : null,
+    raw_response: sanitizeRawRequest(transactionData.raw_response) || transactionData,
     created_at: new Date().toISOString(),
     updated_at: new Date().toISOString()
   };
 
   transactionHistory.unshift(logEntry);
 
-  if (transactionHistory.length > 1000) {
-    transactionHistory = transactionHistory.slice(0, 1000);
+  if (transactionHistory.length > 5000) {
+    transactionHistory = transactionHistory.slice(0, 5000);
   }
 
   await pluginStore.set({
@@ -54,10 +70,19 @@ const getTransactionHistory = async (strapi, filters = {}) => {
   let transactionHistory =
     (await pluginStore.get({ key: "transactionHistory" })) || [];
 
-  if (filters.status) {
-    transactionHistory = transactionHistory.filter(
-      (transaction) => transaction.status === filters.status
-    );
+  if (filters.search) {
+    const searchLower = filters.search.toLowerCase().trim();
+    transactionHistory = transactionHistory.filter((transaction) => {
+      const status = (transaction.status || "").toLowerCase();
+      const txid = (transaction.txid || "").toLowerCase();
+      const reference = (transaction.reference || "").toLowerCase();
+
+      return (
+        status.includes(searchLower) ||
+        txid.includes(searchLower) ||
+        reference.includes(searchLower)
+      );
+    });
   }
 
   if (filters.request_type) {
@@ -66,16 +91,28 @@ const getTransactionHistory = async (strapi, filters = {}) => {
     );
   }
 
-  if (filters.txid) {
-    transactionHistory = transactionHistory.filter(
-      (transaction) => transaction.txid === filters.txid
-    );
-  }
-
-  if (filters.reference) {
-    transactionHistory = transactionHistory.filter(
-      (transaction) => transaction.reference === filters.reference
-    );
+  if (filters.payment_method) {
+    transactionHistory = transactionHistory.filter((transaction) => {
+      const clearingtype = transaction.raw_request?.clearingtype || "";
+      const wallettype = transaction.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" && (wallettype === "GPY" || wallettype === "GOOGLEPAY");
+        case "apple_pay":
+          return clearingtype === "wlt" && (wallettype === "APL" || wallettype === "APPLEPAY");
+        case "sofort":
+          return clearingtype === "sb";
+        case "sepa":
+          return clearingtype === "elv";
+        default:
+          return false;
+      }
+    });
   }
 
   if (filters.date_from) {
@@ -92,6 +129,54 @@ const getTransactionHistory = async (strapi, filters = {}) => {
     );
   }
 
+  if (filters.status) {
+    transactionHistory = transactionHistory.filter(
+      (transaction) => transaction.status === filters.status
+    );
+  }
+
+  // Apply sorting
+  if (filters.sort_by && filters.sort_order) {
+    const sortOrder = filters.sort_order === "desc" ? -1 : 1;
+    
+    transactionHistory.sort((a, b) => {
+      let aValue, bValue;
+
+      switch (filters.sort_by) {
+        case "amount":
+          aValue = a.amount || 0;
+          bValue = b.amount || 0;
+          break;
+        case "created_at":
+          aValue = new Date(a.created_at || a.timestamp || 0).getTime();
+          bValue = new Date(b.created_at || b.timestamp || 0).getTime();
+          break;
+        case "status":
+          aValue = (a.status || "").toLowerCase();
+          bValue = (b.status || "").toLowerCase();
+          break;
+        case "reference":
+          aValue = (a.reference || "").toLowerCase();
+          bValue = (b.reference || "").toLowerCase();
+          break;
+        case "method":
+          const aClearingType = a.raw_request?.clearingtype || "";
+          const bClearingType = b.raw_request?.clearingtype || "";
+          const aWalletType = a.raw_request?.wallettype || "";
+          const bWalletType = b.raw_request?.wallettype || "";
+          aValue = `${aClearingType}_${aWalletType}`.toLowerCase();
+          bValue = `${bClearingType}_${bWalletType}`.toLowerCase();
+          break;
+        default:
+          return 0;
+      }
+
+      if (aValue < bValue) return -1 * sortOrder;
+      if (aValue > bValue) return 1 * sortOrder;
+      return 0;
+    });
+  }
+
   return transactionHistory;
 };
 

package/server/utils/paymentMethodParams.js

@@ -145,15 +145,25 @@ const addPaymentMethodParams = (params, logger) => {
     try {
       const tokenString = Buffer.from(updated.applePayToken, 'base64').toString('utf-8');
       tokenData = JSON.parse(tokenString);
+
+      if (logger) {
+        logger.info("[Apple Pay] Token decoded from Base64 successfully");
+      }
     } catch (e) {
       try {
-        // Try parsing as JSON string directly
         tokenData = typeof updated.applePayToken === 'string'
           ? JSON.parse(updated.applePayToken)
           : updated.applePayToken;
+
+        if (logger) {
+          logger.info("[Apple Pay] Token parsed as JSON string directly");
+        }
       } catch (e2) {
-        // If already an object, use as-is
         tokenData = updated.applePayToken;
+
+        if (logger) {
+          logger.info("[Apple Pay] Token used as-is (already an object)");
+        }
       }
     }
 
@@ -162,7 +172,10 @@ const addPaymentMethodParams = (params, logger) => {
 
       if (!paymentData) {
         if (logger) {
-          logger.error("[Apple Pay] Invalid token structure: missing paymentData field");
+          logger.error("[Apple Pay] Invalid token structure: missing paymentData field", {
+            tokenKeys: Object.keys(tokenData),
+            tokenStructure: JSON.stringify(tokenData).substring(0, 500)
+          });
         }
         delete updated.applePayToken;
         return updated;
@@ -171,30 +184,66 @@ const addPaymentMethodParams = (params, logger) => {
       const header = paymentData.header || {};
 
       // Payone required fields according to docs
-      updated["add_paydata[paymentdata_token_version]"] = paymentData.version || "EC_v1";
-      updated["add_paydata[paymentdata_token_data]"] = paymentData.data || "";
-      updated["add_paydata[paymentdata_token_signature]"] = paymentData.signature || "";
-      updated["add_paydata[paymentdata_token_ephemeral_publickey]"] = header.ephemeralPublicKey || "";
-      updated["add_paydata[paymentdata_token_publickey_hash]"] = header.publicKeyHash || "";
+      // Extract version, data, signature from paymentData
+      const tokenVersion = paymentData.version || "EC_v1";
+      const tokenDataValue = paymentData.data || "";
+      const tokenSignature = paymentData.signature || "";
+
+      // Extract from header
+      const ephemeralPublicKey = header.ephemeralPublicKey || "";
+      const publicKeyHash = header.publicKeyHash || "";
+      const transactionId = paymentData.transactionId || header.transactionId || "";
+
+      // Set Payone required fields
+      updated["add_paydata[paymentdata_token_version]"] = tokenVersion;
+      updated["add_paydata[paymentdata_token_data]"] = tokenDataValue;
+      updated["add_paydata[paymentdata_token_signature]"] = tokenSignature;
+      updated["add_paydata[paymentdata_token_ephemeral_publickey]"] = ephemeralPublicKey;
+      updated["add_paydata[paymentdata_token_publickey_hash]"] = publicKeyHash;
 
       // Transaction ID is optional according to Payone docs
-      if (paymentData.transactionId || header.transactionId) {
-        updated["add_paydata[paymentdata_token_transaction_id]"] = paymentData.transactionId || header.transactionId || "";
+      if (transactionId) {
+        updated["add_paydata[paymentdata_token_transaction_id]"] = transactionId;
+      }
+
+      if (logger) {
+        logger.info("[Apple Pay] Token extracted successfully:", {
+          hasVersion: !!tokenVersion,
+          hasData: !!tokenDataValue,
+          hasSignature: !!tokenSignature,
+          hasEphemeralPublicKey: !!ephemeralPublicKey,
+          hasPublicKeyHash: !!publicKeyHash,
+          hasTransactionId: !!transactionId,
+          dataLength: tokenDataValue.length,
+          signatureLength: tokenSignature.length,
+          ephemeralPublicKeyLength: ephemeralPublicKey.length,
+          publicKeyHashLength: publicKeyHash.length
+        });
       }
 
-      if (!updated["add_paydata[paymentdata_token_data]"] ||
-        !updated["add_paydata[paymentdata_token_signature]"] ||
-        !updated["add_paydata[paymentdata_token_ephemeral_publickey]"] ||
-        !updated["add_paydata[paymentdata_token_publickey_hash]"]) {
+      // Validate required fields
+      if (!tokenDataValue ||
+        !tokenSignature ||
+        !ephemeralPublicKey ||
+        !publicKeyHash) {
         if (logger) {
           logger.error("[Apple Pay] Missing required token fields:", {
-            hasData: !!updated["add_paydata[paymentdata_token_data]"],
-            hasSignature: !!updated["add_paydata[paymentdata_token_signature]"],
-            hasEphemeralPublicKey: !!updated["add_paydata[paymentdata_token_ephemeral_publickey]"],
-            hasPublicKeyHash: !!updated["add_paydata[paymentdata_token_publickey_hash]"]
+            hasData: !!tokenDataValue,
+            hasSignature: !!tokenSignature,
+            hasEphemeralPublicKey: !!ephemeralPublicKey,
+            hasPublicKeyHash: !!publicKeyHash,
+            paymentDataKeys: Object.keys(paymentData),
+            headerKeys: Object.keys(header)
           });
         }
       }
+    } else {
+      if (logger) {
+        logger.error("[Apple Pay] Token is not a valid object:", {
+          tokenType: typeof tokenData,
+          tokenValue: typeof tokenData === 'string' ? tokenData.substring(0, 200) : String(tokenData).substring(0, 200)
+        });
+      }
     }
 
     delete updated.applePayToken;