· 9 years ago · Sep 06, 2017, 06:34 AM
1<?php
2/*
3 Plugin Name: New User Approve
4 Plugin URI: http://www.picklewagon.com/wordpress/new-user-approve/
5 Description: Allow administrators to approve users once they register. Only approved users will be allowed to access the site. For support, please go to the <a href="http://wordpress.org/support/plugin/new-user-approve">support forums</a> on wordpress.org.
6 Author: Josh Harrison
7 Version: 1.7.5
8 Author URI: http://picklewagon.com/
9 */
10
11class pw_new_user_approve {
12
13 /**
14 * The only instance of pw_new_user_approve.
15 *
16 * @var pw_new_user_approve
17 */
18 private static $instance;
19
20 /**
21 * Returns the main instance.
22 *
23 * @return pw_new_user_approve
24 */
25 public static function instance() {
26 if ( !isset( self::$instance ) ) {
27 self::$instance = new pw_new_user_approve();
28
29 self::$instance->includes();
30 self::$instance->email_tags = new NUA_Email_Template_Tags();
31 }
32 return self::$instance;
33 }
34
35 private function __construct() {
36 // Load up the localization file if we're using WordPress in a different language
37 // Just drop it in this plugin's "localization" folder and name it "new-user-approve-[value in wp-config].mo"
38 load_plugin_textdomain( 'new-user-approve', false, dirname( plugin_basename( __FILE__ ) ) . '/localization' );
39
40 register_activation_hook( __FILE__, array( $this, 'activation' ) );
41 register_deactivation_hook( __FILE__, array( $this, 'deactivation' ) );
42
43 // Actions
44 add_action( 'wp_loaded', array( $this, 'admin_loaded' ) );
45 add_action( 'rightnow_end', array( $this, 'dashboard_stats' ) );
46 add_action( 'user_register', array( $this, 'delete_new_user_approve_transient' ), 11 );
47 add_action( 'new_user_approve_approve_user', array( $this, 'delete_new_user_approve_transient' ), 11 );
48 add_action( 'new_user_approve_deny_user', array( $this, 'delete_new_user_approve_transient' ), 11 );
49 add_action( 'deleted_user', array( $this, 'delete_new_user_approve_transient' ) );
50 //add_action( 'register_post', array( $this, 'request_admin_approval_email' ), 10, 3 );
51 add_action( 'register_post', array( $this, 'create_new_user' ), 10, 3 );
52 add_action( 'lostpassword_post', array( $this, 'lost_password' ) );
53 add_action( 'user_register', array( $this, 'add_user_status' ) );
54 add_action( 'user_register', array( $this, 'request_admin_approval_email_2' ) );
55 add_action( 'new_user_approve_approve_user', array( $this, 'approve_user' ) );
56 add_action( 'new_user_approve_deny_user', array( $this, 'deny_user' ) );
57 add_action( 'new_user_approve_deny_user', array( $this, 'update_deny_status' ) );
58 add_action( 'admin_init', array( $this, 'verify_settings' ) );
59 add_action( 'wp_login', array( $this, 'login_user' ), 10, 2 );
60
61 // Filters
62 add_filter( 'wp_authenticate_user', array( $this, 'authenticate_user' ) );
63 add_filter( 'registration_errors', array( $this, 'show_user_pending_message' ) );
64 add_filter( 'login_message', array( $this, 'welcome_user' ) );
65 add_filter( 'new_user_approve_validate_status_update', array( $this, 'validate_status_update' ), 10, 3 );
66 add_filter( 'shake_error_codes', array( $this, 'failure_shake' ) );
67 }
68
69 public function get_plugin_url() {
70 return plugin_dir_url( __FILE__ );
71 }
72
73 public function get_plugin_dir() {
74 return plugin_dir_path( __FILE__ );
75 }
76
77 /**
78 * Include required files
79 *
80 * @access private
81 * @since 1.4
82 * @return void
83 */
84 private function includes() {
85 require_once( $this->get_plugin_dir() . 'includes/email-tags.php' );
86 require_once( $this->get_plugin_dir() . 'includes/messages.php' );
87 }
88
89 /**
90 * Require a minimum version of WordPress on activation
91 *
92 * @uses register_activation_hook
93 */
94 public function activation() {
95 global $wp_version;
96
97 $min_wp_version = '3.5.1';
98 $exit_msg = sprintf( __( 'New User Approve requires WordPress %s or newer.', 'new-user-approve' ), $min_wp_version );
99 if ( version_compare( $wp_version, $min_wp_version, '<' ) ) {
100 exit( $exit_msg );
101 }
102
103 // since the right version of WordPress is being used, run a hook
104 do_action( 'new_user_approve_activate' );
105 }
106
107 /**
108 * @uses register_deactivation_hook
109 */
110 public function deactivation() {
111 do_action( 'new_user_approve_deactivate' );
112 }
113
114 /**
115 * Verify settings upon activation
116 *
117 * @uses admin_init
118 */
119 public function verify_settings() {
120 // make sure the membership setting is turned on
121 if ( get_option( 'users_can_register' ) != 1 ) {
122 add_action( 'admin_notices', array( $this, 'admin_notices' ) );
123 }
124 }
125
126 /**
127 * Show admin notice if the membership setting is turned off.
128 */
129 public function admin_notices() {
130 $user_id = get_current_user_id();
131
132 // if the user isn't an admin, definitely don't show the notice
133 if ( ! current_user_can( 'manage_options' ) ) {
134 return;
135 }
136
137 // update the setting for the current user
138 if ( isset( $_GET['new-user-approve-settings-notice'] ) && '1' == $_GET['new-user-approve-settings-notice'] ) {
139 add_user_meta( $user_id, 'pw_new_user_approve_settings_notice', '1', true );
140 }
141
142 $show_notice = get_user_meta( $user_id, 'pw_new_user_approve_settings_notice' );
143
144 // one last chance to show the update
145 $show_notice = apply_filters( 'new_user_approve_show_membership_notice', $show_notice, $user_id );
146
147 // Check that the user hasn't already clicked to ignore the message
148 if ( ! $show_notice ) {
149 echo '<div class="error"><p>';
150 printf( __( 'The Membership setting must be turned on in order for the New User Approve to work correctly. <a href="%1$s">Update in settings</a>. | <a href="%2$s">Hide Notice</a>', 'new-user-approve' ), admin_url( 'options-general.php' ), add_query_arg( array( 'new-user-approve-settings-notice' => 1 ) ) );
151 echo "</p></div>";
152 }
153 }
154
155 /**
156 * Makes it possible to disable the user admin integration. Must happen after
157 * WordPress is loaded.
158 *
159 * @uses wp_loaded
160 */
161 public function admin_loaded() {
162 $user_admin_integration = apply_filters( 'new_user_approve_user_admin_integration', true );
163 if ( $user_admin_integration ) {
164 require_once( dirname( __FILE__ ) . '/includes/user-list.php' );
165 }
166
167 $legacy_panel = apply_filters( 'new_user_approve_user_admin_legacy', true );
168 if ( $legacy_panel ) {
169 require_once( dirname( __FILE__ ) . '/includes/admin-approve.php' );
170 }
171 }
172
173 /**
174 * Get the status of a user.
175 *
176 * @param int $user_id
177 * @return string the status of the user
178 */
179 public function get_user_status( $user_id ) {
180 $user_status = get_user_meta( $user_id, 'pw_user_status', true );
181
182 if ( empty( $user_status ) ) {
183 $user_status = 'approved';
184 }
185
186 return $user_status;
187 }
188
189 /**
190 * Update the status of a user. The new status must be either 'approve' or 'deny'.
191 *
192 * @param int $user
193 * @param string $status
194 *
195 * @return boolean
196 */
197 public function update_user_status( $user, $status ) {
198 $user_id = absint( $user );
199 if ( !$user_id ) {
200 return false;
201 }
202
203 if ( !in_array( $status, array( 'approve', 'deny' ) ) ) {
204 return false;
205 }
206
207 $do_update = apply_filters( 'new_user_approve_validate_status_update', true, $user_id, $status );
208 if ( !$do_update ) {
209 return false;
210 }
211
212 // where it all happens
213 do_action( 'new_user_approve_' . $status . '_user', $user_id );
214 do_action( 'new_user_approve_user_status_update', $user_id, $status );
215
216 return true;
217 }
218
219 /**
220 * Get the valid statuses. Anything outside of the returned array is an invalid status.
221 *
222 * @return array
223 */
224 public function get_valid_statuses() {
225 return array( 'pending', 'approved', 'denied' );
226 }
227
228 /**
229 * Only validate the update if the status has been updated to prevent unnecessary update
230 * and especially emails.
231 *
232 * @param bool $do_update
233 * @param int $user_id
234 * @param string $status either 'approve' or 'deny'
235 */
236 public function validate_status_update( $do_update, $user_id, $status ) {
237 $current_status = pw_new_user_approve()->get_user_status( $user_id );
238
239 if ( $status == 'approve' ) {
240 $new_status = 'approved';
241 } else {
242 $new_status = 'denied';
243 }
244
245 if ( $current_status == $new_status ) {
246 $do_update = false;
247 }
248
249 return $do_update;
250 }
251
252 /**
253 * The default message that is shown to a user depending on their status
254 * when trying to sign in.
255 *
256 * @return string
257 */
258 public function default_authentication_message( $status ) {
259 $message = '';
260
261 if ( $status == 'pending' ) {
262 $message = __( '<strong>ERROR</strong>: Your account is still pending approval.', 'new-user-approve' );
263 $message = apply_filters( 'new_user_approve_pending_error', $message );
264 } else if ( $status == 'denied' ) {
265 $message = __( '<strong>ERROR</strong>: Your account has been denied access to this site.', 'new-user-approve' );
266 $message = apply_filters( 'new_user_approve_denied_error', $message );
267 }
268
269 $message = apply_filters( 'new_user_approve_default_authentication_message', $message, $status );
270
271 return $message;
272 }
273
274 /**
275 * Determine if the user is good to sign in based on their status.
276 *
277 * @uses wp_authenticate_user
278 * @param array $userdata
279 */
280 public function authenticate_user( $userdata ) {
281 $status = $this->get_user_status( $userdata->ID );
282
283 if ( empty( $status ) ) {
284 // the user does not have a status so let's assume the user is good to go
285 return $userdata;
286 }
287
288 $message = false;
289 switch ( $status ) {
290 case 'pending':
291 $pending_message = $this->default_authentication_message( 'pending' );
292 $message = new WP_Error( 'pending_approval', $pending_message );
293 break;
294 case 'denied':
295 $denied_message = $this->default_authentication_message( 'denied' );
296 $message = new WP_Error( 'denied_access', $denied_message );
297 break;
298 case 'approved':
299 $message = $userdata;
300 break;
301 }
302
303 return $message;
304 }
305
306 public function _get_user_statuses($count = true) {
307 $statuses = array();
308
309 foreach ( $this->get_valid_statuses() as $status ) {
310 // Query the users table
311 if ( $status != 'approved' ) {
312 // Query the users table
313 $query = array(
314 'meta_key' => 'pw_user_status',
315 'meta_value' => $status,
316 'count_total' => true,
317 'number' => 1,
318 );
319 } else {
320 // get all approved users and any user without a status
321 $query = array(
322 'meta_query' => array(
323 'relation' => 'OR',
324 array(
325 'key' => 'pw_user_status',
326 'value' => 'approved',
327 'compare' => '=',
328 ),
329 array(
330 'key' => 'pw_user_status',
331 'value' => '',
332 'compare' => 'NOT EXISTS',
333 ),
334 ),
335 'count_total' => true,
336 'number' => 1,
337 );
338 }
339
340 if ($count === false) {
341 unset($query['count_total']);
342 unset($query['number']);
343 }
344 $wp_user_search = new WP_User_Query( $query );
345
346 if ($count === true) {
347 $statuses[$status] = $wp_user_search->get_total();
348 } else {
349 $statuses[$status] = $wp_user_search->get_results();
350 }
351 }
352
353 return $statuses;
354 }
355
356 /**
357 * Get a list of statuses with a count of users with that status and save them using a transient
358 */
359 public function get_count_of_user_statuses() {
360 $user_statuses = get_transient( 'new_user_approve_user_statuses_count' );
361
362 if ( false === $user_statuses ) {
363 $user_statuses = $this->_get_user_statuses();
364 set_transient( 'new_user_approve_user_statuses_count', $user_statuses );
365 }
366
367 return $user_statuses;
368 }
369
370 public function get_user_statuses() {
371 $user_statuses = get_transient( 'new_user_approve_user_statuses' );
372
373 if ( false === $user_statuses ) {
374 $user_statuses = $this->_get_user_statuses(false);
375 set_transient( 'new_user_approve_user_statuses', $user_statuses );
376 }
377
378 foreach ( $this->get_valid_statuses() as $status ) {
379 $user_statuses[$status] = apply_filters( 'new_user_approve_user_status', $user_statuses[$status], $status );
380 }
381
382 return $user_statuses;
383 }
384
385 /**
386 * Delete the transient storing all of the user statuses.
387 *
388 * @uses user_register
389 * @uses deleted_user
390 * @uses new_user_approve_approve_user
391 * @uses new_user_approve_deny_user
392 */
393 public function delete_new_user_approve_transient() {
394 delete_transient( 'new_user_approve_user_statuses' );
395 }
396
397 /**
398 * Display the stats on the WP dashboard. Will show 1 line with a count
399 * of users and their status.
400 *
401 * @uses rightnow_end
402 */
403 public function dashboard_stats() {
404 $user_status = $this->get_count_of_user_statuses();
405 ?>
406 <div>
407 <p>
408 <span style="font-weight:bold;">
409 <a href="<?php echo apply_filters( 'new_user_approve_dashboard_link', 'users.php' ); ?>"><?php _e( 'Users', 'new-user-approve' ); ?></a>
410 </span>:
411 <?php foreach ( $user_status as $status => $count ) :
412 print __( ucwords($status), 'new-user-approve' ) . "(" .$count . ") ";
413 endforeach; ?>
414 </p>
415 </div>
416 <?php
417 }
418
419 /**
420 * Send email to admin requesting approval.
421 *
422 * @param $user_login username
423 * @param $user_email email address of the user
424 */
425 public function admin_approval_email( $user_login, $user_email ) {
426 $default_admin_url = admin_url( 'users.php?s&pw-status-query-submit=Filter&new_user_approve_filter=pending&paged=1' );
427 $admin_url = apply_filters( 'new_user_approve_admin_link', $default_admin_url );
428
429 /* send email to admin for approval */
430 $message = apply_filters( 'new_user_approve_request_approval_message_default', nua_default_notification_message() );
431
432 $message = nua_do_email_tags( $message, array(
433 'context' => 'request_admin_approval_email',
434 'user_login' => $user_login,
435 'user_email' => $user_email,
436 'admin_url' => $admin_url,
437 ) );
438 $message = apply_filters( 'new_user_approve_request_approval_message', $message, $user_login, $user_email );
439
440 $subject = sprintf( __( '[%s] User Approval', 'new-user-approve' ), wp_specialchars_decode( get_option( 'blogname' ), ENT_QUOTES ) );
441 $subject = apply_filters( 'new_user_approve_request_approval_subject', $subject );
442
443 $to = apply_filters( 'new_user_approve_email_admins', array( get_option( 'admin_email' ) ) );
444 $to = array_unique( $to );
445
446 // send the mail
447 wp_mail( $to, $subject, $message, $this->email_message_headers() );
448 }
449
450 /**
451 * Send an email to the admin to request approval. If there are already errors,
452 * just go back and let core do it's thing.
453 *
454 * @uses register_post
455 * @param string $user_login
456 * @param string $user_email
457 * @param object $errors
458 */
459 public function request_admin_approval_email( $user_login, $user_email, $errors ) {
460 if ( $errors->get_error_code() ) {
461 return;
462 }
463
464 $this->admin_approval_email( $user_login, $user_email );
465 }
466
467 /**
468 * Send an email to the admin to request approval.
469 *
470 * @uses user_register
471 * @param int $user_id
472 */
473 public function request_admin_approval_email_2( $user_id ) {
474 $user = new WP_User( $user_id );
475
476 $user_login = stripslashes( $user->data->user_login );
477 $user_email = stripslashes( $user->data->user_email );
478
479 $this->admin_approval_email( $user_login, $user_email );
480 }
481
482 /**
483 * Create a new user after the registration has been validated. Normally,
484 * when a user registers, an email is sent to the user containing their
485 * username and password. The email does not get sent to the user until
486 * the user is approved when using the default behavior of this plugin.
487 *
488 * @uses register_post
489 * @param string $user_login
490 * @param string $user_email
491 * @param object $errors
492 */
493 public function create_new_user( $user_login, $user_email, $errors ) {
494 if ( $errors->get_error_code() ) {
495 return;
496 }
497
498 // create the user
499 $user_pass = wp_generate_password( 12, false );
500 $user_id = wp_create_user( $user_login, $user_pass, $user_email );
501 if ( !$user_id ) {
502 $errors->add( 'registerfail', sprintf( __( '<strong>ERROR</strong>: Couldn’t register you... please contact the <a href="mailto:%s">webmaster</a> !' ), get_option( 'admin_email' ) ) );
503 }
504 }
505
506 /**
507 * Determine whether a password needs to be reset.
508 *
509 * password should only be reset for users that:
510 * * have never logged in
511 * * are just approved for the first time
512 *
513 * @return boolean
514 */
515 public function do_password_reset( $user_id ) {
516 // Default behavior is to reset password
517 $do_password_reset = true;
518
519 // Get the current user status. By default each user is given a pending
520 // status when the user is created (with this plugin activated). If the
521 // user was created while this plugin was not active, the user will not
522 // have a status set.
523 $user_status = get_user_meta( $user_id, 'pw_user_status' );
524
525 // if no status is set, don't reset password
526 if ( empty( $user_status ) ) {
527 $do_password_reset = false;
528 }
529
530 // if user has signed in, don't reset password
531 $user_has_signed_in = get_user_meta( $user_id, 'pw_new_user_approve_has_signed_in' );
532 if ( $user_has_signed_in ) {
533 $do_password_reset = false;
534 }
535
536 // for backward compatability
537 $bypass_password_reset = apply_filters( 'new_user_approve_bypass_password_reset', !$do_password_reset );
538
539 return apply_filters( 'new_user_approve_do_password_reset', !$bypass_password_reset );
540 }
541
542 /**
543 * Admin approval of user
544 *
545 * @uses new_user_approve_approve_user
546 */
547 public function approve_user( $user_id ) {
548 $user = new WP_User( $user_id );
549
550 wp_cache_delete( $user->ID, 'users' );
551 wp_cache_delete( $user->data->user_login, 'userlogins' );
552
553 // send email to user telling of approval
554 $user_login = stripslashes( $user->data->user_login );
555 $user_email = stripslashes( $user->data->user_email );
556
557 // format the message
558 $message = nua_default_approve_user_message();
559
560 $message = nua_do_email_tags( $message, array(
561 'context' => 'approve_user',
562 'user' => $user,
563 'user_login' => $user_login,
564 'user_email' => $user_email,
565 ) );
566 $message = apply_filters( 'new_user_approve_approve_user_message', $message, $user );
567
568 $subject = sprintf( __( '[%s] Registration Approved', 'new-user-approve' ), get_option( 'blogname' ) );
569 $subject = apply_filters( 'new_user_approve_approve_user_subject', $subject );
570
571 // send the mail
572 wp_mail( $user_email, $subject, $message, $this->email_message_headers() );
573
574 // change usermeta tag in database to approved
575 update_user_meta( $user->ID, 'pw_user_status', 'approved' );
576
577 do_action( 'new_user_approve_user_approved', $user );
578 }
579
580 /**
581 * Send email to notify user of denial.
582 *
583 * @uses new_user_approve_deny_user
584 */
585 public function deny_user( $user_id ) {
586 $user = new WP_User( $user_id );
587
588 // send email to user telling of denial
589 $user_email = stripslashes( $user->user_email );
590
591 // format the message
592 $message = nua_default_deny_user_message();
593 $message = nua_do_email_tags( $message, array(
594 'context' => 'deny_user',
595 ) );
596 $message = apply_filters( 'new_user_approve_deny_user_message', $message, $user );
597
598 $subject = sprintf( __( '[%s] Registration Denied', 'new-user-approve' ), get_option( 'blogname' ) );
599 $subject = apply_filters( 'new_user_approve_deny_user_subject', $subject );
600
601 // send the mail
602 wp_mail( $user_email, $subject, $message, $this->email_message_headers() );
603 }
604
605 /**
606 * Update user status when denying user.
607 *
608 * @uses new_user_approve_deny_user
609 */
610 public function update_deny_status( $user_id ) {
611 $user = new WP_User( $user_id );
612
613 // change usermeta tag in database to denied
614 update_user_meta( $user->ID, 'pw_user_status', 'denied' );
615
616 do_action( 'new_user_approve_user_denied', $user );
617 }
618
619 public function email_message_headers() {
620 $admin_email = get_option( 'admin_email' );
621 if ( empty( $admin_email ) ) {
622 $admin_email = 'support@' . $_SERVER['SERVER_NAME'];
623 }
624
625 $from_name = get_option( 'blogname' );
626
627 $headers = array(
628 "From: \"{$from_name}\" <{$admin_email}>\n",
629 );
630
631 $headers = apply_filters( 'new_user_approve_email_header', $headers );
632
633 return $headers;
634 }
635
636 /**
637 * Display a message to the user after they have registered
638 *
639 * @uses registration_errors
640 */
641 public function show_user_pending_message( $errors ) {
642 if ( !empty( $_POST['redirect_to'] ) ) {
643 // if a redirect_to is set, honor it
644 wp_safe_redirect( $_POST['redirect_to'] );
645 exit();
646 }
647
648 // if there is an error already, let it do it's thing
649 if ( $errors->get_error_code() ) {
650 return $errors;
651 }
652
653 $message = nua_default_registration_complete_message();
654 $message = nua_do_email_tags( $message, array(
655 'context' => 'pending_message',
656 ) );
657 $message = apply_filters( 'new_user_approve_pending_message', $message );
658
659 $errors->add( 'registration_required', $message, 'message' );
660
661 $success_message = __( 'Registration successful.', 'new-user-approve' );
662 $success_message = apply_filters( 'new_user_approve_registration_message', $success_message );
663
664 login_header( __( 'Pending Approval', 'new-user-approve' ), '<p class="message register">' . $success_message . '</p>', $errors );
665 login_footer();
666
667 // an exit is necessary here so the normal process for user registration doesn't happen
668 exit();
669 }
670
671 /**
672 * Only give a user their password if they have been approved
673 *
674 * @uses lostpassword_post
675 */
676 public function lost_password() {
677 $is_email = strpos( $_POST['user_login'], '@' );
678 if ( $is_email === false ) {
679 $username = sanitize_user( $_POST['user_login'] );
680 $user_data = get_user_by( 'login', trim( $username ) );
681 } else {
682 $email = is_email( $_POST['user_login'] );
683 $user_data = get_user_by( 'email', $email );
684 }
685
686 if ( $user_data->pw_user_status && $user_data->pw_user_status != 'approved' ) {
687 wp_redirect( 'wp-login.php' );
688 exit();
689 }
690 }
691
692 /**
693 * Add message to login page saying registration is required.
694 *
695 * @uses login_message
696 * @param string $message
697 * @return string
698 */
699 public function welcome_user( $message ) {
700 if ( !isset( $_GET['action'] ) ) {
701 $welcome = nua_default_welcome_message();
702 $welcome = nua_do_email_tags( $welcome, array(
703 'context' => 'welcome_message',
704 ) );
705 $welcome = apply_filters( 'new_user_approve_welcome_message', $welcome );
706
707 if ( !empty( $welcome ) ) {
708 $message .= '<p class="message register">' . $welcome . '</p>';
709 }
710 }
711
712 if ( isset( $_GET['action'] ) && $_GET['action'] == 'register' && !$_POST ) {
713 $instructions = nua_default_registration_message();
714 $instructions = nua_do_email_tags( $instructions, array(
715 'context' => 'registration_message',
716 ) );
717 $instructions = apply_filters( 'new_user_approve_register_instructions', $instructions );
718
719 if ( !empty( $instructions ) ) {
720 $message .= '<p class="message register">' . $instructions . '</p>';
721 }
722 }
723
724 return $message;
725 }
726
727 /**
728 * Give the user a status
729 *
730 * @uses user_register
731 * @param int $user_id
732 */
733 public function add_user_status( $user_id ) {
734 $status = 'pending';
735
736 // This check needs to happen when a user is created in the admin
737 if ( isset( $_REQUEST['action'] ) && 'createuser' == $_REQUEST['action'] ) {
738 $status = 'approved';
739 }
740
741 $status = apply_filters( 'new_user_approve_default_status', $status, $user_id );
742
743 update_user_meta( $user_id, 'pw_user_status', $status );
744 }
745
746 /**
747 * Add error codes to shake the login form on failure
748 *
749 * @uses shake_error_codes
750 * @param $error_codes
751 * @return array
752 */
753 public function failure_shake( $error_codes ) {
754 $error_codes[] = 'pending_approval';
755 $error_codes[] = 'denied_access';
756
757 return $error_codes;
758 }
759
760 /**
761 * After a user successfully logs in, record in user meta. This will only be recorded
762 * one time. The password will not be reset after a successful login.
763 *
764 * @uses wp_login
765 * @param $user_login
766 * @param $user
767 */
768 public function login_user( $user_login, $user = null ) {
769 if ( $user != null && is_object( $user ) ) {
770 if ( ! get_user_meta( $user->ID, 'pw_new_user_approve_has_signed_in' ) ) {
771 add_user_meta( $user->ID, 'pw_new_user_approve_has_signed_in', time() );
772 }
773 }
774 }
775} // End Class
776
777function pw_new_user_approve() {
778 return pw_new_user_approve::instance();
779}
780
781pw_new_user_approve();