BP_Groups_Group

BuddyPress Group object.

Defined (1)

The class is defined in the following location(s).

/bp-groups/classes/class-bp-groups-group.php  
  1. class BP_Groups_Group { 
  2.  
  3.     /** 
  4.      * ID of the group. 
  5.      * 
  6.      * @since 1.6.0 
  7.      * @var int 
  8.      */ 
  9.     public $id; 
  10.  
  11.     /** 
  12.      * User ID of the group's creator. 
  13.      * 
  14.      * @since 1.6.0 
  15.      * @var int 
  16.      */ 
  17.     public $creator_id; 
  18.  
  19.     /** 
  20.      * Name of the group. 
  21.      * 
  22.      * @since 1.6.0 
  23.      * @var string 
  24.      */ 
  25.     public $name; 
  26.  
  27.     /** 
  28.      * Group slug. 
  29.      * 
  30.      * @since 1.6.0 
  31.      * @var string 
  32.      */ 
  33.     public $slug; 
  34.  
  35.     /** 
  36.      * Group description. 
  37.      * 
  38.      * @since 1.6.0 
  39.      * @var string 
  40.      */ 
  41.     public $description; 
  42.  
  43.     /** 
  44.      * Group status. 
  45.      * 
  46.      * Core statuses are 'public', 'private', and 'hidden'. 
  47.      * 
  48.      * @since 1.6.0 
  49.      * @var string 
  50.      */ 
  51.     public $status; 
  52.  
  53.     /** 
  54.      * Parent ID. 
  55.      * 
  56.      * ID of parent group, if applicable. 
  57.      * 
  58.      * @since 2.7.0 
  59.      * @var int 
  60.      */ 
  61.     public $parent_id; 
  62.  
  63.     /** 
  64.      * Should (legacy) bbPress forums be enabled for this group? 
  65.      * 
  66.      * @since 1.6.0 
  67.      * @var int 
  68.      */ 
  69.     public $enable_forum; 
  70.  
  71.     /** 
  72.      * Date the group was created. 
  73.      * 
  74.      * @since 1.6.0 
  75.      * @var string 
  76.      */ 
  77.     public $date_created; 
  78.  
  79.     /** 
  80.      * Data about the group's admins. 
  81.      * 
  82.      * @since 1.6.0 
  83.      * @var array 
  84.      */ 
  85.     protected $admins; 
  86.  
  87.     /** 
  88.      * Data about the group's moderators. 
  89.      * 
  90.      * @since 1.6.0 
  91.      * @var array 
  92.      */ 
  93.     protected $mods; 
  94.  
  95.     /** 
  96.      * Total count of group members. 
  97.      * 
  98.      * @since 1.6.0 
  99.      * @var int 
  100.      */ 
  101.     protected $total_member_count; 
  102.  
  103.     /** 
  104.      * Is the current user a member of this group? 
  105.      * 
  106.      * @since 1.2.0 
  107.      * @var bool 
  108.      */ 
  109.     protected $is_member; 
  110.  
  111.     /** 
  112.      * Does the current user have an outstanding invitation to this group? 
  113.      * 
  114.      * @since 1.9.0 
  115.      * @var bool 
  116.      */ 
  117.     protected $is_invited; 
  118.  
  119.     /** 
  120.      * Does the current user have a pending membership request to this group? 
  121.      * 
  122.      * @since 1.9.0 
  123.      * @var bool 
  124.      */ 
  125.     protected $is_pending; 
  126.  
  127.     /** 
  128.      * Timestamp of the last activity that happened in this group. 
  129.      * 
  130.      * @since 1.2.0 
  131.      * @var string 
  132.      */ 
  133.     protected $last_activity; 
  134.  
  135.     /** 
  136.      * If this is a private or hidden group, does the current user have access? 
  137.      * 
  138.      * @since 1.6.0 
  139.      * @var bool 
  140.      */ 
  141.     protected $user_has_access; 
  142.  
  143.     /** 
  144.      * Raw arguments passed to the constructor. 
  145.      * 
  146.      * @since 2.0.0 
  147.      * @var array 
  148.      */ 
  149.     public $args; 
  150.  
  151.     /** 
  152.      * Constructor method. 
  153.      * 
  154.      * @since 1.6.0 
  155.      * 
  156.      * @param int|null $id   Optional. If the ID of an existing group is provided,  
  157.      *                       the object will be pre-populated with info about that group. 
  158.      * @param array    $args { 
  159.      *     Array of optional arguments. 
  160.      *     @type bool $populate_extras Deprecated. 
  161.      * } 
  162.      */ 
  163.     public function __construct( $id = null, $args = array() ) { 
  164.         if ( !empty( $id ) ) { 
  165.             $this->id = (int) $id; 
  166.             $this->populate(); 
  167.         } 
  168.     } 
  169.  
  170.     /** 
  171.      * Set up data about the current group. 
  172.      * 
  173.      * @since 1.6.0 
  174.      */ 
  175.     public function populate() { 
  176.         global $wpdb; 
  177.  
  178.         // Get BuddyPress. 
  179.         $bp = buddypress(); 
  180.  
  181.         // Check cache for group data. 
  182.         $group = wp_cache_get( $this->id, 'bp_groups' ); 
  183.  
  184.         // Cache missed, so query the DB. 
  185.         if ( false === $group ) { 
  186.             $group = $wpdb->get_row( $wpdb->prepare( "SELECT g.* FROM {$bp->groups->table_name} g WHERE g.id = %d", $this->id ) ); 
  187.  
  188.             wp_cache_set( $this->id, $group, 'bp_groups' ); 
  189.         } 
  190.  
  191.         // No group found so set the ID and bail. 
  192.         if ( empty( $group ) || is_wp_error( $group ) ) { 
  193.             $this->id = 0; 
  194.             return; 
  195.         } 
  196.  
  197.         // Group found so setup the object variables. 
  198.         $this->id = (int) $group->id; 
  199.         $this->creator_id = (int) $group->creator_id; 
  200.         $this->name = stripslashes( $group->name ); 
  201.         $this->slug = $group->slug; 
  202.         $this->description = stripslashes( $group->description ); 
  203.         $this->status = $group->status; 
  204.         $this->parent_id = (int) $group->parent_id; 
  205.         $this->enable_forum = (int) $group->enable_forum; 
  206.         $this->date_created = $group->date_created; 
  207.     } 
  208.  
  209.     /** 
  210.      * Save the current group to the database. 
  211.      * 
  212.      * @since 1.6.0 
  213.      * 
  214.      * @return bool True on success, false on failure. 
  215.      */ 
  216.     public function save() { 
  217.         global $wpdb; 
  218.  
  219.         $bp = buddypress(); 
  220.  
  221.         $this->creator_id = apply_filters( 'groups_group_creator_id_before_save', $this->creator_id, $this->id ); 
  222.         $this->name = apply_filters( 'groups_group_name_before_save', $this->name, $this->id ); 
  223.         $this->slug = apply_filters( 'groups_group_slug_before_save', $this->slug, $this->id ); 
  224.         $this->description = apply_filters( 'groups_group_description_before_save', $this->description, $this->id ); 
  225.         $this->status = apply_filters( 'groups_group_status_before_save', $this->status, $this->id ); 
  226.         $this->parent_id = apply_filters( 'groups_group_parent_id_before_save', $this->parent_id, $this->id ); 
  227.         $this->enable_forum = apply_filters( 'groups_group_enable_forum_before_save', $this->enable_forum, $this->id ); 
  228.         $this->date_created = apply_filters( 'groups_group_date_created_before_save', $this->date_created, $this->id ); 
  229.  
  230.         /** 
  231.          * Fires before the current group item gets saved. 
  232.          * 
  233.          * Please use this hook to filter the properties above. Each part will be passed in. 
  234.          * 
  235.          * @since 1.0.0 
  236.          * 
  237.          * @param BP_Groups_Group $this Current instance of the group item being saved. Passed by reference. 
  238.          */ 
  239.         do_action_ref_array( 'groups_group_before_save', array( &$this ) ); 
  240.  
  241.         // Groups need at least a name. 
  242.         if ( empty( $this->name ) ) { 
  243.             return false; 
  244.         } 
  245.  
  246.         // Set slug with group title if not passed. 
  247.         if ( empty( $this->slug ) ) { 
  248.             $this->slug = sanitize_title( $this->name ); 
  249.         } 
  250.  
  251.         // Sanity check. 
  252.         if ( empty( $this->slug ) ) { 
  253.             return false; 
  254.         } 
  255.  
  256.         // Check for slug conflicts if creating new group. 
  257.         if ( empty( $this->id ) ) { 
  258.             $this->slug = groups_check_slug( $this->slug ); 
  259.         } 
  260.  
  261.         if ( !empty( $this->id ) ) { 
  262.             $sql = $wpdb->prepare( 
  263.                 "UPDATE {$bp->groups->table_name} SET 
  264.                     creator_id = %d,  
  265.                     name = %s,  
  266.                     slug = %s,  
  267.                     description = %s,  
  268.                     status = %s,  
  269.                     parent_id = %d,  
  270.                     enable_forum = %d,  
  271.                     date_created = %s 
  272.                 WHERE 
  273.                     id = %d 
  274.                 ",  
  275.                     $this->creator_id,  
  276.                     $this->name,  
  277.                     $this->slug,  
  278.                     $this->description,  
  279.                     $this->status,  
  280.                     $this->parent_id,  
  281.                     $this->enable_forum,  
  282.                     $this->date_created,  
  283.                     $this->id 
  284.  ); 
  285.         } else { 
  286.             $sql = $wpdb->prepare( 
  287.                 "INSERT INTO {$bp->groups->table_name} ( 
  288.                     creator_id,  
  289.                     name,  
  290.                     slug,  
  291.                     description,  
  292.                     status,  
  293.                     parent_id,  
  294.                     enable_forum,  
  295.                     date_created 
  296.  ) VALUES ( 
  297.                     %d, %s, %s, %s, %s, %d, %d, %s 
  298.  )",  
  299.                     $this->creator_id,  
  300.                     $this->name,  
  301.                     $this->slug,  
  302.                     $this->description,  
  303.                     $this->status,  
  304.                     $this->parent_id,  
  305.                     $this->enable_forum,  
  306.                     $this->date_created 
  307.  ); 
  308.         } 
  309.  
  310.         if ( false === $wpdb->query($sql) ) 
  311.             return false; 
  312.  
  313.         if ( empty( $this->id ) ) 
  314.             $this->id = $wpdb->insert_id; 
  315.  
  316.         /** 
  317.          * Fires after the current group item has been saved. 
  318.          * 
  319.          * @since 1.0.0 
  320.          * 
  321.          * @param BP_Groups_Group $this Current instance of the group item that was saved. Passed by reference. 
  322.          */ 
  323.         do_action_ref_array( 'groups_group_after_save', array( &$this ) ); 
  324.  
  325.         wp_cache_delete( $this->id, 'bp_groups' ); 
  326.  
  327.         return true; 
  328.     } 
  329.  
  330.     /** 
  331.      * Delete the current group. 
  332.      * 
  333.      * @since 1.6.0 
  334.      * 
  335.      * @return bool True on success, false on failure. 
  336.      */ 
  337.     public function delete() { 
  338.         global $wpdb; 
  339.  
  340.         // Delete groupmeta for the group. 
  341.         groups_delete_groupmeta( $this->id ); 
  342.  
  343.         // Fetch the user IDs of all the members of the group. 
  344.         $user_ids = BP_Groups_Member::get_group_member_ids( $this->id ); 
  345.         $user_id_str = esc_sql( implode( ', ', wp_parse_id_list( $user_ids ) ) ); 
  346.  
  347.         // Modify group count usermeta for members. 
  348.         $wpdb->query( "UPDATE {$wpdb->usermeta} SET meta_value = meta_value - 1 WHERE meta_key = 'total_group_count' AND user_id IN ( {$user_id_str} )" ); 
  349.  
  350.         // Now delete all group member entries. 
  351.         BP_Groups_Member::delete_all( $this->id ); 
  352.  
  353.         /** 
  354.          * Fires before the deletion of a group. 
  355.          * 
  356.          * @since 1.2.0 
  357.          * 
  358.          * @param BP_Groups_Group $this     Current instance of the group item being deleted. Passed by reference. 
  359.          * @param array           $user_ids Array of user IDs that were members of the group. 
  360.          */ 
  361.         do_action_ref_array( 'bp_groups_delete_group', array( &$this, $user_ids ) ); 
  362.  
  363.         wp_cache_delete( $this->id, 'bp_groups' ); 
  364.  
  365.         $bp = buddypress(); 
  366.  
  367.         // Finally remove the group entry from the DB. 
  368.         if ( !$wpdb->query( $wpdb->prepare( "DELETE FROM {$bp->groups->table_name} WHERE id = %d", $this->id ) ) ) 
  369.             return false; 
  370.  
  371.         return true; 
  372.     } 
  373.  
  374.     /** 
  375.      * Magic getter. 
  376.      * 
  377.      * @since 2.7.0 
  378.      * 
  379.      * @param string $key Property name. 
  380.      * @return mixed 
  381.      */ 
  382.     public function __get( $key ) { 
  383.         switch ( $key ) { 
  384.             case 'last_activity' : 
  385.             case 'total_member_count' : 
  386.             case 'forum_id' : 
  387.                 $retval = groups_get_groupmeta( $this->id, $key ); 
  388.  
  389.                 if ( 'last_activity' !== $key ) { 
  390.                     $retval = (int) $retval; 
  391.                 } 
  392.  
  393.                 return $retval; 
  394.  
  395.             case 'admins' : 
  396.                 return $this->get_admins(); 
  397.  
  398.             case 'mods' : 
  399.                 return $this->get_mods(); 
  400.  
  401.             case 'is_member' : 
  402.                 return $this->get_is_member(); 
  403.  
  404.             case 'is_invited' : 
  405.                 return groups_check_user_has_invite( bp_loggedin_user_id(), $this->id ); 
  406.  
  407.             case 'is_pending' : 
  408.                 return groups_check_for_membership_request( bp_loggedin_user_id(), $this->id ); 
  409.  
  410.             case 'user_has_access' : 
  411.                 return $this->get_user_has_access(); 
  412.  
  413.             default : 
  414.                 return isset( $this->{$key} ) ? $this->{$key} : null; 
  415.         } 
  416.     } 
  417.  
  418.     /** 
  419.      * Magic issetter. 
  420.      * 
  421.      * Used to maintain backward compatibility for properties that are now 
  422.      * accessible only via magic method. 
  423.      * 
  424.      * @since 2.7.0 
  425.      * 
  426.      * @param string $key Property name. 
  427.      * @return bool 
  428.      */ 
  429.     public function __isset( $key ) { 
  430.         switch ( $key ) { 
  431.             case 'admins' : 
  432.             case 'is_invited' : 
  433.             case 'is_member' : 
  434.             case 'is_pending' : 
  435.             case 'last_activity' : 
  436.             case 'mods' : 
  437.             case 'total_member_count' : 
  438.             case 'user_has_access' : 
  439.             case 'forum_id' : 
  440.                 return true; 
  441.  
  442.             default : 
  443.                 return isset( $this->{$key} ); 
  444.         } 
  445.     } 
  446.  
  447.     /** 
  448.      * Magic setter. 
  449.      * 
  450.      * Used to maintain backward compatibility for properties that are now 
  451.      * accessible only via magic method. 
  452.      * 
  453.      * @since 2.7.0 
  454.      * 
  455.      * @param string $key Property name. 
  456.      */ 
  457.     public function __set( $key, $value ) { 
  458.         switch ( $key ) { 
  459.             case 'user_has_access' : 
  460.                 return $this->user_has_access = (bool) $value; 
  461.  
  462.             default : 
  463.                 $this->{$key} = $value; 
  464.         } 
  465.     } 
  466.  
  467.     /** 
  468.      * Get a list of the group's admins. 
  469.      * 
  470.      * Used to provide cache-friendly access to the 'admins' property of 
  471.      * the group object. 
  472.      * 
  473.      * @since 2.7.0 
  474.      * 
  475.      * @return array 
  476.      */ 
  477.     protected function get_admins() { 
  478.         if ( isset( $this->admins ) ) { 
  479.             return $this->admins; 
  480.         } 
  481.  
  482.         $this->set_up_admins_and_mods(); 
  483.         return $this->admins; 
  484.     } 
  485.  
  486.     /** 
  487.      * Get a list of the group's mods. 
  488.      * 
  489.      * Used to provide cache-friendly access to the 'mods' property of 
  490.      * the group object. 
  491.      * 
  492.      * @since 2.7.0 
  493.      * 
  494.      * @return array 
  495.      */ 
  496.     protected function get_mods() { 
  497.         if ( isset( $this->mods ) ) { 
  498.             return $this->mods; 
  499.         } 
  500.  
  501.         $this->set_up_admins_and_mods(); 
  502.         return $this->mods; 
  503.     } 
  504.  
  505.     /** 
  506.      * Set up admins and mods for the current group object. 
  507.      * 
  508.      * Called only when the 'admins' or 'mods' property is accessed. 
  509.      * 
  510.      * @since 2.7.0 
  511.      */ 
  512.     protected function set_up_admins_and_mods() { 
  513.         $admin_ids = BP_Groups_Member::get_group_administrator_ids( $this->id ); 
  514.         $admin_ids_plucked = wp_list_pluck( $admin_ids, 'user_id' ); 
  515.  
  516.         $mod_ids = BP_Groups_Member::get_group_moderator_ids( $this->id ); 
  517.         $mod_ids_plucked = wp_list_pluck( $mod_ids, 'user_id' ); 
  518.  
  519.         $admin_mod_users = get_users( array( 
  520.             'include' => array_merge( $admin_ids_plucked, $mod_ids_plucked ),  
  521.  ) ); 
  522.  
  523.         $admin_objects = $mod_objects = array(); 
  524.         foreach ( $admin_mod_users as $admin_mod_user ) { 
  525.             $obj = new stdClass(); 
  526.             $obj->user_id = $admin_mod_user->ID; 
  527.             $obj->user_login = $admin_mod_user->user_login; 
  528.             $obj->user_email = $admin_mod_user->user_email; 
  529.             $obj->user_nicename = $admin_mod_user->user_nicename; 
  530.  
  531.             if ( in_array( $admin_mod_user->ID, $admin_ids_plucked, true ) ) { 
  532.                 $obj->is_admin = 1; 
  533.                 $obj->is_mod = 0; 
  534.                 $admin_objects[] = $obj; 
  535.             } else { 
  536.                 $obj->is_admin = 0; 
  537.                 $obj->is_mod = 1; 
  538.                 $mod_objects[] = $obj; 
  539.             } 
  540.         } 
  541.  
  542.         $this->admins = $admin_objects; 
  543.         $this->mods = $mod_objects; 
  544.     } 
  545.  
  546.     /** 
  547.      * Checks whether the logged-in user is a member of the group. 
  548.      * 
  549.      * @since 2.7.0 
  550.      * 
  551.      * @return bool 
  552.      */ 
  553.     protected function get_is_member() { 
  554.         if ( isset( $this->is_member ) ) { 
  555.             return $this->is_member; 
  556.         } 
  557.  
  558.         $this->is_member = groups_is_user_member( bp_loggedin_user_id(), $this->id ); 
  559.         return $this->is_member; 
  560.     } 
  561.  
  562.     /** 
  563.      * Checks whether the logged-in user has access to the group. 
  564.      * 
  565.      * @since 2.7.0 
  566.      * 
  567.      * @return bool 
  568.      */ 
  569.     protected function get_user_has_access() { 
  570.         if ( isset( $this->user_has_access ) ) { 
  571.             return $this->user_has_access; 
  572.         } 
  573.  
  574.         if ( ( 'private' === $this->status ) || ( 'hidden' === $this->status ) ) { 
  575.  
  576.             // Assume user does not have access to hidden/private groups. 
  577.             $this->user_has_access = false; 
  578.  
  579.             // Group members or community moderators have access. 
  580.             if ( ( is_user_logged_in() && $this->get_is_member() ) || bp_current_user_can( 'bp_moderate' ) ) { 
  581.                 $this->user_has_access = true; 
  582.             } 
  583.         } else { 
  584.             $this->user_has_access = true; 
  585.         } 
  586.  
  587.         return $this->user_has_access; 
  588.     } 
  589.  
  590.     /** Static Methods ****************************************************/ 
  591.  
  592.     /** 
  593.      * Get whether a group exists for a given slug. 
  594.      * 
  595.      * @since 1.6.0 
  596.      * 
  597.      * @param string      $slug       Slug to check. 
  598.      * @param string|bool $table_name Optional. Name of the table to check 
  599.      *                                against. Default: $bp->groups->table_name. 
  600.      * @return int|null Group ID if found; null if not. 
  601.      */ 
  602.     public static function group_exists( $slug, $table_name = false ) { 
  603.         global $wpdb; 
  604.  
  605.         if ( empty( $table_name ) ) 
  606.             $table_name = buddypress()->groups->table_name; 
  607.  
  608.         if ( empty( $slug ) ) 
  609.             return false; 
  610.  
  611.         $query = $wpdb->get_var( $wpdb->prepare( "SELECT id FROM {$table_name} WHERE slug = %s", strtolower( $slug ) ) ); 
  612.  
  613.         return is_numeric( $query ) ? (int) $query : $query; 
  614.     } 
  615.  
  616.     /** 
  617.      * Get the ID of a group by the group's slug. 
  618.      * 
  619.      * Alias of {@link BP_Groups_Group::group_exists()}. 
  620.      * 
  621.      * @since 1.6.0 
  622.      * 
  623.      * @param string $slug See {@link BP_Groups_Group::group_exists()}. 
  624.      * @return string|null See {@link BP_Groups_Group::group_exists()}. 
  625.      */ 
  626.     public static function get_id_from_slug( $slug ) { 
  627.         return BP_Groups_Group::group_exists( $slug ); 
  628.     } 
  629.  
  630.     /** 
  631.      * Get IDs of users with outstanding invites to a given group from a specified user. 
  632.      * 
  633.      * @since 1.6.0 
  634.      * 
  635.      * @param int $user_id ID of the inviting user. 
  636.      * @param int $group_id ID of the group. 
  637.      * @return array IDs of users who have been invited to the group by the 
  638.      *               user but have not yet accepted. 
  639.      */ 
  640.     public static function get_invites( $user_id, $group_id ) { 
  641.         global $wpdb; 
  642.  
  643.         $bp = buddypress(); 
  644.  
  645.         return $wpdb->get_col( $wpdb->prepare( "SELECT user_id FROM {$bp->groups->table_name_members} WHERE group_id = %d and is_confirmed = 0 AND inviter_id = %d", $group_id, $user_id ) ); 
  646.     } 
  647.  
  648.     /** 
  649.      * Get a list of a user's groups, filtered by a search string. 
  650.      * 
  651.      * @since 1.6.0 
  652.      * 
  653.      * @param string   $filter  Search term. Matches against 'name' and 
  654.      *                          'description' fields. 
  655.      * @param int      $user_id ID of the user whose groups are being searched. 
  656.      *                          Default: the displayed user. 
  657.      * @param mixed    $order   Not used. 
  658.      * @param int|null $limit   Optional. The max number of results to return. 
  659.      *                          Default: null (no limit). 
  660.      * @param int|null $page    Optional. The page offset of results to return. 
  661.      *                          Default: null (no limit). 
  662.      * @return false|array { 
  663.      *     @type array $groups Array of matched and paginated group IDs. 
  664.      *     @type int   $total  Total count of groups matching the query. 
  665.      * } 
  666.      */ 
  667.     public static function filter_user_groups( $filter, $user_id = 0, $order = false, $limit = null, $page = null ) { 
  668.         if ( empty( $user_id ) ) { 
  669.             $user_id = bp_displayed_user_id(); 
  670.         } 
  671.  
  672.         $args = array( 
  673.             'search_terms' => $filter,  
  674.             'user_id' => $user_id,  
  675.             'per_page' => $limit,  
  676.             'page' => $page,  
  677.             'order' => $order,  
  678.  ); 
  679.  
  680.         $groups = BP_Groups_Group::get( $args ); 
  681.  
  682.         // Modify the results to match the old format. 
  683.         $paged_groups = array(); 
  684.         $i = 0; 
  685.         foreach ( $groups['groups'] as $group ) { 
  686.             $paged_groups[ $i ] = new stdClass; 
  687.             $paged_groups[ $i ]->group_id = $group->id; 
  688.             $i++; 
  689.         } 
  690.  
  691.         return array( 'groups' => $paged_groups, 'total' => $groups['total'] ); 
  692.     } 
  693.  
  694.     /** 
  695.      * Get a list of groups, filtered by a search string. 
  696.      * 
  697.      * @since 1.6.0 
  698.      * 
  699.      * @param string      $filter  Search term. Matches against 'name' and 
  700.      *                             'description' fields. 
  701.      * @param int|null    $limit   Optional. The max number of results to return. 
  702.      *                             Default: null (no limit). 
  703.      * @param int|null    $page    Optional. The page offset of results to return. 
  704.      *                             Default: null (no limit). 
  705.      * @param string|bool $sort_by Column to sort by. Default: false (default 
  706.      *        sort). 
  707.      * @param string|bool $order   ASC or DESC. Default: false (default sort). 
  708.      * @return array { 
  709.      *     @type array $groups Array of matched and paginated group IDs. 
  710.      *     @type int   $total  Total count of groups matching the query. 
  711.      * } 
  712.      */ 
  713.     public static function search_groups( $filter, $limit = null, $page = null, $sort_by = false, $order = false ) { 
  714.         $args = array( 
  715.             'search_terms' => $filter,  
  716.             'per_page' => $limit,  
  717.             'page' => $page,  
  718.             'orderby' => $sort_by,  
  719.             'order' => $order,  
  720.  ); 
  721.  
  722.         $groups = BP_Groups_Group::get( $args ); 
  723.  
  724.         // Modify the results to match the old format. 
  725.         $paged_groups = array(); 
  726.         $i = 0; 
  727.         foreach ( $groups['groups'] as $group ) { 
  728.             $paged_groups[ $i ] = new stdClass; 
  729.             $paged_groups[ $i ]->group_id = $group->id; 
  730.             $i++; 
  731.         } 
  732.  
  733.         return array( 'groups' => $paged_groups, 'total' => $groups['total'] ); 
  734.     } 
  735.  
  736.     /** 
  737.      * Check for the existence of a slug. 
  738.      * 
  739.      * @since 1.6.0 
  740.      * 
  741.      * @param string $slug Slug to check. 
  742.      * @return string|null The slug, if found. Otherwise null. 
  743.      */ 
  744.     public static function check_slug( $slug ) { 
  745.         global $wpdb; 
  746.  
  747.         $bp = buddypress(); 
  748.  
  749.         return $wpdb->get_var( $wpdb->prepare( "SELECT slug FROM {$bp->groups->table_name} WHERE slug = %s", $slug ) ); 
  750.     } 
  751.  
  752.     /** 
  753.      * Get the slug for a given group ID. 
  754.      * 
  755.      * @since 1.6.0 
  756.      * 
  757.      * @param int $group_id ID of the group. 
  758.      * @return string|null The slug, if found. Otherwise null. 
  759.      */ 
  760.     public static function get_slug( $group_id ) { 
  761.         global $wpdb; 
  762.  
  763.         $bp = buddypress(); 
  764.  
  765.         return $wpdb->get_var( $wpdb->prepare( "SELECT slug FROM {$bp->groups->table_name} WHERE id = %d", $group_id ) ); 
  766.     } 
  767.  
  768.     /** 
  769.      * Check whether a given group has any members. 
  770.      * 
  771.      * @since 1.6.0 
  772.      * 
  773.      * @param int $group_id ID of the group. 
  774.      * @return bool True if the group has members, otherwise false. 
  775.      */ 
  776.     public static function has_members( $group_id ) { 
  777.         global $wpdb; 
  778.  
  779.         $bp = buddypress(); 
  780.  
  781.         $members = $wpdb->get_var( $wpdb->prepare( "SELECT COUNT(id) FROM {$bp->groups->table_name_members} WHERE group_id = %d", $group_id ) ); 
  782.  
  783.         if ( empty( $members ) ) 
  784.             return false; 
  785.  
  786.         return true; 
  787.     } 
  788.  
  789.     /** 
  790.      * Check whether a group has outstanding membership requests. 
  791.      * 
  792.      * @since 1.6.0 
  793.      * 
  794.      * @param int $group_id ID of the group. 
  795.      * @return int|null The number of outstanding requests, or null if 
  796.      *                  none are found. 
  797.      */ 
  798.     public static function has_membership_requests( $group_id ) { 
  799.         global $wpdb; 
  800.  
  801.         $bp = buddypress(); 
  802.  
  803.         return $wpdb->get_var( $wpdb->prepare( "SELECT COUNT(id) FROM {$bp->groups->table_name_members} WHERE group_id = %d AND is_confirmed = 0", $group_id ) ); 
  804.     } 
  805.  
  806.     /** 
  807.      * Get outstanding membership requests for a group. 
  808.      * 
  809.      * @since 1.6.0 
  810.      * 
  811.      * @param int      $group_id ID of the group. 
  812.      * @param int|null $limit    Optional. Max number of results to return. 
  813.      *                           Default: null (no limit). 
  814.      * @param int|null $page     Optional. Page offset of results returned. Default: 
  815.      *                           null (no limit). 
  816.      * @return array { 
  817.      *     @type array $requests The requested page of located requests. 
  818.      *     @type int   $total    Total number of requests outstanding for the 
  819.      *                           group. 
  820.      * } 
  821.      */ 
  822.     public static function get_membership_requests( $group_id, $limit = null, $page = null ) { 
  823.         global $wpdb; 
  824.  
  825.         if ( !empty( $limit ) && !empty( $page ) ) { 
  826.             $pag_sql = $wpdb->prepare( " LIMIT %d, %d", intval( ( $page - 1 ) * $limit), intval( $limit ) ); 
  827.         } 
  828.  
  829.         $bp = buddypress(); 
  830.  
  831.         $paged_requests = $wpdb->get_results( $wpdb->prepare( "SELECT * FROM {$bp->groups->table_name_members} WHERE group_id = %d AND is_confirmed = 0 AND inviter_id = 0{$pag_sql}", $group_id ) ); 
  832.         $total_requests = $wpdb->get_var( $wpdb->prepare( "SELECT COUNT(id) FROM {$bp->groups->table_name_members} WHERE group_id = %d AND is_confirmed = 0 AND inviter_id = 0", $group_id ) ); 
  833.  
  834.         return array( 'requests' => $paged_requests, 'total' => $total_requests ); 
  835.     } 
  836.  
  837.     /** 
  838.      * Query for groups. 
  839.      * 
  840.      * @see WP_Meta_Query::queries for a description of the 'meta_query' 
  841.      *      parameter format. 
  842.      * 
  843.      * @since 1.6.0 
  844.      * @since 2.6.0 Added `$group_type`, `$group_type__in`, and `$group_type__not_in` parameters. 
  845.      * @since 2.7.0 Added `$update_admin_cache` and `$parent_id` parameters. 
  846.      * 
  847.      * @param array $args { 
  848.      *     Array of parameters. All items are optional. 
  849.      *     @type string       $type               Optional. Shorthand for certain orderby/order combinations. 
  850.      *                                            'newest', 'active', 'popular', 'alphabetical', 'random'. 
  851.      *                                            When present, will override orderby and order params. 
  852.      *                                            Default: null. 
  853.      *     @type string       $orderby            Optional. Property to sort by. 'date_created', 'last_activity',  
  854.      *                                            'total_member_count', 'name', 'random'. Default: 'date_created'. 
  855.      *     @type string       $order              Optional. Sort order. 'ASC' or 'DESC'. Default: 'DESC'. 
  856.      *     @type int          $per_page           Optional. Number of items to return per page of results. 
  857.      *                                            Default: null (no limit). 
  858.      *     @type int          $page               Optional. Page offset of results to return. 
  859.      *                                            Default: null (no limit). 
  860.      *     @type int          $user_id            Optional. If provided, results will be limited to groups 
  861.      *                                            of which the specified user is a member. Default: null. 
  862.       *     @type string       $search_terms       Optional. If provided, only groups whose names or descriptions 
  863.      *                                            match the search terms will be returned. Allows specifying the 
  864.      *                                            wildcard position using a '*' character before or after the 
  865.      *                                            string or both. Works in concert with $search_columns. 
  866.      *                                            Default: false. 
  867.        *     @type string       $search_columns     Optional. If provided, only apply the search terms to the 
  868.        *                                            specified columns. Works in concert with $search_terms. 
  869.        *                                            Default: empty array. 
  870.      *     @type array|string $group_type         Array or comma-separated list of group types to limit results to. 
  871.      *     @type array|string $group_type__in     Array or comma-separated list of group types to limit results to. 
  872.      *     @type array|string $group_type__not_in Array or comma-separated list of group types that will be 
  873.      *                                            excluded from results. 
  874.      *     @type array        $meta_query         Optional. An array of meta_query conditions. 
  875.      *                                            See {@link WP_Meta_Query::queries} for description. 
  876.      *     @type array|string $value              Optional. Array or comma-separated list of group IDs. Results 
  877.      *                                            will be limited to groups within the list. Default: false. 
  878.      *     @type array|string $parent_id          Optional. Array or comma-separated list of group IDs. Results 
  879.      *                                            will be limited to children of the specified groups. Default: null. 
  880.      *     @type array|string $exclude            Optional. Array or comma-separated list of group IDs. 
  881.      *                                            Results will exclude the listed groups. Default: false. 
  882.      *     @type bool         $update_meta_cache  Whether to pre-fetch groupmeta for the returned groups. 
  883.      *                                            Default: true. 
  884.      *     @type bool         $update_admin_cache Whether to pre-fetch administrator IDs for the returned 
  885.      *                                            groups. Default: false. 
  886.      *     @type bool         $show_hidden        Whether to include hidden groups in results. Default: false. 
  887.      * } 
  888.      * @return array { 
  889.      *     @type array $groups Array of group objects returned by the 
  890.      *                         paginated query. 
  891.      *     @type int   $total  Total count of all groups matching non- 
  892.      *                         paginated query params. 
  893.      * } 
  894.      */ 
  895.     public static function get( $args = array() ) { 
  896.         global $wpdb; 
  897.  
  898.         // Backward compatibility with old method of passing arguments. 
  899.         if ( ! is_array( $args ) || func_num_args() > 1 ) { 
  900.             _deprecated_argument( __METHOD__, '1.7', sprintf( __( 'Arguments passed to %1$s should be in an associative array. See the inline documentation at %2$s for more details.', 'buddypress' ), __METHOD__, __FILE__ ) ); 
  901.  
  902.             $old_args_keys = array( 
  903.                 0 => 'type',  
  904.                 1 => 'per_page',  
  905.                 2 => 'page',  
  906.                 3 => 'user_id',  
  907.                 4 => 'search_terms',  
  908.                 5 => 'include',  
  909.                 6 => 'populate_extras',  
  910.                 7 => 'exclude',  
  911.                 8 => 'show_hidden',  
  912.  ); 
  913.  
  914.             $args = bp_core_parse_args_array( $old_args_keys, func_get_args() ); 
  915.         } 
  916.  
  917.         $defaults = array( 
  918.             'type' => null,  
  919.             'orderby' => 'date_created',  
  920.             'order' => 'DESC',  
  921.             'per_page' => null,  
  922.             'page' => null,  
  923.             'user_id' => 0,  
  924.             'search_terms' => false,  
  925.             'search_columns' => array(),  
  926.             'group_type' => '',  
  927.             'group_type__in' => '',  
  928.             'group_type__not_in' => '',  
  929.             'meta_query' => false,  
  930.             'include' => false,  
  931.             'parent_id' => null,  
  932.             'update_meta_cache' => true,  
  933.             'update_admin_cache' => false,  
  934.             'exclude' => false,  
  935.             'show_hidden' => false,  
  936.  ); 
  937.  
  938.         $r = wp_parse_args( $args, $defaults ); 
  939.  
  940.         $bp = buddypress(); 
  941.  
  942.         $sql = array( 
  943.             'select' => "SELECT DISTINCT g.id",  
  944.             'from' => "{$bp->groups->table_name} g",  
  945.             'where' => '',  
  946.             'orderby' => '',  
  947.             'pagination' => '',  
  948.  ); 
  949.  
  950.         if ( ! empty( $r['user_id'] ) ) { 
  951.             $sql['from'] .= " JOIN {$bp->groups->table_name_members} m ON ( g.id = m.group_id )"; 
  952.         } 
  953.  
  954.         $where_conditions = array(); 
  955.  
  956.         if ( empty( $r['show_hidden'] ) ) { 
  957.             $where_conditions['hidden'] = "g.status != 'hidden'"; 
  958.         } 
  959.  
  960.         $search = ''; 
  961.         if ( isset( $r['search_terms'] ) ) { 
  962.             $search = trim( $r['search_terms'] ); 
  963.         } 
  964.  
  965.         if ( $search ) { 
  966.             $leading_wild = ( ltrim( $search, '*' ) != $search ); 
  967.             $trailing_wild = ( rtrim( $search, '*' ) != $search ); 
  968.             if ( $leading_wild && $trailing_wild ) { 
  969.                 $wild = 'both'; 
  970.             } elseif ( $leading_wild ) { 
  971.                 $wild = 'leading'; 
  972.             } elseif ( $trailing_wild ) { 
  973.                 $wild = 'trailing'; 
  974.             } else { 
  975.                 // Default is to wrap in wildcard characters. 
  976.                 $wild = 'both'; 
  977.             } 
  978.             $search = trim( $search, '*' ); 
  979.  
  980.             $searches = array(); 
  981.             $leading_wild = ( 'leading' == $wild || 'both' == $wild ) ? '%' : ''; 
  982.             $trailing_wild = ( 'trailing' == $wild || 'both' == $wild ) ? '%' : ''; 
  983.             $wildcarded = $leading_wild . bp_esc_like( $search ) . $trailing_wild; 
  984.  
  985.             $search_columns = array( 'name', 'description' ); 
  986.             if ( $r['search_columns'] ) { 
  987.                 $search_columns = array_intersect( $r['search_columns'], $search_columns ); 
  988.             } 
  989.  
  990.             foreach ( $search_columns as $search_column ) { 
  991.                 $searches[] = $wpdb->prepare( "$search_column LIKE %s", $wildcarded ); 
  992.             } 
  993.  
  994.             $where_conditions['search'] = '(' . implode(' OR ', $searches) . ')'; 
  995.         } 
  996.  
  997.         $meta_query_sql = self::get_meta_query_sql( $r['meta_query'] ); 
  998.  
  999.         if ( ! empty( $meta_query_sql['join'] ) ) { 
  1000.             $sql['from'] .= $meta_query_sql['join']; 
  1001.         } 
  1002.  
  1003.         if ( ! empty( $meta_query_sql['where'] ) ) { 
  1004.             $where_conditions['meta'] = $meta_query_sql['where']; 
  1005.         } 
  1006.  
  1007.         // Only use 'group_type__in', if 'group_type' is not set. 
  1008.         if ( empty( $r['group_type'] ) && ! empty( $r['group_type__in']) ) { 
  1009.             $r['group_type'] = $r['group_type__in']; 
  1010.         } 
  1011.  
  1012.         // Group types to exclude. This has priority over inclusions. 
  1013.         if ( ! empty( $r['group_type__not_in'] ) ) { 
  1014.             $group_type_clause = self::get_sql_clause_for_group_types( $r['group_type__not_in'], 'NOT IN' ); 
  1015.  
  1016.         // Group types to include. 
  1017.         } elseif ( ! empty( $r['group_type'] ) ) { 
  1018.             $group_type_clause = self::get_sql_clause_for_group_types( $r['group_type'], 'IN' ); 
  1019.         } 
  1020.  
  1021.         if ( ! empty( $group_type_clause ) ) { 
  1022.             $where_conditions['group_type'] = $group_type_clause; 
  1023.         } 
  1024.  
  1025.         if ( ! empty( $r['user_id'] ) ) { 
  1026.             $where_conditions['user'] = $wpdb->prepare( "m.user_id = %d AND m.is_confirmed = 1 AND m.is_banned = 0", $r['user_id'] ); 
  1027.         } 
  1028.  
  1029.         if ( ! empty( $r['include'] ) ) { 
  1030.             $include = implode( ', ', wp_parse_id_list( $r['include'] ) ); 
  1031.             $where_conditions['include'] = "g.id IN ({$include})"; 
  1032.         } 
  1033.  
  1034.         if ( ! is_null( $r['parent_id'] ) ) { 
  1035.             // Note that `wp_parse_id_list()` converts `false` to 0. 
  1036.             $parent_id = implode( ', ', wp_parse_id_list( $r['parent_id'] ) ); 
  1037.             $where_conditions['parent_id'] = "g.parent_id IN ({$parent_id})"; 
  1038.         } 
  1039.  
  1040.         if ( ! empty( $r['exclude'] ) ) { 
  1041.             $exclude = implode( ', ', wp_parse_id_list( $r['exclude'] ) ); 
  1042.             $where_conditions['exclude'] = "g.id NOT IN ({$exclude})"; 
  1043.         } 
  1044.  
  1045.         /** Order/orderby ********************************************/ 
  1046.  
  1047.         $order = $r['order']; 
  1048.         $orderby = $r['orderby']; 
  1049.  
  1050.         // If a 'type' parameter was passed, parse it and overwrite 
  1051.         // 'order' and 'orderby' params passed to the function. 
  1052.         if (  ! empty( $r['type'] ) ) { 
  1053.  
  1054.             /** 
  1055.              * Filters the 'type' parameter used to overwrite 'order' and 'orderby' values. 
  1056.              * 
  1057.              * @since 2.1.0 
  1058.              * 
  1059.              * @param array  $value Converted 'type' value for order and orderby. 
  1060.              * @param string $value Parsed 'type' value for the get method. 
  1061.              */ 
  1062.             $order_orderby = apply_filters( 'bp_groups_get_orderby', self::convert_type_to_order_orderby( $r['type'] ), $r['type'] ); 
  1063.  
  1064.             // If an invalid type is passed, $order_orderby will be 
  1065.             // an array with empty values. In this case, we stick 
  1066.             // with the default values of $order and $orderby. 
  1067.             if ( ! empty( $order_orderby['order'] ) ) { 
  1068.                 $order = $order_orderby['order']; 
  1069.             } 
  1070.  
  1071.             if ( ! empty( $order_orderby['orderby'] ) ) { 
  1072.                 $orderby = $order_orderby['orderby']; 
  1073.             } 
  1074.         } 
  1075.  
  1076.         // 'total_member_count' and 'last_activity' sorts require additional table joins. 
  1077.         if ( 'total_member_count' === $orderby ) { 
  1078.             $sql['from'] .= " JOIN {$bp->groups->table_name_groupmeta} gm_total_member_count ON ( g.id = gm_total_member_count.group_id )"; 
  1079.             $where_conditions['total_member_count'] = "gm_total_member_count.meta_key = 'total_member_count'"; 
  1080.         } elseif ( 'last_activity' === $orderby ) { 
  1081.  
  1082.             $sql['from'] .= " JOIN {$bp->groups->table_name_groupmeta} gm_last_activity on ( g.id = gm_last_activity.group_id )"; 
  1083.             $where_conditions['last_activity'] = "gm_last_activity.meta_key = 'last_activity'"; 
  1084.         } 
  1085.  
  1086.         // Sanitize 'order'. 
  1087.         $order = bp_esc_sql_order( $order ); 
  1088.  
  1089.         /** 
  1090.          * Filters the converted 'orderby' term. 
  1091.          * 
  1092.          * @since 2.1.0 
  1093.          * 
  1094.          * @param string $value   Converted 'orderby' term. 
  1095.          * @param string $orderby Original orderby value. 
  1096.          * @param string $value   Parsed 'type' value for the get method. 
  1097.          */ 
  1098.         $orderby = apply_filters( 'bp_groups_get_orderby_converted_by_term', self::convert_orderby_to_order_by_term( $orderby ), $orderby, $r['type'] ); 
  1099.  
  1100.         // Random order is a special case. 
  1101.         if ( 'rand()' === $orderby ) { 
  1102.             $sql['orderby'] = "ORDER BY rand()"; 
  1103.         } else { 
  1104.             $sql['orderby'] = "ORDER BY {$orderby} {$order}"; 
  1105.         } 
  1106.  
  1107.         if ( ! empty( $r['per_page'] ) && ! empty( $r['page'] ) && $r['per_page'] != -1 ) { 
  1108.             $sql['pagination'] = $wpdb->prepare( "LIMIT %d, %d", intval( ( $r['page'] - 1 ) * $r['per_page']), intval( $r['per_page'] ) ); 
  1109.         } 
  1110.  
  1111.         $where = ''; 
  1112.         if ( ! empty( $where_conditions ) ) { 
  1113.             $sql['where'] = implode( ' AND ', $where_conditions ); 
  1114.             $where = "WHERE {$sql['where']}"; 
  1115.         } 
  1116.  
  1117.         $paged_groups_sql = "{$sql['select']} FROM {$sql['from']} {$where} {$sql['orderby']} {$sql['pagination']}"; 
  1118.  
  1119.         /** 
  1120.          * Filters the pagination SQL statement. 
  1121.          * 
  1122.          * @since 1.5.0 
  1123.          * 
  1124.          * @param string $value Concatenated SQL statement. 
  1125.          * @param array  $sql   Array of SQL parts before concatenation. 
  1126.          * @param array  $r     Array of parsed arguments for the get method. 
  1127.          */ 
  1128.         $paged_groups_sql = apply_filters( 'bp_groups_get_paged_groups_sql', $paged_groups_sql, $sql, $r ); 
  1129.  
  1130.         $cached = bp_core_get_incremented_cache( $paged_groups_sql, 'bp_groups' ); 
  1131.         if ( false === $cached ) { 
  1132.             $paged_group_ids = $wpdb->get_col( $paged_groups_sql ); 
  1133.             bp_core_set_incremented_cache( $paged_groups_sql, 'bp_groups', $paged_group_ids ); 
  1134.         } else { 
  1135.             $paged_group_ids = $cached; 
  1136.         } 
  1137.  
  1138.         $uncached_group_ids = bp_get_non_cached_ids( $paged_group_ids, 'bp_groups' ); 
  1139.         if ( $uncached_group_ids ) { 
  1140.             $group_ids_sql = implode( ', ', array_map( 'intval', $uncached_group_ids ) ); 
  1141.             $group_data_objects = $wpdb->get_results( "SELECT g.* FROM {$bp->groups->table_name} g WHERE g.id IN ({$group_ids_sql})" ); 
  1142.             foreach ( $group_data_objects as $group_data_object ) { 
  1143.                 wp_cache_set( $group_data_object->id, $group_data_object, 'bp_groups' ); 
  1144.             } 
  1145.         } 
  1146.  
  1147.         $paged_groups = array(); 
  1148.         foreach ( $paged_group_ids as $paged_group_id ) { 
  1149.             $paged_groups[] = new BP_Groups_Group( $paged_group_id ); 
  1150.         } 
  1151.  
  1152.         $total_groups_sql = "SELECT COUNT(DISTINCT g.id) FROM {$sql['from']} $where"; 
  1153.  
  1154.         /** 
  1155.          * Filters the SQL used to retrieve total group results. 
  1156.          * 
  1157.          * @since 1.5.0 
  1158.          * 
  1159.          * @param string $t_sql     Concatenated SQL statement used for retrieving total group results. 
  1160.          * @param array  $total_sql Array of SQL parts for the query. 
  1161.          * @param array  $r         Array of parsed arguments for the get method. 
  1162.          */ 
  1163.         $total_groups_sql = apply_filters( 'bp_groups_get_total_groups_sql', $total_groups_sql, $sql, $r ); 
  1164.  
  1165.         $cached = bp_core_get_incremented_cache( $total_groups_sql, 'bp_groups' ); 
  1166.         if ( false === $cached ) { 
  1167.             $total_groups = (int) $wpdb->get_var( $total_groups_sql ); 
  1168.             bp_core_set_incremented_cache( $total_groups_sql, 'bp_groups', $total_groups ); 
  1169.         } else { 
  1170.             $total_groups = (int) $cached; 
  1171.         } 
  1172.  
  1173.         $group_ids = array(); 
  1174.         foreach ( (array) $paged_groups as $group ) { 
  1175.             $group_ids[] = $group->id; 
  1176.         } 
  1177.  
  1178.         // Grab all groupmeta. 
  1179.         if ( ! empty( $r['update_meta_cache'] ) ) { 
  1180.             bp_groups_update_meta_cache( $group_ids ); 
  1181.         } 
  1182.  
  1183.         // Prefetch all administrator IDs, if requested. 
  1184.         if ( $r['update_admin_cache'] ) { 
  1185.             BP_Groups_Member::prime_group_admins_mods_cache( $group_ids ); 
  1186.         } 
  1187.  
  1188.         // Set up integer properties needing casting. 
  1189.         $int_props = array( 
  1190.             'id', 'creator_id', 'enable_forum' 
  1191.  ); 
  1192.  
  1193.         // Integer casting. 
  1194.         foreach ( $paged_groups as $key => $g ) { 
  1195.             foreach ( $int_props as $int_prop ) { 
  1196.                 $paged_groups[ $key ]->{$int_prop} = (int) $paged_groups[ $key ]->{$int_prop}; 
  1197.             } 
  1198.         } 
  1199.  
  1200.         unset( $sql, $total_sql ); 
  1201.  
  1202.         return array( 'groups' => $paged_groups, 'total' => $total_groups ); 
  1203.     } 
  1204.  
  1205.     /** 
  1206.      * Get the SQL for the 'meta_query' param in BP_Activity_Activity::get() 
  1207.      * 
  1208.      * We use WP_Meta_Query to do the heavy lifting of parsing the 
  1209.      * meta_query array and creating the necessary SQL clauses. 
  1210.      * 
  1211.      * @since 1.8.0 
  1212.      * 
  1213.      * @param array $meta_query An array of meta_query filters. See the 
  1214.      *                          documentation for {@link WP_Meta_Query} for details. 
  1215.      * @return array $sql_array 'join' and 'where' clauses. 
  1216.      */ 
  1217.     protected static function get_meta_query_sql( $meta_query = array() ) { 
  1218.         global $wpdb; 
  1219.  
  1220.         $sql_array = array( 
  1221.             'join' => '',  
  1222.             'where' => '',  
  1223.  ); 
  1224.  
  1225.         if ( ! empty( $meta_query ) ) { 
  1226.             $groups_meta_query = new WP_Meta_Query( $meta_query ); 
  1227.  
  1228.             // WP_Meta_Query expects the table name at 
  1229.             // $wpdb->group. 
  1230.             $wpdb->groupmeta = buddypress()->groups->table_name_groupmeta; 
  1231.  
  1232.             $meta_sql = $groups_meta_query->get_sql( 'group', 'g', 'id' ); 
  1233.             $sql_array['join'] = $meta_sql['join']; 
  1234.             $sql_array['where'] = self::strip_leading_and( $meta_sql['where'] ); 
  1235.         } 
  1236.  
  1237.         return $sql_array; 
  1238.     } 
  1239.  
  1240.     /** 
  1241.      * Convert the 'type' parameter to 'order' and 'orderby'. 
  1242.      * 
  1243.      * @since 1.8.0 
  1244.      * 
  1245.      * @param string $type The 'type' shorthand param. 
  1246.      * 
  1247.      * @return array { 
  1248.      *     @type string $order   SQL-friendly order string. 
  1249.      *     @type string $orderby SQL-friendly orderby column name. 
  1250.      * } 
  1251.      */ 
  1252.     protected static function convert_type_to_order_orderby( $type = '' ) { 
  1253.         $order = $orderby = ''; 
  1254.  
  1255.         switch ( $type ) { 
  1256.             case 'newest' : 
  1257.                 $order = 'DESC'; 
  1258.                 $orderby = 'date_created'; 
  1259.                 break; 
  1260.  
  1261.             case 'active' : 
  1262.                 $order = 'DESC'; 
  1263.                 $orderby = 'last_activity'; 
  1264.                 break; 
  1265.  
  1266.             case 'popular' : 
  1267.                 $order = 'DESC'; 
  1268.                 $orderby = 'total_member_count'; 
  1269.                 break; 
  1270.  
  1271.             case 'alphabetical' : 
  1272.                 $order = 'ASC'; 
  1273.                 $orderby = 'name'; 
  1274.                 break; 
  1275.  
  1276.             case 'random' : 
  1277.                 $order = ''; 
  1278.                 $orderby = 'random'; 
  1279.                 break; 
  1280.         } 
  1281.  
  1282.         return array( 'order' => $order, 'orderby' => $orderby ); 
  1283.     } 
  1284.  
  1285.     /** 
  1286.      * Get a list of groups, sorted by those that have the most legacy forum topics. 
  1287.      * 
  1288.      * @since 1.6.0 
  1289.      * 
  1290.      * @param int|null          $limit           Optional. The max number of results to return. 
  1291.      *                                           Default: null (no limit). 
  1292.      * @param int|null          $page            Optional. The page offset of results to return. 
  1293.      *                                           Default: null (no limit). 
  1294.      * @param int               $user_id         Optional. If present, groups will be limited to 
  1295.      *                                           those of which the specified user is a member. 
  1296.      * @param string|bool       $search_terms    Optional. Limit groups to those whose name 
  1297.      *                                           or description field contain the search string. 
  1298.      * @param bool              $populate_extras Optional. Whether to fetch extra 
  1299.      *                                           information about the groups. Default: true. 
  1300.      * @param string|array|bool $exclude         Optional. Array or comma-separated list of group 
  1301.      *                                           IDs to exclude from results. 
  1302.      * @return array { 
  1303.      *     @type array $groups Array of group objects returned by the 
  1304.      *                         paginated query. 
  1305.      *     @type int   $total  Total count of all groups matching non- 
  1306.      *                         paginated query params. 
  1307.      * } 
  1308.      */ 
  1309.     public static function get_by_most_forum_topics( $limit = null, $page = null, $user_id = 0, $search_terms = false, $populate_extras = true, $exclude = false ) { 
  1310.         global $wpdb, $bbdb; 
  1311.  
  1312.         if ( empty( $bbdb ) ) { 
  1313.  
  1314.             /** This action is documented in bp-forums/bp-forums-screens */ 
  1315.             do_action( 'bbpress_init' ); 
  1316.         } 
  1317.  
  1318.         if ( !empty( $limit ) && !empty( $page ) ) { 
  1319.             $pag_sql = $wpdb->prepare( " LIMIT %d, %d", intval( ( $page - 1 ) * $limit), intval( $limit ) ); 
  1320.         } 
  1321.  
  1322.         if ( !is_user_logged_in() || ( !bp_current_user_can( 'bp_moderate' ) && ( $user_id != bp_loggedin_user_id() ) ) ) 
  1323.             $hidden_sql = " AND g.status != 'hidden'"; 
  1324.  
  1325.         if ( !empty( $search_terms ) ) { 
  1326.             $search_terms_like = '%' . bp_esc_like( $search_terms ) . '%'; 
  1327.             $search_sql = $wpdb->prepare( ' AND ( g.name LIKE %s OR g.description LIKE %s ) ', $search_terms_like, $search_terms_like ); 
  1328.         } 
  1329.  
  1330.         if ( !empty( $exclude ) ) { 
  1331.             $exclude = implode( ', ', wp_parse_id_list( $exclude ) ); 
  1332.             $exclude_sql = " AND g.id NOT IN ({$exclude})"; 
  1333.         } 
  1334.  
  1335.         $bp = buddypress(); 
  1336.  
  1337.         if ( !empty( $user_id ) ) { 
  1338.             $user_id = absint( esc_sql( $user_id ) ); 
  1339.             $paged_groups = $wpdb->get_results( "SELECT DISTINCT g.*, gm1.meta_value as total_member_count, gm2.meta_value as last_activity FROM {$bp->groups->table_name_groupmeta} gm1, {$bp->groups->table_name_groupmeta} gm2, {$bp->groups->table_name_groupmeta} gm3, {$bp->groups->table_name_members} m, {$bbdb->forums} f, {$bp->groups->table_name} g WHERE g.id = m.group_id AND g.id = gm1.group_id AND g.id = gm2.group_id AND g.id = gm3.group_id AND gm2.meta_key = 'last_activity' AND gm1.meta_key = 'total_member_count' AND (gm3.meta_key = 'forum_id' AND gm3.meta_value = f.forum_id) AND f.topics > 0 {$hidden_sql} {$search_sql} AND m.user_id = {$user_id} AND m.is_confirmed = 1 AND m.is_banned = 0 {$exclude_sql} ORDER BY f.topics DESC {$pag_sql}" ); 
  1340.             $total_groups = $wpdb->get_var( "SELECT COUNT(DISTINCT g.id) FROM {$bp->groups->table_name_groupmeta} gm1, {$bp->groups->table_name_groupmeta} gm2, {$bp->groups->table_name_groupmeta} gm3, {$bbdb->forums} f, {$bp->groups->table_name} g WHERE g.id = gm1.group_id AND g.id = gm2.group_id AND g.id = gm3.group_id AND gm2.meta_key = 'last_activity' AND gm1.meta_key = 'total_member_count' AND (gm3.meta_key = 'forum_id' AND gm3.meta_value = f.forum_id) AND f.topics > 0 {$hidden_sql} {$search_sql} AND m.user_id = {$user_id} AND m.is_confirmed = 1 AND m.is_banned = 0 {$exclude_sql}" ); 
  1341.         } else { 
  1342.             $paged_groups = $wpdb->get_results( "SELECT DISTINCT g.*, gm1.meta_value as total_member_count, gm2.meta_value as last_activity FROM {$bp->groups->table_name_groupmeta} gm1, {$bp->groups->table_name_groupmeta} gm2, {$bp->groups->table_name_groupmeta} gm3, {$bbdb->forums} f, {$bp->groups->table_name} g WHERE g.id = gm1.group_id AND g.id = gm2.group_id AND g.id = gm3.group_id AND gm2.meta_key = 'last_activity' AND gm1.meta_key = 'total_member_count' AND (gm3.meta_key = 'forum_id' AND gm3.meta_value = f.forum_id) AND f.topics > 0 {$hidden_sql} {$search_sql} {$exclude_sql} ORDER BY f.topics DESC {$pag_sql}" ); 
  1343.             $total_groups = $wpdb->get_var( "SELECT COUNT(DISTINCT g.id) FROM {$bp->groups->table_name_groupmeta} gm1, {$bp->groups->table_name_groupmeta} gm2, {$bp->groups->table_name_groupmeta} gm3, {$bbdb->forums} f, {$bp->groups->table_name} g WHERE g.id = gm1.group_id AND g.id = gm2.group_id AND g.id = gm3.group_id AND gm2.meta_key = 'last_activity' AND gm1.meta_key = 'total_member_count' AND (gm3.meta_key = 'forum_id' AND gm3.meta_value = f.forum_id) AND f.topics > 0 {$hidden_sql} {$search_sql} {$exclude_sql}" ); 
  1344.         } 
  1345.  
  1346.         if ( !empty( $populate_extras ) ) { 
  1347.             foreach ( (array) $paged_groups as $group ) { 
  1348.                 $group_ids[] = $group->id; 
  1349.             } 
  1350.             $paged_groups = BP_Groups_Group::get_group_extras( $paged_groups, $group_ids, 'newest' ); 
  1351.         } 
  1352.  
  1353.         return array( 'groups' => $paged_groups, 'total' => $total_groups ); 
  1354.     } 
  1355.  
  1356.     /** 
  1357.      * Convert the 'orderby' param into a proper SQL term/column. 
  1358.      * 
  1359.      * @since 1.8.0 
  1360.      * 
  1361.      * @param string $orderby Orderby term as passed to get(). 
  1362.      * @return string $order_by_term SQL-friendly orderby term. 
  1363.      */ 
  1364.     protected static function convert_orderby_to_order_by_term( $orderby ) { 
  1365.         $order_by_term = ''; 
  1366.  
  1367.         switch ( $orderby ) { 
  1368.             case 'date_created' : 
  1369.             default : 
  1370.                 $order_by_term = 'g.date_created'; 
  1371.                 break; 
  1372.  
  1373.             case 'last_activity' : 
  1374.                 $order_by_term = 'gm_last_activity.meta_value'; 
  1375.                 break; 
  1376.  
  1377.             case 'total_member_count' : 
  1378.                 $order_by_term = 'CONVERT(gm_total_member_count.meta_value, SIGNED)'; 
  1379.                 break; 
  1380.  
  1381.             case 'name' : 
  1382.                 $order_by_term = 'g.name'; 
  1383.                 break; 
  1384.  
  1385.             case 'random' : 
  1386.                 $order_by_term = 'rand()'; 
  1387.                 break; 
  1388.         } 
  1389.  
  1390.         return $order_by_term; 
  1391.     } 
  1392.  
  1393.     /** 
  1394.      * Get a list of groups, sorted by those that have the most legacy forum posts. 
  1395.      * 
  1396.      * @since 1.6.0 
  1397.      * 
  1398.      * @param int|null          $limit           Optional. The max number of results to return. 
  1399.      *                                           Default: null (no limit). 
  1400.      * @param int|null          $page            Optional. The page offset of results to return. 
  1401.      *                                           Default: null (no limit). 
  1402.      * @param string|bool       $search_terms    Optional. Limit groups to those whose name 
  1403.      *                                           or description field contain the search string. 
  1404.      * @param bool              $populate_extras Optional. Whether to fetch extra 
  1405.      *                                           information about the groups. Default: true. 
  1406.      * @param string|array|bool $exclude         Optional. Array or comma-separated list of group 
  1407.      *                                           IDs to exclude from results. 
  1408.      * @return array { 
  1409.      *     @type array $groups Array of group objects returned by the 
  1410.      *                         paginated query. 
  1411.      *     @type int   $total  Total count of all groups matching non- 
  1412.      *                         paginated query params. 
  1413.      * } 
  1414.      */ 
  1415.     public static function get_by_most_forum_posts( $limit = null, $page = null, $search_terms = false, $populate_extras = true, $exclude = false ) { 
  1416.         global $wpdb, $bbdb; 
  1417.  
  1418.         if ( empty( $bbdb ) ) { 
  1419.  
  1420.             /** This action is documented in bp-forums/bp-forums-screens */ 
  1421.             do_action( 'bbpress_init' ); 
  1422.         } 
  1423.  
  1424.         if ( !empty( $limit ) && !empty( $page ) ) { 
  1425.             $pag_sql = $wpdb->prepare( " LIMIT %d, %d", intval( ( $page - 1 ) * $limit), intval( $limit ) ); 
  1426.         } 
  1427.  
  1428.         if ( !is_user_logged_in() || ( !bp_current_user_can( 'bp_moderate' ) && ( $user_id != bp_loggedin_user_id() ) ) ) 
  1429.             $hidden_sql = " AND g.status != 'hidden'"; 
  1430.  
  1431.         if ( !empty( $search_terms ) ) { 
  1432.             $search_terms_like = '%' . bp_esc_like( $search_terms ) . '%'; 
  1433.             $search_sql = $wpdb->prepare( ' AND ( g.name LIKE %s OR g.description LIKE %s ) ', $search_terms_like, $search_terms_like ); 
  1434.         } 
  1435.  
  1436.         if ( !empty( $exclude ) ) { 
  1437.             $exclude = implode( ', ', wp_parse_id_list( $exclude ) ); 
  1438.             $exclude_sql = " AND g.id NOT IN ({$exclude})"; 
  1439.         } 
  1440.  
  1441.         $bp = buddypress(); 
  1442.  
  1443.         if ( !empty( $user_id ) ) { 
  1444.             $user_id = esc_sql( $user_id ); 
  1445.             $paged_groups = $wpdb->get_results( "SELECT DISTINCT g.*, gm1.meta_value as total_member_count, gm2.meta_value as last_activity FROM {$bp->groups->table_name_groupmeta} gm1, {$bp->groups->table_name_groupmeta} gm2, {$bp->groups->table_name_groupmeta} gm3, {$bp->groups->table_name_members} m, {$bbdb->forums} f, {$bp->groups->table_name} g WHERE g.id = m.group_id AND g.id = gm1.group_id AND g.id = gm2.group_id AND g.id = gm3.group_id AND gm2.meta_key = 'last_activity' AND gm1.meta_key = 'total_member_count' AND (gm3.meta_key = 'forum_id' AND gm3.meta_value = f.forum_id) {$hidden_sql} {$search_sql} AND m.user_id = {$user_id} AND m.is_confirmed = 1 AND m.is_banned = 0 {$exclude_sql} ORDER BY f.posts ASC {$pag_sql}" ); 
  1446.             $total_groups = $wpdb->get_results( "SELECT COUNT(DISTINCT g.id) FROM {$bp->groups->table_name_groupmeta} gm1, {$bp->groups->table_name_groupmeta} gm2, {$bp->groups->table_name_groupmeta} gm3, {$bp->groups->table_name_members} m, {$bbdb->forums} f, {$bp->groups->table_name} g WHERE g.id = m.group_id AND g.id = gm1.group_id AND g.id = gm2.group_id AND g.id = gm3.group_id AND gm2.meta_key = 'last_activity' AND gm1.meta_key = 'total_member_count' AND (gm3.meta_key = 'forum_id' AND gm3.meta_value = f.forum_id) AND f.posts > 0 {$hidden_sql} {$search_sql} AND m.user_id = {$user_id} AND m.is_confirmed = 1 AND m.is_banned = 0 {$exclude_sql} " ); 
  1447.         } else { 
  1448.             $paged_groups = $wpdb->get_results( "SELECT DISTINCT g.*, gm1.meta_value as total_member_count, gm2.meta_value as last_activity FROM {$bp->groups->table_name_groupmeta} gm1, {$bp->groups->table_name_groupmeta} gm2, {$bp->groups->table_name_groupmeta} gm3, {$bbdb->forums} f, {$bp->groups->table_name} g WHERE g.id = gm1.group_id AND g.id = gm2.group_id AND g.id = gm3.group_id AND gm2.meta_key = 'last_activity' AND gm1.meta_key = 'total_member_count' AND (gm3.meta_key = 'forum_id' AND gm3.meta_value = f.forum_id) AND f.posts > 0 {$hidden_sql} {$search_sql} {$exclude_sql} ORDER BY f.posts ASC {$pag_sql}" ); 
  1449.             $total_groups = $wpdb->get_var( "SELECT COUNT(DISTINCT g.id) FROM {$bp->groups->table_name_groupmeta} gm1, {$bp->groups->table_name_groupmeta} gm2, {$bp->groups->table_name_groupmeta} gm3, {$bbdb->forums} f, {$bp->groups->table_name} g WHERE g.id = gm1.group_id AND g.id = gm2.group_id AND g.id = gm3.group_id AND gm2.meta_key = 'last_activity' AND gm1.meta_key = 'total_member_count' AND (gm3.meta_key = 'forum_id' AND gm3.meta_value = f.forum_id) {$hidden_sql} {$search_sql} {$exclude_sql}" ); 
  1450.         } 
  1451.  
  1452.         if ( !empty( $populate_extras ) ) { 
  1453.             foreach ( (array) $paged_groups as $group ) { 
  1454.                 $group_ids[] = $group->id; 
  1455.             } 
  1456.             $paged_groups = BP_Groups_Group::get_group_extras( $paged_groups, $group_ids, 'newest' ); 
  1457.         } 
  1458.  
  1459.         return array( 'groups' => $paged_groups, 'total' => $total_groups ); 
  1460.     } 
  1461.  
  1462.     /** 
  1463.      * Get a list of groups whose names start with a given letter. 
  1464.      * 
  1465.      * @since 1.6.0 
  1466.      * 
  1467.      * @param string            $letter          The letter. 
  1468.      * @param int|null          $limit           Optional. The max number of results to return. 
  1469.      *                                           Default: null (no limit). 
  1470.      * @param int|null          $page            Optional. The page offset of results to return. 
  1471.      *                                           Default: null (no limit). 
  1472.      * @param bool              $populate_extras Deprecated. 
  1473.      * @param string|array|bool $exclude         Optional. Array or comma-separated list of group 
  1474.      *                                           IDs to exclude from results. 
  1475.      * @return false|array { 
  1476.      *     @type array $groups Array of group objects returned by the 
  1477.      *                         paginated query. 
  1478.      *     @type int   $total  Total count of all groups matching non- 
  1479.      *                         paginated query params. 
  1480.      * } 
  1481.      */ 
  1482.     public static function get_by_letter( $letter, $limit = null, $page = null, $populate_extras = true, $exclude = false ) { 
  1483.         global $wpdb; 
  1484.  
  1485.         $pag_sql = $hidden_sql = $exclude_sql = ''; 
  1486.  
  1487.         // Multibyte compliance. 
  1488.         if ( function_exists( 'mb_strlen' ) ) { 
  1489.             if ( mb_strlen( $letter, 'UTF-8' ) > 1 || is_numeric( $letter ) || !$letter ) { 
  1490.                 return false; 
  1491.             } 
  1492.         } else { 
  1493.             if ( strlen( $letter ) > 1 || is_numeric( $letter ) || !$letter ) { 
  1494.                 return false; 
  1495.             } 
  1496.         } 
  1497.  
  1498.         $args = array( 
  1499.             'per_page' => $limit,  
  1500.             'page' => $page,  
  1501.             'search_terms' => $letter . '*',  
  1502.             'search_columns' => array( 'name' ),  
  1503.             'exclude' => $exclude,  
  1504.  ); 
  1505.  
  1506.         return BP_Groups_Group::get( $args ); 
  1507.     } 
  1508.  
  1509.     /** 
  1510.      * Get a list of random groups. 
  1511.      * 
  1512.      * Use BP_Groups_Group::get() with 'type' = 'random' instead. 
  1513.      * 
  1514.      * @since 1.6.0 
  1515.      * 
  1516.      * @param int|null          $limit           Optional. The max number of results to return. 
  1517.      *                                           Default: null (no limit). 
  1518.      * @param int|null          $page            Optional. The page offset of results to return. 
  1519.      *                                           Default: null (no limit). 
  1520.      * @param int               $user_id         Optional. If present, groups will be limited to 
  1521.      *                                           those of which the specified user is a member. 
  1522.      * @param string|bool       $search_terms    Optional. Limit groups to those whose name 
  1523.      *                                           or description field contain the search string. 
  1524.      * @param bool              $populate_extras Optional. Whether to fetch extra 
  1525.      *                                           information about the groups. Default: true. 
  1526.      * @param string|array|bool $exclude         Optional. Array or comma-separated list of group 
  1527.      *                                           IDs to exclude from results. 
  1528.      * @return array { 
  1529.      *     @type array $groups Array of group objects returned by the 
  1530.      *                         paginated query. 
  1531.      *     @type int   $total  Total count of all groups matching non- 
  1532.      *                         paginated query params. 
  1533.      * } 
  1534.      */ 
  1535.     public static function get_random( $limit = null, $page = null, $user_id = 0, $search_terms = false, $populate_extras = true, $exclude = false ) { 
  1536.         $args = array( 
  1537.             'type' => 'random',  
  1538.             'per_page' => $limit,  
  1539.             'page' => $page,  
  1540.             'user_id' => $user_id,  
  1541.             'search_terms' => $search_terms,  
  1542.             'exclude' => $exclude,  
  1543.  ); 
  1544.  
  1545.         return BP_Groups_Group::get( $args ); 
  1546.     } 
  1547.  
  1548.     /** 
  1549.      * Fetch extra data for a list of groups. 
  1550.      * 
  1551.      * This method is used throughout the class, by methods that take a 
  1552.      * $populate_extras parameter. 
  1553.      * 
  1554.      * Data fetched: 
  1555.      *     - Logged-in user's status within each group (is_member,  
  1556.      *       is_confirmed, is_pending, is_banned) 
  1557.      * 
  1558.      * @since 1.6.0 
  1559.      * 
  1560.      * @param array        $paged_groups Array of groups. 
  1561.      * @param string|array $group_ids    Array or comma-separated list of IDs matching 
  1562.      *                                   $paged_groups. 
  1563.      * @param string|bool  $type         Not used. 
  1564.      * @return array $paged_groups 
  1565.      */ 
  1566.     public static function get_group_extras( &$paged_groups, &$group_ids, $type = false ) { 
  1567.         $user_id = bp_loggedin_user_id(); 
  1568.  
  1569.         foreach ( $paged_groups as &$group ) { 
  1570.             $group->is_member = groups_is_user_member( $user_id, $group->id )  ? 1 : 0; 
  1571.             $group->is_invited = groups_is_user_invited( $user_id, $group->id ) ? 1 : 0; 
  1572.             $group->is_pending = groups_is_user_pending( $user_id, $group->id ) ? 1 : 0; 
  1573.             $group->is_banned = (bool) groups_is_user_banned( $user_id, $group->id ); 
  1574.         } 
  1575.  
  1576.         return $paged_groups; 
  1577.     } 
  1578.  
  1579.     /** 
  1580.      * Delete all invitations to a given group. 
  1581.      * 
  1582.      * @since 1.6.0 
  1583.      * 
  1584.      * @param int $group_id ID of the group whose invitations are being deleted. 
  1585.      * @return int|null Number of rows records deleted on success, null on 
  1586.      *                  failure. 
  1587.      */ 
  1588.     public static function delete_all_invites( $group_id ) { 
  1589.         global $wpdb; 
  1590.  
  1591.         $bp = buddypress(); 
  1592.  
  1593.         return $wpdb->query( $wpdb->prepare( "DELETE FROM {$bp->groups->table_name_members} WHERE group_id = %d AND invite_sent = 1", $group_id ) ); 
  1594.     } 
  1595.  
  1596.     /** 
  1597.      * Get a total group count for the site. 
  1598.      * 
  1599.      * Will include hidden groups in the count only if 
  1600.      * current_user_can( 'bp_moderate' ). 
  1601.      * 
  1602.      * @since 1.6.0 
  1603.      * 
  1604.      * @return int Group count. 
  1605.      */ 
  1606.     public static function get_total_group_count() { 
  1607.         global $wpdb; 
  1608.  
  1609.         $hidden_sql = ''; 
  1610.         if ( !bp_current_user_can( 'bp_moderate' ) ) 
  1611.             $hidden_sql = "WHERE status != 'hidden'"; 
  1612.  
  1613.         $bp = buddypress(); 
  1614.  
  1615.         return $wpdb->get_var( "SELECT COUNT(id) FROM {$bp->groups->table_name} {$hidden_sql}" ); 
  1616.     } 
  1617.  
  1618.     /** 
  1619.      * Get global count of forum topics in public groups (legacy forums). 
  1620.      * 
  1621.      * @since 1.6.0 
  1622.      * 
  1623.      * @param string $type Optional. If 'unreplied', count will be limited to 
  1624.      *                     those topics that have received no replies. 
  1625.      * @return int Forum topic count. 
  1626.      */ 
  1627.     public static function get_global_forum_topic_count( $type ) { 
  1628.         global $bbdb, $wpdb; 
  1629.  
  1630.         $bp = buddypress(); 
  1631.  
  1632.         if ( 'unreplied' == $type ) 
  1633.             $bp->groups->filter_sql = ' AND t.topic_posts = 1'; 
  1634.  
  1635.         /** 
  1636.          * Filters the portion of the SQL related to global count of forum topics in public groups. 
  1637.          * 
  1638.          * See https://buddypress.trac.wordpress.org/ticket/4306. 
  1639.          * 
  1640.          * @since 1.6.0 
  1641.          * 
  1642.          * @param string $filter_sql SQL portion for the query. 
  1643.          * @param string $type       Type of forum topics to query for. 
  1644.          */ 
  1645.         $extra_sql = apply_filters( 'get_global_forum_topic_count_extra_sql', $bp->groups->filter_sql, $type ); 
  1646.  
  1647.         // Make sure the $extra_sql begins with an AND. 
  1648.         if ( 'AND' != substr( trim( strtoupper( $extra_sql ) ), 0, 3 ) ) 
  1649.             $extra_sql = ' AND ' . $extra_sql; 
  1650.  
  1651.         return $wpdb->get_var( "SELECT COUNT(t.topic_id) FROM {$bbdb->topics} AS t, {$bp->groups->table_name} AS g LEFT JOIN {$bp->groups->table_name_groupmeta} AS gm ON g.id = gm.group_id WHERE (gm.meta_key = 'forum_id' AND gm.meta_value = t.forum_id) AND g.status = 'public' AND t.topic_status = '0' AND t.topic_sticky != '2' {$extra_sql} " ); 
  1652.     } 
  1653.  
  1654.     /** 
  1655.      * Get the member count for a group. 
  1656.      * 
  1657.      * @since 1.6.0 
  1658.      * 
  1659.      * @param int $group_id Group ID. 
  1660.      * @return int Count of confirmed members for the group. 
  1661.      */ 
  1662.     public static function get_total_member_count( $group_id ) { 
  1663.         global $wpdb; 
  1664.  
  1665.         $bp = buddypress(); 
  1666.  
  1667.         return $wpdb->get_var( $wpdb->prepare( "SELECT COUNT(id) FROM {$bp->groups->table_name_members} WHERE group_id = %d AND is_confirmed = 1 AND is_banned = 0", $group_id ) ); 
  1668.     } 
  1669.  
  1670.     /** 
  1671.      * Get a total count of all topics of a given status, across groups/forums. 
  1672.      * 
  1673.      * @since 1.5.0 
  1674.      * 
  1675.      * @param string      $status       Which group type to count. 'public', 'private',  
  1676.      *                                  'hidden', or 'all'. Default: 'public'. 
  1677.      * @param string|bool $search_terms Provided search terms. 
  1678.      * @return int The topic count 
  1679.      */ 
  1680.     public static function get_global_topic_count( $status = 'public', $search_terms = false ) { 
  1681.         global $bbdb, $wpdb; 
  1682.  
  1683.         switch ( $status ) { 
  1684.             case 'all' : 
  1685.                 $status_sql = ''; 
  1686.                 break; 
  1687.  
  1688.             case 'hidden' : 
  1689.                 $status_sql = "AND g.status = 'hidden'"; 
  1690.                 break; 
  1691.  
  1692.             case 'private' : 
  1693.                 $status_sql = "AND g.status = 'private'"; 
  1694.                 break; 
  1695.  
  1696.             case 'public' : 
  1697.             default : 
  1698.                 $status_sql = "AND g.status = 'public'"; 
  1699.                 break; 
  1700.         } 
  1701.  
  1702.         $bp = buddypress(); 
  1703.  
  1704.         $sql = array(); 
  1705.  
  1706.         $sql['select'] = "SELECT COUNT(t.topic_id)"; 
  1707.         $sql['from'] = "FROM {$bbdb->topics} AS t INNER JOIN {$bp->groups->table_name_groupmeta} AS gm ON t.forum_id = gm.meta_value INNER JOIN {$bp->groups->table_name} AS g ON gm.group_id = g.id"; 
  1708.         $sql['where'] = "WHERE gm.meta_key = 'forum_id' {$status_sql} AND t.topic_status = '0' AND t.topic_sticky != '2'"; 
  1709.  
  1710.         if ( !empty( $search_terms ) ) { 
  1711.             $search_terms_like = '%' . bp_esc_like( $search_terms ) . '%'; 
  1712.             $sql['where'] .= $wpdb->prepare( " AND ( t.topic_title LIKE %s )", $search_terms_like ); 
  1713.         } 
  1714.  
  1715.         return $wpdb->get_var( implode( ' ', $sql ) ); 
  1716.     } 
  1717.  
  1718.     /** 
  1719.      * Get an array containing ids for each group type. 
  1720.      * 
  1721.      * A bit of a kludge workaround for some issues 
  1722.      * with bp_has_groups(). 
  1723.      * 
  1724.      * @since 1.7.0 
  1725.      * 
  1726.      * @return array 
  1727.      */ 
  1728.     public static function get_group_type_ids() { 
  1729.         global $wpdb; 
  1730.  
  1731.         $bp = buddypress(); 
  1732.         $ids = array(); 
  1733.  
  1734.         $ids['all'] = $wpdb->get_col( "SELECT id FROM {$bp->groups->table_name}" ); 
  1735.         $ids['public'] = $wpdb->get_col( "SELECT id FROM {$bp->groups->table_name} WHERE status = 'public'" ); 
  1736.         $ids['private'] = $wpdb->get_col( "SELECT id FROM {$bp->groups->table_name} WHERE status = 'private'" ); 
  1737.         $ids['hidden'] = $wpdb->get_col( "SELECT id FROM {$bp->groups->table_name} WHERE status = 'hidden'" ); 
  1738.  
  1739.         return $ids; 
  1740.     } 
  1741.  
  1742.     /** 
  1743.      * Get SQL clause for group type(s). 
  1744.      * 
  1745.      * @since 2.6.0 
  1746.      * 
  1747.      * @param  string|array $group_types Group type(s). 
  1748.      * @param  string       $operator    'IN' or 'NOT IN'. 
  1749.      * @return string       $clause      SQL clause. 
  1750.      */ 
  1751.     protected static function get_sql_clause_for_group_types( $group_types, $operator ) { 
  1752.         global $wpdb; 
  1753.  
  1754.         // Sanitize operator. 
  1755.         if ( 'NOT IN' !== $operator ) { 
  1756.             $operator = 'IN'; 
  1757.         } 
  1758.  
  1759.         // Parse and sanitize types. 
  1760.         if ( ! is_array( $group_types ) ) { 
  1761.             $group_types = preg_split( '/[, \s+]/', $group_types ); 
  1762.         } 
  1763.  
  1764.         $types = array(); 
  1765.         foreach ( $group_types as $gt ) { 
  1766.             if ( bp_groups_get_group_type_object( $gt ) ) { 
  1767.                 $types[] = $gt; 
  1768.             } 
  1769.         } 
  1770.  
  1771.         $tax_query = new WP_Tax_Query( array( 
  1772.             array( 
  1773.                 'taxonomy' => 'bp_group_type',  
  1774.                 'field' => 'name',  
  1775.                 'operator' => $operator,  
  1776.                 'terms' => $types,  
  1777.  ),  
  1778.  ) ); 
  1779.  
  1780.         $site_id = bp_get_taxonomy_term_site_id( 'bp_group_type' ); 
  1781.         $switched = false; 
  1782.         if ( $site_id !== get_current_blog_id() ) { 
  1783.             switch_to_blog( $site_id ); 
  1784.             $switched = true; 
  1785.         } 
  1786.  
  1787.         $sql_clauses = $tax_query->get_sql( 'g', 'id' ); 
  1788.  
  1789.         $clause = ''; 
  1790.  
  1791.         // The no_results clauses are the same between IN and NOT IN. 
  1792.         if ( false !== strpos( $sql_clauses['where'], '0 = 1' ) ) { 
  1793.             $clause = self::strip_leading_and( $sql_clauses['where'] ); 
  1794.  
  1795.         // The tax_query clause generated for NOT IN can be used almost as-is. 
  1796.         } elseif ( 'NOT IN' === $operator ) { 
  1797.             $clause = self::strip_leading_and( $sql_clauses['where'] ); 
  1798.  
  1799.         // IN clauses must be converted to a subquery. 
  1800.         } elseif ( preg_match( '/' . $wpdb->term_relationships . '\.term_taxonomy_id IN \([0-9, ]+\)/', $sql_clauses['where'], $matches ) ) { 
  1801.             $clause = " g.id IN ( SELECT object_id FROM $wpdb->term_relationships WHERE {$matches[0]} )"; 
  1802.         } 
  1803.  
  1804.         if ( $switched ) { 
  1805.             restore_current_blog(); 
  1806.         } 
  1807.  
  1808.         return $clause; 
  1809.     } 
  1810.  
  1811.     /** 
  1812.      * Strips the leading AND and any surrounding whitespace from a string. 
  1813.      * 
  1814.      * Used here to normalize SQL fragments generated by `WP_Meta_Query` and 
  1815.      * other utility classes. 
  1816.      * 
  1817.      * @since 2.7.0 
  1818.      * 
  1819.      * @param string $s String. 
  1820.      * @return string 
  1821.      */ 
  1822.     protected static function strip_leading_and( $s ) { 
  1823.         return preg_replace( '/^\s*AND\s*/', '', $s ); 
  1824.     } 
  1825. }