Ticket #5192: 5192.diff

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

@@ -361 +361 @@
                                         bp_update_option( 'bp-xprofile-fullname-field-name', $field->name );
                                 }
 
+                                // Set member types.
+                                if ( isset( $_POST['has-member-types'] ) ) {
+                                        $member_types = array();
+                                        if ( isset( $_POST['member-types'] ) ) {
+                                                $member_types = stripslashes_deep( $_POST['member-types'] );
+                                        }
+
+                                        $field->set_member_types( $member_types );
+                                }
+
                                 // 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'] );

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

@@ -124 +124 @@
         public $data;
 
         /**
+         * Member types to which the profile field should be applied.
+         *
+         * @since BuddyPress (2.4.0)
+         * @access protected
+         * @var array Array of member types.
+         */
+        protected $member_types;
+
+        /**
          * Initialize and/or populate profile field
          *
          * @since BuddyPress (1.1.0)
@@ -457 +466 @@
                 $wpdb->query( $sql );
         }
 
+        /**
+         * Get the member types to which this field should be available.
+         *
+         * @since BuddyPress (2.4.0)
+         */
+        public function get_member_types() {
+                if ( ! is_null( $this->member_types ) ) {
+                        return $this->member_types;
+                }
+
+                $raw_types = bp_xprofile_get_meta( $this->id, 'field', 'member-type', false );
+
+                // If `$raw_types` is not an array, it probably means this is a new field (id=0).
+                if ( ! is_array( $raw_types ) ) {
+                        $raw_types = array();
+                }
+
+                // If '_none' is found in the array, it overrides all types.
+                $types = array();
+                if ( ! in_array( '_none', $raw_types ) ) {
+                        $registered_types = bp_get_member_types();
+
+                        // Eliminate invalid member types saved in the database.
+                        foreach ( $raw_types as $raw_type ) {
+                                // 'none' is a special case - it represents users without a type.
+                                if ( 'none' === $raw_type || isset( $registered_types[ $raw_type ] ) ) {
+                                        $types[] = $raw_type;
+                                }
+                        }
+
+                        // If no member types have been saved, intepret as *all* member types.
+                        if ( empty( $types ) ) {
+                                $types = array_values( $registered_types );
+
+                                // + the "none" type, ie users without a type.
+                                $types[] = 'none';
+                        }
+                }
+
+                /**
+                 * Filters the member types to which an XProfile object should be applied.
+                 *
+                 * @since BuddyPress (2.4.0)
+                 *
+                 * @param array             $types Member types.
+                 * @param BP_XProfile_Field $field Field object.
+                 */
+                $this->member_types = apply_filters( 'bp_xprofile_field_member_types', $types, $this );
+
+                return $this->member_types;
+        }
+
+        /**
+         * Set the member types for this field.
+         *
+         * @since BuddyPress (2.4.0)
+         *
+         * @param array $member_types Array of member types.
+         * @param bool  $append       Whether to append to existing member types. If false, all existing member type
+         *                            associations will be deleted before adding your `$member_types`. Default false.
+         * @return array Member types for the current field, after being saved.
+         */
+        public function set_member_types( $member_types, $append = false ) {
+                // Unset invalid member types.
+                $types = array();
+                foreach ( $member_types as $member_type ) {
+                        // 'none' is a special case - it represents users without a type.
+                        if ( 'none' === $member_type || bp_get_member_type_object( $member_type ) ) {
+                                $types[] = $member_type;
+                        }
+                }
+
+                // When `$append` is false, delete all existing types before adding new ones.
+                if ( ! $append ) {
+                        bp_xprofile_delete_meta( $this->id, 'field', 'member-type' );
+
+                        /*
+                         * We interpret an empty array as disassociating the field from all types. This is
+                         * represented internally with the '_none' flag.
+                         */
+                        if ( empty( $types ) ) {
+                                bp_xprofile_add_meta( $this->id, 'field', 'member-type', '_none' );
+                        }
+                }
+
+                // "All types" is represented in the database with no meta entries.
+                $registered_types = bp_get_member_types();
+                $rtypes = array_values( $registered_types );
+                $rtypes[] = 'none';
+
+                sort( $types );
+                sort( $rtypes );
+
+                if ( $types !== $rtypes ) {
+                        // Save new types.
+                        foreach ( $types as $type ) {
+                                bp_xprofile_add_meta( $this->id, 'field', 'member-type', $type );
+                        }
+                }
+
+                // Reset internal cache of member types.
+                $this->member_types = null;
+
+                // Refetch fresh items from the database.
+                return $this->get_member_types();
+        }
+
         /** Static Methods ********************************************************/
 
         public static function get_type( $field_id = 0 ) {
@@ -718 +834 @@
                                                         // Output the required metabox
                                                         $this->required_metabox();
 
+                                                        // Output the Member Types metabox.
+                                                        $this->member_type_metabox();
+
                                                         // Output the field visibility metaboxes
                                                         $this->visibility_metabox();
 
@@ -864 +983 @@
         }
 
         /**
+         * Private method used to output field Member Type metabox.
+         *
+         * @since BuddyPress (2.4.0)
+         */
+        private function member_type_metabox() {
+
+                // The primary field is for all, so bail.
+                if ( 1 === (int) $this->id ) {
+                        return;
+                }
+
+                // Bail when no member types are registered.
+                if ( ! $member_types = bp_get_member_types( array(), 'objects' ) ) {
+                        return;
+                }
+
+                $field_member_types = $this->get_member_types();
+
+                ?>
+
+                <div id="for_member_types" class="postbox">
+                        <h3><?php _e( 'Member Types', 'bp-xprofile-field-for-member-types' ); ?></h3>
+                        <div class="inside">
+                                <p class="description"><?php _e( 'This field should be available to:', 'bp-xprofile-field-for-member-types' ); ?></p>
+
+                                <ul>
+                                        <?php foreach ( $member_types as $member_type ) : ?>
+                                        <li>
+                                                <label>
+                                                        <input name="member-types[]" type="checkbox" value="<?php echo $member_type->name; ?>" <?php checked( in_array( $member_type->name, $field_member_types ) ); ?>/>
+                                                        <?php echo $member_type->labels['name']; ?>
+                                                </label>
+                                        </li>
+                                        <?php endforeach; ?>
+
+                                        <li>
+                                                <label>
+                                                        <input name="member-types[]" type="checkbox" value="none" <?php checked( in_array( 'none', $field_member_types ) ); ?>/>
+                                                        <?php _e( 'Users with no member type', 'bp-xprofile-field-for-member-types' ); ?>
+                                                </label>
+                                        </li>
+
+                                </ul>
+                        </div>
+
+                        <input type="hidden" name="has-member-types" value="1" />
+                </div>
+
+                <?php
+        }
+
+        /**
          * Private method used to output field visibility metaboxes
          *
          * @since BuddyPress (2.3.0)

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

@@ -333 +333 @@
 
                 // Fetch the fields
                 $fields    = $wpdb->get_results( "SELECT id, name, description, type, group_id, is_required FROM {$bp->profile->table_name_fields} WHERE group_id IN ( {$group_ids_in} ) AND parent_id = 0 {$exclude_fields_sql} ORDER BY field_order" );
+
+                // Remove fields based on member-type restrictions, if necessary.
+                if ( $r['user_id'] ) {
+                        $user_member_types = bp_get_member_type( $r['user_id'], false );
+                        if ( empty( $user_member_types ) ) {
+                                $user_member_types = array( 'none' );
+                        }
+
+                        foreach ( $fields as $k => $_field ) {
+                                $field_obj = new BP_XProfile_Field( $_field->id );
+                                $field_member_types = $field_obj->get_member_types();
+                                $matching_types = array_intersect( $user_member_types, $field_member_types );
+                                if ( empty( $matching_types ) ) {
+                                        unset( $fields[ $k ] );
+                                }
+                        }
+
+                        // Reset indexes.
+                        $fields = array_values( $fields );
+                }
+
                 $field_ids = wp_list_pluck( $fields, 'id' );
 
                 // Store field IDs for meta cache priming

new file tests/phpunit/testcases/xprofile/BP_XProfile_Field/member_types.php

@@ +1 @@
+<?php
+
+/**
+ * @group member_types
+ * @group xprofile
+ */
+class BP_Tests_XProfile_BpXprofileField_MemberTypes extends BP_UnitTestCase {
+        protected $field_group_id;
+        protected $field_id;
+        protected $field;
+
+        public function setUp() {
+                parent::setUp();
+                bp_register_member_type( 'foo' );
+                bp_register_member_type( 'bar' );
+
+                $this->field_group_id = $this->factory->xprofile_group->create();
+                $this->field_id = $this->factory->xprofile_field->create( array( 'field_group_id' => $this->field_group_id ) );
+                $this->field = new BP_XProfile_Field( $this->field_id );
+        }
+
+        public function tearDown() {
+                buddypress()->members->types = array();
+                parent::tearDown();
+        }
+
+        public function test_get_single_member_type() {
+                bp_xprofile_add_meta( $this->field_id, 'field', 'member-type', 'foo' );
+                $this->assertEqualSets( array( 'foo' ), $this->field->get_member_types() );
+        }
+
+        public function test_get_multiple_member_types() {
+                bp_xprofile_add_meta( $this->field_id, 'field', 'member-type', 'foo' );
+                bp_xprofile_add_meta( $this->field_id, 'field', 'member-type', 'bar' );
+                $this->assertEqualSets( array( 'foo', 'bar' ), $this->field->get_member_types() );
+        }
+
+        public function test_invalid_member_types_should_not_be_returned() {
+                bp_xprofile_add_meta( $this->field_id, 'field', 'member-type', 'foo' );
+                bp_xprofile_add_meta( $this->field_id, 'field', 'member-type', 'phony' );
+                $this->assertEquals( array( 'foo' ), $this->field->get_member_types() );
+        }
+
+        public function test_when_no_stored_types_are_found_all_registered_member_types_as_well_as_null_type_should_be_returned() {
+                $this->assertEqualSets( array( 'none', 'foo', 'bar' ), $this->field->get_member_types() );
+        }
+
+        public function test__none_meta_should_result_in_empty_array() {
+                bp_xprofile_add_meta( $this->field_id, 'field', 'member-type', '_none' );
+                $this->assertEquals( array(), $this->field->get_member_types() );
+        }
+
+        public function test__none_meta_should_override_other_values() {
+                bp_xprofile_add_meta( $this->field_id, 'field', 'member-type', '_none' );
+                bp_xprofile_add_meta( $this->field_id, 'field', 'member-type', 'foo' );
+                $this->assertEquals( array(), $this->field->get_member_types() );
+        }
+
+        public function test_set_should_not_append_by_default() {
+                bp_xprofile_add_meta( $this->field_id, 'field', 'member-type', 'foo' );
+                $this->assertEquals( array( 'bar' ), $this->field->set_member_types( array( 'bar' ) ) );
+        }
+
+        public function test_set_should_not_append_when_append_is_set_to_false() {
+                bp_xprofile_add_meta( $this->field_id, 'field', 'member-type', 'foo' );
+                $this->assertEquals( array( 'bar' ), $this->field->set_member_types( array( 'bar', false ) ) );
+        }
+
+        public function test_set_should_append_when_append_is_set_to_true() {
+                bp_xprofile_add_meta( $this->field_id, 'field', 'member-type', 'foo' );
+                $this->assertEqualSets( array( 'foo', 'bar' ), $this->field->set_member_types( array( 'bar' ), true ) );
+        }
+
+        public function test_set_empty_array_with_append_true_should_have_no_effect_on_saved_types() {
+                bp_xprofile_add_meta( $this->field_id, 'field', 'member-type', 'foo' );
+                $this->assertEqualSets( array( 'foo' ), $this->field->set_member_types( array(), true ) );
+        }
+
+        public function test_set_empty_array_with_append_false_should_result_in_field_being_associated_with_no_member_types() {
+                bp_xprofile_add_meta( $this->field_id, 'field', 'member-type', 'foo' );
+                $this->assertEqualSets( array(), $this->field->set_member_types( array() ) );
+        }
+
+        public function test_set_should_interpret_null_flag_properly() {
+                $this->assertEqualSets( array( 'none' ), $this->field->set_member_types( array( 'none' ) ) );
+        }
+
+        public function test_set_all_types_plus_none_should_result_in_nothing_stored_in_db() {
+                $types = array( 'none', 'foo', 'bar' );
+                $this->assertEqualSets( $types, $this->field->set_member_types( $types ) );
+
+                $types_db = bp_xprofile_get_meta( $this->field_id, 'field', 'member-type', false );
+                $this->assertEqualSets( array(), $types_db );
+        }
+}

tests/phpunit/testcases/xprofile/class-bp-xprofile-group.php

@@ -113 +113 @@
         }
 
         /**
+         * @group member_types
+         */
+        public function test_member_type_restrictions_should_be_ignored_when_user_id_is_null() {
+                $g = $this->factory->xprofile_group->create();
+                $f = $this->factory->xprofile_field->create( array( 'field_group_id' => $g ) );
+                bp_register_member_type( 'foo' );
+
+                $field = new BP_XProfile_Field( $f );
+                $field->set_member_types( array( 'foo' ) );
+
+                $found_groups = BP_XProfile_Group::get( array(
+                        'user_id' => false,
+                        'fetch_fields' => true,
+                ) );
+
+                // The groups aren't indexed, so we have to go looking for it.
+                foreach ( $found_groups as $fg ) {
+                        if ( $g == $fg->id ) {
+                                $the_group = $fg;
+                        }
+                }
+
+                $this->assertContains( $f, wp_list_pluck( $fg->fields, 'id' ) );
+        }
+
+        /**
+         * @group member_types
+         */
+        public function test_member_type_restrictions_should_be_ignored_when_user_id_is_0() {
+                $g = $this->factory->xprofile_group->create();
+                $f = $this->factory->xprofile_field->create( array( 'field_group_id' => $g ) );
+                bp_register_member_type( 'foo' );
+
+                $field = new BP_XProfile_Field( $f );
+                $field->set_member_types( array( 'foo' ) );
+
+                $found_groups = BP_XProfile_Group::get( array(
+                        'user_id' => 0,
+                        'fetch_fields' => true,
+                ) );
+
+                // The groups aren't indexed, so we have to go looking for it.
+                foreach ( $found_groups as $fg ) {
+                        if ( $g == $fg->id ) {
+                                $the_group = $fg;
+                        }
+                }
+
+                $this->assertContains( $f, wp_list_pluck( $fg->fields, 'id' ) );
+        }
+
+        /**
+         * @group member_types
+         */
+        public function test_member_type_restrictions_should_be_obeyed_for_nonzero_user_id() {
+                $g = $this->factory->xprofile_group->create();
+                $f1 = $this->factory->xprofile_field->create( array( 'field_group_id' => $g ) );
+                $f2 = $this->factory->xprofile_field->create( array( 'field_group_id' => $g ) );
+                $f3 = $this->factory->xprofile_field->create( array( 'field_group_id' => $g ) );
+                $f4 = $this->factory->xprofile_field->create( array( 'field_group_id' => $g ) );
+                bp_register_member_type( 'foo' );
+                bp_register_member_type( 'bar' );
+
+                // Field 1 is visible only to 'foo' users.
+                $field1 = new BP_XProfile_Field( $f1 );
+                $field1->set_member_types( array( 'foo' ) );
+
+                // Field 2 is visible only to 'bar' users.
+                $field2 = new BP_XProfile_Field( $f2 );
+                $field2->set_member_types( array( 'bar' ) );
+
+                // Field 3 is visible to all users (no member type set).
+
+                // Field 4 is visible to no one.
+                $field4 = new BP_XProfile_Field( $f4 );
+                $field4->set_member_types( array() );
+
+                // User is in 'foo', so should have f1 and f3 only.
+                $u = $this->factory->user->create();
+                bp_set_member_type( $u, 'foo' );
+
+                $found_groups = BP_XProfile_Group::get( array(
+                        'user_id' => $u,
+                        'fetch_fields' => true,
+                ) );
+
+                // The groups aren't indexed, so we have to go looking for it.
+                foreach ( $found_groups as $fg ) {
+                        if ( $g == $fg->id ) {
+                                $the_group = $fg;
+                        }
+                }
+
+                $this->assertContains( $f1, wp_list_pluck( $fg->fields, 'id' ) );
+                $this->assertContains( $f3, wp_list_pluck( $fg->fields, 'id' ) );
+                $this->assertNotContains( $f2, wp_list_pluck( $fg->fields, 'id' ) );
+                $this->assertNotContains( $f4, wp_list_pluck( $fg->fields, 'id' ) );
+        }
+
+        /**
+         * @group member_types
+         */
+        public function test_member_type_restrictions_should_be_obeyed_for_nonzero_user_id_with_no_member_types() {
+                $g = $this->factory->xprofile_group->create();
+                $f1 = $this->factory->xprofile_field->create( array( 'field_group_id' => $g ) );
+                $f2 = $this->factory->xprofile_field->create( array( 'field_group_id' => $g ) );
+                $f3 = $this->factory->xprofile_field->create( array( 'field_group_id' => $g ) );
+                bp_register_member_type( 'foo' );
+                bp_register_member_type( 'bar' );
+
+                // Field 1 is visible only to 'foo' users.
+                $field1 = new BP_XProfile_Field( $f1 );
+                $field1->set_member_types( array( 'foo' ) );
+
+                // Field 2 is visible only to 'none' users.
+                $field2 = new BP_XProfile_Field( $f2 );
+                $field2->set_member_types( array( 'none' ) );
+
+                // Field 3 is visible to all users (no member type set).
+
+                // User has no member types, so should see f2 and f3 .
+                $u = $this->factory->user->create();
+
+                $found_groups = BP_XProfile_Group::get( array(
+                        'user_id' => $u,
+                        'fetch_fields' => true,
+                ) );
+
+                // The groups aren't indexed, so we have to go looking for it.
+                foreach ( $found_groups as $fg ) {
+                        if ( $g == $fg->id ) {
+                                $the_group = $fg;
+                        }
+                }
+
+                $this->assertNotContains( $f1, wp_list_pluck( $fg->fields, 'id' ) );
+                $this->assertContains( $f2, wp_list_pluck( $fg->fields, 'id' ) );
+                $this->assertContains( $f3, wp_list_pluck( $fg->fields, 'id' ) );
+        }
+
+        /**
          * @group save_xprofile_group_name
          */
         public function test_save_xprofile_group_name() {