22 | * : The receiver
23 | *
24 | * ## EXAMPLES
25 | *
26 | * wp content-sync-fusion relation mirror 1 5
27 | *
28 | * @when after_wp_load
29 | *
30 | * @param $args
31 | * @param $params
32 | *
33 | * @throws \WP_CLI\ExitException
34 | */
35 | public function mirror( $args, $params ) {
36 | if ( count( $args ) !== 2 ) {
37 | WP_CLI::error( 'Missing one parameter for emitter/receiver blog id' );
38 | }
39 |
40 | $this->emitter_blog_id = absint( $args[0] );
41 | $this->receiver_blog_id = absint( $args[1] );
42 |
43 | if ( 1 === $this->receiver_blog_id ) {
44 | WP_CLI::error( 'You can\'t mirror a site to id 1' );
45 | }
46 |
47 | switch_to_blog( $this->emitter_blog_id );
48 |
49 | $syncs = $this->get_emitter_syncs();
50 | if ( empty( $syncs ) ) {
51 | WP_CLI::error( 'No sync registered for this emitter blog' );
52 | }
53 |
54 | $attachments = false;
55 | $post_types = [
56 | 'auto' => [],
57 | 'manual' => [],
58 | ];
59 | $taxonomies = [];
60 |
61 | foreach ( $syncs as $sync ) {
62 | /** @var BEA_CSF_Synchronization $sync */
63 |
64 | $receiver_blogs = $sync->get_receivers();
65 | if ( ! in_array( $this->receiver_blog_id, $receiver_blogs, true ) ) {
66 | WP_CLI::debug( sprintf( 'Skip sync %s because blog is not receiver', $sync->label ) );
67 | continue;
68 | }
69 |
70 | if ( ! empty( $sync->post_type ) ) {
71 | if ( 'attachment' === $sync->post_type ) {
72 | $attachments = true;
73 | } else {
74 | $post_types[ $sync->mode ][] = $sync->post_type;
75 | }
76 | }
77 |
78 | if ( ! empty( $sync->taxonomies ) ) {
79 | $taxonomies = array_merge( array_values( $taxonomies ), array_values( $sync->taxonomies ) );
80 | }
81 | }
82 |
83 | if ( true === $attachments ) {
84 | $this->mirror_attachments();
85 | }
86 |
87 | if ( ! empty( $post_types['auto'] ) ) {
88 | $this->mirror_post_types( $post_types['auto'], false );
89 | }
90 |
91 | if ( ! empty( $post_types['manual'] ) ) {
92 | $this->mirror_post_types( $post_types['manual'], true );
93 | }
94 |
95 | if ( ! empty( $taxonomies ) ) {
96 | $this->mirror_taxonomies( $taxonomies );
97 | }
98 |
99 | WP_CLI::success( sprintf( 'Mirror success, %d relations added !', $this->global_counter ) );
100 | }
101 |
102 | /**
103 | * Mirroring attachments
104 | */
105 | private function mirror_attachments() {
106 | $results = BEA_CSF_Cli_Helper::get_attachments();
107 |
108 | // Loop on attachments
109 | foreach ( (array) $results as $result ) {
110 | if ( ! is_a( $result, 'WP_Post' ) ) {
111 | continue;
112 | }
113 |
114 | $this->global_counter ++;
115 |
116 | BEA_CSF_Relations::merge( 'attachment', $this->emitter_blog_id, $result->ID, $this->receiver_blog_id, $result->ID );
117 | }
118 | }
119 |
120 | /**
121 | * Mirroring post types
122 | *
123 | * @param array $post_types
124 | * @param bool $is_manual
125 | */
126 | private function mirror_post_types( $post_types, $is_manual = false ) {
127 | $results = BEA_CSF_Cli_Helper::get_posts( [ 'post_type' => $post_types ] );
128 |
129 | // Loop on posts
130 | foreach ( (array) $results as $result ) {
131 | if ( ! is_a( $result, 'WP_Post' ) ) {
132 | continue;
133 | }
134 |
135 | $this->global_counter ++;
136 |
137 | BEA_CSF_Relations::merge( 'posttype', $this->emitter_blog_id, $result->ID, $this->receiver_blog_id, $result->ID );
138 |
139 | if ( true === $is_manual ) {
140 | $meta_key = '_b' . $this->emitter_blog_id . '_post_receivers';
141 |
142 | $_post_receivers = (array) get_post_meta( $result->ID, $meta_key, true );
143 | $_post_receivers[] = $this->receiver_blog_id;
144 | $_post_receivers = array_unique( $_post_receivers );
145 | update_post_meta( $result->ID, $meta_key, $_post_receivers );
146 | }
147 | }
148 | }
149 |
150 | /**
151 | * Mirroring taxonomies
152 | *
153 | * @param $taxonomies array with taxo names
154 | */
155 | private function mirror_taxonomies( $taxonomies ) {
156 | $results = BEA_CSF_Cli_Helper::get_terms( $taxonomies );
157 |
158 | // Loop on terms
159 | foreach ( (array) $results as $result ) {
160 | if ( ! isset( $result->term_id ) ) {
161 | continue;
162 | }
163 |
164 | $this->global_counter ++;
165 |
166 | BEA_CSF_Relations::merge( 'taxonomy', $this->emitter_blog_id, $result->term_id, $this->receiver_blog_id, $result->term_id );
167 | }
168 | }
169 |
170 | /**
171 | * Get sync for emitter
172 | *
173 | * @return array
174 | */
175 | private function get_emitter_syncs() {
176 | $has_syncs = BEA_CSF_Synchronizations::get(
177 | [ 'emitters' => $this->emitter_blog_id ],
178 | 'AND',
179 | false,
180 | true
181 | );
182 |
183 | return $has_syncs;
184 | }
185 | }
186 |
187 | WP_CLI::add_command(
188 | 'content-sync-fusion relation',
189 | 'BEA_CSF_Cli_Relation',
190 | array(
191 | 'shortdesc' => __( 'All commands related "relation features" to the BEA Content Sync Fusion plugin', 'bea-content-sync-fusion' ),
192 | )
193 | );
194 |
--------------------------------------------------------------------------------
/classes/cli/resync.php:
--------------------------------------------------------------------------------
1 | all( $args, $params );
31 |
32 | delete_network_option( BEA_CSF_Synchronizations::get_option_network_id(), 'bea-csf-multisite-resync-blogs' );
33 | }
34 |
35 | /**
36 | * Loop on all blogs for resync contents to synchronized
37 | *
38 | * @param $args
39 | * @param $params
40 | *
41 | * @throws \WP_CLI\ExitException
42 | */
43 | public function all( $args, $params ) {
44 | // Use maintenance queue ?
45 | if ( isset( $params['alternativeq'] ) && 'true' === $params['alternativeq'] ) {
46 | BEA_CSF_Async::switch_to_maintenance_queue();
47 | } else {
48 | $params['alternativeq'] = 'false';
49 | }
50 |
51 | // Restrict to some receivers ?
52 | if ( ! isset( $params['receivers'] ) ) {
53 | $params['receivers'] = 'false';
54 | }
55 |
56 | // Optionally params
57 | $params['attachments'] = ! isset( $params['attachments'] ) ? 'false' : $params['attachments'];
58 | $params['post_type'] = ! isset( $params['post_type'] ) ? 'false' : $params['post_type'];
59 | $params['taxonomies'] = ! isset( $params['taxonomies'] ) ? 'false' : $params['taxonomies'];
60 | $params['p2p'] = ! isset( $params['p2p'] ) ? 'false' : $params['p2p'];
61 |
62 | // Default WP_Site_Query arguments
63 | $site_args = array(
64 | 'number' => PHP_INT_MAX,
65 | 'order' => 'ASC',
66 | 'orderby' => 'id',
67 | 'count' => false,
68 | 'fields' => 'ids',
69 | 'no_found_rows' => false,
70 | );
71 |
72 | // Get emitters blogs list from plugin settings
73 | if ( isset( $params['smart'] ) && 'true' === $params['smart'] ) {
74 | $site_args['site__in'] = BEA_CSF_Synchronizations::get_emitters_blogs_ids();
75 | }
76 |
77 | // Restrict to some emitters ?
78 | if ( isset( $params['emitters'] ) ) {
79 | $site_args['site__in'] = explode( ',', $params['emitters'] );
80 | }
81 |
82 | // Restrict to some networks ?
83 | if ( isset( $params['emitters_network'] ) ) {
84 | $site_args['network__in'] = explode( ',', $params['emitters_network'] );
85 | }
86 |
87 | // Get blogs ID to resync
88 | $site_query = new WP_Site_Query( $site_args );
89 | if ( empty( $site_query->sites ) ) {
90 | WP_CLI::warning( __( 'No site to resync', 'bea-content-sync-fusion' ) );
91 |
92 | return;
93 | }
94 |
95 | $progress = \WP_CLI\Utils\make_progress_bar( 'Loop on site with content to resync', $site_query->found_sites );
96 | foreach ( $site_query->sites as $blog_id ) {
97 |
98 | $result = WP_CLI::launch_self(
99 | 'content-sync-fusion resync site',
100 | array(),
101 | array(
102 | 'alternativeq' => $params['alternativeq'],
103 | 'attachments' => $params['attachments'],
104 | 'post_type' => $params['post_type'],
105 | 'taxonomies' => $params['taxonomies'],
106 | 'p2p' => $params['p2p'],
107 | 'receivers' => $params['receivers'],
108 | 'url' => get_home_url( $blog_id, '/' ),
109 | ),
110 | false,
111 | false // enable for debug
112 | );
113 | // var_dump( $result );
114 |
115 | $progress->tick();
116 | }
117 | $progress->finish();
118 | }
119 |
120 | /**
121 | * Flush all contents synchronized for a specific blog_id
122 | *
123 | * @param $args
124 | * @param $params
125 | */
126 | public function site( $args, $params ) {
127 | // Get syncs for current site
128 | $has_syncs = BEA_CSF_Synchronizations::get(
129 | array(
130 | 'emitters' => get_current_blog_id(),
131 | ),
132 | 'AND',
133 | false,
134 | true
135 | );
136 | if ( empty( $has_syncs ) ) {
137 | WP_CLI::warning( __( 'No sync data emission for this website', 'bea-content-sync-fusion' ) );
138 |
139 | return;
140 | }
141 |
142 | // Use maintenance queue ?
143 | if ( isset( $params['alternativeq'] ) && 'true' === $params['alternativeq'] ) {
144 | BEA_CSF_Async::switch_to_maintenance_queue();
145 | }
146 |
147 | // Restrict to some receivers ?
148 | if ( isset( $params['receivers'] ) && 'false' !== $params['receivers'] ) {
149 | $this->receivers_blog_ids = explode( ',', $params['receivers'] );
150 | $this->receivers_blog_ids = array_filter( array_map( 'intval', $this->receivers_blog_ids ) );
151 |
152 | add_filter( 'bea_csf.pre_pre_send_data', array( $this, '_bea_csf_pre_pre_send_data' ), 10, 2 );
153 | }
154 |
155 | // Get data to resync
156 | $data_to_sync = array();
157 |
158 | // Get terms with params argument
159 | if ( ! isset( $params['taxonomies'] ) || 'false' === $params['taxonomies'] ) {
160 | $data_to_sync['terms'] = array();
161 | } else {
162 | // TODO: Manage "any" and filtering
163 | $data_to_sync['terms'] = BEA_CSF_Cli_Helper::get_all_terms();
164 | }
165 |
166 | // Get attachments with params argument
167 | if ( ! isset( $params['attachments'] ) || 'false' === $params['attachments'] ) {
168 | $data_to_sync['attachments'] = array();
169 | } else {
170 | // TODO: Manage "any" and filtering
171 | $data_to_sync['attachments'] = BEA_CSF_Cli_Helper::get_attachments();
172 | }
173 |
174 | // Get posts with params argument
175 | if ( ! isset( $params['post_type'] ) || 'false' === $params['post_type'] ) {
176 | $data_to_sync['posts'] = array();
177 | } else {
178 | // TODO: Manage "any" and filtering
179 | $data_to_sync['posts'] = BEA_CSF_Cli_Helper::get_posts();
180 | }
181 |
182 | // Get P2P with params argument
183 | if ( ! isset( $params['p2p'] ) || 'false' === $params['p2p'] ) {
184 | $data_to_sync['p2p'] = array();
185 | } else {
186 | // TODO: Manage "any" and filtering
187 | $data_to_sync['p2p'] = BEA_CSF_Cli_Helper::get_p2p_connections();
188 | }
189 |
190 | // Make a mega-count
191 | $total = count( $data_to_sync['terms'] ) + count( $data_to_sync['attachments'] ) + count( $data_to_sync['posts'] ) + count( $data_to_sync['p2p'] );
192 |
193 | // No item ?
194 | if ( false === $total ) {
195 | WP_CLI::warning( __( 'No content to resync', 'bea-content-sync-fusion' ) );
196 |
197 | return;
198 | }
199 |
200 | WP_CLI::success( __( 'Start of content resyncing', 'bea-content-sync-fusion' ) );
201 |
202 | $progress = \WP_CLI\Utils\make_progress_bar( 'Loop on content to resync', $total );
203 |
204 | // Loop on terms
205 | foreach ( (array) $data_to_sync['terms'] as $result ) {
206 | if ( ! isset( $result->term_id ) ) {
207 | continue;
208 | }
209 |
210 | do_action( 'edited_term', $result->term_id, $result->term_taxonomy_id, $result->taxonomy );
211 |
212 | $progress->tick();
213 | }
214 |
215 | // Loop on attachments
216 | foreach ( (array) $data_to_sync['attachments'] as $result ) {
217 | if ( ! is_a( $result, 'WP_Post' ) ) {
218 | continue;
219 | }
220 |
221 | do_action( 'edit_attachment', $result->ID );
222 |
223 | $progress->tick();
224 | }
225 |
226 | // Loop on posts
227 | foreach ( $data_to_sync['posts'] as $result ) {
228 | if ( ! is_a( $result, 'WP_Post' ) ) {
229 | continue;
230 | }
231 |
232 | do_action( 'transition_post_status', $result->post_status, $result->post_status, $result );
233 | do_action( 'save_post', $result->ID, $result, true );
234 |
235 | $progress->tick();
236 | }
237 |
238 | // Loop on P2P
239 | foreach ( $data_to_sync['p2p'] as $result_id ) {
240 | do_action( 'p2p_created_connection', $result_id );
241 |
242 | $progress->tick();
243 | }
244 | $progress->finish();
245 |
246 | WP_CLI::success( __( 'End of content resync', 'bea-content-sync-fusion' ) );
247 | }
248 |
249 | /**
250 | * Drop variable content for keep blog_id only to the freshly new created blogs !
251 | *
252 | * @param $receiver_blog_id
253 | * @param $sync
254 | *
255 | * @return bool
256 | */
257 | public function _bea_csf_pre_pre_send_data( $receiver_blog_id, BEA_CSF_Synchronization $sync ) {
258 | if ( empty( $this->receivers_blog_ids ) || ! is_array( $this->receivers_blog_ids ) ) {
259 | return $receiver_blog_id;
260 | }
261 |
262 | if ( in_array( $receiver_blog_id, $this->receivers_blog_ids, true ) ) {
263 | return $receiver_blog_id;
264 | }
265 |
266 | return false;
267 | }
268 |
269 | }
270 |
271 | WP_CLI::add_command(
272 | 'content-sync-fusion resync',
273 | 'BEA_CSF_Cli_Resync',
274 | array(
275 | 'shortdesc' => __( 'All commands related "resync features" to the BEA Content Sync Fusion plugin', 'bea-content-sync-fusion' ),
276 | )
277 | );
278 |
--------------------------------------------------------------------------------
/classes/client-relations.php:
--------------------------------------------------------------------------------
1 | 0 ) {
20 | do_action( 'bea_csf.before_delete_attachment', $attachment_id, $data );
21 |
22 | wp_delete_attachment( $attachment_id, true );
23 |
24 | BEA_CSF_Relations::delete_by_receiver( 'attachment', (int) $GLOBALS['wpdb']->blogid, (int) $attachment_id );
25 |
26 | // Delete additional if reciprocal synchro
27 | BEA_CSF_Relations::delete_by_emitter_and_receiver( 'attachment', (int) $GLOBALS['wpdb']->blogid, (int) $attachment_id, (int) $data['blogid'], (int) $data['ID'] );
28 |
29 | do_action( 'bea_csf.after_delete_attachment', $attachment_id, $data );
30 | }
31 |
32 | return apply_filters( 'bea_csf.client.attachment.delete', true, $sync_fields );
33 | }
34 |
35 |
36 | /**
37 | * Delete a attachment, take the master ID and try to find the new ID for delete it !
38 | *
39 | * @param array $data
40 | * @param array $sync_fields
41 | *
42 | * @return array[WP_Error
43 | */
44 | public static function merge( array $data, array $sync_fields ) {
45 | if ( empty( $data ) || ! is_array( $data ) ) {
46 | return new WP_Error( 'invalid_datas', 'Error - Datas is invalid.' );
47 | }
48 |
49 | if ( ! isset( $data['blogid'] ) ) {
50 | return new WP_Error( 'missing_blog_id', 'Error - Missing a blog ID for allow insertion.' );
51 | }
52 |
53 | // Translate for current media ID
54 | $current_media_id = BEA_CSF_Relations::get_object_for_any( 'attachment', $data['blogid'], $sync_fields['_current_receiver_blog_id'], $data['ID'], $data['ID'] );
55 |
56 | // Find local parent ?
57 | if ( isset( $data['post_parent'] ) ) {
58 | $current_parent_id = BEA_CSF_Relations::get_object_for_any( 'posttype', $data['blogid'], $sync_fields['_current_receiver_blog_id'], $data['post_parent'], $data['post_parent'] );
59 | $data['post_parent'] = ! empty( $current_parent_id ) && (int) $current_parent_id > 0 ? $current_parent_id : 0;
60 | }
61 |
62 | // Clone data for post insertion
63 | $data_for_post = $data;
64 | unset( $data_for_post['taxonomies'], $data_for_post['terms'], $data_for_post['post_custom'], $data_for_post['metadata'] );
65 |
66 | // Post data are expected to be escaped for wp_insert_post/wp_update_post
67 | $data_for_post = wp_slash( $data_for_post );
68 |
69 | // Merge or add ?
70 | if ( ! empty( $current_media_id ) && (int) $current_media_id > 0 ) { // Edit, update only main fields
71 |
72 | $data_for_post['ID'] = $current_media_id;
73 | $new_media_id = wp_update_post( $data_for_post );
74 | if ( is_wp_error( $new_media_id ) || $new_media_id === 0 ) {
75 | return new WP_Error( 'invalid_datas', 'Error - An fatal error occurred during attachment insertion.' );
76 | }
77 |
78 | do_action( 'bea_csf.client_attachment_after_update', $current_media_id, $data['attachment_dir'], $data['post_parent'], $data );
79 |
80 | } else { // Insert with WP media public static function
81 |
82 | //$data_for_post['import_id'] = $data_for_post['ID'];
83 | unset( $data_for_post['ID'] );
84 | $new_media_id = wp_insert_post( $data_for_post );
85 | if ( is_wp_error( $new_media_id ) || $new_media_id === 0 ) {
86 | return new WP_Error( 'invalid_datas', 'Error - An fatal error occurred during attachment insertion.' );
87 | }
88 |
89 | do_action( 'bea_csf.client_attachment_after_insert', $new_media_id, $data['attachment_dir'], $data['post_parent'], $data );
90 |
91 | }
92 |
93 | // Append to relations table
94 | BEA_CSF_Relations::merge( 'attachment', $data['blogid'], $data['ID'], $GLOBALS['wpdb']->blogid, $new_media_id );
95 |
96 | // Save all metas for new post
97 | if ( isset( $data['meta_data'] ) && is_array( $data['meta_data'] ) && ! empty( $data['meta_data'] ) ) {
98 | foreach ( $data['meta_data'] as $key => $values ) {
99 | if ( count( $values ) > 1 || ! isset( $values[0] ) ) {
100 | // TODO: Management exception, SO RARE in WP !
101 | continue;
102 | } else {
103 | update_post_meta( $new_media_id, $key, maybe_unserialize( $values[0] ) );
104 | }
105 | }
106 | }
107 |
108 | // Clean data for each taxonomy
109 | if ( isset( $data['taxonomies'] ) ) {
110 | wp_delete_object_term_relationships( $new_media_id, $data['taxonomies'] );
111 | }
112 |
113 | // Association with terms
114 | if ( isset( $data['terms'] ) && is_array( $data['terms'] ) && ! empty( $data['terms'] ) ) {
115 | $term_ids = array();
116 |
117 | foreach ( $data['terms'] as $term ) {
118 | // Sync settings, check if term is in an allowed taxonomy
119 | if ( ! empty( $sync_fields['taxonomies'] ) && ! in_array( $term['taxonomy'], (array) $sync_fields['taxonomies'] ) ) {
120 | continue;
121 | }
122 |
123 | $local_term_id = BEA_CSF_Relations::get_object_for_any( 'taxonomy', $data['blogid'], $sync_fields['_current_receiver_blog_id'], (int) $term['term_id'], (int) $term['term_id'] );
124 | if ( (int) $local_term_id > 0 ) {
125 | if ( ! isset( $term_ids[ $term['taxonomy'] ] ) ) {
126 | $term_ids[ $term['taxonomy'] ] = array();
127 | }
128 |
129 | $term_ids[ $term['taxonomy'] ][] = (int) $local_term_id;
130 | }
131 | }
132 |
133 | foreach ( $term_ids as $taxonomy => $local_term_ids ) {
134 | wp_set_object_terms( $new_media_id, $local_term_ids, $taxonomy, false );
135 | }
136 | }
137 |
138 | $new_attachment = get_post( $new_media_id );
139 | if ( ! empty( $new_attachment ) ) {
140 | $new_attachment->is_edition = ( ! empty( $current_media_id ) && (int) $current_media_id > 0 ) ? true : false;
141 | }
142 |
143 | // App new new media for 3rd party plugins
144 | $data['new_media_id'] = $new_media_id;
145 |
146 | return apply_filters( 'bea_csf.client.attachment.merge', $data, $sync_fields, $new_attachment );
147 | }
148 | }
149 |
--------------------------------------------------------------------------------
/classes/client/p2p.php:
--------------------------------------------------------------------------------
1 | '7',
7 | 'p2p_from' => '104',
8 | 'p2p_to' => '29',
9 | 'p2p_type' => 'establishment_to_ambassador',
10 | 'blogid' => 1,
11 | )
12 | */
13 |
14 | /**
15 | * Add connection on DB
16 | */
17 | public static function merge( array $data, array $sync_fields ) {
18 | if ( empty( $data ) || ! is_array( $data ) ) {
19 | return new WP_Error( 'invalid_datas', 'Error - Datas is invalid.' );
20 | }
21 |
22 | if ( ! isset( $data['blogid'] ) ) {
23 | return new WP_Error( 'missing_blog_id', 'Error - Missing a blog ID for allow insertion.' );
24 | }
25 |
26 | // P2P Type must be sync ?
27 | if ( ! in_array( $data['p2p_type'], $sync_fields['p2p_connections'] ) ) {
28 | return false;
29 | }
30 |
31 | // From (post/users)
32 | if ( $data['p2p_obj']->side['from']->get_object_type() != 'user' ) {
33 | // Posts exists ?
34 | $p2p_from_local = BEA_CSF_Relations::get_object_for_any( 'posttype', $data['blogid'], $sync_fields['_current_receiver_blog_id'], $data['p2p_from'], $data['p2p_from'] );
35 | } else {
36 | $p2p_from_local = $data['p2p_from'];
37 |
38 | // Prefered role by connection ?
39 | $role = isset( $data['p2p_obj']->side['from']->query_vars['role'] ) ? $data['p2p_obj']->side['from']->query_vars['role'] : 'subscriber';
40 |
41 | // Try to user to blog (if need) and set right role for this connection
42 | self::maybe_add_user_to_current_blog( $p2p_from_local, $role );
43 | }
44 |
45 | // To (post/users)
46 | if ( $data['p2p_obj']->side['to']->get_object_type() != 'user' ) {
47 | // Posts exists ?
48 | $p2p_to_local = BEA_CSF_Relations::get_object_for_any( 'posttype', $data['blogid'], $sync_fields['_current_receiver_blog_id'], $data['p2p_to'], $data['p2p_to'] );
49 | } else {
50 | $p2p_to_local = $data['p2p_to'];
51 |
52 | // Prefered role by connection ?
53 | $role = isset( $data['p2p_obj']->side['to']->query_vars['role'] ) ? $data['p2p_obj']->side['to']->query_vars['role'] : 'subscriber';
54 |
55 | // Try to user to blog (if need) and set right role for this connection
56 | self::maybe_add_user_to_current_blog( $p2p_to_local, $role );
57 | }
58 |
59 | // If from or empty not exists, stop process
60 | if ( empty( $p2p_from_local ) || empty( $p2p_to_local ) ) {
61 | return false;
62 | }
63 |
64 | // Create connection
65 | p2p_type( $data['p2p_type'] )->connect(
66 | $p2p_from_local,
67 | $p2p_to_local,
68 | array(
69 | 'date' => current_time( 'mysql' ),
70 | )
71 | );
72 | }
73 |
74 | /**
75 | * Delete a connection, take the master id, try to find the new ID and delete local connection
76 | *
77 | * @param array $term
78 | *
79 | * @return \WP_Error|boolean
80 | */
81 | public static function delete( array $data, array $sync_fields ) {
82 | // P2P Type must be sync ?
83 | if ( ! in_array( $data['p2p_type'], $sync_fields['p2p_connections'] ) ) {
84 | return false;
85 | }
86 |
87 | // From (post/users)
88 | if ( $data['p2p_obj']->side['from']->get_object_type() != 'user' ) {
89 | $p2p_from_local = BEA_CSF_Relations::get_object_for_any( 'posttype', $data['blogid'], $sync_fields['_current_receiver_blog_id'], $data['p2p_from'], $data['p2p_from'] );
90 | } else {
91 | $p2p_from_local = $data['p2p_from'];
92 | }
93 |
94 | // To (post/users)
95 | if ( $data['p2p_obj']->side['to']->get_object_type() != 'user' ) {
96 | $p2p_to_local = BEA_CSF_Relations::get_object_for_any( 'posttype', $data['blogid'], $sync_fields['_current_receiver_blog_id'], $data['p2p_to'], $data['p2p_to'] );
97 | } else {
98 | $p2p_to_local = $data['p2p_to'];
99 | }
100 |
101 | if ( empty( $p2p_from_local ) || empty( $p2p_to_local ) ) {
102 | return false;
103 | }
104 |
105 | p2p_type( $data['p2p_type'] )->disconnect( $p2p_from_local, $p2p_to_local );
106 | }
107 |
108 | /**
109 | * @param $user_id
110 | * @param string $prefered_role
111 | *
112 | */
113 | public static function maybe_add_user_to_current_blog( $user_id, $prefered_role = 'subscriber' ) {
114 | global $wpdb;
115 |
116 | $blogs = get_blogs_of_user( $user_id, true );
117 |
118 | // Add user to current blog if not exist
119 | if ( ! isset( $blogs[ $wpdb->blogid ] ) ) {
120 | add_user_to_blog( $wpdb->blogid, $user_id, $prefered_role );
121 | } else {
122 | wp_update_user(
123 | array(
124 | 'ID' => $user_id,
125 | 'role' => $prefered_role,
126 | )
127 | );
128 | }
129 | }
130 |
131 | }
132 |
--------------------------------------------------------------------------------
/classes/client/post_type.php:
--------------------------------------------------------------------------------
1 | 0 ? $local_parent_id : 0;
28 | }
29 |
30 | $data = apply_filters( 'bea_csf/client/posttype/before_merge', $data, $sync_fields );
31 |
32 | if ( false === $data || empty( $data ) ) {
33 | return new WP_Error( 'empty_data', 'Error - exclude post to sync' );
34 | }
35 |
36 | // Clone datas for post insertion
37 | $data_for_post = $data;
38 | unset( $data_for_post['medias'], $data_for_post['terms'], $data_for_post['tags_input'], $data_for_post['post_category'] );
39 |
40 | // Post data are expected to be escaped for wp_insert_post/wp_update_post
41 | $data_for_post = wp_slash( $data_for_post );
42 |
43 | // Merge post
44 | if ( ! empty( $data['local_id'] ) && (int) $data['local_id'] > 0 ) {
45 | $current_value = (int) get_post_meta( $data['local_id'], '_exclude_from_futur_sync', true );
46 | if ( $current_value == 1 ) {
47 | return new WP_Error( 'future_sync_exclusion', 'Error - This post is exclude from future sync.' );
48 | }
49 |
50 | // Sync settings, if pending, never try to change the post status ?
51 | if ( 'pending' === $sync_fields['status'] || self::is_blog_post_pending_user_selection( $sync_fields, $data ) ) {
52 | unset( $data_for_post['post_status'] );
53 | }
54 |
55 | $data_for_post['ID'] = $data['local_id'];
56 | $new_post_id = wp_update_post( $data_for_post, true );
57 |
58 | } else {
59 | // Sync settings, allow change post status. Apply only for post creation
60 | if ( 'pending' === $sync_fields['status'] || self::is_blog_post_pending_user_selection( $sync_fields, $data ) ) {
61 | $data_for_post['post_status'] = 'pending';
62 | }
63 |
64 | //$data_for_post['import_id'] = $data_for_post['ID'];
65 | unset( $data_for_post['ID'] );
66 | $new_post_id = wp_insert_post( $data_for_post, true );
67 | }
68 |
69 | // Post on DB ?
70 | if ( is_wp_error( $new_post_id ) ) {
71 | return new WP_Error( 'post_insertion', 'Error during the post insertion ' . $new_post_id->get_error_message() );
72 | }
73 |
74 | BEA_CSF_Relations::merge( 'posttype', $data['blogid'], $data['ID'], $GLOBALS['wpdb']->blogid, $new_post_id );
75 |
76 | // Save all metas for new post
77 | if ( isset( $data['meta_data'] ) && is_array( $data['meta_data'] ) && ! empty( $data['meta_data'] ) ) {
78 | foreach ( $data['meta_data'] as $key => $values ) {
79 | if ( count( $values ) > 1 || ! isset( $values[0] ) ) {
80 | // TODO: Management exception, SO RARE in WP !
81 | continue;
82 | } else {
83 | update_post_meta( $new_post_id, $key, maybe_unserialize( $values[0] ) );
84 | }
85 | }
86 | }
87 |
88 | // Clean data for each taxonomy
89 | if ( isset( $data['taxonomies'] ) ) {
90 | wp_delete_object_term_relationships( $new_post_id, $data['taxonomies'] );
91 | }
92 |
93 | // Association with terms
94 | if ( isset( $data['terms'] ) && is_array( $data['terms'] ) && ! empty( $data['terms'] ) ) {
95 | $term_ids = array();
96 |
97 | foreach ( $data['terms'] as $term ) {
98 | // Sync settings, check if term is in an allowed taxonomy
99 | if ( ! empty( $sync_fields['taxonomies'] ) && ! in_array( $term['taxonomy'], (array) $sync_fields['taxonomies'], true ) ) {
100 | continue;
101 | }
102 |
103 | $local_term_id = BEA_CSF_Relations::get_object_for_any( 'taxonomy', $data['blogid'], $sync_fields['_current_receiver_blog_id'], (int) $term['term_id'], (int) $term['term_id'] );
104 | if ( (int) $local_term_id > 0 ) {
105 | if ( ! isset( $term_ids[ $term['taxonomy'] ] ) ) {
106 | $term_ids[ $term['taxonomy'] ] = array();
107 | }
108 |
109 | $term_ids[ $term['taxonomy'] ][] = (int) $local_term_id;
110 | }
111 | }
112 |
113 | foreach ( $term_ids as $taxonomy => $local_term_ids ) {
114 | wp_set_object_terms( $new_post_id, $local_term_ids, $taxonomy, false );
115 | }
116 | }
117 |
118 | // Medias exist ?
119 | if ( is_array( $data['medias'] ) && ! empty( $data['medias'] ) ) {
120 | // Loop for medias
121 | foreach ( $data['medias'] as $media ) {
122 | // Media exists ?
123 | $current_media_id = (int) BEA_CSF_Relations::get_object_for_any( 'attachment', $data['blogid'], $sync_fields['_current_receiver_blog_id'], $media['ID'], $media['ID'] );
124 | if ( empty( $current_media_id ) ) {
125 | continue;
126 | }
127 |
128 | wp_update_post(
129 | array(
130 | 'ID' => $current_media_id,
131 | 'post_parent' => $new_post_id,
132 | )
133 | );
134 | }
135 | }
136 |
137 | // Remove old thumb
138 | delete_post_meta( $new_post_id, '_thumbnail_id' );
139 |
140 | // Restore post thumb
141 | $thumbnail_id = (int) BEA_CSF_Relations::get_object_for_any( 'attachment', $data['blogid'], $sync_fields['_current_receiver_blog_id'], $data['_thumbnail_id'], $data['_thumbnail_id'] );
142 | if ( empty( $thumbnail_id ) && (int) $thumbnail_id > 0 ) {
143 | update_post_meta( $new_post_id, '_thumbnail_id', $thumbnail_id->receiver_id );
144 | } elseif ( ! empty( $data['_thumbnail'] ) ) {
145 | $data['_thumbnail']['blogid'] = $data['blogid'];
146 | $new_media = BEA_CSF_Client_Attachment::merge( $data['_thumbnail'], $sync_fields );
147 | if ( ! is_wp_error( $new_media ) && isset( $new_media['new_media_id'] ) ) {
148 | update_post_meta( $new_post_id, '_thumbnail_id', $new_media['new_media_id'] );
149 | }
150 | }
151 |
152 | // Set P2P connections
153 | if ( isset( $data['connections'] ) && ! empty( $data['connections'] ) ) {
154 | foreach ( (array) $data['connections'] as $connection ) {
155 | $connection['blogid'] = $data['blogid'];
156 | BEA_CSF_Client_P2P::merge( $connection, $sync_fields );
157 | }
158 | }
159 |
160 | $new_post = get_post( $new_post_id );
161 | if ( ! empty( $new_post ) ) {
162 | $new_post->is_edition = ( ! empty( $data['local_id'] ) && (int) $data['local_id'] > 0 ) ? true : false;
163 | }
164 |
165 | return apply_filters( 'bea_csf.client.posttype.merge', $data, $sync_fields, $new_post );
166 | }
167 |
168 | /**
169 | * Check if the current blog have a user selection status
170 | *
171 | * @param $sync_fields
172 | * @param $data
173 | *
174 | * @return bool
175 | */
176 | private static function is_user_selection_blog_post( $sync_fields, $data ) {
177 | return ( 'user_selection' === $sync_fields['status'] && isset( $data['meta_data'][ '_b' . $data['blogid'] . '_post_receivers_status' ] ) );
178 | }
179 |
180 | /**
181 | * Get post status from post meta for the current blog
182 | *
183 | * @param $data
184 | *
185 | * @return string
186 | */
187 | private static function get_user_selection_blog_post( $data ) {
188 | $_post_receivers_status = maybe_unserialize( $data['meta_data'][ '_b' . $data['blogid'] . '_post_receivers_status' ][0] );
189 | $_current_blog_id = (int) $GLOBALS['wpdb']->blogid;
190 | if ( isset( $_post_receivers_status[ $_current_blog_id ] ) ) {
191 | return $_post_receivers_status[ $_current_blog_id ];
192 | }
193 |
194 | return '';
195 | }
196 |
197 | /**
198 | * Check if blog post have a pending value from user selection
199 | *
200 | * @param $sync_fields
201 | * @param $data
202 | *
203 | * @return bool
204 | */
205 | private static function is_blog_post_pending_user_selection( $sync_fields, $data ) {
206 | if ( ! self::is_user_selection_blog_post( $sync_fields, $data ) ) {
207 | return false;
208 | }
209 |
210 | if ( ! in_array( self::get_user_selection_blog_post( $data ), [ 'pending', 'pending-draft' ], true ) ) {
211 | return false;
212 | }
213 |
214 | return true;
215 | }
216 |
217 | /**
218 | * Delete a post, take the master id, try to find the new ID and delete local post
219 | *
220 | * @param array $data
221 | * @param array $sync_fields
222 | *
223 | * @return bool|WP_Error
224 | * @internal param int $master_id
225 | */
226 | public static function delete( array $data, array $sync_fields ) {
227 | if ( empty( $data ) || ! is_array( $data ) ) {
228 | return new WP_Error( 'invalid_datas', 'Error - Datas is invalid.' );
229 | }
230 |
231 | $local_id = BEA_CSF_Relations::get_object_for_any( 'posttype', $data['blogid'], $sync_fields['_current_receiver_blog_id'], $data['ID'], $data['ID'] );
232 | if ( ! empty( $local_id ) && (int) $local_id > 0 ) {
233 | wp_delete_post( $local_id, true );
234 |
235 | BEA_CSF_Relations::delete_by_receiver( 'posttype', (int) $GLOBALS['wpdb']->blogid, (int) $local_id );
236 |
237 | // Delete additional if reciprocal synchro
238 | BEA_CSF_Relations::delete_by_emitter_and_receiver( 'posttype', (int) $GLOBALS['wpdb']->blogid, (int) $local_id, (int) $data['blogid'], (int) $data['ID'] );
239 | }
240 |
241 | return apply_filters( 'bea_csf.client.posttype.delete', $data, $sync_fields );
242 | }
243 |
244 | }
245 |
--------------------------------------------------------------------------------
/classes/client/taxonomy.php:
--------------------------------------------------------------------------------
1 | model->term_exists_by_slug( $data['slug'], $data['pll']['language'], $data['taxonomy'], BEA_CSF_Relations::get_object_for_any( 'taxonomy', $data['blogid'], $sync_fields['_current_receiver_blog_id'], $data['parent'], $data['parent'] ) );
40 | }
41 |
42 | $local_term_id = BEA_CSF_Relations::get_object_for_any( 'taxonomy', $data['blogid'], $sync_fields['_current_receiver_blog_id'], $data['term_id'], $data['term_id'] );
43 | if ( ! empty( $local_term_id ) && (int) $local_term_id > 0 ) {
44 | // Prevent PLL same slug for several languages on update
45 | if ( ! empty( $data['pll']['is_translated'] ) && ! empty( $exist_pll_term_id ) ) {
46 | $data['slug'] = $data['slug'] . '___' . $data['pll']['language']; // Prevent exist term
47 | }
48 |
49 | $new_term_id = wp_update_term( $local_term_id, $data['taxonomy'], array(
50 | 'name' => $data['name'],
51 | 'description' => $data['description'],
52 | 'slug' => $data['slug'],
53 | 'parent' => BEA_CSF_Relations::get_object_for_any( 'taxonomy', $data['blogid'], $sync_fields['_current_receiver_blog_id'], $data['parent'], $data['parent'] ),
54 | ) );
55 | } else {
56 | // Prevent PLL same slug for several languages on insert
57 | if ( ! empty( $data['pll']['is_translated'] ) && empty( $exist_pll_term_id ) ) {
58 | $data['slug'] = $data['slug'] . '___' . $data['pll']['language']; // Create new one
59 | }
60 |
61 | $new_term_id = wp_insert_term(
62 | $data['name'],
63 | $data['taxonomy'],
64 | array(
65 | 'description' => $data['description'],
66 | 'slug' => $data['slug'],
67 | 'parent' => BEA_CSF_Relations::get_object_for_any( 'taxonomy', $data['blogid'], $sync_fields['_current_receiver_blog_id'], $data['parent'], $data['parent'] ),
68 |
69 | )
70 | );
71 |
72 | // try to manage error when term already exist with the same name !
73 | if ( is_wp_error( $new_term_id ) && 'term_exists' === $new_term_id->get_error_code() ) {
74 |
75 | $term_exists_result = term_exists( $data['name'], $data['taxonomy'], $data['parent'] );
76 |
77 | // Prevent PLL same slug for several languages on update
78 | if ( ! empty( $data['pll']['is_translated'] ) && ! empty( $exist_pll_term_id ) ) {
79 | $term_exists_result = [ 'term_id' => $exist_pll_term_id ];
80 | $data['slug'] = $data['slug'] . '___' . $data['pll']['language']; // Prevent exist term
81 | }
82 |
83 | if ( false !== $term_exists_result && isset( $term_exists_result['term_id'] ) ) {
84 | $new_term_id = wp_update_term(
85 | $term_exists_result['term_id'],
86 | $data['taxonomy'],
87 | array(
88 | 'name' => $data['name'],
89 | 'description' => $data['description'],
90 | 'slug' => $data['slug'],
91 | 'parent' => BEA_CSF_Relations::get_object_for_any( 'taxonomy', $data['blogid'], $sync_fields['_current_receiver_blog_id'], $data['parent'], $data['parent'] ),
92 | )
93 | );
94 | update_term_meta( $term_exists_result['term_id'], 'already_exists', 1 );
95 | }
96 | }
97 | }
98 |
99 | // Delete this variable for skip conflict with next item to sync
100 | unset( $_bea_origin_blog_id );
101 |
102 | // Test merge/insertion
103 | if ( is_wp_error( $new_term_id ) ) {
104 | return new WP_Error( 'term_insertion', $new_term_id->get_error_message() );
105 | } elseif ( is_array( $new_term_id ) && isset( $new_term_id['term_id'] ) ) {
106 | $new_term_id = (int) $new_term_id['term_id'];
107 | } elseif ( 0 !== (int) $new_term_id ) {
108 | $new_term_id = (int) $new_term_id;
109 | }
110 |
111 | // Always valid ?
112 | if ( 0 === $new_term_id ) {
113 | return new WP_Error( 'term_id_invalid', 'Error - Term ID is egal to 0' );
114 | }
115 |
116 | // Get term object
117 | $new_term_obj = get_term( $new_term_id, $data['taxonomy'] );
118 | if ( is_wp_error( $new_term_obj ) ) {
119 | return new WP_Error( 'term_valid', 'Error - Term seems invalid' );
120 | }
121 |
122 | BEA_CSF_Relations::merge( 'taxonomy', $data['blogid'], $data['term_id'], $GLOBALS['wpdb']->blogid, $new_term_obj->term_id );
123 |
124 | // Save all metas for new post
125 | if ( isset( $data['meta_data'] ) && is_array( $data['meta_data'] ) && ! empty( $data['meta_data'] ) ) {
126 | foreach ( $data['meta_data'] as $key => $values ) {
127 | if ( count( $values ) > 1 || ! isset( $values[0] ) ) {
128 | // TODO: Management exception, SO RARE in WP !
129 | continue;
130 | } else {
131 | update_term_meta( $new_term_id, $key, $values[0] );
132 | }
133 | }
134 | }
135 |
136 | return apply_filters( 'bea_csf.client.taxonomy.merge', $data, $sync_fields, $new_term_obj );
137 | }
138 |
139 | /**
140 | * Delete a term, take the master id, try to find the new ID and delete local term
141 | *
142 | * @param array $term
143 | * @param array $sync_fields
144 | *
145 | * @return bool|WP_Error
146 | */
147 | public static function delete( array $term, array $sync_fields ) {
148 | if ( empty( $term ) || ! is_array( $term ) ) {
149 | return new WP_Error( 'invalid_datas', __( 'Bad call, invalid datas.' ) );
150 | }
151 |
152 | $local_term_id = BEA_CSF_Relations::get_object_for_any( 'taxonomy', $term['blogid'], $sync_fields['_current_receiver_blog_id'], $term['term_id'], $term['term_id'] );
153 | if ( ! empty( $local_term_id ) && (int) $local_term_id > 0 ) {
154 | BEA_CSF_Relations::delete_by_receiver( 'taxonomy', (int) $GLOBALS['wpdb']->blogid, (int) $local_term_id );
155 |
156 | // Delete additional if reciprocal synchro
157 | BEA_CSF_Relations::delete_by_emitter_and_receiver( 'taxonomy', (int) $GLOBALS['wpdb']->blogid, (int) $local_term_id, (int) $term['blogid'], (int) $term['term_id'] );
158 |
159 | // Term already exist before sync, keep it !
160 | $already_exists = get_term_meta( $local_term_id, 'already_exists', true );
161 | if ( ! empty( $already_exists ) && 1 === absint( $already_exists ) ) {
162 | return false;
163 | }
164 |
165 | wp_delete_term( $local_term_id, $term['taxonomy'] );
166 | }
167 |
168 | return apply_filters( 'bea_csf.client.taxonomy.delete', true, $sync_fields );
169 | }
170 | }
171 |
--------------------------------------------------------------------------------
/classes/media.php:
--------------------------------------------------------------------------------
1 | &$source ) {
55 | $sources[ $key ]['url'] = self::replace_base_upload_dir( $source['url'], get_current_blog_id(), $external->emitter_blog_id );
56 | }
57 |
58 | return $sources;
59 | }
60 |
61 | /**
62 | * Edit attachment URL on fly for synchronized media
63 | *
64 | * @param string $url
65 | * @param integer $post_id
66 | *
67 | * @return string
68 | */
69 | public static function wp_get_attachment_url( $url, $post_id ) {
70 | $external = BEA_CSF_Relations::current_object_is_synchronized( 'attachment', get_current_blog_id(), $post_id );
71 | if ( empty( $external ) ) {
72 | return $url;
73 | }
74 |
75 | return self::replace_base_upload_dir( $url, get_current_blog_id(), $external->emitter_blog_id );
76 | }
77 |
78 | /**
79 | * Filter the attachment file path
80 | *
81 | * @param string $file
82 | * @param integer $attachment_id
83 | *
84 | * @return string
85 | */
86 | public static function get_attached_file( $file, $attachment_id ) {
87 | $external = BEA_CSF_Relations::current_object_is_synchronized( 'attachment', get_current_blog_id(), $attachment_id );
88 | if ( empty( $external ) ) {
89 | return $file;
90 | }
91 |
92 | return self::replace_base_upload_dir( $file, get_current_blog_id(), $external->emitter_blog_id, 'basedir' );
93 | }
94 |
95 | /**
96 | * An kind of str_replace function with helper wp_upload_dir replacement
97 | *
98 | * @param string $string
99 | * @param integer $receiver_blog_id
100 | * @param integer $emitter_blog_id
101 | * @param string $wp_upload_dir_key
102 | *
103 | * @return string
104 | */
105 | public static function replace_base_upload_dir( &$string, $receiver_blog_id, $emitter_blog_id, $wp_upload_dir_key = 'baseurl' ) {
106 | $receiver_wp_upload_dir = self::get_blog_wp_upload_dir( $receiver_blog_id );
107 | $emitter_wp_upload_dir = self::get_blog_wp_upload_dir( $emitter_blog_id );
108 |
109 | return str_replace(
110 | [
111 | $receiver_wp_upload_dir[ $wp_upload_dir_key ],
112 | '/sites/1/',
113 | ],
114 | [ $emitter_wp_upload_dir[ $wp_upload_dir_key ], '/' ],
115 | $string
116 | );
117 | }
118 |
119 | /**
120 | * Get wp_upload_dir data with a blog_id param and a local cache with static variable
121 | *
122 | * @param int $blog_id
123 | *
124 | * @return bool|array
125 | */
126 | public static function get_blog_wp_upload_dir( $blog_id = 0 ) {
127 | if ( 0 === $blog_id ) {
128 | $blog_id = get_current_blog_id();
129 | }
130 |
131 | // Check on static variables for get cache data
132 | if ( isset( self::$blogs_wp_upload_dir[ $blog_id ] ) ) {
133 | return self::$blogs_wp_upload_dir[ $blog_id ];
134 | }
135 |
136 | // Need to switch for get this value for another blog
137 | if ( get_current_blog_id() !== $blog_id ) {
138 | switch_to_blog( $blog_id );
139 | self::$blogs_wp_upload_dir[ $blog_id ] = wp_upload_dir();
140 | restore_current_blog();
141 | } else {
142 | self::$blogs_wp_upload_dir[ $blog_id ] = wp_upload_dir();
143 | }
144 |
145 | return self::$blogs_wp_upload_dir[ $blog_id ];
146 | }
147 | }
148 |
--------------------------------------------------------------------------------
/classes/multisite.php:
--------------------------------------------------------------------------------
1 | bea_csf_relations} (
35 | `id` INT(20) NOT NULL AUTO_INCREMENT ,
36 | `type` VARCHAR(255) NOT NULL ,
37 | `emitter_blog_id` INT(20) NOT NULL ,
38 | `emitter_id` INT(20) NOT NULL ,
39 | `receiver_blog_id` INT(20) NOT NULL ,
40 | `receiver_id` INT(20) NOT NULL ,
41 | PRIMARY KEY (id),
42 | UNIQUE KEY `type_emitter_receiver` (`type`(191), `emitter_blog_id`, `emitter_id`, `receiver_blog_id`, `receiver_id`),
43 | KEY `emitters` ( `type`(191), `emitter_blog_id`, `emitter_id` ),
44 | KEY `receivers` ( `type`(191), `receiver_blog_id`, `receiver_id` )
45 | );";
46 |
47 | if ( ! function_exists( 'dbDelta' ) ) {
48 | require_once ABSPATH . 'wp-admin/includes/upgrade.php';
49 | }
50 |
51 | // Ensure we always try to create this, regardless of whether we're on the
52 | // main site or not. dbDelta will skip creation of global tables on
53 | // non-main sites.
54 | $offset = array_search( 'bea_csf_relations', $wpdb->ms_global_tables, true );
55 | if ( ! empty( $offset ) ) {
56 | unset( $wpdb->ms_global_tables[ $offset ] );
57 | }
58 | $result = dbDelta( $schema );
59 | $wpdb->ms_global_tables[] = 'bea_csf_relations';
60 |
61 | if ( empty( $result ) ) {
62 | // No changes, database already exists and is up-to-date
63 | return 'exists';
64 | }
65 |
66 | return 'created';
67 | }
68 |
69 | public static function create_queue_table() {
70 | global $wpdb;
71 |
72 | $schema = "CREATE TABLE {$wpdb->bea_csf_queue} (
73 | `id` BIGINT(20) NOT NULL auto_increment,
74 | `type` VARCHAR(255) NOT NULL,
75 | `object_name` VARCHAR(255) NOT NULL,
76 | `hook_data` TEXT NOT NULL,
77 | `current_filter` TEXT NOT NULL,
78 | `receiver_blog_id` BIGINT(20),
79 | `fields` TEXT NOT NULL,
80 | PRIMARY KEY (id),
81 | UNIQUE KEY `unicity_key` (`hook_data`(191),`current_filter`(191),`receiver_blog_id`)
82 | );";
83 |
84 | /**
85 | * Indexes for table `wp_bea_csf_queue`
86 | * ALTER TABLE `wp_bea_csf_queue` ADD UNIQUE KEY `unicity_key` (`hook_data`(255),`current_filter`(255),`receiver_blog_id`,`fields`(255));
87 | **/
88 | if ( ! function_exists( 'dbDelta' ) ) {
89 | require_once ABSPATH . 'wp-admin/includes/upgrade.php';
90 | }
91 |
92 | // Ensure we always try to create this, regardless of whether we're on the
93 | // main site or not. dbDelta will skip creation of global tables on
94 | // non-main sites.
95 | $offset = array_search( 'bea_csf_queue', $wpdb->ms_global_tables, true );
96 | if ( ! empty( $offset ) ) {
97 | unset( $wpdb->ms_global_tables[ $offset ] );
98 | }
99 | $result = dbDelta( $schema );
100 | $wpdb->ms_global_tables[] = 'bea_csf_queue';
101 |
102 | if ( empty( $result ) ) {
103 | // No changes, database already exists and is up-to-date
104 | return 'exists';
105 | }
106 |
107 | return 'created';
108 | }
109 |
110 | public static function create_queue_table_maintenance() {
111 | global $wpdb;
112 |
113 | $schema = "CREATE TABLE {$wpdb->bea_csf_queue_maintenance} (
114 | `id` BIGINT(20) NOT NULL auto_increment,
115 | `type` VARCHAR(255) NOT NULL,
116 | `object_name` VARCHAR(255) NOT NULL,
117 | `hook_data` TEXT NOT NULL,
118 | `current_filter` TEXT NOT NULL,
119 | `receiver_blog_id` BIGINT(20),
120 | `fields` TEXT NOT NULL,
121 | PRIMARY KEY (id),
122 | UNIQUE KEY `unicity_key` (`hook_data`(191),`current_filter`(191),`receiver_blog_id`)
123 | );";
124 |
125 | /**
126 | * Indexes for table `wp_bea_csf_queue_maintenance`
127 | * ALTER TABLE `wp_bea_csf_queue_maintenance` ADD UNIQUE KEY `unicity_key` (`hook_data`(255),`current_filter`(255),`receiver_blog_id`,`fields`(255));
128 | **/
129 |
130 | if ( ! function_exists( 'dbDelta' ) ) {
131 | require_once ABSPATH . 'wp-admin/includes/upgrade.php';
132 | }
133 |
134 | // Ensure we always try to create this, regardless of whether we're on the
135 | // main site or not. dbDelta will skip creation of global tables on
136 | // non-main sites.
137 | $offset = array_search( 'bea_csf_queue_maintenance', $wpdb->ms_global_tables, true );
138 | if ( ! empty( $offset ) ) {
139 | unset( $wpdb->ms_global_tables[ $offset ] );
140 | }
141 | $result = dbDelta( $schema );
142 | $wpdb->ms_global_tables[] = 'bea_csf_queue_maintenance';
143 |
144 | if ( empty( $result ) ) {
145 | // No changes, database already exists and is up-to-date
146 | return 'exists';
147 | }
148 |
149 | return 'created';
150 | }
151 |
152 | /**
153 | * Do nothing :)
154 | */
155 | public static function deactivate() {
156 | }
157 |
158 | /**
159 | * Get post ID from post meta with meta_key and meta_value
160 | *
161 | * @param string $key
162 | * @param string $value
163 | *
164 | * @return int
165 | */
166 | public static function get_post_id_from_meta( $key, $value ) {
167 | global $wpdb;
168 |
169 | return (int) $wpdb->get_var( $wpdb->prepare( "SELECT post_id FROM $wpdb->postmeta WHERE meta_key = %s AND meta_value = %s", $key, $value ) );
170 | }
171 | }
172 |
--------------------------------------------------------------------------------
/classes/query.php:
--------------------------------------------------------------------------------
1 | get( 'bea_csf_filter' ) ) ) {
42 | return $join;
43 | }
44 |
45 | $join_type = $query->get( 'bea_csf_filter' ) === 'local-only' ? 'LEFT' : 'INNER';
46 |
47 | // Get current blog ID safely
48 | $current_blog_id = (int) get_current_blog_id();
49 |
50 | // Prepare the join SQL
51 | $join .= $wpdb->prepare(
52 | " $join_type JOIN {$wpdb->bea_csf_relations} AS bcr ON ({$wpdb->posts}.ID = bcr.receiver_id AND bcr.receiver_blog_id = %d) ",
53 | $current_blog_id
54 | );
55 |
56 | return $join;
57 | }
58 |
59 | /**
60 | * Add join with relations tables for filter local
61 | *
62 | * @param $where
63 | * @param WP_Query $query
64 | *
65 | * @return string
66 | */
67 | public static function posts_where( $where, WP_Query $query ) {
68 | if ( empty( $query->get( 'bea_csf_filter' ) ) || $query->get( 'bea_csf_filter' ) !== 'local-only' ) {
69 | return $where;
70 | }
71 |
72 | $where .= ' AND bcr.receiver_id IS NULL ';
73 |
74 | return $where;
75 | }
76 | }
77 |
78 |
--------------------------------------------------------------------------------
/classes/seo.php:
--------------------------------------------------------------------------------
1 | emitter_blog_id );
60 | $canonical_url = get_permalink( $external->emitter_id );
61 | restore_current_blog();
62 |
63 | return $canonical_url;
64 | }
65 |
66 | }
67 |
--------------------------------------------------------------------------------
/classes/server/attachment.php:
--------------------------------------------------------------------------------
1 | $attachment ), $sync_fields );
25 | }
26 |
27 | /**
28 | * Generic method for get all data need for sync
29 | *
30 | * @param WP_Post|integer $attachment_id
31 | *
32 | * @return array|boolean
33 | */
34 | public static function get_data( $attachment = false ) {
35 | $attachment = get_post( $attachment, ARRAY_A );
36 | if ( empty( $attachment ) ) {
37 | return false;
38 | }
39 |
40 | $attachment['meta_data'] = get_post_custom( $attachment['ID'] );
41 | $attachment['attachment_url'] = get_permalink( $attachment['ID'] );
42 | $attachment['attachment_dir'] = get_attached_file( $attachment['ID'] );
43 | //$attachment['metadata'] = wp_get_attachment_metadata( $attachment['ID'] );
44 |
45 | // Get terms for this object
46 | $taxonomies = get_object_taxonomies( $attachment['post_type'] );
47 | if ( false != $taxonomies ) {
48 | $attachment['terms'] = wp_get_object_terms( $attachment['ID'], $taxonomies );
49 | $attachment['taxonomies'] = $taxonomies;
50 |
51 | foreach ( $attachment['terms'] as $key => $term ) {
52 | $attachment['terms'][ $key ] = BEA_CSF_Server_Taxonomy::get_data( $term );
53 | }
54 | }
55 |
56 | return $attachment;
57 | }
58 |
59 | }
60 |
--------------------------------------------------------------------------------
/classes/server/p2p.php:
--------------------------------------------------------------------------------
1 | $post,
19 | );
20 |
21 | if ( empty( $post ) ) {
22 | return false;
23 | }
24 |
25 | return apply_filters( 'bea_csf.server.posttype.delete', (array) $post, $sync_fields );
26 | }
27 |
28 | /**
29 | * @param WP_Post|boolean|integer $post
30 | * @param array $sync_fields
31 | *
32 | * @return mixed|null|void
33 | */
34 | public static function merge( $post, array $sync_fields ) {
35 | return apply_filters( 'bea_csf.server.posttype.merge', self::get_data( $post, $sync_fields ), $sync_fields );
36 | }
37 |
38 | /**
39 | * Generic method for get all data need for sync
40 | *
41 | * @param WP_Post|integer $post
42 | * @param array $sync_fields
43 | *
44 | * @return array|boolean
45 | */
46 | public static function get_data( $post, array $sync_fields ) {
47 | global $wpdb;
48 |
49 | if ( empty( $post ) ) {
50 | return false;
51 | }
52 |
53 | // Get object from object or ID
54 | $post = get_post( $post );
55 | if ( empty( $post ) ) {
56 | return false;
57 | }
58 |
59 | // Transform objet to array
60 | $post = (array) $post;
61 |
62 | // Get post metas
63 | $post['_thumbnail_id'] = (int) get_post_meta( $post['ID'], '_thumbnail_id', true );
64 | if ( $post['_thumbnail_id'] > 0 ) {
65 | $post['_thumbnail'] = BEA_CSF_Server_Attachment::get_data( $post['_thumbnail_id'] );
66 | } else {
67 | $post['_thumbnail'] = false;
68 | }
69 |
70 | // Get metas
71 | $post['meta_data'] = get_post_custom( $post['ID'] );
72 |
73 | // Remove some internal meta
74 | if ( isset( $post['meta_data'][ '_b' . get_current_blog_id() . '_post_receivers' ] ) ) {
75 | unset( $post['meta_data'][ '_b' . get_current_blog_id() . '_post_receivers' ] );
76 | }
77 | if ( isset( $post['meta_data']['_exclude_from_sync'] ) ) {
78 | unset( $post['meta_data']['_exclude_from_sync'] );
79 | }
80 |
81 | // Get terms for this object
82 | $taxonomies = get_object_taxonomies( $post['post_type'] );
83 | if ( false != $taxonomies ) {
84 | $post['terms'] = wp_get_object_terms( $post['ID'], $taxonomies );
85 | $post['taxonomies'] = $taxonomies;
86 |
87 | foreach ( $post['terms'] as $key => $term ) {
88 | $post['terms'][ $key ] = BEA_CSF_Server_Taxonomy::get_data( $term );
89 | }
90 | }
91 |
92 | // Init medias children
93 | $post['medias'] = array();
94 |
95 | // Get medias attachment
96 | $attachments = get_children(
97 | array(
98 | 'post_parent' => $post['ID'],
99 | 'post_type' => 'attachment',
100 | )
101 | );
102 |
103 | foreach ( $attachments as $attachment ) {
104 | $post['medias'][] = BEA_CSF_Server_Attachment::get_data( $attachment );
105 | }
106 |
107 | // Get P2P connections
108 | if ( defined( 'P2P_PLUGIN_VERSION' ) ) {
109 | $results = (array) $wpdb->get_results( $wpdb->prepare( "SELECT * FROM $wpdb->p2p WHERE p2p_from = %d OR p2p_to = %d", $post['ID'], $post['ID'] ) );
110 |
111 | $post['connections'] = array();
112 | foreach ( $results as $result ) {
113 | $post['connections'][] = BEA_CSF_Server_P2P::merge( $result, $sync_fields );
114 | }
115 | }
116 |
117 | return $post;
118 | }
119 |
120 | }
121 |
--------------------------------------------------------------------------------
/classes/server/taxonomy.php:
--------------------------------------------------------------------------------
1 | $term_values[1],
23 | 'taxonomy' => $term_values[0],
24 | );
25 |
26 | if ( empty( $term ) ) {
27 | return false;
28 | }
29 | } else { // is_stdClass
30 | $term = (array) $term;
31 | }
32 |
33 | return apply_filters( 'bea_csf.server.taxonomy.delete', $term, $sync_fields );
34 | }
35 |
36 | /**
37 | * Check for new term and send it to client
38 | *
39 | * @param stdClass|boolean|integer $post
40 | * @param array $sync_fields
41 | *
42 | * @return mixed|null|void
43 | */
44 | public static function merge( $term, array $sync_fields ) {
45 | if ( empty( $term ) ) {
46 | return false;
47 | }
48 |
49 | if ( is_string( $term ) ) { // Internal format : taxonomy|||term_id
50 | $term_values = explode( '|||', $term );
51 |
52 | $term = get_term( $term_values[1], $term_values[0] );
53 | if ( empty( $term ) ) {
54 | return false;
55 | }
56 | }
57 |
58 | $term = self::get_data( $term );
59 |
60 | return apply_filters( 'bea_csf.server.taxonomy.merge', $term, $sync_fields );
61 | }
62 |
63 | /**
64 | * Generic method for get all data need for sync
65 | *
66 | * @param stdClass $term
67 | *
68 | * @return array
69 | */
70 | public static function get_data( $term ) {
71 | // Get all meta for current term
72 | $term->meta_data = get_term_meta( $term->term_id );
73 |
74 | // Remove some internal meta
75 | if ( isset( $term->meta_data['already_exists'] ) ) {
76 | unset( $term->meta_data['already_exists'] );
77 | }
78 |
79 | // Remove unused fields
80 | unset( $term->term_group, $term->count );
81 |
82 | return (array) $term;
83 | }
84 | }
85 |
--------------------------------------------------------------------------------
/codeception.dist.yml:
--------------------------------------------------------------------------------
1 | paths:
2 | tests: tests
3 | output: tests/_output
4 | data: tests/_data
5 | support: tests/_support
6 | envs: tests/_envs
7 | actor_suffix: Tester
8 | extensions:
9 | enabled:
10 | - Codeception\Extension\RunFailed
11 | commands:
12 | - Codeception\Command\GenerateWPUnit
13 | - Codeception\Command\GenerateWPRestApi
14 | - Codeception\Command\GenerateWPRestController
15 | - Codeception\Command\GenerateWPRestPostTypeController
16 | - Codeception\Command\GenerateWPAjax
17 | - Codeception\Command\GenerateWPCanonical
18 | - Codeception\Command\GenerateWPXMLRPC
19 | params:
20 | - .env.testing
21 |
--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
1 | {
2 | "name": "bea/bea-content-sync-fusion",
3 | "description": "Manage content synchronisation across a WordPress Multisite.",
4 | "license": "GPL-2.0-or-later",
5 | "authors": [
6 | {
7 | "name": "Be API",
8 | "email": "technical@beapi.fr"
9 | }
10 | ],
11 | "type" : "wordpress-plugin",
12 | "config": {
13 | "optimize-autoloader": true,
14 | "preferred-install": "dist",
15 | "sort-packages": true,
16 | "allow-plugins": {
17 | "composer/installers": true,
18 | "phpro/grumphp-shim": true,
19 | "roots/wordpress-core-installer": true,
20 | "dealerdirect/phpcodesniffer-composer-installer": true
21 | }
22 | },
23 | "require" : {
24 | "beapi/gutenberg-serializer": "^1.0",
25 | "composer/installers" : "~1.0"
26 | },
27 | "require-dev": {
28 | "codeception/module-asserts": "^1.3",
29 | "codeception/module-cli": "^1.0",
30 | "codeception/module-db": "^1.0",
31 | "codeception/module-filesystem": "^1.0",
32 | "codeception/module-phpbrowser": "^1.0",
33 | "codeception/module-webdriver": "^1.1",
34 | "codeception/util-universalframework": "^1.0",
35 | "dealerdirect/phpcodesniffer-composer-installer": "^0.7.0",
36 | "lucatume/wp-browser": "^2.6",
37 | "php-parallel-lint/php-parallel-lint": "^1.2",
38 | "phpcompatibility/php-compatibility": "^9.3",
39 | "phpro/grumphp-shim": "^1.0",
40 | "roots/wordpress": "^5.5",
41 | "squizlabs/php_codesniffer": "^3.5",
42 | "vimeo/psalm": "^4.0",
43 | "wp-coding-standards/wpcs": "^2.3"
44 | },
45 | "extra": {
46 | "installer-paths": {
47 | "wordpress": ["roots/wordpress"]
48 | }
49 | },
50 | "scripts": {
51 | "cs": "./vendor/bin/phpcs",
52 | "cbf": "./vendor/bin/phpcbf",
53 | "psalm": "./vendor/bin/psalm",
54 | "test-unit": "./vendor/bin/codecept run unit --html",
55 | "test-wpunit": "./vendor/bin/codecept run wpunit --html",
56 | "test-functional": "./vendor/bin/codecept run functional --html",
57 | "test-acceptance": "./vendor/bin/codecept run acceptance --html"
58 | }
59 | }
60 |
--------------------------------------------------------------------------------
/cron/cronjob.sh:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env bash
2 | # 2018 - BE API - Cronjob for "BEA Content Sync Fusion" plugin
3 |
4 | ## INSTALL
5 | # We recommend to exec this task each minute : */1 * * * *
6 |
7 | ## USAGE
8 | # 5 arguments max
9 | # 1st argument : REQUIRED - the network URL of WordPress, eg : mydomain.fr, https://mydomain.fr
10 | # 2nd argument : OPTIONAL - the WP-CLI binary command, eg: wp, "lando wp", "php wp-cli.phar" (Default value : wp)
11 | # 3nd argument : OPTIONAL - the path of WP installation, eg: /var/www/wp/ (not default value)
12 | # 4rth argument : OPTIONAL - the alternate queue, eg : true (Default value : false)
13 | # 5th argument : OPTIONAL - additional parameters to pass to WPCLI, eg : --skip-plugins=stream
14 |
15 | ## TODO
16 | # Allow to customize path for PID file
17 |
18 | # set -e # same AS set -o errexit
19 | set -o pipefail
20 | set -o nounset
21 |
22 | # Set magic variables for current file & dir
23 | # See: https://kvz.io/blog/2013/11/21/bash-best-practices/
24 | __dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
25 | __file="${__dir}/$(basename "${BASH_SOURCE[0]}")"
26 | __base="$(basename ${__file} .sh)"
27 |
28 | # The first argument is mandatory
29 | if [ -z "${1:-}" ]
30 | then
31 | echo "You must pass at least one argument, the WordPress network URL..."
32 | exit 1
33 | fi
34 |
35 | # Set variables from command arguments
36 | WP_NETWORK_URL=${1}
37 | WP_CLI_BIN=${2:-wp}
38 | ALT_QUEUE=${4:-false}
39 | ADDITIONAL_ARGS=${5:-''}
40 |
41 | # Wrap the 3rd argument if is filled
42 | if [ -n "${3:-}" ]; then
43 | WP_PATH="--path=${3}"
44 | else
45 | WP_PATH=""
46 | fi
47 |
48 | # Use the 4rth argument if is filled
49 | if [ false == ALT_QUEUE ]; then
50 | PIDFILE="$__dir/wp-bea-csf.pid"
51 | else
52 | PIDFILE="$__dir/wp-bea-csf-alt.pid"
53 | fi
54 |
55 | # Create and test for a LOCK PID FILE for Preventing duplicate cron job executions
56 | # See: https://bencane.com/2015/09/22/preventing-duplicate-cron-job-executions/
57 | if [ -f $PIDFILE ]
58 | then
59 | PID=$(cat $PIDFILE)
60 | ps -p $PID > /dev/null 2>&1
61 | if [ $? -eq 0 ]
62 | then
63 | echo "Process already running"
64 | exit 1
65 | else
66 | ## Process not found assume not running
67 | echo $$ > $PIDFILE
68 | if [ $? -ne 0 ]
69 | then
70 | echo "Could not create PID file"
71 | exit 1
72 | fi
73 | fi
74 | else
75 | echo $$ > $PIDFILE
76 | if [ $? -ne 0 ]
77 | then
78 | echo "Could not create PID file"
79 | exit 1
80 | fi
81 | fi
82 |
83 | # Regular queue
84 | $WP_CLI_BIN content-sync-fusion queue get_sites --alternativeq=$ALT_QUEUE --url="$WP_NETWORK_URL" $ADDITIONAL_ARGS $WP_PATH | xargs -I {} $WP_CLI_BIN content-sync-fusion queue pull --alternativeq=$ALT_QUEUE --url={} $ADDITIONAL_ARGS $WP_PATH
85 |
86 | # Check for resync content (new site/blog)
87 | $WP_CLI_BIN content-sync-fusion resync new_sites --smart=true --attachments=true --post_type=true --taxonomies=true --url="$WP_NETWORK_URL" $ADDITIONAL_ARGS $WP_PATH
88 |
89 | # Remove lock PIDFILE
90 | rm $PIDFILE
91 |
92 | exit 0
--------------------------------------------------------------------------------
/functions/api.php:
--------------------------------------------------------------------------------
1 | get_var( $wpdb->prepare( "SELECT tm.term_id FROM $wpdb->termmeta tm INNER JOIN $wpdb->term_taxonomy tt ON tm.term_id = tt.term_id WHERE tm.meta_key = %s AND tm.meta_value = %s AND tt.taxonomy = %s", $meta_key, $meta_value, $taxonomy ) );
37 | } else {
38 | $result = (int) $wpdb->get_var( $wpdb->prepare( "SELECT term_id FROM $wpdb->termmeta WHERE meta_key = %s AND meta_value = %s", $meta_key, $meta_value ) );
39 | }
40 |
41 | //wp_cache_set( $key, $result, 'term_meta' );
42 | //}
43 |
44 | return $result;
45 | }
46 |
--------------------------------------------------------------------------------
/functions/template.php:
--------------------------------------------------------------------------------
1 |
2 | have_posts() ) : ?>
3 |
4 |
5 |
6 | |
7 | |
8 |
9 |
10 | have_posts() ) :
12 | $query_contents->the_post();
13 | ?>
14 |
15 | | - |
16 | |
17 |
18 |
19 |
20 |
21 |
22 |
23 |
24 |
--------------------------------------------------------------------------------
/views/admin/blog-widget-status.php:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 | 0 ) : ?>
7 |
13 |
14 |
2 |
3 |
4 |
5 | />
6 |
9 |
10 |
11 |
12 |
13 |
14 |
15 |
16 | %1$s, and from the original article: %2$s', 'bea-content-sync-fusion' ), $emitter_data['blog_name'], $emitter_data['post_title'] );
18 | ?>
19 |
20 |
--------------------------------------------------------------------------------
/views/admin/client-page-settings-notification.php:
--------------------------------------------------------------------------------
1 |
30 |
--------------------------------------------------------------------------------
/views/admin/client-terms-form.php:
--------------------------------------------------------------------------------
1 |
2 | |
3 |
4 |
5 |
6 |
7 |
13 |
14 |
15 |
16 |
17 |
24 |
25 |
26 | |
27 |
28 |
--------------------------------------------------------------------------------
/views/admin/server-metabox-attachment.php:
--------------------------------------------------------------------------------
1 | ID); ?>
2 |
3 |
4 |
5 |
6 | />
8 |
9 |
12 |
13 |
14 | %s', 'bea-content-sync-fusion' ), implode( ', ', $sync_names ) ); ?>
15 |
16 |
--------------------------------------------------------------------------------
/views/admin/server-metabox-auto.php:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 | />
7 |
10 |
11 |
12 |
13 |
14 |
15 |
16 |
17 | %s', 'bea-content-sync-fusion' ), implode( ', ', $sync_names ) ); ?>
18 |
19 |
--------------------------------------------------------------------------------
/views/admin/server-metabox-manual.php:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
40 |
41 |
42 |
43 |
45 |
46 |
47 |
48 | %s', 'bea-content-sync-fusion' ), implode( ', ', $sync_names ) ); ?>
49 |
50 |
--------------------------------------------------------------------------------
/views/admin/server-page-add.php:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 |
139 |
2 |
3 |
4 | ' . sprintf( __( 'Cron process %1$d items by %2$d items', 'bea-content-sync-fusion' ), BEA_CSF_CRON_QTY, BEA_CSF_CRON_QTY ) . '';
8 |
9 | echo __( 'Number of items in the queue : ', 'bea-content-sync-fusion' ) . $nbqueue;
10 |
11 | $lock_file = sys_get_temp_dir() . '/bea-content-sync-fusion.lock';
12 | if ( file_exists( $lock_file ) ) {
13 | echo '
' . sprintf( __( 'The file %s has been modified : ', 'bea-content-sync-fusion' ), $lock_file ) . date( 'd F Y H:i:s.', filemtime( $lock_file ) ) . '
';
14 | ?>
15 |
22 | ' . sprintf( __( 'The file %s has been deleted', 'bea-content-sync-fusion' ), $lock_file ) . '';
26 | }
27 |
28 | // Maintenance
29 | global $wpdb;
30 | $nb_queue_maintenance = (int) $wpdb->get_var( 'SELECT COUNT(id) as nbqueue FROM ' . $GLOBALS['wpdb']->bea_csf_queue_maintenance );
31 | if ( $nb_queue_maintenance > 0 ) {
32 | echo '
' . __( 'Number of items in the queue of maintenance : ', 'bea-content-sync-fusion' ) . $nb_queue_maintenance . '
';
33 | }
34 | ?>
35 |
36 |
37 |
38 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 |
10 | |
11 | |
12 | |
13 | |
14 |
15 | |
16 |
17 | |
18 | |
19 | |
20 | |
21 |
22 |
23 |
24 | ' . sprintf( __( 'No synchronization exists. Want to create one?', 'bea-content-sync-fusion' ), network_admin_url( 'admin.php?page=' . 'bea-csf-add' ) ) . ' | ';
27 | else :
28 | $class = 'alternate';
29 | $i = 0;
30 | foreach ( $registered_syncs as $sync ) :
31 | // Skip invalid data
32 | $label = $sync->get_field( 'label' );
33 | if ( empty( $label ) ) {
34 | continue;
35 | }
36 |
37 | // Get post type label from cpt name
38 | $post_type_label = '-';
39 | $post_type_object = get_post_type_object( $sync->get_field( 'post_type' ) );
40 | if ( $post_type_object != false ) {
41 | $post_type_label = $post_type_object->labels->name;
42 | }
43 |
44 | // Get taxonomies labels from taxo name
45 | $taxonomies_label = array();
46 | foreach ( $sync->get_field( 'taxonomies' ) as $taxonomy_name ) {
47 | $taxonomy_object = get_taxonomy( $taxonomy_name );
48 | if ( $taxonomy_object != false ) {
49 | $taxonomies_label[] = $taxonomy_object->labels->name;
50 | }
51 | }
52 | $taxonomies_label = implode( ', ', $taxonomies_label );
53 |
54 | // Get P2P labels from taxo name
55 | $p2p_label = implode( ', ', (array) $sync->get_field( 'p2p_connections' ) );
56 |
57 | $i ++;
58 | $class = ( $class == 'alternate' ) ? '' : 'alternate';
59 | ?>
60 |
61 | |
62 | get_field( 'label' ) ); ?>
63 |
64 |
99 | |
100 | get_field( 'active' ) ] ); ?> |
101 | |
102 | |
103 |
104 | |
105 |
106 | get_field( 'mode' ) ); ?> |
107 | get_field( 'status' ) ); ?> |
108 | ', self::get_sites( $sync->get_field( 'emitters', true ), 'blogname' ) ); ?> |
109 | ', self::get_sites( $sync->get_field( 'receivers', true ), 'blogname' ) ); ?> |
110 |
111 |
115 |
116 |
117 |
118 |
119 |
120 |
121 |
122 |
149 |
2 | |
3 |
4 |
5 |
6 |
7 |
8 |
21 |
22 |
23 |
24 | %s', 'bea-content-sync-fusion' ), implode( ', ', $sync_names ) ); ?>
25 |
26 |
27 | |
28 |
29 |
--------------------------------------------------------------------------------
/wp-cli.yml:
--------------------------------------------------------------------------------
1 | url: https://bea-content-sync-fusion.lndo.site
2 | path: /app/wordpress
--------------------------------------------------------------------------------