· 9 years ago · Sep 05, 2017, 06:48 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, $user_id ) {
426
427 $user_id = get_current_user_id();
428 $default_admin_url = admin_url( 'user-edit.php?user_id=' . $user_id . 'test' );
429 $admin_url = apply_filters( 'new_user_approve_admin_link', $default_admin_url );
430
431 /* send email to admin for approval */
432 $message = apply_filters( 'new_user_approve_request_approval_message_default', nua_default_notification_message() );
433
434 $message = nua_do_email_tags( $message, array(
435 'context' => 'request_admin_approval_email',
436 'user_login' => $user_login,
437 'user_email' => $user_email,
438 'admin_url' => $admin_url,
439 ) );
440 $message = apply_filters( 'new_user_approve_request_approval_message', $message, $user_login, $user_email );
441
442 $subject = sprintf( __( '[%s] User Approval', 'new-user-approve' ), wp_specialchars_decode( get_option( 'blogname' ), ENT_QUOTES ) );
443 $subject = apply_filters( 'new_user_approve_request_approval_subject', $subject );
444
445 $to = apply_filters( 'new_user_approve_email_admins', array( get_option( 'admin_email' ) ) );
446 $to = array_unique( $to );
447
448 // send the mail
449 wp_mail( $to, $subject, $message, $this->email_message_headers() );
450 }
451
452 /**
453 * Send an email to the admin to request approval. If there are already errors,
454 * just go back and let core do it's thing.
455 *
456 * @uses register_post
457 * @param string $user_login
458 * @param string $user_email
459 * @param object $errors
460 */
461 public function request_admin_approval_email( $user_login, $user_email, $errors ) {
462 if ( $errors->get_error_code() ) {
463 return;
464 }
465
466 $this->admin_approval_email( $user_login, $user_email );
467 }
468
469 /**
470 * Send an email to the admin to request approval.
471 *
472 * @uses user_register
473 * @param int $user_id
474 */
475 public function request_admin_approval_email_2( $user_id ) {
476 $user = new WP_User( $user_id );
477
478 $user_login = stripslashes( $user->data->user_login );
479 $user_email = stripslashes( $user->data->user_email );
480
481 $this->admin_approval_email( $user_login, $user_email );
482 }
483
484 /**
485 * Create a new user after the registration has been validated. Normally,
486 * when a user registers, an email is sent to the user containing their
487 * username and password. The email does not get sent to the user until
488 * the user is approved when using the default behavior of this plugin.
489 *
490 * @uses register_post
491 * @param string $user_login
492 * @param string $user_email
493 * @param object $errors
494 */
495 public function create_new_user( $user_login, $user_email, $errors ) {
496 if ( $errors->get_error_code() ) {
497 return;
498 }
499
500 // create the user
501 $user_pass = wp_generate_password( 12, false );
502 $user_id = wp_create_user( $user_login, $user_pass, $user_email );
503 if ( !$user_id ) {
504 $errors->add( 'registerfail', sprintf( __( '<strong>ERROR</strong>: Couldn’t register you... please contact the <a href="mailto:%s">webmaster</a> !' ), get_option( 'admin_email' ) ) );
505 }
506 }
507
508 /**
509 * Determine whether a password needs to be reset.
510 *
511 * password should only be reset for users that:
512 * * have never logged in
513 * * are just approved for the first time
514 *
515 * @return boolean
516 */
517 public function do_password_reset( $user_id ) {
518 // Default behavior is to reset password
519 $do_password_reset = true;
520
521 // Get the current user status. By default each user is given a pending
522 // status when the user is created (with this plugin activated). If the
523 // user was created while this plugin was not active, the user will not
524 // have a status set.
525 $user_status = get_user_meta( $user_id, 'pw_user_status' );
526
527 // if no status is set, don't reset password
528 if ( empty( $user_status ) ) {
529 $do_password_reset = false;
530 }
531
532 // if user has signed in, don't reset password
533 $user_has_signed_in = get_user_meta( $user_id, 'pw_new_user_approve_has_signed_in' );
534 if ( $user_has_signed_in ) {
535 $do_password_reset = false;
536 }
537
538 // for backward compatability
539 $bypass_password_reset = apply_filters( 'new_user_approve_bypass_password_reset', !$do_password_reset );
540
541 return apply_filters( 'new_user_approve_do_password_reset', !$bypass_password_reset );
542 }
543
544 /**
545 * Admin approval of user
546 *
547 * @uses new_user_approve_approve_user
548 */
549 public function approve_user( $user_id ) {
550 $user = new WP_User( $user_id );
551
552 wp_cache_delete( $user->ID, 'users' );
553 wp_cache_delete( $user->data->user_login, 'userlogins' );
554
555 // send email to user telling of approval
556 $user_login = stripslashes( $user->data->user_login );
557 $user_email = stripslashes( $user->data->user_email );
558
559 // format the message
560 $message = nua_default_approve_user_message();
561
562 $message = nua_do_email_tags( $message, array(
563 'context' => 'approve_user',
564 'user' => $user,
565 'user_login' => $user_login,
566 'user_email' => $user_email,
567 ) );
568 $message = apply_filters( 'new_user_approve_approve_user_message', $message, $user );
569
570 $subject = sprintf( __( '[%s] Registration Approved', 'new-user-approve' ), get_option( 'blogname' ) );
571 $subject = apply_filters( 'new_user_approve_approve_user_subject', $subject );
572
573 // send the mail
574 wp_mail( $user_email, $subject, $message, $this->email_message_headers() );
575
576 // change usermeta tag in database to approved
577 update_user_meta( $user->ID, 'pw_user_status', 'approved' );
578
579 do_action( 'new_user_approve_user_approved', $user );
580 }
581
582 /**
583 * Send email to notify user of denial.
584 *
585 * @uses new_user_approve_deny_user
586 */
587 public function deny_user( $user_id ) {
588 $user = new WP_User( $user_id );
589
590 // send email to user telling of denial
591 $user_email = stripslashes( $user->user_email );
592
593 // format the message
594 $message = nua_default_deny_user_message();
595 $message = nua_do_email_tags( $message, array(
596 'context' => 'deny_user',
597 ) );
598 $message = apply_filters( 'new_user_approve_deny_user_message', $message, $user );
599
600 $subject = sprintf( __( '[%s] Registration Denied', 'new-user-approve' ), get_option( 'blogname' ) );
601 $subject = apply_filters( 'new_user_approve_deny_user_subject', $subject );
602
603 // send the mail
604 wp_mail( $user_email, $subject, $message, $this->email_message_headers() );
605 }
606
607 /**
608 * Update user status when denying user.
609 *
610 * @uses new_user_approve_deny_user
611 */
612 public function update_deny_status( $user_id ) {
613 $user = new WP_User( $user_id );
614
615 // change usermeta tag in database to denied
616 update_user_meta( $user->ID, 'pw_user_status', 'denied' );
617
618 do_action( 'new_user_approve_user_denied', $user );
619 }
620
621 public function email_message_headers() {
622 $admin_email = get_option( 'admin_email' );
623 if ( empty( $admin_email ) ) {
624 $admin_email = 'support@' . $_SERVER['SERVER_NAME'];
625 }
626
627 $from_name = get_option( 'blogname' );
628
629 $headers = array(
630 "From: \"{$from_name}\" <{$admin_email}>\n",
631 );
632
633 $headers = apply_filters( 'new_user_approve_email_header', $headers );
634
635 return $headers;
636 }
637
638 /**
639 * Display a message to the user after they have registered
640 *
641 * @uses registration_errors
642 */
643 public function show_user_pending_message( $errors ) {
644 if ( !empty( $_POST['redirect_to'] ) ) {
645 // if a redirect_to is set, honor it
646 wp_safe_redirect( $_POST['redirect_to'] );
647 exit();
648 }
649
650 // if there is an error already, let it do it's thing
651 if ( $errors->get_error_code() ) {
652 return $errors;
653 }
654
655 $message = nua_default_registration_complete_message();
656 $message = nua_do_email_tags( $message, array(
657 'context' => 'pending_message',
658 ) );
659 $message = apply_filters( 'new_user_approve_pending_message', $message );
660
661 $errors->add( 'registration_required', $message, 'message' );
662
663 $success_message = __( 'Registration successful.', 'new-user-approve' );
664 $success_message = apply_filters( 'new_user_approve_registration_message', $success_message );
665
666 login_header( __( 'Pending Approval', 'new-user-approve' ), '<p class="message register">' . $success_message . '</p>', $errors );
667 login_footer();
668
669 // an exit is necessary here so the normal process for user registration doesn't happen
670 exit();
671 }
672
673 /**
674 * Only give a user their password if they have been approved
675 *
676 * @uses lostpassword_post
677 */
678 public function lost_password() {
679 $is_email = strpos( $_POST['user_login'], '@' );
680 if ( $is_email === false ) {
681 $username = sanitize_user( $_POST['user_login'] );
682 $user_data = get_user_by( 'login', trim( $username ) );
683 } else {
684 $email = is_email( $_POST['user_login'] );
685 $user_data = get_user_by( 'email', $email );
686 }
687
688 if ( $user_data->pw_user_status && $user_data->pw_user_status != 'approved' ) {
689 wp_redirect( 'wp-login.php' );
690 exit();
691 }
692 }
693
694 /**
695 * Add message to login page saying registration is required.
696 *
697 * @uses login_message
698 * @param string $message
699 * @return string
700 */
701 public function welcome_user( $message ) {
702 if ( !isset( $_GET['action'] ) ) {
703 $welcome = nua_default_welcome_message();
704 $welcome = nua_do_email_tags( $welcome, array(
705 'context' => 'welcome_message',
706 ) );
707 $welcome = apply_filters( 'new_user_approve_welcome_message', $welcome );
708
709 if ( !empty( $welcome ) ) {
710 $message .= '<p class="message register">' . $welcome . '</p>';
711 }
712 }
713
714 if ( isset( $_GET['action'] ) && $_GET['action'] == 'register' && !$_POST ) {
715 $instructions = nua_default_registration_message();
716 $instructions = nua_do_email_tags( $instructions, array(
717 'context' => 'registration_message',
718 ) );
719 $instructions = apply_filters( 'new_user_approve_register_instructions', $instructions );
720
721 if ( !empty( $instructions ) ) {
722 $message .= '<p class="message register">' . $instructions . '</p>';
723 }
724 }
725
726 return $message;
727 }
728
729 /**
730 * Give the user a status
731 *
732 * @uses user_register
733 * @param int $user_id
734 */
735 public function add_user_status( $user_id ) {
736 $status = 'pending';
737
738 // This check needs to happen when a user is created in the admin
739 if ( isset( $_REQUEST['action'] ) && 'createuser' == $_REQUEST['action'] ) {
740 $status = 'approved';
741 }
742
743 $status = apply_filters( 'new_user_approve_default_status', $status, $user_id );
744
745 update_user_meta( $user_id, 'pw_user_status', $status );
746 }
747
748 /**
749 * Add error codes to shake the login form on failure
750 *
751 * @uses shake_error_codes
752 * @param $error_codes
753 * @return array
754 */
755 public function failure_shake( $error_codes ) {
756 $error_codes[] = 'pending_approval';
757 $error_codes[] = 'denied_access';
758
759 return $error_codes;
760 }
761
762 /**
763 * After a user successfully logs in, record in user meta. This will only be recorded
764 * one time. The password will not be reset after a successful login.
765 *
766 * @uses wp_login
767 * @param $user_login
768 * @param $user
769 */
770 public function login_user( $user_login, $user = null ) {
771 if ( $user != null && is_object( $user ) ) {
772 if ( ! get_user_meta( $user->ID, 'pw_new_user_approve_has_signed_in' ) ) {
773 add_user_meta( $user->ID, 'pw_new_user_approve_has_signed_in', time() );
774 }
775 }
776 }
777} // End Class
778
779function pw_new_user_approve() {
780 return pw_new_user_approve::instance();
781}
782
783pw_new_user_approve();