1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
|
<?php
new WPCOM_JSON_API_List_Posts_Endpoint( array(
'description' => 'Get a list of matching posts.',
'new_version' => '1.1',
'max_version' => '1',
'group' => 'posts',
'stat' => 'posts',
'method' => 'GET',
'path' => '/sites/%s/posts/',
'path_labels' => array(
'$site' => '(int|string) Site ID or domain',
),
'query_parameters' => array(
'number' => '(int=20) The number of posts to return. Limit: 100.',
'offset' => '(int=0) 0-indexed offset.',
'page' => '(int) Return the Nth 1-indexed page of posts. Takes precedence over the <code>offset</code> parameter.',
'order' => array(
'DESC' => 'Return posts in descending order. For dates, that means newest to oldest.',
'ASC' => 'Return posts in ascending order. For dates, that means oldest to newest.',
),
'order_by' => array(
'date' => 'Order by the created time of each post.',
'modified' => 'Order by the modified time of each post.',
'title' => "Order lexicographically by the posts' titles.",
'comment_count' => 'Order by the number of comments for each post.',
'ID' => 'Order by post ID.',
),
'after' => '(ISO 8601 datetime) Return posts dated on or after the specified datetime.',
'before' => '(ISO 8601 datetime) Return posts dated on or before the specified datetime.',
'tag' => '(string) Specify the tag name or slug.',
'category' => '(string) Specify the category name or slug.',
'term' => '(object:string) Specify comma-separated term slugs to search within, indexed by taxonomy slug.',
'type' => "(string) Specify the post type. Defaults to 'post', use 'any' to query for both posts and pages. Post types besides post and page need to be whitelisted using the <code>rest_api_allowed_post_types</code> filter.",
'parent_id' => '(int) Returns only posts which are children of the specified post. Applies only to hierarchical post types.',
'exclude' => '(array:int|int) Excludes the specified post ID(s) from the response',
'exclude_tree' => '(int) Excludes the specified post and all of its descendants from the response. Applies only to hierarchical post types.',
'status' => array(
'publish' => 'Return only published posts.',
'private' => 'Return only private posts.',
'draft' => 'Return only draft posts.',
'pending' => 'Return only posts pending editorial approval.',
'future' => 'Return only posts scheduled for future publishing.',
'trash' => 'Return only posts in the trash.',
'any' => 'Return all posts regardless of status.',
),
'sticky' => array(
'false' => 'Post is not marked as sticky.',
'true' => 'Stick the post to the front page.',
),
'author' => "(int) Author's user ID",
'search' => '(string) Search query',
'meta_key' => '(string) Metadata key that the post should contain',
'meta_value' => '(string) Metadata value that the post should contain. Will only be applied if a `meta_key` is also given',
),
'example_request' => 'https://public-api.wordpress.com/rest/v1/sites/en.blog.wordpress.com/posts/?number=5'
) );
class WPCOM_JSON_API_List_Posts_Endpoint extends WPCOM_JSON_API_Post_Endpoint {
public $date_range = array();
public $response_format = array(
'found' => '(int) The total number of posts found that match the request (ignoring limits, offsets, and pagination).',
'posts' => '(array:post) An array of post objects.',
);
// /sites/%s/posts/ -> $blog_id
function callback( $path = '', $blog_id = 0 ) {
$blog_id = $this->api->switch_to_blog_and_validate_user( $this->api->get_blog_id( $blog_id ) );
if ( is_wp_error( $blog_id ) ) {
return $blog_id;
}
$args = $this->query_args();
if ( $args['number'] < 1 ) {
$args['number'] = 20;
} elseif ( 100 < $args['number'] ) {
return new WP_Error( 'invalid_number', 'The NUMBER parameter must be less than or equal to 100.', 400 );
}
if ( isset( $args['type'] ) && ! $this->is_post_type_allowed( $args['type'] ) ) {
return new WP_Error( 'unknown_post_type', 'Unknown post type', 404 );
}
// Normalize post_type
if ( isset( $args['type'] ) && 'any' == $args['type'] ) {
if ( version_compare( $this->api->version, '1.1', '<' ) ) {
$args['type'] = array( 'post', 'page' );
} else { // 1.1+
$args['type'] = $this->_get_whitelisted_post_types();
}
}
// determine statuses
$status = $args['status'];
$status = ( $status ) ? explode( ',', $status ) : array( 'publish' );
if ( is_user_logged_in() ) {
$statuses_whitelist = array(
'publish',
'pending',
'draft',
'future',
'private',
'trash',
'any',
);
$status = array_intersect( $status, $statuses_whitelist );
} else {
// logged-out users can see only published posts
$statuses_whitelist = array( 'publish', 'any' );
$status = array_intersect( $status, $statuses_whitelist );
if ( empty( $status ) ) {
// requested only protected statuses? nothing for you here
return array( 'found' => 0, 'posts' => array() );
}
// clear it (AKA published only) because "any" includes protected
$status = array();
}
// let's be explicit about defaulting to 'post'
$args['type'] = isset( $args['type'] ) ? $args['type'] : 'post';
// make sure the user can read or edit the requested post type(s)
if ( is_array( $args['type'] ) ) {
$allowed_types = array();
foreach ( $args['type'] as $post_type ) {
if ( $this->current_user_can_access_post_type( $post_type, $args['context'] ) ) {
$allowed_types[] = $post_type;
}
}
if ( empty( $allowed_types ) ) {
return array( 'found' => 0, 'posts' => array() );
}
$args['type'] = $allowed_types;
}
else {
if ( ! $this->current_user_can_access_post_type( $args['type'], $args['context'] ) ) {
return array( 'found' => 0, 'posts' => array() );
}
}
$query = array(
'posts_per_page' => $args['number'],
'order' => $args['order'],
'orderby' => $args['order_by'],
'post_type' => $args['type'],
'post_status' => $status,
'post_parent' => isset( $args['parent_id'] ) ? $args['parent_id'] : null,
'author' => isset( $args['author'] ) && 0 < $args['author'] ? $args['author'] : null,
's' => isset( $args['search'] ) && '' !== $args['search'] ? $args['search'] : null,
'fields' => 'ids',
);
if ( ! is_user_logged_in () ) {
$query['has_password'] = false;
}
if ( isset( $args['meta_key'] ) ) {
$show = false;
if ( WPCOM_JSON_API_Metadata::is_public( $args['meta_key'] ) )
$show = true;
if ( current_user_can( 'edit_post_meta', $query['post_type'], $args['meta_key'] ) )
$show = true;
if ( is_protected_meta( $args['meta_key'], 'post' ) && ! $show )
return new WP_Error( 'invalid_meta_key', 'Invalid meta key', 404 );
$meta = array( 'key' => $args['meta_key'] );
if ( isset( $args['meta_value'] ) )
$meta['value'] = $args['meta_value'];
$query['meta_query'] = array( $meta );
}
if (
isset( $args['sticky'] )
&&
( $sticky = get_option( 'sticky_posts' ) )
&&
is_array( $sticky )
) {
if ( $args['sticky'] ) {
$query['post__in'] = $sticky;
} else {
$query['post__not_in'] = $sticky;
$query['ignore_sticky_posts'] = 1;
}
} else {
$query['post__not_in'] = $sticky;
$query['ignore_sticky_posts'] = 1;
}
if ( isset( $args['exclude'] ) ) {
$query['post__not_in'] = array_merge( $query['post__not_in'], (array) $args['exclude'] );
}
if ( isset( $args['exclude_tree'] ) && is_post_type_hierarchical( $args['type'] ) ) {
// get_page_children is a misnomer; it supports all hierarchical post types
$page_args = array(
'child_of' => $args['exclude_tree'],
'post_type' => $args['type'],
// since we're looking for things to exclude, be aggressive
'post_status' => 'publish,draft,pending,private,future,trash',
);
$post_descendants = get_pages( $page_args );
$exclude_tree = array( $args['exclude_tree'] );
foreach ( $post_descendants as $child ) {
$exclude_tree[] = $child->ID;
}
$query['post__not_in'] = isset( $query['post__not_in'] ) ? array_merge( $query['post__not_in'], $exclude_tree ) : $exclude_tree;
}
if ( isset( $args['category'] ) ) {
$category = get_term_by( 'slug', $args['category'], 'category' );
if ( $category === false) {
$query['category_name'] = $args['category'];
} else {
$query['cat'] = $category->term_id;
}
}
if ( isset( $args['tag'] ) ) {
$query['tag'] = $args['tag'];
}
if ( ! empty( $args['term'] ) ) {
$query['tax_query'] = array();
foreach ( $args['term'] as $taxonomy => $slug ) {
$taxonomy_object = get_taxonomy( $taxonomy );
if ( false === $taxonomy_object || ( ! $taxonomy_object->public &&
! current_user_can( $taxonomy_object->cap->assign_terms ) ) ) {
continue;
}
$query['tax_query'][] = array(
'taxonomy' => $taxonomy,
'field' => 'slug',
'terms' => explode( ',', $slug )
);
}
}
if ( isset( $args['page'] ) ) {
if ( $args['page'] < 1 ) {
$args['page'] = 1;
}
$query['paged'] = $args['page'];
} else {
if ( $args['offset'] < 0 ) {
$args['offset'] = 0;
}
$query['offset'] = $args['offset'];
}
if ( isset( $args['before'] ) ) {
$this->date_range['before'] = $args['before'];
}
if ( isset( $args['after'] ) ) {
$this->date_range['after'] = $args['after'];
}
if ( $this->date_range ) {
add_filter( 'posts_where', array( $this, 'handle_date_range' ) );
}
/**
* 'column' necessary for the me/posts endpoint (which extends sites/$site/posts).
* Would need to be added to the sites/$site/posts definition if we ever want to
* use it there.
*/
$column_whitelist = array( 'post_modified_gmt' );
if ( isset( $args['column'] ) && in_array( $args['column'], $column_whitelist ) ) {
$query['column'] = $args['column'];
}
$wp_query = new WP_Query( $query );
if ( $this->date_range ) {
remove_filter( 'posts_where', array( $this, 'handle_date_range' ) );
$this->date_range = array();
}
$return = array();
$excluded_count = 0;
foreach ( array_keys( $this->response_format ) as $key ) {
switch ( $key ) {
case 'found' :
$return[$key] = (int) $wp_query->found_posts;
break;
case 'posts' :
$posts = array();
foreach ( $wp_query->posts as $post_ID ) {
$the_post = $this->get_post_by( 'ID', $post_ID, $args['context'] );
if ( $the_post && ! is_wp_error( $the_post ) ) {
$posts[] = $the_post;
} else {
$excluded_count++;
}
}
if ( $posts ) {
/** This action is documented in json-endpoints/class.wpcom-json-api-site-settings-endpoint.php */
do_action( 'wpcom_json_api_objects', 'posts', count( $posts ) );
}
$return[$key] = $posts;
break;
}
}
$return['found'] -= $excluded_count;
return $return;
}
function handle_date_range( $where ) {
global $wpdb;
switch ( count( $this->date_range ) ) {
case 2 :
$where .= $wpdb->prepare(
" AND `$wpdb->posts`.post_date BETWEEN CAST( %s AS DATETIME ) AND CAST( %s AS DATETIME ) ",
$this->date_range['after'],
$this->date_range['before']
);
break;
case 1 :
if ( isset( $this->date_range['before'] ) ) {
$where .= $wpdb->prepare(
" AND `$wpdb->posts`.post_date <= CAST( %s AS DATETIME ) ",
$this->date_range['before']
);
} else {
$where .= $wpdb->prepare(
" AND `$wpdb->posts`.post_date >= CAST( %s AS DATETIME ) ",
$this->date_range['after']
);
}
break;
}
return $where;
}
}
|