Ticket #4017: 4017.04.diff

src/bp-core/bp-core-taxonomy.php

@@ -24 +24 @@
         register_taxonomy( 'bp_member_type', 'user', array(
                 'public' => false,
         ) );
+
+        // Group Type.
+        register_taxonomy( 'bp_group_type', 'bp_group', array(
+                'public' => false,
+        ) );
 }
 add_action( 'bp_register_taxonomies', 'bp_register_default_taxonomies' );
 

src/bp-groups/bp-groups-cache.php

@@ -206 +206 @@
 }
 add_action( 'groups_member_after_save', 'groups_clear_group_administrator_cache_on_member_save' );
 
+/**
+ * Clear the group type cache for group.
+ *
+ * Called when group is deleted.
+ *
+ * @since 2.5.0
+ *
+ * @param int $group_id The group ID.
+ */
+function groups_clear_group_type_cache( $group_id = 0 ) {
+        wp_cache_delete( $group_id, 'bp_groups_group_type' );
+}
+add_action( 'groups_delete_group', 'groups_clear_group_type_cache' );
+
 /* List actions to clear super cached pages on, if super cache is installed */
 add_action( 'groups_join_group',                 'bp_core_clear_cache' );
 add_action( 'groups_leave_group',                'bp_core_clear_cache' );

src/bp-groups/bp-groups-functions.php

@@ -1747 +1747 @@
 add_action( 'wpmu_delete_user',  'groups_remove_data_for_user' );
 add_action( 'delete_user',       'groups_remove_data_for_user' );
 add_action( 'bp_make_spam_user', 'groups_remove_data_for_user' );
+
+/** Member Types *************************************************************/
+
+/**
+ * Register a group type.
+ *
+ * @since 2.5.0
+ *
+ * @param string $group_type Unique string identifier for the group type.
+ * @param array  $args {
+ *     Array of arguments describing the group type.
+ *
+ *     @type array       $labels {
+ *         Array of labels to use in various parts of the interface.
+ *
+ *         @type string $name          Default name. Should typically be plural.
+ *         @type string $singular_name Singular name.
+ *     }
+ *     @type bool|string $has_directory Whether the group type should have its own type-specific directory.
+ *                                      Pass `true` to use the `$group_type` string as the type's slug.
+ *                                      Pass a string to customize the slug. Pass `false` to disable.
+ *                                      Default: true.
+ * }
+ * @return object|WP_Error Group type object on success, WP_Error object on failure.
+ */
+function groups_register_type( $group_type, $args = array() ) {
+        $bp = buddypress();
+
+        if ( isset( $bp->groups->types[ $group_type ] ) ) {
+                return new WP_Error( 'bp_group_type_exists', __( 'Group type already exists.', 'buddypress' ), $group_type );
+        }
+
+        $r = bp_parse_args( $args, array(
+                'labels'        => array(),
+                'has_directory' => true,
+        ), 'register_group_type' );
+
+        $group_type = sanitize_key( $group_type );
+
+        // Store the group type name as data in the object (not just as the array key).
+        $r['name'] = $group_type;
+
+        // Make sure the relevant labels have been filled in.
+        $default_name = isset( $r['labels']['name'] ) ? $r['labels']['name'] : ucfirst( $r['name'] );
+        $r['labels'] = array_merge( array(
+                'name'          => $default_name,
+                'singular_name' => $default_name,
+        ), $r['labels'] );
+
+        if ( $r['has_directory'] ) {
+                if ( is_string( $r['has_directory'] ) ) {
+                        $directory_slug = $r['has_directory'];
+                } else {
+                        $directory_slug = $group_type;
+                }
+
+                // Sanitize for use in URls.
+                $r['directory_slug'] = sanitize_title( $directory_slug );
+                $r['has_directory']  = true;
+        } else {
+                $r['directory_slug'] = '';
+                $r['has_directory']  = false;
+        }
+
+        $bp->groups->types[ $group_type ] = $type = (object) $r;
+
+        /**
+         * Fires after a group type is registered.
+         *
+         * @since 2.5.0
+         *
+         * @param  string $group_type Group type indentifier.
+         * @param  object $$type      Group type object.
+         */
+        do_action( 'groups_registered_type', $group_type, $type );
+
+        return $type;
+}
+
+/**
+ * Get a list of all registered group type objects.
+ *
+ * @since 2.5.0
+ *
+ * @see groups_register_type() for accepted arguments.
+ * 
+ * @param array|string $args     Optional. An array of key => value arguments to match against
+ *                               the group type objects. Default empty array.
+ * @param string       $output   Optional. The type of output to return. Accepts 'names'
+ *                               or 'objects'. Default 'names'.
+ * @param string       $operator Optional. The logical operation to perform. 'or' means only one
+ *                               element from the array needs to match; 'and' means all elements
+ *                               must match. Accepts 'or' or 'and'. Default 'and'.
+ * @return array       $types    A list of groups type names or objects.
+ */
+function groups_get_types( $args = array(), $output = 'names', $operator = 'and' ) {
+        $types = buddypress()->groups->types;
+
+        $type = wp_filter_object_list( $types, $args, $operator );
+
+        /**
+         * Filters the array of group type objects.
+         *
+         * This filter is run before the $output filter has been applied, so that
+         * filtering functions have access to the entire group type objects.
+         *
+         * @since 2.5.0
+         *
+         * @param array  $types     group type objects, keyed by name.
+         * @param array  $args      Array of key=>value arguments for filtering.
+         * @param string $operator  'or' to match any of $args, 'and' to require all.
+         */
+        $types = apply_filters( 'groups_get_types', $types, $args, $operator );
+
+        if ( 'names' === $output ) {
+                $types = wp_list_pluck( $types, 'name' );
+        }
+
+        return $types;
+}
+
+/**
+ * Retrieve a group type object by name.
+ *
+ * @since 2.5.0
+ *
+ * @param string $group_type The name of the group type.
+ * @return object A group type object.
+ */
+function groups_get_type_object( $group_type ) {
+        $types = groups_get_types( array(), 'objects' );
+
+        if ( empty( $types[ $group_type ] ) ) {
+                return null;
+        }
+
+        return $types[ $group_type ];
+}
+
+/**
+ * Checks whether group type(s) exist.
+ * 
+ * @param  string|array $group_types The name(s) of group type(s).
+ * @return bool|array   $types       Array of group types on success, false on failure.
+ */
+function groups_type_exists( $group_types ) {
+        if ( empty( $group_types ) ) {
+                return false;
+        }
+
+        if ( ! is_array( $group_types ) ) {
+                $group_types = array( $group_types );
+        }
+
+        $types = array();
+        foreach ( $group_types as $group_type ) {
+                // Skip, if type isn't registered.
+                if ( ! groups_get_type_object( $group_type ) ) {
+                        continue;
+                }
+
+                $types[] = $group_type;
+        }
+
+        if ( empty( $types ) ) {
+                return false;
+        }
+
+        return $types;
+}
+
+/**
+ * Set type for a group.
+ *
+ * @since 2.5.0
+ *
+ * @param int          $group       ID of the group.
+ * @param string|array $group_types Group type(s).
+ * @param bool         $append      Optional. True to append this to existing types for group,
+ *                            false to replace. Default: false.
+ * @return array $retval See {@see bp_set_object_terms()}.
+ */
+function groups_set_type( $group_id, $group_types, $append = false ) {
+        $types = groups_type_exists( $group_types );
+
+        if ( ! empty( $group_types ) && ! $types ) {
+                return false;
+        }
+
+        $retval = bp_set_object_terms( $group_id, $types, 'bp_group_type', $append );
+
+        // Bust the cache if the type has been updated.
+        if ( ! is_wp_error( $retval ) ) {
+                wp_cache_delete( $group_id, 'bp_groups_group_type' );
+
+                /**
+                 * Fires just after a group type has been changed.
+                 *
+                 * @since 2.2.0
+                 *
+                 * @param int          $group_id    ID of the group whose group type has been updated.
+                 * @param string|array $group_types Group type(s).
+                 * @param bool         $append      Whether the type is being appended to existing types.
+                 */
+                do_action( 'groups_set_type', $group_id, $group_types, $append );
+        }
+
+        return $retval;
+}
+
+/**
+ * Get type for a group.
+ *
+ * @since 2.5.0
+ *
+ * @param int  $group_id ID of the group.
+ * @param bool $single  Optional. Whether to return a single type string. If multiple types are found
+ *                      for the group, the oldest one will be returned. Default: true.
+ * @return string|array|bool On success, returns a single group type (if $single is true) or an array of group
+ *                           types (if $single is false). Returns false on failure.
+ */
+function groups_get_type( $group_id, $single = true ) {
+        $types = wp_cache_get( $group_id, 'bp_groups_group_type' );
+
+        if ( false === $types ) {
+                $types = bp_get_object_terms( $group_id, 'bp_group_type' );
+
+                if ( ! is_wp_error( $types ) ) {
+                        $types = wp_list_pluck( $types, 'name' );
+                        wp_cache_set( $group_id, $types, 'bp_groups_group_type' );
+                }
+        }
+
+        $type = false;
+        if ( ! empty( $types ) ) {
+                if ( $single ) {
+                        $type = end( $types );
+                } else {
+                        $type = $types;
+                }
+        }
+
+        /**
+         * Filter's a groups's group type(s).
+         *
+         * @since 2.5.0
+         *
+         * @param string $type     Group type.
+         * @param int    $group_id ID of the group.
+         * @param bool   $single   Whether to return a single type srting, or an array.
+         */
+        return apply_filters( 'groups_get_type', $type, $group_id, $single );
+}
+
+/**
+ * Remove type for a group.
+ *
+ * @since 2.5.0
+ *
+ * @param int          $group       ID of the user.
+ * @param string|array $group_types Group type(s).
+ * @return bool|WP_Error            True on success. False or WP_Error on failure.
+ */
+function groups_remove_type( $group_id, $group_types ) {
+        if ( ! $types = groups_type_exists( $group_types ) ) {
+                return false;
+        }
+
+        $deleted = bp_remove_object_terms( $group_id, $types, 'bp_group_type' );
+
+        // Bust the case, if the type has been removed.
+        if ( ! is_wp_error( $deleted ) ) {
+                wp_cache_delete( $group_id, 'bp_groups_group_type' );
+
+                /**
+                 * Fire just after a group's group type has been removed.
+                 *
+                 * @since 2.5.0
+                 *
+                 * @param int          $group       ID of the group whose group type has been removed.
+                 * @param string|array $group_types Group type(s).
+                 */
+                do_action( 'groups_remove_type', $group_id, $group_types );
+        }
+
+        return $deleted;
+}
+
+/**
+ * Check whether the given group has a certain group type.
+ * 
+ * @param  int    $group_id   ID of the group.
+ * @param  srting $group_type Group type.
+ * @return bool   Whether the group has the give group type.
+ */
+function groups_has_type( $group_id, $group_type ) {
+        if ( empty( $group_type ) || ! groups_get_type_object( $group_type ) ) {
+                return false;
+        }
+
+        // Get all group's group types.
+        $types = groups_get_type( $group_id, false );
+
+        if ( ! is_array( $types ) ) {
+                return false;
+        }
+
+        return in_array( $group_type, $types );
+}
+
+/**
+ * Delete a group's type when the group is deleted.
+ * 
+ * @param  int   $group_id ID of the group.
+ * @return array $value    See {@see group_set_type()}.
+ */
+function groups_remove_type_on_group_delete( $group_id = 0 ) {
+        groups_set_type( $group_id, '' );
+}
+add_action( 'groups_delete_group', 'groups_remove_type_on_group_delete' );
+ No newline at end of file

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

@@ -643 +643 @@
          *
          * @param array $args {
          *     Array of parameters. All items are optional.
-         *     @type string       $type              Optional. Shorthand for certain orderby/
-         *                                           order combinations. 'newest', 'active', 'popular',
-         *                                           'alphabetical', 'random'. When present, will override
-         *                                           orderby and order params. Default: null.
-         *     @type string       $orderby           Optional. Property to sort by.
-         *                                           'date_created', 'last_activity', 'total_member_count',
-         *                                           'name', 'random'. Default: 'date_created'.
-         *     @type string       $order             Optional. Sort order. 'ASC' or 'DESC'.
-         *                                           Default: 'DESC'.
-         *     @type int          $per_page          Optional. Number of items to return per page
-         *                                           of results. Default: null (no limit).
-         *     @type int          $page              Optional. Page offset of results to return.
-         *                                           Default: null (no limit).
-         *     @type int          $user_id           Optional. If provided, results will be limited to groups
-         *                                           of which the specified user is a member. Default: null.
-         *     @type string       $search_terms      Optional. If provided, only groups whose names
-         *                                           or descriptions match the search terms will be
-         *                                           returned. Default: false.
-         *     @type array        $meta_query        Optional. An array of meta_query conditions.
-         *                                           See {@link WP_Meta_Query::queries} for description.
-         *     @type array|string $value             Optional. Array or comma-separated list of group IDs.
-         *                                           Results will be limited to groups within the
-         *                                           list. Default: false.
-         *     @type bool         $populate_extras   Whether to fetch additional information
-         *                                           (such as member count) about groups. Default: true.
-         *     @type array|string $exclude           Optional. Array or comma-separated list of group IDs.
-         *                                           Results will exclude the listed groups. Default: false.
-         *     @type bool         $update_meta_cache Whether to pre-fetch groupmeta for
-         *                                           the returned groups. Default: true.
-         *     @type bool         $show_hidden       Whether to include hidden groups in results. Default: false.
+         *     @type string       $type                Optional. Shorthand for certain orderby/
+         *                                             order combinations. 'newest', 'active', 'popular',
+         *                                             'alphabetical', 'random'. When present, will override
+         *                                             orderby and order params. Default: null.
+         *     @type string       $orderby             Optional. Property to sort by.
+         *                                             'date_created', 'last_activity', 'total_member_count',
+         *                                             'name', 'random'. Default: 'date_created'.
+         *     @type string       $order               Optional. Sort order. 'ASC' or 'DESC'.
+         *                                             Default: 'DESC'.
+         *     @type int          $per_page            Optional. Number of items to return per page
+         *                                             of results. Default: null (no limit).
+         *     @type int          $page                Optional. Page offset of results to return.
+         *                                             Default: null (no limit).
+         *     @type int          $user_id             Optional. If provided, results will be limited to groups
+         *                                             of which the specified user is a member. Default: null.
+         *     @type string       $search_terms        Optional. If provided, only groups whose names
+         *                                             or descriptions match the search terms will be
+         *                                             returned. Default: false.
+         *     @type array|string $group_type          Array or comma-separated list of group types to limit results to.
+         *     @type array|string $group_type__in      Array or comma-separated list of group types to limit results to.
+         *     @type array|string $group_type__not_in  Array or comma-separated list of group types,that will be
+         *                                             excluded from results.
+         *     @type array        $meta_query          Optional. An array of meta_query conditions.
+         *                                             See {@link WP_Meta_Query::queries} for description.
+         *     @type array|string $value               Optional. Array or comma-separated list of group IDs.
+         *                                             Results will be limited to groups within the
+         *                                             list. Default: false.
+         *     @type bool         $populate_extras     Whether to fetch additional information
+         *                                             (such as member count) about groups. Default: true.
+         *     @type array|string $exclude             Optional. Array or comma-separated list of group IDs.
+         *                                             Results will exclude the listed groups. Default: false.
+         *     @type bool         $update_meta_cache   Whether to pre-fetch groupmeta for
+         *                                             the returned groups. Default: true.
+         *     @type bool         $show_hidden         Whether to include hidden groups in results. Default: false.
          * }
          * @return array {
          *     @type array $groups Array of group objects returned by the
@@ -705 +709 @@
                 }
 
                 $defaults = array(
-                        'type'              => null,
-                        'orderby'           => 'date_created',
-                        'order'             => 'DESC',
-                        'per_page'          => null,
-                        'page'              => null,
-                        'user_id'           => 0,
-                        'search_terms'      => false,
-                        'meta_query'        => false,
-                        'include'           => false,
-                        'populate_extras'   => true,
-                        'update_meta_cache' => true,
-                        'exclude'           => false,
-                        'show_hidden'       => false,
+                        'type'               => null,
+                        'orderby'            => 'date_created',
+                        'order'              => 'DESC',
+                        'per_page'           => null,
+                        'page'               => null,
+                        'user_id'            => 0,
+                        'search_terms'       => false,
+                        'group_type'         => '',
+                        'group_type__in'     => '',
+                        'group_type__not_in' => '',
+                        'meta_query'         => false,
+                        'include'            => false,
+                        'populate_extras'    => true,
+                        'update_meta_cache'  => true,
+                        'exclude'            => false,
+                        'show_hidden'        => false,
                 );
 
                 $r = wp_parse_args( $args, $defaults );
@@ -761 +768 @@
                         $sql['meta'] = $meta_query_sql['where'];
                 }
 
+                // Only use 'group_type__in', if 'group_type' is not set.
+                if ( empty( $r['group_type'] ) && ! empty( $r['group_type__in']) ) {
+                        $r['group_type'] = $r['group_type__in'];
+                }
+
+                // Group types to exclude. This has priority over inclusions.
+                if ( ! empty( $r['group_type__not_in'] ) ) {
+                        $group_type_clause = self::get_sql_clause_for_group_types($r['group_type__not_in'], 'NOT IN' );
+
+                // Group types to include.
+                } elseif ( ! empty( $r['group_type'] ) ) {
+                        $group_type_clause = self::get_sql_clause_for_group_types($r['group_type'], 'IN' );
+                }
+
+                if ( ! empty( $group_type_clause ) ) {
+                        $sql['group_type'] = $group_type_clause;
+                }
+
                 if ( ! empty( $r['user_id'] ) ) {
                         $sql['user'] = $wpdb->prepare( " AND m.user_id = %d AND m.is_confirmed = 1 AND m.is_banned = 0", $r['user_id'] );
                 }
@@ -872 +897 @@
                         $total_sql['where'][] = $meta_query_clause;
                 }
 
+                // Trim leading 'AND' to match $total_sql query style.
+                if ( ! empty( $group_type_clause ) ) {
+                        $total_sql['where'][] = preg_replace( '/^\s*AND\s*/', '', $group_type_clause );
+                }
+
                 // Already escaped in the paginated results block.
                 if ( ! empty( $include ) ) {
                         $total_sql['where'][] = "g.id IN ({$include})";
@@ -1563 +1593 @@
 
                 return $ids;
         }
+
+        /**
+         * Get SQL clause for group type(s).
+         *
+         * @since 2.5.0
+         * 
+         * @param  string|array $group_types Group type(s).
+         * @param  string       $operator    'IN' or 'NOT IN'.
+         * @return string       $clause      SQL clause.
+         */
+        protected static function get_sql_clause_for_group_types( $group_types, $operator ) {
+                global $wpdb;
+
+                // Sanitize operator.
+                if ( 'NOT IN' !== $operator ) {
+                        $operator = 'IN';
+                }
+
+                // Parse and sanitize types.
+                if ( ! is_array( $group_types ) ) {
+                        $group_types = preg_split( '/[,\s+]/', $group_types );
+                }
+
+                $types = groups_type_exists( $group_types );
+                if ( false === $types ) {
+                        $types = array();
+                }
+
+                $tax_query = new WP_Tax_Query( array(
+                        array(
+                                'taxonomy' => 'bp_group_type',
+                                'field'    => 'name',
+                                'operator' => $operator,
+                                'terms'    => $types,
+                        ),
+                ) );
+
+                $switched = false;
+                if ( ! bp_is_root_blog() ) {
+                        switch_to_blog( bp_get_root_blog_id() );
+                        $switched = true;
+                }
+
+                $sql_clauses = $tax_query->get_sql( 'g', 'id' );
+
+                if ( $switched ) {
+                        restore_current_blog();
+                }
+
+                $clause = '';
+
+                // The no_results clauses are the same between IN and NOT IN.
+                if ( false !== strpos( $sql_clauses['where'], '0 = 1' ) ) {
+                        $clause = $sql_clauses['where'];
+
+                // The tax_query clause generated for NOT IN can be used almost as-is.
+                } elseif ( 'NOT IN' === $operator ) {
+                        $clause = $sql_clauses['where'];
+
+                // IN clauses must be converted to a subquery.
+                } elseif ( preg_match( '/' . $wpdb->term_relationships . '\.term_taxonomy_id IN \([0-9, ]+\)/', $sql_clauses['where'], $matches ) ) {
+                        $clause = " AND g.id IN ( SELECT object_id FROM $wpdb->term_relationships WHERE {$matches[0]} )";
+                }
+
+                return $clause;
+        }
 }