[ 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              'meta_query'         => false,
 175              'update_meta_cache'  => true,
 176              'update_admin_cache' => false,
 177          );
 178  
 179          $r = bp_parse_args( $args, $defaults, 'groups_template' );
 180          extract( $r );
 181  
 182          $this->pag_arg  = sanitize_key( $r['page_arg'] );
 183          $this->pag_page = bp_sanitize_pagination_arg( $this->pag_arg, $r['page']     );
 184          $this->pag_num  = bp_sanitize_pagination_arg( 'num',          $r['per_page'] );
 185  
 186          if ( bp_current_user_can( 'bp_moderate' ) || ( is_user_logged_in() && $user_id == bp_loggedin_user_id() ) ) {
 187              $show_hidden = true;
 188          }
 189  
 190          if ( 'invites' == $type ) {
 191              $this->groups = groups_get_invites_for_user( $user_id, $this->pag_num, $this->pag_page, $exclude );
 192          } elseif ( 'single-group' == $type ) {
 193              $this->single_group = true;
 194  
 195              if ( groups_get_current_group() ) {
 196                  $group = groups_get_current_group();
 197  
 198              } else {
 199                  $group = groups_get_group( BP_Groups_Group::get_id_from_slug( $r['slug'] ) );
 200              }
 201  
 202              // Backwards compatibility - the 'group_id' variable is not part of the
 203              // BP_Groups_Group object, but we add it here for devs doing checks against it
 204              //
 205              // @see https://buddypress.trac.wordpress.org/changeset/3540
 206              //
 207              // this is subject to removal in a future release; devs should check against
 208              // $group->id instead.
 209              $group->group_id = $group->id;
 210  
 211              $this->groups = array( $group );
 212  
 213          } else {
 214              $this->groups = groups_get_groups( array(
 215                  'type'               => $type,
 216                  'order'              => $order,
 217                  'orderby'            => $orderby,
 218                  'per_page'           => $this->pag_num,
 219                  'page'               => $this->pag_page,
 220                  'user_id'            => $user_id,
 221                  'search_terms'       => $search_terms,
 222                  'search_columns'     => $search_columns,
 223                  'meta_query'         => $meta_query,
 224                  'group_type'         => $group_type,
 225                  'group_type__in'     => $group_type__in,
 226                  'group_type__not_in' => $group_type__not_in,
 227                  'include'            => $include,
 228                  'exclude'            => $exclude,
 229                  'parent_id'          => $parent_id,
 230                  'update_meta_cache'  => $update_meta_cache,
 231                  'update_admin_cache' => $update_admin_cache,
 232                  'show_hidden'        => $show_hidden,
 233              ) );
 234          }
 235  
 236          if ( 'invites' == $type ) {
 237              $this->total_group_count = (int) $this->groups['total'];
 238              $this->group_count       = (int) $this->groups['total'];
 239              $this->groups            = $this->groups['groups'];
 240          } elseif ( 'single-group' == $type ) {
 241              if ( empty( $group->id ) ) {
 242                  $this->total_group_count = 0;
 243                  $this->group_count       = 0;
 244              } else {
 245                  $this->total_group_count = 1;
 246                  $this->group_count       = 1;
 247              }
 248          } else {
 249              if ( empty( $max ) || $max >= (int) $this->groups['total'] ) {
 250                  $this->total_group_count = (int) $this->groups['total'];
 251              } else {
 252                  $this->total_group_count = (int) $max;
 253              }
 254  
 255              $this->groups = $this->groups['groups'];
 256  
 257              if ( !empty( $max ) ) {
 258                  if ( $max >= count( $this->groups ) ) {
 259                      $this->group_count = count( $this->groups );
 260                  } else {
 261                      $this->group_count = (int) $max;
 262                  }
 263              } else {
 264                  $this->group_count = count( $this->groups );
 265              }
 266          }
 267  
 268          // Build pagination links.
 269          if ( (int) $this->total_group_count && (int) $this->pag_num ) {
 270              $pag_args = array(
 271                  $this->pag_arg => '%#%'
 272              );
 273  
 274              if ( defined( 'DOING_AJAX' ) && true === (bool) DOING_AJAX ) {
 275                  $base = remove_query_arg( 's', wp_get_referer() );
 276              } else {
 277                  $base = '';
 278              }
 279  
 280              $add_args = array(
 281                  'num'     => $this->pag_num,
 282                  'sortby'  => $this->sort_by,
 283                  'order'   => $this->order,
 284              );
 285  
 286              if ( ! empty( $search_terms ) ) {
 287                  $query_arg = bp_core_get_component_search_query_arg( 'groups' );
 288                  $add_args[ $query_arg ] = urlencode( $search_terms );
 289              }
 290  
 291              $this->pag_links = paginate_links( array(
 292                  'base'      => add_query_arg( $pag_args, $base ),
 293                  'format'    => '',
 294                  'total'     => ceil( (int) $this->total_group_count / (int) $this->pag_num ),
 295                  'current'   => $this->pag_page,
 296                  'prev_text' => _x( '&larr;', 'Group pagination previous text', 'buddypress' ),
 297                  'next_text' => _x( '&rarr;', 'Group pagination next text', 'buddypress' ),
 298                  'mid_size'  => 1,
 299                  'add_args'  => $add_args,
 300              ) );
 301          }
 302      }
 303  
 304      /**
 305       * Whether there are groups available in the loop.
 306       *
 307       * @since 1.2.0
 308       *
 309       * @see bp_has_groups()
 310       *
 311       * @return bool True if there are items in the loop, otherwise false.
 312       */
 313  	function has_groups() {
 314          if ( $this->group_count ) {
 315              return true;
 316          }
 317  
 318          return false;
 319      }
 320  
 321      /**
 322       * Set up the next group and iterate index.
 323       *
 324       * @since 1.2.0
 325       *
 326       * @return object The next group to iterate over.
 327       */
 328  	function next_group() {
 329          $this->current_group++;
 330          $this->group = $this->groups[$this->current_group];
 331  
 332          return $this->group;
 333      }
 334  
 335      /**
 336       * Rewind the groups and reset member index.
 337       *
 338       * @since 1.2.0
 339       */
 340  	function rewind_groups() {
 341          $this->current_group = -1;
 342          if ( $this->group_count > 0 ) {
 343              $this->group = $this->groups[0];
 344          }
 345      }
 346  
 347      /**
 348       * Whether there are groups left in the loop to iterate over.
 349       *
 350       * This method is used by {@link bp_groups()} as part of the while loop
 351       * that controls iteration inside the groups loop, eg:
 352       *     while ( bp_groups() ) { ...
 353       *
 354       * @since 1.2.0
 355       *
 356       * @see bp_groups()
 357       *
 358       * @return bool True if there are more groups to show, otherwise false.
 359       */
 360  	function groups() {
 361          if ( $this->current_group + 1 < $this->group_count ) {
 362              return true;
 363          } elseif ( $this->current_group + 1 == $this->group_count ) {
 364  
 365              /**
 366               * Fires right before the rewinding of groups list.
 367               *
 368               * @since 1.5.0
 369               */
 370              do_action('group_loop_end');
 371              // Do some cleaning up after the loop.
 372              $this->rewind_groups();
 373          }
 374  
 375          $this->in_the_loop = false;
 376          return false;
 377      }
 378  
 379      /**
 380       * Set up the current group inside the loop.
 381       *
 382       * Used by {@link bp_the_group()} to set up the current group data
 383       * while looping, so that template tags used during that iteration make
 384       * reference to the current member.
 385       *
 386       * @since 1.2.0
 387       *
 388       * @see bp_the_group()
 389       */
 390  	function the_group() {
 391          $this->in_the_loop = true;
 392          $this->group       = $this->next_group();
 393  
 394          if ( 0 == $this->current_group ) {
 395  
 396              /**
 397               * Fires if the current group item is the first in the loop.
 398               *
 399               * @since 1.1.0
 400               */
 401              do_action( 'group_loop_start' );
 402          }
 403      }
 404  }


Generated: Mon Dec 9 01:01:38 2019 Cross-referenced by PHPXref 0.7.1