Ticket #7162: 7162.patch

src/bp-xprofile/bp-xprofile-admin.php

@@ -493 +493 @@
                         $field->type        = $_POST['fieldtype'];
                         $field->name        = $_POST['title'];
 
+                        /*
+                         * By default a Textbox field is created. To run field type's feature
+                         * checks we need to set it to what it really is early.
+                         */
+                        if ( is_null( $field_id ) ) {
+                                $field_type = bp_xprofile_create_field_type( $field->type );
+
+                                // If it's a placeholder, then the field type is not registered.
+                                if ( ! $field_type instanceof BP_XProfile_Field_Type_Placeholder ) {
+                                        $field->type_obj = $field_type;
+                                }
+                        }
+
+                        if ( ! $field->field_type_supports( 'required' ) ) {
+                                $field->is_required = "0";
+                        }
+
                         if ( ! empty( $_POST['description'] ) ) {
                                 $field->description = $_POST['description'];
                         } else {
@@ -537 +554 @@
 
                                 // Validate default visibility.
                                 if ( ! empty( $_POST['default-visibility'] ) && in_array( $_POST['default-visibility'], wp_list_pluck( bp_xprofile_get_visibility_levels(), 'id' ) ) ) {
-                                        bp_xprofile_update_field_meta( $field_id, 'default_visibility', $_POST['default-visibility'] );
+                                        $default_visibility = $_POST['default-visibility'];
+
+                                        if ( ! $field->field_type_supports( 'allow_custom_visibility' ) ) {
+                                                $default_visibility = 'public';
+                                        }
+
+                                        bp_xprofile_update_field_meta( $field_id, 'default_visibility', $default_visibility );
                                 }
 
                                 // Validate custom visibility.
                                 if ( ! empty( $_POST['allow-custom-visibility'] ) && in_array( $_POST['allow-custom-visibility'], array( 'allowed', 'disabled' ) ) ) {
-                                        bp_xprofile_update_field_meta( $field_id, 'allow_custom_visibility', $_POST['allow-custom-visibility'] );
+                                        $allow_custom_visibility = $_POST['allow-custom-visibility'];
+
+                                        if ( ! $field->field_type_supports( 'allow_custom_visibility' ) ) {
+                                                $allow_custom_visibility = 'disabled';
+                                        }
+
+                                        bp_xprofile_update_field_meta( $field_id, 'allow_custom_visibility', $allow_custom_visibility );
                                 }
 
                                 // Validate signup.
@@ -552 +581 @@
                                         bp_xprofile_delete_meta( $field_id, 'field', 'signup_position' );
                                 }
 
+                                $do_autolink = '';
+                                if ( $field->field_type_supports( 'do_autolink' ) && isset( $_POST['do_autolink'] ) && $_POST['do_autolink'] ) {
+                                        $do_autolink = wp_unslash( $_POST['do_autolink'] );
+                                }
+
                                 // Save autolink settings.
-                                if ( isset( $_POST['do_autolink'] ) && 'on' === wp_unslash( $_POST['do_autolink'] ) ) {
+                                if ( 'on' === $do_autolink ) {
                                         bp_xprofile_update_field_meta( $field_id, 'do_autolink', 'on' );
                                 } else {
                                         bp_xprofile_update_field_meta( $field_id, 'do_autolink', 'off' );

src/bp-xprofile/bp-xprofile-cache.php

@@ -302 +302 @@
 
 // List actions to clear super cached pages on, if super cache is installed.
 add_action( 'xprofile_updated_profile', 'bp_core_clear_cache' );
+
+/**
+ * Resets the User Metadata ids cache.
+ *
+ * @since 8.0.0
+ *
+ * @param integer $user_id The user ID.
+ */
+function bp_xprofile_reset_user_mid_cache( $user_id ) {
+        wp_cache_delete( $user_id, 'bp_user_mid' );
+}
+add_action( 'profile_update', 'bp_xprofile_reset_user_mid_cache', 10, 1 );

src/bp-xprofile/bp-xprofile-filters.php

@@ -352 +352 @@
  * @return string
  */
 function bp_xprofile_escape_field_data( $value, $field_type, $field_id ) {
+        // Sanitization for these types is directly done into their `display_filter()` method.
+        if ( 'wp-biography' === $field_type || 'wp-textbox' === $field_type ) {
+                return $value;
+        }
+
         if ( bp_xprofile_is_richtext_enabled_for_field( $field_id ) ) {
                 // The xprofile_filter_kses() expects a BP_XProfile_ProfileData object.
                 $data_obj = null;

src/bp-xprofile/bp-xprofile-functions.php

@@ -159 +159 @@
                 'textarea'       => 'BP_XProfile_Field_Type_Textarea',
                 'textbox'        => 'BP_XProfile_Field_Type_Textbox',
                 'telephone'      => 'BP_XProfile_Field_Type_Telephone',
+                'wp-biography'   => 'BP_XProfile_Field_Type_WordPress_Biography',
+                'wp-textbox'     => 'BP_XProfile_Field_Type_WordPress_Textbox',
         );
 
         /**
@@ -462 +464 @@
                 return false;
         }
 
-        $field           = new BP_XProfile_ProfileData();
-        $field->field_id = $field_id;
-        $field->user_id  = $user_id;
+        $field_args = compact( 'field_type_obj', 'field', 'user_id', 'value', 'is_required' );
 
-        // Gets un/reserialized via xprofile_sanitize_data_value_before_save().
-        $field->value    = maybe_serialize( $value );
+        /**
+         * Return a WP_Error object or true to use your custom way of saving field values.
+         *
+         * @since 8.0.0
+         *
+         * @param boolean Whether to shortcircuit the $bp->profile->table_name_data table.
+         * @param array $field_args {
+         *     An array of arguments.
+         *
+         *     @type object            $field_type_obj Field type object.
+         *     @type BP_XProfile_Field $field          Field object.
+         *     @type integer           $user_id        The user ID.
+         *     @type mixed             $value          Value passed to xprofile_set_field_data().
+         *     @type boolean           $is_required    Whether or not the field is required.
+         * }
+         */
+        $retval = apply_filters( 'bp_xprofile_set_field_data_pre_save', false, $field_args );
 
-        return $field->save();
+        if ( is_wp_error( $retval ) ) {
+                return false;
+        }
+
+        if ( false === $retval ) {
+                $field           = new BP_XProfile_ProfileData();
+                $field->field_id = $field_id;
+                $field->user_id  = $user_id;
+
+                // Gets un/reserialized via xprofile_sanitize_data_value_before_save().
+                $field->value    = maybe_serialize( $value );
+
+                $retval = $field->save();
+        }
+
+        return $retval;
 }
 
 /**
@@ -1357 +1387 @@
                 'done' => true,
         );
 }
+
+/**
+ * Returns the list of supporterd WordPress field meta keys.
+ *
+ * @since 8.0.0
+ *
+ * @return string[] List of supported WordPress user keys.
+ */
+function bp_xprofile_get_wp_user_keys() {
+        return array_merge(
+                array( 'first_name', 'last_name', 'user_url', 'description' ),
+                array_keys( wp_get_user_contact_methods() )
+        );
+}

src/bp-xprofile/classes/class-bp-xprofile-component.php

@@ -410 +410 @@
                         'bp_xprofile_data',
                         'bp_xprofile_fields',
                         'bp_xprofile_groups',
-                        'xprofile_meta'
+                        'xprofile_meta',
+                        'bp_user_mid',
                 ) );
 
                 parent::setup_cache_groups();

new file src/bp-xprofile/classes/class-bp-xprofile-field-type-wordpress-biography.php

@@ +1 @@
+<?php
+/**
+ * BuddyPress XProfile Classes.
+ *
+ * @package BuddyPress
+ * @subpackage XProfileClasses
+ * @since 8.0.0
+ */
+
+// Exit if accessed directly.
+defined( 'ABSPATH' ) || exit;
+
+/**
+ * WordPress Biography xProfile field type.
+ *
+ * @since 8.0.0
+ */
+class BP_XProfile_Field_Type_WordPress_Biography extends BP_XProfile_Field_Type_WordPress {
+
+        /**
+         * Constructor for the WordPress biography field type.
+         *
+         * @since 8.0.0
+         */
+        public function __construct() {
+                parent::__construct();
+
+                $this->category           = _x( 'WordPress Fields', 'xprofile field type category', 'buddypress' );
+                $this->name               = _x( 'Biography', 'xprofile field type', 'buddypress' );
+                $this->accepts_null_value = true;
+                $this->wp_user_key        = 'description';
+
+                $this->set_format( '/^.*$/m', 'replace' );
+
+                /**
+                 * Fires inside __construct() method for BP_XProfile_Field_Type_WordPress_Biography class.
+                 *
+                 * @since 8.0.0
+                 *
+                 * @param BP_XProfile_Field_Type_WordPress_Biography $this Instance of the field type object.
+                 */
+                do_action( 'bp_xprofile_field_type_wordpress_biography', $this );
+        }
+
+        /**
+         * Sanitize the user field before saving it to db.
+         *
+         * @since 8.0.0
+         *
+         * @param string $value The user field value.
+         * @return string The sanitized field value.
+         */
+        public function sanitize_for_db( $value ) {
+                return trim( $value );
+        }
+
+        /**
+         * Sanitize the user field before displaying it as an attribute.
+         *
+         * @since 8.0.0
+         *
+         * @param string $value The user field value.
+         * @param integer $user_id The user ID.
+         * @return string The sanitized field value.
+         */
+        public function sanitize_for_output( $value, $user_id = 0 ) {
+                if ( ! $user_id ) {
+                        $user_id = bp_displayed_user_id();
+                }
+
+                return sanitize_user_field( $this->wp_user_key, $value, $user_id, 'attribute' );
+        }
+
+        /**
+         * Output the edit field HTML for this field type.
+         *
+         * Must be used inside the {@link bp_profile_fields()} template loop.
+         *
+         * @since 8.0.0
+         *
+         * @param array $raw_properties Optional key/value array of
+         *                              {@link http://dev.w3.org/html5/markup/textarea.html permitted attributes}
+         *                              that you want to add.
+         */
+        public function edit_field_html( array $raw_properties = array() ) {
+                /*
+                 * User_id is a special optional parameter that certain other fields
+                 * types pass to {@link bp_the_profile_field_options()}.
+                 */
+                if ( ! is_admin() && isset( $raw_properties['user_id'] ) ) {
+                        unset( $raw_properties['user_id'] );
+                }
+
+                $user_id = bp_displayed_user_id();
+                if ( isset( $raw_properties['user_id'] ) && $raw_properties['user_id'] ) {
+                        $user_id = (int) $raw_properties['user_id'];
+                        unset( $raw_properties['user_id'] );
+                }
+                ?>
+
+                <label for="<?php bp_the_profile_field_input_name(); ?>">
+                        <?php bp_the_profile_field_name(); ?>
+                        <?php bp_the_profile_field_required_label(); ?>
+                </label>
+
+                <?php
+                /** This action is documented in bp-xprofile/bp-xprofile-classes */
+                do_action( bp_get_the_profile_field_errors_action() );
+
+                $r = wp_parse_args( $raw_properties, array(
+                        'cols' => 40,
+                        'rows' => 5,
+                ) );
+                ?>
+
+                <textarea <?php echo $this->get_edit_field_html_elements( $r ); ?>><?php
+                        echo $this->sanitize_for_output( bp_get_user_meta( $user_id, $this->wp_user_key, true ), $user_id );
+                ?></textarea>
+
+                <?php
+        }
+
+        /**
+         * Output HTML for this field type on the wp-admin Profile Fields screen.
+         *
+         * Must be used inside the {@link bp_profile_fields()} template loop.
+         *
+         * @since 8.0.0
+         *
+         * @param array $raw_properties Optional key/value array of permitted attributes that you want to add.
+         */
+        public function admin_field_html( array $raw_properties = array() ) {
+                $r = bp_parse_args( $raw_properties, array(
+                        'cols' => 40,
+                        'rows' => 5,
+                ) ); ?>
+
+                <textarea <?php echo $this->get_edit_field_html_elements( $r ); ?>></textarea>
+
+                <?php
+        }
+
+        /**
+         * This method usually outputs HTML for this field type's children options on the wp-admin Profile Fields
+         * "Add Field" and "Edit Field" screens, but for this field type, we don't want it, so it's stubbed out.
+         *
+         * @since 8.0.0
+         *
+         * @param BP_XProfile_Field $current_field The current profile field on the add/edit screen.
+         * @param string            $control_type  Optional. HTML input type used to render the
+         *                                         current field's child options.
+         */
+        public function admin_new_field_html( BP_XProfile_Field $current_field, $control_type = '' ) {}
+
+        /**
+         * Format WordPress Biography for display.
+         *
+         * @since 8.0.0
+         *
+         * @param string     $field_value The field value, as saved in the database.
+         * @param string|int $field_id    Optional. ID of the field.
+         * @return string The sanitized WordPress field.
+         */
+        public static function display_filter( $field_value, $field_id = '' ) {
+                return sanitize_user_field( 'description', $field_value, bp_displayed_user_id(), 'display' );
+        }
+}

new file src/bp-xprofile/classes/class-bp-xprofile-field-type-wordpress-textbox.php

@@ +1 @@
+<?php
+/**
+ * BuddyPress XProfile Classes.
+ *
+ * @package BuddyPress
+ * @subpackage XProfileClasses
+ * @since 8.0.0
+ */
+
+// Exit if accessed directly.
+defined( 'ABSPATH' ) || exit;
+
+/**
+ * WordPress xProfile regular field type.
+ *
+ * @since 8.0.0
+ */
+class BP_XProfile_Field_Type_WordPress_Textbox extends BP_XProfile_Field_Type_WordPress {
+
+        /**
+         * Constructor for the WordPress regular field type.
+         *
+         * @since 8.0.0
+         */
+        public function __construct() {
+                parent::__construct();
+
+                $this->category            = _x( 'WordPress Fields', 'xprofile field type category', 'buddypress' );
+                $this->name                = _x( 'Text field', 'xprofile field type', 'buddypress' );
+                $this->accepts_null_value  = true;
+                $this->do_settings_section = true;
+
+                $this->wp_user_key = '';
+                if ( isset( $this->field_obj->id ) ) {
+                        $this->wp_user_key = self::get_field_settings( $this->field_obj->id );
+                }
+
+                $this->set_format( '/^.*$/', 'replace' );
+
+                /**
+                 * Fires inside __construct() method for BP_XProfile_Field_Type_WordPress_Textbox class.
+                 *
+                 * @since 8.0.0
+                 *
+                 * @param BP_XProfile_Field_Type_WordPress_Textbox $this Instance of the field type object.
+                 */
+                do_action( 'bp_xprofile_field_type_wordpress_textbox', $this );
+
+                /*
+                 * As we are using an xProfile field meta to store the WordPress field meta key we need to make
+                 * sure $this->wp_user_key is set before trying to save a field.
+                 */
+                add_filter( 'bp_xprofile_set_field_data_pre_validate', array( $this, 'set_wp_user_key' ), 10, 2 );
+        }
+
+        /**
+         * Gets the WordPress field value during an xProfile fields loop.
+         *
+         * This function is used inside `BP_XProfile_ProfileData::get_data_for_user()`
+         * to include the WordPress field value into the xProfile fields loop.
+         *
+         * @since 8.0.0
+         *
+         * @param integer $user_id The user ID.
+         * @param integer $field_id The xProfile field ID.
+         * @return array An array containing the metadata `id`, `value` and `table_name`.
+         */
+        public function get_field_value( $user_id, $field_id = 0 ) {
+                if ( ! $this->wp_user_key ) {
+                        $this->wp_user_key = self::get_field_settings( $field_id );
+                }
+
+                return parent::get_field_value( $user_id, $field_id );
+        }
+
+        /**
+         * Sets the WordPress field wp_user_key property before saving the xProfile field.
+         *
+         * @since 8.0.0
+         *
+         * @param mixed                  $value Value passed to xprofile_set_field_data().
+         * @param BP_XProfile_Field      $field Field object.
+         * @return mixed Unchanged value.
+         */
+        public function set_wp_user_key( $value, $field ) {
+                if ( ! $this->wp_user_key && 'wp-textbox' === $field->type ) {
+                        $this->wp_user_key = self::get_field_settings( $field->id );
+                }
+
+                return $value;
+        }
+
+        /**
+         * Sanitize the user field before saving it to db.
+         *
+         * @since 8.0.0
+         *
+         * @param string $value The user field value.
+         * @return string The sanitized field value.
+         */
+        public function sanitize_for_db( $value ) {
+                if ( 'user_url' === $this->wp_user_key ) {
+                        return esc_url_raw( $value );
+                }
+
+                return sanitize_text_field( $value );
+        }
+
+        /**
+         * Sanitize the user field before displaying it as an attribute.
+         *
+         * @since 8.0.0
+         *
+         * @param string $value The user field value.
+         * @return string The sanitized field value.
+         */
+        public function sanitize_for_output( $value, $user_id = 0 ) {
+                if ( ! $user_id ) {
+                        $user_id = bp_displayed_user_id();
+                }
+
+                return sanitize_user_field( $this->wp_user_key, $value, $user_id, 'attribute' );
+        }
+
+        /**
+         * Output the edit field HTML for this field type.
+         *
+         * Must be used inside the {@link bp_profile_fields()} template loop.
+         *
+         * @since 8.0.0
+         *
+         * @param array $raw_properties Optional key/value array of
+         *                              {@link http://dev.w3.org/html5/markup/textarea.html permitted attributes}
+         *                              that you want to add.
+         */
+        public function edit_field_html( array $raw_properties = array() ) {
+                /*
+                 * User_id is a special optional parameter that certain other fields
+                 * types pass to {@link bp_the_profile_field_options()}.
+                 */
+                if ( ! is_admin() && isset( $raw_properties['user_id'] ) ) {
+                        unset( $raw_properties['user_id'] );
+                }
+
+                $user_id = bp_displayed_user_id();
+                if ( isset( $raw_properties['user_id'] ) && $raw_properties['user_id'] ) {
+                        $user_id = (int) $raw_properties['user_id'];
+                        unset( $raw_properties['user_id'] );
+                }
+
+                if ( ! $this->wp_user_key ) {
+                        $this->wp_user_key = self::get_field_settings( bp_get_the_profile_field_id() );
+                }
+
+                if ( 'user_url' === $this->wp_user_key ) {
+                        if ( bp_displayed_user_id() ) {
+                                $field_value = bp_get_displayed_user()->userdata->{$this->wp_user_key};
+                        } elseif ( $user_id ) {
+                                $user = get_user_by( 'id', $user_id );
+                                $field_value = $user->{$this->wp_user_key};
+                        }
+                } else {
+                        $field_value = bp_get_user_meta( $user_id, $this->wp_user_key, true );
+                }
+
+                $r = wp_parse_args( $raw_properties, array(
+                        'type'  => 'text',
+                        'value' => $this->sanitize_for_output( $field_value, $user_id ),
+                ) );
+                ?>
+
+                <legend id="<?php bp_the_profile_field_input_name(); ?>-1">
+                        <?php bp_the_profile_field_name(); ?>
+                        <?php bp_the_profile_field_required_label(); ?>
+                </legend>
+
+                <?php
+
+                /** This action is documented in bp-xprofile/bp-xprofile-classes */
+                do_action( bp_get_the_profile_field_errors_action() ); ?>
+
+                <input <?php echo $this->get_edit_field_html_elements( $r ); ?> aria-labelledby="<?php bp_the_profile_field_input_name(); ?>-1" aria-describedby="<?php bp_the_profile_field_input_name(); ?>-3">
+
+                <?php if ( bp_get_the_profile_field_description() ) : ?>
+                        <p class="description" id="<?php bp_the_profile_field_input_name(); ?>-3"><?php bp_the_profile_field_description(); ?></p>
+                <?php endif; ?>
+
+                <?php
+        }
+
+        /**
+         * Output HTML for this field type on the wp-admin Profile Fields screen.
+         *
+         * Must be used inside the {@link bp_profile_fields()} template loop.
+         *
+         * @since 8.0.0
+         *
+         * @param array $raw_properties Optional key/value array of permitted attributes that you want to add.
+         */
+        public function admin_field_html( array $raw_properties = array() ) {
+                $r = wp_parse_args( $raw_properties, array(
+                        'type' => 'text'
+                ) ); ?>
+
+                <label for="<?php bp_the_profile_field_input_name(); ?>" class="screen-reader-text"><?php
+                        /* translators: accessibility text */
+                        esc_html_e( 'WordPress field', 'buddypress' );
+                ?></label>
+                <input <?php echo $this->get_edit_field_html_elements( $r ); ?>>
+
+                <?php
+        }
+
+        /**
+         * Get settings for a given WordPress field.
+         *
+         * @since 8.0.0
+         *
+         * @param int $field_id ID of the field.
+         * @return string The meta_key used for this field.
+         */
+        public static function get_field_settings( $field_id ) {
+                $wp_user_key = bp_xprofile_get_meta( $field_id, 'field', 'wp_user_key', true );
+
+                return sanitize_key( $wp_user_key );
+        }
+
+        /**
+         * Save settings from the field edit screen in the Dashboard.
+         *
+         * @since 8.0.0
+         *
+         * @param int   $field_id ID of the field.
+         * @param array $settings Array of settings.
+         * @return bool True on success.
+         */
+        public function admin_save_settings( $field_id, $settings ) {
+                $existing_setting = self::get_field_settings( $field_id );
+                $setting = '';
+
+                if ( isset( $settings['wp_user_key'] ) ) {
+                        $setting = sanitize_key( $settings['wp_user_key'] );
+                }
+
+                if ( $setting && $setting !== $existing_setting ) {
+                        bp_xprofile_update_meta( $field_id, 'field', 'wp_user_key', $setting );
+                }
+
+                return true;
+        }
+
+        /**
+         * This method usually outputs HTML for this field type's children options on the wp-admin Profile Fields
+         * "Add Field" and "Edit Field" screens, but for this field type, we don't want it, so it's stubbed out.
+         *
+         * @since 8.0.0
+         *
+         * @param BP_XProfile_Field $current_field The current profile field on the add/edit screen.
+         * @param string            $control_type  Optional. HTML input type used to render the
+         *                                         current field's child options.
+         */
+        public function admin_new_field_html( BP_XProfile_Field $current_field, $control_type = '' ) {
+                $type = array_search( get_class( $this ), bp_xprofile_get_field_types() );
+
+                if ( false === $type ) {
+                        return;
+                }
+
+                $style = 'margin-top: 15px;';
+                if ( $current_field->type !== $type ) {
+                        $style .= ' display: none;';
+                };
+
+                $setting = self::get_field_settings( $current_field->id );
+
+                $wp_labels = array_merge(
+                        array(
+                                'first_name' => _x( 'First Name', 'xpofile wp-textbox field type label', 'buddypress' ),
+                                'last_name'  => _x( 'Last Name', 'xpofile wp-textbox field type label', 'buddypress' ),
+                                'user_url'   => _x( 'Website', 'xpofile wp-textbox field type label', 'buddypress' ),
+                        ),
+                        wp_get_user_contact_methods()
+                );
+                ?>
+                <div id="<?php echo esc_attr( $type ); ?>" class="postbox bp-options-box" style="<?php echo esc_attr( $style ); ?>">
+                        <h3><?php esc_html_e( 'Select the information you want to use for your WordPress field.', 'buddypress' ); ?></h3>
+
+                        <div class="inside" aria-live="polite" aria-atomic="true" aria-relevant="all">
+                                <div class="bp-option">
+                                        <ul>
+                                                <?php
+                                                foreach ( $this->supported_keys as $key ) {
+                                                        if ( 'description' === $key || ! isset( $wp_labels[ $key ] ) ) {
+                                                                continue;
+                                                        }
+
+                                                        printf(
+                                                                '<li>
+                                                                        <label for="wp-textbox-wp_user_key-%1$s">
+                                                                                <input type="radio" id="wp-textbox-wp_user_key-%1$s" name="field-settings[wp_user_key]" value="%1$s" %2$s/>
+                                                                                %3$s
+                                                                        </label>
+                                                                </li>',
+                                                                esc_attr( $key ),
+                                                                checked( $key, $setting, false ),
+                                                                esc_html( $wp_labels[ $key ] )
+                                                        );
+                                                }
+                                                ?>
+                                        </ul>
+                                </div>
+                        </div>
+                </div>
+                <?php
+        }
+
+        /**
+         * Format WordPress field values for display.
+         *
+         * @since 8.0.0
+         *
+         * @param string     $field_value The field value, as saved in the database.
+         * @param string|int $field_id    Optional. ID of the field.
+         * @return string The sanitized WordPress field.
+         */
+        public static function display_filter( $field_value, $field_id = '' ) {
+                $wp_user_key = self::get_field_settings( $field_id );
+
+                if ( ! $wp_user_key ) {
+                        return '';
+                }
+
+                if ( 'user_url' === $wp_user_key ) {
+                        $sanitized_website = sanitize_user_field( $wp_user_key, $field_value, bp_displayed_user_id(), 'attribute' );
+                        return sprintf( '<a href="%1$s" rel="nofollow">%1$s</a>', $sanitized_website );
+                }
+
+                return sanitize_user_field( $wp_user_key, $field_value, bp_displayed_user_id(), 'display' );
+        }
+}

new file src/bp-xprofile/classes/class-bp-xprofile-field-type-wordpress.php

@@ +1 @@
+<?php
+/**
+ * BuddyPress XProfile Classes.
+ *
+ * @package BuddyPress
+ * @subpackage XProfileClasses
+ * @since 8.0.0
+ */
+
+// Exit if accessed directly.
+defined( 'ABSPATH' ) || exit;
+
+/**
+ * Base class for xprofile field types that set/get WordPress profile data from usermeta.
+ *
+ * @since 8.0.0
+ */
+abstract class BP_XProfile_Field_Type_WordPress extends BP_XProfile_Field_Type {
+
+        /**
+         * The usermeta key for the WordPress field.
+         *
+         * @since 8.0.0
+         * @var string The meta key name of this WordPress field.
+         */
+        public $wp_user_key = '';
+
+        /**
+         * The WordPress supported user keys.
+         *
+         * @since 8.0.0
+         * @var string[] The WordPress supported user keys.
+         */
+        public $supported_keys = array();
+
+        /**
+         * Supported features for the WordPress field type.
+         *
+         * @since 8.0.0
+         * @var bool[] The WordPress field supported features.
+         */
+        public static $supported_features = array(
+                'switch_fieldtype'        => false,
+                'required'                => false,
+                'do_autolink'             => false,
+                'allow_custom_visibility' => false,
+        );
+
+        /**
+         * Constructor for the WordPress field type.
+         *
+         * @since 8.0.0
+         */
+        public function __construct() {
+                parent::__construct();
+
+                /**
+                 * Fires inside __construct() method for BP_XProfile_Field_Type_WordPress class.
+                 *
+                 * @since 8.0.0
+                 *
+                 * @param BP_XProfile_Field_Type_WordPress $this Instance of the field type object.
+                 */
+                do_action( 'bp_xprofile_field_type_wordpress', $this );
+
+                // Use the `$wpdb->usermeta` table instead of the $bp->profile->table_name_data one.
+                add_filter( 'bp_xprofile_set_field_data_pre_save', array( $this, 'set_field_value' ), 10, 2 );
+
+                // Set the supported keys.
+                $this->supported_keys = bp_xprofile_get_wp_user_keys();
+        }
+
+        /**
+         * Sanitize the user field before inserting it into db.
+         *
+         * @since 8.0.0
+         *
+         * @param string $value The user field value.
+         */
+        abstract public function sanitize_for_db( $value );
+
+        /**
+         * Sanitize the user field before displaying it as an attribute.
+         *
+         * @since 8.0.0
+         *
+         * @param string $value The user field value.
+         * @param integer $user_id The user ID.
+         */
+        abstract public function sanitize_for_output( $value, $user_id = 0 );
+
+        /**
+         * Sets the WordPress field value.
+         *
+         * @since 8.0.0
+         *
+         * @param boolean $retval Whether to shortcircuit the $bp->profile->table_name_data table.
+         *                        Default `false`.
+         * @param array $field_args {
+         *     An array of arguments.
+         *
+         *     @type object            $field_type_obj Field type object.
+         *     @type BP_XProfile_Field $field          Field object.
+         *     @type integer           $user_id        The user ID.
+         *     @type mixed             $value          Value passed to xprofile_set_field_data().
+         *     @type boolean           $is_required    Whether or not the field is required.
+         * }
+         * @return boolean Whether to shortcircuit the $bp->profile->table_name_data table.
+         */
+        public function set_field_value( $retval = false, $field_args = array() ) {
+                // Check the wp_user_key is valid and supported.
+                if ( ! isset( $field_args['field']->type_obj->wp_user_key ) || $this->wp_user_key !== $field_args['field']->type_obj->wp_user_key || ! in_array( $field_args['field']->type_obj->wp_user_key, $this->supported_keys, true ) ) {
+                        return false;
+                }
+
+                $wp_user_field_value = $this->sanitize_for_db( $field_args['value'] );
+                $bp_displayed_user   = bp_get_displayed_user();
+
+                if ( isset( $bp_displayed_user->updated_keys ) ) {
+                        $bp_displayed_user->updated_keys[ $this->wp_user_key ] = $wp_user_field_value;
+                        $retval = true;
+                } else {
+                        $retval = wp_update_user(
+                                array(
+                                        'ID'               => (int) $field_args['user_id'],
+                                        $this->wp_user_key => $wp_user_field_value,
+                                )
+                        );
+                }
+
+                if ( ! is_wp_error( $retval ) ) {
+                        $retval = true;
+                }
+
+                return $retval;
+        }
+
+        /**
+         * Gets the WordPress field value during an xProfile fields loop.
+         *
+         * This function is used inside `BP_XProfile_ProfileData::get_data_for_user()`
+         * to include the WordPress field value into the xProfile fields loop.
+         *
+         * @since 8.0.0
+         *
+         * @param integer $user_id The user ID.
+         * @param integer $field_id The xProfile field ID.
+         * @return array An array containing the metadata `id`, `value` and `table_name`.
+         */
+        public function get_field_value( $user_id, $field_id = 0 ) {
+                global $wpdb;
+                $wp_field = array(
+                        'id'         => 0,
+                        'value'      => '',
+                        'table_name' => $wpdb->usermeta,
+                );
+
+                if ( 'user_url' === $this->wp_user_key ) {
+                        if ( bp_displayed_user_id() ) {
+                                $wp_field['value'] = bp_get_displayed_user()->userdata->{$this->wp_user_key};
+                        } elseif ( $user_id ) {
+                                $user = get_user_by( 'id', $user_id );
+                                $wp_field['value'] = $user->{$this->wp_user_key};
+                        }
+
+                        $wp_field['id']         = $user_id;
+                        $wp_field['table_name'] = $wpdb->users;
+                } else {
+                        $umeta_key = $this->wp_user_key;
+                        $user_mid  = wp_cache_get( $user_id, 'bp_user_mid' );
+                        if ( ! $user_mid ) {
+                                $user_mid = array();
+                        }
+
+                        if ( ! $user_mid ) {
+                                $list_values   = bp_get_user_meta( $user_id, $umeta_key );
+                                $wp_field['value'] = reset( $list_values );
+                                $wp_field['id']    = key( $list_values );
+
+                                if ( 0 === $wp_field['id'] ) {
+                                        /*
+                                        * We can't just update the WP User Meta cache to key again meta values with meta_ids because of
+                                        * `return maybe_unserialize( $meta_cache[ $meta_key ][0] );` in `get_metadata_raw()`.
+                                        */
+                                        $user_meta_cache = wp_cache_get( $user_id, 'user_meta' );
+
+                                        if ( $user_meta_cache ) {
+                                                $metas = $wpdb->get_results( $wpdb->prepare( "SELECT umeta_id, meta_key, meta_value FROM {$wpdb->usermeta} WHERE user_id = %d ORDER BY umeta_id ASC", $user_id ) );
+
+                                                if ( $metas ) {
+                                                        foreach ( $user_meta_cache as $meta_key => $meta_values ) {
+                                                                if ( ! in_array( $meta_key, $this->supported_keys, true ) ) {
+                                                                        continue;
+                                                                }
+
+                                                                foreach ( $meta_values as $meta_value ) {
+                                                                        $meta_object = wp_list_filter( $metas, array( 'meta_key' => $meta_key, 'meta_value' => $meta_value ) );
+
+                                                                        if ( 1 === count( $meta_object ) ) {
+                                                                                $meta_object = reset( $meta_object );
+                                                                                $user_mid[ $meta_key ][ $meta_object->umeta_id ] = $meta_value;
+
+                                                                                // Set the meta_id for the requested field.
+                                                                                if ( $umeta_key === $meta_key ) {
+                                                                                        $wp_field['id'] = $meta_object->umeta_id;
+                                                                                }
+                                                                        }
+                                                                }
+                                                        }
+                                                }
+
+                                                // Set the User mid cache.
+                                                wp_cache_set( $user_id, $user_mid, 'bp_user_mid' );
+                                        }
+                                }
+                        }
+
+                        if ( isset( $user_mid[ $umeta_key ] ) ) {
+                                $wp_field['value'] = reset( $user_mid[ $umeta_key ] );
+                                $wp_field['id']    = key( $user_mid[ $umeta_key ] );
+                        }
+                }
+
+                return $wp_field;
+        }
+}

src/bp-xprofile/classes/class-bp-xprofile-field.php

@@ -1317 +1317 @@
         <?php
         }
 
+        /**
+         * Gets field type supports.
+         *
+         * @since 8.0.0
+         *
+         * @return bool[] Supported features.
+         */
+        public function get_field_type_supports() {
+                $supports = array(
+                        'switch_fieldtype'       => true,
+                        'allow_required'         => true,
+                        'allow_autolink'         => true,
+                        'allo_custom_visibility' => true,
+                );
+
+                if ( isset( $this->type_obj ) && $this->type_obj ) {
+                        $field_type        = $this->type_obj;
+                        $parent_field_type = get_parent_class( $field_type );
+
+                        if ( 'BP_XProfile_Field_Type_WordPress' === $parent_field_type && isset( $field_type::$supported_features ) ) {
+                                $supports = array_merge( $supports, $field_type::$supported_features );
+                        }
+                }
+
+                return $supports;
+        }
+
+        /**
+         * Checks whether the field type supports the requested feature.
+         *
+         * @since 8.0.0
+         *
+         * @param string $support The name of the feature.
+         * @return boolean True if the field type supports the feature. False otherwise.
+         */
+        public function field_type_supports( $support = '' ) {
+                $retval   = true;
+                $features = $this->get_field_type_supports();
+
+                if ( isset( $features[ $support ] ) ) {
+                        $retval = $features[ $support ];
+                }
+
+                return $retval;
+        }
+
         /**
          * Private method used to display the submit metabox.
          *
@@ -1496 +1542 @@
          */
         private function visibility_metabox() {
 
-                // Default field cannot have custom visibility.
-                if ( true === $this->is_default_field() ) {
+                // Default field and field types not supporting the feature cannot have custom visibility.
+                if ( true === $this->is_default_field() || ! $this->field_type_supports( 'allow_custom_visibility' ) ) {
                         return;
                 } ?>
 
@@ -1545 +1591 @@
          */
         private function required_metabox() {
 
-                // Default field is always required.
-                if ( true === $this->is_default_field() ) {
+                // Default field and field types not supporting the feature cannot be required.
+                if ( true === $this->is_default_field() || ! $this->field_type_supports( 'required' ) ) {
                         return;
                 } ?>
 
@@ -1571 +1617 @@
          * @return void If default field id 1.
          */
         private function autolink_metabox() {
-                ?>
+
+                // Field types not supporting the feature cannot use autolink.
+                if ( ! $this->field_type_supports( 'do_autolink' ) ) {
+                        return;
+                } ?>
 
                 <div class="postbox">
                         <h2><?php esc_html_e( 'Autolink', 'buddypress' ); ?></h2>
@@ -1606 +1656 @@
                 // Default field cannot change type.
                 if ( true === $this->is_default_field() ) {
                         return;
-                } ?>
+                }
+                ?>
 
                 <div class="postbox">
                         <h2><label for="fieldtype"><?php esc_html_e( 'Type', 'buddypress'); ?></label></h2>
                         <div class="inside" aria-live="polite" aria-atomic="true" aria-relevant="all">
-                                <select name="fieldtype" id="fieldtype" onchange="show_options(this.value)">
+                                <?php if ( ! $this->field_type_supports( 'switch_fieldtype' ) ) : ?>
+                                        <input type="text" disabled="true" value="<?php echo esc_attr( $this->type_obj->name ); ?>">
+                                        <input type="hidden" name="fieldtype" id="fieldtype" value="<?php echo esc_attr( $this->type ); ?>">
 
-                                        <?php bp_xprofile_admin_form_field_types( $this->type ); ?>
+                                <?php else : ?>
+                                        <select name="fieldtype" id="fieldtype" onchange="show_options(this.value)">
 
-                                </select>
+                                                <?php bp_xprofile_admin_form_field_types( $this->type ); ?>
+
+                                        </select>
+                                <?php endif; ?>
 
                                 <?php
 
@@ -1642 +1699 @@
                 // Nonce.
                 wp_nonce_field( 'bp_xprofile_admin_field', 'bp_xprofile_admin_field' );
 
-                // Field 1 is the fullname field, which cannot have custom visibility.
-                if ( false === $this->is_default_field() ) {
-                        return;
-                } ?>
+                // Init default field hidden inputs.
+                $default_field_hidden_inputs = array();
+                $hidden_fields = array(
+                        'required' => array(
+                                'name'  => 'required',
+                                'id'    => 'required',
+                                'value' => '0',
+                        ),
+                        'default_visibility' => array(
+                                'name'  => 'default-visibility',
+                                'id'    => 'default-visibility',
+                                'value' => 'public',
+                        ),
+                        'allow_custom_visibility' => array(
+                                'name'  => 'allow-custom-visibility',
+                                'id'    => 'allow-custom-visibility',
+                                'value' => 'disabled',
+                        ),
+                        'do_autolink' => array(
+                                'name'  => 'do_autolink',
+                                'id'    => 'do-autolink',
+                                'value' => '',
+                        ),
+                );
+
+                // Field 1 is the fullname field, which is required.
+                if ( true === $this->is_default_field() ) {
+                        $default_field_required          = $hidden_fields['required'];
+                        $default_field_required['value'] = '1';
+
+                        $default_field_hidden_inputs = array(
+                                $default_field_required,
+                                array(
+                                        'name'  => 'fieldtype',
+                                        'id'    => 'fieldtype',
+                                        'value' => 'textbox',
+                                ),
+                        );
+                }
 
-                <input type="hidden" name="required"  id="required"  value="1"       />
-                <input type="hidden" name="fieldtype" id="fieldtype" value="textbox" />
+                $supports = $this->get_field_type_supports();
+                if ( $supports ) {
+                        foreach ( $supports as $feature => $support ) {
+                                if ( true === $support || 'switch_fieldtype' === $feature ) {
+                                        continue;
+                                }
 
-                <?php
+                                $default_field_hidden_inputs[] = $hidden_fields[ $feature ];
+
+                                if ( 'allow_custom_visibility' === $feature ) {
+                                        $default_field_hidden_inputs[] = $hidden_fields['default_visibility'];
+                                }
+                        }
+                }
+
+                if ( ! $default_field_hidden_inputs ) {
+                        return;
+                }
+
+                foreach ( $default_field_hidden_inputs as $default_field_hidden_input ) {
+                        printf(
+                                '<input type="hidden" name="%1$s" id="%2$s" value="%3$s"/>',
+                                esc_attr( $default_field_hidden_input['name'] ),
+                                esc_attr( $default_field_hidden_input['id'] ),
+                                esc_attr( $default_field_hidden_input['value'] ),
+                        );
+                }
         }
 
         /**

src/bp-xprofile/classes/class-bp-xprofile-group.php

@@ -346 +346 @@
 
                 // Maybe fetch field data.
                 if ( ! empty( $r['fetch_field_data'] ) ) {
+                        $field_type_objects = wp_list_pluck( $fields, 'type_obj', 'id' );
 
                         // Get field data for user ID.
                         if ( ! empty( $field_ids ) && ! empty( $r['user_id'] ) ) {
-                                $field_data = BP_XProfile_ProfileData::get_data_for_user( $r['user_id'], $field_ids );
+                                $field_data = BP_XProfile_ProfileData::get_data_for_user( $r['user_id'], $field_ids, $field_type_objects );
                         }
 
                         // Remove data-less fields, if necessary.

src/bp-xprofile/classes/class-bp-xprofile-profiledata.php

@@ -321 +321 @@
          * @param array $field_ids Array of field IDs to query for.
          * @return array
          */
-        public static function get_data_for_user( $user_id, $field_ids ) {
+        public static function get_data_for_user( $user_id, $field_ids, $field_type_objects = array() ) {
                 global $wpdb;
 
                 $data = array();
@@ -339 +339 @@
                         foreach ( $uncached_data as $ud ) {
                                 $d               = new stdClass;
                                 $d->id           = $ud->id;
+                                $d->table_name   = $bp->profile->table_name_data;
                                 $d->user_id      = $ud->user_id;
                                 $d->field_id     = $ud->field_id;
                                 $d->value        = $ud->value;
@@ -359 +360 @@
                                 // If no value was found, cache an empty item
                                 // to avoid future cache misses.
                                 } else {
-                                        $d               = new stdClass;
-                                        $d->id           = '';
+                                        $d = new stdClass;
+
+                                        // Check WordPress if it's a WordPress field.
+                                        if ( isset( $field_type_objects[ $field_id ]->wp_user_key ) ) {
+                                                $meta          = $field_type_objects[ $field_id ]->get_field_value( $user_id, $field_id );
+                                                $d->id         = $meta['id'];
+                                                $d->value      = $meta['value'];
+                                                $d->table_name = $meta['table_name'];
+
+                                        } else {
+                                                $d->id    = '';
+                                                $d->value = '';
+                                        }
+
+                                        $d->table_name   = '';
                                         $d->user_id      = $user_id;
                                         $d->field_id     = $field_id;
-                                        $d->value        = '';
                                         $d->last_updated = '';
 
                                         wp_cache_set( $cache_key, $d, 'bp_xprofile_data' );

src/bp-xprofile/screens/edit.php

@@ -50 +50 @@
                 $posted_field_ids = wp_parse_id_list( $_POST['field_ids'] );
                 $is_required      = array();
 
+                $bp_displayed_user = bp_get_displayed_user();
+                $bp_displayed_user->updated_keys = array();
+
                 // Loop through the posted fields formatting any datebox values then validate the field.
                 foreach ( (array) $posted_field_ids as $field_id ) {
                         bp_xprofile_maybe_format_datebox_post_data( $field_id );
@@ -126 +129 @@
                          */
                         do_action( 'xprofile_updated_profile', bp_displayed_user_id(), $posted_field_ids, $errors, $old_values, $new_values );
 
+                        // Some WP User keys have been updated: let's update the WP fiels all together.
+                        if ( $bp_displayed_user->updated_keys ) {
+                                $user_id = wp_update_user(
+                                        array_merge(
+                                                array(
+                                                        'ID' => bp_displayed_user_id(),
+                                                ),
+                                                $bp_displayed_user->updated_keys
+                                        )
+                                );
+
+                                $bp_displayed_user->updated_keys = array();
+
+                                if ( is_wp_error( $user_id ) ) {
+                                        $errors = true;
+                                }
+                        }
+
                         // Set the feedback messages.
                         if ( !empty( $errors ) ) {
                                 bp_core_add_message( __( 'There was a problem updating some of your profile information. Please try again.', 'buddypress' ), 'error' );
@@ -153 +174 @@
          * @param string $template Path to the XProfile edit template to load.
          */
         bp_core_load_template( apply_filters( 'xprofile_template_edit_profile', 'members/single/home' ) );
-}
- No newline at end of file
+}