[ Index ]

PHP Cross Reference of BuddyPress

title

Body

[close]

/src/bp-groups/classes/ -> class-bp-groups-template.php (source)

   1  <?php
   2  /**
   3   * BuddyPress Groups Template loop class.
   4   *
   5   * @package BuddyPress
   6   * @since 1.2.0
   7   */
   8  
   9  // Exit if accessed directly.
  10  defined( 'ABSPATH' ) || exit;
  11  
  12  /**
  13   * The main Groups template loop class.
  14   *
  15   * Responsible for loading a group of groups into a loop for display.
  16   *
  17   * @since 1.2.0
  18   */
  19  class BP_Groups_Template {
  20  
  21      /**
  22       * The loop iterator.
  23       *
  24       * @var int
  25       * @since 1.2.0
  26       */
  27      public $current_group = -1;
  28  
  29      /**
  30       * The number of groups returned by the paged query.
  31       *
  32       * @var int
  33       * @since 1.2.0
  34       */
  35      public $group_count;
  36  
  37      /**
  38       * Array of groups located by the query.
  39       *
  40       * @var array
  41       * @since 1.2.0
  42       */
  43      public $groups;
  44  
  45      /**
  46       * The group object currently being iterated on.
  47       *
  48       * @var object
  49       * @since 1.2.0
  50       */
  51      public $group;
  52  
  53      /**
  54       * A flag for whether the loop is currently being iterated.
  55       *
  56       * @var bool
  57       * @since 1.2.0
  58       */
  59      public $in_the_loop;
  60  
  61      /**
  62       * The page number being requested.
  63       *
  64       * @var string
  65       * @since 1.2.0
  66       */
  67      public $pag_page;
  68  
  69      /**
  70       * The number of items being requested per page.
  71       *
  72       * @var string
  73       * @since 1.2.0
  74       */
  75      public $pag_num;
  76  
  77      /**
  78       * An HTML string containing pagination links.
  79       *
  80       * @var string
  81       * @since 1.2.0
  82       */
  83      public $pag_links;
  84  
  85      /**
  86       * The total number of groups matching the query parameters.
  87       *
  88       * @var int
  89       * @since 1.2.0
  90       */
  91      public $total_group_count;
  92  
  93      /**
  94       * Whether the template loop is for a single group page.
  95       *
  96       * @var bool
  97       * @since 1.2.0
  98       */
  99      public $single_group = false;
 100  
 101      /**
 102       * Field to sort by.
 103       *
 104       * @var string
 105       * @since 1.2.0
 106       */
 107      public $sort_by;
 108  
 109      /**
 110       * Sort order.
 111       *
 112       * @var string
 113       * @since 1.2.0
 114       */
 115      public $order;
 116  
 117      /**
 118       * Constructor method.
 119       *
 120       * @see BP_Groups_Group::get() for an in-depth description of arguments.
 121       *
 122       * @param array $args {
 123       *     Array of arguments. Accepts all arguments accepted by
 124       *     {@link BP_Groups_Group::get()}. In cases where the default
 125       *     values of the params differ, they have been discussed below.
 126       *     @type int $per_page Default: 20.
 127       *     @type int $page Default: 1.
 128       * }
 129       */
 130  	function __construct( $args = array() ){
 131          $function_args = func_get_args();
 132  
 133          // Backward compatibility with old method of passing arguments.
 134          if ( ! is_array( $args ) || count( $function_args ) > 1 ) {
 135              _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__ ) );
 136  
 137              $old_args_keys = array(
 138                  0  => 'user_id',
 139                  1  => 'type',
 140                  2  => 'page',
 141                  3  => 'per_page',
 142                  4  => 'max',
 143                  5  => 'slug',
 144                  6  => 'search_terms',
 145                  7  => 'populate_extras',
 146                  8  => 'include',
 147                  9  => 'exclude',
 148                  10 => 'show_hidden',
 149                  11 => 'page_arg',
 150              );
 151  
 152              $args = bp_core_parse_args_array( $old_args_keys, $function_args );
 153          }
 154  
 155          $defaults = array(
 156              'page'               => 1,
 157              'per_page'           => 20,
 158              'page_arg'           => 'grpage',
 159              'max'                => false,
 160              'type'               => 'active',
 161              'order'              => 'DESC',
 162              'orderby'            => 'date_created',
 163              'show_hidden'        => false,
 164              'user_id'            => 0,
 165              'slug'               => false,
 166              'include'            => false,
 167              'exclude'            => false,
 168              'parent_id'          => null,
 169              'search_terms'       => '',
 170              'search_columns'     => array(),
 171              'group_type'         => '',
 172              'group_type__in'     => '',
 173              'group_type__not_in' => '',
 174              'status'             => array(),
 175              'meta_query'         => false,
 176              'update_meta_cache'  => true,
 177              'update_admin_cache' => false,
 178          );
 179  
 180          $r = bp_parse_args( $args, $defaults, 'groups_template' );
 181          extract( $r );
 182  
 183          $this->pag_arg  = sanitize_key( $r['page_arg'] );
 184          $this->pag_page = bp_sanitize_pagination_arg( $this->pag_arg, $r['page']     );
 185          $this->pag_num  = bp_sanitize_pagination_arg( 'num',          $r['per_page'] );
 186  
 187          if ( bp_current_user_can( 'bp_moderate' ) || ( is_user_logged_in() && $user_id == bp_loggedin_user_id() ) ) {
 188              $show_hidden = true;
 189          }
 190  
 191          if ( 'invites' == $type ) {
 192              $this->groups = groups_get_invites_for_user( $user_id, $this->pag_num, $this->pag_page, $exclude );
 193          } elseif ( 'single-group' == $type ) {
 194              $this->single_group = true;
 195  
 196              if ( groups_get_current_group() ) {
 197                  $group = groups_get_current_group();
 198  
 199              } else {
 200                  $group = groups_get_group( BP_Groups_Group::get_id_from_slug( $r['slug'] ) );
 201              }
 202  
 203              // Backwards compatibility - the 'group_id' variable is not part of the
 204              // BP_Groups_Group object, but we add it here for devs doing checks against it
 205              //
 206              // @see https://buddypress.trac.wordpress.org/changeset/3540
 207              //
 208              // this is subject to removal in a future release; devs should check against
 209              // $group->id instead.
 210              $group->group_id = $group->id;
 211  
 212              $this->groups = array( $group );
 213  
 214          } else {
 215              $this->groups = groups_get_groups( array(
 216                  'type'               => $type,
 217                  'order'              => $order,
 218                  'orderby'            => $orderby,
 219                  'per_page'           => $this->pag_num,
 220                  'page'               => $this->pag_page,
 221                  'user_id'            => $user_id,
 222                  'search_terms'       => $search_terms,
 223                  'search_columns'     => $search_columns,
 224                  'meta_query'         => $meta_query,
 225                  'group_type'         => $group_type,
 226                  'group_type__in'     => $group_type__in,
 227                  'group_type__not_in' => $group_type__not_in,
 228                  'status'             => $status,
 229                  'include'            => $include,
 230                  'exclude'            => $exclude,
 231                  'parent_id'          => $parent_id,
 232                  'update_meta_cache'  => $update_meta_cache,
 233                  'update_admin_cache' => $update_admin_cache,
 234                  'show_hidden'        => $show_hidden,
 235              ) );
 236          }
 237  
 238          if ( 'invites' == $type ) {
 239              $this->total_group_count = (int) $this->groups['total'];
 240              $this->group_count       = (int) $this->groups['total'];
 241              $this->groups            = $this->groups['groups'];
 242          } elseif ( 'single-group' == $type ) {
 243              if ( empty( $group->id ) ) {
 244                  $this->total_group_count = 0;
 245                  $this->group_count       = 0;
 246              } else {
 247                  $this->total_group_count = 1;
 248                  $this->group_count       = 1;
 249              }
 250          } else {
 251              if ( empty( $max ) || $max >= (int) $this->groups['total'] ) {
 252                  $this->total_group_count = (int) $this->groups['total'];
 253              } else {
 254                  $this->total_group_count = (int) $max;
 255              }
 256  
 257              $this->groups = $this->groups['groups'];
 258  
 259              if ( !empty( $max ) ) {
 260                  if ( $max >= count( $this->groups ) ) {
 261                      $this->group_count = count( $this->groups );
 262                  } else {
 263                      $this->group_count = (int) $max;
 264                  }
 265              } else {
 266                  $this->group_count = count( $this->groups );
 267              }
 268          }
 269  
 270          // Build pagination links.
 271          if ( (int) $this->total_group_count && (int) $this->pag_num ) {
 272              $pag_args = array(
 273                  $this->pag_arg => '%#%'
 274              );
 275  
 276              if ( defined( 'DOING_AJAX' ) && true === (bool) DOING_AJAX ) {
 277                  $base = remove_query_arg( 's', wp_get_referer() );
 278              } else {
 279                  $base = '';
 280              }
 281  
 282              $add_args = array(
 283                  'num'     => $this->pag_num,
 284                  'sortby'  => $this->sort_by,
 285                  'order'   => $this->order,
 286              );
 287  
 288              if ( ! empty( $search_terms ) ) {
 289                  $query_arg = bp_core_get_component_search_query_arg( 'groups' );
 290                  $add_args[ $query_arg ] = urlencode( $search_terms );
 291              }
 292  
 293              $this->pag_links = paginate_links( array(
 294                  'base'      => add_query_arg( $pag_args, $base ),
 295                  'format'    => '',
 296                  'total'     => ceil( (int) $this->total_group_count / (int) $this->pag_num ),
 297                  'current'   => $this->pag_page,
 298                  'prev_text' => _x( '&larr;', 'Group pagination previous text', 'buddypress' ),
 299                  'next_text' => _x( '&rarr;', 'Group pagination next text', 'buddypress' ),
 300                  'mid_size'  => 1,
 301                  'add_args'  => $add_args,
 302              ) );
 303          }
 304      }
 305  
 306      /**
 307       * Whether there are groups available in the loop.
 308       *
 309       * @since 1.2.0
 310       *
 311       * @see bp_has_groups()
 312       *
 313       * @return bool True if there are items in the loop, otherwise false.
 314       */
 315  	function has_groups() {
 316          if ( $this->group_count ) {
 317              return true;
 318          }
 319  
 320          return false;
 321      }
 322  
 323      /**
 324       * Set up the next group and iterate index.
 325       *
 326       * @since 1.2.0
 327       *
 328       * @return object The next group to iterate over.
 329       */
 330  	function next_group() {
 331          $this->current_group++;
 332          $this->group = $this->groups[$this->current_group];
 333  
 334          return $this->group;
 335      }
 336  
 337      /**
 338       * Rewind the groups and reset member index.
 339       *
 340       * @since 1.2.0
 341       */
 342  	function rewind_groups() {
 343          $this->current_group = -1;
 344          if ( $this->group_count > 0 ) {
 345              $this->group = $this->groups[0];
 346          }
 347      }
 348  
 349      /**
 350       * Whether there are groups left in the loop to iterate over.
 351       *
 352       * This method is used by {@link bp_groups()} as part of the while loop
 353       * that controls iteration inside the groups loop, eg:
 354       *     while ( bp_groups() ) { ...
 355       *
 356       * @since 1.2.0
 357       *
 358       * @see bp_groups()
 359       *
 360       * @return bool True if there are more groups to show, otherwise false.
 361       */
 362  	function groups() {
 363          if ( $this->current_group + 1 < $this->group_count ) {
 364              return true;
 365          } elseif ( $this->current_group + 1 == $this->group_count ) {
 366  
 367              /**
 368               * Fires right before the rewinding of groups list.
 369               *
 370               * @since 1.5.0
 371               */
 372              do_action('group_loop_end');
 373              // Do some cleaning up after the loop.
 374              $this->rewind_groups();
 375          }
 376  
 377          $this->in_the_loop = false;
 378          return false;
 379      }
 380  
 381      /**
 382       * Set up the current group inside the loop.
 383       *
 384       * Used by {@link bp_the_group()} to set up the current group data
 385       * while looping, so that template tags used during that iteration make
 386       * reference to the current member.
 387       *
 388       * @since 1.2.0
 389       *
 390       * @see bp_the_group()
 391       */
 392  	function the_group() {
 393          $this->in_the_loop = true;
 394          $this->group       = $this->next_group();
 395  
 396          if ( 0 == $this->current_group ) {
 397  
 398              /**
 399               * Fires if the current group item is the first in the loop.
 400               *
 401               * @since 1.1.0
 402               */
 403              do_action( 'group_loop_start' );
 404          }
 405      }
 406  }


Generated: Sat Nov 28 01:01:39 2020 Cross-referenced by PHPXref 0.7.1