Skip to:
Content

BuddyPress.org

Ticket #4785: 4785.04.patch

File 4785.04.patch, 32.7 KB (added by boonebgorges, 7 years ago)
  • src/bp-groups/bp-groups-actions.php

    diff --git src/bp-groups/bp-groups-actions.php src/bp-groups/bp-groups-actions.php
    index 2a0ea8b..1b06d0d 100644
     
    1515if ( !defined( 'ABSPATH' ) ) exit;
    1616
    1717/**
     18 * Protect access to single groups.
     19 *
     20 * @since BuddyPress (2.1.0)
     21 */
     22function bp_groups_group_access_protection() {
     23        if ( ! bp_is_group() ) {
     24                return;
     25        }
     26
     27        $current_group   = groups_get_current_group();
     28        $user_has_access = $current_group->user_has_access;
     29        $no_access_args  = array();
     30
     31        if ( ! $user_has_access && 'hidden' !== $current_group->status ) {
     32                // Always allow access to home and request-membership
     33                if ( bp_is_current_action( 'home' ) || bp_is_current_action( 'request-membership' ) ) {
     34                        $user_has_access = true;
     35
     36                // User doesn't have access, so set up redirect args
     37                } else {
     38                        if ( is_user_logged_in() ) {
     39                                $no_access_args = array(
     40                                        'message'  => __( 'You do not have access to this group.', 'buddypress' ),
     41                                        'root'     => bp_get_group_permalink( $current_group ) . 'home/',
     42                                        'redirect' => false
     43                                );
     44                        }
     45                }
     46        }
     47
     48        // Protect the admin tab from non-admins
     49        if ( bp_is_current_action( 'admin' ) && ! bp_is_item_admin() ) {
     50                $user_has_access = false;
     51                $no_access_args  = array(
     52                        'message'  => __( 'You are not an admin of this group.', 'buddypress' ),
     53                        'root'     => bp_get_group_permalink( $current_group ),
     54                        'redirect' => false
     55                );
     56        }
     57
     58        // Send the current value off to be filtered based on plugin-specific settings
     59        $user_has_access = apply_filters_ref_array( 'bp_group_user_has_access', array( $user_has_access, &$no_access_args ) );
     60
     61        // If user has access, we return rather than redirect
     62        if ( $user_has_access ) {
     63                return;
     64        }
     65
     66        // Hidden groups should return a 404 for non-members.
     67        // Unset the current group so that you're not redirected
     68        // to the default group tab
     69        if ( 'hidden' == $current_group->status ) {
     70                buddypress()->groups->current_group = 0;
     71                buddypress()->is_single_item        = false;
     72                bp_do_404();
     73                return;
     74        } else {
     75                bp_core_no_access( $no_access_args );
     76        }
     77
     78}
     79add_action( 'bp_actions', 'bp_groups_group_access_protection' );
     80
     81/**
    1882 * Catch and process group creation form submissions.
    1983 */
    2084function groups_action_create_group() {
  • src/bp-groups/bp-groups-classes.php

    diff --git src/bp-groups/bp-groups-classes.php src/bp-groups/bp-groups-classes.php
    index db67026..7507e79 100644
    class BP_Group_Extension { 
    28742874        public $params = array();
    28752875
    28762876        /**
     2877         * Raw config params, as passed by the extending class.
     2878         *
     2879         * @since BuddyPress (2.1.0)
     2880         * @var array
     2881         */
     2882        public $params_raw = array();
     2883
     2884        /**
    28772885         * The ID of the current group.
    28782886         *
    28792887         * @since BuddyPress (1.8.0)
    class BP_Group_Extension { 
    29172925        public $enable_nav_item = true;
    29182926
    29192927        /**
     2928         * Whether the current user should see the navigation item.
     2929         *
     2930         * @since BuddyPress (2.1.0)
     2931         * @var bool
     2932         */
     2933        public $user_can_see_nav_item;
     2934
     2935        /**
     2936         * Whether the current user can visit the tab.
     2937         *
     2938         * @since BuddyPress (2.1.0)
     2939         * @var bool
     2940         */
     2941        public $user_can_visit;
     2942
     2943        /**
    29202944         * The text of the nav item. Defaults to self::name.
    29212945         *
    29222946         * @var string
    class BP_Group_Extension { 
    30543078         * }
    30553079         */
    30563080        public function init( $args = array() ) {
     3081                // Store the raw arguments
     3082                $this->params_raw = $args;
    30573083
    30583084                // Before this init() method was introduced, plugins were
    30593085                // encouraged to set their config directly. For backward
    class BP_Group_Extension { 
    30743100                        'display_hook'      => $this->display_hook,
    30753101                        'template_file'     => $this->template_file,
    30763102                        'screens'           => $this->get_default_screens(),
     3103                        'access'            => null,
     3104                        'show_tab'          => null,
    30773105                ) );
    30783106
    30793107                $this->initialized = true;
    class BP_Group_Extension { 
    31173145                // Configure 'screens': create, admin, and edit contexts
    31183146                $this->setup_screens();
    31193147
     3148                // Configure access-related settings
     3149                $this->setup_access_settings();
     3150
    31203151                // Mirror configuration data so it's accessible to plugins
    31213152                // that look for it in its old locations
    31223153                $this->setup_legacy_properties();
    class BP_Group_Extension { 
    32353266                }
    32363267        }
    32373268
     3269        /**
     3270         * Set up access-related settings for this extension.
     3271         *
     3272         * @since BuddyPress (2.1.0)
     3273         */
     3274        protected function setup_access_settings() {
     3275                // Backward compatibility
     3276                if ( isset( $this->params['enable_nav_item'] ) ) {
     3277                        $this->enable_nav_item = (bool) $this->params['enable_nav_item'];
     3278                }
     3279
     3280                // Tab Access
     3281                $this->user_can_visit = false;
     3282
     3283                // Backward compatibility for components that do not provide
     3284                // explicit 'access' parameter
     3285                if ( empty( $this->params['access'] ) ) {
     3286                        if ( false === $this->enable_nav_item ) {
     3287                                $this->params['access'] = 'noone';
     3288                        } else {
     3289                                $group = groups_get_group( array(
     3290                                        'group_id' => $this->group_id,
     3291                                ) );
     3292
     3293                                if ( ! empty( $group->status ) && 'public' === $group->status ) {
     3294                                        // Tabs in public groups are accessible to anyone by default
     3295                                        $this->params['access'] = 'anyone';
     3296                                } else {
     3297                                        // All other groups have members-only as the default
     3298                                        $this->params['access'] = 'member';
     3299                                }
     3300                        }
     3301                }
     3302
     3303                // Parse multiple access conditions into an array
     3304                $access_conditions = $this->params['access'];
     3305                if ( ! is_array( $access_conditions ) ) {
     3306                        $access_conditions = explode( ',', $access_conditions );
     3307                }
     3308
     3309                // If the current user meets at least one condition, the
     3310                // get access
     3311                foreach ( $access_conditions as $access_condition ) {
     3312                        if ( $this->user_meets_access_condition( $access_condition ) ) {
     3313                                $this->user_can_visit = true;
     3314                                break;
     3315                        }
     3316                }
     3317
     3318                // Tab Visibility
     3319                $this->user_can_see_nav_item = false;
     3320
     3321                // Backward compatibility for components that do not provide
     3322                // explicit 'show_tab' parameter
     3323                if ( empty( $this->params['show_tab'] ) ) {
     3324                        if ( false === $this->params['enable_nav_item'] ) {
     3325                                // enable_nav_item is only false if it's been
     3326                                // defined explicitly as such in the
     3327                                // constructor. So we always trust this value
     3328                                $this->params['show_tab'] = 'noone';
     3329
     3330                        } else if ( isset( $this->params_raw['enable_nav_item'] ) || isset( $this->params_raw['visibility'] ) ) {
     3331                                // If enable_nav_item or visibility is passed,
     3332                                // we assume this  is a legacy extension.
     3333                                // Legacy behavior is that enable_nav_item=true +
     3334                                // visibility=private implies members-only
     3335                                if ( 'public' !== $this->visibility ) {
     3336                                        $this->params['show_tab'] = 'member';
     3337                                } else {
     3338                                        $this->params['show_tab'] = 'anyone';
     3339                                }
     3340
     3341                        } else {
     3342                                // No show_tab or enable_nav_item value is
     3343                                // available, so match the value of 'access'
     3344                                $this->params['show_tab'] = $this->params['access'];
     3345                        }
     3346                }
     3347
     3348                // Parse multiple access conditions into an array
     3349                $access_conditions = $this->params['show_tab'];
     3350                if ( ! is_array( $access_conditions ) ) {
     3351                        $access_conditions = explode( ',', $access_conditions );
     3352                }
     3353
     3354                // If the current user meets at least one condition, the
     3355                // get access
     3356                foreach ( $access_conditions as $access_condition ) {
     3357                        if ( $this->user_meets_access_condition( $access_condition ) ) {
     3358                                $this->user_can_see_nav_item = true;
     3359                                break;
     3360                        }
     3361                }
     3362        }
     3363
     3364        /**
     3365         * Check whether the current user meets an access condition.
     3366         *
     3367         * @param string $access_condition 'anyone', 'loggedin', 'member',
     3368         *        'mod', 'admin'.
     3369         * @return bool
     3370         */
     3371        protected function user_meets_access_condition( $access_condition ) {
     3372                $group = groups_get_group( array(
     3373                        'group_id' => $this->group_id,
     3374                ) );
     3375
     3376                switch ( $access_condition ) {
     3377                        case 'admin' :
     3378                                $meets_condition = groups_is_user_admin( bp_loggedin_user_id(), $this->group_id );
     3379                                break;
     3380
     3381                        case 'mod' :
     3382                                $meets_condition = groups_is_user_mod( bp_loggedin_user_id(), $this->group_id );
     3383                                break;
     3384
     3385                        case 'member' :
     3386                                $meets_condition = groups_is_user_member( bp_loggedin_user_id(), $this->group_id );
     3387                                break;
     3388
     3389                        case 'loggedin' :
     3390                                $meets_condition = is_user_logged_in();
     3391                                break;
     3392
     3393                        case 'noone' :
     3394                                $meets_condition = false;
     3395                                break;
     3396
     3397                        case 'anyone' :
     3398                        default :
     3399                                $meets_condition = true;
     3400                                break;
     3401                }
     3402
     3403                return $meets_condition;
     3404        }
     3405
    32383406        /** Display ***********************************************************/
    32393407
    32403408        /**
    class BP_Group_Extension { 
    32493417                        return;
    32503418                }
    32513419
    3252                 // Bail if the current user doesn't have access
     3420                // Backward compatibility only
    32533421                if ( ( 'public' !== $this->visibility ) && ! buddypress()->groups->current_group->user_has_access ) {
    32543422                        return;
    32553423                }
    32563424
    3257                 if ( true === $this->enable_nav_item ) {
     3425                $user_can_see_nav_item = $this->user_can_see_nav_item();
     3426
     3427                if ( $user_can_see_nav_item ) {
    32583428                        bp_core_new_subnav_item( array(
    32593429                                'name'            => ! $this->nav_item_name ? $this->name : $this->nav_item_name,
    32603430                                'slug'            => $this->slug,
    class BP_Group_Extension { 
    32633433                                'position'        => $this->nav_item_position,
    32643434                                'item_css_id'     => 'nav-' . $this->slug,
    32653435                                'screen_function' => array( &$this, '_display_hook' ),
    3266                                 'user_has_access' => $this->enable_nav_item
     3436                                'user_has_access' => $user_can_see_nav_item,
    32673437                        ) );
    32683438
    32693439                        // When we are viewing the extension display page, set the title and options title
    32703440                        if ( bp_is_current_action( $this->slug ) ) {
     3441                                add_filter( 'bp_group_user_has_access',   array( $this, 'user_can_visit' ) );
    32713442                                add_action( 'bp_template_content_header', create_function( '', 'echo "' . esc_attr( $this->name ) . '";' ) );
    32723443                                add_action( 'bp_template_title',          create_function( '', 'echo "' . esc_attr( $this->name ) . '";' ) );
    32733444                        }
    class BP_Group_Extension { 
    32873458                bp_core_load_template( apply_filters( 'bp_core_template_plugin', $this->template_file ) );
    32883459        }
    32893460
     3461        /**
     3462         * Determine whether the current user should see this nav tab.
     3463         *
     3464         * Note that this controls only the display of the navigation item.
     3465         * Access to the tab is controlled by the user_can_visit() check.
     3466         *
     3467         * @since BuddyPress (2.1.0)
     3468         *
     3469         * @return bool
     3470         */
     3471        public function user_can_see_nav_item( $user_can_see_nav_item = false ) {
     3472                if ( current_user_can( 'bp_moderate' ) ) {
     3473                        return true;
     3474                }
     3475
     3476                return $this->user_can_see_nav_item;
     3477        }
     3478
     3479        /**
     3480         * Determine whether the current user has access to visit this tab.
     3481         *
     3482         * @since BuddyPress (2.1.0)
     3483         *
     3484         * @return bool
     3485         */
     3486        public function user_can_visit( $user_can_visit = false ) {
     3487                if ( current_user_can( 'bp_moderate' ) ) {
     3488                        return true;
     3489                }
     3490
     3491                return $this->user_can_visit;
     3492        }
     3493
     3494
    32903495        /** Create ************************************************************/
    32913496
    32923497        /**
  • src/bp-groups/bp-groups-loader.php

    diff --git src/bp-groups/bp-groups-loader.php src/bp-groups/bp-groups-loader.php
    index 08edbff..49d06a7 100644
    class BP_Groups_Component extends BP_Component { 
    269269
    270270                }
    271271
    272                 // Group access control
    273                 if ( bp_is_groups_component() && !empty( $this->current_group ) ) {
    274                         if ( !$this->current_group->user_has_access ) {
    275 
    276                                 // Hidden groups should return a 404 for non-members.
    277                                 // Unset the current group so that you're not redirected
    278                                 // to the default group tab
    279                                 if ( 'hidden' == $this->current_group->status ) {
    280                                         $this->current_group = 0;
    281                                         $bp->is_single_item  = false;
    282                                         bp_do_404();
    283                                         return;
    284 
    285                                 // Skip the no_access check on home and membership request pages
    286                                 } elseif ( !bp_is_current_action( 'home' ) && !bp_is_current_action( 'request-membership' ) ) {
    287 
    288                                         // Off-limits to this user. Throw an error and redirect to the group's home page
    289                                         if ( is_user_logged_in() ) {
    290                                                 bp_core_no_access( array(
    291                                                         'message'  => __( 'You do not have access to this group.', 'buddypress' ),
    292                                                         'root'     => bp_get_group_permalink( $bp->groups->current_group ) . 'home/',
    293                                                         'redirect' => false
    294                                                 ) );
    295 
    296                                         // User does not have access, and does not get a message
    297                                         } else {
    298                                                 bp_core_no_access();
    299                                         }
    300                                 }
    301                         }
    302 
    303                         // Protect the admin tab from non-admins
    304                         if ( bp_is_current_action( 'admin' ) && !bp_is_item_admin() ) {
    305                                 bp_core_no_access( array(
    306                                         'message'  => __( 'You are not an admin of this group.', 'buddypress' ),
    307                                         'root'     => bp_get_group_permalink( $bp->groups->current_group ),
    308                                         'redirect' => false
    309                                 ) );
    310                         }
    311                 }
    312 
    313272                // Preconfigured group creation steps
    314273                $this->group_creation_steps = apply_filters( 'groups_create_group_steps', array(
    315274                        'group-details'  => array(
  • src/bp-templates/bp-legacy/buddypress/groups/single/home.php

    diff --git src/bp-templates/bp-legacy/buddypress/groups/single/home.php src/bp-templates/bp-legacy/buddypress/groups/single/home.php
    index 11dfb2e..f22e339 100644
     
    3333                 * @todo A real template hierarchy? Gasp!
    3434                 */
    3535
    36                 // Group is visible
    37                 if ( bp_group_is_visible() ) :
    38 
    3936                        // Looking at home location
    4037                        if ( bp_is_group_home() ) :
    4138
    42                                 // Use custom front if one exists
    43                                 $custom_front = bp_locate_template( array( 'groups/single/front.php' ), false, true );
    44                                 if     ( ! empty( $custom_front   ) ) : load_template( $custom_front, true );
     39                                if ( bp_group_is_visible() ) {
    4540
    46                                 // Default to activity
    47                                 elseif ( bp_is_active( 'activity' ) ) : bp_get_template_part( 'groups/single/activity' );
     41                                        // Use custom front if one exists
     42                                        $custom_front = bp_locate_template( array( 'groups/single/front.php' ), false, true );
     43                                        if     ( ! empty( $custom_front   ) ) : load_template( $custom_front, true );
    4844
    49                                 // Otherwise show members
    50                                 elseif ( bp_is_active( 'members'  ) ) : bp_groups_members_template_part();
     45                                        // Default to activity
     46                                        elseif ( bp_is_active( 'activity' ) ) : bp_get_template_part( 'groups/single/activity' );
     47
     48                                        // Otherwise show members
     49                                        elseif ( bp_is_active( 'members'  ) ) : bp_groups_members_template_part();
     50
     51                                        endif;
     52
     53                                } else {
     54
     55                                        do_action( 'bp_before_group_status_message' ); ?>
     56
     57                                        <div id="message" class="info">
     58                                                <p><?php bp_group_status_message(); ?></p>
     59                                        </div>
     60
     61                                        <?php do_action( 'bp_after_group_status_message' );
     62
     63                                }
    5164
    52                                 endif;
    53                                
    5465                        // Not looking at home
    5566                        else :
    5667
     
    7687                                else                                : bp_get_template_part( 'groups/single/plugins'      );
    7788
    7889                                endif;
    79                         endif;
    80 
    81                 // Group is not visible
    82                 elseif ( ! bp_group_is_visible() ) :
    83 
    84                         // Membership request
    85                         if ( bp_is_group_membership_request() ) :
    86                                 bp_get_template_part( 'groups/single/request-membership' );
    87 
    88                         // The group is not visible, show the status message
    89                         else :
    90 
    91                                 do_action( 'bp_before_group_status_message' ); ?>
    92 
    93                                 <div id="message" class="info">
    94                                         <p><?php bp_group_status_message(); ?></p>
    95                                 </div>
    96 
    97                                 <?php do_action( 'bp_after_group_status_message' );
    9890
    9991                        endif;
    100                 endif;
    10192
    10293                do_action( 'bp_after_group_body' ); ?>
    10394
  • tests/phpunit/assets/group-extensions.php

    diff --git tests/phpunit/assets/group-extensions.php tests/phpunit/assets/group-extensions.php
    index 3f6ea36..279c150 100644
    class BPTest_Group_Extension_Visibility_Public extends BP_Group_Extension { 
    202202                parent::init( $args );
    203203        }
    204204}
     205
     206class BPTest_Group_Extension_Inferred_Access_Settings_EnableNavItem_True extends BP_Group_Extension {
     207        public function __construct() {
     208                $class_name = get_class( $this );
     209
     210                $args = array(
     211                        'name' => $class_name,
     212                        'slug' => sanitize_title( $class_name ),
     213                        'enable_nav_item' => true,
     214                );
     215
     216                parent::init( $args );
     217        }
     218}
     219
     220class BPTest_Group_Extension_Inferred_Access_Settings_EnableNavItem_False extends BP_Group_Extension {
     221        public function __construct() {
     222                $class_name = get_class( $this );
     223
     224                $args = array(
     225                        'name' => $class_name,
     226                        'slug' => sanitize_title( $class_name ),
     227                        'enable_nav_item' => false,
     228                );
     229
     230                parent::init( $args );
     231        }
     232}
     233class BPTest_Group_Extension_Access_Anyone extends BP_Group_Extension {
     234        public function __construct() {
     235                $class_name = get_class( $this );
     236
     237                $args = array(
     238                        'name' => $class_name,
     239                        'slug' => sanitize_title( $class_name ),
     240                        'access' => 'anyone',
     241                );
     242
     243                parent::init( $args );
     244        }
     245}
     246
     247class BPTest_Group_Extension_Access_Loggedin extends BP_Group_Extension {
     248        public function __construct() {
     249                $class_name = get_class( $this );
     250
     251                $args = array(
     252                        'name' => $class_name,
     253                        'slug' => sanitize_title( $class_name ),
     254                        'access' => 'loggedin',
     255                );
     256
     257                parent::init( $args );
     258        }
     259}
     260
     261class BPTest_Group_Extension_Access_Member extends BP_Group_Extension {
     262        public function __construct() {
     263                $class_name = get_class( $this );
     264
     265                $args = array(
     266                        'name' => $class_name,
     267                        'slug' => sanitize_title( $class_name ),
     268                        'access' => 'member',
     269                );
     270
     271                parent::init( $args );
     272        }
     273}
     274
     275class BPTest_Group_Extension_Access_AdminMod extends BP_Group_Extension {
     276        public function __construct() {
     277                $class_name = get_class( $this );
     278
     279                $args = array(
     280                        'name' => $class_name,
     281                        'slug' => sanitize_title( $class_name ),
     282                        'access' => array(
     283                                'mod',
     284                                'admin',
     285                        ),
     286                );
     287
     288                parent::init( $args );
     289        }
     290}
     291
     292class BPTest_Group_Extension_Access_Admin extends BP_Group_Extension {
     293        public function __construct() {
     294                $class_name = get_class( $this );
     295
     296                $args = array(
     297                        'name' => $class_name,
     298                        'slug' => sanitize_title( $class_name ),
     299                        'access' => 'admin',
     300                );
     301
     302                parent::init( $args );
     303        }
     304}
     305
     306class BPTest_Group_Extension_ShowTab_Anyone extends BP_Group_Extension {
     307        public function __construct() {
     308                $class_name = get_class( $this );
     309
     310                $args = array(
     311                        'name' => $class_name,
     312                        'slug' => sanitize_title( $class_name ),
     313                        'access' => 'admin',
     314                        'show_tab' => 'anyone',
     315                );
     316
     317                parent::init( $args );
     318        }
     319}
     320
     321class BPTest_Group_Extension_ShowTab_Loggedin extends BP_Group_Extension {
     322        public function __construct() {
     323                $class_name = get_class( $this );
     324
     325                $args = array(
     326                        'name' => $class_name,
     327                        'slug' => sanitize_title( $class_name ),
     328                        'access' => 'admin',
     329                        'show_tab' => 'loggedin',
     330                );
     331
     332                parent::init( $args );
     333        }
     334}
     335
     336class BPTest_Group_Extension_ShowTab_Member extends BP_Group_Extension {
     337        public function __construct() {
     338                $class_name = get_class( $this );
     339
     340                $args = array(
     341                        'name' => $class_name,
     342                        'slug' => sanitize_title( $class_name ),
     343                        'access' => 'admin',
     344                        'show_tab' => 'member',
     345                );
     346
     347                parent::init( $args );
     348        }
     349}
     350
     351class BPTest_Group_Extension_ShowTab_AdminMod extends BP_Group_Extension {
     352        public function __construct() {
     353                $class_name = get_class( $this );
     354
     355                $args = array(
     356                        'name' => $class_name,
     357                        'slug' => sanitize_title( $class_name ),
     358                        'access' => 'admin',
     359                        'show_tab' => array(
     360                                'mod',
     361                                'admin',
     362                        ),
     363                );
     364
     365                parent::init( $args );
     366        }
     367}
     368
     369class BPTest_Group_Extension_ShowTab_Admin extends BP_Group_Extension {
     370        public function __construct() {
     371                $class_name = get_class( $this );
     372
     373                $args = array(
     374                        'name' => $class_name,
     375                        'slug' => sanitize_title( $class_name ),
     376                        'access' => 'admin',
     377                        'show_tab' => 'admin',
     378                );
     379
     380                parent::init( $args );
     381        }
     382}
  • tests/phpunit/testcases/groups/class-bp-group-extension.php

    diff --git tests/phpunit/testcases/groups/class-bp-group-extension.php tests/phpunit/testcases/groups/class-bp-group-extension.php
    index b6ef89b..eeda8a6 100644
    class BP_Tests_Group_Extension_TestCases extends BP_UnitTestCase { 
    346346                buddypress()->bp_options_nav = $old_options_nav;
    347347                $this->set_current_user( $old_current_user );
    348348        }
     349
     350        /**
     351         * @group user_can_visit
     352         */
     353        public function test_user_can_visit_inferred_from_enable_nav_item() {
     354                $old_current_user = get_current_user_id();
     355
     356                $g = $this->factory->group->create( array(
     357                        'status' => 'public',
     358                ) );
     359                $g_obj = groups_get_group( array( 'group_id' => $g ) );
     360                $this->go_to( bp_get_group_permalink( $g_obj ) );
     361
     362                $this->set_current_user( 0 );
     363
     364                $e = new BPTest_Group_Extension_Inferred_Access_Settings_EnableNavItem_True();
     365                $e->_register();
     366                $this->assertTrue( $e->user_can_visit() );
     367
     368                $e2 = new BPTest_Group_Extension_Inferred_Access_Settings_EnableNavItem_False();
     369                $e2->_register();
     370                $this->assertFalse( $e2->user_can_visit() );
     371
     372                $this->set_current_user( $old_current_user );
     373        }
     374
     375        /**
     376         * @group user_can_visit
     377         */
     378        public function test_user_can_visit_explicit_for_logged_out_user() {
     379                $old_current_user = get_current_user_id();
     380                $this->set_current_user( 0 );
     381
     382                $g = $this->factory->group->create( array(
     383                        'status' => 'public',
     384                ) );
     385                $g_obj = groups_get_group( array( 'group_id' => $g ) );
     386                $this->go_to( bp_get_group_permalink( $g_obj ) );
     387
     388                $e1 = new BPTest_Group_Extension_Access_Anyone();
     389                $e1->_register();
     390                $this->assertTrue( $e1->user_can_visit() );
     391
     392                $e2 = new BPTest_Group_Extension_Access_Loggedin();
     393                $e2->_register();
     394                $this->assertFalse( $e2->user_can_visit() );
     395
     396                $e3 = new BPTest_Group_Extension_Access_Member();
     397                $e3->_register();
     398                $this->assertFalse( $e3->user_can_visit() );
     399
     400                $e4 = new BPTest_Group_Extension_Access_AdminMod();
     401                $e4->_register();
     402                $this->assertFalse( $e4->user_can_visit() );
     403
     404                $e5 = new BPTest_Group_Extension_Access_Admin();
     405                $e5->_register();
     406                $this->assertFalse( $e5->user_can_visit() );
     407
     408                $this->set_current_user( $old_current_user );
     409        }
     410
     411        /**
     412         * @group user_can_visit
     413         */
     414        public function test_user_can_visit_explicit_for_logged_in_user() {
     415                $g = $this->factory->group->create( array(
     416                        'status' => 'public',
     417                ) );
     418                $g_obj = groups_get_group( array( 'group_id' => $g ) );
     419
     420                $u = $this->create_user();
     421                $old_current_user = get_current_user_id();
     422                $this->set_current_user( $u );
     423
     424                $this->go_to( bp_get_group_permalink( $g_obj ) );
     425
     426                $e1 = new BPTest_Group_Extension_Access_Anyone();
     427                $e1->_register();
     428                $this->assertTrue( $e1->user_can_visit() );
     429
     430                $e2 = new BPTest_Group_Extension_Access_Loggedin();
     431                $e2->_register();
     432                $this->assertTrue( $e2->user_can_visit() );
     433
     434                $e3 = new BPTest_Group_Extension_Access_Member();
     435                $e3->_register();
     436                $this->assertFalse( $e3->user_can_visit() );
     437
     438                $e4 = new BPTest_Group_Extension_Access_AdminMod();
     439                $e4->_register();
     440                $this->assertFalse( $e4->user_can_visit() );
     441
     442                $e5 = new BPTest_Group_Extension_Access_Admin();
     443                $e5->_register();
     444                $this->assertFalse( $e5->user_can_visit() );
     445
     446                $this->set_current_user( $old_current_user );
     447        }
     448
     449        /**
     450         * @group user_can_visit
     451         */
     452        public function test_user_can_visit_explicit_for_group_member() {
     453                $g = $this->factory->group->create( array(
     454                        'status' => 'public',
     455                ) );
     456                $g_obj = groups_get_group( array( 'group_id' => $g ) );
     457
     458                $u = $this->create_user();
     459                $old_current_user = get_current_user_id();
     460                $this->set_current_user( $u );
     461
     462                $this->add_user_to_group( $u, $g );
     463
     464                $this->go_to( bp_get_group_permalink( $g_obj ) );
     465
     466                $e1 = new BPTest_Group_Extension_Access_Anyone();
     467                $e1->_register();
     468                $this->assertTrue( $e1->user_can_visit() );
     469
     470                $e2 = new BPTest_Group_Extension_Access_Loggedin();
     471                $e2->_register();
     472                $this->assertTrue( $e2->user_can_visit() );
     473
     474                $e3 = new BPTest_Group_Extension_Access_Member();
     475                $e3->_register();
     476                $this->assertTrue( $e3->user_can_visit() );
     477
     478                $e4 = new BPTest_Group_Extension_Access_AdminMod();
     479                $e4->_register();
     480                $this->assertFalse( $e4->user_can_visit() );
     481
     482                $e5 = new BPTest_Group_Extension_Access_Admin();
     483                $e5->_register();
     484                $this->assertFalse( $e5->user_can_visit() );
     485
     486                $this->set_current_user( $old_current_user );
     487        }
     488
     489        /**
     490         * @group user_can_visit
     491         */
     492        public function test_user_can_visit_explicit_for_group_mod() {
     493                $g = $this->factory->group->create( array(
     494                        'status' => 'public',
     495                ) );
     496                $g_obj = groups_get_group( array( 'group_id' => $g ) );
     497
     498                $u = $this->create_user();
     499                $old_current_user = get_current_user_id();
     500                $this->set_current_user( $u );
     501
     502                $m = $this->add_user_to_group( $u, $g );
     503                $gm = new BP_Groups_Member( $u, $g );
     504                $gm->promote( 'mod' );
     505
     506                $this->go_to( bp_get_group_permalink( $g_obj ) );
     507
     508                $e1 = new BPTest_Group_Extension_Access_Anyone();
     509                $e1->_register();
     510                $this->assertTrue( $e1->user_can_visit() );
     511
     512                $e2 = new BPTest_Group_Extension_Access_Loggedin();
     513                $e2->_register();
     514                $this->assertTrue( $e2->user_can_visit() );
     515
     516                $e3 = new BPTest_Group_Extension_Access_Member();
     517                $e3->_register();
     518                $this->assertTrue( $e3->user_can_visit() );
     519
     520                $e4 = new BPTest_Group_Extension_Access_AdminMod();
     521                $e4->_register();
     522                $this->assertTrue( $e4->user_can_visit() );
     523
     524                $e5 = new BPTest_Group_Extension_Access_Admin();
     525                $e5->_register();
     526                $this->assertFalse( $e5->user_can_visit() );
     527
     528                $this->set_current_user( $old_current_user );
     529        }
     530
     531        /**
     532         * @group user_can_visit
     533         */
     534        public function test_user_can_visit_explicit_for_group_admin() {
     535                $g = $this->factory->group->create( array(
     536                        'status' => 'public',
     537                ) );
     538                $g_obj = groups_get_group( array( 'group_id' => $g ) );
     539
     540                $u = $this->create_user();
     541                $old_current_user = get_current_user_id();
     542                $this->set_current_user( $u );
     543
     544                $m = $this->add_user_to_group( $u, $g );
     545                $gm = new BP_Groups_Member( $u, $g );
     546                $gm->promote( 'admin' );
     547
     548                $this->go_to( bp_get_group_permalink( $g_obj ) );
     549
     550                $e1 = new BPTest_Group_Extension_Access_Anyone();
     551                $e1->_register();
     552                $this->assertTrue( $e1->user_can_visit() );
     553
     554                $e2 = new BPTest_Group_Extension_Access_Loggedin();
     555                $e2->_register();
     556                $this->assertTrue( $e2->user_can_visit() );
     557
     558                $e3 = new BPTest_Group_Extension_Access_Member();
     559                $e3->_register();
     560                $this->assertTrue( $e3->user_can_visit() );
     561
     562                $e4 = new BPTest_Group_Extension_Access_AdminMod();
     563                $e4->_register();
     564                $this->assertTrue( $e4->user_can_visit() );
     565
     566                $e5 = new BPTest_Group_Extension_Access_Admin();
     567                $e5->_register();
     568                $this->assertTrue( $e5->user_can_visit() );
     569
     570                $this->set_current_user( $old_current_user );
     571        }
     572
     573        /**
     574         * @group user_can_see_nav_item
     575         */
     576        public function test_user_can_see_nav_item_implied() {
     577                $g = $this->factory->group->create( array(
     578                        'status' => 'public',
     579                ) );
     580                $g_obj = groups_get_group( array( 'group_id' => $g ) );
     581
     582                $old_current_user = get_current_user_id();
     583                $this->set_current_user( 0 );
     584
     585                $this->go_to( bp_get_group_permalink( $g_obj ) );
     586
     587                $e1 = new BPTest_Group_Extension_Access_Anyone();
     588                $e1->_register();
     589                $this->assertTrue( $e1->user_can_see_nav_item() );
     590
     591                $e2 = new BPTest_Group_Extension_Access_Loggedin();
     592                $e2->_register();
     593                $this->assertFalse( $e2->user_can_see_nav_item() );
     594
     595                $e3 = new BPTest_Group_Extension_Access_Member();
     596                $e3->_register();
     597                $this->assertFalse( $e3->user_can_see_nav_item() );
     598
     599                $e4 = new BPTest_Group_Extension_Access_AdminMod();
     600                $e4->_register();
     601                $this->assertFalse( $e4->user_can_see_nav_item() );
     602
     603                $e5 = new BPTest_Group_Extension_Access_Admin();
     604                $e5->_register();
     605                $this->assertFalse( $e5->user_can_see_nav_item() );
     606
     607                $this->set_current_user( $old_current_user );
     608        }
     609
     610        /**
     611         * @group user_can_see_nav_item
     612         */
     613        public function test_user_can_see_nav_item_explicit_for_logged_out_user() {
     614                $g = $this->factory->group->create( array(
     615                        'status' => 'public',
     616                ) );
     617                $g_obj = groups_get_group( array( 'group_id' => $g ) );
     618
     619                $old_current_user = get_current_user_id();
     620                $this->set_current_user( 0 );
     621
     622                $this->go_to( bp_get_group_permalink( $g_obj ) );
     623
     624                $e1 = new BPTest_Group_Extension_ShowTab_Anyone();
     625                $e1->_register();
     626                $this->assertTrue( $e1->user_can_see_nav_item() );
     627
     628                $e2 = new BPTest_Group_Extension_ShowTab_Loggedin();
     629                $e2->_register();
     630                $this->assertFalse( $e2->user_can_see_nav_item() );
     631
     632                $e3 = new BPTest_Group_Extension_ShowTab_Member();
     633                $e3->_register();
     634                $this->assertFalse( $e3->user_can_see_nav_item() );
     635
     636                $e4 = new BPTest_Group_Extension_ShowTab_AdminMod();
     637                $e4->_register();
     638                $this->assertFalse( $e4->user_can_see_nav_item() );
     639
     640                $e5 = new BPTest_Group_Extension_ShowTab_Admin();
     641                $e5->_register();
     642                $this->assertFalse( $e5->user_can_see_nav_item() );
     643
     644                $this->set_current_user( $old_current_user );
     645        }
     646
     647        /**
     648         * @group user_can_see_nav_item
     649         */
     650        public function test_user_can_see_nav_item_explicit_for_logged_in_user() {
     651                $g = $this->factory->group->create( array(
     652                        'status' => 'public',
     653                ) );
     654                $g_obj = groups_get_group( array( 'group_id' => $g ) );
     655
     656                $u = $this->create_user();
     657                $old_current_user = get_current_user_id();
     658                $this->set_current_user( $u );
     659
     660                $this->go_to( bp_get_group_permalink( $g_obj ) );
     661
     662                $e1 = new BPTest_Group_Extension_ShowTab_Anyone();
     663                $e1->_register();
     664                $this->assertTrue( $e1->user_can_see_nav_item() );
     665
     666                $e2 = new BPTest_Group_Extension_ShowTab_Loggedin();
     667                $e2->_register();
     668                $this->assertTrue( $e2->user_can_see_nav_item() );
     669
     670                $e3 = new BPTest_Group_Extension_ShowTab_Member();
     671                $e3->_register();
     672                $this->assertFalse( $e3->user_can_see_nav_item() );
     673
     674                $e4 = new BPTest_Group_Extension_ShowTab_AdminMod();
     675                $e4->_register();
     676                $this->assertFalse( $e4->user_can_see_nav_item() );
     677
     678                $e5 = new BPTest_Group_Extension_ShowTab_Admin();
     679                $e5->_register();
     680                $this->assertFalse( $e5->user_can_see_nav_item() );
     681
     682                $this->set_current_user( $old_current_user );
     683        }
     684
     685        /**
     686         * @group user_can_see_nav_item
     687         */
     688        public function test_user_can_see_nav_item_explicit_for_group_member() {
     689                $g = $this->factory->group->create( array(
     690                        'status' => 'public',
     691                ) );
     692                $g_obj = groups_get_group( array( 'group_id' => $g ) );
     693
     694                $u = $this->create_user();
     695                $old_current_user = get_current_user_id();
     696                $this->set_current_user( $u );
     697
     698                $this->add_user_to_group( $u, $g );
     699
     700                $this->go_to( bp_get_group_permalink( $g_obj ) );
     701
     702                $e1 = new BPTest_Group_Extension_ShowTab_Anyone();
     703                $e1->_register();
     704                $this->assertTrue( $e1->user_can_see_nav_item() );
     705
     706                $e2 = new BPTest_Group_Extension_ShowTab_Loggedin();
     707                $e2->_register();
     708                $this->assertTrue( $e2->user_can_see_nav_item() );
     709
     710                $e3 = new BPTest_Group_Extension_ShowTab_Member();
     711                $e3->_register();
     712                $this->assertTrue( $e3->user_can_see_nav_item() );
     713
     714                $e4 = new BPTest_Group_Extension_ShowTab_AdminMod();
     715                $e4->_register();
     716                $this->assertFalse( $e4->user_can_see_nav_item() );
     717
     718                $e5 = new BPTest_Group_Extension_ShowTab_Admin();
     719                $e5->_register();
     720                $this->assertFalse( $e5->user_can_see_nav_item() );
     721
     722                $this->set_current_user( $old_current_user );
     723        }
     724
     725        /**
     726         * @group user_can_see_nav_item
     727         */
     728        public function test_user_can_see_nav_item_explicit_for_group_mod() {
     729                $g = $this->factory->group->create( array(
     730                        'status' => 'public',
     731                ) );
     732                $g_obj = groups_get_group( array( 'group_id' => $g ) );
     733
     734                $u = $this->create_user();
     735                $old_current_user = get_current_user_id();
     736                $this->set_current_user( $u );
     737
     738                $this->add_user_to_group( $u, $g );
     739                $gm = new BP_Groups_Member( $u, $g );
     740                $gm->promote( 'mod' );
     741
     742                $this->go_to( bp_get_group_permalink( $g_obj ) );
     743
     744                $e1 = new BPTest_Group_Extension_ShowTab_Anyone();
     745                $e1->_register();
     746                $this->assertTrue( $e1->user_can_see_nav_item() );
     747
     748                $e2 = new BPTest_Group_Extension_ShowTab_Loggedin();
     749                $e2->_register();
     750                $this->assertTrue( $e2->user_can_see_nav_item() );
     751
     752                $e3 = new BPTest_Group_Extension_ShowTab_Member();
     753                $e3->_register();
     754                $this->assertTrue( $e3->user_can_see_nav_item() );
     755
     756                $e4 = new BPTest_Group_Extension_ShowTab_AdminMod();
     757                $e4->_register();
     758                $this->assertTrue( $e4->user_can_see_nav_item() );
     759
     760                $e5 = new BPTest_Group_Extension_ShowTab_Admin();
     761                $e5->_register();
     762                $this->assertFalse( $e5->user_can_see_nav_item() );
     763
     764                $this->set_current_user( $old_current_user );
     765        }
     766
     767        /**
     768         * @group user_can_see_nav_item
     769         */
     770        public function test_user_can_see_nav_item_explicit_for_group_admin() {
     771                $g = $this->factory->group->create( array(
     772                        'status' => 'public',
     773                ) );
     774                $g_obj = groups_get_group( array( 'group_id' => $g ) );
     775
     776                $u = $this->create_user();
     777                $old_current_user = get_current_user_id();
     778                $this->set_current_user( $u );
     779
     780                $this->add_user_to_group( $u, $g );
     781                $gm = new BP_Groups_Member( $u, $g );
     782                $gm->promote( 'admin' );
     783
     784                $this->go_to( bp_get_group_permalink( $g_obj ) );
     785
     786                $e1 = new BPTest_Group_Extension_ShowTab_Anyone();
     787                $e1->_register();
     788                $this->assertTrue( $e1->user_can_see_nav_item() );
     789
     790                $e2 = new BPTest_Group_Extension_ShowTab_Loggedin();
     791                $e2->_register();
     792                $this->assertTrue( $e2->user_can_see_nav_item() );
     793
     794                $e3 = new BPTest_Group_Extension_ShowTab_Member();
     795                $e3->_register();
     796                $this->assertTrue( $e3->user_can_see_nav_item() );
     797
     798                $e4 = new BPTest_Group_Extension_ShowTab_AdminMod();
     799                $e4->_register();
     800                $this->assertTrue( $e4->user_can_see_nav_item() );
     801
     802                $e5 = new BPTest_Group_Extension_ShowTab_Admin();
     803                $e5->_register();
     804                $this->assertTrue( $e5->user_can_see_nav_item() );
     805
     806                $this->set_current_user( $old_current_user );
     807        }
    349808}