strapi-plugin-payone-provider 1.1.3 → 1.3.0

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

@@ -0,0 +1,456 @@
+import { useState, useEffect } from "react";
+import { useNotification } from "@strapi/helper-plugin";
+import payoneRequests from "../utils/api";
+import {
+  getPreauthorizationParams,
+  getAuthorizationParams,
+  getCaptureParams,
+  getRefundParams
+} from "../utils/paymentUtils";
+import { DEFAULT_PAYMENT_DATA } from "../constants/paymentConstants";
+
+const usePaymentActions = () => {
+  const toggleNotification = useNotification();
+
+  // Load settings to get enable3DSecure value
+  const [settings, setSettings] = useState({ enable3DSecure: false });
+
+  useEffect(() => {
+    const loadSettings = async () => {
+      try {
+        const response = await payoneRequests.getSettings();
+        if (response?.data) {
+          setSettings(response.data);
+        }
+      } catch (error) {
+        // Silent fail
+      }
+    };
+    loadSettings();
+  }, []);
+
+  // Payment form state
+  const [paymentAmount, setPaymentAmount] = useState("1000");
+
+  // Generate reference automatically
+  const generateReference = (prefix = "REF") => {
+    const timestamp = Date.now().toString(36).toUpperCase();
+    const random = Math.random().toString(36).substring(2, 6).toUpperCase();
+    return `${prefix}-${timestamp}${random}`.slice(0, 20);
+  };
+
+  const [preauthReference, setPreauthReference] = useState(generateReference("PRE"));
+  const [authReference, setAuthReference] = useState(generateReference("AUTH"));
+  const [captureTxid, setCaptureTxid] = useState("");
+  const [refundTxid, setRefundTxid] = useState("");
+  const [refundSequenceNumber, setRefundSequenceNumber] = useState("2");
+  const [refundReference, setRefundReference] = useState("");
+  const [paymentMethod, setPaymentMethod] = useState("cc");
+  const [captureMode, setCaptureMode] = useState("full");
+  const [googlePayToken, setGooglePayToken] = useState(null);
+
+  // Card details for 3DS testing
+  const [cardtype, setCardtype] = useState("");
+  const [cardpan, setCardpan] = useState("");
+  const [cardexpiredate, setCardexpiredate] = useState("");
+  const [cardcvc2, setCardcvc2] = useState("");
+
+  // Payment processing state
+  const [isProcessingPayment, setIsProcessingPayment] = useState(false);
+  const [paymentResult, setPaymentResult] = useState(null);
+  const [paymentError, setPaymentError] = useState(null);
+
+  const handlePaymentError = (error, defaultMessage) => {
+    const errorMessage =
+      error.response?.data?.data?.Error?.ErrorMessage ||
+      error.message ||
+      defaultMessage;
+    setPaymentError(errorMessage);
+    toggleNotification({
+      type: "warning",
+      message: defaultMessage
+    });
+  };
+
+  const handlePaymentSuccess = (message) => {
+    toggleNotification({
+      type: "success",
+      message
+    });
+  };
+
+  const handlePreauthorization = async (tokenParam = null) => {
+    setIsProcessingPayment(true);
+    setPaymentError(null);
+    setPaymentResult(null);
+    try {
+      // Auto-generate reference if empty
+      const finalPreauthReference = preauthReference.trim() || generateReference("PRE");
+      if (!preauthReference.trim()) {
+        setPreauthReference(finalPreauthReference);
+      }
+
+      // Determine currency based on card type
+      // American Express typically requires USD, other cards use EUR
+      const currency = (paymentMethod === "cc" && cardtype === "A") ? "USD" : "EUR";
+
+      const baseParams = {
+        amount: parseInt(paymentAmount),
+        currency: currency,
+        reference: finalPreauthReference,
+        enable3DSecure: settings.enable3DSecure !== false,
+        ...DEFAULT_PAYMENT_DATA
+      };
+
+      // Add card details if credit card payment and 3DS enabled
+      if (paymentMethod === "cc" && settings.enable3DSecure !== false) {
+        if (cardtype) baseParams.cardtype = cardtype;
+        if (cardpan) baseParams.cardpan = cardpan;
+        if (cardexpiredate) baseParams.cardexpiredate = cardexpiredate;
+        if (cardcvc2) baseParams.cardcvc2 = cardcvc2;
+      }
+
+      const needsRedirectUrls =
+        (paymentMethod === "cc" && settings.enable3DSecure !== false) ||
+        ["wlt", "gpp", "apl", "sb"].includes(paymentMethod);
+
+      if (needsRedirectUrls) {
+        const baseUrl = window.location.origin;
+        baseParams.successurl = `${baseUrl}/admin/plugins/strapi-plugin-payone-provider/payment/success`;
+        baseParams.errorurl = `${baseUrl}/admin/plugins/strapi-plugin-payone-provider/payment/error`;
+        baseParams.backurl = `${baseUrl}/admin/plugins/strapi-plugin-payone-provider/payment/back`;
+      }
+
+      const tokenToUse = tokenParam || googlePayToken;
+      if (paymentMethod === "gpp" && tokenToUse) {
+        baseParams.googlePayToken = tokenToUse;
+        baseParams.settings = settings;
+      }
+
+      const params = getPreauthorizationParams(paymentMethod, baseParams);
+
+      const result = await payoneRequests.preauthorization(params);
+      const responseData = result?.data || result;
+
+      // Log full response
+      console.log("Preauthorization Response:", responseData);
+      console.log("Response Status:", responseData.status || responseData.Status);
+      console.log("Response Error Code:", responseData.errorcode || responseData.errorCode || responseData.ErrorCode);
+      console.log("Response Error Message:", responseData.errormessage || responseData.errorMessage || responseData.ErrorMessage);
+      console.log("All redirect URL fields:", {
+        redirectUrl: responseData.redirectUrl,
+        redirecturl: responseData.redirecturl,
+        RedirectUrl: responseData.RedirectUrl,
+        redirect_url: responseData.redirect_url,
+        url: responseData.url,
+        Url: responseData.Url
+      });
+
+      const status = (responseData.status || responseData.Status || "").toUpperCase();
+      const errorCode = responseData.errorcode || responseData.errorCode || responseData.ErrorCode;
+      const errorMessage = responseData.errormessage || responseData.errorMessage || responseData.ErrorMessage;
+
+      // Check for 3DS required error (4219)
+      const requires3DSErrorCodes = ["4219", 4219];
+      const is3DSRequiredError = requires3DSErrorCodes.includes(errorCode);
+
+      // Check all possible redirect URL fields
+      const redirectUrl =
+        responseData.redirectUrl ||
+        responseData.redirecturl ||
+        responseData.RedirectUrl ||
+        responseData.redirect_url ||
+        responseData.url ||
+        responseData.Url ||
+        null;
+
+      // If 3DS required but no redirect URL, show helpful message
+      if (is3DSRequiredError && !redirectUrl) {
+        console.warn("3DS authentication required (Error 4219) but no redirect URL found in response");
+        console.log("Full response:", JSON.stringify(responseData, null, 2));
+        setPaymentError(
+          "3D Secure authentication required. Please check Payone configuration and ensure redirect URLs are properly set. Error: " +
+          (errorMessage || `Error code: ${errorCode}`)
+        );
+        setPaymentResult(responseData);
+        return;
+      }
+
+      // Check for other errors (but not 3DS required)
+      if ((status === "ERROR" || status === "INVALID" || errorCode) && !is3DSRequiredError) {
+        setPaymentError(
+          errorMessage ||
+          `Payment failed with error code: ${errorCode || "Unknown"}` ||
+          "Preauthorization failed"
+        );
+        setPaymentResult(responseData);
+        return;
+      }
+
+      const needsRedirect = responseData.requires3DSRedirect ||
+        (status === "REDIRECT" && redirectUrl) ||
+        (is3DSRequiredError && redirectUrl);
+
+      if (needsRedirect && redirectUrl) {
+        console.log("Redirecting to 3DS:", redirectUrl);
+        window.location.href = redirectUrl;
+        return;
+      }
+
+      setPaymentResult(responseData);
+
+      if (status === "APPROVED") {
+        handlePaymentSuccess("Preauthorization completed successfully");
+      } else {
+        handlePaymentError(
+          { message: `Unexpected status: ${status}` },
+          `Preauthorization completed with status: ${status}`
+        );
+      }
+    } catch (error) {
+      handlePaymentError(error, "Preauthorization failed");
+    } finally {
+      setIsProcessingPayment(false);
+    }
+  };
+
+  const handleAuthorization = async (tokenParam = null) => {
+    setIsProcessingPayment(true);
+    setPaymentError(null);
+    setPaymentResult(null);
+
+    try {
+      // Auto-generate reference if empty
+      const finalAuthReference = authReference.trim() || generateReference("AUTH");
+      if (!authReference.trim()) {
+        setAuthReference(finalAuthReference);
+      }
+
+      // Determine currency based on card type
+      // American Express typically requires USD, other cards use EUR
+      const currency = (paymentMethod === "cc" && cardtype === "A") ? "USD" : "EUR";
+
+      const baseParams = {
+        amount: parseInt(paymentAmount),
+        currency: currency,
+        reference: finalAuthReference,
+        enable3DSecure: settings.enable3DSecure !== false,
+        ...DEFAULT_PAYMENT_DATA
+      };
+
+      // Add card details if credit card payment and 3DS enabled
+      if (paymentMethod === "cc" && settings.enable3DSecure !== false) {
+        if (cardtype) baseParams.cardtype = cardtype;
+        if (cardpan) baseParams.cardpan = cardpan;
+        if (cardexpiredate) baseParams.cardexpiredate = cardexpiredate;
+        if (cardcvc2) baseParams.cardcvc2 = cardcvc2;
+      }
+
+      const needsRedirectUrls =
+        (paymentMethod === "cc" && settings.enable3DSecure !== false) ||
+        ["wlt", "gpp", "apl", "sb"].includes(paymentMethod);
+
+      if (needsRedirectUrls) {
+        const baseUrl = window.location.origin;
+        baseParams.successurl = `${baseUrl}/admin/plugins/strapi-plugin-payone-provider/payment/success`;
+        baseParams.errorurl = `${baseUrl}/admin/plugins/strapi-plugin-payone-provider/payment/error`;
+        baseParams.backurl = `${baseUrl}/admin/plugins/strapi-plugin-payone-provider/payment/back`;
+      }
+
+      const tokenToUse = tokenParam || googlePayToken;
+      if (paymentMethod === "gpp" && tokenToUse) {
+        baseParams.googlePayToken = tokenToUse;
+        baseParams.settings = settings;
+      }
+
+      const params = getAuthorizationParams(paymentMethod, baseParams);
+
+      const result = await payoneRequests.authorization(params);
+      const responseData = result?.data || result;
+
+      // Log full response
+      console.log("Authorization Response:", responseData);
+      console.log("Response Status:", responseData.status || responseData.Status);
+      console.log("Response Error Code:", responseData.errorcode || responseData.errorCode || responseData.ErrorCode);
+      console.log("Response Error Message:", responseData.errormessage || responseData.errorMessage || responseData.ErrorMessage);
+      console.log("All redirect URL fields:", {
+        redirectUrl: responseData.redirectUrl,
+        redirecturl: responseData.redirecturl,
+        RedirectUrl: responseData.RedirectUrl,
+        redirect_url: responseData.redirect_url,
+        url: responseData.url,
+        Url: responseData.Url
+      });
+
+      const status = (responseData.status || responseData.Status || "").toUpperCase();
+      const errorCode = responseData.errorcode || responseData.errorCode || responseData.ErrorCode;
+      const errorMessage = responseData.errormessage || responseData.errorMessage || responseData.ErrorMessage;
+
+      // Check for 3DS required error (4219)
+      const requires3DSErrorCodes = ["4219", 4219];
+      const is3DSRequiredError = requires3DSErrorCodes.includes(errorCode);
+
+      // Check all possible redirect URL fields
+      const redirectUrl =
+        responseData.redirectUrl ||
+        responseData.redirecturl ||
+        responseData.RedirectUrl ||
+        responseData.redirect_url ||
+        responseData.url ||
+        responseData.Url ||
+        null;
+
+      // If 3DS required but no redirect URL, show helpful message
+      if (is3DSRequiredError && !redirectUrl) {
+        console.warn("3DS authentication required (Error 4219) but no redirect URL found in response");
+        console.log("Full response:", JSON.stringify(responseData, null, 2));
+        setPaymentError(
+          "3D Secure authentication required. Please check Payone configuration and ensure redirect URLs are properly set. Error: " +
+          (errorMessage || `Error code: ${errorCode}`)
+        );
+        setPaymentResult(responseData);
+        return;
+      }
+
+      // Check for other errors (but not 3DS required)
+      if ((status === "ERROR" || status === "INVALID" || errorCode) && !is3DSRequiredError) {
+        setPaymentError(
+          errorMessage ||
+          `Payment failed with error code: ${errorCode || "Unknown"}` ||
+          "Authorization failed"
+        );
+        setPaymentResult(responseData);
+        return;
+      }
+
+      const needsRedirect = responseData.requires3DSRedirect ||
+        (status === "REDIRECT" && redirectUrl) ||
+        (is3DSRequiredError && redirectUrl);
+
+      if (needsRedirect && redirectUrl) {
+        console.log("Redirecting to 3DS:", redirectUrl);
+        window.location.href = redirectUrl;
+        return;
+      }
+
+      setPaymentResult(responseData);
+
+      if (status === "APPROVED") {
+        handlePaymentSuccess("Authorization completed successfully");
+      } else {
+        handlePaymentError(
+          { message: `Unexpected status: ${status}` },
+          `Authorization completed with status: ${status}`
+        );
+      }
+    } catch (error) {
+      handlePaymentError(error, "Authorization failed");
+    } finally {
+      setIsProcessingPayment(false);
+    }
+  };
+
+  const handleCapture = async () => {
+    if (!captureTxid.trim()) {
+      setPaymentError("Transaction ID is required for capture");
+      return;
+    }
+    setIsProcessingPayment(true);
+    setPaymentError(null);
+    setPaymentResult(null);
+    try {
+      const params = getCaptureParams(paymentMethod, {
+        txid: captureTxid,
+        amount: parseInt(paymentAmount),
+        currency: "EUR",
+        captureMode: captureMode,
+        sequencenumber: 1
+      });
+
+      const result = await payoneRequests.capture(params);
+      setPaymentResult(result);
+      handlePaymentSuccess("Capture completed successfully");
+    } catch (error) {
+      handlePaymentError(error, "Capture failed");
+    } finally {
+      setIsProcessingPayment(false);
+    }
+  };
+
+  const handleRefund = async () => {
+    if (!refundTxid.trim()) {
+      setPaymentError("Transaction ID is required for refund");
+      return;
+    }
+    setIsProcessingPayment(true);
+    setPaymentError(null);
+    setPaymentResult(null);
+    try {
+      const params = getRefundParams(paymentMethod, {
+        txid: refundTxid,
+        sequencenumber: parseInt(refundSequenceNumber),
+        amount: parseInt(paymentAmount),
+        currency: "EUR",
+        reference: refundReference || `REFUND-${Date.now()}`
+      });
+
+      const result = await payoneRequests.refund(params);
+      setPaymentResult(result);
+      handlePaymentSuccess("Refund completed successfully");
+    } catch (error) {
+      handlePaymentError(error, "Refund failed");
+    } finally {
+      setIsProcessingPayment(false);
+    }
+  };
+
+  return {
+    // Form state
+    paymentAmount,
+    setPaymentAmount,
+    preauthReference,
+    setPreauthReference,
+    authReference,
+    setAuthReference,
+    captureTxid,
+    setCaptureTxid,
+    refundTxid,
+    setRefundTxid,
+    refundSequenceNumber,
+    setRefundSequenceNumber,
+    refundReference,
+    setRefundReference,
+    paymentMethod,
+    setPaymentMethod,
+    captureMode,
+    setCaptureMode,
+
+    // Processing state
+    isProcessingPayment,
+    paymentResult,
+    paymentError,
+
+    // Handlers
+    handlePreauthorization,
+    handleAuthorization,
+    handleCapture,
+    handleRefund,
+
+    // Google Pay
+    googlePayToken,
+    setGooglePayToken,
+
+    // Card details for 3DS
+    cardtype,
+    setCardtype,
+    cardpan,
+    setCardpan,
+    cardexpiredate,
+    setCardexpiredate,
+    cardcvc2,
+    setCardcvc2
+  };
+};
+
+export default usePaymentActions;
+

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

@@ -0,0 +1,111 @@
+import { useState, useEffect } from "react";
+import { useNotification } from "@strapi/helper-plugin";
+import payoneRequests from "../utils/api";
+
+const useSettings = () => {
+  const toggleNotification = useNotification();
+  const [settings, setSettings] = useState({
+    aid: "",
+    portalid: "",
+    mid: "",
+    key: "",
+    mode: "test",
+    api_version: "3.10",
+    enable3DSecure: false
+  });
+  const [isLoading, setIsLoading] = useState(false);
+  const [isSaving, setIsSaving] = useState(false);
+  const [isTesting, setIsTesting] = useState(false);
+  const [testResult, setTestResult] = useState(null);
+
+  useEffect(() => {
+    loadSettings();
+  }, []);
+
+  const loadSettings = async () => {
+    setIsLoading(true);
+    try {
+      const response = await payoneRequests.getSettings();
+      if (response?.data) setSettings(response.data);
+    } catch (error) {
+      toggleNotification({
+        type: "warning",
+        message: "Failed to load settings"
+      });
+    } finally {
+      setIsLoading(false);
+    }
+  };
+
+  const handleInputChange = (field, value) => {
+    setSettings((prev) => ({ ...prev, [field]: value }));
+  };
+
+  const handleSave = async () => {
+    setIsSaving(true);
+    try {
+      await payoneRequests.updateSettings(settings);
+      toggleNotification({
+        type: "success",
+        message: "Settings saved successfully"
+      });
+    } catch (error) {
+      toggleNotification({
+        type: "warning",
+        message: "Failed to save settings"
+      });
+    } finally {
+      setIsSaving(false);
+    }
+  };
+
+  const handleTestConnection = async () => {
+    setIsTesting(true);
+    setTestResult(null);
+    try {
+      const response = await payoneRequests.testConnection();
+      if (response.data) {
+        const result = response.data;
+        setTestResult(result);
+        if (result.success !== undefined) {
+          toggleNotification({
+            type: Boolean(result.success) ? "success" : "warning",
+            message: result.message || "Test completed"
+          });
+        }
+      } else {
+        throw new Error("Invalid response format from server");
+      }
+    } catch (error) {
+      toggleNotification({
+        type: "warning",
+        message: "Failed to test connection"
+      });
+      setTestResult({
+        success: false,
+        message:
+          "Failed to test connection. Please check your network and server logs for details.",
+        details: {
+          errorCode: "NETWORK",
+          rawResponse: error.message || "Network error"
+        }
+      });
+    } finally {
+      setIsTesting(false);
+    }
+  };
+
+  return {
+    settings,
+    isLoading,
+    isSaving,
+    isTesting,
+    testResult,
+    handleInputChange,
+    handleSave,
+    handleTestConnection
+  };
+};
+
+export default useSettings;
+

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);
+};
+