Changeset 10766 for trunk/src/bp-groups/classes/class-bp-groups-group.php

Timestamp:

05/15/2016 02:21:54 AM (9 years ago)

Author:

boonebgorges

Message:

Introduce Group Types API.

Modeled on the Member Types API, Group Types allow developers to register
arbitrary group categorizations, and assign one or more of these types to a
given group. BuddyPress stores this information in a custom taxonomy on the
root blog.

Group queries can be filtered by group type, by using the group_type,
group_type__in, and group_type__not_in parameters in the bp_has_groups()
template loop function stack.

Props Mamaduka, boonebgorges, dcavins.
See #6784.

File:

• trunk/src/bp-groups/classes/class-bp-groups-group.php (modified) (6 diffs)

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

@@ -684 +684 @@
      *
      * @since 1.6.0
+     * @since 2.6.0 Added `$group_type`, `$group_type__in`, and `$group_type__not_in` parameters.
      *
      * @param array $args {
@@ -705 +706 @@
      *                                           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.
@@ -756 +761 @@
             'user_id'           => 0,
             'search_terms'      => false,
+            'group_type'         => '',
+            'group_type__in'     => '',
+            'group_type__not_in' => '',
             'meta_query'        => false,
             'include'           => false,
@@ -803 +811 @@
         if ( ! empty( $meta_query_sql['where'] ) ) {
             $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;
         }
 
@@ -914 +940 @@
             $meta_query_clause = preg_replace( '/^\s*AND/', '', $meta_query_sql['where'] );
             $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 );
         }
 
@@ -1625 +1656 @@
         return $ids;
     }
+
+    /**
+     * Get SQL clause for group type(s).
+     *
+     * @since 2.6.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 = array();
+        foreach ( $group_types as $gt ) {
+            if ( bp_groups_get_group_type_object( $gt ) ) {
+                $types[] = $gt;
+            }
+        }
+
+        $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;
+    }
 }