assistant / backend / src / Controllers / PostsController.php

PostsController.php in Assistant – Every Day Productivity Apps 0.3.1, at backend/src/Controllers/PostsController.php

425 lines 10.2 KB

Raw Download Zip

1	<?php
2
3	namespace FL\Assistant\Controllers;
4
5	use FL\Assistant\Data\Repository\PostsRepository;
6	use FL\Assistant\Data\Transformers\PostTransformer;
7	use FL\Assistant\System\Integrations\BeaverBuilder;
8	use FL\Assistant\System\Contracts\ControllerAbstract;
9	use WP_REST_Request;
10	use WP_REST_Server;
11
12	/**
13	* REST API logic for posts.
14	*/
15	class PostsController extends ControllerAbstract {
16
17	protected $posts;
18	protected $transformer;
19
20	public function __construct( PostsRepository $posts, PostTransformer $transformer ) {
21	$this->posts = $posts;
22	$this->transformer = $transformer;
23	}
24
25	/**
26	* Register routes.
27	*/
28	public function register_routes() {
29	$this->route(
30	'/posts', [
31	[
32	'methods' => WP_REST_Server::READABLE,
33	'callback' => [ $this, 'posts' ],
34	'permission_callback' => function () {
35	return current_user_can( 'edit_others_posts' );
36	},
37	],
38	[
39	'methods' => WP_REST_Server::CREATABLE,
40	'callback' => [ $this, 'create_post' ],
41	'permission_callback' => function () {
42	return current_user_can( 'edit_others_posts' );
43	},
44	],
45	]
46	);
47
48	$this->route(
49	'/posts/hierarchical', [
50	[
51	'methods' => WP_REST_Server::READABLE,
52	'callback' => [ $this, 'hierarchical_posts' ],
53	'permission_callback' => function () {
54	return current_user_can( 'edit_others_posts' );
55	},
56	],
57	]
58	);
59
60	$this->route(
61	'/posts/count', [
62	[
63	'methods' => WP_REST_Server::READABLE,
64	'callback' => [ $this, 'posts_count' ],
65	'permission_callback' => function () {
66	return current_user_can( 'edit_others_posts' );
67	},
68	],
69	]
70	);
71
72	$this->route(
73	'/posts/(?P<id>\d+)', [
74	[
75	'methods' => WP_REST_Server::READABLE,
76	'callback' => [ $this, 'post' ],
77	'args' => [
78	'id' => [
79	'required' => true,
80	'type' => 'number',
81	],
82	],
83	'permission_callback' => function () {
84	return current_user_can( 'edit_others_posts' );
85	},
86	],
87	[
88	'methods' => WP_REST_Server::CREATABLE,
89	'callback' => [ $this, 'update_post' ],
90	'args' => [
91	'id' => [
92	'required' => true,
93	'type' => 'number',
94	],
95	'action' => [
96	'required' => true,
97	'type' => 'string',
98	],
99	],
100	'permission_callback' => function () {
101	return current_user_can( 'edit_others_posts' );
102	},
103	],
104	[
105	'methods' => WP_REST_Server::DELETABLE,
106	'callback' => [ $this, 'delete_post' ],
107	'args' => [
108	'id' => [
109	'required' => true,
110	'type' => 'number',
111	],
112	],
113	'permission_callback' => function () {
114	return current_user_can( 'edit_others_posts' );
115	},
116	],
117	]
118	);
119
120	$this->route(
121	'/posts/(?P<id>\d+)/clone', [
122	[
123	'methods' => WP_REST_Server::CREATABLE,
124	'callback' => [ $this, 'clone_post' ],
125	'args' => [
126	'id' => [
127	'required' => true,
128	'type' => 'number',
129	],
130	],
131	'permission_callback' => function () {
132	return current_user_can( 'edit_others_posts' );
133	},
134	],
135	]
136	);
137	}
138
139	/**
140	* Returns an array of posts and related data.
141	*/
142	public function posts( WP_REST_Request $request ) {
143
144	$params = $request->get_params();
145
146	$params['perm'] = 'editable';
147
148	$pager = $this->posts->paginate( $params, $this->transformer );
149
150	return rest_ensure_response( $pager->to_array() );
151	}
152
153	/**
154	* Returns an array of posts and related data
155	* with child posts contained in the parent
156	* post's data array.
157	*/
158	public function hierarchical_posts( $request ) {
159	$response = [];
160	$children = [];
161	$params = $request->get_params();
162	$posts = get_posts(
163	array_merge(
164	$params, [
165	'perm' => 'editable',
166	]
167	)
168	);
169
170	foreach ( $posts as $post ) {
171	if ( $post->post_parent ) {
172	if ( ! isset( $children[ $post->post_parent ] ) ) {
173	$children[ $post->post_parent ] = [];
174	}
175	$children[ $post->post_parent ][] = $post;
176	}
177	}
178
179	foreach ( $posts as $post ) {
180	if ( ! $post->post_parent ) {
181	$parent = $this->transform( $post );
182	$parent['children'] = $this->get_child_posts( $post, $children );
183	$response[] = $parent;
184	}
185	}
186
187	return rest_ensure_response( $response );
188	}
189
190	/**
191	* Returns an array of response data for a single post.
192	*/
193	public function transform( $post ) {
194	return call_user_func( $this->transformer, $post );
195	}
196
197	/**
198	* Returns an array of child posts for the given post.
199	* A $children array must be passed to search for children.
200	*/
201	public function get_child_posts( $post, $children ) {
202	if ( isset( $children[ $post->ID ] ) ) {
203	$post_children = $children[ $post->ID ];
204	foreach ( $post_children as $i => $child ) {
205	$post_children[ $i ] = $this->transform( $child );
206	$post_children[ $i ]['children'] = $this->get_child_posts( $child, $children );
207	}
208
209	return $post_children;
210	}
211
212	return [];
213	}
214
215	/**
216	* Returns an array of counts by post type.
217	*/
218	public function posts_count( $request ) {
219
220	$post_types = $this->posts->get_types();
221	$response = [];
222
223	foreach ( $post_types as $slug => $label ) {
224	$counts = wp_count_posts( $slug );
225	$counts->total = $counts->publish + $counts->draft + $counts->pending + $counts->private + $counts->future;
226	$response[ $slug ] = $counts;
227	}
228
229	return rest_ensure_response( $response );
230	}
231
232	/**
233	* Returns data for a single post.
234	*/
235	public function post( $request ) {
236	$id = $request->get_param( 'id' );
237
238	if ( current_user_can( 'edit_post', $id ) ) {
239	$post = get_post( $id );
240
241	return $this->transform( $post );
242	}
243
244	return [];
245	}
246
247	/**
248	* Creates a single post.
249	*/
250	public function create_post( $request ) {
251	$id = wp_insert_post( $request->get_params() );
252
253	if ( ! $id \|\| is_wp_error( $id ) ) {
254	return [
255	'error' => true,
256	];
257	}
258
259	return $this->transform( get_post( $id ) );
260	}
261
262	/**
263	* Clones a single post.
264	*/
265	public function clone_post( $request ) {
266	global $wpdb;
267
268	$post_id = absint( $request->get_param( 'id' ) );
269	$post = get_post( $post_id );
270	$current_user = wp_get_current_user();
271	$post_data = [
272	'comment_status' => $post->comment_status,
273	'ping_status' => $post->ping_status,
274	'post_author' => $current_user->ID,
275	'post_content' => $post->post_content,
276	'post_excerpt' => $post->post_excerpt,
277	'post_name' => $post->post_name . '-copy',
278	'post_parent' => $post->post_parent,
279	'post_password' => $post->post_password,
280	'post_status' => 'draft',
281	/* translators: %s: post/page title */
282	'post_title' => sprintf( _x( '%s - Copy', '%s stands for post/page title.', 'fl-assistant' ), $post->post_title ),
283	'post_type' => $post->post_type,
284	'to_ping' => $post->to_ping,
285	'menu_order' => $post->menu_order,
286	];
287
288	$new_post_id = wp_insert_post( $post_data );
289	$post_meta = $wpdb->get_results( $wpdb->prepare( "SELECT meta_key, meta_value FROM {$wpdb->postmeta} WHERE post_id = %d", $post_id ) );
290	$taxonomies = get_object_taxonomies( $post->post_type );
291
292	if ( count( $post_meta ) !== 0 ) {
293	foreach ( $post_meta as $meta_info ) {
294	$meta_key = $meta_info->meta_key;
295	$meta_value = addslashes( $meta_info->meta_value );
296	$wpdb->query( "INSERT INTO {$wpdb->postmeta} (post_id, meta_key, meta_value) values ({$new_post_id}, '{$meta_key}', '{$meta_value}')" ); // phpcs:ignore WordPress.DB.PreparedSQL.InterpolatedNotPrepared
297	}
298	}
299
300	foreach ( $taxonomies as $taxonomy ) {
301	$post_terms = wp_get_object_terms( $post_id, $taxonomy );
302	for ( $i = 0; $i < count( $post_terms ); $i ++ ) {
303	wp_set_object_terms( $new_post_id, $post_terms[ $i ]->slug, $taxonomy, true );
304	}
305	}
306
307	return $this->transform( get_post( $new_post_id ) );
308	}
309
310	/**
311	* Updates a single post based on the specified action.
312	*/
313	public function update_post( $request ) {
314	$id = $request->get_param( 'id' );
315	$action = $request->get_param( 'action' );
316
317	if ( ! current_user_can( 'edit_post', $id ) ) {
318	return rest_ensure_response(
319	[
320	'error' => true,
321	]
322	);
323	}
324
325	switch ( $action ) {
326	case 'data':
327	$data = (array) $request->get_param( 'data' );
328	if ( isset( $data['meta'] ) ) {
329	$this->update_post_meta( $id, $data['meta'] );
330	unset( $data['meta'] );
331	}
332	if ( isset( $data['terms'] ) ) {
333	$this->update_post_terms( $id, $data['terms'] );
334	unset( $data['terms'] );
335	}
336	if ( isset( $data['thumbnail'] ) ) {
337	if ( '0' === $data['thumbnail'] ) {
338	delete_post_meta( $id, '_thumbnail_id' );
339	} else {
340	set_post_thumbnail( $id, $data['thumbnail'] );
341	}
342
343	unset( $data['thumbnail'] );
344	}
345	wp_update_post(
346	array_merge(
347	$data, [
348	'ID' => $id,
349	]
350	)
351	);
352	break;
353	case 'meta':
354	$data = (array) $request->get_param( 'data' );
355	$this->update_post_meta( $id, $data );
356	break;
357	case 'terms':
358	$data = (array) $request->get_param( 'data' );
359	$this->update_post_terms( $id, $data );
360	break;
361	case 'trash':
362	if ( ! EMPTY_TRASH_DAYS ) {
363	wp_delete_post( $id );
364	} else {
365	wp_trash_post( $id );
366	}
367	break;
368	case 'untrash':
369	wp_untrash_post( $id );
370	break;
371
372	}
373
374	$updated_post = get_post( $id );
375
376	return rest_ensure_response(
377	[
378	'success' => true,
379	'post' => $updated_post ? $this->transform( $updated_post ) : null,
380	]
381	);
382	}
383
384	/**
385	* Updates post meta values for a post.
386	*/
387	public function update_post_meta( $id, $meta ) {
388	foreach ( $meta as $key => $value ) {
389	update_post_meta( $id, $key, $value );
390	}
391	}
392
393	/**
394	* Updates terms for a post.
395	*/
396	public function update_post_terms( $id, $terms ) {
397	foreach ( $terms as $taxonomy => $ids ) {
398	wp_set_post_terms( $id, $ids, $taxonomy, false );
399	}
400	}
401
402	/**
403	* Deletes a single post based on the specified ID.
404	*/
405	public function delete_post( $request ) {
406	$id = $request->get_param( 'id' );
407
408	if ( ! current_user_can( 'edit_post', $id ) ) {
409	return rest_ensure_response(
410	[
411	'error' => true,
412	]
413	);
414	}
415
416	wp_delete_post( $id );
417
418	return rest_ensure_response(
419	[
420	'success' => true,
421	]
422	);
423	}
424	}
425