' . esc_html__( 'Your message has been sent', 'jetpack-forms' ) . '
' . wp_kses(
$submission_result,
array(
'br' => array(),
'blockquote' => array( 'class' => array() ),
'p' => array(),
)
);
}
die( 0 );
}
/**
* Ensure the post author is always zero for contact-form feedbacks
* Attached to `wp_insert_post_data`
*
* @see Contact_Form::process_submission()
*
* @param array $data the data to insert.
* @param array $postarr the data sent to wp_insert_post().
* @return array The filtered $data to insert.
*/
public function insert_feedback_filter( $data, $postarr ) {
if ( $data['post_type'] === 'feedback' && $postarr['post_type'] === 'feedback' ) {
$data['post_author'] = 0;
}
return $data;
}
/**
* Adds our contact-form shortcode
* The "child" contact-field shortcode is enabled as needed by the contact-form shortcode handler
*/
public function add_shortcode() {
add_shortcode( 'contact-form', array( '\Automattic\Jetpack\Forms\ContactForm\Contact_Form', 'parse' ) );
add_shortcode( 'contact-field', array( '\Automattic\Jetpack\Forms\ContactForm\Contact_Form', 'parse_contact_field' ) );
// We need 'contact-field-option' to be registered, so it's included to the get_shortcode_regex() method
// But we don't need a callback because we're handling contact-field-option manually
add_shortcode( 'contact-field-option', '__return_null' );
}
/**
* Tokenize the label.
*
* @param string $label - the label.
*
* @return string
*/
public static function tokenize_label( $label ) {
return '{' . trim( wp_strip_all_tags( preg_replace( '#^\d+_#', '', $label ) ) ) . '}';
}
/**
* Sanitizes the value of a field.
*
* @param string|array|null $value The value to sanitize.
* @return string The sanitized value.
*/
public static function sanitize_value( $value ) {
if ( null === $value ) {
return '';
}
// If value is an array, convert it to a comma-separated string
if ( is_array( $value ) ) {
return implode( ', ', array_map( array( __CLASS__, 'sanitize_value' ), $value ) );
}
return preg_replace( '=((||0x0A/%0A|0x0D/%0D|\\n|\\r)\S).*=i', '', $value );
}
/**
* Sanitizes and formats values for display, ensuring arrays are properly converted to strings.
*
* @param mixed $value The value to format.
* @return string|array The formatted value ready for display or file array for upload fields.
*/
public static function format_value_for_display( $value ) {
if ( is_array( $value ) ) {
// Check if this is a file upload field
if ( Contact_Form::is_file_upload_field( $value ) ) {
// This is a file upload field, return as is to be handled by the proper renderer
return $value;
}
// Process each array element recursively and join with commas
$formatted_values = array();
foreach ( $value as $key => $item ) {
$formatted_values[] = is_numeric( $key ) ? self::format_value_for_display( $item ) : "$key: " . self::format_value_for_display( $item );
}
return implode( ', ', $formatted_values );
}
// Simple value, just convert to string
return (string) $value;
}
/**
* Replaces tokens like {city} or {City} (case insensitive) with the value
* of an input field of that name
*
* @param string $subject - the subject.
* @param array $field_values Array with field label => field value associations.
*
* @return string The filtered $subject with the tokens replaced.
*/
public function replace_tokens_with_input( $subject, $field_values ) {
// Wrap labels into tokens (inside {})
$wrapped_labels = array_map( array( '\Automattic\Jetpack\Forms\ContactForm\Contact_Form_Plugin', 'tokenize_label' ), array_keys( $field_values ) );
// Sanitize all values
$sanitized_values = array_map( array( '\Automattic\Jetpack\Forms\ContactForm\Contact_Form_Plugin', 'sanitize_value' ), array_values( $field_values ) );
foreach ( $sanitized_values as $k => $sanitized_value ) {
if ( is_array( $sanitized_value ) ) {
$sanitized_values[ $k ] = implode( ', ', $sanitized_value );
}
}
// Search for all valid tokens (based on existing fields) and replace with the field's value
$subject = str_ireplace( $wrapped_labels, $sanitized_values, $subject );
return $subject;
}
/**
* Tracks the widget currently being processed.
* Attached to `dynamic_sidebar`
*
* @see $current_widget_id - the current widget ID.
*
* @param array $widget The widget data.
*/
public function track_current_widget( $widget ) {
$this->current_widget_id = $widget['id'];
}
/**
* Tracks the sidebar currently being processed.
* Attached to `dynamic_sidebar_before`
*
* @see $current_sidebar_id - the current sidebar ID.
*
* @param string $index The sidebar index.
*/
public function track_current_widget_before( $index ) {
$this->current_sidebar_id = $index;
}
/**
* Clear the current widget context.
*/
public function track_current_widget_after() {
$this->current_sidebar_id = '';
$this->current_widget_id = '';
}
/**
* Gets the current widget context.
*
* @return string The current widget context or false if not set.
*/
public function get_current_widget_context() {
// If we don't have a current widget ID or sidebar ID, we
if ( empty( $this->current_widget_id ) || empty( $this->current_sidebar_id ) ) {
return '';
}
return $this->current_widget_id . '-' . $this->current_sidebar_id;
}
/**
* Adds a "widget" attribute to every contact-form embedded in a text widget.
* Used to tell the difference between post-embedded contact-forms and widget-embedded contact-forms
* Attached to `widget_text`
*
* @param string $text The widget text.
*
* @return string The filtered widget text.
*/
public function widget_atts( $text ) {
Contact_Form::style( true );
return preg_replace( '/\[contact-form([^a-zA-Z_-])/', '[contact-form widget="' . $this->current_widget_id . '"\\1', $text );
}
/**
* For sites where text widgets are not processed for shortcodes, we add this hack to process just our shortcode
* Attached to `widget_text`
*
* @param string $text The widget text.
*
* @return string The contact-form filtered widget text
*/
public function widget_shortcode_hack( $text ) {
if ( ! preg_match( '/\[contact-form([^a-zA-Z_-])/', $text ) ) {
return $text;
}
$old = $GLOBALS['shortcode_tags'];
remove_all_shortcodes();
self::$using_contact_form_field = true;
$this->add_shortcode();
$text = do_shortcode( $text );
self::$using_contact_form_field = false;
$GLOBALS['shortcode_tags'] = $old; // phpcs:ignore WordPress.WP.GlobalVariablesOverride.Prohibited
return $text;
}
/**
* Check if a submission matches the Comment Blocklist.
* The Comment Blocklist is a means to moderate discussion, and contact
* forms are 1:1 discussion forums, ripe for abuse by users who are being
* removed from the public discussion.
* Attached to `jetpack_contact_form_is_spam`
*
* @param bool $is_spam - if the submission is spam.
* @param array $form - the form data.
* @return bool TRUE => spam, FALSE => not spam
*/
public function is_spam_blocklist( $is_spam, $form = array() ) {
if ( $is_spam ) {
return $is_spam;
}
return $this->is_in_disallowed_list( false, $form );
}
/**
* Check if a submission matches the comment disallowed list.
* Attached to `jetpack_contact_form_in_comment_disallowed_list`.
*
* @param boolean $in_disallowed_list Whether the feedback is in the disallowed list.
* @param array $form The form array.
* @return bool Returns true if the form submission matches the disallowed list and false if it doesn't.
*/
public function is_in_disallowed_list( $in_disallowed_list, $form = array() ) {
if ( $in_disallowed_list ) {
return $in_disallowed_list;
}
if (
wp_check_comment_disallowed_list(
$form['comment_author'],
$form['comment_author_email'],
$form['comment_author_url'],
$form['comment_content'],
$form['user_ip'],
$form['user_agent']
)
) {
return true;
}
return false;
}
/**
* Populate an array with all values necessary to submit a NEW contact-form feedback to Akismet.
* Note that this includes the current user_ip etc, so this should only be called when accepting a new item via $_POST
*
* @param array $form - contact form feedback array.
*
* @return array feedback array with additional data ready for submission to Akismet.
*/
public function prepare_for_akismet( $form ) {
$form['comment_type'] = 'contact_form';
$form['user_ip'] = isset( $_SERVER['REMOTE_ADDR'] ) ? sanitize_text_field( wp_unslash( $_SERVER['REMOTE_ADDR'] ) ) : '';
$form['user_agent'] = isset( $_SERVER['HTTP_USER_AGENT'] ) ? filter_var( wp_unslash( $_SERVER['HTTP_USER_AGENT'] ) ) : '';
$form['referrer'] = isset( $_SERVER['HTTP_REFERER'] ) ? esc_url_raw( wp_unslash( $_SERVER['HTTP_REFERER'] ) ) : '';
$form['blog'] = get_option( 'home' );
$form['comment_date_gmt'] = gmdate( DATE_ATOM, time() ); // ISO 8601. See https://www.php.net/manual/en/class.datetimeinterface.php#datetimeinterface.constants.types
foreach ( $_SERVER as $key => $value ) {
if ( ! is_string( $value ) ) {
continue;
}
if ( in_array( $key, array( 'HTTP_COOKIE', 'HTTP_COOKIE2', 'HTTP_USER_AGENT', 'HTTP_REFERER' ), true ) ) {
// We don't care about cookies, and the UA and Referrer were caught above.
continue;
} elseif ( in_array( $key, array( 'REMOTE_ADDR', 'REQUEST_URI', 'DOCUMENT_URI' ), true ) ) {
// All three of these are relevant indicators and should be passed along.
$form[ $key ] = $value;
} elseif ( str_starts_with( $key, 'HTTP_' ) ) {
// Any other HTTP header indicators.
$form[ $key ] = $value;
}
}
/**
* Filter the values that are sent to Akismet for the spam check.
*
* @module contact-form
*
* @since 10.2.0
*
* @param array $form The form values being sent to Akismet.
*/
return apply_filters( 'jetpack_contact_form_akismet_values', $form );
}
/**
* Submit contact-form data to Akismet to check for spam.
* If you're accepting a new item via $_POST, run it Contact_Form_Plugin::prepare_for_akismet() first
* Attached to `jetpack_contact_form_is_spam`
*
* @param bool $is_spam - if the submission is spam.
* @param array $form - the form data.
* @return bool|WP_Error TRUE => spam, FALSE => not spam, WP_Error => stop processing entirely
*/
public function is_spam_akismet( $is_spam, $form = array() ) {
global $akismet_api_host, $akismet_api_port;
// The signature of this function changed from accepting just $form.
// If something only sends an array, assume it's still using the old
// signature and work around it.
if ( empty( $form ) && is_array( $is_spam ) ) {
$form = $is_spam;
$is_spam = false;
}
// If a previous filter has alrady marked this as spam, trust that and move on.
if ( $is_spam ) {
return $is_spam;
}
if ( ! function_exists( 'akismet_http_post' ) && ! defined( 'AKISMET_VERSION' ) ) {
return false;
}
$query_string = http_build_query( $form );
if ( method_exists( 'Akismet', 'http_post' ) ) {
$response = \Akismet::http_post( $query_string, 'comment-check' );
} else {
$response = akismet_http_post( $query_string, $akismet_api_host, '/1.1/comment-check', $akismet_api_port );
}
$result = false;
if ( isset( $response[0]['x-akismet-pro-tip'] ) && 'discard' === trim( $response[0]['x-akismet-pro-tip'] ) && get_option( 'akismet_strictness' ) === '1' ) {
$result = new WP_Error( 'feedback-discarded', __( 'Feedback discarded.', 'jetpack-forms' ) );
} elseif ( isset( $response[1] ) && 'true' === trim( $response[1] ) ) { // 'true' is spam
$result = true;
}
/**
* Filter the results returned by Akismet for each submitted contact form.
*
* @module contact-form
*
* @since 1.3.1
*
* @param WP_Error|bool $result Is the submitted feedback spam.
* @param array|bool $form Submitted feedback.
*/
return apply_filters( 'contact_form_is_spam_akismet', $result, $form );
}
/**
* Submit a feedback as either spam or ham
*
* @param string $as - Either 'spam' or 'ham'.
* @param array $form - the contact-form data.
*
* @return bool|string
*/
public function akismet_submit( $as, $form ) {
global $akismet_api_host, $akismet_api_port;
if ( ! in_array( $as, array( 'ham', 'spam' ), true ) ) {
return false;
}
$query_string = '';
if ( is_array( $form ) ) {
$query_string = http_build_query( $form );
}
if ( method_exists( 'Akismet', 'http_post' ) ) {
$response = \Akismet::http_post( $query_string, "submit-{$as}" );
} else {
$response = akismet_http_post( $query_string, $akismet_api_host, "/1.1/submit-{$as}", $akismet_api_port );
}
return trim( $response[1] );
}
/**
* Prints a dropdown of posts with forms.
*
* @param int $selected_id Currently selected post ID.
* @return void
*/
public static function form_posts_dropdown( $selected_id ) {
?>
', $post_content );
return trim( $content[0] );
}
/**
* Get `_feedback_extra_fields` field from post meta data.
*
* @param int $post_id Id of the post to fetch meta data for.
* @param bool $has_json_data Whether the post has JSON data or not, defaults to false for backwards compatibility.
*
* @return mixed
*/
public function get_post_meta_for_csv_export( $post_id, $has_json_data = false ) {
$content_fields = self::parse_fields_from_content( $post_id );
$all_fields = isset( $content_fields['_feedback_all_fields'] ) ? $content_fields['_feedback_all_fields'] : array();
$md = $has_json_data
? array_diff_key( $all_fields, array_flip( array_keys( self::NON_PRINTABLE_FIELDS ) ) )
: (array) get_post_meta( $post_id, '_feedback_extra_fields', true );
$md['-3_response_date'] = get_the_date( 'Y-m-d H:i:s', $post_id );
$md['93_ip_address'] = ( isset( $content_fields['_feedback_ip'] ) ) ? $content_fields['_feedback_ip'] : 0;
// add the email_marketing_consent to the post meta.
$md['90_consent'] = 0;
if ( ! empty( $all_fields ) ) {
// check if the email_marketing_consent field exists.
if ( isset( $all_fields['email_marketing_consent'] ) ) {
$md['90_consent'] = $all_fields['email_marketing_consent'];
}
// check if the feedback entry has a title.
if ( isset( $all_fields['entry_title'] ) ) {
$md['-9_title'] = $all_fields['entry_title'];
}
// check if the feedback entry has a permalink we can use.
if ( ! empty( $all_fields['entry_permalink'] ) ) {
$parsed = wp_parse_url( $all_fields['entry_permalink'] );
$md['-6_source'] = '';
if ( $parsed && ! empty( $parsed['path'] ) && strpos( $parsed['path'], '/' ) === 0 ) {
$md['-6_source'] .= $parsed['path'];
}
if ( $parsed && ! empty( $parsed['query'] ) ) {
$md['-6_source'] .= '?' . $parsed['query'];
}
}
}
// flatten and decode all values.
$result = array();
foreach ( $md as $key => $value ) {
if ( is_array( $value ) ) {
if ( Contact_Form::is_file_upload_field( $value ) ) {
$file_names = array();
foreach ( $value['files'] as $file ) {
$file_names[] = $file['name'];
}
$value = implode( ', ', $file_names );
} else {
$value = implode( ', ', $value );
}
}
$result[ $key ] = html_entity_decode( $value, ENT_QUOTES | ENT_SUBSTITUTE | ENT_HTML401 );
}
return $result;
}
/**
* Get parsed feedback post fields.
*
* @param int $post_id Id of the post to fetch parsed contents for.
*
* @return array
*
* @codeCoverageIgnore - No need to be covered.
*/
public function get_parsed_field_contents_of_post( $post_id ) {
return self::parse_fields_from_content( $post_id );
}
/**
* Properly maps fields that are missing from the post meta data
* to names, that are similar to those of the post meta.
*
* @param array $parsed_post_content Parsed post content.
* @param bool $use_main_comment Whether to use the main comment from the post_content or not.
* Defaults to true for backwards compatibility. New JSON format
* does not have a main comment and instead has all fields in the parsed content.
*
* @see parse_fields_from_content for how the input data is generated.
*
* @return array Mapped fields.
*/
public function map_parsed_field_contents_of_post_to_field_names( $parsed_post_content, $use_main_comment = true ) {
$mapped_fields = array();
$field_mapping = array(
// TODO: Commented out since we'll be re-introducing this after some other changes
// '_feedback_subject' => __( 'Contact Form', 'jetpack-forms' ),
'_feedback_author' => '1_Name',
'_feedback_author_email' => '2_Email',
'_feedback_author_url' => '3_Website',
'_feedback_ip' => '93_ip_address',
);
if ( $use_main_comment ) {
$field_mapping['_feedback_main_comment'] = '4_Comment';
}
foreach ( $field_mapping as $parsed_field_name => $field_name ) {
if (
isset( $parsed_post_content[ $parsed_field_name ] )
&& ! empty( $parsed_post_content[ $parsed_field_name ] )
) {
$mapped_fields[ $field_name ] = $parsed_post_content[ $parsed_field_name ];
}
}
return $mapped_fields;
}
/**
* Registers the personal data exporter.
*
* @since 6.1.1
*
* @param array $exporters An array of personal data exporters.
*
* @return array $exporters An array of personal data exporters.
*/
public function register_personal_data_exporter( $exporters ) {
$exporters['jetpack-feedback'] = array(
'exporter_friendly_name' => __( 'Feedback', 'jetpack-forms' ),
'callback' => array( $this, 'personal_data_exporter' ),
);
return $exporters;
}
/**
* Registers the personal data eraser.
*
* @since 6.1.1
*
* @param array $erasers An array of personal data erasers.
*
* @return array $erasers An array of personal data erasers.
*/
public function register_personal_data_eraser( $erasers ) {
$erasers['jetpack-feedback'] = array(
'eraser_friendly_name' => __( 'Feedback', 'jetpack-forms' ),
'callback' => array( $this, 'personal_data_eraser' ),
);
return $erasers;
}
/**
* Exports personal data.
*
* @since 6.1.1
*
* @param string $email Email address.
* @param int $page Page to export.
*
* @return array $return Associative array with keys expected by core.
*/
public function personal_data_exporter( $email, $page = 1 ) {
return $this->internal_personal_data_exporter( $email, $page );
}
/**
* Internal method for exporting personal data.
*
* Allows us to have a different signature than core expects
* while protecting against future core API changes.
*
* @internal
* @since 6.5
*
* @param string $email Email address.
* @param int $page Page to export.
* @param int $per_page Number of feedbacks to process per page. Internal use only (testing).
*
* @return array Associative array with keys expected by core.
*/
public function internal_personal_data_exporter( $email, $page = 1, $per_page = 250 ) {
$post_ids = $this->personal_data_post_ids_by_email( $email, $per_page, $page );
return array(
'data' => $this->internal_personal_data_formater( $post_ids ),
'done' => count( $post_ids ) < $per_page,
);
}
/**
* Formats personal data for export.
*
* @param array $post_ids Array of post IDs to format.
*
* @return array $export_data Formatted personal data for export.
*/
public function internal_personal_data_formater( $post_ids ) {
$export_data = array();
foreach ( $post_ids as $post_id ) {
$post_export_data = array();
$feedback = Feedback::get( $post_id );
if ( ! $feedback ) {
continue;
}
$fields = $feedback->get_compiled_fields( 'personal_export', 'all' );
$post_export_data[] = array(
'name' => __( 'Date', 'jetpack-forms' ),
'value' => $feedback->get_time(),
);
$post_export_data[] = array(
'name' => __( 'Source Title', 'jetpack-forms' ),
'value' => $feedback->get_entry_title(),
);
$post_export_data[] = array(
'name' => __( 'Source URL:', 'jetpack-forms' ),
'value' => $feedback->get_entry_permalink(),
);
foreach ( $fields as $field ) {
$post_export_data[] = array(
'name' => $field['label'],
'value' => $field['value'],
);
}
$post_export_data[] = array(
'name' => __( 'Consent', 'jetpack-forms' ),
'value' => $feedback->has_consent() ? __( 'Yes', 'jetpack-forms' ) : __( 'No', 'jetpack-forms' ),
);
$post_export_data[] = array(
'name' => __( 'IP Address', 'jetpack-forms' ),
'value' => $feedback->get_ip_address(),
);
$export_data[] = array(
'group_id' => 'feedback',
'group_label' => __( 'Feedback', 'jetpack-forms' ),
'item_id' => 'feedback-' . $post_id,
'data' => $post_export_data,
);
}
return $export_data;
}
/**
* Erases personal data.
*
* @since 6.1.1
*
* @param string $email Email address.
* @param int $page Page to erase.
*
* @return array Associative array with keys expected by core.
*/
public function personal_data_eraser( $email, $page = 1 ) {
return $this->_internal_personal_data_eraser( $email, $page );
}
/**
* Internal method for erasing personal data.
*
* Allows us to have a different signature than core expects
* while protecting against future core API changes.
*
* @internal
* @since 6.5
*
* @param string $email Email address.
* @param int $page Page to erase.
* @param int $per_page Number of feedbacks to process per page. Internal use only (testing).
*
* @return array Associative array with keys expected by core.
*/
public function _internal_personal_data_eraser( $email, $page = 1, $per_page = 250 ) { // phpcs:ignore PSR2.Methods.MethodDeclaration.Underscore -- this is called in other files.
$removed = false;
$retained = false;
$messages = array();
$option_name = sprintf( '_jetpack_pde_feedback_%s', md5( $email ) );
$last_post_id = 1 === $page ? 0 : get_option( $option_name, 0 );
$post_ids = $this->personal_data_post_ids_by_email( $email, $per_page, $page, $last_post_id );
foreach ( $post_ids as $post_id ) {
$last_post_id = $post_id;
/**
* Filters whether to erase a particular Feedback post.
*
* @since 6.3.0
*
* @param bool|string $prevention_message Whether to apply erase the Feedback post (bool).
* Custom prevention message (string). Default true.
* @param int $post_id Feedback post ID.
*/
$prevention_message = apply_filters( 'grunion_contact_form_delete_feedback_post', true, $post_id );
if ( true !== $prevention_message ) {
if ( $prevention_message && is_string( $prevention_message ) ) {
$messages[] = esc_html( $prevention_message );
} else {
$messages[] = sprintf(
// translators: %d: Post ID.
__( 'Feedback ID %d could not be removed at this time.', 'jetpack-forms' ),
$post_id
);
}
$retained = true;
continue;
}
if ( wp_delete_post( $post_id, true ) ) {
$removed = true;
} else {
$retained = true;
$messages[] = sprintf(
// translators: %d: Post ID.
__( 'Feedback ID %d could not be removed at this time.', 'jetpack-forms' ),
$post_id
);
}
}
$done = count( $post_ids ) < $per_page;
if ( $done ) {
delete_option( $option_name );
} else {
update_option( $option_name, (int) $last_post_id );
}
return array(
'items_removed' => $removed,
'items_retained' => $retained,
'messages' => $messages,
'done' => $done,
);
}
/**
* Queries personal data by email address.
*
* @since 6.1.1
*
* @param string $email Email address.
* @param int $per_page Post IDs per page. Default is `250`.
* @param int $page Page to query. Default is `1`.
* @param int $last_post_id Page to query. Default is `0`. If non-zero, used instead of $page.
*
* @return array An array of post IDs.
*/
public function personal_data_post_ids_by_email( $email, $per_page = 250, $page = 1, $last_post_id = 0 ) {
add_filter( 'posts_search', array( $this, 'personal_data_search_filter' ) );
$this->pde_last_post_id_erased = $last_post_id;
$this->pde_email_address = $email;
$post_ids = get_posts(
array(
'post_type' => 'feedback',
'post_status' => 'publish',
// This search parameter gets overwritten in ->personal_data_search_filter()
's' => '..PDE..AUTHOR EMAIL:..PDE..',
'sentence' => true,
'order' => 'ASC',
'orderby' => 'ID',
'fields' => 'ids',
'posts_per_page' => $per_page,
'paged' => $last_post_id ? 1 : $page,
'suppress_filters' => false,
)
);
$this->pde_last_post_id_erased = 0;
$this->pde_email_address = '';
remove_filter( 'posts_search', array( $this, 'personal_data_search_filter' ) );
return $post_ids;
}
/**
* Filters searches by email address.
*
* @since 6.1.1
*
* @param string $search SQL where clause.
*
* @return string Filtered SQL where clause.
*/
public function personal_data_search_filter( $search ) {
global $wpdb;
/*
* Limits search to `post_content` only, and we only match the
* author's email address whenever it's on a line by itself.
*/
if ( $this->pde_email_address && str_contains( $search, '..PDE..AUTHOR EMAIL:..PDE..' ) ) {
$search = (string) $wpdb->prepare(
" AND (
{$wpdb->posts}.post_content LIKE %s
OR {$wpdb->posts}.post_content LIKE %s
)",
// `chr( 10 )` = `\n`, `chr( 13 )` = `\r` - Keeping this in case someone needs it for reference.
'%' . $wpdb->esc_like( chr( 10 ) . 'AUTHOR EMAIL: ' . $this->pde_email_address . chr( 10 ) ) . '%',
'%' . $wpdb->esc_like( chr( 13 ) . 'AUTHOR EMAIL: ' . $this->pde_email_address . chr( 13 ) ) . '%'
);
if ( $this->pde_last_post_id_erased ) {
$search .= $wpdb->prepare( " AND {$wpdb->posts}.ID > %d", $this->pde_last_post_id_erased );
}
}
return $search;
}
/**
* Returns an array of feedback data for export.
*
* @param array $feedback_ids Array of feedback IDs to fetch the data for.
*
* @return array
*/
public function get_export_feedback_data( $feedback_ids ) {
$feedback_data = array();
$field_names = array();
foreach ( $feedback_ids as $feedback_id ) {
$response = Feedback::get( $feedback_id );
if ( ! $response instanceof Feedback ) {
continue; // Skip if the feedback is not an instance of Feedback.
}
$feedback_data[ $feedback_id ] = $response;
$field_names = array_merge( $field_names, $response->get_compiled_fields( 'csv', 'label' ) );
}
/**
* Make sure the field names are unique, because we don't want duplicate data.
*/
$field_names = array_unique( $field_names );
return $this->format_feedback_data_for_csv( $feedback_data, $field_names );
}
/**
* Returns an array of feedback data for CSV export.
*
* @param array $feedback_data Array of feedback data to fetch the results for.
* @param array $field_names Array of field names to include in the results.
*
* @return array
*/
private function format_feedback_data_for_csv( $feedback_data, $field_names ) {
$results = array();
foreach ( $feedback_data as $feedback_id => $feedback ) {
if ( ! $feedback instanceof Feedback ) {
continue; // Skip if the feedback is not an instance of Feedback.
}
$results[ __( 'ID', 'jetpack-forms' ) ][] = $feedback_id;
$results[ __( 'Date', 'jetpack-forms' ) ][] = $feedback->get_time();
$results[ __( 'Title', 'jetpack-forms' ) ][] = $feedback->get_entry_title();
$results[ __( 'Source', 'jetpack-forms' ) ][] = $feedback->get_entry_short_permalink();
/**
* Go through all the possible fields and check if the field is available
* in the current feedback.
*
* If it is - add the data as a value.
* If it is not - add an empty string, which is just a placeholder in the CSV.
*/
foreach ( $field_names as $single_field_name ) {
if ( ! isset( $results[ $single_field_name ] ) ) {
$results[ $single_field_name ] = array();
}
$results[ $single_field_name ][] = $feedback->get_field_value_by_label( $single_field_name, 'csv' );
}
$results[ __( 'Consent', 'jetpack-forms' ) ][] = $feedback->has_consent() ? __( 'Yes', 'jetpack-forms' ) : __( 'No', 'jetpack-forms' );
$results[ __( 'IP Address', 'jetpack-forms' ) ][] = $feedback->get_ip_address();
}
return $results;
}
/**
* Prepares feedback post data for CSV export.
*
* @deprecated since 5.1.0
*
* @see get_export_feedback_data()
* @param array $post_ids Post IDs to fetch the data for. These need to be Feedback posts.
*
* @return array
*/
public function get_export_data_for_posts( $post_ids ) {
_deprecated_function( __METHOD__, 'package-5.1.0', 'Contact_Form_Plugin::get_export_feedback_data()' );
return $this->get_export_feedback_data( $post_ids );
}
/**
* Returns an array of [prefixed column name] => [translated column name], used on export.
* Prefix indicates the position in which the column will be rendered:
* - Negative numbers render BEFORE any form field/value column: -5, -3, -1...
* - Positive values render AFTER any form field/value column: 1, 30, 93...
* Mind using high numbering on these ones as the prefix is used on regular inputs: 1_Name, 2_Email, etc
*
* @deprecated since 5.1.0
*
* @return array
*/
public function get_well_known_column_names() {
_deprecated_function( __METHOD__, 'package-5.1.0', 'Contact_Form_Plugin::get_export_column_names()' );
return array(
'-9_title' => __( 'Title', 'jetpack-forms' ),
'-6_source' => __( 'Source', 'jetpack-forms' ),
'-3_response_date' => __( 'Response Date', 'jetpack-forms' ),
'90_consent' => _x( 'Consent', 'noun', 'jetpack-forms' ),
'93_ip_address' => __( 'IP Address', 'jetpack-forms' ),
);
}
/**
* Extracts feedback entries based on POST data.
*/
public function get_feedback_entries_from_post() {
if ( empty( $_POST['feedback_export_nonce_csv'] ) && empty( $_POST['feedback_export_nonce_gdrive'] ) ) {
return;
} elseif ( ! empty( $_POST['feedback_export_nonce_csv'] ) ) {
check_admin_referer( 'feedback_export', 'feedback_export_nonce_csv' );
} elseif ( ! empty( $_POST['feedback_export_nonce_gdrive'] ) ) {
check_admin_referer( 'feedback_export', 'feedback_export_nonce_gdrive' );
}
if ( ! current_user_can( 'export' ) ) {
return;
}
$args = array(
'posts_per_page' => -1,
'post_type' => 'feedback',
'post_status' => array( 'publish', 'draft' ),
'order' => 'ASC',
'fields' => 'ids',
'suppress_filters' => false,
'date_query' => array(),
);
// Check if we want to download all the feedbacks or just a certain contact form
if ( ! empty( $_POST['post'] ) && $_POST['post'] !== 'all' ) {
$args['post_parent'] = (int) $_POST['post'];
}
if ( ! empty( $_POST['status'] ) && in_array( $_POST['status'], array( 'spam', 'trash' ), true ) ) {
$args['post_status'] = sanitize_text_field( wp_unslash( $_POST['status'] ) );
}
if ( ! empty( $_POST['search'] ) ) {
$args['s'] = sanitize_text_field( wp_unslash( $_POST['search'] ) );
}
// TODO: We can remove this when the wp-admin UI is removed.
if ( ! empty( $_POST['year'] ) && intval( $_POST['year'] ) > 0 ) {
$args['date_query']['year'] = intval( $_POST['year'] );
}
// TODO: We can remove this when the wp-admin UI is removed.
if ( ! empty( $_POST['month'] ) && intval( $_POST['month'] ) > 0 ) {
$args['date_query']['month'] = intval( $_POST['month'] );
}
if ( ! empty( $_POST['after'] ) && ! empty( $_POST['before'] ) ) {
$before = strtotime( sanitize_text_field( wp_unslash( $_POST['before'] ) ) );
$after = strtotime( sanitize_text_field( wp_unslash( $_POST['after'] ) ) );
if ( $before && $after && $before < $after ) {
$args['date_query']['after'] = $after;
$args['date_query']['before'] = $before;
}
}
if ( ! empty( $_POST['selected'] ) && is_array( $_POST['selected'] ) ) {
$args['include'] = array_filter(
array_map(
function ( $selected ) {
return intval( $selected );
},
$_POST['selected'] // phpcs:ignore WordPress.Security.ValidatedSanitizedInput.MissingUnslash, WordPress.Security.ValidatedSanitizedInput.InputNotSanitized
)
);
}
$feedbacks = get_posts( $args );
return $this->get_export_feedback_data( $feedbacks );
}
/**
* Download exported data as CSV
*/
public function download_feedback_as_csv() {
// phpcs:ignore WordPress.Security.NonceVerification.Missing -- verification is done on get_feedback_entries_from_post function
$post_data = wp_unslash( $_POST );
$data = $this->get_feedback_entries_from_post();
if ( empty( $data ) ) {
return;
}
// Check if we want to download all the feedbacks or just a certain contact form
if ( ! empty( $post_data['post'] ) && $post_data['post'] !== 'all' ) {
$filename = sprintf(
'%s - %s.csv',
Util::get_export_filename( get_the_title( (int) $post_data['post'] ) ),
gmdate( 'Y-m-d H:i' )
);
} else {
$filename = sprintf(
'%s - %s.csv',
Util::get_export_filename(),
gmdate( 'Y-m-d H:i' )
);
}
/**
* Extract field names from `$data` for later use.
*/
$fields = array_keys( $data );
/**
* Count how many rows will be exported.
*/
$row_count = count( reset( $data ) );
// Forces the download of the CSV instead of echoing
header( 'Content-Disposition: attachment; filename=' . $filename );
header( 'Pragma: no-cache' );
header( 'Expires: 0' );
header( 'Content-Type: text/csv; charset=utf-8' );
$output = fopen( 'php://output', 'w' );
/**
* Print CSV headers
*/
// @todo When we drop support for PHP <7.4, consider passing empty-string for `$escape` here for better spec compatibility.
fputcsv( $output, $fields, ',', '"', '\\' );
/**
* Print rows to the output.
*/
for ( $i = 0; $i < $row_count; $i++ ) {
$current_row = array();
/**
* Put all the fields in `$current_row` array.
*/
foreach ( $fields as $single_field_name ) {
$current_row[] = $this->esc_csv( $data[ $single_field_name ][ $i ] );
}
/**
* Output the complete CSV row
*/
// @todo When we drop support for PHP <7.4, consider passing empty-string for `$escape` here for better spec compatibility.
fputcsv( $output, $current_row, ',', '"', '\\' );
}
fclose( $output ); // phpcs:ignore WordPress.WP.AlternativeFunctions.file_system_operations_fclose
$this->record_tracks_event( 'forms_export_responses', array( 'format' => 'csv' ) );
exit( 0 );
}
/**
* Create a new page with a Form block
*/
public function create_new_form() {
if ( ! isset( $_POST['newFormNonce'] ) || ! wp_verify_nonce( sanitize_text_field( wp_unslash( $_POST['newFormNonce'] ) ), 'create_new_form' ) ) {
wp_send_json_error(
__( 'Invalid nonce', 'jetpack-forms' ),
403
);
}
if ( ! current_user_can( 'edit_pages' ) ) {
wp_send_json_error(
__( 'You do not have permission to create pages', 'jetpack-forms' ),
403
);
}
$pattern_name = isset( $_POST['pattern'] ) ? sanitize_text_field( wp_unslash( $_POST['pattern'] ) ) : null;
if ( $pattern_name && WP_Block_Patterns_Registry::get_instance()->is_registered( $pattern_name ) ) {
$pattern = WP_Block_Patterns_Registry::get_instance()->get_registered( $pattern_name );
$pattern_content = $pattern['content'];
}
// If no pattern found or specified, use a default form block
if ( empty( $pattern_content ) ) {
$pattern_content = '
';
}
$post_id = wp_insert_post(
array(
'post_type' => 'page',
'post_title' => esc_html__( 'Jetpack Forms', 'jetpack-forms' ),
'post_content' => $pattern_content,
)
);
if ( is_wp_error( $post_id ) ) {
wp_send_json_error(
$post_id->get_error_message(),
500
);
} else {
wp_send_json(
array(
'post_url' => admin_url( 'post.php?post=' . intval( $post_id ) . '&action=edit' ),
)
);
}
}
/**
* Send an event to Tracks
*
* @param string $event_name - the name of the event.
* @param array $event_props - event properties to send.
*
* @return null|void
*/
public function record_tracks_event( $event_name, $event_props ) {
/*
* Event details.
*/
$event_user = wp_get_current_user();
/*
* Record event.
* We use different libs on wpcom and Jetpack.
*/
if ( defined( 'IS_WPCOM' ) && IS_WPCOM ) {
$event_name = 'wpcom_' . $event_name;
$event_props['blog_id'] = get_current_blog_id();
// logged out visitor, record event with blog owner.
if ( empty( $event_user->ID ) ) {
$event_user_id = wpcom_get_blog_owner( $event_props['blog_id'] );
$event_user = get_userdata( $event_user_id );
}
require_lib( 'tracks/client' );
tracks_record_event( $event_user, $event_name, $event_props );
} else {
$user_connected = ( new \Automattic\Jetpack\Connection\Manager( 'jetpack-forms' ) )->is_user_connected( get_current_user_id() );
if ( ! $user_connected ) {
return;
}
// logged out visitor, record event with Jetpack master user.
if ( empty( $event_user->ID ) ) {
$master_user_id = Jetpack_Options::get_option( 'master_user' );
if ( ! empty( $master_user_id ) ) {
$event_user = get_userdata( $master_user_id );
}
}
$tracking = new Tracking();
$tracking->record_user_event( $event_name, $event_props, $event_user );
}
}
/**
* Escape a string to be used in a CSV context
*
* Malicious input can inject formulas into CSV files, opening up the possibility for phishing attacks and
* disclosure of sensitive information.
*
* Additionally, Excel exposes the ability to launch arbitrary commands through the DDE protocol.
*
* @see https://www.contextis.com/en/blog/comma-separated-vulnerabilities
*
* @param string $field - the CSV field.
*
* @return string
*/
public function esc_csv( $field ) {
$active_content_triggers = array( '=', '+', '-', '@' );
if ( in_array( mb_substr( $field, 0, 1 ), $active_content_triggers, true ) ) {
$field = "'" . $field;
}
return $field;
}
/**
* Returns an array of parent post IDs for the user.
* The parent posts are those posts where forms have been published.
*
* @param array $query_args A WP_Query compatible array of query args.
*
* @return array The array of post IDs
*/
public static function get_all_parent_post_ids( $query_args = array() ) {
$default_query_args = array(
'fields' => 'id=>parent',
'posts_per_page' => 100000, // phpcs:ignore WordPress.WP.PostsPerPage.posts_per_page_posts_per_page
'post_type' => 'feedback',
'post_status' => 'publish',
'suppress_filters' => false,
);
$args = array_merge( $default_query_args, $query_args );
// Get the feedbacks' parents' post IDs
$feedbacks = get_posts( $args );
return array_values( array_unique( array_values( $feedbacks ) ) );
}
/**
* Returns a string of HTML ',
esc_attr( $parent_id ),
$selected_id === $parent_id ? 'selected' : '',
esc_html( basename( $parsed_url['path'] ) )
);
}
return $options;
}
/**
* Get the names of all the form's fields
*
* @param array|int $posts the post we want the fields of.
*
* @return array the array of fields
*
* @deprecated As this is no longer necessary as of the CSV export rewrite. - 2015-12-29
*/
protected function get_field_names( $posts ) {
$posts = (array) $posts;
$all_fields = array();
foreach ( $posts as $post ) {
$fields = self::parse_fields_from_content( $post );
if ( isset( $fields['_feedback_all_fields'] ) ) {
$extra_fields = array_keys( $fields['_feedback_all_fields'] );
$all_fields = array_merge( $all_fields, $extra_fields );
}
}
$all_fields = array_unique( $all_fields );
return $all_fields;
}
/**
* Returns if the feedback post has JSON data
*
* @param int $post_id The feedback post ID to check.
* @return bool
*/
public function has_json_data( $post_id ) {
$post_content = get_post_field( 'post_content', $post_id );
$content = explode( "\nJSON_DATA", $post_content );
if ( empty( $content[1] ) ) {
return false;
}
$json_data = json_decode( $content[1], true );
return is_array( $json_data ) && ! empty( $json_data );
}
/**
* Helper function to parse the post content.
*
* @param string $post_content The post content to parse.
* @return array Parsed fields.
*/
public static function parse_feedback_content( $post_content ) {
$all_values = array();
$content = explode( '', $post_content );
$lines = array();
if ( count( $content ) > 1 ) {
$content = str_ireplace( array( ' ', ')' ), '', $content[1] );
if ( str_contains( $content, 'JSON_DATA' ) ) {
$chunks = explode( "\nJSON_DATA", $content );
$all_values = json_decode( $chunks[1], true );
if ( $all_values === null ) {
// If JSON decoding fails, try to decode the second try with stripslashes and trim.
// This is a workaround for some cases where the JSON data is not properly formatted.
$all_values = json_decode( stripslashes( trim( $chunks[1] ) ), true );
}
$lines = array_filter( explode( "\n", $chunks[0] ) );
} else {
$fields_array = preg_replace( '/.*Array\s\( (.*)\)/msx', '$1', $content );
// This line of code is used to parse a string containing key-value pairs formatted as [Key] => Value and extract the keys and values into an array.
// The regular expression ensures that each key-value pair is correctly identified and captured.
// Given an input string
// [Key1] => Value1
// [Key2] => Value2
// it $matches[1]: The keys (e.g., Key1, Key2 ).
// and $matches[2]: The values (e.g., Value1, Value2 ).
preg_match_all( '/^\s*\[([^\]]+)\] =\>\; (.*)(?=^\s*(\[[^\]]+\] =\>\;)|\z)/msU', $fields_array, $matches );
if ( count( $matches ) > 1 ) {
$all_values = array_combine( array_map( 'trim', $matches[1] ), array_map( 'trim', $matches[2] ) );
}
$lines = array_filter( explode( "\n", $content ) );
}
}
$var_map = array(
'AUTHOR' => '_feedback_author',
'AUTHOR EMAIL' => '_feedback_author_email',
'AUTHOR URL' => '_feedback_author_url',
'SUBJECT' => '_feedback_subject',
'IP' => '_feedback_ip',
);
$fields = array();
foreach ( $lines as $line ) {
$vars = explode( ': ', $line, 2 );
if ( ! empty( $vars ) ) {
if ( isset( $var_map[ $vars[0] ] ) ) {
$fields[ $var_map[ $vars[0] ] ] = self::strip_tags( trim( $vars[1] ) );
}
}
}
// All fields should always be an array, even if empty.
if ( ! is_array( $all_values ) ) {
$all_values = array();
}
$fields['_feedback_all_fields'] = array();
foreach ( $all_values as $key => $value ) {
$fields['_feedback_all_fields'][ wp_strip_all_tags( $key ) ] = $value;
}
return $fields;
}
/**
* Parse the contact form fields.
*
* @param int $post_id - the post ID.
* @return array Fields.
*/
public static function parse_fields_from_content( $post_id ) {
static $post_fields;
if ( ! is_array( $post_fields ) ) {
$post_fields = array();
}
if ( isset( $post_fields[ $post_id ] ) ) {
return $post_fields[ $post_id ];
}
$post_content = get_post_field( 'post_content', $post_id );
$fields = self::parse_feedback_content( $post_content );
$post_fields[ $post_id ] = $fields;
return $fields;
}
/**
* Creates a valid csv row from a post id
*
* @param int $post_id The id of the post.
* @param array $fields An array containing the names of all the fields of the csv.
*
* @return String The csv row
*
* @deprecated This is no longer needed, as of the CSV export rewrite.
*/
protected static function make_csv_row_from_feedback( $post_id, $fields ) {
$content_fields = self::parse_fields_from_content( $post_id );
$all_fields = array();
if ( isset( $content_fields['_feedback_all_fields'] ) ) {
$all_fields = $content_fields['_feedback_all_fields'];
}
// Overwrite the parsed content with the content we stored in post_meta in a better format.
$extra_fields = get_post_meta( $post_id, '_feedback_extra_fields', true );
foreach ( $extra_fields as $extra_field => $extra_value ) {
$all_fields[ $extra_field ] = $extra_value;
}
// The first element in all of the exports will be the subject
$row_items = array();
$row_items[] = $content_fields['_feedback_subject'];
// Loop the fields array in order to fill the $row_items array correctly
foreach ( $fields as $field ) {
if ( $field === __( 'Contact Form', 'jetpack-forms' ) ) { // the first field will ever be the contact form, so we can continue
continue;
} elseif ( array_key_exists( $field, $all_fields ) ) {
$row_items[] = $all_fields[ $field ];
} else {
$row_items[] = '';
}
}
return $row_items;
}
/**
* Get the IP address.
*
* @return string|null IP address.
*/
public static function get_ip_address() {
return isset( $_SERVER['REMOTE_ADDR'] ) ? sanitize_text_field( wp_unslash( $_SERVER['REMOTE_ADDR'] ) ) : null;
}
/**
* Disable Block Editor for feedbacks.
*
* @param bool $can_edit Whether the post type can be edited or not.
* @param string $post_type The post type being checked.
* @return bool
*/
public function use_block_editor_for_post_type( $can_edit, $post_type ) {
return 'feedback' === $post_type ? false : $can_edit;
}
/**
* Kludge method: reverses the output of a standard print_r( $array ).
* Sort of what unserialize does to a serialized object.
* This is here while we work on a better data storage inside the posts. See:
* - p1675781140892129-slack-C01CSBEN0QZ
* - https://www.php.net/manual/en/function.print-r.php#93529
*
* @param string $print_r_output The array string to be reverted. Needs to being with 'Array'.
* @param bool $parse_html Whether to run html_entity_decode on each line.
* As strings are stored right now, they are all escaped, so '=>' are '>'.
* @return array|string Array when succesfully reconstructed, string otherwise. Output will always be esc_html'd.
*/
public static function reverse_that_print( $print_r_output, $parse_html = false ) {
$lines = explode( "\n", trim( $print_r_output ) );
if ( $parse_html ) {
$lines = array_map( 'html_entity_decode', $lines );
}
if ( trim( $lines[0] ) !== 'Array' ) {
// bottomed out to something that isn't an array, escape it and be done
return esc_html( $print_r_output );
} else {
// this is an array, lets parse it
if ( preg_match( '/(\s{5,})\(/', $lines[1], $match ) ) {
// this is a tested array/recursive call to this function
// take a set of spaces off the beginning
$spaces = $match[1];
$spaces_length = strlen( $spaces );
$lines_total = count( $lines );
for ( $i = 0; $i < $lines_total; $i++ ) {
if ( substr( $lines[ $i ], 0, $spaces_length ) === $spaces ) {
$lines[ $i ] = substr( $lines[ $i ], $spaces_length );
}
}
}
array_shift( $lines ); // Array
array_shift( $lines ); // (
array_pop( $lines ); // )
$print_r_output = implode( "\n", $lines );
// make sure we only match stuff with 4 preceding spaces (stuff for this array and not a nested one
preg_match_all( '/^\s{4}\[(.+?)\] \=\> /m', $print_r_output, $matches, PREG_OFFSET_CAPTURE | PREG_SET_ORDER );
$pos = array();
$previous_key = '';
$in_length = strlen( $print_r_output );
// store the following in $pos:
// array with key = key of the parsed array's item
// value = array(start position in $print_r_output, $end position in $print_r_output)
foreach ( $matches as $match ) {
$key = $match[1][0];
$start = $match[0][1] + strlen( $match[0][0] );
$pos[ $key ] = array( $start, $in_length );
if ( $previous_key !== '' ) {
$pos[ $previous_key ][1] = $match[0][1] - 1;
}
$previous_key = $key;
}
$ret = array();
foreach ( $pos as $key => $where ) {
// recursively see if the parsed out value is an array too
$ret[ $key ] = self::reverse_that_print( substr( $print_r_output, $where[0], $where[1] - $where[0] ), $parse_html );
}
return $ret;
}
}
/**
* Method untrash_feedback_status_handler
* wp_untrash_post filter handler.
*
* @param string $current_status The status to be set.
* @param int $post_id The post ID.
* @param string $previous_status The previous status.
*/
public function untrash_feedback_status_handler( $current_status, $post_id, $previous_status ) {
$post = get_post( $post_id );
if ( 'feedback' === $post->post_type ) {
if ( in_array( $previous_status, array( 'spam', 'publish' ), true ) ) {
return $previous_status;
}
return 'publish';
}
return $current_status;
}
/**
* Returns whether we are in condition to track and use
* analytics functionality like Tracks.
*
* @return bool Returns true if we can track analytics, else false.
*/
public static function can_use_analytics() {
$is_wpcom = defined( 'IS_WPCOM' ) && IS_WPCOM;
$status = new Status();
$connection = new Connection_Manager();
$tracking = new Tracking( 'jetpack', $connection );
$should_enable_tracking = $tracking->should_enable_tracking( new Terms_Of_Service(), $status );
return $is_wpcom || $should_enable_tracking;
}
/**
* Jetpack menu item might have a count badge when there are updates available.
* This method parses that information, removes the associated markup and adds it to the response.
* Copied verbatim from WPCOM_REST_API_V2_Endpoint_Admin_Menu::prepare_menu_item.
*
* Also sanitizes the titles from remaining unexpected markup.
*
* @param string $title Title to parse.
* @return array
*/
private function parse_menu_item( $title ) {
$item = array();
if (
str_contains( $title, 'count-' )
&& preg_match( '/(.+)<\/span>/', $title, $matches )
) {
$text = $matches[1];
if ( $text ) {
// Keep the text in the item array.
$item['inlineText'] = $text;
}
// Finally remove the markup.
$title = trim( str_replace( $matches[0], '', $title ) );
}
if (
str_contains( $title, 'awaiting-mod' )
&& preg_match( '/(.+)<\/span>/', $title, $matches )
) {
$text = $matches[1];
if ( $text ) {
// Keep the text in the item array.
$item['badge'] = $text;
}
// Finally remove the markup.
$title = trim( str_replace( $matches[0], '', $title ) );
}
// It's important we sanitize the title after parsing data to remove any unexpected markup but keep the content.
// We are also capitalizing the first letter in case there was a counter (now parsed) in front of the title.
$item['title'] = ucfirst( wp_strip_all_tags( $title ) );
return $item;
}
/**
* Render the rating field.
*
* @param array $atts - the block attributes.
* @param string $content - html content.
* @param WP_Block $block - the block instance object.
*
* @return string HTML for the contact form field.
*/
public static function gutenblock_render_field_rating( $atts, $content, $block ) {
$atts = self::block_attributes_to_shortcode_attributes( $atts, 'rating', $block );
return Contact_Form::parse_contact_field( $atts, $content, $block );
}
/**
* Render the slider field.
*
* @param array $atts - the block attributes.
* @param string $content - html content.
* @param WP_Block $block - the block instance object.
*
* @return string HTML for the contact form field.
*/
public static function gutenblock_render_field_slider( $atts, $content, $block ) {
// Get min, max, and default from the parent block's attributes.
$parent_attrs = $block->parsed_block['attrs'] ?? array();
$atts['min'] = isset( $parent_attrs['min'] ) ? $parent_attrs['min'] : 0;
$atts['max'] = isset( $parent_attrs['max'] ) ? $parent_attrs['max'] : 100;
$atts['default'] = isset( $parent_attrs['default'] ) ? $parent_attrs['default'] : 0;
$atts = self::block_attributes_to_shortcode_attributes( $atts, 'slider', $block );
return Contact_Form::parse_contact_field( $atts, $content, $block );
}
}