jetpack / jetpack_vendor / automattic / jetpack-sync / src / modules / class-users.php

class-users.php in Jetpack – WP Security, Backup, Speed, & Growth 16.3-a.1, at jetpack_vendor/automattic/jetpack-sync/src/modules/class-users.php

944 lines 25.8 KB

Raw Download Zip

1	<?php
2	/**
3	* Users sync module.
4	*
5	* @package automattic/jetpack-sync
6	*/
7
8	namespace Automattic\Jetpack\Sync\Modules;
9
10	use Automattic\Jetpack\Connection\Manager;
11	use Automattic\Jetpack\Constants as Jetpack_Constants;
12	use Automattic\Jetpack\Password_Checker;
13	use Automattic\Jetpack\Sync\Defaults;
14
15	if ( ! defined( 'ABSPATH' ) ) {
16	exit( 0 );
17	}
18
19	/**
20	* Class to handle sync for users.
21	*/
22	class Users extends Module {
23	/**
24	* Maximum number of users to sync initially.
25	*
26	* @var int
27	*/
28	const MAX_INITIAL_SYNC_USERS = 100;
29
30	/**
31	* User flags we care about.
32	*
33	* @access protected
34	*
35	* @var array
36	*/
37	protected $flags = array();
38
39	/**
40	* Mapping between user fields to flags.
41	*
42	* @var array
43	*/
44	protected $user_fields_to_flags_mapping = array(
45	'user_pass' => 'password_changed',
46	'user_email' => 'email_changed',
47	'user_nicename' => 'nicename_changed',
48	'user_url' => 'url_changed',
49	'user_registered' => 'registration_date_changed',
50	'user_activation_key' => 'activation_key_changed',
51	'display_name' => 'display_name_changed',
52	);
53
54	/**
55	* Sync module name.
56	*
57	* @access public
58	*
59	* @return string
60	*/
61	public function name() {
62	return 'users';
63	}
64
65	/**
66	* The table name.
67	*
68	* @access public
69	*
70	* @return string
71	* @deprecated since 3.11.0 Use table() instead.
72	*/
73	public function table_name() {
74	_deprecated_function( __METHOD__, '3.11.0', 'Automattic\\Jetpack\\Sync\\Users->table' );
75	return 'usermeta';
76	}
77
78	/**
79	* The table in the database with the prefix.
80	*
81	* @access public
82	*
83	* @return string\|bool
84	*/
85	public function table() {
86	global $wpdb;
87	return $wpdb->usermeta;
88	}
89
90	/**
91	* The id field in the database.
92	*
93	* @access public
94	*
95	* @return string
96	*/
97	public function id_field() {
98	return 'user_id';
99	}
100
101	/**
102	* Retrieve a user by its ID.
103	* This is here to support the backfill API.
104	*
105	* @access public
106	*
107	* @param string $object_type Type of the sync object.
108	* @param int $id ID of the sync object.
109	* @return \WP_User\|bool Filtered \WP_User object, or false if the object is not a user.
110	*/
111	public function get_object_by_id( $object_type, $id ) {
112	if ( 'user' === $object_type ) {
113	$user = get_user_by( 'id', (int) $id );
114	if ( $user ) {
115	return $this->sanitize_user_and_expand( $user );
116	}
117	}
118
119	return false;
120	}
121
122	/**
123	* Initialize users action listeners.
124	*
125	* @access public
126	*
127	* @param callable $callable Action handler callable.
128	*/
129	public function init_listeners( $callable ) {
130	// Users.
131	add_action( 'user_register', array( $this, 'user_register_handler' ) );
132	add_action( 'profile_update', array( $this, 'save_user_handler' ), 10, 2 );
133
134	add_action( 'add_user_to_blog', array( $this, 'add_user_to_blog_handler' ) );
135	add_action( 'jetpack_sync_add_user', $callable, 10, 2 );
136
137	add_action( 'jetpack_sync_register_user', $callable, 10, 2 );
138	add_action( 'jetpack_sync_save_user', $callable, 10, 2 );
139
140	add_action( 'jetpack_sync_user_locale', $callable, 10, 2 );
141	add_action( 'jetpack_sync_user_locale_delete', $callable, 10, 1 );
142
143	add_action( 'deleted_user', array( $this, 'deleted_user_handler' ), 10, 2 );
144	add_action( 'jetpack_deleted_user', $callable, 10, 3 );
145	add_action( 'remove_user_from_blog', array( $this, 'remove_user_from_blog_handler' ), 10, 3 );
146	add_action( 'jetpack_removed_user_from_blog', $callable, 10, 2 );
147
148	// User roles.
149	add_action( 'add_user_role', array( $this, 'add_user_role_handler' ), 10, 2 );
150	add_action( 'set_user_role', array( $this, 'save_user_role_handler' ), 10, 3 );
151	add_action( 'remove_user_role', array( $this, 'remove_user_role_handler' ), 10, 2 );
152
153	// User capabilities.
154	add_action( 'added_user_meta', array( $this, 'maybe_save_user_meta' ), 10, 4 );
155	add_action( 'updated_user_meta', array( $this, 'maybe_save_user_meta' ), 10, 4 );
156	add_action( 'deleted_user_meta', array( $this, 'maybe_save_user_meta' ), 10, 4 );
157
158	// User authentication.
159	add_filter( 'authenticate', array( $this, 'authenticate_handler' ), 1000, 3 );
160	add_action( 'wp_login', array( $this, 'wp_login_handler' ), 10, 2 );
161
162	add_action( 'jetpack_wp_login', $callable, 10, 3 );
163
164	add_action( 'wp_logout', $callable, 10, 1 );
165	add_action( 'wp_masterbar_logout', $callable, 10, 1 );
166
167	// Add on init.
168	add_filter( 'jetpack_sync_before_enqueue_jetpack_sync_add_user', array( $this, 'expand_action' ) );
169	add_filter( 'jetpack_sync_before_enqueue_jetpack_sync_register_user', array( $this, 'expand_action' ) );
170	add_filter( 'jetpack_sync_before_enqueue_jetpack_sync_save_user', array( $this, 'expand_action' ) );
171	add_filter( 'jetpack_sync_before_enqueue_jetpack_wp_login', array( $this, 'expand_login_username' ), 10, 1 );
172	add_filter( 'jetpack_sync_before_enqueue_wp_logout', array( $this, 'expand_logout_username' ), 10, 1 );
173	}
174
175	/**
176	* Initialize users action listeners for full sync.
177	*
178	* @access public
179	*
180	* @param callable $callable Action handler callable.
181	*/
182	public function init_full_sync_listeners( $callable ) {
183	add_action( 'jetpack_full_sync_users', $callable );
184	}
185
186	/**
187	* Initialize the module in the sender.
188	*
189	* @access public
190	*/
191	public function init_before_send() {
192	// Full sync.
193	add_filter( 'jetpack_sync_before_send_jetpack_full_sync_users', array( $this, 'expand_users' ) );
194	}
195
196	/**
197	* Retrieve a user by a user ID or object.
198	*
199	* @access private
200	*
201	* @param mixed $user User object or ID.
202	* @return \WP_User\|null User object, or `null` if user invalid/not found.
203	*/
204	private function get_user( $user ) {
205	if ( is_numeric( $user ) ) {
206	$user = get_user_by( 'id', $user );
207	}
208	if ( $user instanceof \WP_User ) {
209	return $user;
210	}
211	return null;
212	}
213
214	/**
215	* Sanitize a user object.
216	* Removes the password from the user object because we don't want to sync it.
217	*
218	* @access public
219	*
220	* @todo Refactor `serialize`/`unserialize` to `wp_json_encode`/`wp_json_decode`.
221	*
222	* @param \WP_User $user User object.
223	* @return \WP_User Sanitized user object.
224	*/
225	public function sanitize_user( $user ) {
226	$user = $this->get_user( $user );
227	// This creates a new user object and stops the passing of the object by reference.
228	// // phpcs:disable WordPress.PHP.DiscouragedPHPFunctions.serialize_serialize, WordPress.PHP.DiscouragedPHPFunctions.serialize_unserialize
229	$user = unserialize( serialize( $user ) );
230
231	if ( is_object( $user ) && is_object( $user->data ) ) {
232	unset( $user->data->user_pass );
233	}
234	return $user;
235	}
236
237	/**
238	* Expand a particular user.
239	*
240	* @access public
241	*
242	* @param \WP_User $user User object.
243	* @return \WP_User Expanded user object.
244	*/
245	public function expand_user( $user ) {
246	if ( ! is_object( $user ) ) {
247	return null;
248	}
249	$user->allowed_mime_types = get_allowed_mime_types( $user );
250	$user->allcaps = $this->get_real_user_capabilities( $user );
251
252	// Only set the user locale if it is different from the site locale.
253	if ( get_locale() !== get_user_locale( $user->ID ) ) {
254	$user->locale = get_user_locale( $user->ID );
255	}
256
257	$user->is_connected = ( new Manager( 'jetpack' ) )->is_user_connected( $user->ID );
258
259	return $user;
260	}
261
262	/**
263	* Retrieve capabilities we care about for a particular user.
264	*
265	* @access public
266	*
267	* @param \WP_User $user User object.
268	* @return array User capabilities.
269	*/
270	public function get_real_user_capabilities( $user ) {
271	$user_capabilities = array();
272	if ( is_wp_error( $user ) ) {
273	return $user_capabilities;
274	}
275	foreach ( Defaults::get_capabilities_whitelist() as $capability ) {
276	if ( user_can( $user, $capability ) ) {
277	$user_capabilities[ $capability ] = true;
278	}
279	}
280	return $user_capabilities;
281	}
282
283	/**
284	* Retrieve, expand and sanitize a user.
285	* Can be directly used in the sync user action handlers.
286	*
287	* @access public
288	*
289	* @param mixed $user User ID or user object.
290	* @return \WP_User Expanded and sanitized user object.
291	*/
292	public function sanitize_user_and_expand( $user ) {
293	$user = $this->get_user( $user );
294	$user = $this->expand_user( $user );
295	return $this->sanitize_user( $user );
296	}
297
298	/**
299	* Expand the user within a hook before it is serialized and sent to the server.
300	*
301	* @access public
302	*
303	* @param array $args The hook arguments.
304	* @return array $args The hook arguments.
305	*/
306	public function expand_action( $args ) {
307	// The first argument is always the user.
308	list( $user ) = $args;
309	if ( $user ) {
310	$args[0] = $this->sanitize_user_and_expand( $user );
311	return $args;
312	}
313
314	return false;
315	}
316
317	/**
318	* Expand the user username at login before enqueuing.
319	*
320	* @access public
321	*
322	* @param array $args The hook arguments.
323	* @return array $args Expanded hook arguments.
324	*/
325	public function expand_login_username( $args ) {
326	list( $login, $user, $flags ) = $args;
327	$user = $this->sanitize_user( $user );
328
329	return array( $login, $user, $flags );
330	}
331
332	/**
333	* Expand the user username at logout before enqueuing.
334	*
335	* @access public
336	*
337	* @param array $args The hook arguments.
338	* @return false\|array $args Expanded hook arguments or false if we don't have a user.
339	*/
340	public function expand_logout_username( $args ) {
341	list( $user_id ) = $args;
342
343	$user = get_userdata( $user_id );
344	$user = $this->sanitize_user( $user );
345
346	$login = '';
347	if ( is_object( $user ) && is_object( $user->data ) ) {
348	$login = $user->data->user_login;
349	}
350
351	// If we don't have a user here lets not enqueue anything.
352	if ( empty( $login ) ) {
353	return false;
354	}
355
356	return array( $login, $user );
357	}
358
359	/**
360	* Additional processing is needed for wp_login so we introduce this wrapper handler.
361	*
362	* @access public
363	*
364	* @param string $user_login The user login.
365	* @param \WP_User $user The user object.
366	*/
367	public function wp_login_handler( $user_login, $user = null ) {
368	if ( ! $user instanceof \WP_User \|\| empty( $user->ID ) ) {
369	return;
370	}
371
372	/**
373	* Fires when a user is logged into a site.
374	*
375	* @since 1.6.3
376	* @since-jetpack 7.2.0
377	*
378	* @param int $user_id The user ID.
379	* @param \WP_User $user The User Object of the user that currently logged in.
380	* @param array $params Any Flags that have been added during login.
381	*/
382	do_action( 'jetpack_wp_login', $user->ID, $user, $this->get_flags( $user->ID ) );
383	$this->clear_flags( $user->ID );
384	}
385
386	/**
387	* A hook for the authenticate event that checks the password strength.
388	*
389	* @access public
390	*
391	* @param \WP_Error\|\WP_User $user The user object, or an error.
392	* @param string $username The username.
393	* @param string $password The password used to authenticate.
394	* @return \WP_Error\|\WP_User the same object that was passed into the function.
395	*/
396	public function authenticate_handler( $user, $username, $password ) {
397	// In case of cookie authentication we don't do anything here.
398	if ( empty( $password ) ) {
399	return $user;
400	}
401
402	// We are only interested in successful authentication events.
403	if ( is_wp_error( $user ) \|\| ! ( $user instanceof \WP_User ) ) {
404	return $user;
405	}
406
407	$password_checker = new Password_Checker( $user->ID );
408
409	$test_results = $password_checker->test( $password, true );
410
411	// If the password passes tests, we don't do anything.
412	if ( empty( $test_results['test_results']['failed'] ) ) {
413	return $user;
414	}
415
416	$this->add_flags(
417	$user->ID,
418	array(
419	'warning' => 'The password failed at least one strength test.',
420	'failures' => $test_results['test_results']['failed'],
421	)
422	);
423
424	return $user;
425	}
426
427	/**
428	* Handler for after the user is deleted.
429	*
430	* @access public
431	*
432	* @param int $deleted_user_id ID of the deleted user.
433	* @param int $reassigned_user_id ID of the user the deleted user's posts are reassigned to (if any).
434	*/
435	public function deleted_user_handler( $deleted_user_id, $reassigned_user_id = '' ) {
436	$is_multisite = is_multisite();
437	/**
438	* Fires when a user is deleted on a site
439	*
440	* @since 1.6.3
441	* @since-jetpack 5.4.0
442	*
443	* @param int $deleted_user_id - ID of the deleted user.
444	* @param int $reassigned_user_id - ID of the user the deleted user's posts are reassigned to (if any).
445	* @param bool $is_multisite - Whether this site is a multisite installation.
446	*/
447	do_action( 'jetpack_deleted_user', $deleted_user_id, $reassigned_user_id, $is_multisite );
448	}
449
450	/**
451	* Handler for user registration.
452	*
453	* @access public
454	*
455	* @param int $user_id ID of the deleted user.
456	*/
457	public function user_register_handler( $user_id ) {
458	// Ensure we only sync users who are members of the current blog.
459	if ( ! is_user_member_of_blog( $user_id, get_current_blog_id() ) ) {
460	return;
461	}
462
463	if ( Jetpack_Constants::is_true( 'JETPACK_INVITE_ACCEPTED' ) ) {
464	$this->add_flags( $user_id, array( 'invitation_accepted' => true ) );
465	}
466	/**
467	* Fires when a new user is registered on a site
468	*
469	* @since 1.6.3
470	* @since-jetpack 4.9.0
471	*
472	* @param object The WP_User object
473	*/
474	do_action( 'jetpack_sync_register_user', $user_id, $this->get_flags( $user_id ) );
475	$this->clear_flags( $user_id );
476	}
477
478	/**
479	* Handler for user addition to the current blog.
480	*
481	* @access public
482	*
483	* @param int $user_id ID of the user.
484	*/
485	public function add_user_to_blog_handler( $user_id ) {
486	// Ensure we only sync users who are members of the current blog.
487	if ( ! is_user_member_of_blog( $user_id, get_current_blog_id() ) ) {
488	return;
489	}
490
491	if ( Jetpack_Constants::is_true( 'JETPACK_INVITE_ACCEPTED' ) ) {
492	$this->add_flags( $user_id, array( 'invitation_accepted' => true ) );
493	}
494
495	/**
496	* Fires when a user is added on a site
497	*
498	* @since 1.6.3
499	* @since-jetpack 4.9.0
500	*
501	* @param object The WP_User object
502	*/
503	do_action( 'jetpack_sync_add_user', $user_id, $this->get_flags( $user_id ) );
504	$this->clear_flags( $user_id );
505	}
506
507	/**
508	* Handler for user save.
509	*
510	* @access public
511	*
512	* @param int $user_id ID of the user.
513	* @param \WP_User $old_user_data User object before the changes.
514	*/
515	public function save_user_handler( $user_id, $old_user_data = null ) {
516	// Ensure we only sync users who are members of the current blog.
517	if ( ! is_user_member_of_blog( $user_id, get_current_blog_id() ) ) {
518	return;
519	}
520
521	$user = get_user_by( 'id', $user_id );
522
523	// Older versions of WP don't pass the old_user_data in ->data.
524	if ( isset( $old_user_data->data ) ) {
525	$old_user = $old_user_data->data;
526	} else {
527	$old_user = $old_user_data;
528	}
529
530	if ( ! is_object( $old_user ) ) {
531	return;
532	}
533
534	$old_user_array = get_object_vars( $old_user );
535
536	foreach ( $old_user_array as $user_field => $field_value ) {
537	if ( false === $user->has_prop( $user_field ) ) {
538	continue;
539	}
540	if ( 'ID' === $user_field ) {
541	continue;
542	}
543	if ( $user->$user_field !== $field_value ) {
544	if ( 'user_email' === $user_field ) {
545	/**
546	* The '_new_email' user meta is deleted right after the call to wp_update_user
547	* that got us to this point so if it's still set then this was a user confirming
548	* their new email address.
549	*/
550	if ( 1 === (int) get_user_meta( $user->ID, '_new_email', true ) ) {
551	$this->flags[ $user_id ]['email_changed'] = true;
552	}
553	continue;
554	}
555
556	$flag = $this->user_fields_to_flags_mapping[ $user_field ] ?? 'unknown_field_changed';
557
558	$this->flags[ $user_id ][ $flag ] = true;
559	}
560	}
561
562	if ( isset( $this->flags[ $user_id ] ) ) {
563
564	/**
565	* Fires when the client needs to sync an updated user.
566	*
567	* @since 1.6.3
568	* @since-jetpack 4.2.0
569	*
570	* @param \WP_User The WP_User object
571	* @param array State - New since 5.8.0
572	*/
573	do_action( 'jetpack_sync_save_user', $user_id, $this->get_flags( $user_id ) );
574	$this->clear_flags( $user_id );
575	}
576	}
577
578	/**
579	* Handler for add user role change.
580	*
581	* @access public
582	*
583	* @param int $user_id ID of the user.
584	* @param string $role New user role.
585	*/
586	public function add_user_role_handler( $user_id, $role ) {
587	$this->add_flags(
588	$user_id,
589	array(
590	'role_added' => $role,
591	)
592	);
593
594	$this->save_user_role_handler( $user_id, $role );
595	}
596
597	/**
598	* Handler for remove user role change.
599	*
600	* @access public
601	*
602	* @param int $user_id ID of the user.
603	* @param string $role Removed user role.
604	*/
605	public function remove_user_role_handler( $user_id, $role ) {
606	$this->add_flags(
607	$user_id,
608	array(
609	'role_removed' => $role,
610	)
611	);
612
613	$this->save_user_role_handler( $user_id, $role );
614	}
615
616	/**
617	* Handler for user role change.
618	*
619	* @access public
620	*
621	* @param int $user_id ID of the user.
622	* @param string $role New user role.
623	* @param array $old_roles Previous user roles.
624	*/
625	public function save_user_role_handler( $user_id, $role, $old_roles = null ) {
626	$this->add_flags(
627	$user_id,
628	array(
629	'role_changed' => true,
630	'previous_role' => $old_roles,
631	)
632	);
633
634	// The jetpack_sync_register_user payload is identical to jetpack_sync_save_user, don't send both.
635	if ( $this->is_function_in_backtrace(
636	array_merge( $this->get_create_user_functions(), $this->get_add_user_to_blog_functions() )
637	) ) {
638	return;
639	}
640	/**
641	* This action is documented already in this file
642	*/
643	do_action( 'jetpack_sync_save_user', $user_id, $this->get_flags( $user_id ) );
644	$this->clear_flags( $user_id );
645	}
646
647	/**
648	* Retrieve current flags for a particular user.
649	*
650	* @access public
651	*
652	* @param int $user_id ID of the user.
653	* @return array Current flags of the user.
654	*/
655	public function get_flags( $user_id ) {
656	if ( isset( $this->flags[ $user_id ] ) ) {
657	return $this->flags[ $user_id ];
658	}
659	return array();
660	}
661
662	/**
663	* Clear the flags of a particular user.
664	*
665	* @access public
666	*
667	* @param int $user_id ID of the user.
668	*/
669	public function clear_flags( $user_id ) {
670	if ( isset( $this->flags[ $user_id ] ) ) {
671	unset( $this->flags[ $user_id ] );
672	}
673	}
674
675	/**
676	* Add flags to a particular user.
677	*
678	* @access public
679	*
680	* @param int $user_id ID of the user.
681	* @param array $flags New flags to add for the user.
682	*/
683	public function add_flags( $user_id, $flags ) {
684	$this->flags[ $user_id ] = wp_parse_args( $flags, $this->get_flags( $user_id ) );
685	}
686
687	/**
688	* Save the user meta, if we're interested in it.
689	* Also uses the time to add flags for the user.
690	*
691	* @access public
692	*
693	* @param int $meta_id ID of the meta object.
694	* @param int $user_id ID of the user.
695	* @param string $meta_key Meta key.
696	* @param mixed $value Meta value.
697	*/
698	public function maybe_save_user_meta( $meta_id, $user_id, $meta_key, $value ) { // phpcs:ignore VariableAnalysis.CodeAnalysis.VariableAnalysis.UnusedVariable
699	if ( 'locale' === $meta_key ) {
700	$this->add_flags( $user_id, array( 'locale_changed' => true ) );
701	}
702
703	$user = get_user_by( 'id', $user_id );
704	if ( isset( $user->cap_key ) && $meta_key === $user->cap_key ) {
705	$this->add_flags( $user_id, array( 'capabilities_changed' => true ) );
706	}
707
708	if ( $this->is_function_in_backtrace(
709	array_merge( $this->get_create_user_functions(), $this->get_add_user_to_blog_functions(), $this->get_delete_user_functions() )
710	) ) {
711	return;
712	}
713
714	if ( isset( $this->flags[ $user_id ] ) ) {
715	/**
716	* This action is documented already in this file
717	*/
718	do_action( 'jetpack_sync_save_user', $user_id, $this->get_flags( $user_id ) );
719	}
720	}
721
722	/**
723	* Enqueue the users actions for full sync.
724	*
725	* @access public
726	*
727	* @param array $config Full sync configuration for this sync module.
728	* @param int $max_items_to_enqueue Maximum number of items to enqueue.
729	* @param boolean $state True if full sync has finished enqueueing this module, false otherwise.
730	* @return array Number of actions enqueued, and next module state.
731	*/
732	public function enqueue_full_sync_actions( $config, $max_items_to_enqueue, $state ) {
733	global $wpdb;
734
735	return $this->enqueue_all_ids_as_action( 'jetpack_full_sync_users', $wpdb->usermeta, 'user_id', $this->get_where_sql( $config ), $max_items_to_enqueue, $state );
736	}
737
738	/**
739	* Retrieve an estimated number of actions that will be enqueued.
740	*
741	* @access public
742	*
743	* @todo Refactor to prepare the SQL query before executing it.
744	*
745	* @param array $config Full sync configuration for this sync module.
746	* @return int Number of items yet to be enqueued.
747	*/
748	public function estimate_full_sync_actions( $config ) {
749	global $wpdb;
750
751	$query = "SELECT count(*) FROM $wpdb->usermeta";
752
753	$where_sql = $this->get_where_sql( $config );
754	if ( $where_sql ) {
755	$query .= ' WHERE ' . $where_sql;
756	}
757
758	// phpcs:ignore WordPress.DB.PreparedSQL.NotPrepared,WordPress.DB.DirectDatabaseQuery.DirectQuery,WordPress.DB.DirectDatabaseQuery.NoCaching
759	$count = (int) $wpdb->get_var( $query );
760
761	return (int) ceil( $count / self::ARRAY_CHUNK_SIZE );
762	}
763
764	/**
765	* Retrieve the WHERE SQL clause based on the module config.
766	*
767	* @access public
768	*
769	* @param array $config Full sync configuration for this sync module.
770	* @return string WHERE SQL clause, or `null` if no comments are specified in the module config.
771	*/
772	public function get_where_sql( $config ) {
773	global $wpdb;
774
775	$query = "meta_key = '{$wpdb->prefix}user_level' AND meta_value > 0";
776
777	// The $config variable is a list of user IDs to sync.
778	if ( is_array( $config ) && ! empty( $config ) ) {
779	$query .= ' AND user_id IN (' . implode( ',', array_map( 'intval', $config ) ) . ')';
780	}
781
782	return $query;
783	}
784
785	/**
786	* Retrieve the actions that will be sent for this module during a full sync.
787	*
788	* @access public
789	*
790	* @return array Full sync actions of this module.
791	*/
792	public function get_full_sync_actions() {
793	return array( 'jetpack_full_sync_users' );
794	}
795
796	/**
797	* Retrieve initial sync user config.
798	*
799	* @access public
800	*
801	* @todo Refactor the SQL query to call $wpdb->prepare() before execution.
802	*
803	* @return array\|boolean IDs of users to initially sync, or false if tbe number of users exceed the maximum.
804	*/
805	public function get_initial_sync_user_config() {
806	global $wpdb;
807
808	// phpcs:ignore WordPress.DB.PreparedSQL.NotPrepared
809	$user_ids = $wpdb->get_col( "SELECT user_id FROM $wpdb->usermeta WHERE meta_key = '{$wpdb->prefix}user_level' AND meta_value > 0 LIMIT " . ( self::MAX_INITIAL_SYNC_USERS + 1 ) );
810	$user_ids_count = is_countable( $user_ids ) ? count( $user_ids ) : 0;
811
812	if ( $user_ids_count <= self::MAX_INITIAL_SYNC_USERS ) {
813	return $user_ids;
814	} else {
815	return false;
816	}
817	}
818
819	/**
820	* Expand the users within a hook before they are serialized and sent to the server.
821	*
822	* @access public
823	*
824	* @param array $args The hook arguments.
825	* @return array $args The hook arguments.
826	*/
827	public function expand_users( $args ) {
828	list( $user_ids, $previous_end ) = $args;
829
830	return array(
831	'users' => array_map(
832	array( $this, 'sanitize_user_and_expand' ),
833	get_users(
834	array(
835	'include' => $user_ids,
836	'orderby' => 'ID',
837	'order' => 'DESC',
838	)
839	)
840	),
841	'previous_end' => $previous_end,
842	);
843	}
844
845	/**
846	* Handler for user removal from a particular blog.
847	*
848	* @access public
849	*
850	* @param int $user_id ID of the user.
851	* @param int $blog_id ID of the blog.
852	* @param int $reassign ID of the user to whom to reassign posts.
853	*/
854	public function remove_user_from_blog_handler( $user_id, $blog_id, $reassign = 0 ) {
855	// User is removed on add, see https://github.com/WordPress/WordPress/blob/0401cee8b36df3def8e807dd766adc02b359dfaf/wp-includes/ms-functions.php#L2114.
856	if ( $this->is_add_new_user_to_blog() ) {
857	return;
858	}
859
860	$reassigned_user_id = $reassign;
861
862	// Note that we are in the context of the blog the user is removed from, see https://github.com/WordPress/WordPress/blob/473e1ba73bc5c18c72d7f288447503713d518790/wp-includes/ms-functions.php#L233.
863	/**
864	* Fires when a user is removed from a blog on a multisite installation
865	*
866	* @since 1.6.3
867	* @since-jetpack 5.4.0
868	*
869	* @param int $user_id - ID of the removed user
870	* @param int $reassigned_user_id - ID of the user the removed user's posts are reassigned to (if any).
871	*/
872	do_action( 'jetpack_removed_user_from_blog', $user_id, $reassigned_user_id );
873	}
874
875	/**
876	* Whether we're adding a new user to a blog in this request.
877	*
878	* @access protected
879	*
880	* @return boolean
881	*/
882	protected function is_add_new_user_to_blog() {
883	return $this->is_function_in_backtrace( 'add_new_user_to_blog' );
884	}
885
886	/**
887	* Get the function names that indicate a user is being created.
888	*
889	* @access protected
890	*
891	* @return array
892	*/
893	protected function get_create_user_functions() {
894	return array(
895	'add_new_user_to_blog', // Used to suppress jetpack_sync_save_user in save_user_cap_handler when user registered on multi site.
896	'wp_create_user', // Used to suppress jetpack_sync_save_user in save_user_role_handler when user registered on multi site.
897	'wp_insert_user', // Used to suppress jetpack_sync_save_user in save_user_cap_handler and save_user_role_handler when user registered on single site.
898	);
899	}
900
901	/**
902	* Get the function names that indicate a user is being added to a blog.
903	*
904	* @access protected
905	*
906	* @return array
907	*/
908	protected function get_add_user_to_blog_functions() {
909	return array( 'add_user_to_blog' );
910	}
911
912	/**
913	* Get the function names that indicate a user is being deleted.
914	*
915	* @access protected
916	*
917	* @return array
918	*/
919	protected function get_delete_user_functions() {
920	return array( 'wp_delete_user', 'remove_user_from_blog' );
921	}
922
923	/**
924	* Checks if one or more function names is in debug_backtrace.
925	*
926	* @access protected
927	*
928	* @param array\|string $names Mixed string name of function or array of string names of functions.
929	* @return bool
930	*/
931	protected function is_function_in_backtrace( $names ) {
932	$backtrace = debug_backtrace( DEBUG_BACKTRACE_IGNORE_ARGS ); // phpcs:ignore WordPress.PHP.DevelopmentFunctions.error_log_debug_backtrace
933	if ( ! is_array( $names ) ) {
934	$names = array( $names );
935	}
936	$names_as_keys = array_flip( $names );
937
938	$backtrace_functions = array_column( $backtrace, 'function' );
939	$backtrace_functions_as_keys = array_flip( $backtrace_functions );
940	$intersection = array_intersect_key( $backtrace_functions_as_keys, $names_as_keys );
941	return ! empty( $intersection );
942	}
943	}
944