Code Coverage
 
Lines
Functions and Methods
Classes and Traits
Total
19.75%
125 / 633
20.00%
2 / 10
 CRAP
0.00%
0 / 1
WPCOM_JSON_API_Update_Post_v1_1_Endpoint
27.47%
125 / 455
20.00%
2 / 10
 27260.23
0.00%
0 / 1
 __construct
66.67%
2 / 3
0.00%
0 / 1
 2.15
 callback
62.50%
5 / 8
0.00%
0 / 1
 4.84
 write_post
29.29%
111 / 379
0.00%
0 / 1
 17806.14
 delete_post
0.00%
0 / 20
0.00%
0 / 1
 90
 restore_post
0.00%
0 / 9
0.00%
0 / 1
 20
 parse_and_set_featured_image
0.00%
0 / 12
0.00%
0 / 1
 42
 parse_and_set_author
0.00%
0 / 12
0.00%
0 / 1
 72
 should_untrash_post
100.00%
1 / 1
100.00%
1 / 1
 3
 untrash_post
100.00%
6 / 6
100.00%
1 / 1
 4
 should_load_theme_functions
0.00%
0 / 5
0.00%
0 / 1
 12
1<?php // phpcs:ignore WordPress.Files.FileName.InvalidClassFileName
2/**
3 * Update post endpoint v1.1
4 *
5 * Endpoints:
6 * Create a post:  /sites/%s/posts/new
7 * Update a post:  /sites/%s/posts/%d
8 * Delete a post:  /sites/%s/posts/%d/delete
9 * Restore a post: /sites/%s/posts/%d/restore
10 */
11
12if ( ! defined( 'ABSPATH' ) ) {
13    exit( 0 );
14}
15
16new WPCOM_JSON_API_Update_Post_v1_1_Endpoint(
17    array(
18        'description'          => 'Create a post.',
19        'group'                => 'posts',
20        'stat'                 => 'posts:new',
21        'new_version'          => '1.2',
22        'min_version'          => '1.1',
23        'max_version'          => '1.1',
24        'method'               => 'POST',
25        'path'                 => '/sites/%s/posts/new',
26        'path_labels'          => array(
27            '$site' => '(int|string) Site ID or domain',
28        ),
29
30        'request_format'       => array(
31            // explicitly document all input.
32            'date'              => "(ISO 8601 datetime) The post's creation time.",
33            'title'             => '(HTML) The post title.',
34            'content'           => '(HTML) The post content.',
35            'excerpt'           => '(HTML) An optional post excerpt.',
36            'slug'              => '(string) The name (slug) for the post, used in URLs.',
37            'author'            => '(string) The username or ID for the user to assign the post to.',
38            'publicize'         => '(array|bool) True or false if the post be shared to external services. An array of services if we only want to share to a select few. Defaults to true.',
39            'publicize_message' => '(string) Custom message to be shared to external services.',
40            'status'            => array(
41                'publish'    => 'Publish the post.',
42                'private'    => 'Privately publish the post.',
43                'draft'      => 'Save the post as a draft.',
44                'pending'    => 'Mark the post as pending editorial approval.',
45                'future'     => 'Schedule the post (alias for publish; you must also set a future date).',
46                'auto-draft' => 'Save a placeholder for a newly created post, with no content.',
47            ),
48            'sticky'            => array(
49                'false' => 'Post is not marked as sticky.',
50                'true'  => 'Stick the post to the front page.',
51            ),
52            'password'          => '(string) The plaintext password protecting the post, or, more likely, the empty string if the post is not password protected.',
53            'parent'            => "(int) The post ID of the new post's parent.",
54            'type'              => "(string) The post type. Defaults to 'post'. Post types besides post and page need to be whitelisted using the <code>rest_api_allowed_post_types</code> filter.",
55            'terms'             => '(object) Mapping of taxonomy to comma-separated list or array of terms (name or id)',
56            'categories'        => '(array|string) Comma-separated list or array of categories (name or id)',
57            'tags'              => '(array|string) Comma-separated list or array of tags (name or id)',
58            'format'            => array_merge( array( 'default' => 'Use default post format' ), get_post_format_strings() ),
59            'featured_image'    => '(string) The post ID of an existing attachment to set as the featured image. Pass an empty string to delete the existing image.',
60            'media'             => '(media) An array of files to attach to the post. To upload media, the entire request should be multipart/form-data encoded. Multiple media items will be displayed in a gallery. Accepts  jpg, jpeg, png, gif, pdf, doc, ppt, odt, pptx, docx, pps, ppsx, xls, xlsx, key. Audio and Video may also be available. See <code>allowed_file_types</code> in the options response of the site endpoint. Errors produced by media uploads, if any, will be in `media_errors` in the response. <br /><br /><strong>Example</strong>:<br />' .
61                            "<code>curl \<br />--form 'title=Image Post' \<br />--form 'media[0]=@/path/to/file.jpg' \<br />--form 'media_attrs[0][caption]=My Great Photo' \<br />-H 'Authorization: BEARER your-token' \<br />'https://public-api.wordpress.com/rest/v1/sites/123/posts/new'</code>",
62            'media_urls'        => '(array) An array of URLs for images to attach to a post. Sideloads the media in for a post. Errors produced by media sideloading, if any, will be in `media_errors` in the response.',
63            'media_attrs'       => '(array) An array of attributes (`title`, `description` and `caption`) are supported to assign to the media uploaded via the `media` or `media_urls` properties. You must use a numeric index for the keys of `media_attrs` which follow the same sequence as `media` and `media_urls`. <br /><br /><strong>Example</strong>:<br />' .
64                            "<code>curl \<br />--form 'title=Gallery Post' \<br />--form 'media[]=@/path/to/file1.jpg' \<br />--form 'media_urls[]=http://exapmple.com/file2.jpg' \<br /> \<br />--form 'media_attrs[0][caption]=This will be the caption for file1.jpg' \<br />--form 'media_attrs[1][title]=This will be the title for file2.jpg' \<br />-H 'Authorization: BEARER your-token' \<br />'https://public-api.wordpress.com/rest/v1/sites/123/posts/new'</code>",
65            'metadata'          => '(array) Array of metadata objects containing the following properties: `key` (metadata key), `id` (meta ID), `previous_value` (if set, the action will only occur for the provided previous value), `value` (the new value to set the meta to), `operation` (the operation to perform: `update` or `add`; defaults to `update`). Unprotected meta keys can be changed by users who can edit the post. Protected meta keys (those starting with an underscore) can be changed only when the user can edit that key, which requires an <code>auth_callback</code> registered with <code>register_meta()</code> or an <code>auth_post_meta_{$meta_key}</code> filter. Keys allowed by the <code>rest_api_allowed_public_metadata</code> filter can also be added or updated.',
66            'discussion'        => '(object) A hash containing one or more of the following boolean values, which default to the blog\'s discussion preferences: `comments_open`, `pings_open`',
67            'likes_enabled'     => "(bool) Should the post be open to likes? Defaults to the blog's preference.",
68            'sharing_enabled'   => '(bool) Should sharing buttons show on this post? Defaults to true.',
69            'menu_order'        => '(int) (Pages Only) the order pages should appear in. Use 0 to maintain alphabetical order.',
70            'page_template'     => '(string) (Pages Only) The page template this page should use.',
71        ),
72
73        'example_request'      => 'https://public-api.wordpress.com/rest/v1.1/sites/82974409/posts/new/',
74
75        'example_request_data' => array(
76            'headers' => array(
77                'authorization' => 'Bearer YOUR_API_TOKEN',
78            ),
79
80            'body'    => array(
81                'title'      => 'Hello World',
82                'content'    => 'Hello. I am a test post. I was created by the API',
83                'tags'       => 'tests',
84                'categories' => 'API',
85            ),
86        ),
87    )
88);
89
90new WPCOM_JSON_API_Update_Post_v1_1_Endpoint(
91    array(
92        'description'          => 'Edit a post.',
93        'group'                => 'posts',
94        'stat'                 => 'posts:1:POST',
95        'new_version'          => '1.2',
96        'min_version'          => '1.1',
97        'max_version'          => '1.1',
98        'method'               => 'POST',
99        'path'                 => '/sites/%s/posts/%d',
100        'path_labels'          => array(
101            '$site'    => '(int|string) Site ID or domain',
102            '$post_ID' => '(int) The post ID',
103        ),
104
105        'request_format'       => array(
106            'date'              => "(ISO 8601 datetime) The post's creation time.",
107            'title'             => '(HTML) The post title.',
108            'content'           => '(HTML) The post content.',
109            'excerpt'           => '(HTML) An optional post excerpt.',
110            'slug'              => '(string) The name (slug) for the post, used in URLs.',
111            'author'            => '(string) The username or ID for the user to assign the post to.',
112            'publicize'         => '(array|bool) True or false if the post be shared to external services. An array of services if we only want to share to a select few. Defaults to true.',
113            'publicize_message' => '(string) Custom message to be shared to external services.',
114            'status'            => array(
115                'publish' => 'Publish the post.',
116                'private' => 'Privately publish the post.',
117                'draft'   => 'Save the post as a draft.',
118                'future'  => 'Schedule the post (alias for publish; you must also set a future date).',
119                'pending' => 'Mark the post as pending editorial approval.',
120                'trash'   => 'Set the post as trashed.',
121            ),
122            'sticky'            => array(
123                'false' => 'Post is not marked as sticky.',
124                'true'  => 'Stick the post to the front page.',
125            ),
126            'password'          => '(string) The plaintext password protecting the post, or, more likely, the empty string if the post is not password protected.',
127            'parent'            => "(int) The post ID of the new post's parent.",
128            'terms'             => '(object) Mapping of taxonomy to comma-separated list or array of terms (name or id)',
129            'categories'        => '(array|string) Comma-separated list or array of categories (name or id)',
130            'tags'              => '(array|string) Comma-separated list or array of tags (name or id)',
131            'format'            => array_merge( array( 'default' => 'Use default post format' ), get_post_format_strings() ),
132            'discussion'        => '(object) A hash containing one or more of the following boolean values, which default to the blog\'s discussion preferences: `comments_open`, `pings_open`',
133            'likes_enabled'     => '(bool) Should the post be open to likes?',
134            'menu_order'        => '(int) (Pages only) the order pages should appear in. Use 0 to maintain alphabetical order.',
135            'page_template'     => '(string) (Pages Only) The page template this page should use.',
136            'sharing_enabled'   => '(bool) Should sharing buttons show on this post?',
137            'featured_image'    => '(string) The post ID of an existing attachment to set as the featured image. Pass an empty string to delete the existing image.',
138            'media'             => '(media) An array of files to attach to the post. To upload media, the entire request should be multipart/form-data encoded. Multiple media items will be displayed in a gallery. Accepts  jpg, jpeg, png, gif, pdf, doc, ppt, odt, pptx, docx, pps, ppsx, xls, xlsx, key. Audio and Video may also be available. See <code>allowed_file_types</code> in the options resposne of the site endpoint. <br /><br /><strong>Example</strong>:<br />' .
139                            "<code>curl \<br />--form 'title=Image' \<br />--form 'media[]=@/path/to/file.jpg' \<br />-H 'Authorization: BEARER your-token' \<br />'https://public-api.wordpress.com/rest/v1/sites/123/posts/new'</code>",
140            'media_urls'        => '(array) An array of URLs for images to attach to a post. Sideloads the media in for a post.',
141            'metadata'          => '(array) Array of metadata objects containing the following properties: `key` (metadata key), `id` (meta ID), `previous_value` (if set, the action will only occur for the provided previous value), `value` (the new value to set the meta to), `operation` (the operation to perform: `update` or `add`; defaults to `update`). Users who can edit the post get its unprotected meta keys. Protected meta keys (those starting with an underscore) are returned only when the user can edit that key, which requires an <code>auth_callback</code> registered with <code>register_meta()</code> or an <code>auth_post_meta_{$meta_key}</code> filter. Keys allowed by the <code>rest_api_allowed_public_metadata</code> filter, plus <code>_thumbnail_id</code> and keys starting with <code>geo_</code> or <code>_wpas_</code>, are returned to anyone who can read the post. Most keys starting with <code>_jetpack_</code>, and all keys starting with <code>_elasticsearch_</code>, are never returned.',
142        ),
143
144        'example_request'      => 'https://public-api.wordpress.com/rest/v1.1/sites/82974409/posts/881',
145
146        'example_request_data' => array(
147            'headers' => array(
148                'authorization' => 'Bearer YOUR_API_TOKEN',
149            ),
150
151            'body'    => array(
152                'title'      => 'Hello World (Again)',
153                'content'    => 'Hello. I am an edited post. I was edited by the API',
154                'tags'       => 'tests',
155                'categories' => 'API',
156            ),
157        ),
158    )
159);
160
161new WPCOM_JSON_API_Update_Post_v1_1_Endpoint(
162    array(
163        'description'          => 'Delete a post. Note: If the trash is enabled, this request will send the post to the trash. A second request will permanently delete the post.',
164        'group'                => 'posts',
165        'stat'                 => 'posts:1:delete',
166        'min_version'          => '1.1',
167        'max_version'          => '1.1',
168        'method'               => 'POST',
169        'path'                 => '/sites/%s/posts/%d/delete',
170        'path_labels'          => array(
171            '$site'    => '(int|string) Site ID or domain',
172            '$post_ID' => '(int) The post ID',
173        ),
174
175        'example_request'      => 'https://public-api.wordpress.com/rest/v1.1/sites/82974409/posts/$post_ID/delete/',
176
177        'example_request_data' => array(
178            'headers' => array(
179                'authorization' => 'Bearer YOUR_API_TOKEN',
180            ),
181        ),
182    )
183);
184
185new WPCOM_JSON_API_Update_Post_v1_1_Endpoint(
186    array(
187        'description'          => 'Restore a post or page from the trash to its previous status.',
188        'group'                => 'posts',
189        'stat'                 => 'posts:1:restore',
190        'min_version'          => '1.1',
191        'max_version'          => '1.1',
192        'method'               => 'POST',
193        'path'                 => '/sites/%s/posts/%d/restore',
194        'path_labels'          => array(
195            '$site'    => '(int|string) Site ID or domain',
196            '$post_ID' => '(int) The post ID',
197        ),
198
199        'example_request'      => 'https://public-api.wordpress.com/rest/v1.1/sites/82974409/posts/$post_ID/restore/',
200
201        'example_request_data' => array(
202            'headers' => array(
203                'authorization' => 'Bearer YOUR_API_TOKEN',
204            ),
205        ),
206    )
207);
208
209// phpcs:disable PEAR.NamingConventions.ValidClassName.Invalid
210/**
211 * Update post v1.1 endpoint class.
212 *
213 * @phan-constructor-used-for-side-effects
214 */
215class WPCOM_JSON_API_Update_Post_v1_1_Endpoint extends WPCOM_JSON_API_Post_v1_1_Endpoint {
216    /**
217     * WPCOM_JSON_API_Update_Post_v1_1_Endpoint constructor.
218     *
219     * @param array $args Args.
220     */
221    public function __construct( $args ) {
222        parent::__construct( $args );
223        if ( $this->api->ends_with( $this->path, '/delete' ) ) {
224            $this->post_object_format['status']['deleted'] = 'The post has been deleted permanently.';
225        }
226    }
227
228    /**
229     * Update post API v1.1 callback.
230     *
231     * /sites/%s/posts/new        -> $blog_id
232     * /sites/%s/posts/%d         -> $blog_id, $post_id
233     * /sites/%s/posts/%d/delete  -> $blog_id, $post_id
234     * /sites/%s/posts/%d/restore -> $blog_id, $post_id
235     *
236     * @param string $path API path.
237     * @param int    $blog_id Blog ID.
238     * @param int    $post_id Post ID.
239     *
240     * @return array|bool|WP_Error
241     */
242    public function callback( $path = '', $blog_id = 0, $post_id = 0 ) {
243        $blog_id = $this->api->switch_to_blog_and_validate_user( $this->api->get_blog_id( $blog_id ) );
244        if ( is_wp_error( $blog_id ) ) {
245            return $blog_id;
246        }
247
248        if ( $this->api->ends_with( $path, '/delete' ) ) {
249            return $this->delete_post( $path, $blog_id, $post_id );
250        } elseif ( $this->api->ends_with( $path, '/restore' ) ) {
251            return $this->restore_post( $path, $blog_id, $post_id );
252        } else {
253            return $this->write_post( $path, $blog_id, $post_id );
254        }
255    }
256
257    /**
258     * Create or update a post.
259     *
260     * /sites/%s/posts/new -> $blog_id
261     * /sites/%s/posts/%d  -> $blog_id, $post_id
262     *
263     * @param string $path API path.
264     * @param int    $blog_id Blog ID.
265     * @param int    $post_id Post ID.
266     */
267    public function write_post( $path, $blog_id, $post_id ) {
268        $delete_featured_image = null;
269        $media_results         = array();
270        $post                  = null;
271        global $wpdb;
272
273        $new  = $this->api->ends_with( $path, '/new' );
274        $args = $this->query_args();
275
276        // unhook publicize, it's hooked again later -- without this, skipping services is impossible.
277        if ( defined( 'IS_WPCOM' ) && IS_WPCOM ) {
278            remove_action( 'save_post', array( $GLOBALS['publicize_ui']->publicize, 'async_publicize_post' ), 100 );
279            add_action( 'rest_api_inserted_post', array( $GLOBALS['publicize_ui']->publicize, 'async_publicize_post' ) );
280
281            if ( $this->should_load_theme_functions( $post_id ) ) {
282                $this->load_theme_functions();
283            }
284        }
285
286        if ( $new ) {
287            $input = $this->input( true );
288
289            // 'future' is an alias for 'publish' for now
290            if ( 'future' === $input['status'] ) {
291                $input['status'] = 'publish';
292            }
293
294            // default to post.
295            if ( empty( $input['type'] ) ) {
296                $input['type'] = 'post';
297            }
298
299            if ( 'revision' === $input['type'] ) {
300                if ( ! isset( $input['parent'] ) ) {
301                    return new WP_Error( 'invalid_input', 'Invalid request input', 400 );
302                }
303                $input['status'] = 'inherit'; // force inherit for revision type.
304                $input['slug']   = $input['parent'] . '-autosave-v1';
305            } elseif ( ! isset( $input['title'] ) && ! isset( $input['content'] ) && ! isset( $input['excerpt'] ) ) {
306                return new WP_Error( 'invalid_input', 'Invalid request input', 400 );
307            }
308
309            $post_type = get_post_type_object( $input['type'] );
310
311            if ( ! $this->is_post_type_allowed( $input['type'] ) ) {
312                return new WP_Error( 'unknown_post_type', 'Unknown post type', 404 );
313            }
314
315            if ( ! empty( $input['author'] ) ) {
316                $author_id = $this->parse_and_set_author( $input['author'], $input['type'] );
317                unset( $input['author'] );
318                if ( is_wp_error( $author_id ) ) {
319                    return $author_id;
320                }
321            }
322
323            if ( 'publish' === $input['status'] ) {
324                if ( ! current_user_can( $post_type->cap->publish_posts ) ) {
325                    if ( current_user_can( $post_type->cap->edit_posts ) ) {
326                        $input['status'] = 'pending';
327                    } else {
328                        return new WP_Error( 'unauthorized', 'User cannot publish posts', 403 );
329                    }
330                }
331            } elseif ( ! current_user_can( $post_type->cap->edit_posts ) ) {
332                return new WP_Error( 'unauthorized', 'User cannot edit posts', 403 );
333            }
334        } else {
335            $input = $this->input( false );
336
337            if ( ! is_array( $input ) || ! $input ) {
338                return new WP_Error( 'invalid_input', 'Invalid request input', 400 );
339            }
340
341            $post = get_post( $post_id );
342            if ( ! $post || is_wp_error( $post ) ) {
343                return new WP_Error( 'unknown_post', 'Unknown post', 404 );
344            }
345
346            if ( isset( $input['status'] ) && 'trash' === $input['status'] && ! current_user_can( 'delete_post', $post_id ) ) {
347                return new WP_Error( 'unauthorized', 'User cannot delete post', 403 );
348            }
349
350            // 'future' is an alias for 'publish' for now
351            if ( isset( $input['status'] ) && 'future' === $input['status'] ) {
352                $input['status'] = 'publish';
353            }
354
355            $_post_type = ( ! empty( $input['type'] ) ) ? $input['type'] : $post->post_type;
356            $post_type  = get_post_type_object( $_post_type );
357
358            if ( ! current_user_can( 'edit_post', $post->ID ) ) {
359                return new WP_Error( 'unauthorized', 'User cannot edit post', 403 );
360            }
361
362            if ( ! empty( $input['author'] ) ) {
363                $author_id = $this->parse_and_set_author( $input['author'], $_post_type );
364                unset( $input['author'] );
365                if ( is_wp_error( $author_id ) ) {
366                    return $author_id;
367                }
368            }
369
370            if ( ( isset( $input['status'] ) && 'publish' === $input['status'] ) && 'publish' !== $post->post_status && ! current_user_can( 'publish_post', $post->ID ) ) {
371                $input['status'] = 'pending';
372            }
373            $last_status = $post->post_status;
374            $new_status  = $input['status'] ?? $last_status;
375
376            // Make sure that drafts get the current date when transitioning to publish if not supplied in the post.
377            // Similarly, scheduled posts that are manually published before their scheduled date should have the date reset.
378            $date_in_past         = ( strtotime( $post->post_date_gmt ) < time() );
379            $reset_draft_date     = 'publish' === $new_status && 'draft' === $last_status && ! isset( $input['date_gmt'] ) && $date_in_past;
380            $reset_scheduled_date = 'publish' === $new_status && 'future' === $last_status && ! isset( $input['date_gmt'] ) && ! $date_in_past;
381
382            if ( $reset_draft_date || $reset_scheduled_date ) {
383                $input['date_gmt'] = gmdate( 'Y-m-d H:i:s' );
384            }
385
386            // Untrash a post so that the proper hooks get called as well as the comments get untrashed.
387            if ( $this->should_untrash_post( $last_status, $new_status, $post ) ) {
388                $input = $this->untrash_post( $post, $input );
389            }
390        }
391
392        if ( function_exists( 'wpcom_switch_to_blog_locale' ) ) {
393            // fixes calypso-pre-oss #12476: respect blog locale when creating the post slug.
394            wpcom_switch_to_blog_locale( $blog_id );
395        }
396
397        // If date was set, $this->input will set date_gmt, date still needs to be adjusted for the blog's offset.
398        if ( isset( $input['date_gmt'] ) ) {
399            $gmt_offset       = get_option( 'gmt_offset' );
400            $time_with_offset = strtotime( $input['date_gmt'] ) + $gmt_offset * HOUR_IN_SECONDS;
401            $input['date']    = gmdate( 'Y-m-d H:i:s', $time_with_offset );
402        }
403
404        if ( ! empty( $author_id ) && get_current_user_id() !== $author_id ) {
405            if ( ! current_user_can( $post_type->cap->edit_others_posts ) ) {
406                return new WP_Error( 'unauthorized', "User is not allowed to publish others' posts.", 403 );
407            } elseif ( ! user_can( $author_id, $post_type->cap->edit_posts ) ) {
408                return new WP_Error( 'unauthorized', 'Assigned author cannot publish post.', 403 );
409            }
410        }
411
412        if ( ! is_post_type_hierarchical( $post_type->name ) && 'revision' !== $post_type->name ) {
413            unset( $input['parent'] );
414        }
415
416        $input['terms'] = isset( $input['terms'] ) ? (array) $input['terms'] : array();
417
418        // Convert comma-separated terms to array before attempting to
419        // merge with hardcoded taxonomies.
420        foreach ( $input['terms'] as $taxonomy => $terms ) {
421            if ( is_string( $terms ) ) {
422                $input['terms'][ $taxonomy ] = explode( ',', $terms );
423            } elseif ( ! is_array( $terms ) ) {
424                $input['terms'][ $taxonomy ] = array();
425            }
426        }
427
428        // For each hard-coded taxonomy, merge into terms object.
429        foreach ( array(
430            'categories' => 'category',
431            'tags'       => 'post_tag',
432        ) as $taxonomy_key => $taxonomy ) {
433            if ( ! isset( $input[ $taxonomy_key ] ) ) {
434                continue;
435            }
436
437            if ( ! isset( $input['terms'][ $taxonomy ] ) ) {
438                $input['terms'][ $taxonomy ] = array();
439            }
440
441            $terms = $input[ $taxonomy_key ];
442            if ( is_string( $terms ) ) {
443                $terms = explode( ',', $terms );
444            } elseif ( ! is_array( $terms ) ) {
445                continue;
446            }
447
448            $input['terms'][ $taxonomy ] = array_merge(
449                $input['terms'][ $taxonomy ],
450                $terms
451            );
452        }
453
454        $tax_input = array();
455
456        foreach ( $input['terms'] as $taxonomy => $terms ) {
457            $tax_input[ $taxonomy ] = array();
458            $is_hierarchical        = is_taxonomy_hierarchical( $taxonomy );
459
460            foreach ( $terms as $term ) {
461                /**
462                 * `curl --data 'terms[category][]=123'` should be interpreted as a category ID,
463                 * not a category whose name is '123'.
464                 *
465                 * Consequence: To add a category/tag whose name is '123', the client must
466                 * first look up its ID.
467                 */
468                $term = (string) $term; // ctype_digit compat.
469                if ( ctype_digit( $term ) ) {
470                    $term = (int) $term;
471                }
472
473                $term_info = term_exists( $term, $taxonomy );
474
475                if ( ! $term_info ) {
476                    // A term ID that doesn't already exist. Ignore it: we don't know what name to give it.
477                    if ( is_int( $term ) ) {
478                        continue;
479                    }
480                    // only add a new tag/cat if the user has access to.
481                    $tax = get_taxonomy( $taxonomy );
482
483                    // see https://core.trac.wordpress.org/ticket/26409 .
484                    if ( $is_hierarchical && ! current_user_can( $tax->cap->edit_terms ) ) {
485                        continue;
486                    } elseif ( ! current_user_can( $tax->cap->assign_terms ) ) {
487                        continue;
488                    }
489
490                    $term_info = wp_insert_term( $term, $taxonomy );
491                }
492
493                if ( ! is_wp_error( $term_info ) ) {
494                    if ( $is_hierarchical ) {
495                        // Hierarchical terms must be added by ID.
496                        $tax_input[ $taxonomy ][] = (int) $term_info['term_id'];
497                    } elseif ( is_int( $term ) ) { // Non-hierarchical terms must be added by name.
498                        $term                     = get_term( $term, $taxonomy );
499                        $tax_input[ $taxonomy ][] = $term->name;
500                    } else {
501                        $tax_input[ $taxonomy ][] = $term;
502                    }
503                }
504            }
505        }
506
507        if ( isset( $input['terms']['category'] ) && empty( $tax_input['category'] ) && 'revision' !== $post_type->name ) {
508            $tax_input['category'][] = get_option( 'default_category' );
509        }
510
511        unset( $input['terms'], $input['tags'], $input['categories'] );
512
513        $insert = array();
514
515        if ( ! empty( $input['slug'] ) ) {
516            $insert['post_name'] = $input['slug'];
517            unset( $input['slug'] );
518        }
519
520        if ( isset( $input['discussion'] ) ) {
521            $discussion = (array) $input['discussion'];
522            foreach ( array( 'comment', 'ping' ) as $discussion_type ) {
523                $discussion_open   = sprintf( '%ss_open', $discussion_type );
524                $discussion_status = sprintf( '%s_status', $discussion_type );
525
526                if ( isset( $discussion[ $discussion_open ] ) ) {
527                    $is_open                          = WPCOM_JSON_API::is_truthy( $discussion[ $discussion_open ] );
528                    $discussion[ $discussion_status ] = $is_open ? 'open' : 'closed';
529                }
530
531                if ( isset( $discussion[ $discussion_status ] ) &&
532                    in_array( $discussion[ $discussion_status ], array( 'open', 'closed' ), true ) ) {
533                    $insert[ $discussion_status ] = $discussion[ $discussion_status ];
534                }
535            }
536        }
537
538        unset( $input['discussion'] );
539
540        if ( isset( $input['menu_order'] ) ) {
541            $insert['menu_order'] = $input['menu_order'];
542            unset( $input['menu_order'] );
543        }
544
545        $publicize = $input['publicize'] ?? null;
546        unset( $input['publicize'] );
547
548        $publicize_custom_message = $input['publicize_message'] ?? null;
549        unset( $input['publicize_message'] );
550
551        if ( isset( $input['featured_image'] ) ) {
552            $featured_image        = trim( $input['featured_image'] );
553            $delete_featured_image = empty( $featured_image );
554            unset( $input['featured_image'] );
555        }
556
557        $metadata = $input['metadata'] ?? null;
558        unset( $input['metadata'] );
559
560        $likes = $input['likes_enabled'] ?? null;
561        unset( $input['likes_enabled'] );
562
563        $sharing = $input['sharing_enabled'] ?? null;
564        unset( $input['sharing_enabled'] );
565
566        $sticky = $input['sticky'] ?? null;
567        unset( $input['sticky'] );
568
569        foreach ( $input as $key => $value ) {
570            $insert[ "post_$key" ] = $value;
571        }
572
573        if ( ! empty( $author_id ) ) {
574            $insert['post_author'] = absint( $author_id );
575        }
576
577        if ( ! empty( $tax_input ) ) {
578            $insert['tax_input'] = $tax_input;
579        }
580
581        $has_media        = ! empty( $input['media'] ) ? count( $input['media'] ) : false;
582        $has_media_by_url = ! empty( $input['media_urls'] ) ? count( $input['media_urls'] ) : false;
583
584        $media_id_string = '';
585        if ( $has_media || $has_media_by_url ) {
586            $media_files     = ! empty( $input['media'] ) ? $input['media'] : array();
587            $media_urls      = ! empty( $input['media_urls'] ) ? $input['media_urls'] : array();
588            $media_attrs     = ! empty( $input['media_attrs'] ) ? $input['media_attrs'] : array();
589            $media_results   = $this->handle_media_creation_v1_1( $media_files, $media_urls, $media_attrs );
590            $media_id_string = implode( ',', array_filter( array_map( 'absint', $media_results['media_ids'] ) ) );
591        }
592
593        // A JSON boolean false is cast to array( false ) by the (array|bool) input type.
594        $skip_publicize = false === $publicize || array( false ) === $publicize;
595
596        $block_publicize_flag = $skip_publicize && ! ( defined( 'IS_WPCOM' ) && IS_WPCOM );
597
598        /**
599         * On Jetpack sites, Sync flags the post for sharing on publish, before the skip meta below exists.
600         * WordPress.com unhooks sharing from save_post above instead.
601         *
602         * @return false
603         */
604        $block_publicize = static function () {
605            return false;
606        };
607        if ( $block_publicize_flag ) {
608            add_filter( 'publicize_should_publicize_published_post', $block_publicize, PHP_INT_MAX );
609        }
610
611        if ( $new ) {
612            if ( isset( $input['content'] ) && ! has_shortcode( $input['content'], 'gallery' ) && ( $has_media || $has_media_by_url ) ) {
613                switch ( ( $has_media + $has_media_by_url ) ) {
614                    case 0:
615                        // No images - do nothing.
616                        break;
617                    case 1:
618                        // 1 image - make it big
619                        $input['content']       = sprintf(
620                            "[gallery size=full ids='%s' columns=1]\n\n",
621                            $media_id_string
622                        ) . $input['content'];
623                        $insert['post_content'] = $input['content'];
624                        break;
625                    default:
626                        // Several images - 3 column gallery.
627                        $input['content']       = sprintf(
628                            "[gallery ids='%s']\n\n",
629                            $media_id_string
630                        ) . $input['content'];
631                        $insert['post_content'] = $input['content'];
632                        break;
633                }
634            }
635
636            $post_id = wp_insert_post( add_magic_quotes( $insert ), true );
637        } else {
638            $insert['ID'] = $post->ID;
639
640            // wp_update_post ignores date unless edit_date is set
641            // See: https://codex.wordpress.org/Function_Reference/wp_update_post#Scheduling_posts .
642            // See: https://core.trac.wordpress.org/browser/tags/3.9.2/src/wp-includes/post.php#L3302 .
643            if ( isset( $input['date_gmt'] ) || isset( $input['date'] ) ) {
644                $insert['edit_date'] = true;
645            }
646
647            // this two-step process ensures any changes submitted along with status=trash get saved before trashing.
648            if ( isset( $input['status'] ) && 'trash' === $input['status'] ) {
649                // if we insert it with status='trash', it will get double-trashed, so insert it as a draft first.
650                unset( $insert['status'] );
651                $post_id = wp_update_post( (object) $insert );
652                // now call wp_trash_post so post_meta gets set and any filters get called.
653                wp_trash_post( $post_id );
654            } else {
655                $post_id = wp_update_post( (object) $insert );
656            }
657        }
658
659        if ( $block_publicize_flag ) {
660            remove_filter( 'publicize_should_publicize_published_post', $block_publicize, PHP_INT_MAX );
661        }
662
663        if ( ! $post_id || is_wp_error( $post_id ) ) {
664            return $post_id;
665        }
666
667        // make sure this post actually exists and is not an error of some kind (ie, trying to load media in the posts endpoint).
668        $post_check = $this->get_post_by( 'ID', $post_id, $args['context'] );
669        if ( is_wp_error( $post_check ) ) {
670            return $post_check;
671        }
672
673        if ( $media_id_string ) {
674            // Yes - this is really how wp-admin does it.
675            $wpdb->query(
676                $wpdb->prepare(
677                    "UPDATE $wpdb->posts SET post_parent = %d WHERE post_type = 'attachment' AND ID IN ( $media_id_string )", // phpcs:ignore WordPress.DB.PreparedSQL.InterpolatedNotPrepared -- IDs are filtered to absint above.
678                    $post_id
679                )
680            );
681            foreach ( $media_results['media_ids'] as $media_id ) {
682                clean_attachment_cache( $media_id );
683            }
684            clean_post_cache( $post_id );
685        }
686
687        // set page template for this post.
688        if ( isset( $input['page_template'] ) && 'page' === $post_type->name ) {
689            $page_template  = $input['page_template'];
690            $page_templates = wp_get_theme()->get_page_templates( get_post( $post_id ) );
691            if ( empty( $page_template ) || 'default' === $page_template || isset( $page_templates[ $page_template ] ) ) {
692                update_post_meta( $post_id, '_wp_page_template', $page_template );
693            }
694        }
695
696        // Set like status for the post.
697        /** This filter is documented in modules/likes.php */
698        $sitewide_likes_enabled = (bool) apply_filters( 'wpl_is_enabled_sitewide', ! get_option( 'disabled_likes' ) );
699        if ( $new ) {
700            if ( $sitewide_likes_enabled ) {
701                if ( false === $likes ) {
702                    update_post_meta( $post_id, 'switch_like_status', 0 );
703                } else {
704                    delete_post_meta( $post_id, 'switch_like_status' );
705                }
706            } elseif ( $likes ) {
707                update_post_meta( $post_id, 'switch_like_status', 1 );
708            } else {
709                delete_post_meta( $post_id, 'switch_like_status' );
710            }
711        } elseif ( isset( $likes ) ) {
712            if ( $sitewide_likes_enabled ) {
713                if ( false === $likes ) {
714                    update_post_meta( $post_id, 'switch_like_status', 0 );
715                } else {
716                    delete_post_meta( $post_id, 'switch_like_status' );
717                }
718            } elseif ( true === $likes ) {
719                update_post_meta( $post_id, 'switch_like_status', 1 );
720            } else {
721                delete_post_meta( $post_id, 'switch_like_status' );
722            }
723        }
724
725        // Set sharing status of the post.
726        if ( $new ) {
727            $sharing_enabled = isset( $sharing ) ? (bool) $sharing : true;
728            if ( ! $sharing_enabled ) {
729                update_post_meta( $post_id, 'sharing_disabled', 1 );
730            }
731        } elseif ( isset( $sharing ) && true === $sharing ) {
732            delete_post_meta( $post_id, 'sharing_disabled' );
733        } elseif ( isset( $sharing ) && false == $sharing ) { // phpcs:ignore Universal.Operators.StrictComparisons.LooseEqual
734            update_post_meta( $post_id, 'sharing_disabled', 1 );
735        }
736
737        if ( isset( $sticky ) ) {
738            if ( true === $sticky ) {
739                stick_post( $post_id );
740            } else {
741                unstick_post( $post_id );
742            }
743        }
744
745        // WPCOM Specific (Jetpack's will get bumped elsewhere
746        // Tracks how many posts are published and sets meta
747        // so we can track some other cool stats (like likes & comments on posts published).
748        if ( defined( 'IS_WPCOM' ) && IS_WPCOM ) {
749            if (
750                ( $new && 'publish' === $input['status'] )
751                || (
752                    ! $new && isset( $last_status )
753                    && 'publish' !== $last_status
754                    && isset( $new_status )
755                    && 'publish' === $new_status
756                )
757            ) {
758                /** This action is documented in modules/widgets/social-media-icons.php */
759                do_action( 'jetpack_bump_stats_extras', 'api-insights-posts', $this->api->token_details['client_id'] );
760                update_post_meta( $post_id, '_rest_api_published', 1 );
761                update_post_meta( $post_id, '_rest_api_client_id', $this->api->token_details['client_id'] );
762            }
763        }
764
765        // We ask the user/dev to pass Publicize services he/she wants activated for the post, but Publicize expects us
766        // to instead flag the ones we don't want to be skipped. proceed with said logic.
767        if ( $skip_publicize ) {
768            // No publicize at all, skip all by ID.
769            foreach ( $GLOBALS['publicize_ui']->publicize->get_services( 'all' ) as $name => $service ) {
770                delete_post_meta( $post_id, $GLOBALS['publicize_ui']->publicize->POST_SKIP . $name );
771                $service_connections = $GLOBALS['publicize_ui']->publicize->get_connections( $name );
772                if ( ! $service_connections ) {
773                    continue;
774                }
775                foreach ( $service_connections as $service_connection ) {
776                    update_post_meta( $post_id, $GLOBALS['publicize_ui']->publicize->POST_SKIP . $GLOBALS['publicize_ui']->publicize->get_connection_unique_id( $service_connection ), 1 );
777                }
778            }
779        } elseif ( is_array( $publicize ) && ( $publicize !== array() ) ) {
780            foreach ( $GLOBALS['publicize_ui']->publicize->get_services( 'all' ) as $name => $service ) {
781                /*
782                 * We support both indexed and associative arrays:
783                 * * indexed are to pass entire services
784                 * * associative are to pass specific connections per service
785                 *
786                 * We do support mixed arrays: mixed integer and string keys (see 3rd example below).
787                 *
788                 * EG: array( 'linkedin', 'facebook') will only publicize to those, ignoring the other available services
789                 *      Form data: publicize[]=linkedin&publicize[]=facebook
790                 * EG: array( 'linkedin' => '(int) $pub_conn_id_0, (int) $pub_conn_id_3', 'facebook' => (int) $pub_conn_id_7 ) will publicize to two LinkedIn accounts, and one Facebook connection, of potentially many.
791                 *      Form data: publicize[linkedin]=$pub_conn_id_0,$pub_conn_id_3&publicize[facebook]=$pub_conn_id_7
792                 * EG: array( 'linkedin', 'facebook' => '(int) $pub_conn_id_0, (int) $pub_conn_id_3' ) will publicize to all available LinkedIn accounts, but only 2 of potentially many Facebook connections
793                 *      Form data: publicize[]=linkedin&publicize[facebook]=$pub_conn_id_0,$pub_conn_id_3
794                 */
795
796                // Delete any stale SKIP value for the service by name. We'll add it back by ID.
797                delete_post_meta( $post_id, $GLOBALS['publicize_ui']->publicize->POST_SKIP . $name );
798
799                // Get the user's connections.
800                $service_connections = $GLOBALS['publicize_ui']->publicize->get_connections( $name );
801
802                // if the user doesn't have any connections for this service, move on.
803                if ( ! $service_connections ) {
804                    continue;
805                }
806
807                if ( ! in_array( $name, $publicize, true ) && ! array_key_exists( $name, $publicize ) ) {
808                    // Skip the whole service by adding each connection ID.
809                    foreach ( $service_connections as $service_connection ) {
810                        update_post_meta( $post_id, $GLOBALS['publicize_ui']->publicize->POST_SKIP . $GLOBALS['publicize_ui']->publicize->get_connection_unique_id( $service_connection ), 1 );
811                    }
812                } elseif ( ! empty( $publicize[ $name ] ) ) {
813                    // Seems we're being asked to only push to [a] specific connection[s].
814                    // Explode the list on commas, which will also support a single passed ID.
815                    $requested_connections = explode( ',', ( preg_replace( '/[\s]*/', '', $publicize[ $name ] ) ) );
816
817                    // Flag the connections we can't match with the requested list to be skipped.
818                    foreach ( $service_connections as $service_connection ) {
819                        if ( ! in_array( (string) $GLOBALS['publicize_ui']->publicize->get_connection_id( $service_connection ), $requested_connections, true ) ) {
820                            update_post_meta( $post_id, $GLOBALS['publicize_ui']->publicize->POST_SKIP . $GLOBALS['publicize_ui']->publicize->get_connection_unique_id( $service_connection ), 1 );
821                        } else {
822                            delete_post_meta( $post_id, $GLOBALS['publicize_ui']->publicize->POST_SKIP . $GLOBALS['publicize_ui']->publicize->get_connection_unique_id( $service_connection ) );
823                        }
824                    }
825                } else {
826                    // delete all SKIP values; it's okay to publish to all connected IDs for this service.
827                    foreach ( $service_connections as $service_connection ) {
828                        delete_post_meta( $post_id, $GLOBALS['publicize_ui']->publicize->POST_SKIP . $GLOBALS['publicize_ui']->publicize->get_connection_unique_id( $service_connection ) );
829                    }
830                }
831            }
832        }
833
834        if ( $publicize_custom_message !== null ) {
835            if ( empty( $publicize_custom_message ) ) {
836                delete_post_meta( $post_id, $GLOBALS['publicize_ui']->publicize->POST_MESS );
837            } else {
838                update_post_meta( $post_id, $GLOBALS['publicize_ui']->publicize->POST_MESS, trim( $publicize_custom_message ) );
839            }
840        }
841
842        if ( ! empty( $insert['post_format'] ) ) {
843            if ( 'default' !== strtolower( $insert['post_format'] ) ) {
844                set_post_format( $post_id, $insert['post_format'] );
845            } else {
846                set_post_format( $post_id, get_option( 'default_post_format' ) );
847            }
848        }
849
850        if ( isset( $featured_image ) ) {
851            $this->parse_and_set_featured_image( $post_id, $delete_featured_image, $featured_image );
852        }
853
854        if ( ! empty( $metadata ) ) {
855            foreach ( (array) $metadata as $meta ) {
856
857                $meta = (object) $meta;
858
859                if (
860                    in_array( $meta->key ?? null, Jetpack_SEO_Posts::POST_META_KEYS_ARRAY, true ) &&
861                    ! Jetpack_SEO_Utils::is_enabled_jetpack_seo()
862                ) {
863                    return new WP_Error( 'unauthorized', __( 'SEO tools are not enabled for this site.', 'jetpack' ), 403 );
864                }
865
866                $existing_meta_item = new stdClass();
867
868                if ( empty( $meta->operation ) ) {
869                    $meta->operation = 'update';
870                }
871
872                if ( ! empty( $meta->value ) ) {
873                    if ( 'true' == $meta->value ) { // phpcs:ignore Universal.Operators.StrictComparisons.LooseEqual
874                        $meta->value = true;
875                    }
876                    if ( 'false' == $meta->value ) { // phpcs:ignore Universal.Operators.StrictComparisons.LooseEqual
877                        $meta->value = false;
878                    }
879                }
880
881                if ( ! empty( $meta->id ) ) {
882                    $meta->id           = absint( $meta->id );
883                    $existing_meta_item = get_metadata_by_mid( 'post', $meta->id );
884                    if ( $post_id !== (int) $existing_meta_item->post_id ) {
885                        // Only allow updates for metadata on this post.
886                        continue;
887                    }
888                }
889
890                $unslashed_meta_key           = isset( $meta->key ) ? wp_unslash( $meta->key ) : null; // should match what the final key will be.
891                $meta->key                    = isset( $meta->key ) ? wp_slash( $meta->key ) : null;
892                $unslashed_existing_meta_key  = isset( $existing_meta_item->meta_key ) ? wp_unslash( $existing_meta_item->meta_key ) : null;
893                $existing_meta_item->meta_key = isset( $existing_meta_item->meta_key ) ? wp_slash( $existing_meta_item->meta_key ) : null;
894
895                // make sure that the meta id passed matches the existing meta key.
896                if ( ! empty( $meta->id ) && ! empty( $meta->key ) ) {
897                    $meta_by_id = get_metadata_by_mid( 'post', $meta->id );
898                    if ( $meta_by_id->meta_key !== $meta->key ) {
899                        continue; // skip this meta.
900                    }
901                }
902
903                switch ( $meta->operation ) {
904                    case 'delete':
905                        if ( ! empty( $meta->id ) && ! empty( $existing_meta_item->meta_key ) && current_user_can( 'delete_post_meta', $post_id, $unslashed_existing_meta_key ) ) {
906                            delete_metadata_by_mid( 'post', $meta->id );
907                        } elseif ( ! empty( $meta->key ) && ! empty( $meta->previous_value ) && current_user_can( 'delete_post_meta', $post_id, $unslashed_meta_key ) ) {
908                            delete_post_meta( $post_id, $meta->key, $meta->previous_value );
909                        } elseif ( ! empty( $meta->key ) && current_user_can( 'delete_post_meta', $post_id, $unslashed_meta_key ) ) {
910                            delete_post_meta( $post_id, $meta->key );
911                        }
912
913                        break;
914                    case 'add':
915                        if ( ! empty( $meta->id ) || ! empty( $meta->previous_value ) ) {
916                            break;
917                        } elseif ( ! empty( $meta->key ) && ! empty( $meta->value ) && ( current_user_can( 'add_post_meta', $post_id, $unslashed_meta_key ) ) || WPCOM_JSON_API_Metadata::is_public( $meta->key ) ) {
918                            add_post_meta( $post_id, $meta->key, $meta->value );
919                        }
920
921                        break;
922                    case 'update':
923                        if ( ! isset( $meta->value ) ) {
924                            break;
925                        } elseif ( ! empty( $meta->id ) && ! empty( $existing_meta_item->meta_key ) && ( current_user_can( 'edit_post_meta', $post_id, $unslashed_existing_meta_key ) || WPCOM_JSON_API_Metadata::is_public( $meta->key ) ) ) {
926                            update_metadata_by_mid( 'post', $meta->id, $meta->value );
927                        } elseif ( ! empty( $meta->key ) && ! empty( $meta->previous_value ) && ( current_user_can( 'edit_post_meta', $post_id, $unslashed_meta_key ) || WPCOM_JSON_API_Metadata::is_public( $meta->key ) ) ) {
928                            update_post_meta( $post_id, $meta->key, $meta->value, $meta->previous_value );
929                        } elseif ( ! empty( $meta->key ) && ( current_user_can( 'edit_post_meta', $post_id, $unslashed_meta_key ) || WPCOM_JSON_API_Metadata::is_public( $meta->key ) ) ) {
930                            update_post_meta( $post_id, $meta->key, $meta->value );
931                        }
932
933                        break;
934                }
935            }
936        }
937
938        /** This action is documented in json-endpoints/class.wpcom-json-api-update-post-endpoint.php */
939        do_action( 'rest_api_inserted_post', $post_id, $insert, $new );
940
941        $return = $this->get_post_by( 'ID', $post_id, $args['context'] );
942        if ( ! $return || is_wp_error( $return ) ) {
943            return $return;
944        }
945
946        if ( isset( $input['type'] ) && 'revision' === $input['type'] ) {
947            $return['preview_nonce'] = wp_create_nonce( 'post_preview_' . $input['parent'] );
948        }
949
950        if ( isset( $sticky ) ) {
951            // workaround for sticky test occasionally failing, maybe a race condition with stick_post() above.
952            $return['sticky'] = ( true === $sticky );
953        }
954
955        if ( ! empty( $media_results['errors'] ) ) {
956            $return['media_errors'] = $media_results['errors'];
957        }
958
959        // Generate suggestions for new posts or non-published posts
960        if ( $new || ( isset( $return['status'] ) && 'publish' !== $return['status'] ) ) {
961            $sal_site             = $this->get_sal_post_by( 'ID', $post_id, $args['context'] );
962            $title                = $input['title'] ?? '';
963            $return['other_URLs'] = (object) $sal_site->get_permalink_suggestions( $title );
964        }
965
966        /** This action is documented in json-endpoints/class.wpcom-json-api-site-settings-endpoint.php */
967        do_action( 'wpcom_json_api_objects', 'posts' );
968
969        return $return;
970    }
971
972    /**
973     * Delete a post.
974     *
975     * /sites/%s/posts/%d/delete -> $blog_id, $post_id
976     *
977     * @param string $path API path.
978     * @param array  $blog_id Blog ID.
979     * @param array  $post_id Post ID.
980     *
981     * @return array|WP_Error
982     */
983    public function delete_post( $path, $blog_id, $post_id ) {
984        $post = get_post( $post_id );
985        if ( ! $post || is_wp_error( $post ) ) {
986            return new WP_Error( 'unknown_post', 'Unknown post', 404 );
987        }
988
989        if ( ! $this->is_post_type_allowed( $post->post_type ) ) {
990            return new WP_Error( 'unknown_post_type', 'Unknown post type', 404 );
991        }
992
993        if ( ! current_user_can( 'delete_post', $post->ID ) ) {
994            return new WP_Error( 'unauthorized', 'User cannot delete posts', 403 );
995        }
996
997        $args   = $this->query_args();
998        $return = $this->get_post_by( 'ID', $post->ID, $args['context'] );
999        if ( ! $return || is_wp_error( $return ) ) {
1000            return $return;
1001        }
1002
1003        /** This action is documented in json-endpoints/class.wpcom-json-api-site-settings-endpoint.php */
1004        do_action( 'wpcom_json_api_objects', 'posts' );
1005
1006        // we need to call wp_trash_post so that untrash will work correctly for all post types.
1007        if ( 'trash' === $post->post_status ) {
1008            wp_delete_post( $post->ID );
1009        } else {
1010            wp_trash_post( $post->ID );
1011        }
1012
1013        $status = get_post_status( $post->ID );
1014        if ( false === $status ) {
1015            $return['status'] = 'deleted';
1016            return $return;
1017        }
1018
1019        return $this->get_post_by( 'ID', $post->ID, $args['context'] );
1020    }
1021
1022    /**
1023     * Restore a post.
1024     *
1025     * /sites/%s/posts/%d/restore -> $blog_id, $post_id
1026     *
1027     * @param string $path API path.
1028     * @param int    $blog_id Blog ID.
1029     * @param int    $post_id Post ID.
1030     *
1031     * @return array|WP_Error
1032     */
1033    public function restore_post( $path, $blog_id, $post_id ) {
1034        $args = $this->query_args();
1035        $post = get_post( $post_id );
1036
1037        if ( ! $post || is_wp_error( $post ) ) {
1038            return new WP_Error( 'unknown_post', 'Unknown post', 404 );
1039        }
1040
1041        if ( ! current_user_can( 'delete_post', $post->ID ) ) {
1042            return new WP_Error( 'unauthorized', 'User cannot restore trashed posts', 403 );
1043        }
1044
1045        /** This action is documented in json-endpoints/class.wpcom-json-api-site-settings-endpoint.php */
1046        do_action( 'wpcom_json_api_objects', 'posts' );
1047
1048        wp_untrash_post( $post->ID );
1049
1050        return $this->get_post_by( 'ID', $post->ID, $args['context'] );
1051    }
1052
1053    /**
1054     * Set or delete a post's featured image.
1055     *
1056     * @param int  $post_id Post ID.
1057     * @param bool $delete_featured_image Whether to delete the featured image.
1058     * @param int  $featured_image Thumbnail ID to attach.
1059     *
1060     * @return null|int|bool
1061     */
1062    protected function parse_and_set_featured_image( $post_id, $delete_featured_image, $featured_image ) {
1063        if ( $delete_featured_image ) {
1064            delete_post_thumbnail( $post_id );
1065            return;
1066        }
1067
1068        $featured_image = (string) $featured_image;
1069
1070        // if we got a post ID, we can just set it as the thumbnail.
1071        if ( ctype_digit( $featured_image ) && 'attachment' === get_post_type( $featured_image ) ) {
1072            set_post_thumbnail( $post_id, $featured_image );
1073            return $featured_image;
1074        }
1075
1076        $featured_image_id = $this->handle_media_sideload( $featured_image, $post_id, 'image' );
1077
1078        if ( empty( $featured_image_id ) || ! is_int( $featured_image_id ) ) {
1079            return false;
1080        }
1081
1082        set_post_thumbnail( $post_id, $featured_image_id );
1083        return $featured_image_id;
1084    }
1085
1086    /**
1087     * Get the Author ID for a post.
1088     *
1089     * @param int|string $author Author ID.
1090     * @param string     $post_type Post type.
1091     *
1092     * @return int|WP_Error
1093     */
1094    protected function parse_and_set_author( $author = null, $post_type = 'post' ) {
1095        if ( empty( $author ) || ! post_type_supports( $post_type, 'author' ) ) {
1096            return get_current_user_id();
1097        }
1098
1099        $author = (string) $author;
1100        if ( ctype_digit( $author ) ) {
1101            $_user = get_user_by( 'id', $author );
1102            if ( ! $_user || is_wp_error( $_user ) ) {
1103                return new WP_Error( 'invalid_author', 'Invalid author provided' );
1104            }
1105
1106            return $_user->ID;
1107        }
1108
1109        $_user = get_user_by( 'login', $author );
1110        if ( ! $_user || is_wp_error( $_user ) ) {
1111            return new WP_Error( 'invalid_author', 'Invalid author provided' );
1112        }
1113
1114        return $_user->ID;
1115    }
1116
1117    /**
1118     * Determine if a post can be untrashed.
1119     *
1120     * @param string  $last_status Last post status.
1121     * @param string  $new_status New post status.
1122     * @param WP_Post $post Post.
1123     *
1124     * @return bool
1125     */
1126    protected function should_untrash_post( $last_status, $new_status, $post ) {
1127        return 'trash' === $last_status && 'trash' !== $new_status && isset( $post->ID );
1128    }
1129
1130    /**
1131     * Untrash a post.
1132     *
1133     * @param WP_Post $post Post to untrash.
1134     * @param array   $input POST body data.
1135     */
1136    protected function untrash_post( $post, $input ) {
1137        wp_untrash_post( $post->ID );
1138        $untrashed_post = get_post( $post->ID );
1139        // Lets make sure that we use the reverted the slug.
1140        if ( isset( $input['slug'] ) && isset( $untrashed_post->post_name ) &&
1141            $untrashed_post->post_name . '__trashed' === $input['slug'] ) {
1142            unset( $input['slug'] );
1143        }
1144        return $input;
1145    }
1146
1147    /**
1148     * Determine if a theme's functions.php file should be loaded.
1149     *
1150     * @param int $post_id Post ID.
1151     *
1152     * @return bool
1153     */
1154    protected function should_load_theme_functions( $post_id = null ) {
1155        if ( empty( $post_id ) ) {
1156            $input = $this->input( true );
1157            $type  = $input['type'] ?? null;
1158        } else {
1159            $type = get_post_type( $post_id );
1160        }
1161
1162        return ! empty( $type ) && ! in_array( $type, array( 'post', 'revision' ), true );
1163    }
1164}