Field ID => new value pairs that differ from the current entry data.
+ */
+ private static function get_payer_field_updates( $payer, $response, $action, $entry ) {
+ $updates = array();
+ $settings = $action->post_content;
+
+ // Email: setting is a shortcode like [25], extract the field ID.
+ if ( ! empty( $settings['email'] ) && preg_match( '/\[(\d+)\]/', $settings['email'], $matches ) ) {
+ $email_field_id = (int) $matches[1];
+
+ if ( ! empty( $payer->email_address ) ) {
+ $current = $entry->metas[ $email_field_id ] ?? '';
+
+ if ( $current !== $payer->email_address ) {
+ $updates[ $email_field_id ] = $payer->email_address;
+ }
+ }
+ }
+
+ // Name fields.
+ if ( isset( $payer->name ) ) {
+ $first_name_field_id = ! empty( $settings['billing_first_name'] ) ? (int) $settings['billing_first_name'] : 0;
+ $last_name_field_id = ! empty( $settings['billing_last_name'] ) ? (int) $settings['billing_last_name'] : 0;
+
+ if ( $first_name_field_id && $first_name_field_id === $last_name_field_id ) {
+ // Both settings point to the same Name field. Store as a serialized array.
+ $new_value = array(
+ 'first' => ! empty( $payer->name->given_name ) ? $payer->name->given_name : '',
+ 'last' => ! empty( $payer->name->surname ) ? $payer->name->surname : '',
+ );
+ $current = $entry->metas[ $first_name_field_id ] ?? array();
+
+ if ( $current !== $new_value ) {
+ $updates[ $first_name_field_id ] = $new_value;
+ }
+ } else {
+ // Separate text fields for first and last name.
+ if ( $first_name_field_id && ! empty( $payer->name->given_name ) ) {
+ $current = $entry->metas[ $first_name_field_id ] ?? '';
+
+ if ( $current !== $payer->name->given_name ) {
+ $updates[ $first_name_field_id ] = $payer->name->given_name;
+ }
+ }
+
+ if ( $last_name_field_id && ! empty( $payer->name->surname ) ) {
+ $current = $entry->metas[ $last_name_field_id ] ?? '';
+
+ if ( $current !== $payer->name->surname ) {
+ $updates[ $last_name_field_id ] = $payer->name->surname;
+ }
+ }
+ }//end if
+ }//end if
+
+ // Address: pull from the first purchase unit's shipping address.
+ if ( empty( $settings['billing_address'] ) ) {
+ return $updates;
+ }
+
+ $field_id = (int) $settings['billing_address'];
+ $shipping = self::get_shipping_address_from_response( $response );
+
+ if ( ! $shipping ) {
+ return $updates;
+ }
+
+ $new_value = array(
+ 'line1' => ! empty( $shipping->address_line_1 ) ? $shipping->address_line_1 : '',
+ 'line2' => ! empty( $shipping->address_line_2 ) ? $shipping->address_line_2 : '',
+ 'city' => ! empty( $shipping->admin_area_2 ) ? $shipping->admin_area_2 : '',
+ 'state' => ! empty( $shipping->admin_area_1 ) ? $shipping->admin_area_1 : '',
+ 'zip' => ! empty( $shipping->postal_code ) ? $shipping->postal_code : '',
+ 'country' => ! empty( $shipping->country_code ) ? $shipping->country_code : '',
+ );
+
+ if ( ! array_filter( $new_value ) ) {
+ return $updates;
+ }
+
+ $current = $entry->metas[ $field_id ] ?? array();
+
+ if ( $current !== $new_value ) {
+ $updates[ $field_id ] = $new_value;
+ }
+
+ return $updates;
+ }
+
+ /**
+ * Get the shipping address object from the first purchase unit in the response.
+ *
+ * @since x.x
+ *
+ * @param object $response The capture response.
+ *
+ * @return false|object The address object, or false if not available.
+ */
+ private static function get_shipping_address_from_response( $response ) {
+ if ( empty( $response->purchase_units ) || ! is_array( $response->purchase_units ) ) {
+ return false;
+ }
+
+ $purchase_unit = reset( $response->purchase_units );
+
+ if ( empty( $purchase_unit->shipping ) || ! is_object( $purchase_unit->shipping ) || empty( $purchase_unit->shipping->address ) ) {
+ return false;
+ }
+
+ return $purchase_unit->shipping->address;
+ }
+
+ /**
+ * Add a payment row for the payments table.
+ *
+ * @param array $atts The arguments for the payment.
+ *
+ * @return int
+ */
+ private static function create_new_payment( $atts ) {
+ $atts['charge'] = (object) $atts['charge'];
+
+ $new_values = array(
+ 'amount' => FrmTransLiteAppHelper::get_formatted_amount_for_currency( $atts['charge']->amount, $atts['action'] ),
+ 'status' => $atts['status'],
+ 'paysys' => 'paypal',
+ 'item_id' => $atts['entry']->id,
+ 'action_id' => $atts['action']->ID,
+ 'receipt_id' => $atts['charge']->id,
+ 'sub_id' => $atts['charge']->sub_id ?? '',
+ 'test' => 'test' === FrmPayPalLiteAppHelper::active_mode() ? 1 : 0,
+ );
+
+ $frm_payment = new FrmTransLitePayment();
+ return $frm_payment->create( $new_values );
+ }
+
+ /**
+ * Create a new PayPal subscription and a subscription and payment for the payments tables.
+ *
+ * @param array $atts Includes 'customer', 'entry', 'action', 'amount'.
+ *
+ * @return bool|string True on success, error message on failure
+ */
+ private static function trigger_recurring_payment( $atts ) {
+ $subscription_id = FrmAppHelper::get_post_param( 'paypal_subscription_id', '', 'sanitize_text_field' );
+
+ if ( ! $subscription_id ) {
+ return __( 'No PayPal subscription ID found.', 'formidable' );
+ }
+
+ $subscription = FrmPayPalLiteConnectHelper::get_subscription( $subscription_id );
+
+ if ( false === $subscription ) {
+ return 'Failed to get subscription.';
+ }
+
+ if ( ! self::validate_subscription_status( $subscription ) ) {
+ return 'This subscription status is not valid.';
+ }
+
+ if ( ! self::validate_subscription_amount( $subscription, $atts['amount'] ) ) {
+ return 'This subscription amount appears to be tampered with.';
+ }
+
+ $sub_id = self::create_new_subscription( $subscription_id, $atts, $subscription );
+
+ self::$active_payment_source = FrmAppHelper::get_post_param( 'paypal_payment_source', '', 'sanitize_text_field' );
+
+ self::$active_order_id = FrmAppHelper::get_post_param( 'paypal_order_id', '', 'sanitize_text_field' );
+
+ self::sync_entry_data_with_subscription_response( $subscription, $atts );
+
+ self::maybe_create_initial_subscription_payment( $subscription_id, $sub_id, $atts );
+
+ return true;
+ }
+
+ /**
+ * Create a new subscription record in the payments tables.
+ *
+ * @param string $subscription_id The PayPal subscription ID.
+ * @param array $atts Includes 'entry', 'action', 'amount'.
+ * @param object $subscription The PayPal subscription API response.
+ *
+ * @return int
+ */
+ private static function create_new_subscription( $subscription_id, $atts, $subscription ) {
+ $next_bill_date = gmdate( 'Y-m-d' );
+
+ if ( ! empty( $subscription->billing_info->next_billing_time ) ) {
+ $next_bill_date = gmdate( 'Y-m-d', strtotime( $subscription->billing_info->next_billing_time ) );
+ }
+
+ $new_values = array(
+ 'amount' => FrmTransLiteAppHelper::get_formatted_amount_for_currency( $atts['amount'], $atts['action'] ),
+ 'paysys' => 'paypal',
+ 'item_id' => $atts['entry']->id,
+ 'action_id' => $atts['action']->ID,
+ 'sub_id' => $subscription_id,
+ 'interval_count' => $atts['action']->post_content['interval_count'],
+ 'time_interval' => $atts['action']->post_content['interval'],
+ 'status' => 'active',
+ 'next_bill_date' => $next_bill_date,
+ 'test' => 'test' === FrmPayPalLiteAppHelper::active_mode() ? 1 : 0,
+ );
+
+ $frm_sub = new FrmTransLiteSubscription();
+ return $frm_sub->create( $new_values );
+ }
+
+ /**
+ * Create the initial payment record for a new subscription.
+ *
+ * Uses the PayPal subscription ID as a temporary receipt_id. When the PAYMENT.SALE.COMPLETED
+ * webhook arrives later, the receipt_id is updated to the real capture/sale ID.
+ *
+ * @since x.x
+ *
+ * @param string $subscription_id The PayPal subscription ID.
+ * @param int $sub_id The local subscription record ID.
+ * @param array $atts Includes 'entry', 'action', 'amount'.
+ *
+ * @return void
+ */
+ private static function maybe_create_initial_subscription_payment( $subscription_id, $sub_id, $atts ) {
+ $atts['status'] = 'complete';
+ $atts['charge'] = new stdClass();
+ $atts['charge']->id = $subscription_id;
+ $atts['charge']->amount = $atts['amount'];
+ $atts['charge']->sub_id = $sub_id;
+
+ $payment_id = self::create_new_payment( $atts );
+ $frm_payment = new FrmTransLitePayment();
+ $payment = $frm_payment->get_one( $payment_id );
+ $status = $atts['status'];
+
+ FrmTransLiteActionsController::trigger_payment_status_change( compact( 'status', 'payment' ) );
+ }
+
+ /**
+ * Check if PayPal integration is enabled.
+ *
+ * @return bool true if PayPal is set up.
+ */
+ private static function paypal_is_configured() {
+ return (bool) FrmPayPalLiteConnectHelper::get_merchant_id();
+ }
+
+ /**
+ * Convert the amount from 10.00 to 1000.
+ *
+ * @param mixed $amount
+ * @param array $atts
+ *
+ * @return string
+ */
+ public static function prepare_amount( $amount, $atts = array() ) {
+ $amount = parent::prepare_amount( $amount, $atts );
+ $currency = self::get_currency_for_action( $atts );
+ return number_format( $amount, $currency['decimals'], '', '' );
+ }
+
+ /**
+ * If this form submits with ajax, load the scripts on the first page.
+ *
+ * @param array $params
+ *
+ * @return void
+ */
+ public static function maybe_load_scripts( $params ) {
+ // phpcs:ignore Universal.Operators.StrictComparisons
+ if ( $params['form_id'] == $params['posted_form_id'] ) {
+ // This form has already been posted, so we aren't on the first page.
+ return;
+ }
+
+ $form = FrmForm::getOne( $params['form_id'] );
+
+ if ( ! $form ) {
+ return;
+ }
+
+ $credit_card_field = FrmField::getAll(
+ array(
+ 'fi.form_id' => $form->id,
+ 'type' => 'credit_card',
+ )
+ );
+
+ if ( ! $credit_card_field ) {
+ return;
+ }
+
+ $payment_actions = self::get_actions_before_submit( $form->id );
+
+ if ( ! $payment_actions ) {
+ return;
+ }
+
+ $found_gateway = false;
+
+ foreach ( $payment_actions as $action ) {
+ $gateways = $action->post_content['gateway'];
+
+ if ( in_array( 'paypal', (array) $gateways, true ) ) {
+ $found_gateway = true;
+ break;
+ }
+ }
+
+ if ( ! $found_gateway ) {
+ return;
+ }
+
+ self::load_scripts( (int) $form->id );
+ }
+
+ /**
+ * Load front end JavaScript for a PayPal form.
+ *
+ * @param int $form_id
+ *
+ * @return void
+ */
+ public static function load_scripts( $form_id ) {
+ if ( FrmAppHelper::is_admin_page( 'formidable-entries' ) ) {
+ return;
+ }
+
+ if ( wp_script_is( 'formidable-paypal', 'enqueued' ) ) {
+ return;
+ }
+
+ if ( ! $form_id || ! is_int( $form_id ) ) {
+ _doing_it_wrong( __METHOD__, '$form_id parameter must be a non-zero integer', 'x.x' );
+ return;
+ }
+
+ $payment_action_by_id = array();
+
+ add_filter(
+ 'frm_trans_settings_for_js',
+ /**
+ * @param array $settings_for_action
+ * @param WP_Post $payment_action
+ *
+ * @return array
+ */
+ function ( $settings_for_action, $payment_action ) use ( &$payment_action_by_id ) {
+ $payment_action_by_id[ $payment_action->ID ] = $payment_action;
+ $settings_for_action['layout'] = ! empty( $payment_action->post_content['layout'] ) ? $payment_action->post_content['layout'] : 'card_and_checkout';
+ return $settings_for_action;
+ },
+ 10,
+ 2
+ );
+
+ $action_settings = self::prepare_settings_for_js( $form_id );
+ $action_setting_match = false;
+
+ foreach ( $action_settings as $action ) {
+ $gateways = $action['gateways'];
+
+ if ( ! $gateways || in_array( 'paypal', (array) $gateways, true ) ) {
+ $action_setting_match = $action;
+ break;
+ }
+ }
+
+ if ( false === $action_setting_match || ! array_key_exists( $action_setting_match['id'], $payment_action_by_id ) ) {
+ return;
+ }
+
+ $action = $payment_action_by_id[ $action_setting_match['id'] ];
+
+ // Use capture for one-time payments and subscription for recurring payments.
+ $intent = $action->post_content['type'] === 'single' ? 'capture' : 'subscription';
+
+ /**
+ * Build the PayPal SDK URL with required parameters.
+ *
+ * - Subscriptions require intent=subscription.
+ * - Subscriptions also require vault=true.
+ */
+ $query_args = array(
+ 'client-id' => self::get_client_id(),
+ 'intent' => $intent,
+ 'currency' => strtoupper( $action->post_content['currency'] ?? 'USD' ),
+ 'merchant-id' => FrmPayPalLiteConnectHelper::get_merchant_id(),
+ 'enable-funding' => 'venmo,applepay',
+ );
+
+ if ( 'subscription' === $intent ) {
+ $query_args['vault'] = 'true';
+ }
+
+ $include_buttons = false;
+ $include_card_fields = false;
+ $include_messages = true;
+
+ switch ( $action->post_content['layout'] ?? 'card_and_checkout' ) {
+ case 'card_only':
+ $include_card_fields = true;
+ break;
+
+ case 'checkout_only':
+ $include_buttons = true;
+ break;
+
+ default:
+ $include_buttons = true;
+ $include_card_fields = true;
+ break;
+ }
+
+ switch ( $action->post_content['pay_later'] ?? 'auto' ) {
+ case 'off':
+ $query_args['disable-funding'] = 'paylater';
+ break;
+ case 'no-messaging':
+ // PayPal throws a TypeError: can't access property "PAGE_TYPE", trackingDetails is undefined error
+ // a lot of the time if you include messages. If you see this error, try using this 'no-messaging' option.
+ $include_messages = false;
+ break;
+ }
+
+ $components = array();
+
+ if ( $include_buttons ) {
+ $components[] = 'buttons';
+ $components[] = 'googlepay';
+ $components[] = 'applepay';
+ }
+
+ if ( $include_card_fields ) {
+ $components[] = 'card-fields';
+ }
+
+ if ( $include_messages ) {
+ $components[] = 'messages';
+ }
+
+ // Enables .isEligible checks.
+ $components[] = 'funding-eligibility';
+
+ // Required for radio button option logos.
+ $components[] = 'marks';
+
+ $query_args['components'] = implode( ',', $components );
+ $locale = self::get_paypal_locale();
+
+ if ( $locale ) {
+ $query_args['locale'] = str_replace( '-', '_', $locale );
+ }
+
+ /**
+ * Allow customization of the PayPal SDK URL query arguments.
+ *
+ * @since x.x
+ *
+ * @param array $query_args
+ * @param WP_Post $action
+ */
+ $query_args = apply_filters( 'frm_paypal_sdk_url_query_args', $query_args, $action );
+
+ $sdk_url = add_query_arg( $query_args, 'https://www.paypal.com/sdk/js' );
+
+ wp_register_script( 'paypal-sdk', $sdk_url, array(), null, false );
+ wp_register_script( 'apple-pay-sdk', 'https://applepay.cdn-apple.com/jsapi/1.latest/apple-pay-sdk.js', array(), null, false );
+
+ $has_break = FrmAppHelper::pro_is_installed() && (bool) FrmField::get_all_types_in_form( $form_id, 'break' );
+
+ add_filter(
+ 'script_loader_tag',
+ /**
+ * @param string $tag
+ * @param string $handle
+ *
+ * @return string
+ */
+ function ( $tag, $handle ) use ( $has_break ) {
+ if ( 'paypal-sdk' === $handle ) {
+ $attributes = ' async data-partner-attribution-id="' . esc_attr( FrmPayPalLiteConnectHelper::get_bn_code() ) . '"';
+ return str_replace( ' src=', $attributes . ' src=', $tag );
+ }
+
+ if ( in_array( $handle, array( 'apple-pay-sdk', 'google-pay' ), true ) ) {
+ return str_replace( ' src=', ' async src=', $tag );
+ }
+
+ if ( $has_break && 'formidable-paypal' === $handle ) {
+ return str_replace( ' src=', ' async src=', $tag );
+ }
+
+ return $tag;
+ },
+ 10,
+ 2
+ );
+
+ wp_enqueue_style(
+ 'formidable-paypal',
+ FrmPayPalLiteAppHelper::plugin_url() . 'css/frontend.css',
+ array(),
+ FrmAppHelper::plugin_version()
+ );
+
+ $dependencies = array( 'paypal-sdk', 'formidable' );
+
+ if ( $include_buttons ) {
+ $dependencies[] = 'apple-pay-sdk';
+ }
+
+ $script_url = FrmPayPalLiteAppHelper::plugin_url() . 'js/frontend.js';
+
+ wp_enqueue_script(
+ 'formidable-paypal',
+ $script_url,
+ $dependencies,
+ FrmAppHelper::plugin_version(),
+ false
+ );
+
+ if ( $include_buttons ) {
+ wp_enqueue_script(
+ 'google-pay',
+ 'https://pay.google.com/gp/p/js/pay.js',
+ array(),
+ '1.0',
+ false
+ );
+ }
+
+ $paypal_vars = array(
+ 'formId' => $form_id,
+ 'nonce' => wp_create_nonce( 'frm_paypal_ajax' ),
+ 'ajax' => esc_url_raw( FrmAppHelper::get_ajax_url() ),
+ 'settings' => $action_settings,
+ 'style' => self::get_style_for_js( $form_id ),
+ 'buttonStyle' => self::get_button_style_for_js( $action ),
+ 'imagesUrl' => FrmPayPalLiteAppHelper::plugin_url() . 'images/',
+ );
+
+ wp_localize_script( 'formidable-paypal', 'frmPayPalVars', $paypal_vars );
+ }
+
+ /**
+ * @since x.x
+ *
+ * @return string
+ */
+ private static function get_paypal_locale() { // phpcs:ignore Generic.Metrics.CyclomaticComplexity.MaxExceeded, SlevomatCodingStandard.Functions.FunctionLength.FunctionLength
+ $locale = str_replace( '_', '-', get_locale() );
+ $parts = explode( '_', $locale );
+ $lang = strtolower( $parts[0] );
+ $country = isset( $parts[1] ) ? strtoupper( $parts[1] ) : '';
+
+ switch ( $lang ) {
+ case 'ar':
+ // Arabic
+ $countries = array( 'DZ', 'BH', 'EG', 'JO', 'KW', 'MA', 'OM', 'QA', 'SA', 'TN', 'AE', 'YE' );
+ break;
+
+ case 'bg':
+ // Bulgarian
+ $countries = array( 'BG' );
+ break;
+
+ case 'cs':
+ // Czech
+ $countries = array( 'CZ' );
+ break;
+
+ case 'da':
+ // Danish
+ $countries = array( 'DK', 'FO', 'GL' );
+ break;
+
+ case 'de':
+ // German
+ $countries = array( 'AT', 'DE', 'LU', 'CH' );
+ break;
+
+ case 'el':
+ // Greek
+ $countries = array( 'GR' );
+ break;
+
+ case 'en':
+ // English
+ $countries = array(
+ 'AL',
+ 'DZ',
+ 'AD',
+ 'AO',
+ 'AI',
+ 'AG',
+ 'AR',
+ 'AM',
+ 'AW',
+ 'AU',
+ 'AT',
+ 'AZ',
+ 'BS',
+ 'BH',
+ 'BB',
+ 'BY',
+ 'BE',
+ 'BZ',
+ 'BJ',
+ 'BM',
+ 'BT',
+ 'BO',
+ 'BA',
+ 'BW',
+ 'BR',
+ 'VG',
+ 'BN',
+ 'BG',
+ 'BF',
+ 'BI',
+ 'KH',
+ 'CM',
+ 'CA',
+ 'CV',
+ 'KY',
+ 'TD',
+ 'CL',
+ 'C2',
+ 'CN',
+ 'CO',
+ 'KM',
+ 'CG',
+ 'CD',
+ 'CK',
+ 'CR',
+ 'CI',
+ 'HR',
+ 'CY',
+ 'CZ',
+ 'DK',
+ 'DJ',
+ 'DM',
+ 'DO',
+ 'EC',
+ 'EG',
+ 'SV',
+ 'ER',
+ 'EE',
+ 'SZ',
+ 'ET',
+ 'FK',
+ 'FO',
+ 'FJ',
+ 'FI',
+ 'FR',
+ 'GF',
+ 'PF',
+ 'GA',
+ 'GM',
+ 'GE',
+ 'DE',
+ 'GI',
+ 'GR',
+ 'GL',
+ 'GD',
+ 'GP',
+ 'GT',
+ 'GN',
+ 'GW',
+ 'GY',
+ 'HN',
+ 'HK',
+ 'HU',
+ 'IS',
+ 'IN',
+ 'ID',
+ 'IE',
+ 'IL',
+ 'IT',
+ 'JM',
+ 'JP',
+ 'JO',
+ 'KZ',
+ 'KE',
+ 'KI',
+ 'KW',
+ 'KG',
+ 'LA',
+ 'LV',
+ 'LS',
+ 'LI',
+ 'LT',
+ 'LU',
+ 'MG',
+ 'MW',
+ 'MY',
+ 'MV',
+ 'ML',
+ 'MT',
+ 'MH',
+ 'MQ',
+ 'MR',
+ 'MU',
+ 'MX',
+ 'FM',
+ 'MD',
+ 'MC',
+ 'MN',
+ 'ME',
+ 'MS',
+ 'MA',
+ 'MZ',
+ 'NA',
+ 'NR',
+ 'NP',
+ 'NL',
+ 'AN',
+ 'NC',
+ 'NZ',
+ 'NI',
+ 'NE',
+ 'NG',
+ 'NU',
+ 'NF',
+ 'MK',
+ 'NO',
+ 'OM',
+ 'PW',
+ 'PA',
+ 'PG',
+ 'PY',
+ 'PE',
+ 'PH',
+ 'PN',
+ 'PL',
+ 'PT',
+ 'QA',
+ 'RE',
+ 'RO',
+ 'RU',
+ 'RW',
+ 'WS',
+ 'SM',
+ 'ST',
+ 'SA',
+ 'SN',
+ 'RS',
+ 'SC',
+ 'SL',
+ 'SG',
+ 'SK',
+ 'SI',
+ 'SB',
+ 'SO',
+ 'ZA',
+ 'KR',
+ 'ES',
+ 'LK',
+ 'SH',
+ 'KN',
+ 'LC',
+ 'PM',
+ 'VC',
+ 'SR',
+ 'SJ',
+ 'SE',
+ 'CH',
+ 'TW',
+ 'TJ',
+ 'TZ',
+ 'TH',
+ 'TG',
+ 'TO',
+ 'TT',
+ 'TN',
+ 'TR',
+ 'TM',
+ 'TC',
+ 'TV',
+ 'UG',
+ 'UA',
+ 'AE',
+ 'GB',
+ 'US',
+ 'UY',
+ 'VU',
+ 'VA',
+ 'VE',
+ 'VN',
+ 'WF',
+ 'YE',
+ 'ZM',
+ 'ZW',
+ );
+ break;
+
+ case 'es':
+ // Spanish
+ $countries = array(
+ 'DZ',
+ 'AD',
+ 'AO',
+ 'AI',
+ 'AG',
+ 'AR',
+ 'AM',
+ 'AW',
+ 'AZ',
+ 'BS',
+ 'BH',
+ 'BB',
+ 'BZ',
+ 'BJ',
+ 'BM',
+ 'BO',
+ 'BW',
+ 'VG',
+ 'BF',
+ 'BI',
+ 'CV',
+ 'KY',
+ 'TD',
+ 'CL',
+ 'CO',
+ 'KM',
+ 'CG',
+ 'CD',
+ 'CK',
+ 'CR',
+ 'DJ',
+ 'DM',
+ 'DO',
+ 'EC',
+ 'EG',
+ 'SV',
+ 'ER',
+ 'SZ',
+ 'ET',
+ 'FK',
+ 'FO',
+ 'FJ',
+ 'PF',
+ 'GA',
+ 'GM',
+ 'GE',
+ 'GI',
+ 'GL',
+ 'GD',
+ 'GT',
+ 'GN',
+ 'GW',
+ 'GY',
+ 'HN',
+ 'IE',
+ 'JM',
+ 'JO',
+ 'KZ',
+ 'KE',
+ 'KI',
+ 'KW',
+ 'KG',
+ 'LS',
+ 'LI',
+ 'LU',
+ 'MG',
+ 'MW',
+ 'ML',
+ 'MH',
+ 'MR',
+ 'MU',
+ 'MX',
+ 'MS',
+ 'MA',
+ 'MZ',
+ 'NA',
+ 'NR',
+ 'AN',
+ 'NC',
+ 'NZ',
+ 'NI',
+ 'NE',
+ 'NU',
+ 'NF',
+ 'OM',
+ 'PW',
+ 'PA',
+ 'PG',
+ 'PY',
+ 'PE',
+ 'PN',
+ 'QA',
+ 'RW',
+ 'SM',
+ 'ST',
+ 'SA',
+ 'SN',
+ 'RS',
+ 'SC',
+ 'SL',
+ 'SB',
+ 'SO',
+ 'ZA',
+ 'ES',
+ 'SH',
+ 'KN',
+ 'LC',
+ 'PM',
+ 'VC',
+ 'SR',
+ 'SJ',
+ 'TJ',
+ 'TZ',
+ 'TG',
+ 'TT',
+ 'TN',
+ 'TM',
+ 'TC',
+ 'TV',
+ 'UG',
+ 'UA',
+ 'AE',
+ 'US',
+ 'UY',
+ 'VU',
+ 'VA',
+ 'VE',
+ 'WF',
+ 'YE',
+ 'ZM',
+ );
+ break;
+
+ case 'et':
+ // Estonian
+ $countries = array( 'EE' );
+ break;
+
+ case 'fi':
+ // Finnish
+ $countries = array( 'FI' );
+ break;
+
+ case 'fr':
+ // French
+ $countries = array(
+ 'DZ',
+ 'AD',
+ 'AO',
+ 'AI',
+ 'AG',
+ 'AM',
+ 'AW',
+ 'AZ',
+ 'BS',
+ 'BH',
+ 'BB',
+ 'BE',
+ 'BZ',
+ 'BJ',
+ 'BM',
+ 'BO',
+ 'BW',
+ 'VG',
+ 'BF',
+ 'BI',
+ 'CM',
+ 'CA',
+ 'CV',
+ 'KY',
+ 'TD',
+ 'CL',
+ 'CO',
+ 'KM',
+ 'CG',
+ 'CD',
+ 'CK',
+ 'CR',
+ 'CI',
+ 'DJ',
+ 'DM',
+ 'DO',
+ 'EC',
+ 'EG',
+ 'SV',
+ 'ER',
+ 'SZ',
+ 'ET',
+ 'FK',
+ 'FO',
+ 'FJ',
+ 'FR',
+ 'GF',
+ 'PF',
+ 'GA',
+ 'GM',
+ 'GE',
+ 'GI',
+ 'GL',
+ 'GD',
+ 'GP',
+ 'GT',
+ 'GN',
+ 'GW',
+ 'GY',
+ 'HN',
+ 'IE',
+ 'JM',
+ 'JO',
+ 'KZ',
+ 'KE',
+ 'KI',
+ 'KW',
+ 'KG',
+ 'LS',
+ 'LI',
+ 'LU',
+ 'MG',
+ 'MW',
+ 'ML',
+ 'MH',
+ 'MQ',
+ 'MR',
+ 'MU',
+ 'YT',
+ 'MC',
+ 'MS',
+ 'MA',
+ 'MZ',
+ 'NA',
+ 'NR',
+ 'AN',
+ 'NC',
+ 'NZ',
+ 'NI',
+ 'NE',
+ 'NU',
+ 'NF',
+ 'OM',
+ 'PW',
+ 'PA',
+ 'PG',
+ 'PE',
+ 'PN',
+ 'QA',
+ 'RE',
+ 'RW',
+ 'SC',
+ 'SM',
+ 'ST',
+ 'SA',
+ 'SN',
+ 'RS',
+ 'SL',
+ 'SB',
+ 'SO',
+ 'ZA',
+ 'SH',
+ 'KN',
+ 'LC',
+ 'PM',
+ 'VC',
+ 'SR',
+ 'SJ',
+ 'CH',
+ 'TJ',
+ 'TZ',
+ 'TG',
+ 'TT',
+ 'TN',
+ 'TM',
+ 'TC',
+ 'TV',
+ 'UG',
+ 'UA',
+ 'AE',
+ 'US',
+ 'UY',
+ 'VU',
+ 'VA',
+ 'VE',
+ 'WF',
+ 'YE',
+ 'ZM',
+ );
+ break;
+
+ case 'he':
+ // Hebrew
+ $countries = array( 'IL' );
+ break;
+
+ case 'hu':
+ // Hungarian
+ $countries = array( 'HU' );
+ break;
+
+ case 'id':
+ // Indonesian
+ $countries = array( 'ID' );
+ break;
+
+ case 'it':
+ // Italian
+ $countries = array( 'IT' );
+ break;
+
+ case 'ja':
+ // Japanese
+ $countries = array( 'JP' );
+ break;
+
+ case 'ko':
+ // Korean
+ $countries = array( 'KR' );
+ break;
+
+ case 'lt':
+ // Lithuanian
+ $countries = array( 'LT' );
+ break;
+
+ case 'lv':
+ // Latvian
+ $countries = array( 'LV' );
+ break;
+
+ case 'ms':
+ // Malay
+ $countries = array( 'BN', 'MY' );
+ break;
+
+ case 'nl':
+ // Dutch
+ $countries = array( 'BE', 'NL' );
+ break;
+
+ case 'no':
+ // Norwegian
+ $countries = array( 'NO' );
+ break;
+
+ case 'pl':
+ // Polish
+ $countries = array( 'PL' );
+ break;
+
+ case 'pt':
+ // Portuguese
+ $countries = array( 'BR', 'PT' );
+ break;
+
+ case 'ro':
+ // Romanian
+ $countries = array( 'RO' );
+ break;
+
+ case 'ru':
+ // Russian
+ $countries = array( 'EE', 'LV', 'LT', 'RU', 'UA' );
+ break;
+
+ case 'si':
+ // Sinhala
+ $countries = array( 'LK' );
+ break;
+
+ case 'sk':
+ // Slovak
+ $countries = array( 'SK' );
+ break;
+
+ case 'sl':
+ // Slovenian
+ $countries = array( 'SI' );
+ break;
+
+ case 'sq':
+ // Albanian
+ $countries = array( 'AL' );
+ break;
+
+ case 'sv':
+ // Swedish
+ $countries = array( 'SE' );
+ break;
+
+ case 'th':
+ // Thai
+ $countries = array( 'TH' );
+ break;
+
+ case 'tl':
+ // Tagalog
+ $countries = array( 'PH' );
+ break;
+
+ case 'tr':
+ // Turkish
+ $countries = array( 'TR' );
+ break;
+
+ case 'vi':
+ // Vietnamese
+ $countries = array( 'VN' );
+ break;
+
+ case 'zh':
+ // Chinese
+ $countries = array(
+ 'C2',
+ 'CN',
+ 'HK',
+ 'TW',
+ 'DZ',
+ 'AD',
+ 'AO',
+ 'AI',
+ 'AG',
+ 'AM',
+ 'AW',
+ 'AZ',
+ 'BS',
+ 'BH',
+ 'BB',
+ 'BZ',
+ 'BJ',
+ 'BM',
+ 'BO',
+ 'BW',
+ 'VG',
+ 'BF',
+ 'BI',
+ 'CV',
+ 'KY',
+ 'TD',
+ 'CL',
+ 'CO',
+ 'KM',
+ 'CG',
+ 'CD',
+ 'CK',
+ 'CR',
+ 'DJ',
+ 'DM',
+ 'DO',
+ 'EC',
+ 'EG',
+ 'SV',
+ 'ER',
+ 'SZ',
+ 'ET',
+ 'FK',
+ 'FO',
+ 'FJ',
+ 'PF',
+ 'GA',
+ 'GM',
+ 'GE',
+ 'GI',
+ 'GL',
+ 'GD',
+ 'GT',
+ 'GN',
+ 'GW',
+ 'GY',
+ 'HN',
+ 'IE',
+ 'JM',
+ 'JO',
+ 'KZ',
+ 'KE',
+ 'KI',
+ 'KW',
+ 'KG',
+ 'LS',
+ 'LI',
+ 'LT',
+ 'LU',
+ 'MG',
+ 'MW',
+ 'ML',
+ 'MH',
+ 'MR',
+ 'MU',
+ 'MS',
+ 'MA',
+ 'MZ',
+ 'NA',
+ 'NR',
+ 'AN',
+ 'NC',
+ 'NZ',
+ 'NI',
+ 'NE',
+ 'NU',
+ 'NF',
+ 'OM',
+ 'PW',
+ 'PA',
+ 'PG',
+ 'PE',
+ 'PN',
+ 'QA',
+ 'RW',
+ 'SM',
+ 'ST',
+ 'SA',
+ 'SN',
+ 'RS',
+ 'SC',
+ 'SL',
+ 'SB',
+ 'SO',
+ 'ZA',
+ 'SH',
+ 'KN',
+ 'LC',
+ 'PM',
+ 'VC',
+ 'SR',
+ 'SJ',
+ 'TJ',
+ 'TZ',
+ 'TG',
+ 'TT',
+ 'TN',
+ 'TM',
+ 'TC',
+ 'TV',
+ 'UG',
+ 'UA',
+ 'AE',
+ 'US',
+ 'UY',
+ 'VU',
+ 'VA',
+ 'VE',
+ 'WF',
+ 'YE',
+ 'ZM',
+ );
+ break;
+
+ default:
+ $countries = array();
+ break;
+ }//end switch
+
+ if ( $country && in_array( $country, $countries, true ) ) {
+ return $lang . '-' . $country;
+ }
+
+ return 'en-US';
+ }
+
+ /**
+ * Get the style for the PayPal form.
+ *
+ * @param int $form_id
+ *
+ * @return array
+ */
+ public static function get_style_for_js( $form_id ) {
+ $settings = self::get_style_settings_for_form( $form_id );
+
+ $style = array(
+ 'body' => array(
+ 'padding' => 0,
+ ),
+ 'input' => array(
+ 'font-size' => $settings['field_font_size'],
+ 'color' => $settings['text_color'],
+ 'font-weight' => $settings['field_weight'],
+ 'padding' => $settings['field_pad'],
+ 'line-height' => 1.3,
+ 'border' => self::get_border_shorthand( $settings ),
+ 'border-radius' => self::get_border_radius( $settings ),
+ ),
+ 'input::placeholder' => array(
+ 'color' => $settings['text_color_disabled'],
+ ),
+ '.invalid' => array(
+ 'color' => $settings['border_color_error'],
+ ),
+ );
+
+ if ( ! empty( $settings['font'] ) ) {
+ $style['input']['font-family'] = $settings['font'];
+ }
+
+ /**
+ * Filter the PayPal card field styles.
+ *
+ * @since x.x
+ *
+ * @param array $style
+ * @param array $settings
+ * @param int $form_id
+ */
+ return apply_filters( 'frm_paypal_style', $style, $settings, $form_id );
+ }
+
+ /**
+ * Get PayPal button style configuration from form action settings.
+ * Documentation at https://developer.paypal.com/sdk/js/reference/#style
+ *
+ * @since x.x
+ *
+ * @param WP_Post $form_action The form action containing button settings.
+ *
+ * @return array The style configuration array for PayPal button.
+ */
+ private static function get_button_style_for_js( $form_action ) {
+ $button_color = $form_action->post_content['button_color'] ?? 'default';
+ $button_label = $form_action->post_content['button_label'] ?? 'paypal';
+ $button_border_radius = $form_action->post_content['button_border_radius'] ?? 10;
+
+ $style_for_js = array(
+ 'layout' => 'vertical',
+ 'color' => $button_color,
+ 'label' => $button_label,
+ 'borderRadius' => (int) $button_border_radius,
+ 'height' => 40,
+ );
+
+ // Unset the color so PayPal can use its defaults.
+ // Many buttons have different colors
+ if ( 'default' === $button_color ) {
+ unset( $style_for_js['color'] );
+ }
+
+ /**
+ * @since x.x
+ *
+ * @param array $style_for_js
+ * @param WP_Post $form_action
+ */
+ return apply_filters( 'frm_paypal_button_style', $style_for_js, $form_action );
+ }
+
+ /**
+ * Get and format the style settings for JavaScript to use with the get_style function.
+ *
+ * @param int $form_id
+ *
+ * @return array
+ */
+ private static function get_style_settings_for_form( $form_id ) {
+ if ( ! $form_id ) {
+ return array();
+ }
+
+ $style = FrmStylesController::get_form_style( $form_id );
+
+ if ( ! $style ) {
+ return array();
+ }
+
+ $settings = FrmStylesHelper::get_settings_for_output( $style );
+ $disallowed = array( ';', ':', '!important' );
+
+ foreach ( $settings as $k => $s ) {
+ if ( is_string( $s ) ) {
+ $settings[ $k ] = str_replace( $disallowed, '', $s );
+ }
+ }
+
+ return $settings;
+ }
+
+ /**
+ * Get the border width for PayPal card fields.
+ *
+ * @since x.x
+ *
+ * @param array $settings
+ *
+ * @return string
+ */
+ private static function get_border_width( $settings ) {
+ if ( ! empty( $settings['field_shape_type'] ) && 'underline' === $settings['field_shape_type'] ) {
+ return '0 0 ' . $settings['field_border_width'] . ' 0';
+ }
+ return $settings['field_border_width'];
+ }
+
+ /**
+ * Get the border radius for PayPal card fields.
+ *
+ * @since x.x
+ *
+ * @param array $settings
+ *
+ * @return string
+ */
+ private static function get_border_radius( $settings ) {
+ if ( ! empty( $settings['field_shape_type'] ) ) {
+ switch ( $settings['field_shape_type'] ) {
+ case 'underline':
+ case 'regular':
+ return '0px';
+ case 'circle':
+ return '30px';
+ }
+ }
+ return $settings['border_radius'];
+ }
+
+ /**
+ * Get the border shorthand for PayPal card fields.
+ *
+ * @since x.x
+ *
+ * @param array $settings
+ *
+ * @return string
+ */
+ private static function get_border_shorthand( $settings ) {
+ $width = self::get_border_width( $settings );
+ $style = $settings['field_border_style'];
+ $color = $settings['border_color'];
+
+ return "{$width} {$style} {$color}";
+ }
+
+ /**
+ * If the names are being used on the CC fields,
+ * make sure it doesn't prevent the submission if PayPal has approved.
+ *
+ * @since x.x
+ *
+ * @param array $errors
+ * @param stdClass $field
+ *
+ * @return array
+ */
+ public static function remove_cc_validation( $errors, $field ) {
+ $paypal_order_id = FrmAppHelper::get_post_param( 'paypal_order_id', '', 'sanitize_text_field' );
+ $paypal_subscription_id = FrmAppHelper::get_post_param( 'paypal_subscription_id', '', 'sanitize_text_field' );
+
+ if ( ! $paypal_order_id && ! $paypal_subscription_id ) {
+ return $errors;
+ }
+
+ return FrmTransLiteActionsController::remove_cc_errors( $errors, $field );
+ }
+
+ /**
+ * @since x.x
+ *
+ * @return void
+ */
+ public static function actions_js() {
+ wp_enqueue_script(
+ 'frm_paypal_admin',
+ FrmPayPalLiteAppHelper::plugin_url() . 'js/action.js',
+ array( 'wp-hooks', 'wp-i18n' ),
+ FrmAppHelper::plugin_version()
+ );
+ }
+
+ /**
+ * Modify the new action post data to use the payment action type when the PayPal plugin is not active.
+ * This works better than having it disabled even when PayPal is supported.
+ *
+ * @since x.x
+ *
+ * @return void
+ */
+ public static function maybe_modify_new_action_post_data() {
+ $action_type = FrmAppHelper::get_param( 'type', '', 'post', 'sanitize_text_field' );
+
+ if ( 'paypal-legacy' === $action_type ) {
+ $_POST['type'] = 'paypal';
+ return;
+ }
+
+ if ( ! in_array( $action_type, array( 'paypal', 'stripe', 'square' ), true ) ) {
+ return;
+ }
+
+ $_POST['type'] = 'payment';
+
+ add_filter(
+ 'frm_form_payment_action_settings',
+ /**
+ * @param WP_Post $action_settings
+ *
+ * @return WP_Post
+ */
+ function ( $action_settings ) use ( $action_type ) {
+ return self::set_gateway_as_default( $action_settings, $action_type );
+ }
+ );
+ }
+
+ /**
+ * Set the gateway to PayPal as the default.
+ *
+ * @param WP_Post $action_settings
+ * @param string $action_type
+ *
+ * @return WP_Post
+ */
+ private static function set_gateway_as_default( $action_settings, $action_type ) {
+ $action_settings->post_content['gateway'] = array( $action_type );
+ return $action_settings;
+ }
+
+ /**
+ * Print additional options for Stripe action settings.
+ *
+ * @param array $atts
+ *
+ * @return void
+ */
+ public static function add_action_options( $atts ) {
+ $form_action = $atts['form_action'];
+ $action_control = $atts['action_control'];
+
+ include FrmPayPalLiteAppHelper::plugin_path() . '/views/settings/action-settings-options.php';
+ }
+
+ /**
+ * Print additional options for button settings.
+ *
+ * @since x.x
+ *
+ * @param array|FrmFormAction $args_or_action_control Either the args array with form_action and action_control, or the action_control object.
+ * @param WP_Post $form_action The form action object (when called directly).
+ *
+ * @return void
+ */
+ public static function add_button_settings_section( $args_or_action_control, $form_action = null ) {
+ if ( is_array( $args_or_action_control ) ) {
+ $form_action = $args_or_action_control['form_action'];
+ $action_control = $args_or_action_control['action_control'];
+ } else {
+ $action_control = $args_or_action_control;
+ }
+
+ include FrmPayPalLiteAppHelper::plugin_path() . '/views/settings/button-settings.php';
+ }
+
+ /**
+ * Add PayPal subscription settings (product name and product type) after payment type.
+ *
+ * @since x.x
+ *
+ * @param array $args Arguments containing form_action and action_control.
+ *
+ * @return void
+ */
+ public static function add_paypal_subscription_settings_from_hook( $args ) {
+ $form_action = $args['form_action'];
+ $action_control = $args['action_control'];
+
+ $product_type_value = $form_action->post_content['product_type'] ?? '';
+ ?>
+
+
+
+
+
+
+
+
+
+
+
+
+
';
+ }
+}
diff --git a/paypal/controllers/FrmPayPalLiteAppController.php b/paypal/controllers/FrmPayPalLiteAppController.php
new file mode 100644
index 0000000000..ac506b2a3a
--- /dev/null
+++ b/paypal/controllers/FrmPayPalLiteAppController.php
@@ -0,0 +1,862 @@
+ 'PayPal',
+ 'user_label' => __( 'Payment', 'formidable' ),
+ 'class' => 'PayPalLite',
+ 'recurring' => true,
+ 'include' => array(
+ 'billing_first_name',
+ 'billing_last_name',
+ 'credit_card',
+ 'billing_address',
+ ),
+ );
+ return $gateways;
+ }
+
+ /**
+ * Handle the request to initialize with PayPal Api
+ */
+ public static function handle_oauth() {
+ FrmAppHelper::permission_check( 'frm_change_settings' );
+
+ if ( ! check_admin_referer( 'frm_ajax', 'nonce' ) ) {
+ wp_send_json_error();
+ }
+
+ $redirect_url = FrmPayPalLiteConnectHelper::get_oauth_redirect_url();
+
+ if ( false === $redirect_url ) {
+ wp_send_json_error( 'Unable to connect to PayPal successfully' );
+ }
+
+ $response_data = array(
+ 'redirect_url' => $redirect_url,
+ );
+ wp_send_json_success( $response_data );
+ }
+
+ public static function handle_disconnect() {
+ FrmAppHelper::permission_check( 'frm_change_settings' );
+
+ if ( ! check_admin_referer( 'frm_ajax', 'nonce' ) ) {
+ wp_send_json_error();
+ }
+
+ FrmPayPalLiteConnectHelper::handle_disconnect();
+ wp_send_json_success();
+ }
+
+ /**
+ * Get the current amount for a PayPal action via AJAX.
+ * Used to update the Pay Later messaging when price fields change.
+ *
+ * @since x.x
+ *
+ * @return void
+ */
+ public static function get_amount() {
+ check_ajax_referer( 'frm_paypal_ajax', 'nonce' );
+
+ $form_id = FrmAppHelper::get_post_param( 'form_id', 0, 'absint' );
+
+ if ( ! $form_id ) {
+ wp_send_json_error( __( 'Invalid form ID', 'formidable' ) );
+ }
+
+ $actions = FrmPayPalLiteActionsController::get_actions_before_submit( $form_id );
+
+ if ( ! $actions ) {
+ wp_send_json_error( __( 'No PayPal actions found for this form', 'formidable' ) );
+ }
+
+ $action = reset( $actions );
+ $amount = self::get_amount_value_for_verification( $action );
+
+ wp_send_json_success( array( 'amount' => $amount ) );
+ }
+
+ /**
+ * Extract pricing data from posted form values.
+ *
+ * @since x.x
+ *
+ * @param int $form_id The form ID.
+ *
+ * @return array Array of products with prices and quantities.
+ */
+ private static function get_pricing_data_from_posted_values( $form_id ) {
+ $products = array();
+ $fields = FrmField::get_all_for_form( $form_id );
+
+ if ( ! $fields ) {
+ return $products;
+ }
+
+ // phpcs:ignore WordPress.Security.NonceVerification.Missing
+ $posted_data = $_POST['item_meta'] ?? array();
+
+ foreach ( $fields as $field ) {
+ if ( ! in_array( $field->type, array( 'product', 'quantity', 'total' ), true ) ) {
+ continue;
+ }
+
+ $field_id = $field->id;
+ $value = $posted_data[ $field_id ] ?? '';
+
+ if ( ! $value ) {
+ continue;
+ }
+
+ if ( 'product' === $field->type ) {
+ $product_field = FrmFieldFactory::get_field_object( $field );
+
+ if ( method_exists( $product_field, 'get_posted_price' ) ) {
+ $price = $product_field->get_posted_price( $value );
+
+ if ( $price ) {
+ $products[] = array(
+ 'name' => $field->name,
+ 'price' => is_array( $price ) ? array_sum( $price ) : $price,
+ 'quantity' => 1,
+ 'type' => 'product',
+ 'field_id' => $field_id,
+ );
+ }
+ }
+ } elseif ( 'quantity' === $field->type ) {
+ $quantity = is_numeric( $value ) ? (int) $value : 1;
+ // Quantity fields are linked to product fields via product_field setting
+ $product_field_ids = FrmField::get_option( $field, 'product_field' );
+
+ if ( $product_field_ids ) {
+ // This quantity will be associated with its product field
+ // We'll handle the association in the product processing
+ $products[] = array(
+ 'name' => $field->name,
+ 'price' => 0,
+ // Quantity fields don't have price
+ 'quantity' => $quantity,
+ 'type' => 'quantity',
+ 'product_field_ids' => (array) $product_field_ids,
+ );
+ }
+ }//end if
+ }//end foreach
+
+ // Associate quantity fields with their products
+ $final_products = array();
+ $product_quantities = array();
+
+ foreach ( $products as $item ) {
+ if ( 'quantity' !== $item['type'] ) {
+ continue;
+ }
+
+ foreach ( $item['product_field_ids'] as $product_field_id ) {
+ $product_quantities[ $product_field_id ] = $item['quantity'];
+ }
+ }
+
+ foreach ( $products as $item ) {
+ if ( 'product' !== $item['type'] ) {
+ continue;
+ }
+
+ $quantity = $product_quantities[ $item['field_id'] ] ?? 1;
+ $final_products[] = array(
+ 'name' => $item['name'],
+ 'price' => $item['price'],
+ 'quantity' => $quantity,
+ );
+ }
+
+ return $final_products;
+ }
+
+ /**
+ * Create a PayPal order via AJAX.
+ */
+ public static function create_order() {
+ check_ajax_referer( 'frm_paypal_ajax', 'nonce' );
+
+ // Check if PayPal is connected before attempting to create an order.
+ $connection_check = self::check_paypal_connection();
+ if ( is_wp_error( $connection_check ) ) {
+ wp_send_json_error( $connection_check->get_error_message() );
+ }
+
+ $form_id = FrmAppHelper::get_post_param( 'form_id', 0, 'absint' );
+
+ if ( ! $form_id ) {
+ wp_send_json_error( __( 'Invalid form ID', 'formidable' ) );
+ }
+
+ $payment_source = FrmAppHelper::get_post_param( 'payment_source', '', 'sanitize_text_field' );
+
+ if ( ! $payment_source ) {
+ wp_send_json_error( __( 'No payment source provided', 'formidable' ) );
+ }
+
+ if ( ! in_array( $payment_source, self::get_valid_payment_sources(), true ) ) {
+ wp_send_json_error( __( 'Invalid payment source', 'formidable' ) );
+ }
+
+ $actions = FrmPayPalLiteActionsController::get_actions_before_submit( $form_id );
+
+ if ( ! $actions ) {
+ wp_send_json_error( __( 'No PayPal actions found for this form', 'formidable' ) );
+ }
+
+ $action = reset( $actions );
+ $amount = self::get_amount_value_for_verification( $action );
+ $payer = self::get_payer_data_from_posted_values( $action );
+ $shipping = self::get_shipping_data_from_posted_values( $action );
+ $shipping_preference = self::get_shipping_preference( $action );
+ $pricing_data = self::get_pricing_data_from_posted_values( $form_id );
+
+ // PayPal expects the amount in a format like 10.00, so format it.
+ $amount = number_format( floatval( $amount ), 2, '.', '' );
+ $currency = strtoupper( $action->post_content['currency'] );
+
+ $order_response = FrmPayPalLiteConnectHelper::create_order( $amount, $currency, $payment_source, $payer, $shipping_preference, $pricing_data, $shipping );
+
+ if ( class_exists( 'FrmLog' ) ) {
+ $log = new FrmLog();
+ $log->add(
+ array(
+ 'title' => 'PayPal Order Response',
+ 'content' => print_r( $order_response, true ),
+ )
+ );
+ }
+
+ if ( false === $order_response ) {
+ $error = FrmPayPalLiteConnectHelper::get_latest_error_from_paypal_api();
+ wp_send_json_error( self::format_paypal_error( $error, 'Failed to create PayPal order' ) );
+ }
+
+ if ( ! isset( $order_response->order_id ) ) {
+ // Check if the response is a structured error with debug_id
+ if ( isset( $order_response->message ) && isset( $order_response->debug_id ) ) {
+ wp_send_json_error( self::format_paypal_error( $order_response->message . '{{debug_id:' . $order_response->debug_id . '}}', 'Failed to create PayPal order' ) );
+ }
+ wp_send_json_error( 'Failed to create PayPal order' );
+ }
+
+ wp_send_json_success( array( 'orderID' => $order_response->order_id ) );
+ }
+
+ /**
+ * @since x.x
+ *
+ * @param WP_Post $action
+ *
+ * @return array
+ */
+ private static function get_payer_data_from_posted_values( $action ) {
+ $email_setting = $action->post_content['email'];
+ $first_name_setting = $action->post_content['billing_first_name'];
+ $last_name_setting = $action->post_content['billing_last_name'];
+ $address_setting = $action->post_content['billing_address'];
+
+ $entry = self::generate_false_entry();
+ $first_name = $first_name_setting && isset( $entry->metas[ $first_name_setting ] ) ? $entry->metas[ $first_name_setting ] : '';
+ $last_name = $last_name_setting && isset( $entry->metas[ $last_name_setting ] ) ? $entry->metas[ $last_name_setting ] : '';
+ $address = $address_setting && isset( $entry->metas[ $address_setting ] ) ? $entry->metas[ $address_setting ] : '';
+
+ if ( is_array( $first_name ) && isset( $first_name['first'] ) ) {
+ $first_name = $first_name['first'];
+ }
+
+ if ( is_array( $last_name ) && isset( $last_name['last'] ) ) {
+ $last_name = $last_name['last'];
+ }
+
+ $payer = array();
+
+ if ( $first_name && $last_name ) {
+ $payer['name'] = array(
+ 'given_name' => $first_name,
+ 'surname' => $last_name,
+ );
+ }
+
+ if ( $email_setting ) {
+ $shortcode_atts = array(
+ 'entry' => $entry,
+ 'form' => $action->menu_order,
+ 'value' => $email_setting,
+ );
+ $payer['email_address'] = FrmTransLiteAppHelper::process_shortcodes( $shortcode_atts );
+ }
+
+ self::maybe_add_address_data( $payer, $address, (int) $address_setting );
+
+ return $payer;
+ }
+
+ /**
+ * Build shipping data from the action's shipping field settings.
+ *
+ * @since x.x
+ *
+ * @param WP_Post $action
+ *
+ * @return array
+ */
+ private static function get_shipping_data_from_posted_values( $action ) {
+ $settings = $action->post_content;
+
+ $email_setting = ! empty( $settings['shipping_email'] ) ? $settings['shipping_email'] : '';
+ $first_name_setting = ! empty( $settings['shipping_first_name'] ) ? $settings['shipping_first_name'] : '';
+ $last_name_setting = ! empty( $settings['shipping_last_name'] ) ? $settings['shipping_last_name'] : '';
+ $address_setting = ! empty( $settings['shipping_address'] ) ? $settings['shipping_address'] : '';
+
+ if ( ! $email_setting && ! $first_name_setting && ! $last_name_setting && ! $address_setting ) {
+ return array();
+ }
+
+ $entry = self::generate_false_entry();
+ $first_name = $first_name_setting && isset( $entry->metas[ $first_name_setting ] ) ? $entry->metas[ $first_name_setting ] : '';
+ $last_name = $last_name_setting && isset( $entry->metas[ $last_name_setting ] ) ? $entry->metas[ $last_name_setting ] : '';
+
+ if ( is_array( $first_name ) && isset( $first_name['first'] ) ) {
+ $first_name = $first_name['first'];
+ }
+
+ if ( is_array( $last_name ) && isset( $last_name['last'] ) ) {
+ $last_name = $last_name['last'];
+ }
+
+ $shipping = array();
+
+ if ( $email_setting ) {
+ $shortcode_atts = array(
+ 'entry' => $entry,
+ 'form' => $action->menu_order,
+ 'value' => $email_setting,
+ );
+ $email = FrmTransLiteAppHelper::process_shortcodes( $shortcode_atts );
+ if ( $email ) {
+ $shipping['email_address'] = $email;
+ }
+ }
+
+ if ( $first_name || $last_name ) {
+ $shipping['name'] = array(
+ 'full_name' => trim( $first_name . ' ' . $last_name ),
+ );
+ }
+
+ if ( $address_setting ) {
+ $address = isset( $entry->metas[ $address_setting ] ) ? $entry->metas[ $address_setting ] : '';
+ $formatted_address = self::format_address_for_paypal( $address, (int) $address_setting );
+
+ if ( $formatted_address ) {
+ $shipping['address'] = $formatted_address;
+ }
+ }
+
+ return $shipping;
+ }
+
+ /**
+ * Format a Formidable address field value into a PayPal address array.
+ *
+ * @since x.x
+ *
+ * @param mixed $address The address field value.
+ * @param int $address_field_id The field ID.
+ *
+ * @return array|false The formatted address array, or false if invalid.
+ */
+ private static function format_address_for_paypal( $address, $address_field_id ) {
+ if ( ! is_array( $address ) || ! isset( $address['line1'] ) || ! is_callable( 'FrmProAddressesController::get_country_code' ) ) {
+ return false;
+ }
+
+ $address_field = FrmField::getOne( $address_field_id );
+
+ if ( ! $address_field ) {
+ return false;
+ }
+
+ if ( 'us' === $address_field->field_options['address_type'] ) {
+ $country_code = 'US';
+ } else {
+ $country_code = FrmProAddressesController::get_country_code( $address['country'] );
+ }
+
+ if ( ! $address['line1'] || ! $address['city'] || ! $address['state'] || ! $address['zip'] || ! $country_code ) {
+ return false;
+ }
+
+ return array(
+ 'address_line_1' => $address['line1'],
+ 'address_line_2' => $address['line2'] ?? '',
+ 'admin_area_2' => $address['city'],
+ 'admin_area_1' => $address['state'],
+ 'postal_code' => $address['zip'],
+ 'country_code' => $country_code,
+ );
+ }
+
+ /**
+ * @since x.x
+ *
+ * @param WP_Post $action
+ *
+ * @return string
+ */
+ private static function get_shipping_preference( $action ) {
+ $setting = ! empty( $action->post_content['shipping_preference'] ) ? $action->post_content['shipping_preference'] : 'use_paypal_account_data';
+
+ switch ( $setting ) {
+ case 'use_address_field_data':
+ return 'SET_PROVIDED_ADDRESS';
+
+ case 'no_shipping':
+ return 'NO_SHIPPING';
+
+ case 'use_paypal_account_data':
+ default:
+ return 'GET_FROM_FILE';
+ }
+ }
+
+ /**
+ * @since x.x
+ *
+ * @param array $payer
+ * @param array $address
+ * @param int $address_field_id
+ *
+ * @return void
+ */
+ private static function maybe_add_address_data( &$payer, $address, $address_field_id ) {
+ if ( ! is_array( $address ) || ! isset( $address['line1'] ) || ! is_callable( 'FrmProAddressesController::get_country_code' ) ) {
+ return;
+ }
+
+ $address_field = FrmField::getOne( $address_field_id );
+
+ if ( ! $address_field ) {
+ return;
+ }
+
+ if ( 'us' === $address_field->field_options['address_type'] ) {
+ $country_code = 'US';
+ } else {
+ $country_code = FrmProAddressesController::get_country_code( $address['country'] );
+ }
+
+ if ( ! $address['line1'] || ! $address['city'] || ! $address['state'] || ! $address['zip'] || ! $country_code ) {
+ return;
+ }
+
+ $payer['address'] = array(
+ 'address_line_1' => $address['line1'],
+ 'address_line_2' => $address['line2'] ?? '',
+ 'admin_area_2' => $address['city'],
+ 'admin_area_1' => $address['state'],
+ 'postal_code' => $address['zip'],
+ 'country_code' => $country_code,
+ );
+ }
+
+ /**
+ * @since x.x
+ *
+ * @return array
+ */
+ private static function get_valid_payment_sources() {
+ $sources = array(
+ 'card',
+ 'paypal',
+ 'apple_pay',
+ 'bancontact',
+ 'blik',
+ 'eps',
+ 'giropay',
+ 'ideal',
+ 'mybank',
+ 'p24',
+ 'sepa',
+ 'sofort',
+ 'trustly',
+ 'venmo',
+ 'paylater',
+ 'google_pay',
+ );
+
+ /**
+ * @since x.x
+ *
+ * @param array $sources
+ */
+ return apply_filters( 'frm_paypal_valid_payment_sources', $sources );
+ }
+
+ /**
+ * Get the amount value for verification.
+ *
+ * @param WP_Post $action
+ *
+ * @return string
+ */
+ private static function get_amount_value_for_verification( $action ) {
+ $amount = $action->post_content['amount'];
+
+ if ( ! str_contains( $amount, '[' ) ) {
+ return $amount;
+ }
+
+ $form = FrmForm::getOne( $action->menu_order );
+
+ if ( ! $form ) {
+ return $amount;
+ }
+
+ // Update amount based on field shortcodes.
+ $entry = self::generate_false_entry();
+
+ return number_format( floatval( FrmPayPalLiteActionsController::prepare_amount( $amount, compact( 'form', 'entry', 'action' ) ) ) / 100, 2 );
+ }
+
+ /**
+ * Create an entry object with posted values.
+ *
+ * @since x.x
+ *
+ * @return stdClass
+ */
+ private static function generate_false_entry() {
+ $entry = new stdClass();
+ $entry->post_id = 0;
+ $entry->id = 0;
+ $entry->item_key = '';
+ $entry->metas = array();
+
+ // phpcs:ignore WordPress.Security.NonceVerification.Missing
+ foreach ( $_POST as $k => $v ) {
+ $k = sanitize_text_field( stripslashes( $k ) );
+ $v = wp_unslash( $v );
+
+ if ( $k !== 'item_meta' ) {
+ FrmAppHelper::sanitize_value( 'wp_kses_post', $v );
+ $entry->{$k} = $v;
+ continue;
+ }
+
+ if ( ! is_array( $v ) ) {
+ continue;
+ }
+
+ foreach ( $v as $f => $value ) {
+ FrmAppHelper::sanitize_value( 'wp_kses_post', $value );
+ $entry->metas[ absint( $f ) ] = $value;
+ }
+ }
+
+ return $entry;
+ }
+
+ /**
+ * Create a PayPal subscription object via AJAX.
+ *
+ * @return void
+ */
+ public static function create_subscription() {
+ check_ajax_referer( 'frm_paypal_ajax', 'nonce' );
+
+ // Check if PayPal is connected before attempting to create a subscription.
+ $connection_check = self::check_paypal_connection();
+ if ( is_wp_error( $connection_check ) ) {
+ wp_send_json_error( $connection_check->get_error_message() );
+ }
+
+ $form_id = FrmAppHelper::get_post_param( 'form_id', 0, 'absint' );
+
+ if ( ! $form_id ) {
+ wp_send_json_error( __( 'Invalid form ID', 'formidable' ) );
+ }
+
+ $actions = FrmPayPalLiteActionsController::get_actions_before_submit( $form_id );
+
+ if ( ! $actions ) {
+ wp_send_json_error( __( 'No PayPal actions found for this form', 'formidable' ) );
+ }
+
+ $action = reset( $actions );
+ $amount = self::get_amount_value_for_verification( $action );
+
+ // PayPal expects the amount in a format like 10.00, so format it.
+ $amount = number_format( floatval( $amount ), 2, '.', '' );
+ $currency = strtoupper( $action->post_content['currency'] );
+
+ // Pass $product_name, $interval and $interval_count to the helper
+ // As well as trial period and the maximum number of payments.
+ // Also send subscriber email.
+ $product_name = self::process_shortcodes_for_action( $action->post_content['product_name'] ?? '', $action );
+ $interval = $action->post_content['interval'] ?? '';
+ $interval_count = $action->post_content['interval_count'] ?? 1;
+ $trial_period = $action->post_content['trial_period'] ?? '';
+ $payment_limit = $action->post_content['payment_limit'] ?? '';
+ $product_type = $action->post_content['product_type'] ?? 'SERVICE';
+
+ if ( ! $product_name ) {
+ wp_send_json_error( __( 'A product name is required for subscriptions. Please update your PayPal action settings.', 'formidable' ) );
+ }
+
+ if ( ! $interval ) {
+ wp_send_json_error( __( 'A billing interval is required for subscriptions. Please update your PayPal action settings.', 'formidable' ) );
+ }
+
+ if ( ! $amount || '0.00' === $amount ) {
+ wp_send_json_error( __( 'A valid amount is required for subscriptions.', 'formidable' ) );
+ }
+
+ $data = array(
+ 'amount' => $amount,
+ 'currency' => $currency,
+ 'product_name' => $product_name,
+ 'product_type' => $product_type,
+ 'interval' => $interval,
+ 'interval_count' => $interval_count,
+ 'trial_period' => $trial_period,
+ 'payment_limit' => $payment_limit,
+ 'payer' => self::get_payer_data_from_posted_values( $action ),
+ 'shipping_preference' => self::get_shipping_preference( $action ),
+ );
+
+ $vault_setup_token = FrmAppHelper::get_post_param( 'vault_setup_token', '', 'sanitize_text_field' );
+
+ if ( $vault_setup_token ) {
+ $data['vault_setup_token'] = $vault_setup_token;
+ }
+
+ $response = FrmPayPalLiteConnectHelper::create_subscription( $data );
+
+ if ( false === $response ) {
+ $error = FrmPayPalLiteConnectHelper::get_latest_error_from_paypal_api();
+ wp_send_json_error( self::format_paypal_error( $error, 'Failed to create PayPal subscription' ) );
+ }
+
+ // Check if response is a structured error with message and debug_id (array or object)
+ if ( ( is_array( $response ) || is_object( $response ) ) && isset( $response->message ) && isset( $response->debug_id ) ) {
+ wp_send_json_error( $response );
+ }
+
+ if ( ! isset( $response->subscription_id ) ) {
+ wp_send_json_error( 'Failed to create PayPal subscription' );
+ }
+
+ wp_send_json_success( array( 'subscriptionID' => $response->subscription_id ) );
+ }
+
+ public static function create_vault_setup_token() {
+ check_ajax_referer( 'frm_paypal_ajax', 'nonce' );
+
+ $payment_source = FrmAppHelper::get_post_param( 'payment_source', 'card', 'sanitize_text_field' );
+
+ $data = array(
+ 'payment_source' => $payment_source,
+ );
+
+ $response = FrmPayPalLiteConnectHelper::create_vault_setup_token( $data );
+
+ if ( false === $response ) {
+ wp_send_json_error( 'Failed to create PayPal vault setup token' );
+ }
+
+ if ( ! isset( $response->token ) ) {
+ wp_send_json_error( 'Failed to create PayPal vault setup token' );
+ }
+
+ wp_send_json_success( array( 'token' => $response->token ) );
+ }
+
+ /**
+ * Handle a PayPal error reported by the frontend JavaScript.
+ *
+ * Logs the debug ID and error details, then returns a display message
+ * that includes the debug ID only when the current user has permission.
+ *
+ * @since x.x
+ *
+ * @return void
+ */
+ public static function report_error() {
+ check_ajax_referer( 'frm_paypal_ajax', 'nonce' );
+
+ $error_message = substr( FrmAppHelper::get_post_param( 'error_message', '', 'sanitize_text_field' ), 0, 500 );
+ $debug_id = substr( FrmAppHelper::get_post_param( 'debug_id', '', 'sanitize_text_field' ), 0, 50 );
+ $context = substr( FrmAppHelper::get_post_param( 'context', '', 'sanitize_text_field' ), 0, 100 );
+
+ if ( $debug_id ) {
+ self::log_paypal_debug_id( $debug_id, $error_message, $context );
+ }
+
+ $display_message = $error_message ?: __( 'Payment failed. Please try again.', 'formidable' );
+
+ if ( $debug_id && current_user_can( 'frm_change_settings' ) ) {
+ $display_message .= "\n\nDebug ID: " . $debug_id;
+ }
+
+ wp_send_json_success( array( 'message' => $display_message ) );
+ }
+
+ /**
+ * Log a PayPal debug ID to the recent debug IDs option.
+ *
+ * Stores up to 20 entries, newest first.
+ *
+ * @since x.x
+ *
+ * @param string $debug_id The PayPal debug ID.
+ * @param string $error_message The associated error message.
+ * @param string $context The context where the error occurred (e.g. 'create_order', 'card_submit').
+ *
+ * @return void
+ */
+ public static function log_paypal_debug_id( $debug_id, $error_message = '', $context = '' ) {
+ $option_name = 'frm_paypal_debug_ids';
+ $max_entries = 20;
+ $entries = get_option( $option_name, array() );
+
+ if ( ! is_array( $entries ) ) {
+ $entries = array();
+ }
+
+ if ( $error_message && preg_match( '/^[A-Z_]+$/', $error_message ) ) {
+ $prefixes = array( 'REFUND_FAILED_', 'REFUND_' );
+ $reason = str_replace( $prefixes, '', $error_message );
+
+ if ( $reason !== $error_message ) {
+ $error_message = 'Refund Failed (' . ucwords( strtolower( str_replace( '_', ' ', $reason ) ) ) . ')';
+ } else {
+ $error_message = ucwords( strtolower( str_replace( '_', ' ', $error_message ) ) );
+ }
+ }
+
+ $entry = array(
+ 'debug_id' => $debug_id,
+ 'error_message' => $error_message,
+ 'context' => $context,
+ 'timestamp' => gmdate( 'Y-m-d H:i:s' ),
+ );
+
+ array_unshift( $entries, $entry );
+ $entries = array_slice( $entries, 0, $max_entries );
+
+ update_option( $option_name, $entries, false );
+ }
+
+ /**
+ * Process shortcodes in an action setting value using posted form data.
+ *
+ * @since x.x
+ *
+ * @param string $value The value that may contain shortcodes.
+ * @param WP_Post $action The payment action.
+ *
+ * @return string
+ */
+ private static function process_shortcodes_for_action( $value, $action ) {
+ if ( ! str_contains( $value, '[' ) ) {
+ return $value;
+ }
+
+ $form = FrmForm::getOne( $action->menu_order );
+
+ if ( ! $form ) {
+ return $value;
+ }
+
+ $entry = self::generate_false_entry();
+
+ return FrmTransLiteAppHelper::process_shortcodes(
+ array(
+ 'value' => $value,
+ 'form' => $form,
+ 'entry' => $entry,
+ )
+ );
+ }
+
+ /**
+ * Check if PayPal is connected before attempting to create an order or subscription.
+ *
+ * @since x.x
+ *
+ * @return true|WP_Error True if connected, WP_Error with message if not connected.
+ */
+ private static function check_paypal_connection() {
+ $merchant_id = FrmPayPalLiteConnectHelper::get_merchant_id();
+
+ if ( ! $merchant_id ) {
+ $message = __( 'PayPal is not connected. Please connect your PayPal account to process payments.', 'formidable' );
+
+ if ( current_user_can( 'frm_change_settings' ) ) {
+ $message .= ' ' . __( 'You can connect PayPal in Global Settings, under the Payments section.', 'formidable' );
+ }
+
+ return new WP_Error( 'paypal_not_connected', $message );
+ }
+
+ return true;
+ }
+
+ /**
+ * Parse a PayPal API error string and conditionally include the debug ID.
+ *
+ * The PayPal API addon embeds debug IDs using a {{debug_id:...}} delimiter.
+ * This method strips that token and appends a human-readable debug ID line
+ * only for users who can edit forms.
+ *
+ * @since x.x
+ *
+ * @param string|null $error The error string from the PayPal API, possibly containing a debug ID token.
+ * @param string $fallback The fallback message when no error is available.
+ * @return string
+ */
+ private static function format_paypal_error( $error, $fallback ) {
+ if ( ! $error ) {
+ return $fallback;
+ }
+
+ // If error is already a structured array with message and debug_id, return it directly
+ if ( is_array( $error ) && isset( $error['message'] ) && isset( $error['debug_id'] ) ) {
+ return $error;
+ }
+
+ if ( ! preg_match( '/\{\{debug_id:([^}]+)\}\}/', $error, $matches ) ) {
+ return $error;
+ }
+
+ $clean_message = str_replace( $matches[0], '', $error );
+ $clean_message = trim( $clean_message );
+
+ // Always return structured error with debug_id so JavaScript can extract and send it
+ return array(
+ 'message' => $clean_message ?: $fallback,
+ 'debug_id' => $matches[1],
+ );
+ }
+}
diff --git a/paypal/controllers/FrmPayPalLiteEventsController.php b/paypal/controllers/FrmPayPalLiteEventsController.php
new file mode 100644
index 0000000000..5414d4db1a
--- /dev/null
+++ b/paypal/controllers/FrmPayPalLiteEventsController.php
@@ -0,0 +1,881 @@
+flush_response();
+
+ $unprocessed_event_ids = FrmPayPalLiteConnectHelper::get_unprocessed_event_ids();
+
+ if ( $unprocessed_event_ids ) {
+ $this->process_event_ids( $unprocessed_event_ids );
+ }
+
+ wp_send_json_success();
+ }
+
+ /**
+ * @since x.x
+ *
+ * @param array $event_ids
+ *
+ * @return void
+ */
+ private function process_event_ids( $event_ids ) {
+ foreach ( $event_ids as $event_id ) {
+ if ( $this->should_skip_event( $event_id ) ) {
+ continue;
+ }
+
+ set_transient( 'frm_paypal_last_process_' . $event_id, time(), 60 );
+
+ $this->event = FrmPayPalLiteConnectHelper::get_event( $event_id );
+
+ if ( ! is_object( $this->event ) ) {
+ $this->count_failed_event( $event_id );
+ continue;
+ }
+
+ $this->handle_event();
+ $this->track_handled_event( $event_id );
+ FrmPayPalLiteConnectHelper::process_event( $event_id );
+ }
+ }
+
+ /**
+ * @since x.x
+ *
+ * @param string $event_id
+ *
+ * @return bool True if the event should be skipped.
+ */
+ private function should_skip_event( $event_id ) {
+ if ( $this->last_attempt_to_process_event_is_too_recent( $event_id ) ) {
+ return true;
+ }
+
+ $option = get_option( self::$events_to_skip_option_name );
+
+ return is_array( $option ) && in_array( $event_id, $option, true );
+ }
+
+ /**
+ * @param string $event_id
+ *
+ * @return bool
+ */
+ private function last_attempt_to_process_event_is_too_recent( $event_id ) {
+ $last_process_attempt = get_transient( 'frm_paypal_last_process_' . $event_id );
+ return is_numeric( $last_process_attempt ) && $last_process_attempt > time() - 60;
+ }
+
+ /**
+ * @since x.x
+ *
+ * @param string $event_id
+ *
+ * @return void
+ */
+ private function count_failed_event( $event_id ) {
+ $transient_name = 'frm_paypal_failed_event_' . $event_id;
+ $transient = get_transient( $transient_name );
+ $failed_count = is_int( $transient ) ? $transient + 1 : 1;
+ $maximum_retries = 3;
+
+ if ( $failed_count >= $maximum_retries ) {
+ $this->track_handled_event( $event_id );
+ } else {
+ set_transient( $transient_name, $failed_count, 4 * DAY_IN_SECONDS );
+ }
+ }
+
+ /**
+ * Track an event to no longer process.
+ * This is called for successful events, and also for failed events after a number of retries.
+ *
+ * @since x.x
+ *
+ * @param string $event_id
+ *
+ * @return void
+ */
+ private function track_handled_event( $event_id ) {
+ $option = get_option( self::$events_to_skip_option_name );
+
+ if ( is_array( $option ) ) {
+ if ( count( $option ) > 1000 ) {
+ // Prevent the option from getting too big by removing the front item before adding the next.
+ array_shift( $option );
+ }
+ } else {
+ $option = array();
+ }
+
+ $option[] = $event_id;
+ update_option( self::$events_to_skip_option_name, $option, false );
+ }
+
+ /**
+ * @return void
+ */
+ private function handle_event() {
+ $this->resource = $this->event->resource ?? null;
+
+ if ( ! is_object( $this->resource ) ) {
+ FrmTransLiteLog::log_message( 'PayPal Webhook Message', 'No resource object found in event' );
+ return;
+ }
+
+ $payment_events = array(
+ 'PAYMENT.CAPTURE.COMPLETED' => 'complete',
+ 'PAYMENT.CAPTURE.DECLINED' => 'failed',
+ 'PAYMENT.CAPTURE.DENIED' => 'failed',
+ 'PAYMENT.CAPTURE.REFUNDED' => 'refunded',
+ 'PAYMENT.CAPTURE.REVERSED' => 'refunded',
+ 'PAYMENT.SALE.COMPLETED' => 'complete',
+ 'PAYMENT.SALE.DENIED' => 'failed',
+ 'PAYMENT.SALE.REFUNDED' => 'refunded',
+ 'PAYMENT.SALE.REVERSED' => 'refunded',
+ );
+
+ if ( isset( $payment_events[ $this->event->event_type ] ) ) {
+ $this->status = $payment_events[ $this->event->event_type ];
+ $this->handle_payment_event();
+ return;
+ }
+
+ switch ( $this->event->event_type ) {
+ case 'BILLING.SUBSCRIPTION.ACTIVATED':
+ case 'BILLING.SUBSCRIPTION.RE-ACTIVATED':
+ $this->handle_subscription_activated();
+ break;
+
+ case 'BILLING.SUBSCRIPTION.CANCELLED':
+ case 'BILLING.SUBSCRIPTION.EXPIRED':
+ case 'BILLING.SUBSCRIPTION.SUSPENDED':
+ $this->handle_subscription_canceled();
+ break;
+
+ case 'BILLING.SUBSCRIPTION.PAYMENT.FAILED':
+ $this->handle_subscription_payment_failed();
+ break;
+
+ case 'BILLING.SUBSCRIPTION.UPDATED':
+ $this->handle_subscription_updated();
+ break;
+ }
+ }
+
+ /**
+ * Handle a payment capture or sale event by syncing the payment record.
+ *
+ * @since x.x
+ *
+ * @return void
+ */
+ private function handle_payment_event() {
+ $receipt_id = $this->get_receipt_id_for_event();
+
+ if ( ! $receipt_id ) {
+ FrmTransLiteLog::log_message( 'PayPal Webhook Message', 'No resource ID found in payment event' );
+ return;
+ }
+
+ $frm_payment = new FrmTransLitePayment();
+ $payment = $frm_payment->get_one_by( $receipt_id, 'receipt_id' );
+
+ // If no payment was found by capture ID, check for a pending payment
+ // stored with the order ID as receipt_id. Update it to the capture ID.
+ if ( ! $payment ) {
+ $payment = $this->maybe_resolve_pending_payment( $frm_payment, $receipt_id );
+ }
+
+ if ( ! $payment && $this->status === 'refunded' ) {
+ FrmTransLiteLog::log_message( 'PayPal Webhook Message', 'No action taken. The refunded payment does not exist for ' . $receipt_id );
+ return;
+ }
+
+ $run_triggers = false;
+
+ if ( ! $payment ) {
+ $payment = $this->maybe_create_subscription_payment();
+
+ if ( $payment ) {
+ $run_triggers = true;
+ }
+ } elseif ( $payment->status !== $this->status ) {
+ $payment_values = (array) $payment;
+ $is_partial_refund = $this->is_partial_refund();
+
+ if ( $is_partial_refund ) {
+ $this->set_partial_refund( $payment_values );
+ // translators: %s: The amount of money that was refunded.
+ $note = sprintf( __( 'Payment partially refunded %s', 'formidable' ), $this->get_refunded_amount() );
+ } else {
+ $payment_values['status'] = $this->status;
+ $payment->status = $this->status;
+ // translators: %s: The status of the payment.
+ $note = sprintf( __( 'Payment %s', 'formidable' ), $payment_values['status'] );
+ }
+
+ FrmTransLiteAppHelper::add_note_to_payment( $payment_values, $note );
+
+ $frm_payment->update( $payment->id, $payment_values );
+
+ if ( ! $is_partial_refund ) {
+ $run_triggers = true;
+ }
+ }//end if
+
+ if ( $run_triggers && $payment && $payment->action_id ) {
+ FrmTransLiteActionsController::trigger_payment_status_change(
+ array(
+ 'status' => $this->status,
+ 'payment' => $payment,
+ )
+ );
+ }
+ }
+
+ /**
+ * Try to create a new payment record from a subscription payment event.
+ * This handles recurring payments after the first one.
+ *
+ * @since x.x
+ *
+ * @return false|object The new payment object or false if not a subscription payment.
+ */
+ private function maybe_create_subscription_payment() {
+ $subscription_id = $this->get_subscription_id_from_resource();
+
+ if ( ! $subscription_id ) {
+ return false;
+ }
+
+ $sub = $this->get_subscription( $subscription_id );
+
+ if ( ! $sub ) {
+ return false;
+ }
+
+ $receipt_id = $this->resource->id ?? '';
+ $amount = $this->get_amount_from_resource();
+
+ $payment_values = array(
+ 'paysys' => 'paypal',
+ 'amount' => $amount,
+ 'status' => $this->status,
+ 'item_id' => $sub->item_id,
+ 'action_id' => $sub->action_id,
+ 'receipt_id' => $receipt_id,
+ 'sub_id' => $sub->id,
+ 'begin_date' => gmdate( 'Y-m-d' ),
+ 'expire_date' => '0000-00-00',
+ 'meta_value' => array(),
+ 'created_at' => current_time( 'mysql', 1 ),
+ 'test' => 'test' === FrmPayPalLiteAppHelper::active_mode() ? 1 : 0,
+ );
+
+ FrmTransLiteAppHelper::add_note_to_payment( $payment_values );
+
+ $frm_payment = new FrmTransLitePayment();
+ $existing_payment = $frm_payment->get_one_by( $receipt_id, 'receipt_id' );
+
+ if ( $existing_payment ) {
+ return false;
+ }
+
+ $existing_sub_payment = $frm_payment->get_one_by( $sub->id, 'sub_id' );
+
+ if ( $existing_sub_payment && str_starts_with( $existing_sub_payment->receipt_id, 'I-' ) ) {
+ $frm_payment->update( $existing_sub_payment->id, array( 'receipt_id' => $receipt_id ) );
+
+ $this->update_next_bill_date( $sub );
+ $this->maybe_cancel_subscription_at_limit( $sub );
+
+ return $frm_payment->get_one( $existing_sub_payment->id );
+ }
+
+ $payment_id = $frm_payment->create( $payment_values );
+
+ $this->update_next_bill_date( $sub );
+ $this->maybe_cancel_subscription_at_limit( $sub );
+
+ return $frm_payment->get_one( $payment_id );
+ }
+
+ /**
+ * Get the PayPal subscription ID from the resource object.
+ *
+ * @since x.x
+ *
+ * @return string
+ */
+ private function get_subscription_id_from_resource() {
+ if ( ! empty( $this->resource->billing_agreement_id ) ) {
+ return $this->resource->billing_agreement_id;
+ }
+
+ if ( ! empty( $this->resource->supplementary_data->related_ids->subscription_id ) ) {
+ return $this->resource->supplementary_data->related_ids->subscription_id;
+ }
+
+ return '';
+ }
+
+ /**
+ * Get the payment amount from the resource object.
+ *
+ * @since x.x
+ *
+ * @return string
+ */
+ private function get_amount_from_resource() {
+ if ( ! empty( $this->resource->amount->total ) ) {
+ return $this->resource->amount->total;
+ }
+
+ if ( ! empty( $this->resource->amount->value ) ) {
+ return $this->resource->amount->value;
+ }
+
+ return '0.00';
+ }
+
+ /**
+ * Get the refunded amount from the resource object.
+ *
+ * @since x.x
+ *
+ * @return string
+ */
+ private function get_refunded_amount() {
+ if ( ! empty( $this->resource->amount->total ) ) {
+ return $this->resource->amount->total;
+ }
+
+ if ( ! empty( $this->resource->amount->value ) ) {
+ return $this->resource->amount->value;
+ }
+
+ return '0.00';
+ }
+
+ /**
+ * Check if a refund is partial by comparing the refunded amount to the original payment amount.
+ *
+ * @since x.x
+ *
+ * @return bool
+ */
+ private function is_partial_refund() {
+ if ( $this->status !== 'refunded' ) {
+ return false;
+ }
+
+ $receipt_id = $this->get_receipt_id_for_event();
+
+ if ( ! $receipt_id ) {
+ return false;
+ }
+
+ $frm_payment = new FrmTransLitePayment();
+ $original_payment = $frm_payment->get_one_by( $receipt_id, 'receipt_id' );
+ $refunded_amount = (float) $this->get_refunded_amount();
+
+ if ( $original_payment ) {
+ return $refunded_amount < (float) $original_payment->amount;
+ }
+
+ return false;
+ }
+
+ /**
+ * Set the partial refund amount on a payment.
+ *
+ * @since x.x
+ *
+ * @param array $payment_values The payment values to update.
+ *
+ * @return void
+ */
+ private function set_partial_refund( &$payment_values ) {
+ $refunded = (float) $this->get_refunded_amount();
+ $original = (float) $payment_values['amount'];
+ $payment_values['amount'] = number_format( $original - $refunded, 2, '.', '' );
+ }
+
+ /**
+ * Try to find a pending payment stored with the order ID as receipt_id.
+ *
+ * When a capture is pending, the payment record is created with the order
+ * ID as receipt_id. When the capture completes, the webhook provides a
+ * capture ID. This method extracts the order ID from the resource's HATEOAS
+ * 'up' link, looks up the pending payment, and updates its receipt_id to
+ * the capture ID.
+ *
+ * @since x.x
+ *
+ * @param FrmTransLitePayment $frm_payment The payment model instance.
+ * @param string $capture_id The capture ID from the webhook resource.
+ *
+ * @return object|null The payment if found and updated, or null.
+ */
+ private function maybe_resolve_pending_payment( $frm_payment, $capture_id ) {
+ $order_id = $this->get_order_id_from_resource_links();
+
+ if ( ! $order_id ) {
+ return null;
+ }
+
+ $payment = $frm_payment->get_one_by( $order_id, 'receipt_id' );
+
+ if ( ! $payment || 'pending' !== $payment->status ) {
+ return null;
+ }
+
+ $frm_payment->update( $payment->id, array( 'receipt_id' => $capture_id ) );
+ $payment->receipt_id = $capture_id;
+
+ return $payment;
+ }
+
+ /**
+ * Extract the order ID from the webhook resource's HATEOAS 'up' link.
+ *
+ * For PAYMENT.CAPTURE.COMPLETED events, the 'up' link points to the
+ * order: /v2/checkout/orders/{order_id}.
+ *
+ * @since x.x
+ *
+ * @return string The order ID, or empty string if not found.
+ */
+ private function get_order_id_from_resource_links() {
+ if ( empty( $this->resource->links ) || ! is_array( $this->resource->links ) ) {
+ return '';
+ }
+
+ foreach ( $this->resource->links as $link ) {
+ if ( ! isset( $link->rel ) || 'up' !== $link->rel ) {
+ continue;
+ }
+
+ if ( empty( $link->href ) ) {
+ continue;
+ }
+
+ $path = wp_parse_url( $link->href, PHP_URL_PATH );
+
+ if ( ! $path ) {
+ continue;
+ }
+
+ $segments = explode( '/', rtrim( $path, '/' ) );
+ $last_segment = end( $segments );
+
+ if ( $last_segment ) {
+ return $last_segment;
+ }
+ }
+
+ return '';
+ }
+
+ /**
+ * Get the receipt ID to use for looking up a payment record.
+ *
+ * For most events, this is the resource ID. For refund/reversal events,
+ * the resource is the refund object, so we need to extract the original
+ * capture or sale ID from the resource's sale_id property or HATEOAS links.
+ *
+ * @since x.x
+ *
+ * @return string The receipt ID of the original payment.
+ */
+ private function get_receipt_id_for_event() {
+ if ( $this->status !== 'refunded' ) {
+ return $this->resource->id ?? '';
+ }
+
+ $refund_id = $this->resource->id ?? '';
+
+ // For sale refunds, the sale_id property references the original sale.
+ if ( ! empty( $this->resource->sale_id ) ) {
+ return $this->resource->sale_id;
+ }
+
+ // For capture refunds, extract the capture ID from the HATEOAS 'up' link.
+ // The 'up' link points to the original capture: /v2/payments/captures/{capture_id}
+ if ( empty( $this->resource->links ) || ! is_array( $this->resource->links ) ) {
+ return $refund_id;
+ }
+
+ foreach ( $this->resource->links as $link ) {
+ if ( ! isset( $link->rel ) || 'up' !== $link->rel ) {
+ continue;
+ }
+
+ if ( empty( $link->href ) ) {
+ continue;
+ }
+
+ // Extract the ID from the URL path: .../captures/{id} or .../sale/{id}
+ $path = wp_parse_url( $link->href, PHP_URL_PATH );
+
+ if ( ! $path ) {
+ continue;
+ }
+
+ $segments = explode( '/', rtrim( $path, '/' ) );
+ $last_segment = end( $segments );
+
+ if ( $last_segment ) {
+ return $last_segment;
+ }
+ }//end foreach
+
+ // Fallback to the resource ID (the refund ID itself).
+ return $refund_id;
+ }
+
+ /**
+ * Get a subscription record by its PayPal subscription ID.
+ *
+ * @since x.x
+ *
+ * @param string $sub_id The PayPal subscription ID.
+ *
+ * @return object|null
+ */
+ private function get_subscription( $sub_id ) {
+ $frm_sub = new FrmTransLiteSubscription();
+ $sub = $frm_sub->get_one_by( $sub_id, 'sub_id' );
+
+ if ( ! $sub ) {
+ FrmTransLiteLog::log_message( 'PayPal Webhook Message', 'No action taken since there is not a matching subscription for ' . $sub_id );
+ }
+
+ return $sub;
+ }
+
+ /**
+ * Update the next bill date for a subscription using the PayPal API.
+ *
+ * @since x.x
+ *
+ * @param object $sub The local subscription record.
+ *
+ * @return void
+ */
+ private function update_next_bill_date( $sub ) {
+ $subscription = FrmPayPalLiteConnectHelper::get_subscription( $sub->sub_id );
+
+ if ( ! is_object( $subscription ) ) {
+ return;
+ }
+
+ $next_bill_date = '';
+
+ if ( ! empty( $subscription->billing_info->next_billing_time ) ) {
+ $next_bill_date = gmdate( 'Y-m-d', strtotime( $subscription->billing_info->next_billing_time ) );
+ }
+
+ if ( ! $next_bill_date ) {
+ return;
+ }
+
+ $frm_sub = new FrmTransLiteSubscription();
+ $frm_sub->update( $sub->id, array( 'next_bill_date' => $next_bill_date ) );
+ }
+
+ /**
+ * Check if a subscription has reached its payment limit.
+ * If it has, cancel the subscription.
+ *
+ * @since x.x
+ *
+ * @param object $sub The local subscription record.
+ *
+ * @return void
+ */
+ private function maybe_cancel_subscription_at_limit( $sub ) {
+ $action = FrmFormAction::get_single_action_type( $sub->action_id, 'payment' );
+
+ if ( ! is_object( $action ) || empty( $action->post_content['payment_limit'] ) ) {
+ return;
+ }
+
+ $frm_payment = new FrmTransLitePayment();
+ $all_payments = $frm_payment->get_all_by( $sub->id, 'sub_id' );
+ $count = FrmTransLiteAppHelper::count_completed_payments( $all_payments );
+
+ if ( $count < (int) $action->post_content['payment_limit'] ) {
+ return;
+ }
+
+ $cancelled = FrmPayPalLiteConnectHelper::cancel_subscription( $sub->sub_id );
+
+ if ( $cancelled ) {
+ FrmTransLiteSubscriptionsController::change_subscription_status(
+ array(
+ 'status' => 'future_cancel',
+ 'sub' => $sub,
+ )
+ );
+ }
+ }
+
+ /**
+ * Handle a subscription activated or re-activated event.
+ *
+ * @since x.x
+ *
+ * @return void
+ */
+ private function handle_subscription_activated() {
+ $subscription_id = $this->resource->id ?? '';
+
+ if ( ! $subscription_id ) {
+ return;
+ }
+
+ $sub = $this->get_subscription( $subscription_id );
+
+ if ( ! $sub ) {
+ return;
+ }
+
+ if ( $sub->status === 'active' ) {
+ return;
+ }
+
+ FrmTransLiteSubscriptionsController::change_subscription_status(
+ array(
+ 'status' => 'active',
+ 'sub' => $sub,
+ )
+ );
+
+ $this->update_next_bill_date( $sub );
+ }
+
+ /**
+ * Handle a subscription cancelled, expired, or suspended event.
+ *
+ * @since x.x
+ *
+ * @return void
+ */
+ private function handle_subscription_canceled() {
+ $subscription_id = $this->resource->id ?? '';
+
+ if ( ! $subscription_id ) {
+ FrmTransLiteLog::log_message( 'PayPal Webhook Debug', 'BILLING.SUBSCRIPTION.CANCELLED: No subscription ID found in resource' );
+ return;
+ }
+
+ FrmTransLiteLog::log_message( 'PayPal Webhook Debug', 'BILLING.SUBSCRIPTION.CANCELLED: Looking for subscription ID: ' . $subscription_id );
+
+ $sub = $this->get_subscription( $subscription_id );
+
+ if ( ! $sub ) {
+ FrmTransLiteLog::log_message( 'PayPal Webhook Debug', 'BILLING.SUBSCRIPTION.CANCELLED: Subscription not found in database for ID: ' . $subscription_id );
+ return;
+ }
+
+ FrmTransLiteLog::log_message( 'PayPal Webhook Debug', 'BILLING.SUBSCRIPTION.CANCELLED: Found subscription, current status: ' . $sub->status );
+
+ if ( $sub->status === 'canceled' ) {
+ FrmTransLiteLog::log_message( 'PayPal Webhook Debug', 'BILLING.SUBSCRIPTION.CANCELLED: Subscription already canceled, no action needed' );
+ return;
+ }
+
+ FrmTransLiteLog::log_message( 'PayPal Webhook Debug', 'BILLING.SUBSCRIPTION.CANCELLED: Updating subscription status to canceled' );
+
+ FrmTransLiteSubscriptionsController::change_subscription_status(
+ array(
+ 'status' => 'canceled',
+ 'sub' => $sub,
+ )
+ );
+
+ FrmTransLiteLog::log_message( 'PayPal Webhook Debug', 'BILLING.SUBSCRIPTION.CANCELLED: Status update completed' );
+ }
+
+ /**
+ * Handle a subscription payment failed event.
+ * Increments the fail count and cancels after too many failures.
+ *
+ * @since x.x
+ *
+ * @return void
+ */
+ private function handle_subscription_payment_failed() {
+ $subscription_id = $this->resource->id ?? '';
+
+ if ( ! $subscription_id ) {
+ return;
+ }
+
+ $sub = $this->get_subscription( $subscription_id );
+
+ if ( ! $sub ) {
+ return;
+ }
+
+ $frm_sub = new FrmTransLiteSubscription();
+ $fail_count = (int) $sub->fail_count + 1;
+
+ $frm_sub->update(
+ $sub->id,
+ array( 'fail_count' => $fail_count )
+ );
+
+ if ( $fail_count > 3 ) {
+ FrmTransLiteSubscriptionsController::change_subscription_status(
+ array(
+ 'status' => 'canceled',
+ 'sub' => $sub,
+ )
+ );
+ }
+ }
+
+ /**
+ * Handle a subscription updated event.
+ * Syncs subscription data like amount and next bill date.
+ *
+ * @since x.x
+ *
+ * @return void
+ */
+ private function handle_subscription_updated() {
+ $subscription_id = $this->resource->id ?? '';
+
+ if ( ! $subscription_id ) {
+ return;
+ }
+
+ $sub = $this->get_subscription( $subscription_id );
+
+ if ( ! $sub ) {
+ return;
+ }
+
+ $new_values = array();
+
+ // Sync the subscription status.
+ $paypal_status = $this->resource->status ?? '';
+ $status_map = array(
+ 'ACTIVE' => 'active',
+ 'SUSPENDED' => 'canceled',
+ 'CANCELLED' => 'canceled',
+ 'EXPIRED' => 'canceled',
+ );
+
+ if ( $paypal_status && isset( $status_map[ $paypal_status ] ) && $sub->status !== $status_map[ $paypal_status ] ) {
+ FrmTransLiteSubscriptionsController::change_subscription_status(
+ array(
+ 'status' => $status_map[ $paypal_status ],
+ 'sub' => $sub,
+ )
+ );
+ }
+
+ // Sync next billing date and amount from the PayPal API.
+ $subscription = FrmPayPalLiteConnectHelper::get_subscription( $subscription_id );
+
+ if ( ! is_object( $subscription ) ) {
+ // If the subscription doesn't exist in PayPal's API (404 error), it's likely cancelled.
+ // Update the local status to canceled if it's not already.
+ if ( $sub->status !== 'canceled' ) {
+ FrmTransLiteSubscriptionsController::change_subscription_status(
+ array(
+ 'status' => 'canceled',
+ 'sub' => $sub,
+ )
+ );
+ }
+
+ return;
+ }
+
+ if ( ! empty( $subscription->billing_info->next_billing_time ) ) {
+ $new_values['next_bill_date'] = gmdate( 'Y-m-d', strtotime( $subscription->billing_info->next_billing_time ) );
+ }
+
+ if ( ! empty( $subscription->plan->billing_cycles[0]->pricing_scheme->fixed_price->value ) ) {
+ $new_values['amount'] = $subscription->plan->billing_cycles[0]->pricing_scheme->fixed_price->value;
+ }
+
+ if ( ! $new_values ) {
+ return;
+ }
+
+ $frm_sub = new FrmTransLiteSubscription();
+ $frm_sub->update( $sub->id, $new_values );
+ }
+}
diff --git a/paypal/controllers/FrmPayPalLiteFieldsController.php b/paypal/controllers/FrmPayPalLiteFieldsController.php
new file mode 100644
index 0000000000..181541bd43
--- /dev/null
+++ b/paypal/controllers/FrmPayPalLiteFieldsController.php
@@ -0,0 +1,40 @@
+This is a PayPal order field. It is automatically populated when a payment is processed, and is automatically excluded from the form HTML.
';
+ }
+ }
+}
diff --git a/paypal/controllers/FrmPayPalLiteHooksController.php b/paypal/controllers/FrmPayPalLiteHooksController.php
new file mode 100644
index 0000000000..9da4692df1
--- /dev/null
+++ b/paypal/controllers/FrmPayPalLiteHooksController.php
@@ -0,0 +1,101 @@
+ self::class,
+ 'function' => 'route',
+ 'icon' => 'frm_icon_font frm_paypal_icon',
+ );
+
+ return $sections;
+ }
+
+ /**
+ * Handle global settings routing.
+ *
+ * @return void
+ */
+ public static function route() {
+ self::global_settings_form();
+ }
+
+ /**
+ * Print the PayPal section for Global settings.
+ *
+ * @param array $atts
+ *
+ * @return void
+ */
+ public static function global_settings_form( $atts = array() ) {
+ include FrmPayPalLiteAppHelper::plugin_path() . '/views/settings/form.php';
+ }
+
+ /**
+ * Handle processing changes to global PayPal Settings.
+ *
+ * @return void
+ */
+ public static function process_form() {
+ $settings = FrmPayPalLiteAppHelper::get_settings();
+ // phpcs:ignore WordPress.Security.NonceVerification.Missing
+ $settings->update( $_POST );
+ $settings->store();
+ }
+}
diff --git a/paypal/css/frontend.css b/paypal/css/frontend.css
new file mode 100644
index 0000000000..702dc51748
--- /dev/null
+++ b/paypal/css/frontend.css
@@ -0,0 +1,171 @@
+.frm-payment-method-selector {
+ display: flex;
+ flex-direction: column;
+ gap: 0;
+ margin-bottom: 16px;
+ border: 1px solid #e0e0e0;
+ border-radius: 8px;
+ overflow: hidden;
+ max-width: 500px;
+}
+
+.frm-payment-method-option {
+ display: flex;
+ align-items: center;
+ gap: 12px;
+ padding: 16px;
+ cursor: pointer;
+ border-bottom: 1px solid #e0e0e0;
+ background: #fff;
+ transition: background-color 0.15s ease;
+ position: relative;
+ margin: 0;
+}
+
+.frm-payment-method-option:last-child {
+ border-bottom: none;
+}
+
+.frm-payment-method-option:hover {
+ background-color: #f9f9fb;
+}
+
+.frm-payment-method-active {
+ background-color: #f0f4ff;
+}
+
+.frm-payment-method-active:hover {
+ background-color: #f0f4ff;
+}
+
+.frm-payment-method-option input[type="radio"] {
+ appearance: none !important;
+ -webkit-appearance: none !important;
+ width: 20px !important;
+ height: 20px !important;
+ min-width: 20px !important;
+ min-height: 20px !important;
+ border: 2px solid #c0c0c0 !important;
+ border-radius: 50% !important;
+ flex-shrink: 0;
+ margin: 0 !important;
+ padding: 0 !important;
+ cursor: pointer;
+ transition: border-color 0.15s ease, background 0.15s ease;
+ background: #fff !important;
+ box-shadow: none !important;
+ outline: none !important;
+}
+
+.frm-payment-method-option input[type="radio"]:checked {
+ border-color: #0070ba !important;
+ background: radial-gradient(circle, #0070ba 40%, #fff 40%, #fff 100%) !important;
+}
+
+.frm-payment-method-option input[type="radio"]:focus {
+ outline: 2px solid rgba(0, 112, 186, 0.3) !important;
+ outline-offset: 2px !important;
+}
+
+.frm-payment-method-text {
+ display: flex;
+ flex-direction: column;
+ gap: 2px;
+ flex: 1;
+ min-width: 0;
+}
+
+.frm-payment-method-label-text {
+ font-size: 15px;
+ font-weight: 500;
+ color: #1a1a2e;
+ line-height: 1.3;
+}
+
+.frm-payment-method-desc {
+ font-size: 13px;
+ color: #6b7280;
+ line-height: 1.3;
+}
+
+.frm-payment-method-mark {
+ flex-shrink: 0;
+ display: flex;
+ align-items: center;
+ gap: 4px;
+}
+
+.frm-payment-method-mark img,
+.frm-payment-method-mark svg {
+ height: 24px;
+ width: auto;
+}
+
+.frm-payment-method-google-pay-icon {
+ height: 24px;
+}
+
+.frm-payment-method-google-pay-icon svg {
+ height: 24px;
+ width: auto;
+}
+
+.frm-payment-method-apple-pay-icon {
+ height: 24px;
+}
+
+.frm-payment-method-apple-pay-icon svg {
+ height: 24px;
+ width: auto;
+}
+
+.frm-payment-method-paylater-wrap {
+ border-bottom: 1px solid #e0e0e0;
+ background: #fff;
+ transition: background-color 0.15s ease;
+}
+
+.frm-payment-method-paylater-wrap:hover {
+ background-color: #f9f9fb;
+}
+
+.frm-payment-method-paylater-wrap.frm-payment-method-active-wrap {
+ background-color: #f0f4ff;
+}
+
+.frm-payment-method-paylater-wrap.frm-payment-method-active-wrap:hover {
+ background-color: #f0f4ff;
+}
+
+.frm-payment-method-paylater-wrap.frm-payment-method-active-wrap .frm-payment-method-paylater-msg {
+ background-color: #f0f4ff;
+}
+
+.frm-payment-method-paylater-wrap:last-child {
+ border-bottom: none;
+}
+
+.frm-payment-method-paylater-wrap .frm-payment-method-option {
+ border-bottom: none;
+ background: transparent;
+}
+
+.frm-payment-method-paylater-wrap .frm-payment-method-option:hover {
+ background: transparent;
+}
+
+.frm-payment-method-paylater-msg {
+ padding: 0 16px 12px 48px;
+ font-size: 13px;
+ color: #6b7280;
+ background: transparent;
+}
+
+.frm-payment-method-area {
+ margin-top: 16px;
+}
+
+.frm-payment-method-container {
+ display: none;
+ max-width: 500px;
+}
diff --git a/paypal/helpers/FrmPayPalLiteApiHelper.php b/paypal/helpers/FrmPayPalLiteApiHelper.php
new file mode 100644
index 0000000000..78d75c6f7e
--- /dev/null
+++ b/paypal/helpers/FrmPayPalLiteApiHelper.php
@@ -0,0 +1,35 @@
+settings->test_mode ? 'test' : 'live';
+ }
+
+ /**
+ * Get PayPal button style configuration from form action settings
+ *
+ * @param object $form_action The form action object containing post_content.
+ *
+ * @return array PayPal button style configuration
+ */
+ public static function get_paypal_button_style( $form_action ) {
+ $button_layout = $form_action->post_content['button_layout'] ?? 'vertical';
+ $button_color = $form_action->post_content['button_color'] ?? 'default';
+ $button_label = $form_action->post_content['button_label'] ?? 'paypal';
+ $button_border_radius = $form_action->post_content['button_border_radius'] ?? 10;
+
+ return array(
+ 'style' => array(
+ 'layout' => $button_layout,
+ 'color' => $button_color,
+ 'shape' => 'rect',
+ // Default shape, could be made configurable
+ 'label' => $button_label,
+ 'messaging' => true,
+ // Show messaging under button
+ 'borderRadius' => (int) $button_border_radius,
+ ),
+ );
+ }
+
+ /**
+ * Add education about PayPal fees.
+ *
+ * @param string $medium Medium identifier for the tip (for example 'tip').
+ * @param array|false|string $gateway Gateway or list of gateways this applies to.
+ *
+ * @return void
+ */
+ public static function fee_education( $medium = 'tip', $gateway = false ) {
+ $license_type = FrmAddonsController::license_type();
+
+ if ( in_array( $license_type, array( 'elite', 'business' ), true ) ) {
+ return;
+ }
+
+ $classes = 'frm-light-tip show_paypal';
+
+ if ( $gateway && ! array_intersect( (array) $gateway, array( 'paypal' ) ) ) {
+ $classes .= ' frm_hidden';
+ }
+
+ FrmTipsHelper::show_tip(
+ array(
+ 'link' => array(
+ 'content' => 'paypal-fee',
+ 'medium' => $medium,
+ ),
+ 'tip' => 'Pay as you go pricing: 3% fee per-transaction + PayPal fees.',
+ 'call' => __( 'Upgrade to save on fees.', 'formidable' ),
+ 'class' => $classes,
+ ),
+ 'p'
+ );
+ }
+}
diff --git a/paypal/helpers/FrmPayPalLiteConnectHelper.php b/paypal/helpers/FrmPayPalLiteConnectHelper.php
new file mode 100644
index 0000000000..c005d86b46
--- /dev/null
+++ b/paypal/helpers/FrmPayPalLiteConnectHelper.php
@@ -0,0 +1,1158 @@
+payments_receivable = true;
+ $status->primary_email_confirmed = true;
+ $status->oauth_integrations = true;
+ $status->primary_email = 'test@example.com';
+ */
+
+ if ( ! is_object( $status ) ) {
+ self::render_error( __( 'Unable to retrieve seller status.', 'formidable' ), '', $merchant_id );
+ return false;
+ }
+
+ $email = $status->primary_email ?? '';
+ $paypal_settings_url = self::get_paypal_account_settings_url( $mode );
+
+ if ( empty( $status->primary_email_confirmed ) ) {
+ self::render_error( __( 'Primary email not confirmed.', 'formidable' ), $email, $merchant_id, $paypal_settings_url );
+ return false;
+ }
+
+ if ( ! $status->payments_receivable ) {
+ self::render_error( __( 'Payments are not receivable.', 'formidable' ), $email, $merchant_id, $paypal_settings_url );
+ return false;
+ }
+
+ if ( ! $status->oauth_integrations ) {
+ self::render_error(
+ __( 'OAuth integrations are not enabled. Please finish connecting your PayPal account.', 'formidable' ),
+ $email,
+ $merchant_id,
+ '',
+ $mode
+ );
+ return false;
+ }
+
+ // OAuth integrations are valid. Clear any stored tracking_id from a prior incomplete onboarding.
+ delete_option( self::get_tracking_id_option_name( $mode ) );
+
+ $product = self::check_for_product( $status->products, 'PPCP_CUSTOM' );
+ $only_supports_checkout_button = false;
+
+ if ( ! $product || empty( $product->capabilities ) ) {
+ $product = self::check_for_product( $status->products, 'EXPRESS_CHECKOUT' );
+
+ if ( ! $product ) {
+ self::render_error( __( 'No data was found for expected PayPal product.', 'formidable' ), $email, $merchant_id );
+ return false;
+ }
+
+ if ( 'ACTIVE' !== $product->status ) {
+ self::render_error( __( 'PayPal Checkout is not available.', 'formidable' ), $email, $merchant_id );
+ return false;
+ }
+
+ $only_supports_checkout_button = true;
+ }
+
+ if ( $email ) {
+ update_option( self::get_paypal_seller_status_option_name( $mode ), $status, false );
+ }
+
+ echo '';
+ esc_html_e( 'Your seller status is valid.', 'formidable' );
+ echo '
';
+
+ self::echo_email( $email );
+ self::echo_merchant_id( $merchant_id );
+
+ echo '
';
+ echo '
';
+ echo '
' . esc_html__( 'Enabled scopes:', 'formidable' ) . '';
+ echo '
';
+ echo '- ';
+ /**
+ * @var string[] $scopes
+ */
+ $scopes = $status->oauth_integrations[0]->oauth_third_party[0]->scopes;
+ echo implode( '
- ', array_map( 'esc_html', $scopes ) );
+ echo '
';
+ echo '
';
+
+ echo '
';
+ echo '
' . esc_html__( 'Enabled capabilities:', 'formidable' ) . '';
+ echo '
';
+
+ echo '- ' . esc_html__( 'PayPal Checkout', 'formidable' ) . '
';
+
+ $can_process_card_fields = ! $only_supports_checkout_button && in_array( 'CUSTOM_CARD_PROCESSING', $product->capabilities, true );
+
+ if ( $can_process_card_fields ) {
+ echo '- ' . esc_html__( 'Card Processing', 'formidable' ) . '
';
+ }
+ echo '
';
+
+ if ( $can_process_card_fields ) {
+ self::render_acdc_vetting_status( $product );
+ }
+
+ echo '
';
+ echo '' . esc_html__( 'ACDC Application Vetting Status:', 'formidable' ) . '';
+ echo ' ';
+ echo esc_html( self::get_acdc_vetting_status_message( $vetting_status ) );
+
+ if ( ! in_array( $vetting_status, array( 'DECLINED', 'DENIED', 'NEED_MORE_DATA' ), true ) ) {
+ return;
+ }
+
+ echo ' ';
+ echo '';
+ esc_html_e( 'Reapply for Advanced Card Processing', 'formidable' );
+ echo '';
+ }
+
+ /**
+ * @since x.x
+ *
+ * @param string $vetting_status
+ *
+ * @return string
+ */
+ private static function get_acdc_vetting_status_message( $vetting_status ) {
+ switch ( $vetting_status ) {
+ case 'NOT_SET':
+ return 'Unavailable';
+ case 'APPROVED':
+ case 'SUBSCRIBED':
+ return 'Approved';
+ case 'PENDING':
+ return 'Pending';
+ case 'IN_REVIEW':
+ return 'In Review';
+ case 'DECLINED':
+ return 'Declined';
+ case 'NEED_MORE_DATA':
+ return 'Needs More Data';
+ case 'DENIED':
+ return 'Denied';
+ default:
+ return '';
+ }
+ }
+
+ /**
+ * @since x.x
+ *
+ * @param string $mode
+ *
+ * @return void
+ */
+ public static function render_seller_status_placeholder( $mode ) {
+ include FrmPayPalLiteAppHelper::plugin_path() . '/views/settings/seller-status-placeholder.php';
+ }
+
+ /**
+ * Get the PayPal account settings URL for the given mode.
+ *
+ * @since x.x
+ *
+ * @param string $mode 'test' or 'live'.
+ *
+ * @return string
+ */
+ private static function get_paypal_account_settings_url( $mode ) {
+ if ( 'test' === $mode ) {
+ return 'https://www.sandbox.paypal.com/businessprofile/settings';
+ }
+ return 'https://www.paypal.com/businessprofile/settings';
+ }
+
+ /**
+ * @param array $products
+ * @param string $name
+ *
+ * @return bool|object
+ */
+ private static function check_for_product( $products, $name = 'PPCP_CUSTOM' ) {
+ foreach ( $products as $current_product ) {
+ if ( $name === $current_product->name ) {
+ return $current_product;
+ }
+ }
+ return false;
+ }
+
+ /**
+ * @param string $email
+ *
+ * @return void
+ */
+ private static function echo_email( $email ) {
+ if ( ! $email ) {
+ return;
+ }
+
+ echo '
';
+ echo '' . esc_html__( 'Connected account:', 'formidable' ) . '';
+ echo '
';
+ echo esc_html( $email );
+ }
+
+ /**
+ * @param string $merchant_id
+ *
+ * @return void
+ */
+ private static function echo_merchant_id( $merchant_id ) {
+ echo '
';
+ echo '' . esc_html__( 'Merchant ID:', 'formidable' ) . '';
+ echo ' ';
+
+ if ( $merchant_id ) {
+ echo esc_html( $merchant_id );
+ } else {
+ esc_html_e( 'N/A', 'formidable' );
+ }
+ }
+
+ /**
+ * @param string $message
+ * @param string $email
+ * @param string $merchant_id
+ * @param string $link URL to help the user resolve the issue.
+ * @param string $reconnect_mode When set to 'test' or 'live', renders a Reconnect button
+ * that triggers the OAuth flow again for that mode.
+ *
+ * @return void
+ */
+ private static function render_error( $message, $email = '', $merchant_id = '', $link = '', $reconnect_mode = '' ) {
+ echo '';
+ }
+
+ /**
+ * @param string $mode
+ *
+ * @return void
+ */
+ public static function render_settings_for_mode( $mode ) {
+ $connected = (bool) self::get_merchant_id( $mode );
+ include FrmPayPalLiteAppHelper::plugin_path() . '/views/settings/connect-settings-box.php';
+ }
+
+ /**
+ * @return void
+ */
+ private static function register_settings_scripts() {
+ $script_url = FrmPayPalLiteAppHelper::plugin_url() . '/js/settings.js';
+ $dependencies = array( 'formidable_dom' );
+ wp_register_script( 'formidable_paypal_settings', $script_url, $dependencies, FrmAppHelper::plugin_version(), true );
+ wp_enqueue_script( 'formidable_paypal_settings' );
+ }
+
+ /**
+ * @return false|string
+ */
+ public static function get_oauth_redirect_url() {
+ $mode = FrmAppHelper::get_post_param( 'mode', 'test', 'sanitize_text_field' );
+ $tracking_id = get_option( self::get_tracking_id_option_name( $mode ) );
+
+ if ( self::get_merchant_id( $mode ) && ! $tracking_id ) {
+ // Do not allow for initialize if there is already a configured account id,
+ // unless a tracking_id is stored, which indicates the user is re-onboarding
+ // after an incomplete OAuth integration.
+ return false;
+ }
+
+ $additional_body = array(
+ 'password' => self::generate_client_password( $mode ),
+ 'user_id' => get_current_user_id(),
+ 'frm_paypal_api_mode' => $mode,
+ );
+
+ if ( $tracking_id ) {
+ // Reuse the existing tracking_id so the Connect server can resume onboarding.
+ $additional_body['tracking_id'] = $tracking_id;
+ }
+
+ // Clear the transient so it doesn't fail.
+ delete_option( 'frm_paypal_lite_last_verify_attempt' );
+ $data = self::post_to_connect_server( 'oauth_request', $additional_body );
+
+ if ( is_string( $data ) ) {
+ self::$latest_error_from_paypal_api = $data;
+ FrmTransLiteLog::log_message( 'PayPal OAuth Error', $data );
+ return false;
+ }
+
+ if ( ! empty( $data->password ) ) {
+ update_option( self::get_server_side_token_option_name( $mode ), $data->password, false );
+ }
+
+ if ( ! empty( $data->tracking_id ) ) {
+ update_option( self::get_tracking_id_option_name( $mode ), $data->tracking_id, false );
+ }
+
+ if ( ! is_object( $data ) || empty( $data->redirect_url ) ) {
+ return false;
+ }
+
+ return $data->redirect_url;
+ }
+
+ /**
+ * @param string $action
+ * @param array $additional_body
+ *
+ * @return object|string
+ */
+ private static function post_to_connect_server( $action, $additional_body = array() ) {
+ $body = array(
+ 'frm_paypal_api_action' => $action,
+ 'frm_paypal_api_mode' => FrmPayPalLiteAppHelper::active_mode(),
+ );
+ $body = array_merge( $body, $additional_body );
+ $url = self::get_url_to_connect_server();
+ $headers = self::build_headers_for_post();
+
+ // (Seconds) default timeout is 5. we want a bit more time to work with.
+ $timeout = 45;
+
+ self::try_to_extend_server_timeout( $timeout );
+
+ $args = compact( 'body', 'headers', 'timeout' );
+ $response = wp_remote_post( $url, $args );
+
+ if ( ! self::validate_response( $response ) ) {
+ return 'Response from server is invalid';
+ }
+
+ $body = self::pull_response_body( $response );
+
+ if ( empty( $body->success ) ) {
+ $error_message = 'Response from server was not successful';
+ $debug_id = '';
+
+ // Handle structured error response with message and debug_id
+ $data = $body->data ?? null;
+ if ( is_object( $data ) ) {
+ if ( ! empty( $data->message ) ) {
+ $error_message = $data->message;
+ }
+ if ( ! empty( $data->debug_id ) ) {
+ $debug_id = $data->debug_id;
+ }
+ } elseif ( is_string( $data ) ) {
+ $error_message = $data;
+ }
+
+ // Check for debug_id at top level as well
+ if ( ! $debug_id && ! empty( $body->debug_id ) ) {
+ $debug_id = $body->debug_id;
+ }
+
+ // Parse debug_id from error message if not found
+ if ( ! $debug_id && preg_match( '/\{\{debug_id:([^}]+)\}\}/', $error_message, $matches ) ) {
+ $debug_id = $matches[1];
+ }
+
+ if ( $debug_id ) {
+ $clean_message = trim( preg_replace( '/\{\{debug_id:[^}]+\}\}/', '', $error_message ) );
+ FrmPayPalLiteAppController::log_paypal_debug_id( $debug_id, $clean_message, $action );
+ // Return structured error with debug_id so it can be passed to JavaScript
+ return array(
+ 'message' => $clean_message ?: $error_message,
+ 'debug_id' => $debug_id,
+ );
+ }
+
+ return $error_message;
+ }
+
+ return $body->data ?? array();
+ }
+
+ /**
+ * @param array $response
+ *
+ * @return mixed
+ */
+ private static function pull_response_body( $response ) {
+ $http_response = $response['http_response'];
+ $response_object = $http_response->get_response_object();
+ return json_decode( $response_object->body );
+ }
+
+ /**
+ * @param mixed $response
+ *
+ * @return bool
+ */
+ private static function validate_response( $response ) {
+ return ! is_wp_error( $response ) && is_array( $response ) && isset( $response['http_response'] );
+ }
+
+ /**
+ * @return string
+ */
+ private static function get_url_to_connect_server() {
+ // return 'https://api.strategy11.com/';
+ return 'https://dev-site.local/';
+ // return 'https://qa.formidableforms.com/paypal/';
+ }
+
+ /**
+ * @return array
+ */
+ private static function build_headers_for_post() {
+ $password = self::maybe_get_pro_license();
+
+ if ( false === $password ) {
+ $password = 'lite_' . self::get_uuid();
+ }
+
+ $site_url = home_url();
+ $site_url = self::maybe_fix_wpml_url( $site_url );
+ // Remove protocol from url (our url cannot include the colon).
+ $site_url = preg_replace( '#^https?://#', '', $site_url );
+ // Remove port from url (mostly helpful in development).
+ $site_url = preg_replace( '/:[0-9]+/', '', $site_url );
+ $site_url = self::strip_lang_from_url( $site_url );
+
+ // $password is either a Pro license or a uuid (See FrmUsage::uuid).
+ return array(
+ 'Authorization' => 'Basic ' . base64_encode( $site_url . ':' . $password ),
+ );
+ }
+
+ /**
+ * Get a unique ID to use for connecting Lite users.
+ *
+ * @return string
+ */
+ private static function get_uuid() {
+ $usage = new FrmUsage();
+ return $usage->uuid();
+ }
+
+ /**
+ * WPML might add a language to the url. Don't send that to the server.
+ *
+ * @param string $url URL to strip language from.
+ *
+ * @return string
+ */
+ private static function strip_lang_from_url( $url ) {
+ $split_on_language = explode( '/?lang=', $url );
+ return 2 === count( $split_on_language ) ? $split_on_language[0] : $url;
+ }
+
+ /**
+ * WPML alters the output of home_url.
+ * If it is active, use the WPML "absolute home" URL which is not modified.
+ *
+ * @param string $url URL to maybe fix.
+ *
+ * @return string
+ */
+ private static function maybe_fix_wpml_url( $url ) {
+ if ( defined( 'ICL_SITEPRESS_VERSION' ) && ! ICL_PLUGIN_INACTIVE && class_exists( 'SitePress' ) ) {
+ global $wpml_url_converter;
+ $url = $wpml_url_converter->get_abs_home();
+ }
+ return $url;
+ }
+
+ /**
+ * Get a Pro license when Pro is active.
+ * Otherwise we'll use a uuid to support Lite.
+ *
+ * @return false|string
+ */
+ private static function maybe_get_pro_license() {
+ if ( FrmAppHelper::pro_is_installed() ) {
+ $pro_license = FrmAddonsController::get_pro_license();
+
+ if ( $pro_license ) {
+ $password = $pro_license;
+ }
+ }
+
+ return ! empty( $password ) ? $password : false;
+ }
+
+ /**
+ * Try to make sure the server time limit exceeds the request time limit.
+ *
+ * @param int $timeout seconds.
+ *
+ * @return void
+ */
+ private static function try_to_extend_server_timeout( $timeout ) {
+ if ( function_exists( 'set_time_limit' ) ) {
+ set_time_limit( $timeout + 10 );
+ }
+ }
+
+ /**
+ * @param string $mode either 'auto', 'live', or 'test'.
+ *
+ * @return string
+ */
+ private static function get_server_side_token_option_name( $mode = 'auto' ) {
+ return self::get_paypal_connect_option_name( 'server_password', $mode );
+ }
+
+ /**
+ * @param string $mode either 'auto', 'live', or 'test'.
+ *
+ * @return string
+ */
+ private static function get_tracking_id_option_name( $mode = 'auto' ) {
+ return self::get_paypal_connect_option_name( 'tracking_id', $mode );
+ }
+
+ /**
+ * Generate a new client password for authenticating with Connect Service and save it locally as an option.
+ *
+ * @param string $mode 'live' or 'test'.
+ *
+ * @return string the client password.
+ */
+ private static function generate_client_password( $mode ) {
+ $client_password = wp_generate_password();
+ update_option( self::get_client_side_token_option_name( $mode ), $client_password, false );
+ return $client_password;
+ }
+
+ /**
+ * @param string $mode either 'auto', 'live', or 'test'.
+ *
+ * @return string
+ */
+ private static function get_client_side_token_option_name( $mode = 'auto' ) {
+ return self::get_paypal_connect_option_name( 'client_password', $mode );
+ }
+
+ /**
+ * @param string $mode
+ *
+ * @return string
+ */
+ private static function get_paypal_seller_status_option_name( $mode = 'auto' ) {
+ return self::get_paypal_connect_option_name( 'seller_status', $mode );
+ }
+
+ /**
+ * @return string
+ */
+ private static function get_mode_value() {
+ $settings = FrmPayPalLiteAppHelper::get_settings();
+ return $settings->settings->test_mode ? 'test' : 'live';
+ }
+
+ /**
+ * @param string $mode either 'auto', 'live', or 'test'.
+ *
+ * @return bool|string
+ */
+ public static function get_merchant_id( $mode = 'auto' ) {
+ if ( 'auto' === $mode ) {
+ $mode = self::get_mode_value();
+ }
+ return get_option( self::get_merchant_id_option_name( $mode ) );
+ }
+
+ /**
+ * @param string $mode either 'auto', 'live', or 'test'.
+ *
+ * @return string
+ */
+ private static function get_merchant_id_option_name( $mode = 'auto' ) {
+ return self::get_paypal_connect_option_name( 'merchant_id', $mode );
+ }
+
+ /**
+ * @param string $mode either 'auto', 'live', or 'test'.
+ *
+ * @return string
+ */
+ private static function get_merchant_currency_option_name( $mode = 'auto' ) {
+ return self::get_paypal_connect_option_name( 'merchant_currency', $mode );
+ }
+
+ /**
+ * @param string $key 'merchant_id', 'client_password', 'server_password'.
+ * @param string $mode either 'auto', 'live', or 'test'.
+ *
+ * @return string
+ */
+ private static function get_paypal_connect_option_name( $key, $mode = 'auto' ) {
+ return 'frm_paypal_connect_' . $key . self::get_active_mode_option_name_suffix( $mode );
+ }
+
+ /**
+ * @param string $mode either 'auto', 'live', or 'test'.
+ *
+ * @return string either _test or _live.
+ */
+ private static function get_active_mode_option_name_suffix( $mode = 'auto' ) {
+ if ( 'auto' !== $mode ) {
+ return '_' . $mode;
+ }
+ return '_' . FrmPayPalLiteAppHelper::active_mode();
+ }
+
+ public static function check_for_redirects() {
+ if ( self::user_landed_on_the_oauth_return_url() ) {
+ self::redirect_oauth();
+ }
+ }
+
+ /**
+ * @return bool
+ */
+ private static function user_landed_on_the_oauth_return_url() {
+ return isset( $_GET['frm_paypal_api_return_oauth'] );
+ }
+
+ private static function redirect_oauth() {
+ $connected = self::check_server_for_oauth_merchant_id();
+ wp_safe_redirect( self::get_url_for_paypal_settings( $connected ) );
+ exit;
+ }
+
+ /**
+ * @param bool $connected
+ *
+ * @return string
+ */
+ private static function get_url_for_paypal_settings( $connected ) {
+ return admin_url( 'admin.php?page=formidable-settings&t=paypal_settings&connected=' . intval( $connected ) );
+ }
+
+ /**
+ * @return bool
+ */
+ private static function check_server_for_oauth_merchant_id() {
+ $mode = 'test' === FrmAppHelper::simple_get( 'mode' ) ? 'test' : 'live';
+ $tracking_id = get_option( self::get_tracking_id_option_name( $mode ) );
+ $is_reconnect = (bool) $tracking_id;
+
+ if ( self::get_merchant_id( $mode ) && ! $is_reconnect ) {
+ // Do not allow for initialize if there is already a configured merchant id,
+ // unless a tracking_id is stored, which indicates the user is re-onboarding
+ // after an incomplete OAuth integration and the new credentials must be synced.
+ return false;
+ }
+
+ $body = array(
+ 'server_password' => get_option( self::get_server_side_token_option_name( $mode ) ),
+ 'client_password' => get_option( self::get_client_side_token_option_name( $mode ) ),
+ 'frm_paypal_api_mode' => $mode,
+ );
+
+ if ( $tracking_id ) {
+ $body['tracking_id'] = $tracking_id;
+ }
+
+ $data = self::post_to_connect_server( 'oauth_merchant_status', $body );
+
+ if ( is_object( $data ) && ! empty( $data->merchant_id ) ) {
+ update_option( self::get_merchant_id_option_name( $mode ), $data->merchant_id, false );
+
+ // Invalidate the cached seller status so the next render fetches fresh data
+ // with the newly synced credentials.
+ delete_option( self::get_paypal_seller_status_option_name( $mode ) );
+
+ FrmTransLiteAppController::install();
+
+ return true;
+ }
+
+ return false;
+ }
+
+ /**
+ * @param string $action
+ * @param array $additional_body
+ *
+ * @return false|object
+ */
+ private static function post_with_authenticated_body( $action, $additional_body = array() ) {
+ $body = array_merge( self::get_standard_authenticated_body(), $additional_body );
+ $response = self::post_to_connect_server( $action, $body );
+
+ if ( is_object( $response ) ) {
+ return $response;
+ }
+
+ if ( is_array( $response ) ) {
+ // Arrays with error data (e.g., from mock responses) should be preserved
+ // Only convert empty arrays to empty objects
+ if ( ! empty( $response ) ) {
+ // Check if this is an error response with message and debug_id
+ if ( isset( $response['message'] ) && ( isset( $response['debug_id'] ) || isset( $response['debugId'] ) ) ) {
+ self::$latest_error_from_paypal_api = $response['message'];
+ // PayPal API returns debug_id (snake_case) in some cases and debugId (camelCase) in others
+ self::$latest_debug_id_from_paypal_api = $response['debug_id'] ?? $response['debugId'] ?? '';
+ if ( class_exists( 'FrmTransLiteLog' ) ) {
+ FrmTransLiteLog::log_message( 'PayPal API Error', $response['message'] );
+ }
+ // Return the array with error details so the caller can extract them
+ return (object) $response;
+ }
+ // Convert array to object for consistency
+ return (object) $response;
+ }
+ return new stdClass();
+ }
+
+ if ( is_string( $response ) ) {
+ self::$latest_error_from_paypal_api = $response;
+ // Extract debug_id from formatted error string if present
+ if ( preg_match( '/{{debug_id:([^}]+)}}/', $response, $matches ) ) {
+ self::$latest_debug_id_from_paypal_api = $matches[1];
+ // Remove the debug_id token from the error message for display
+ self::$latest_error_from_paypal_api = preg_replace( '/\s*{{debug_id:[^}]+}}/', '', $response );
+ }
+ FrmTransLiteLog::log_message( 'PayPal API Error', $response );
+ } else {
+ self::$latest_error_from_paypal_api = '';
+ }
+
+ return false;
+ }
+
+ /**
+ * @return array
+ */
+ private static function get_standard_authenticated_body() {
+ $mode = self::get_mode_value_from_post();
+ return array(
+ 'merchant_id' => get_option( self::get_merchant_id_option_name( $mode ) ),
+ 'server_password' => get_option( self::get_server_side_token_option_name( $mode ) ),
+ 'client_password' => get_option( self::get_client_side_token_option_name( $mode ) ),
+ );
+ }
+
+ /**
+ * Check $_POST for live or test mode value as it can be updated in real time from PayPal Settings and can be configured before the update is saved.
+ *
+ * @return string 'test' or 'live'
+ */
+ private static function get_mode_value_from_post() {
+ // phpcs:ignore WordPress.Security.NonceVerification.Missing
+ if ( empty( $_POST ) || ! array_key_exists( 'testMode', $_POST ) ) {
+ return FrmPayPalLiteAppHelper::active_mode();
+ }
+
+ $test_mode = FrmAppHelper::get_param( 'testMode', '', 'post', 'absint' );
+ return $test_mode ? 'test' : 'live';
+ }
+
+ /**
+ * @return string|null
+ */
+ public static function get_latest_error_from_paypal_api() {
+ return self::$latest_error_from_paypal_api;
+ }
+
+ /**
+ * @return string
+ */
+ public static function get_latest_debug_id_from_paypal_api() {
+ return self::$latest_debug_id_from_paypal_api;
+ }
+
+ /**
+ * @return array
+ */
+ public static function get_unprocessed_event_ids() {
+ $data = self::post_with_authenticated_body( 'get_unprocessed_event_ids' );
+
+ if ( false === $data || empty( $data->event_ids ) ) {
+ return array();
+ }
+
+ /**
+ * @var array $data->event_ids
+ */
+ return $data->event_ids;
+ }
+
+ /**
+ * @param string $event_id
+ *
+ * @return false|object
+ */
+ public static function get_event( $event_id ) {
+ $event = wp_cache_get( $event_id, 'frm_paypal' );
+
+ if ( is_object( $event ) ) {
+ return $event;
+ }
+
+ $event = self::post_with_authenticated_body( 'get_event', compact( 'event_id' ) );
+
+ if ( false === $event || empty( $event->event ) ) {
+ return false;
+ }
+
+ wp_cache_set( $event_id, $event->event, 'frm_paypal' );
+
+ return $event->event;
+ }
+
+ /**
+ * @param string $event_id
+ *
+ * @return false|object
+ */
+ public static function process_event( $event_id ) {
+ return self::post_with_authenticated_body( 'process_event', compact( 'event_id' ) );
+ }
+
+ public static function handle_disconnect() {
+ self::disconnect();
+ self::reset_paypal_api_integration();
+ wp_send_json_success();
+ }
+
+ /**
+ * @return false|object
+ */
+ private static function disconnect() {
+ $additional_body = array(
+ 'frm_paypal_api_mode' => self::get_mode_value_from_post(),
+ );
+ return self::post_with_authenticated_body( 'disconnect', $additional_body );
+ }
+
+ /**
+ * Delete every PayPal API option, calling when disconnecting.
+ *
+ * @return void
+ */
+ public static function reset_paypal_api_integration() {
+ $mode = self::get_mode_value_from_post();
+ delete_option( self::get_merchant_id_option_name( $mode ) );
+ delete_option( self::get_server_side_token_option_name( $mode ) );
+ delete_option( self::get_client_side_token_option_name( $mode ) );
+ delete_option( self::get_merchant_currency_option_name( $mode ) );
+ delete_option( self::get_paypal_seller_status_option_name( $mode ) );
+ delete_option( self::get_tracking_id_option_name( $mode ) );
+ }
+
+ /**
+ * @since x.x
+ *
+ * @return bool
+ */
+ public static function at_least_one_mode_is_setup() {
+ return self::get_merchant_id( 'test' ) || self::get_merchant_id( 'live' );
+ }
+
+ /**
+ * Verify a site identifier is a match.
+ */
+ public static function verify() {
+ $option_name = 'frm_paypal_lite_last_verify_attempt';
+ $last_request = get_option( $option_name );
+
+ if ( $last_request && $last_request > strtotime( '-1 day' ) ) {
+ wp_send_json_error( 'Too many requests' );
+ }
+
+ $site_identifier = FrmAppHelper::get_post_param( 'site_identifier' );
+ $usage = new FrmUsage();
+
+ update_option( $option_name, time() );
+
+ if ( $site_identifier === $usage->uuid() ) {
+ wp_send_json_success();
+ }
+
+ wp_send_json_error();
+ }
+
+ /**
+ * Create a PayPal order.
+ *
+ * @param string $amount
+ * @param string $currency
+ * @param string $payment_source Valid values are 'card', 'paypal'.
+ * @param array $payer
+ * @param string $shipping_preference
+ * @param array $pricing_data Optional. Array of products with prices and quantities.
+ * @param array $shipping Optional. Shipping name and address data.
+ *
+ * @return false|object
+ */
+ public static function create_order( $amount, $currency, $payment_source, $payer, $shipping_preference, $pricing_data = array(), $shipping = array() ) {
+ $brand_name = self::get_brand_name();
+
+ // Log pricing data for debugging if FrmLog is available
+ if ( class_exists( 'FrmLog' ) && $pricing_data ) {
+ $log = new FrmLog();
+ $log->add(
+ array(
+ 'title' => 'PayPal Order: Pricing Data',
+ 'content' => print_r( $pricing_data, true ),
+ )
+ );
+ }
+
+ return self::post_with_authenticated_body( 'create_order', compact( 'amount', 'currency', 'payment_source', 'brand_name', 'payer', 'shipping_preference', 'pricing_data', 'shipping' ) );
+ }
+
+ /**
+ * @since x.x
+ *
+ * @return string
+ */
+ private static function get_brand_name() {
+ $brand_name = get_bloginfo( 'name' );
+
+ /**
+ * Allow people to modify the brand name used in the PayPal order.
+ *
+ * @since x.x
+ *
+ * @param string $brand_name
+ *
+ * @return string
+ */
+ $filtered_brand_name = apply_filters( 'frm_paypal_brand_name', $brand_name );
+
+ if ( is_string( $filtered_brand_name ) ) {
+ return $filtered_brand_name;
+ }
+
+ _doing_it_wrong( 'FrmPayPalLiteConnectHelper::get_brand_name', 'The frm_paypal_brand_name filter must return a string.', 'x.x' );
+
+ return $brand_name;
+ }
+
+ /**
+ * @param string $order_id
+ *
+ * @return false|object
+ */
+ public static function capture_order( $order_id ) {
+ return self::post_with_authenticated_body( 'capture_order', compact( 'order_id' ) );
+ }
+
+ /**
+ * @param string $capture_id
+ *
+ * @return false|object
+ */
+ public static function refund_payment( $capture_id ) {
+ return self::post_with_authenticated_body( 'refund_capture', array( 'capture_id' => $capture_id ) );
+ }
+
+ /**
+ * @param string $subscription_id
+ *
+ * @return false|object
+ */
+ public static function cancel_subscription( $subscription_id ) {
+ return self::post_with_authenticated_body( 'cancel_subscription', compact( 'subscription_id' ) );
+ }
+
+ /**
+ * @param array $data Subscription data.
+ *
+ * @return false|object
+ */
+ public static function create_subscription( $data ) {
+ $data['brand_name'] = self::get_brand_name();
+ return self::post_with_authenticated_body( 'create_subscription', compact( 'data' ) );
+ }
+
+ /**
+ * @since x.x
+ *
+ * @param array $data Setup token data including payment_source.
+ *
+ * @return false|object
+ */
+ public static function create_vault_setup_token( $data = array() ) {
+ return self::post_with_authenticated_body( 'create_vault_setup_token', compact( 'data' ) );
+ }
+
+ /**
+ * @return false|object
+ */
+ public static function get_seller_status() {
+ $mode = self::get_mode_value_from_post();
+ $status = get_option( self::get_paypal_seller_status_option_name( $mode ) );
+
+ if ( is_object( $status ) ) {
+ return $status;
+ }
+
+ return self::post_with_authenticated_body( 'get_seller_status' );
+ }
+
+ /**
+ * @since x.x
+ *
+ * @param string $capture_id
+ *
+ * @return false|object
+ */
+ public static function get_capture( $capture_id ) {
+ return self::post_with_authenticated_body( 'get_capture', compact( 'capture_id' ) );
+ }
+
+ /**
+ * @since x.x
+ *
+ * @param string $order_id
+ *
+ * @return false|object
+ */
+ public static function get_order( $order_id ) {
+ return self::post_with_authenticated_body( 'get_order', compact( 'order_id' ) );
+ }
+
+ /**
+ * @since x.x
+ *
+ * @param string $subscription_id The PayPal subscription ID.
+ *
+ * @return false|object
+ */
+ public static function get_subscription( $subscription_id ) {
+ return self::post_with_authenticated_body( 'get_subscription', compact( 'subscription_id' ) );
+ }
+
+ /**
+ * @since x.x
+ *
+ * @param string $mode
+ *
+ * @return string
+ */
+ public static function get_bn_code() {
+ return 'Strategy11LLCPPCP_SP';
+ }
+}
diff --git a/paypal/images/amex.svg b/paypal/images/amex.svg
new file mode 100644
index 0000000000..22dafe4e86
--- /dev/null
+++ b/paypal/images/amex.svg
@@ -0,0 +1 @@
+
diff --git a/paypal/images/apple-pay.svg b/paypal/images/apple-pay.svg
new file mode 100644
index 0000000000..5733474aa1
--- /dev/null
+++ b/paypal/images/apple-pay.svg
@@ -0,0 +1,16 @@
+
+
+
diff --git a/paypal/images/discover.svg b/paypal/images/discover.svg
new file mode 100644
index 0000000000..e6ee965659
--- /dev/null
+++ b/paypal/images/discover.svg
@@ -0,0 +1 @@
+
diff --git a/paypal/images/gpay.svg b/paypal/images/gpay.svg
new file mode 100644
index 0000000000..238108a6a4
--- /dev/null
+++ b/paypal/images/gpay.svg
@@ -0,0 +1 @@
+
\ No newline at end of file
diff --git a/paypal/images/mastercard.svg b/paypal/images/mastercard.svg
new file mode 100644
index 0000000000..73b6a4d6ba
--- /dev/null
+++ b/paypal/images/mastercard.svg
@@ -0,0 +1,14 @@
+
diff --git a/paypal/images/visa.svg b/paypal/images/visa.svg
new file mode 100644
index 0000000000..c2e790a0d9
--- /dev/null
+++ b/paypal/images/visa.svg
@@ -0,0 +1,11 @@
+
diff --git a/paypal/js/action.js b/paypal/js/action.js
new file mode 100644
index 0000000000..0c40d6f40f
--- /dev/null
+++ b/paypal/js/action.js
@@ -0,0 +1,22 @@
+( function() {
+ const actions = document.getElementById( 'frm_notification_settings' );
+ if ( ! actions ) {
+ return;
+ }
+
+ jQuery( actions ).on( 'change', 'select[name*="[post_content][layout]"]', onLayoutChange );
+
+ function onLayoutChange() {
+ const settings = this.closest( '.frm_form_action_settings' );
+ if ( ! settings ) {
+ return;
+ }
+
+ const buttonSettings = settings.querySelector( '.frm_paypal_button_settings' );
+ if ( ! buttonSettings ) {
+ return;
+ }
+
+ buttonSettings.classList.toggle( 'frm_hidden', 'card_only' === this.value );
+ }
+}() );
diff --git a/paypal/js/frontend.js b/paypal/js/frontend.js
new file mode 100644
index 0000000000..2c19026a46
--- /dev/null
+++ b/paypal/js/frontend.js
@@ -0,0 +1,1955 @@
+/**
+ * PayPal Payment Integration - Radio-Based Payment Method Selector.
+ *
+ * Architecture:
+ * - A radio group lets the user pick their payment method (Card, PayPal, Venmo, etc.).
+ * - Only the selected method's UI is visible at a time.
+ * - Card + PayPal are pre-rendered on init (hybrid approach).
+ * - Other methods (Venmo, Google Pay, etc.) are lazy-rendered on first selection, then cached.
+ * - When Card is selected: card fields + native submit button are shown.
+ * - When any button method is selected: the submit button is hidden and only that button is shown.
+ */
+( function() {
+ if ( ! window.frmPayPalVars ) {
+ return;
+ }
+
+ // ---- State ----
+
+ let thisForm = null;
+ let running = 0;
+ let cardFieldsInstance = null;
+ let cardFieldsValid = false;
+ let submitEvent = null;
+ let isRecurring = false;
+
+ /**
+ * Registry of available payment methods.
+ * Populated during init based on SDK eligibility checks.
+ *
+ * @type {Map}
+ */
+ const paymentMethods = new Map();
+
+ /** Currently selected payment method key. */
+ let selectedMethod = null;
+
+ /** Cached Google Pay config from paypal.Googlepay().config(). */
+ let googlePayConfig = null;
+
+ /** Cached Apple Pay config from paypal.Applepay().config(). */
+ let applePayConfig = null;
+
+ // ---- Constants ----
+
+ /**
+ * Human-readable labels for funding sources.
+ */
+ const METHOD_LABELS = {
+ card: 'Credit Card',
+ paypal: 'PayPal',
+ venmo: 'Venmo',
+ paylater: 'Pay Later',
+ google_pay: 'Google Pay',
+ apple_pay: 'Apple Pay',
+ bancontact: 'Bancontact',
+ blik: 'BLIK',
+ eps: 'EPS',
+ p24: 'Przelewy24',
+ trustly: 'Trustly',
+ satispay: 'Satispay',
+ sepa: 'SEPA',
+ mybank: 'MyBank',
+ ideal: 'iDEAL',
+ };
+
+ /**
+ * Maps internal method keys to PayPal FUNDING constants for the Marks API.
+ * Card and Google Pay use local images instead of PayPal Marks.
+ */
+ const METHOD_FUNDING_SOURCE = {
+ paypal: 'paypal',
+ venmo: 'venmo',
+ paylater: 'paylater',
+ bancontact: 'bancontact',
+ blik: 'blik',
+ eps: 'eps',
+ p24: 'p24',
+ trustly: 'trustly',
+ satispay: 'satispay',
+ sepa: 'sepa',
+ mybank: 'mybank',
+ ideal: 'ideal',
+ };
+
+ /**
+ * Methods that should be pre-rendered on init (hybrid approach).
+ * Everything else is lazy-rendered on first selection.
+ */
+ const PRE_RENDER_METHODS = new Set( [ 'card', 'paypal' ] );
+
+ /**
+ * Base request object shared by isReadyToPay and PaymentDataRequest.
+ */
+ const googlePayBaseRequest = {
+ apiVersion: 2,
+ apiVersionMinor: 0
+ };
+
+ // ---- Initialization ----
+
+ /**
+ * Main entry point.
+ */
+ async function paypalInit() {
+ const cardElement = document.querySelector( '.frm-card-element' );
+ if ( ! cardElement ) {
+ return;
+ }
+
+ thisForm = cardElement.closest( 'form' );
+ if ( ! thisForm ) {
+ return;
+ }
+
+ const settings = getPayPalSettings()[ 0 ];
+ if ( ! settings ) {
+ return;
+ }
+
+ isRecurring = 'single' !== settings.one;
+ const { layout } = settings;
+ const cardFieldsAreSupported = layout !== 'checkout_only' && 'function' === typeof window.paypal.CardFields;
+ const buttonsAreEnabled = layout !== 'card_only' && 'function' === typeof window.paypal.Buttons;
+
+ // Clear the card element. We rebuild it entirely.
+ cardElement.innerHTML = '';
+
+ // 1. Discover eligible methods and register them.
+ await discoverPaymentMethods( {
+ cardFieldsAreSupported,
+ buttonsAreEnabled,
+ isRecurring
+ } );
+
+ if ( paymentMethods.size === 0 ) {
+ displayPaymentFailure( 'No payment methods available.' );
+ return;
+ }
+
+ // 2. Build the radio selector UI, then render marks after it's in the DOM.
+ const radioGroup = buildRadioGroup();
+ cardElement.append( radioGroup );
+ renderMarks();
+
+ // 3. Build a container area for each method's UI (buttons / card fields).
+ const methodArea = document.createElement( 'div' );
+ methodArea.classList.add( 'frm-payment-method-area' );
+ cardElement.append( methodArea );
+
+ for ( const [ key, method ] of paymentMethods ) {
+ const container = document.createElement( 'div' );
+ container.id = `frm-payment-method-${ key }`;
+ container.classList.add( 'frm-payment-method-container' );
+ methodArea.append( container );
+ method.containerEl = container;
+ }
+
+ // 4. Pre-render Card + PayPal (hybrid approach).
+ for ( const key of PRE_RENDER_METHODS ) {
+ const method = paymentMethods.get( key );
+ if ( method?.eligible ) {
+ try {
+ await method.render();
+ method.rendered = true;
+ } catch ( err ) {
+ console.error( `Failed to pre-render payment method: ${ key }`, err );
+ }
+ }
+ }
+
+ // 5. Auto-select the first eligible method.
+ const firstKey = paymentMethods.keys().next().value;
+ await selectPaymentMethod( firstKey );
+
+ // 6. Attach form submit handler (for card method).
+ thisForm.addEventListener( 'submit', handleFormSubmission );
+
+ // 7. Pay Later messages.
+ if ( paymentMethods.has( 'paylater' ) ) {
+ renderMessages();
+ jQuery( document ).on( 'frmFieldChanged', priceChanged );
+ checkPriceFieldsOnLoad();
+ }
+ }
+
+ // ---- Discovery ----
+
+ /**
+ * Discover which payment methods are eligible and register them.
+ *
+ * @param {Object} opts Config flags.
+ */
+ async function discoverPaymentMethods( opts ) {
+ const { cardFieldsAreSupported, buttonsAreEnabled, isRecurring } = opts;
+
+ // --- Card Fields ---
+ if ( cardFieldsAreSupported ) {
+ const cardFields = createCardFieldsSDKInstance();
+ if ( cardFields?.isEligible() ) {
+ cardFieldsInstance = cardFields;
+ registerMethod( 'card', {
+ eligible: true,
+ render: renderCardFields
+ } );
+ }
+ }
+
+ // --- PayPal button ---
+ if ( buttonsAreEnabled ) {
+ const paypalBtn = createPayPalButton( paypal.FUNDING.PAYPAL, isRecurring );
+ if ( paypalBtn.isEligible() ) {
+ registerMethod( 'paypal', {
+ eligible: true,
+ buttonInstance: paypalBtn,
+ render() {
+ this.buttonInstance.render( `#${ this.containerEl.id }` );
+ }
+ } );
+ }
+ }
+
+ // --- Alternative funding sources ---
+ if ( buttonsAreEnabled ) {
+ const fundingSources = [
+ { key: 'venmo', funding: paypal.FUNDING.VENMO },
+ { key: 'paylater', funding: paypal.FUNDING.PAYLATER },
+ { key: 'bancontact', funding: paypal.FUNDING.BANCONTACT },
+ { key: 'blik', funding: paypal.FUNDING.BLIK },
+ { key: 'eps', funding: paypal.FUNDING.EPS },
+ { key: 'p24', funding: paypal.FUNDING.P24 },
+ { key: 'trustly', funding: paypal.FUNDING.TRUSTLY },
+ { key: 'satispay', funding: paypal.FUNDING.SATISPAY },
+ { key: 'sepa', funding: paypal.FUNDING.SEPA },
+ { key: 'mybank', funding: paypal.FUNDING.MYBANK },
+ { key: 'ideal', funding: paypal.FUNDING.IDEAL },
+ ];
+
+ for ( const { key, funding } of fundingSources ) {
+ const btn = createPayPalButton( funding, isRecurring );
+ if ( btn.isEligible() ) {
+ registerMethod( key, {
+ eligible: true,
+ buttonInstance: btn,
+ render() {
+ this.buttonInstance.render( `#${ this.containerEl.id }` );
+ }
+ } );
+ }
+ }
+ }
+
+ // --- Google Pay ---
+ if ( buttonsAreEnabled && ! isRecurring ) {
+ const googlePayEligible = await checkGooglePayEligibility();
+ if ( googlePayEligible ) {
+ registerMethod( 'google_pay', {
+ eligible: true,
+ render: renderGooglePayButton
+ } );
+ }
+ }
+
+ // --- Apple Pay ---
+ if ( buttonsAreEnabled && ! isRecurring ) {
+ const applePayEligibilityResult = await checkApplePayEligibility();
+ if ( applePayEligibilityResult === '' ) {
+ registerMethod( 'apple_pay', {
+ eligible: true,
+ render: renderApplePayButton
+ } );
+ }
+ }
+ }
+
+ /**
+ * Register a payment method in the registry.
+ *
+ * @param {string} key Unique identifier.
+ * @param {Object} config Method configuration.
+ */
+ function registerMethod( key, config ) {
+ paymentMethods.set( key, {
+ key,
+ label: METHOD_LABELS[ key ] || key,
+ eligible: config.eligible || false,
+ rendered: false,
+ containerEl: null,
+ buttonInstance: config.buttonInstance || null,
+ render: config.render || ( () => {} ),
+ } );
+ }
+
+ // ---- Radio Group UI ----
+
+ /**
+ * Build the radio button group for payment method selection.
+ * Each option is a card-like row with a radio, label, description, and PayPal Mark logo.
+ *
+ * @return {HTMLElement} The radio group container.
+ */
+ function buildRadioGroup() {
+ const group = document.createElement( 'div' );
+ group.classList.add( 'frm-payment-method-selector' );
+ group.setAttribute( 'role', 'radiogroup' );
+ group.setAttribute( 'aria-label', 'Select payment method' );
+
+ for ( const [ key, method ] of paymentMethods ) {
+ const label = document.createElement( 'label' );
+ label.classList.add( 'frm-payment-method-option' );
+ label.setAttribute( 'for', `frm-payment-method-radio-${ key }` );
+
+ const radio = document.createElement( 'input' );
+ radio.type = 'radio';
+ radio.name = 'frm_payment_method';
+ radio.id = `frm-payment-method-radio-${ key }`;
+ radio.value = key;
+
+ radio.addEventListener( 'change', () => selectPaymentMethod( key ) );
+
+ // Text column: label + description.
+ const textWrap = document.createElement( 'div' );
+ textWrap.classList.add( 'frm-payment-method-text' );
+
+ const labelText = document.createElement( 'span' );
+ labelText.classList.add( 'frm-payment-method-label-text' );
+ labelText.textContent = method.label;
+ textWrap.append( labelText );
+
+ // Mark column: will be populated by renderMarks() after the group is in the DOM.
+ const markWrap = document.createElement( 'div' );
+ markWrap.classList.add( 'frm-payment-method-mark' );
+ markWrap.id = `frm-payment-mark-${ key }`;
+
+ const baseUrl = frmPayPalVars.imagesUrl || '';
+
+ if ( key === 'card' ) {
+ const cardBrands = [
+ { file: 'visa.svg', alt: 'Visa' },
+ { file: 'mastercard.svg', alt: 'Mastercard' },
+ { file: 'amex.svg', alt: 'American Express' },
+ { file: 'discover.svg', alt: 'Discover' },
+ ];
+ cardBrands.forEach( function( brand ) {
+ const img = document.createElement( 'img' );
+ img.src = baseUrl + brand.file;
+ img.alt = brand.alt;
+ img.height = 24;
+ markWrap.append( img );
+ } );
+ } else if ( key === 'google_pay' ) {
+ markWrap.classList.add( 'frm-payment-method-google-pay-icon' );
+ const img = document.createElement( 'img' );
+ img.src = `${ baseUrl }gpay.svg`;
+ img.alt = 'Google Pay';
+ img.height = 24;
+ markWrap.append( img );
+ } else if ( key === 'apple_pay' ) {
+ markWrap.classList.add( 'frm-payment-method-apple-pay-icon' );
+ const img = document.createElement( 'img' );
+ img.src = `${ baseUrl }apple-pay.svg`;
+ img.alt = 'Apple Pay';
+ img.height = 24;
+ img.style.width = 'auto';
+ markWrap.append( img );
+ }
+
+ label.append( radio );
+ label.append( textWrap );
+ label.append( markWrap );
+
+ if ( key === 'paylater' ) {
+ // Wrap the label and a message container in a div.
+ const wrapper = document.createElement( 'div' );
+ wrapper.classList.add( 'frm-payment-method-paylater-wrap' );
+ wrapper.append( label );
+
+ const msgContainer = document.createElement( 'div' );
+ msgContainer.id = 'frm-paylater-message';
+ msgContainer.classList.add( 'frm-payment-method-paylater-msg' );
+ wrapper.append( msgContainer );
+
+ group.append( wrapper );
+ } else {
+ group.append( label );
+ }
+ }
+
+ return group;
+ }
+
+ /**
+ * Render PayPal Marks into the radio group containers.
+ * Must be called AFTER the radio group is appended to the DOM,
+ * because the Marks API needs the containers to be in the document.
+ */
+ function renderMarks() {
+ if ( 'function' !== typeof paypal.Marks ) {
+ return;
+ }
+
+ for ( const [ key ] of paymentMethods ) {
+ const fundingSource = METHOD_FUNDING_SOURCE[ key ];
+ if ( ! fundingSource ) {
+ continue;
+ }
+
+ const markContainerId = `frm-payment-mark-${ key }`;
+ const container = document.getElementById( markContainerId );
+ if ( ! container ) {
+ continue;
+ }
+
+ try {
+ const mark = paypal.Marks( { fundingSource } );
+ if ( mark.isEligible() ) {
+ mark.render( `#${ markContainerId }` );
+ }
+ } catch ( err ) {
+ // Mark not available for this source, that's fine.
+ }
+ }
+ }
+
+ // ---- Method Selection ----
+
+ /**
+ * Handle switching to a new payment method.
+ *
+ * 1. Lazy-render if this method hasn't been rendered yet.
+ * 2. Hide all method containers.
+ * 3. Show the selected method's container.
+ * 4. Toggle submit button visibility.
+ *
+ * @param {string} key The payment method key to select.
+ */
+ async function selectPaymentMethod( key ) {
+ const method = paymentMethods.get( key );
+ if ( ! method ) {
+ return;
+ }
+
+ selectedMethod = key;
+
+ // Update radio checked state.
+ const radio = document.getElementById( `frm-payment-method-radio-${ key }` );
+ if ( radio && ! radio.checked ) {
+ radio.checked = true;
+ }
+
+ // Lazy-render if this is the first time selecting a non-pre-rendered method.
+ if ( ! method.rendered ) {
+ method.containerEl.innerHTML = '';
+ try {
+ await method.render();
+ method.rendered = true;
+ } catch ( err ) {
+ console.error( `Failed to render payment method: ${ key }`, err );
+ method.containerEl.innerHTML = '';
+ }
+ }
+
+ // Hide all method containers.
+ for ( const [ , m ] of paymentMethods ) {
+ if ( m.containerEl ) {
+ m.containerEl.style.display = 'none';
+ }
+ }
+
+ // Show the selected one.
+ if ( method.containerEl ) {
+ method.containerEl.style.display = 'block';
+ }
+
+ // Toggle submit button + card fields visibility.
+ updateSubmitButtonVisibility( key );
+
+ // Update active class on radio labels.
+ document.querySelectorAll( '.frm-payment-method-option' ).forEach( el => {
+ el.classList.remove( 'frm-payment-method-active' );
+ } );
+ document.querySelectorAll( '.frm-payment-method-paylater-wrap' ).forEach( el => {
+ el.classList.remove( 'frm-payment-method-active-wrap' );
+ } );
+ const activeLabel = radio?.closest( '.frm-payment-method-option' );
+ if ( activeLabel ) {
+ activeLabel.classList.add( 'frm-payment-method-active' );
+ const wrapper = activeLabel.closest( '.frm-payment-method-paylater-wrap' );
+ if ( wrapper ) {
+ wrapper.classList.add( 'frm-payment-method-active-wrap' );
+ }
+ }
+ }
+
+ /**
+ * Show/hide the native submit button based on the selected method.
+ *
+ * - Card: submit button visible (user fills card fields, clicks submit).
+ * - Everything else: submit button hidden (PayPal SDK button handles submission).
+ *
+ * @param {string} key The selected payment method key.
+ */
+ function updateSubmitButtonVisibility( key ) {
+ const submitButtons = thisForm.querySelectorAll(
+ 'input[type="submit"], input[type="button"], button[type="submit"]'
+ );
+ const isCardMethod = key === 'card';
+
+ submitButtons.forEach( btn => {
+ if ( btn.classList.contains( 'frm_prev_page' ) ) {
+ return;
+ }
+
+ if ( isCardMethod ) {
+ btn.style.display = '';
+ if ( cardFieldsValid ) {
+ btn.removeAttribute( 'disabled' );
+ } else {
+ btn.setAttribute( 'disabled', 'disabled' );
+ }
+ } else {
+ btn.style.display = 'none';
+ }
+ } );
+ }
+
+ // ---- Card Fields ----
+
+ /**
+ * Create the PayPal CardFields SDK instance (without rendering).
+ *
+ * @return {Object|null} The card fields instance.
+ */
+ function createCardFieldsSDKInstance() {
+ try {
+ const config = {
+ onError,
+ style: frmPayPalVars.style,
+ inputEvents: {
+ onChange: onCardFieldsChange
+ }
+ };
+
+ if ( isRecurring ) {
+ config.createVaultSetupToken = createVaultSetupToken;
+ config.onApprove = onVaultApprove;
+ } else {
+ config.createOrder = createOrder;
+ config.onApprove = onApprove;
+ }
+
+ return window.paypal.CardFields( config );
+ } catch ( err ) {
+ console.error( 'Failed to create CardFields instance', err );
+ return null;
+ }
+ }
+
+ /**
+ * Handle card field value changes.
+ *
+ * @param {Object} data The onChange event data.
+ */
+ function onCardFieldsChange( data ) {
+ cardFieldsValid = data.isFormValid;
+
+ if ( selectedMethod === 'card' ) {
+ if ( cardFieldsValid ) {
+ enableSubmit();
+ } else {
+ disableSubmit( thisForm );
+ }
+ }
+ }
+
+ /**
+ * Render the card number / expiry / CVV fields into the method container.
+ */
+ function renderCardFields() {
+ const method = paymentMethods.get( 'card' );
+ if ( ! method || ! cardFieldsInstance ) {
+ return;
+ }
+
+ const wrapper = document.createElement( 'div' );
+ wrapper.classList.add( 'frm-card-fields-wrapper', 'frm_grid_container' );
+
+ const cardNumberWrapper = document.createElement( 'div' );
+ cardNumberWrapper.id = 'frm-paypal-card-number';
+ cardNumberWrapper.classList.add( 'frm6', 'frm-payment-card-number' );
+
+ const expiryWrapper = document.createElement( 'div' );
+ expiryWrapper.id = 'frm-paypal-card-expiry';
+ expiryWrapper.classList.add( 'frm3', 'frm-payment-card-expiry' );
+
+ const cvvWrapper = document.createElement( 'div' );
+ cvvWrapper.id = 'frm-paypal-card-cvv';
+ cvvWrapper.classList.add( 'frm3', 'frm-payment-card-cvv' );
+
+ wrapper.append( cardNumberWrapper, expiryWrapper, cvvWrapper );
+ method.containerEl.innerHTML = '';
+ method.containerEl.append( wrapper );
+
+ cardFieldsInstance.NumberField().render( '#frm-paypal-card-number' );
+ cardFieldsInstance.ExpiryField().render( '#frm-paypal-card-expiry' );
+ cardFieldsInstance.CVVField().render( '#frm-paypal-card-cvv' );
+
+ setupCardFieldIframeObservers();
+ }
+
+ /**
+ * Watch for PayPal iframe height changes and add 1px to prevent border clipping.
+ */
+ function setupCardFieldIframeObservers() {
+ const ids = [ 'frm-paypal-card-number', 'frm-paypal-card-expiry', 'frm-paypal-card-cvv' ];
+ const wrappers = ids
+ .map( id => document.getElementById( id )?.querySelector( 'iframe' )?.parentNode )
+ .filter( Boolean );
+
+ if ( ! wrappers.length ) {
+ return;
+ }
+
+ const observerOptions = { attributes: true, attributeFilter: [ 'style' ] };
+
+ const observerCallback = ( mutationsList, observer ) => {
+ observer.disconnect();
+
+ for ( const mutation of mutationsList ) {
+ if ( mutation.type !== 'attributes' || mutation.attributeName !== 'style' ) {
+ continue;
+ }
+
+ const currentHeight = mutation.target.offsetHeight;
+ if ( currentHeight > 0 ) {
+ mutation.target.style.height = `${ currentHeight + 1 }px`;
+ }
+ }
+
+ wrappers.forEach( w => observer.observe( w, observerOptions ) );
+ };
+
+ const observer = new MutationObserver( observerCallback );
+ wrappers.forEach( w => observer.observe( w, observerOptions ) );
+ }
+
+ // ---- PayPal Button Creation ----
+
+ /**
+ * Create a PayPal Buttons instance for a given funding source (without rendering).
+ *
+ * @param {string} fundingSource The PayPal FUNDING constant.
+ * @param {boolean} isRecurring Whether this is a recurring payment.
+ *
+ * @return {Object} The PayPal Buttons instance.
+ */
+ function createPayPalButton( fundingSource, isRecurring ) {
+ const buttonConfig = {
+ fundingSource,
+ onApprove,
+ onError,
+ onCancel,
+ style: { ...frmPayPalVars.buttonStyle },
+ };
+
+ const supportedColors = [ 'silver', 'black', 'white' ];
+ const supportedColorsMap = {
+ venmo: [ 'blue' ],
+ paylater: [ 'gold', 'blue' ]
+ };
+
+ supportedColorsMap[ fundingSource ]?.forEach( color => supportedColors.push( color ) );
+
+ if ( ! supportedColors.includes( buttonConfig.style.color ) ) {
+ delete buttonConfig.style.color;
+ }
+
+ if ( isRecurring ) {
+ buttonConfig.createSubscription = createSubscription;
+ } else {
+ buttonConfig.createOrder = createOrder;
+ }
+
+ return paypal.Buttons( buttonConfig );
+ }
+
+ // ---- Google Pay ----
+
+ /**
+ * Check if Google Pay is eligible (without rendering).
+ *
+ * @return {Promise} Whether Google Pay is supported and ready to accept payments in the current environment.
+ */
+ async function checkGooglePayEligibility() {
+ if ( 'function' !== typeof paypal.Googlepay ) {
+ return false;
+ }
+
+ if ( 'undefined' === typeof google || google.payments === undefined ) {
+ return false;
+ }
+
+ try {
+ googlePayConfig = await paypal.Googlepay().config();
+ const paymentsClient = getGooglePaymentsClient();
+
+ const readyToPayRequest = Object.assign( {}, googlePayBaseRequest, {
+ allowedPaymentMethods: googlePayConfig.allowedPaymentMethods
+ } );
+
+ const response = await paymentsClient.isReadyToPay( readyToPayRequest );
+ return response.result;
+ } catch ( err ) {
+ console.error( 'Google Pay eligibility check failed', err );
+ return false;
+ }
+ }
+
+ /**
+ * Render the Google Pay button into its method container.
+ */
+ async function renderGooglePayButton() {
+ const method = paymentMethods.get( 'google_pay' );
+ if ( ! method || ! googlePayConfig ) {
+ return;
+ }
+
+ const paymentsClient = getGooglePaymentsClient();
+ const buttonOptions = Object.assign(
+ getGooglePayButtonStyle(),
+ {
+ onClick: () => onGooglePayButtonClicked( googlePayConfig ),
+ allowedPaymentMethods: googlePayConfig.allowedPaymentMethods
+ }
+ );
+ const button = paymentsClient.createButton( buttonOptions );
+
+ const container = method.containerEl;
+ container.innerHTML = '';
+ container.append( button );
+ }
+
+ /**
+ * Get a Google PaymentsClient configured for the current environment.
+ *
+ * @return {google.payments.api.PaymentsClient} The payments client instance.
+ */
+ function getGooglePaymentsClient() {
+ return new google.payments.api.PaymentsClient( {
+ environment: 'TEST',
+ paymentDataCallbacks: {
+ onPaymentAuthorized
+ }
+ } );
+ }
+
+ /**
+ * Map frmPayPalVars.buttonStyle to Google Pay ButtonOptions.
+ *
+ * @return {Object} Google Pay button style options.
+ */
+ function getGooglePayButtonStyle() {
+ const style = frmPayPalVars.buttonStyle || {};
+ const options = { buttonSizeMode: 'fill' };
+
+ const colorMap = { black: 'black', white: 'white', silver: 'white' };
+ if ( style.color && colorMap[ style.color ] ) {
+ options.buttonColor = colorMap[ style.color ];
+ }
+
+ const typeMap = { pay: 'pay', checkout: 'checkout', buynow: 'buy', donate: 'donate', subscribe: 'subscribe' };
+ if ( style.label && typeMap[ style.label ] ) {
+ options.buttonType = typeMap[ style.label ];
+ }
+
+ if ( style.borderRadius !== undefined ) {
+ options.buttonRadius = style.borderRadius;
+ }
+
+ return options;
+ }
+
+ /**
+ * Handle Google Pay button click.
+ *
+ * @param {Object} config The config from paypal.Googlepay().config().
+ *
+ * @return {Promise}
+ */
+ async function onGooglePayButtonClicked( config ) {
+ const settings = getPayPalSettings()[ 0 ];
+ const currency = ( settings.currency || 'USD' ).toUpperCase();
+
+ const paymentDataRequest = Object.assign( {}, googlePayBaseRequest );
+ paymentDataRequest.allowedPaymentMethods = config.allowedPaymentMethods;
+ paymentDataRequest.merchantInfo = config.merchantInfo;
+ paymentDataRequest.callbackIntents = [ 'PAYMENT_AUTHORIZATION' ];
+
+ paymentDataRequest.transactionInfo = {
+ currencyCode: currency,
+ totalPriceStatus: 'ESTIMATED',
+ totalPrice: '0.00'
+ };
+
+ try {
+ const amount = await new Promise( ( resolve, reject ) => {
+ getPrice( result => {
+ if ( result?.data?.amount ) {
+ resolve( result.data.amount );
+ } else {
+ reject( new Error( 'No amount' ) );
+ }
+ } );
+ } );
+
+ paymentDataRequest.transactionInfo.totalPrice = String( amount );
+ paymentDataRequest.transactionInfo.totalPriceStatus = 'FINAL';
+ } catch ( e ) {
+ // Fall back to ESTIMATED with 0.00 if we can't get the price.
+ }
+
+ const paymentsClient = getGooglePaymentsClient();
+ paymentsClient.loadPaymentData( paymentDataRequest );
+ }
+
+ /**
+ * Callback invoked by Google Pay when the buyer authorizes the payment.
+ *
+ * @param {Object} paymentData The Google Pay PaymentData response object.
+ *
+ * @return {Promise