Skip to:
Content

Ticket #7218: 7218.members.patch

File 7218.members.patch, 23.9 KB (added by r-a-y, 9 months ago)

For the Members component - refreshed for 2.9

  • new file src/bp-members/bp-members-register.php

    new file mode 100644
    - +  
     1<?php 
     2/** 
     3 * BuddyPress Registration Screens. 
     4 * 
     5 * Handlers for the registration and activation screens. 
     6 * 
     7 * @package BuddyPress 
     8 * @subpackage MembersScreens 
     9 * @since 1.5.0 
     10 */ 
     11 
     12// Exit if accessed directly. 
     13defined( 'ABSPATH' ) || exit; 
     14 
     15/** 
     16 * Handle the loading of the signup screen. 
     17 * 
     18 * @since 1.1.0 
     19 */ 
     20function bp_core_screen_signup() { 
     21        $bp = buddypress(); 
     22 
     23        if ( ! bp_is_current_component( 'register' ) || bp_current_action() ) 
     24                return; 
     25 
     26        // Not a directory. 
     27        bp_update_is_directory( false, 'register' ); 
     28 
     29        // If the user is logged in, redirect away from here. 
     30        if ( is_user_logged_in() ) { 
     31 
     32                $redirect_to = bp_is_component_front_page( 'register' ) 
     33                        ? bp_get_members_directory_permalink() 
     34                        : bp_get_root_domain(); 
     35 
     36                /** 
     37                 * Filters the URL to redirect logged in users to when visiting registration page. 
     38                 * 
     39                 * @since 1.5.1 
     40                 * 
     41                 * @param string $redirect_to URL to redirect user to. 
     42                 */ 
     43                bp_core_redirect( apply_filters( 'bp_loggedin_register_page_redirect_to', $redirect_to ) ); 
     44 
     45                return; 
     46        } 
     47 
     48        $bp->signup->step = 'request-details'; 
     49 
     50        if ( !bp_get_signup_allowed() ) { 
     51                $bp->signup->step = 'registration-disabled'; 
     52 
     53                // If the signup page is submitted, validate and save. 
     54        } elseif ( isset( $_POST['signup_submit'] ) && bp_verify_nonce_request( 'bp_new_signup' ) ) { 
     55 
     56                /** 
     57                 * Fires before the validation of a new signup. 
     58                 * 
     59                 * @since 2.0.0 
     60                 */ 
     61                do_action( 'bp_signup_pre_validate' ); 
     62 
     63                // Check the base account details for problems. 
     64                $account_details = bp_core_validate_user_signup( $_POST['signup_username'], $_POST['signup_email'] ); 
     65 
     66                // If there are errors with account details, set them for display. 
     67                if ( !empty( $account_details['errors']->errors['user_name'] ) ) 
     68                        $bp->signup->errors['signup_username'] = $account_details['errors']->errors['user_name'][0]; 
     69 
     70                if ( !empty( $account_details['errors']->errors['user_email'] ) ) 
     71                        $bp->signup->errors['signup_email'] = $account_details['errors']->errors['user_email'][0]; 
     72 
     73                // Check that both password fields are filled in. 
     74                if ( empty( $_POST['signup_password'] ) || empty( $_POST['signup_password_confirm'] ) ) 
     75                        $bp->signup->errors['signup_password'] = __( 'Please make sure you enter your password twice', 'buddypress' ); 
     76 
     77                // Check that the passwords match. 
     78                if ( ( !empty( $_POST['signup_password'] ) && !empty( $_POST['signup_password_confirm'] ) ) && $_POST['signup_password'] != $_POST['signup_password_confirm'] ) 
     79                        $bp->signup->errors['signup_password'] = __( 'The passwords you entered do not match.', 'buddypress' ); 
     80 
     81                $bp->signup->username = $_POST['signup_username']; 
     82                $bp->signup->email = $_POST['signup_email']; 
     83 
     84                // Now we've checked account details, we can check profile information. 
     85                if ( bp_is_active( 'xprofile' ) ) { 
     86 
     87                        // Make sure hidden field is passed and populated. 
     88                        if ( isset( $_POST['signup_profile_field_ids'] ) && !empty( $_POST['signup_profile_field_ids'] ) ) { 
     89 
     90                                // Let's compact any profile field info into an array. 
     91                                $profile_field_ids = explode( ',', $_POST['signup_profile_field_ids'] ); 
     92 
     93                                // Loop through the posted fields formatting any datebox values then validate the field. 
     94                                foreach ( (array) $profile_field_ids as $field_id ) { 
     95                                        bp_xprofile_maybe_format_datebox_post_data( $field_id ); 
     96 
     97                                        // Create errors for required fields without values. 
     98                                        if ( xprofile_check_is_required_field( $field_id ) && empty( $_POST[ 'field_' . $field_id ] ) && ! bp_current_user_can( 'bp_moderate' ) ) 
     99                                                $bp->signup->errors['field_' . $field_id] = __( 'This is a required field', 'buddypress' ); 
     100                                } 
     101 
     102                                // This situation doesn't naturally occur so bounce to website root. 
     103                        } else { 
     104                                bp_core_redirect( bp_get_root_domain() ); 
     105                        } 
     106                } 
     107 
     108                // Finally, let's check the blog details, if the user wants a blog and blog creation is enabled. 
     109                if ( isset( $_POST['signup_with_blog'] ) ) { 
     110                        $active_signup = bp_core_get_root_option( 'registration' ); 
     111 
     112                        if ( 'blog' == $active_signup || 'all' == $active_signup ) { 
     113                                $blog_details = bp_core_validate_blog_signup( $_POST['signup_blog_url'], $_POST['signup_blog_title'] ); 
     114 
     115                                // If there are errors with blog details, set them for display. 
     116                                if ( !empty( $blog_details['errors']->errors['blogname'] ) ) 
     117                                        $bp->signup->errors['signup_blog_url'] = $blog_details['errors']->errors['blogname'][0]; 
     118 
     119                                if ( !empty( $blog_details['errors']->errors['blog_title'] ) ) 
     120                                        $bp->signup->errors['signup_blog_title'] = $blog_details['errors']->errors['blog_title'][0]; 
     121                        } 
     122                } 
     123 
     124                /** 
     125                 * Fires after the validation of a new signup. 
     126                 * 
     127                 * @since 1.1.0 
     128                 */ 
     129                do_action( 'bp_signup_validate' ); 
     130 
     131                // Add any errors to the action for the field in the template for display. 
     132                if ( !empty( $bp->signup->errors ) ) { 
     133                        foreach ( (array) $bp->signup->errors as $fieldname => $error_message ) { 
     134                                /* 
     135                                 * The addslashes() and stripslashes() used to avoid create_function() 
     136                                 * syntax errors when the $error_message contains quotes. 
     137                                 */ 
     138 
     139                                /** 
     140                                 * Filters the error message in the loop. 
     141                                 * 
     142                                 * @since 1.5.0 
     143                                 * 
     144                                 * @param string $value Error message wrapped in html. 
     145                                 */ 
     146                                add_action( 'bp_' . $fieldname . '_errors', create_function( '', 'echo apply_filters(\'bp_members_signup_error_message\', "<div class=\"error\">" . stripslashes( \'' . addslashes( $error_message ) . '\' ) . "</div>" );' ) ); 
     147                        } 
     148                } else { 
     149                        $bp->signup->step = 'save-details'; 
     150 
     151                        // No errors! Let's register those deets. 
     152                        $active_signup = bp_core_get_root_option( 'registration' ); 
     153 
     154                        if ( 'none' != $active_signup ) { 
     155 
     156                                // Make sure the extended profiles module is enabled. 
     157                                if ( bp_is_active( 'xprofile' ) ) { 
     158                                        // Let's compact any profile field info into usermeta. 
     159                                        $profile_field_ids = explode( ',', $_POST['signup_profile_field_ids'] ); 
     160 
     161                                        /* 
     162                                         * Loop through the posted fields, formatting any 
     163                                         * datebox values, then add to usermeta. 
     164                                         */ 
     165                                        foreach ( (array) $profile_field_ids as $field_id ) { 
     166                                                bp_xprofile_maybe_format_datebox_post_data( $field_id ); 
     167 
     168                                                if ( !empty( $_POST['field_' . $field_id] ) ) 
     169                                                        $usermeta['field_' . $field_id] = $_POST['field_' . $field_id]; 
     170 
     171                                                if ( !empty( $_POST['field_' . $field_id . '_visibility'] ) ) 
     172                                                        $usermeta['field_' . $field_id . '_visibility'] = $_POST['field_' . $field_id . '_visibility']; 
     173                                        } 
     174 
     175                                        // Store the profile field ID's in usermeta. 
     176                                        $usermeta['profile_field_ids'] = $_POST['signup_profile_field_ids']; 
     177                                } 
     178 
     179                                // Hash and store the password. 
     180                                $usermeta['password'] = wp_hash_password( $_POST['signup_password'] ); 
     181 
     182                                // If the user decided to create a blog, save those details to usermeta. 
     183                                if ( 'blog' == $active_signup || 'all' == $active_signup ) 
     184                                        $usermeta['public'] = ( isset( $_POST['signup_blog_privacy'] ) && 'public' == $_POST['signup_blog_privacy'] ) ? true : false; 
     185 
     186                                /** 
     187                                 * Filters the user meta used for signup. 
     188                                 * 
     189                                 * @since 1.1.0 
     190                                 * 
     191                                 * @param array $usermeta Array of user meta to add to signup. 
     192                                 */ 
     193                                $usermeta = apply_filters( 'bp_signup_usermeta', $usermeta ); 
     194 
     195                                // Finally, sign up the user and/or blog. 
     196                                if ( isset( $_POST['signup_with_blog'] ) && is_multisite() ) 
     197                                        $wp_user_id = bp_core_signup_blog( $blog_details['domain'], $blog_details['path'], $blog_details['blog_title'], $_POST['signup_username'], $_POST['signup_email'], $usermeta ); 
     198                                else 
     199                                        $wp_user_id = bp_core_signup_user( $_POST['signup_username'], $_POST['signup_password'], $_POST['signup_email'], $usermeta ); 
     200 
     201                                if ( is_wp_error( $wp_user_id ) ) { 
     202                                        $bp->signup->step = 'request-details'; 
     203                                        bp_core_add_message( $wp_user_id->get_error_message(), 'error' ); 
     204                                } else { 
     205                                        $bp->signup->step = 'completed-confirmation'; 
     206                                } 
     207                        } 
     208 
     209                        /** 
     210                         * Fires after the completion of a new signup. 
     211                         * 
     212                         * @since 1.1.0 
     213                         */ 
     214                        do_action( 'bp_complete_signup' ); 
     215                } 
     216 
     217        } 
     218 
     219        /** 
     220         * Fires right before the loading of the Member registration screen template file. 
     221         * 
     222         * @since 1.5.0 
     223         */ 
     224        do_action( 'bp_core_screen_signup' ); 
     225 
     226        /** 
     227         * Filters the template to load for the Member registration page screen. 
     228         * 
     229         * @since 1.5.0 
     230         * 
     231         * @param string $value Path to the Member registration template to load. 
     232         */ 
     233        bp_core_load_template( apply_filters( 'bp_core_template_register', array( 'register', 'registration/register' ) ) ); 
     234} 
     235add_action( 'bp_screens', 'bp_core_screen_signup' ); 
     236 
     237/** 
     238 * Handle the loading of the Activate screen. 
     239 * 
     240 * @since 1.1.0 
     241 * 
     242 * @todo Move the actual activation process into an action in bp-members-actions.php 
     243 */ 
     244function bp_core_screen_activation() { 
     245 
     246        // Bail if not viewing the activation page. 
     247        if ( ! bp_is_current_component( 'activate' ) ) { 
     248                return false; 
     249        } 
     250 
     251        // If the user is already logged in, redirect away from here. 
     252        if ( is_user_logged_in() ) { 
     253 
     254                // If activation page is also front page, set to members directory to 
     255                // avoid an infinite loop. Otherwise, set to root domain. 
     256                $redirect_to = bp_is_component_front_page( 'activate' ) 
     257                        ? bp_get_members_directory_permalink() 
     258                        : bp_get_root_domain(); 
     259 
     260                // Trailing slash it, as we expect these URL's to be. 
     261                $redirect_to = trailingslashit( $redirect_to ); 
     262 
     263                /** 
     264                 * Filters the URL to redirect logged in users to when visiting activation page. 
     265                 * 
     266                 * @since 1.9.0 
     267                 * 
     268                 * @param string $redirect_to URL to redirect user to. 
     269                 */ 
     270                $redirect_to = apply_filters( 'bp_loggedin_activate_page_redirect_to', $redirect_to ); 
     271 
     272                // Redirect away from the activation page. 
     273                bp_core_redirect( $redirect_to ); 
     274        } 
     275 
     276        // Grab the key (the old way). 
     277        $key = isset( $_GET['key'] ) ? $_GET['key'] : ''; 
     278 
     279        // Grab the key (the new way). 
     280        if ( empty( $key ) ) { 
     281                $key = bp_current_action(); 
     282        } 
     283 
     284        // Get BuddyPress. 
     285        $bp = buddypress(); 
     286 
     287        // We've got a key; let's attempt to activate the signup. 
     288        if ( ! empty( $key ) ) { 
     289 
     290                /** 
     291                 * Filters the activation signup. 
     292                 * 
     293                 * @since 1.1.0 
     294                 * 
     295                 * @param bool|int $value Value returned by activation. 
     296                 *                        Integer on success, boolean on failure. 
     297                 */ 
     298                $user = apply_filters( 'bp_core_activate_account', bp_core_activate_signup( $key ) ); 
     299 
     300                // If there were errors, add a message and redirect. 
     301                if ( ! empty( $user->errors ) ) { 
     302                        bp_core_add_message( $user->get_error_message(), 'error' ); 
     303                        bp_core_redirect( trailingslashit( bp_get_root_domain() . '/' . $bp->pages->activate->slug ) ); 
     304                } 
     305 
     306                bp_core_add_message( __( 'Your account is now active!', 'buddypress' ) ); 
     307                $bp->activation_complete = true; 
     308        } 
     309 
     310        /** 
     311         * Filters the template to load for the Member activation page screen. 
     312         * 
     313         * @since 1.1.1 
     314         * 
     315         * @param string $value Path to the Member activation template to load. 
     316         */ 
     317        bp_core_load_template( apply_filters( 'bp_core_template_activate', array( 'activate', 'registration/activate' ) ) ); 
     318} 
     319add_action( 'bp_screens', 'bp_core_screen_activation' ); 
     320 
     321/** Theme Compatibility *******************************************************/ 
     322 
     323new BP_Registration_Theme_Compat(); 
  • src/bp-members/bp-members-screens.php

     
    6464} 
    6565add_action( 'bp_screens', 'bp_members_screen_index' ); 
    6666 
    67 /** 
    68  * Handle the loading of the signup screen. 
    69  * 
    70  * @since 1.1.0 
    71  */ 
    72 function bp_core_screen_signup() { 
    73         $bp = buddypress(); 
    74  
    75         if ( ! bp_is_current_component( 'register' ) || bp_current_action() ) 
    76                 return; 
    77  
    78         // Not a directory. 
    79         bp_update_is_directory( false, 'register' ); 
    80  
    81         // If the user is logged in, redirect away from here. 
    82         if ( is_user_logged_in() ) { 
    83  
    84                 $redirect_to = bp_is_component_front_page( 'register' ) 
    85                         ? bp_get_members_directory_permalink() 
    86                         : bp_get_root_domain(); 
    87  
    88                 /** 
    89                  * Filters the URL to redirect logged in users to when visiting registration page. 
    90                  * 
    91                  * @since 1.5.1 
    92                  * 
    93                  * @param string $redirect_to URL to redirect user to. 
    94                  */ 
    95                 bp_core_redirect( apply_filters( 'bp_loggedin_register_page_redirect_to', $redirect_to ) ); 
    96  
    97                 return; 
    98         } 
    99  
    100         $bp->signup->step = 'request-details'; 
    101  
    102         if ( !bp_get_signup_allowed() ) { 
    103                 $bp->signup->step = 'registration-disabled'; 
    104  
    105                 // If the signup page is submitted, validate and save. 
    106         } elseif ( isset( $_POST['signup_submit'] ) && bp_verify_nonce_request( 'bp_new_signup' ) ) { 
    107  
    108                 /** 
    109                  * Fires before the validation of a new signup. 
    110                  * 
    111                  * @since 2.0.0 
    112                  */ 
    113                 do_action( 'bp_signup_pre_validate' ); 
    114  
    115                 // Check the base account details for problems. 
    116                 $account_details = bp_core_validate_user_signup( $_POST['signup_username'], $_POST['signup_email'] ); 
    117  
    118                 // If there are errors with account details, set them for display. 
    119                 if ( !empty( $account_details['errors']->errors['user_name'] ) ) 
    120                         $bp->signup->errors['signup_username'] = $account_details['errors']->errors['user_name'][0]; 
    121  
    122                 if ( !empty( $account_details['errors']->errors['user_email'] ) ) 
    123                         $bp->signup->errors['signup_email'] = $account_details['errors']->errors['user_email'][0]; 
    124  
    125                 // Check that both password fields are filled in. 
    126                 if ( empty( $_POST['signup_password'] ) || empty( $_POST['signup_password_confirm'] ) ) 
    127                         $bp->signup->errors['signup_password'] = __( 'Please make sure you enter your password twice', 'buddypress' ); 
    128  
    129                 // Check that the passwords match. 
    130                 if ( ( !empty( $_POST['signup_password'] ) && !empty( $_POST['signup_password_confirm'] ) ) && $_POST['signup_password'] != $_POST['signup_password_confirm'] ) 
    131                         $bp->signup->errors['signup_password'] = __( 'The passwords you entered do not match.', 'buddypress' ); 
    132  
    133                 $bp->signup->username = $_POST['signup_username']; 
    134                 $bp->signup->email = $_POST['signup_email']; 
    135  
    136                 // Now we've checked account details, we can check profile information. 
    137                 if ( bp_is_active( 'xprofile' ) ) { 
    138  
    139                         // Make sure hidden field is passed and populated. 
    140                         if ( isset( $_POST['signup_profile_field_ids'] ) && !empty( $_POST['signup_profile_field_ids'] ) ) { 
    141  
    142                                 // Let's compact any profile field info into an array. 
    143                                 $profile_field_ids = explode( ',', $_POST['signup_profile_field_ids'] ); 
    144  
    145                                 // Loop through the posted fields formatting any datebox values then validate the field. 
    146                                 foreach ( (array) $profile_field_ids as $field_id ) { 
    147                                         bp_xprofile_maybe_format_datebox_post_data( $field_id ); 
    148  
    149                                         // Create errors for required fields without values. 
    150                                         if ( xprofile_check_is_required_field( $field_id ) && empty( $_POST[ 'field_' . $field_id ] ) && ! bp_current_user_can( 'bp_moderate' ) ) 
    151                                                 $bp->signup->errors['field_' . $field_id] = __( 'This is a required field', 'buddypress' ); 
    152                                 } 
    153  
    154                                 // This situation doesn't naturally occur so bounce to website root. 
    155                         } else { 
    156                                 bp_core_redirect( bp_get_root_domain() ); 
    157                         } 
    158                 } 
    159  
    160                 // Finally, let's check the blog details, if the user wants a blog and blog creation is enabled. 
    161                 if ( isset( $_POST['signup_with_blog'] ) ) { 
    162                         $active_signup = bp_core_get_root_option( 'registration' ); 
    163  
    164                         if ( 'blog' == $active_signup || 'all' == $active_signup ) { 
    165                                 $blog_details = bp_core_validate_blog_signup( $_POST['signup_blog_url'], $_POST['signup_blog_title'] ); 
    166  
    167                                 // If there are errors with blog details, set them for display. 
    168                                 if ( !empty( $blog_details['errors']->errors['blogname'] ) ) 
    169                                         $bp->signup->errors['signup_blog_url'] = $blog_details['errors']->errors['blogname'][0]; 
    170  
    171                                 if ( !empty( $blog_details['errors']->errors['blog_title'] ) ) 
    172                                         $bp->signup->errors['signup_blog_title'] = $blog_details['errors']->errors['blog_title'][0]; 
    173                         } 
    174                 } 
    175  
    176                 /** 
    177                  * Fires after the validation of a new signup. 
    178                  * 
    179                  * @since 1.1.0 
    180                  */ 
    181                 do_action( 'bp_signup_validate' ); 
    182  
    183                 // Add any errors to the action for the field in the template for display. 
    184                 if ( !empty( $bp->signup->errors ) ) { 
    185                         foreach ( (array) $bp->signup->errors as $fieldname => $error_message ) { 
    186                                 /* 
    187                                  * The addslashes() and stripslashes() used to avoid create_function() 
    188                                  * syntax errors when the $error_message contains quotes. 
    189                                  */ 
    190  
    191                                 /** 
    192                                  * Filters the error message in the loop. 
    193                                  * 
    194                                  * @since 1.5.0 
    195                                  * 
    196                                  * @param string $value Error message wrapped in html. 
    197                                  */ 
    198                                 add_action( 'bp_' . $fieldname . '_errors', create_function( '', 'echo apply_filters(\'bp_members_signup_error_message\', "<div class=\"error\">" . stripslashes( \'' . addslashes( $error_message ) . '\' ) . "</div>" );' ) ); 
    199                         } 
    200                 } else { 
    201                         $bp->signup->step = 'save-details'; 
    202  
    203                         // No errors! Let's register those deets. 
    204                         $active_signup = bp_core_get_root_option( 'registration' ); 
    205  
    206                         if ( 'none' != $active_signup ) { 
    207  
    208                                 // Make sure the extended profiles module is enabled. 
    209                                 if ( bp_is_active( 'xprofile' ) ) { 
    210                                         // Let's compact any profile field info into usermeta. 
    211                                         $profile_field_ids = explode( ',', $_POST['signup_profile_field_ids'] ); 
    212  
    213                                         /* 
    214                                          * Loop through the posted fields, formatting any 
    215                                          * datebox values, then add to usermeta. 
    216                                          */ 
    217                                         foreach ( (array) $profile_field_ids as $field_id ) { 
    218                                                 bp_xprofile_maybe_format_datebox_post_data( $field_id ); 
    219  
    220                                                 if ( !empty( $_POST['field_' . $field_id] ) ) 
    221                                                         $usermeta['field_' . $field_id] = $_POST['field_' . $field_id]; 
    222  
    223                                                 if ( !empty( $_POST['field_' . $field_id . '_visibility'] ) ) 
    224                                                         $usermeta['field_' . $field_id . '_visibility'] = $_POST['field_' . $field_id . '_visibility']; 
    225                                         } 
    226  
    227                                         // Store the profile field ID's in usermeta. 
    228                                         $usermeta['profile_field_ids'] = $_POST['signup_profile_field_ids']; 
    229                                 } 
    230  
    231                                 // Hash and store the password. 
    232                                 $usermeta['password'] = wp_hash_password( $_POST['signup_password'] ); 
    233  
    234                                 // If the user decided to create a blog, save those details to usermeta. 
    235                                 if ( 'blog' == $active_signup || 'all' == $active_signup ) 
    236                                         $usermeta['public'] = ( isset( $_POST['signup_blog_privacy'] ) && 'public' == $_POST['signup_blog_privacy'] ) ? true : false; 
    237  
    238                                 /** 
    239                                  * Filters the user meta used for signup. 
    240                                  * 
    241                                  * @since 1.1.0 
    242                                  * 
    243                                  * @param array $usermeta Array of user meta to add to signup. 
    244                                  */ 
    245                                 $usermeta = apply_filters( 'bp_signup_usermeta', $usermeta ); 
    246  
    247                                 // Finally, sign up the user and/or blog. 
    248                                 if ( isset( $_POST['signup_with_blog'] ) && is_multisite() ) 
    249                                         $wp_user_id = bp_core_signup_blog( $blog_details['domain'], $blog_details['path'], $blog_details['blog_title'], $_POST['signup_username'], $_POST['signup_email'], $usermeta ); 
    250                                 else 
    251                                         $wp_user_id = bp_core_signup_user( $_POST['signup_username'], $_POST['signup_password'], $_POST['signup_email'], $usermeta ); 
    252  
    253                                 if ( is_wp_error( $wp_user_id ) ) { 
    254                                         $bp->signup->step = 'request-details'; 
    255                                         bp_core_add_message( $wp_user_id->get_error_message(), 'error' ); 
    256                                 } else { 
    257                                         $bp->signup->step = 'completed-confirmation'; 
    258                                 } 
    259                         } 
    260  
    261                         /** 
    262                          * Fires after the completion of a new signup. 
    263                          * 
    264                          * @since 1.1.0 
    265                          */ 
    266                         do_action( 'bp_complete_signup' ); 
    267                 } 
    268  
    269         } 
    270  
    271         /** 
    272          * Fires right before the loading of the Member registration screen template file. 
    273          * 
    274          * @since 1.5.0 
    275          */ 
    276         do_action( 'bp_core_screen_signup' ); 
    277  
    278         /** 
    279          * Filters the template to load for the Member registration page screen. 
    280          * 
    281          * @since 1.5.0 
    282          * 
    283          * @param string $value Path to the Member registration template to load. 
    284          */ 
    285         bp_core_load_template( apply_filters( 'bp_core_template_register', array( 'register', 'registration/register' ) ) ); 
    286 } 
    287 add_action( 'bp_screens', 'bp_core_screen_signup' ); 
    288  
    289 /** 
    290  * Handle the loading of the Activate screen. 
    291  * 
    292  * @since 1.1.0 
    293  * 
    294  * @todo Move the actual activation process into an action in bp-members-actions.php 
    295  */ 
    296 function bp_core_screen_activation() { 
    297  
    298         // Bail if not viewing the activation page. 
    299         if ( ! bp_is_current_component( 'activate' ) ) { 
    300                 return false; 
    301         } 
    302  
    303         // If the user is already logged in, redirect away from here. 
    304         if ( is_user_logged_in() ) { 
    305  
    306                 // If activation page is also front page, set to members directory to 
    307                 // avoid an infinite loop. Otherwise, set to root domain. 
    308                 $redirect_to = bp_is_component_front_page( 'activate' ) 
    309                         ? bp_get_members_directory_permalink() 
    310                         : bp_get_root_domain(); 
    311  
    312                 // Trailing slash it, as we expect these URL's to be. 
    313                 $redirect_to = trailingslashit( $redirect_to ); 
    314  
    315                 /** 
    316                  * Filters the URL to redirect logged in users to when visiting activation page. 
    317                  * 
    318                  * @since 1.9.0 
    319                  * 
    320                  * @param string $redirect_to URL to redirect user to. 
    321                  */ 
    322                 $redirect_to = apply_filters( 'bp_loggedin_activate_page_redirect_to', $redirect_to ); 
    323  
    324                 // Redirect away from the activation page. 
    325                 bp_core_redirect( $redirect_to ); 
    326         } 
    327  
    328         // Grab the key (the old way). 
    329         $key = isset( $_GET['key'] ) ? $_GET['key'] : ''; 
    330  
    331         // Grab the key (the new way). 
    332         if ( empty( $key ) ) { 
    333                 $key = bp_current_action(); 
    334         } 
    335  
    336         // Get BuddyPress. 
    337         $bp = buddypress(); 
    338  
    339         // We've got a key; let's attempt to activate the signup. 
    340         if ( ! empty( $key ) ) { 
    341  
    342                 /** 
    343                  * Filters the activation signup. 
    344                  * 
    345                  * @since 1.1.0 
    346                  * 
    347                  * @param bool|int $value Value returned by activation. 
    348                  *                        Integer on success, boolean on failure. 
    349                  */ 
    350                 $user = apply_filters( 'bp_core_activate_account', bp_core_activate_signup( $key ) ); 
    351  
    352                 // If there were errors, add a message and redirect. 
    353                 if ( ! empty( $user->errors ) ) { 
    354                         bp_core_add_message( $user->get_error_message(), 'error' ); 
    355                         bp_core_redirect( trailingslashit( bp_get_root_domain() . '/' . $bp->pages->activate->slug ) ); 
    356                 } 
    357  
    358                 bp_core_add_message( __( 'Your account is now active!', 'buddypress' ) ); 
    359                 $bp->activation_complete = true; 
    360         } 
    361  
    362         /** 
    363          * Filters the template to load for the Member activation page screen. 
    364          * 
    365          * @since 1.1.1 
    366          * 
    367          * @param string $value Path to the Member activation template to load. 
    368          */ 
    369         bp_core_load_template( apply_filters( 'bp_core_template_activate', array( 'activate', 'registration/activate' ) ) ); 
    370 } 
    371 add_action( 'bp_screens', 'bp_core_screen_activation' ); 
    372  
    37367/** Theme Compatibility *******************************************************/ 
    37468 
    37569new BP_Members_Theme_Compat(); 
    376 new BP_Registration_Theme_Compat(); 
  • src/bp-members/classes/class-bp-members-component.php

     
    5757 
    5858                // Always include these files. 
    5959                $includes = array( 
    60                         'actions', 
    6160                        'filters', 
    62                         'screens', 
    6361                        'template', 
    6462                        'adminbar', 
    6563                        'functions', 
     
    7169                        $includes[] = 'activity'; 
    7270                } 
    7371 
     72                // Include frontend action code for test suite. 
     73                if ( function_exists( 'tests_add_filter' ) ) { 
     74                        $includes[] = 'actions'; 
     75                        $includes[] = 'screens'; 
     76                        $includes[] = 'register'; 
     77 
     78                // Otherwise, only include frontend action code when on members component. 
     79                } else { 
     80                        add_action( 'bp_setup_canonical_stack', array( $this, 'late_includes' ), 20 ); 
     81                } 
     82 
    7483                // Include these only if in admin. 
    7584                if ( is_admin() ) { 
    7685                        $includes[] = 'admin'; 
     
    8089        } 
    8190 
    8291        /** 
     92         * Late includes method 
     93         * 
     94         * Only load up member-specific action and screen code when on a member page. 
     95         * 
     96         * @since 2.9.0 
     97         */ 
     98        public function late_includes() { 
     99                if ( bp_is_current_component( 'register' ) || bp_is_current_component( 'activate' ) ) { 
     100                        require $this->path . 'bp-members/bp-members-register.php'; 
     101                } elseif ( bp_is_members_directory() || bp_is_user() ) { 
     102                        require $this->path . 'bp-members/bp-members-actions.php'; 
     103                        require $this->path . 'bp-members/bp-members-screens.php'; 
     104                } 
     105        } 
     106 
     107        /** 
    83108         * Set up bp-members global settings. 
    84109         * 
    85110         * The BP_MEMBERS_SLUG constant is deprecated, and only used here for