Skip to:
Content

BuddyPress.org

Changeset 10022


Ignore:
Timestamp:
07/21/2015 02:00:38 PM (9 years ago)
Author:
boonebgorges
Message:

Allow xProfile fields to be restricted to users belonging to one or more member types.

A new metabox on the profile field edit panel allows the administrator to
select the member types to which the field is applicable. Admins can also
choose to have a field apply to users who do not belong to any member type.
Information about a field's member type associations is displayed on the
Users > Profile Fields page, alongside each field name.

During registration, the only fields that are displayed are those that are
unrestricted - that is, those available to all users, regardless of member type
(or lack thereof).

This changeset introduces a number of new methods on BP_XProfile_Field that
developers should use to manipulate member type information:
get_member_types(), set_member_types(), and the static
get_fields_for_member_type(). In addition to member types that have been
explicitly registered, 'null' is a pseudo-type representing users who do not
belong to a member type.

This changeset introduces a blacklist of illegal member type names. By default,
the blacklist includes 'any', 'null', and '_none'. Use the
'bp_member_type_illegal_names' filter to add names to the blacklist.

Props Offereins, boonebgorges, tanner m, imath.
See #5192.

Location:
trunk
Files:
2 added
10 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/bp-members/bp-members-functions.php

    r9977 r10022  
    25242524    $member_type = sanitize_key( $member_type );
    25252525
     2526    /**
     2527     * Filters the list of illegal member type names.
     2528     *
     2529     * - 'any' is a special pseudo-type, representing items unassociated with any member type.
     2530     * - 'null' is a special pseudo-type, representing users without any type.
     2531     * - '_none' is used internally to denote an item that should not apply to any member types.
     2532     *
     2533     * @since BuddyPress (2.4.0)
     2534     *
     2535     * @param array $illegal_names Array of illegal names.
     2536     */
     2537    $illegal_names = apply_filters( 'bp_member_type_illegal_names', array( 'any', 'null', '_none' ) );
     2538    if ( in_array( $member_type, $illegal_names, true ) ) {
     2539        return new WP_Error( 'bp_member_type_illegal_name', __( 'You may not register a member type with this name.', 'buddypress' ), $member_type );
     2540    }
     2541
    25262542    // Store the post type name as data in the object (not just as the array key).
    25272543    $r['name'] = $member_type;

  • trunk/src/bp-xprofile/admin/css/admin.css

    r9819 r10022  
    275275    margin-bottom: 0;
    276276}
     277
     278span.member-type-none-notice,
     279p.member-type-none-notice {
     280    color: #f00;
     281}
     282
     283.hide {
     284    display: none;
     285    visibility: hidden;
     286}

  • trunk/src/bp-xprofile/admin/js/admin.js

    r9819 r10022  
    9797}
    9898
     99/**
     100 * @summary Toggles "no member type" notice.
     101 *
     102 * @since BuddyPress (2.4.0)
     103 */
     104function toggle_no_member_type_notice() {
     105    var $member_type_checkboxes = jQuery( 'input.member-type-selector' );
     106
     107    // No checkboxes? Nothing to do.
     108    if ( ! $member_type_checkboxes.length ) {
     109        return;
     110    }
     111
     112    var has_checked = false;
     113    $member_type_checkboxes.each( function() {
     114        if ( jQuery( this ).is( ':checked' ) ) {
     115            has_checked = true;
     116            return false;
     117        }
     118    } );
     119
     120    if ( has_checked ) {
     121        jQuery( 'p.member-type-none-notice' ).addClass( 'hide' );
     122    } else {
     123        jQuery( 'p.member-type-none-notice' ).removeClass( 'hide' );
     124    }
     125}
     126
    99127var fixHelper = function(e, ui) {
    100128    ui.children().each(function() {
    … …  
    152180    // Set focus in Field Title, if we're on the right page
    153181    jQuery( '#bp-xprofile-add-field #title' ).focus();
     182
     183    // Set up the notice that shows when no member types are selected for a field.
     184    toggle_no_member_type_notice();
     185    jQuery( 'input.member-type-selector' ).on( 'change', function() {
     186        toggle_no_member_type_notice();
     187    } );
    154188
    155189    // Set up deleting options ajax

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

    r9974 r10022  
    362362                }
    363363
     364                // Set member types.
     365                if ( isset( $_POST['has-member-types'] ) ) {
     366                    $member_types = array();
     367                    if ( isset( $_POST['member-types'] ) ) {
     368                        $member_types = stripslashes_deep( $_POST['member-types'] );
     369                    }
     370
     371                    $field->set_member_types( $member_types );
     372                }
     373
    364374                // Validate default visibility
    365375                if ( ! empty( $_POST['default-visibility'] ) && in_array( $_POST['default-visibility'], wp_list_pluck( bp_xprofile_get_visibility_levels(), 'id' ) ) ) {
    … …  
    500510                <?php if ( bp_get_the_profile_field_is_required()                         ) : ?><?php esc_html_e( '(Required)', 'buddypress' ); endif; ?>
    501511                <?php if ( bp_xprofile_get_meta( $field->id, 'field', 'signup_position' ) ) : ?><?php esc_html_e( '(Sign-up)',  'buddypress' ); endif; ?>
     512                <?php if ( bp_get_member_types() ) : echo $field->get_member_type_label(); endif; ?>
    502513
    503514                <?php

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

    r9819 r10022  
    235235add_action( 'xprofile_fields_saved_field',   'xprofile_clear_profile_field_object_cache' );
    236236add_action( 'xprofile_fields_deleted_field', 'xprofile_clear_profile_field_object_cache' );
     237
     238/**
     239 * Clears member_type cache when a field's member types are updated.
     240 *
     241 * @since BuddyPress (2.4.0)
     242 */
     243function bp_xprofile_clear_member_type_cache() {
     244    wp_cache_delete( 'field_member_types', 'bp_xprofile' );
     245}
     246add_action( 'bp_xprofile_field_set_member_type', 'bp_xprofile_clear_member_type_cache' );
    237247
    238248/**

  • trunk/src/bp-xprofile/bp-xprofile-template.php

    r10015 r10022  
    111111
    112112    /**
    113      * Get activity items, as specified by parameters
     113     * Get activity items, as specified by parameters.
     114     *
     115     * @see BP_XProfile_Group::get() for more details about parameters.
     116     *
     117     * @since BuddyPress (2.4.0) Introduced `$member_type` argument.
    114118     *
    115119     * @param array $args {
    116120     *     An array of arguments. All items are optional.
    117121     *
    118      *     @type int       $user_id                 Fetch field data for this user ID
    119      *     @type int       $profile_group_id        Field group to fetch fields & data for
    120      *     @type int|bool  $hide_empty_groups       Should empty field groups be skipped
    121      *     @type int|bool  $fetch_fields            Fetch fields for field group
    122      *     @type int|bool  $fetch_field_data        Fetch field data for fields in group
    123      *     @type array     $exclude_groups          Exclude these field groups
    124      *     @type array     $exclude_fields          Exclude these fields
    125      *     @type int|bool  $hide_empty_fields       Should empty fields be skipped
    126      *     @type int|bool  $fetch_visibility_level  Fetch visibility levels
    127      *     @type int|bool  $update_meta_cache       Should metadata cache be updated
     122     *     @type int          $user_id                 Fetch field data for this user ID.
     123     *     @type string|array $member_type             Limit results to those matching member type(s).
     124     *     @type int          $profile_group_id        Field group to fetch fields & data for.
     125     *     @type int|bool     $hide_empty_groups       Should empty field groups be skipped.
     126     *     @type int|bool     $fetch_fields            Fetch fields for field group.
     127     *     @type int|bool     $fetch_field_data        Fetch field data for fields in group.
     128     *     @type array        $exclude_groups          Exclude these field groups.
     129     *     @type array        $exclude_fields          Exclude these fields.
     130     *     @type int|bool     $hide_empty_fields       Should empty fields be skipped.
     131     *     @type int|bool     $fetch_visibility_level  Fetch visibility levels.
     132     *     @type int|bool     $update_meta_cache       Should metadata cache be updated.
    128133     * }
    129134     */
    … …  
    154159            'profile_group_id'       => false,
    155160            'user_id'                => false,
     161            'member_type'            => 'any',
    156162            'hide_empty_groups'      => false,
    157163            'hide_empty_fields'      => false,
    … …  
    318324 *     Array of arguments. See BP_XProfile_Group::get() for full description. Those arguments whose defaults differ
    319325 *     from that method are described here:
    320  *     @type bool $hide_empty_groups      Default: true.
    321  *     @type bool $hide_empty_fields      Defaults to true on the Dashboard, on a user's Edit Profile page,
    322  *                                        or during registration. Otherwise false.
    323  *     @type bool $fetch_visibility_level Defaults to true when an admin is viewing a profile, or when a user is
    324  *                                        viewing her own profile, or during registration. Otherwise false.
    325  *     @type bool $fetch_fields           Default: true.
    326  *     @type bool $fetch_field_data       Default: true.
     326 *     @type string|array $member_type            Default: 'any'.
     327 *     @type bool         $hide_empty_groups      Default: true.
     328 *     @type bool         $hide_empty_fields      Defaults to true on the Dashboard, on a user's Edit Profile page,
     329 *                                                or during registration. Otherwise false.
     330 *     @type bool         $fetch_visibility_level Defaults to true when an admin is viewing a profile, or when a user is
     331 *                                                viewing her own profile, or during registration. Otherwise false.
     332 *     @type bool         $fetch_fields           Default: true.
     333 *     @type bool         $fetch_field_data       Default: true.
    327334 * }
    328335 *
    … …  
    346353    $r = bp_parse_args( $args, array(
    347354        'user_id'                => bp_displayed_user_id(),
     355        'member_type'            => 'any',
    348356        'profile_group_id'       => false,
    349357        'hide_empty_groups'      => true,

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

    r9986 r10022  
    123123     */
    124124    public $data;
     125
     126    /**
     127     * Member types to which the profile field should be applied.
     128     *
     129     * @since BuddyPress (2.4.0)
     130     * @access protected
     131     * @var array Array of member types.
     132     */
     133    protected $member_types;
    125134
    126135    /**
    … …  
    458467    }
    459468
     469    /**
     470     * Gets the member types to which this field should be available.
     471     *
     472     * Will not return inactive member types, even if associated metadata is found.
     473     *
     474     * 'null' is a special pseudo-type, which represents users that do not have a member type.
     475     *
     476     * @since BuddyPress (2.4.0)
     477     *
     478     * @return array Array of member type names.
     479     */
     480    public function get_member_types() {
     481        if ( ! is_null( $this->member_types ) ) {
     482            return $this->member_types;
     483        }
     484
     485        $raw_types = bp_xprofile_get_meta( $this->id, 'field', 'member_type', false );
     486
     487        // If `$raw_types` is not an array, it probably means this is a new field (id=0).
     488        if ( ! is_array( $raw_types ) ) {
     489            $raw_types = array();
     490        }
     491
     492        // If '_none' is found in the array, it overrides all types.
     493        $types = array();
     494        if ( ! in_array( '_none', $raw_types ) ) {
     495            $registered_types = bp_get_member_types();
     496
     497            // Eliminate invalid member types saved in the database.
     498            foreach ( $raw_types as $raw_type ) {
     499                // 'null' is a special case - it represents users without a type.
     500                if ( 'null' === $raw_type || isset( $registered_types[ $raw_type ] ) ) {
     501                    $types[] = $raw_type;
     502                }
     503            }
     504
     505            // If no member types have been saved, intepret as *all* member types.
     506            if ( empty( $types ) ) {
     507                $types = array_values( $registered_types );
     508
     509                // + the "null" type, ie users without a type.
     510                $types[] = 'null';
     511            }
     512        }
     513
     514        /**
     515         * Filters the member types to which an XProfile object should be applied.
     516         *
     517         * @since BuddyPress (2.4.0)
     518         *
     519         * @param array             $types Member types.
     520         * @param BP_XProfile_Field $field Field object.
     521         */
     522        $this->member_types = apply_filters( 'bp_xprofile_field_member_types', $types, $this );
     523
     524        return $this->member_types;
     525    }
     526
     527    /**
     528     * Sets the member types for this field.
     529     *
     530     * @since BuddyPress (2.4.0)
     531     *
     532     * @param array $member_types Array of member types. Can include 'null' (users with no type) in addition to any
     533     *                            registered types.
     534     * @param bool  $append       Whether to append to existing member types. If false, all existing member type
     535     *                            associations will be deleted before adding your `$member_types`. Default false.
     536     * @return array Member types for the current field, after being saved.
     537     */
     538    public function set_member_types( $member_types, $append = false ) {
     539        // Unset invalid member types.
     540        $types = array();
     541        foreach ( $member_types as $member_type ) {
     542            // 'null' is a special case - it represents users without a type.
     543            if ( 'null' === $member_type || bp_get_member_type_object( $member_type ) ) {
     544                $types[] = $member_type;
     545            }
     546        }
     547
     548        // When `$append` is false, delete all existing types before adding new ones.
     549        if ( ! $append ) {
     550            bp_xprofile_delete_meta( $this->id, 'field', 'member_type' );
     551
     552            /*
     553             * We interpret an empty array as disassociating the field from all types. This is
     554             * represented internally with the '_none' flag.
     555             */
     556            if ( empty( $types ) ) {
     557                bp_xprofile_add_meta( $this->id, 'field', 'member_type', '_none' );
     558            }
     559        }
     560
     561        /*
     562         * Unrestricted fields are represented in the database as having no 'member_type'.
     563         * We detect whether a field is being set to unrestricted by checking whether the
     564         * list of types passed to the method is the same as the list of registered types,
     565         * plus the 'null' pseudo-type.
     566         */
     567        $_rtypes  = bp_get_member_types();
     568        $rtypes   = array_values( $_rtypes );
     569        $rtypes[] = 'null';
     570
     571        sort( $types );
     572        sort( $rtypes );
     573
     574        // Only save if this is a restricted field.
     575        if ( $types !== $rtypes ) {
     576            // Save new types.
     577            foreach ( $types as $type ) {
     578                bp_xprofile_add_meta( $this->id, 'field', 'member_type', $type );
     579            }
     580        }
     581
     582        // Reset internal cache of member types.
     583        $this->member_types = null;
     584
     585        /**
     586         * Fires after a field's member types have been updated.
     587         *
     588         * @since BuddyPress (2.4.0)
     589         *
     590         * @param BP_XProfile_Field $field Field object.
     591         */
     592        do_action( 'bp_xprofile_field_set_member_type', $this );
     593
     594        // Refetch fresh items from the database.
     595        return $this->get_member_types();
     596    }
     597
     598    /**
     599     * Gets a label representing the field's member types.
     600     *
     601     * This label is displayed alongside the field's name on the Profile Fields Dashboard panel.
     602     *
     603     * @since BuddyPress (2.4.0)
     604     *
     605     * @return string
     606     */
     607    public function get_member_type_label() {
     608        // Field 1 is always displayed to everyone, so never gets a label.
     609        if ( 1 == $this->id ) {
     610            return '';
     611        }
     612
     613        // Return an empty string if no member types are registered.
     614        $all_types = bp_get_member_types();
     615        if ( empty( $all_types ) ) {
     616            return '';
     617        }
     618
     619        $member_types = $this->get_member_types();
     620
     621        // If the field applies to all member types, show no message.
     622        $all_types[] = 'null';
     623        if ( array_values( $all_types ) == $member_types ) {
     624            return '';
     625        }
     626
     627        $label = '';
     628        if ( ! empty( $member_types ) ) {
     629            $has_null = false;
     630            $member_type_labels = array();
     631            foreach ( $member_types as $member_type ) {
     632                if ( 'null' === $member_type ) {
     633                    $has_null = true;
     634                    continue;
     635                } else {
     636                    $mt_obj = bp_get_member_type_object( $member_type );
     637                    $member_type_labels[] = $mt_obj->labels['name'];
     638                }
     639            }
     640
     641            // Alphabetical sort.
     642            natcasesort( $member_type_labels );
     643            $member_type_labels = array_values( $member_type_labels );
     644
     645            // Add the 'null' option to the end of the list.
     646            if ( $has_null ) {
     647                $member_type_labels[] = __( 'Users with no member type', 'buddypress' );
     648            }
     649
     650            $label = sprintf( __( '(Member types: %s)', 'buddypress' ), implode( ', ', array_map( 'esc_html', $member_type_labels ) ) );
     651        } else {
     652            $label = '<span class="member-type-none-notice">' . __( '(Unavailable to all members)', 'buddypress' ) . '</span>';
     653        }
     654
     655        return $label;
     656    }
     657
    460658    /** Static Methods ********************************************************/
    461659
    … …  
    572770
    573771        return false;
     772    }
     773
     774    /**
     775     * Gets the IDs of fields applicable for a given member type or array of member types.
     776     *
     777     * @since BuddyPress (2.4.0)
     778     *
     779     * @param string|array $member_types Member type or array of member types. Use 'any' to return unrestricted
     780     *                                   fields (those available for anyone, regardless of member type).
     781     * @return array Multi-dimensional array, with field IDs as top-level keys, and arrays of member types
     782     *               associated with each field as values.
     783     */
     784    public static function get_fields_for_member_type( $member_types ) {
     785        global $wpdb;
     786
     787        $fields = array();
     788
     789        if ( empty( $member_types ) ) {
     790            $member_types = array( 'any' );
     791        } elseif ( ! is_array( $member_types ) ) {
     792            $member_types = array( $member_types );
     793        }
     794
     795        $bp = buddypress();
     796
     797        // Pull up all recorded field member type data.
     798        $mt_meta = wp_cache_get( 'field_member_types', 'bp_xprofile' );
     799        if ( false === $mt_meta ) {
     800            $mt_meta = $wpdb->get_results( "SELECT object_id, meta_value FROM {$bp->profile->table_name_meta} WHERE meta_key = 'member_type' AND object_type = 'field'" );
     801            wp_cache_set( 'field_member_types', $mt_meta, 'bp_xprofile' );
     802        }
     803
     804        // Keep track of all fields with recorded member_type metadata.
     805        $all_recorded_field_ids = wp_list_pluck( $mt_meta, 'object_id' );
     806
     807        // Sort member_type matches in arrays, keyed by field_id.
     808        foreach ( $mt_meta as $_mt_meta ) {
     809            if ( ! isset( $fields[ $_mt_meta->object_id ] ) ) {
     810                $fields[ $_mt_meta->object_id ] = array();
     811            }
     812
     813            $fields[ $_mt_meta->object_id ][] = $_mt_meta->meta_value;
     814        }
     815
     816        /*
     817         * Filter out fields that don't match any passed types, or those marked '_none'.
     818         * The 'any' type is implicitly handled here: it will match no types.
     819         */
     820        foreach ( $fields as $field_id => $field_types ) {
     821            if ( ! array_intersect( $field_types, $member_types ) ) {
     822                unset( $fields[ $field_id ] );
     823            }
     824        }
     825
     826        // Any fields with no member_type metadata are available to all member types.
     827        if ( ! in_array( '_none', $member_types ) ) {
     828            if ( ! empty( $all_recorded_field_ids ) ) {
     829                $all_recorded_field_ids_sql = implode( ',', array_map( 'absint', $all_recorded_field_ids ) );
     830                $unrestricted_field_ids = $wpdb->get_col( "SELECT id FROM {$bp->profile->table_name_fields} WHERE id NOT IN ({$all_recorded_field_ids_sql})" );
     831            } else {
     832                $unrestricted_field_ids = $wpdb->get_col( "SELECT id FROM {$bp->profile->table_name_fields}" );
     833            }
     834
     835            // Append the 'null' pseudo-type.
     836            $all_member_types   = bp_get_member_types();
     837            $all_member_types   = array_values( $all_member_types );
     838            $all_member_types[] = 'null';
     839
     840            foreach ( $unrestricted_field_ids as $unrestricted_field_id ) {
     841                $fields[ $unrestricted_field_id ] = $all_member_types;
     842            }
     843        }
     844
     845        return $fields;
    574846    }
    575847
    … …  
    718990                            // Output the required metabox
    719991                            $this->required_metabox();
     992
     993                            // Output the Member Types metabox.
     994                            $this->member_type_metabox();
    720995
    721996                            // Output the field visibility metaboxes
    … …  
    8621137
    8631138    <?php
     1139    }
     1140
     1141    /**
     1142     * Private method used to output field Member Type metabox.
     1143     *
     1144     * @since BuddyPress (2.4.0)
     1145     */
     1146    private function member_type_metabox() {
     1147
     1148        // The primary field is for all, so bail.
     1149        if ( 1 === (int) $this->id ) {
     1150            return;
     1151        }
     1152
     1153        // Bail when no member types are registered.
     1154        if ( ! $member_types = bp_get_member_types( array(), 'objects' ) ) {
     1155            return;
     1156        }
     1157
     1158        $field_member_types = $this->get_member_types();
     1159
     1160        ?>
     1161
     1162        <div id="member-types-div" class="postbox">
     1163            <h3><?php _e( 'Member Types', 'buddypress' ); ?></h3>
     1164            <div class="inside">
     1165                <p class="description"><?php _e( 'This field should be available to:', 'buddypress' ); ?></p>
     1166
     1167                <ul>
     1168                    <?php foreach ( $member_types as $member_type ) : ?>
     1169                    <li>
     1170                        <label>
     1171                            <input name="member-types[]" class="member-type-selector" type="checkbox" value="<?php echo $member_type->name; ?>" <?php checked( in_array( $member_type->name, $field_member_types ) ); ?>/>
     1172                            <?php echo $member_type->labels['name']; ?>
     1173                        </label>
     1174                    </li>
     1175                    <?php endforeach; ?>
     1176
     1177                    <li>
     1178                        <label>
     1179                            <input name="member-types[]" class="member-type-selector" type="checkbox" value="null" <?php checked( in_array( 'null', $field_member_types ) ); ?>/>
     1180                            <?php _e( 'Users with no member type', 'buddypress' ); ?>
     1181                        </label>
     1182                    </li>
     1183
     1184                </ul>
     1185                <p class="description member-type-none-notice<?php if ( ! empty( $field_member_types ) ) : ?> hide<?php endif; ?>"><?php _e( 'Unavailable to all members.', 'buddypress' ) ?></p>
     1186            </div>
     1187
     1188            <input type="hidden" name="has-member-types" value="1" />
     1189        </div>
     1190
     1191        <?php
    8641192    }
    8651193

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

    r10009 r10022  
    233233     *      @type int   $user_id           Required if you want to load a specific user's data.
    234234     *                                     Default: displayed user's ID.
     235     *      @type array|string $member_type Limit fields by those restricted to a given member type, or array of
     236     *                                      member types. If `$user_id` is provided, the value of `$member_type`
     237     *                                      will be overridden by the member types of the provided user. The
     238     *                                      special value of 'any' will return only those fields that are
     239     *                                      unrestricted by member type - i.e., those applicable to any type.
    235240     *      @type bool  $hide_empty_groups True to hide groups that don't have any fields. Default: false.
    236241     *  @type bool  $hide_empty_fields True to hide fields where the user has not provided data. Default: false.
    … …  
    252257            'profile_group_id'       => false,
    253258            'user_id'                => bp_displayed_user_id(),
     259            'member_type'            => false,
    254260            'hide_empty_groups'      => false,
    255261            'hide_empty_fields'      => false,
    … …  
    319325        $exclude_fields_cs  = implode( ',', $exclude_fields_cs );
    320326
    321         // Setup IN query for field IDs
     327        // Set up NOT IN query for excluded field IDs.
    322328        if ( ! empty( $exclude_fields_cs ) ) {
    323329            $exclude_fields_sql = "AND id NOT IN ({$exclude_fields_cs})";
    … …  
    326332        }
    327333
     334        // Set up IN query for included field IDs.
     335        $include_field_ids = array();
     336
     337        // Member-type restrictions.
     338        if ( bp_get_member_types() ) {
     339            if ( $r['user_id'] || false !== $r['member_type'] ) {
     340                $member_types = $r['member_type'];
     341                if ( $r['user_id'] ) {
     342                    $member_types = bp_get_member_type( $r['user_id'], false );
     343                    if ( empty( $member_types ) ) {
     344                        $member_types = array( 'null' );
     345                    }
     346                }
     347
     348                $member_types_fields = BP_XProfile_Field::get_fields_for_member_type( $member_types );
     349                $include_field_ids += array_keys( $member_types_fields );
     350            }
     351        }
     352
     353        $in_sql = '';
     354        if ( ! empty( $include_field_ids ) ) {
     355            $include_field_ids_cs = implode( ',', array_map( 'intval', $include_field_ids ) );
     356            $in_sql = " AND id IN ({$include_field_ids_cs}) ";
     357        }
     358
    328359        // Fetch the fields
    329         $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" );
     360        $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} {$in_sql} ORDER BY field_order" );
     361
    330362        $field_ids = wp_list_pluck( $fields, 'id' );
    331363

  • trunk/tests/phpunit/testcases/members/types.php

    r9819 r10022  
    2222
    2323    /**
     24     * @dataProvider illegal_names
     25     * @ticket BP5192
     26     */
     27    public function test_illegal_names( $name ) {
     28        $this->assertWPError( bp_register_member_type( $name ) );
     29    }
     30
     31    public function illegal_names() {
     32        return array(
     33            array( 'any' ),
     34            array( 'null' ),
     35            array( '_none' ),
     36        );
     37    }
     38
     39    /**
    2440     * @ticket BP6139
    2541     */

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

    r10004 r10022  
    114114
    115115    /**
     116     * @group member_types
     117     * @ticket BP5192
     118     */
     119    public function test_member_type_restrictions_should_be_ignored_when_user_id_is_null_and_member_type_is_not_explicitly_provided() {
     120        $g = $this->factory->xprofile_group->create();
     121        $f = $this->factory->xprofile_field->create( array( 'field_group_id' => $g ) );
     122        bp_register_member_type( 'foo' );
     123
     124        $field = new BP_XProfile_Field( $f );
     125        $field->set_member_types( array( 'foo' ) );
     126
     127        $found_groups = BP_XProfile_Group::get( array(
     128            'user_id' => false,
     129            'fetch_fields' => true,
     130        ) );
     131
     132        // The groups aren't indexed, so we have to go looking for it.
     133        foreach ( $found_groups as $fg ) {
     134            if ( $g == $fg->id ) {
     135                $the_group = $fg;
     136            }
     137        }
     138
     139        $this->assertContains( $f, wp_list_pluck( $the_group->fields, 'id' ) );
     140    }
     141
     142    /**
     143     * @group member_types
     144     * @ticket BP5192
     145     */
     146    public function test_member_type_restrictions_should_be_ignored_when_user_id_is_0_and_member_type_is_false() {
     147        $g = $this->factory->xprofile_group->create();
     148        $f = $this->factory->xprofile_field->create( array( 'field_group_id' => $g ) );
     149        bp_register_member_type( 'foo' );
     150
     151        $field = new BP_XProfile_Field( $f );
     152        $field->set_member_types( array( 'foo' ) );
     153
     154        $found_groups = BP_XProfile_Group::get( array(
     155            'user_id' => 0,
     156            'member_type' => false,
     157            'fetch_fields' => true,
     158        ) );
     159
     160        // The groups aren't indexed, so we have to go looking for it.
     161        foreach ( $found_groups as $fg ) {
     162            if ( $g == $fg->id ) {
     163                $the_group = $fg;
     164            }
     165        }
     166
     167        $this->assertContains( $f, wp_list_pluck( $the_group->fields, 'id' ) );
     168    }
     169
     170    /**
     171     * @group member_types
     172     * @ticket BP5192
     173     */
     174    public function test_member_type_restrictions_should_be_obeyed_for_nonzero_user_id() {
     175        $g = $this->factory->xprofile_group->create();
     176        $f1 = $this->factory->xprofile_field->create( array( 'field_group_id' => $g ) );
     177        $f2 = $this->factory->xprofile_field->create( array( 'field_group_id' => $g ) );
     178        $f3 = $this->factory->xprofile_field->create( array( 'field_group_id' => $g ) );
     179        $f4 = $this->factory->xprofile_field->create( array( 'field_group_id' => $g ) );
     180        bp_register_member_type( 'foo' );
     181        bp_register_member_type( 'bar' );
     182
     183        // Field 1 is visible only to 'foo' users.
     184        $field1 = new BP_XProfile_Field( $f1 );
     185        $field1->set_member_types( array( 'foo' ) );
     186
     187        // Field 2 is visible only to 'bar' users.
     188        $field2 = new BP_XProfile_Field( $f2 );
     189        $field2->set_member_types( array( 'bar' ) );
     190
     191        // Field 3 is visible to all users (no member type set).
     192
     193        // Field 4 is visible to no one.
     194        $field4 = new BP_XProfile_Field( $f4 );
     195        $field4->set_member_types( array() );
     196
     197        // User is in 'foo', so should have f1 and f3 only.
     198        $u = $this->factory->user->create();
     199        bp_set_member_type( $u, 'foo' );
     200
     201        $found_groups = BP_XProfile_Group::get( array(
     202            'user_id' => $u,
     203            'fetch_fields' => true,
     204        ) );
     205
     206        // The groups aren't indexed, so we have to go looking for it.
     207        foreach ( $found_groups as $fg ) {
     208            if ( $g == $fg->id ) {
     209                $the_group = $fg;
     210            }
     211        }
     212
     213        $this->assertContains( $f1, wp_list_pluck( $the_group->fields, 'id' ) );
     214        $this->assertContains( $f3, wp_list_pluck( $the_group->fields, 'id' ) );
     215        $this->assertNotContains( $f2, wp_list_pluck( $the_group->fields, 'id' ) );
     216        $this->assertNotContains( $f4, wp_list_pluck( $the_group->fields, 'id' ) );
     217    }
     218
     219    /**
     220     * @group member_types
     221     * @ticket BP5192
     222     */
     223    public function test_member_type_restrictions_should_be_obeyed_for_nonzero_user_id_with_no_member_types() {
     224        $g = $this->factory->xprofile_group->create();
     225        $f1 = $this->factory->xprofile_field->create( array( 'field_group_id' => $g ) );
     226        $f2 = $this->factory->xprofile_field->create( array( 'field_group_id' => $g ) );
     227        $f3 = $this->factory->xprofile_field->create( array( 'field_group_id' => $g ) );
     228        bp_register_member_type( 'foo' );
     229        bp_register_member_type( 'bar' );
     230
     231        // Field 1 is visible only to 'foo' users.
     232        $field1 = new BP_XProfile_Field( $f1 );
     233        $field1->set_member_types( array( 'foo' ) );
     234
     235        // Field 2 is visible only to 'null' users.
     236        $field2 = new BP_XProfile_Field( $f2 );
     237        $field2->set_member_types( array( 'null' ) );
     238
     239        // Field 3 is visible to all users (no member type set).
     240
     241        // User has no member types, so should see f2 and f3 .
     242        $u = $this->factory->user->create();
     243
     244        $found_groups = BP_XProfile_Group::get( array(
     245            'user_id' => $u,
     246            'fetch_fields' => true,
     247        ) );
     248
     249        // The groups aren't indexed, so we have to go looking for it.
     250        foreach ( $found_groups as $fg ) {
     251            if ( $g == $fg->id ) {
     252                $the_group = $fg;
     253            }
     254        }
     255
     256        $this->assertNotContains( $f1, wp_list_pluck( $the_group->fields, 'id' ) );
     257        $this->assertContains( $f2, wp_list_pluck( $the_group->fields, 'id' ) );
     258        $this->assertContains( $f3, wp_list_pluck( $the_group->fields, 'id' ) );
     259    }
     260
     261    /**
     262     * @group member_types
     263     * @ticket BP5192
     264     */
     265    public function test_member_types_of_provided_user_id_should_take_precedence_over_provided_member_type() {
     266        $g = $this->factory->xprofile_group->create();
     267        $f1 = $this->factory->xprofile_field->create( array( 'field_group_id' => $g ) );
     268        $f2 = $this->factory->xprofile_field->create( array( 'field_group_id' => $g ) );
     269        bp_register_member_type( 'foo' );
     270        bp_register_member_type( 'bar' );
     271
     272        $field1 = new BP_XProfile_Field( $f1 );
     273        $field1->set_member_types( array( 'foo' ) );
     274        $field2 = new BP_XProfile_Field( $f2 );
     275        $field2->set_member_types( array( 'bar' ) );
     276
     277        $u = $this->factory->user->create();
     278        bp_set_member_type( $u, 'foo' );
     279
     280        $found_groups = BP_XProfile_Group::get( array(
     281            'user_id' => $u,
     282            'member_type' => 'bar',
     283            'fetch_fields' => true,
     284        ) );
     285
     286        // The groups aren't indexed, so we have to go looking for it.
     287        foreach ( $found_groups as $fg ) {
     288            if ( $g == $fg->id ) {
     289                $the_group = $fg;
     290            }
     291        }
     292
     293        $this->assertContains( $f1, wp_list_pluck( $the_group->fields, 'id' ) );
     294    }
     295
     296    /**
     297     * @group member_types
     298     * @ticket BP5192
     299     */
     300    public function test_member_type_single_value_should_be_respected() {
     301        $g = $this->factory->xprofile_group->create();
     302        $f1 = $this->factory->xprofile_field->create( array( 'field_group_id' => $g ) );
     303        $f2 = $this->factory->xprofile_field->create( array( 'field_group_id' => $g ) );
     304        bp_register_member_type( 'foo' );
     305        bp_register_member_type( 'bar' );
     306
     307        $field1 = new BP_XProfile_Field( $f1 );
     308        $field1->set_member_types( array( 'foo' ) );
     309        $field2 = new BP_XProfile_Field( $f2 );
     310        $field2->set_member_types( array( 'bar' ) );
     311
     312        $found_groups = BP_XProfile_Group::get( array(
     313            'member_type' => 'bar',
     314            'fetch_fields' => true,
     315        ) );
     316
     317        // The groups aren't indexed, so we have to go looking for it.
     318        foreach ( $found_groups as $fg ) {
     319            if ( $g == $fg->id ) {
     320                $the_group = $fg;
     321            }
     322        }
     323
     324        $this->assertNotContains( $f1, wp_list_pluck( $the_group->fields, 'id' ) );
     325        $this->assertContains( $f2, wp_list_pluck( $the_group->fields, 'id' ) );
     326    }
     327
     328    /**
     329     * @group member_types
     330     * @ticket BP5192
     331     */
     332    public function test_member_type_array_value_should_be_respected() {
     333        $g = $this->factory->xprofile_group->create();
     334        $f1 = $this->factory->xprofile_field->create( array( 'field_group_id' => $g ) );
     335        $f2 = $this->factory->xprofile_field->create( array( 'field_group_id' => $g ) );
     336        bp_register_member_type( 'foo' );
     337        bp_register_member_type( 'bar' );
     338
     339        $field1 = new BP_XProfile_Field( $f1 );
     340        $field1->set_member_types( array( 'foo' ) );
     341        $field2 = new BP_XProfile_Field( $f2 );
     342        $field2->set_member_types( array( 'bar' ) );
     343
     344        $found_groups = BP_XProfile_Group::get( array(
     345            'member_type' => array( 'bar' ),
     346            'fetch_fields' => true,
     347        ) );
     348
     349        // The groups aren't indexed, so we have to go looking for it.
     350        foreach ( $found_groups as $fg ) {
     351            if ( $g == $fg->id ) {
     352                $the_group = $fg;
     353            }
     354        }
     355
     356        $this->assertNotContains( $f1, wp_list_pluck( $the_group->fields, 'id' ) );
     357        $this->assertContains( $f2, wp_list_pluck( $the_group->fields, 'id' ) );
     358    }
     359
     360    /**
     361     * @group member_types
     362     * @ticket BP5192
     363     */
     364    public function test_member_type_null_should_be_respected() {
     365        $g = $this->factory->xprofile_group->create();
     366        $f1 = $this->factory->xprofile_field->create( array( 'field_group_id' => $g ) );
     367        $f2 = $this->factory->xprofile_field->create( array( 'field_group_id' => $g ) );
     368        bp_register_member_type( 'foo' );
     369        bp_register_member_type( 'bar' );
     370
     371        $field1 = new BP_XProfile_Field( $f1 );
     372        $field1->set_member_types( array( 'foo' ) );
     373
     374        $found_groups = BP_XProfile_Group::get( array(
     375            'member_type' => array( 'null' ),
     376            'fetch_fields' => true,
     377        ) );
     378
     379        // The groups aren't indexed, so we have to go looking for it.
     380        foreach ( $found_groups as $fg ) {
     381            if ( $g == $fg->id ) {
     382                $the_group = $fg;
     383            }
     384        }
     385
     386        $this->assertNotContains( $f1, wp_list_pluck( $the_group->fields, 'id' ) );
     387        $this->assertContains( $f2, wp_list_pluck( $the_group->fields, 'id' ) );
     388    }
     389
     390    /**
    116391     * @group save_xprofile_group_name
    117392     */
Note: See TracChangeset for help on using the changeset viewer.