]> scripts.mit.edu Git - autoinstalls/wordpress.git/blob - wp-admin/includes/post.php
Wordpress 3.1.4-scripts
[autoinstalls/wordpress.git] / wp-admin / includes / post.php
1 <?php
2 /**
3  * WordPress Post Administration API.
4  *
5  * @package WordPress
6  * @subpackage Administration
7  */
8
9 /**
10  * Rename $_POST data from form names to DB post columns.
11  *
12  * Manipulates $_POST directly.
13  *
14  * @package WordPress
15  * @since 2.6.0
16  *
17  * @param bool $update Are we updating a pre-existing post?
18  * @param array $post_data Array of post data. Defaults to the contents of $_POST.
19  * @return object|bool WP_Error on failure, true on success.
20  */
21 function _wp_translate_postdata( $update = false, $post_data = null ) {
22
23         if ( empty($post_data) )
24                 $post_data = &$_POST;
25
26         if ( $update )
27                 $post_data['ID'] = (int) $post_data['post_ID'];
28         $post_data['post_content'] = isset($post_data['content']) ? $post_data['content'] : '';
29         $post_data['post_excerpt'] = isset($post_data['excerpt']) ? $post_data['excerpt'] : '';
30         $post_data['post_parent'] = isset($post_data['parent_id'])? $post_data['parent_id'] : '';
31         if ( isset($post_data['trackback_url']) )
32                 $post_data['to_ping'] = $post_data['trackback_url'];
33
34         if ( !isset($post_data['user_ID']) )
35                 $post_data['user_ID'] = $GLOBALS['user_ID'];
36
37         if (!empty ( $post_data['post_author_override'] ) ) {
38                 $post_data['post_author'] = (int) $post_data['post_author_override'];
39         } else {
40                 if (!empty ( $post_data['post_author'] ) ) {
41                         $post_data['post_author'] = (int) $post_data['post_author'];
42                 } else {
43                         $post_data['post_author'] = (int) $post_data['user_ID'];
44                 }
45         }
46
47         $ptype = get_post_type_object( $post_data['post_type'] );
48         if ( isset($post_data['user_ID']) && ($post_data['post_author'] != $post_data['user_ID']) ) {
49                 if ( !current_user_can( $ptype->cap->edit_others_posts ) ) {
50                         if ( 'page' == $post_data['post_type'] ) {
51                                 return new WP_Error( 'edit_others_pages', $update ?
52                                         __( 'You are not allowed to edit pages as this user.' ) :
53                                         __( 'You are not allowed to create pages as this user.' )
54                                 );
55                         } else {
56                                 return new WP_Error( 'edit_others_posts', $update ?
57                                         __( 'You are not allowed to edit posts as this user.' ) :
58                                         __( 'You are not allowed to post as this user.' )
59                                 );
60                         }
61                 }
62         }
63
64         // What to do based on which button they pressed
65         if ( isset($post_data['saveasdraft']) && '' != $post_data['saveasdraft'] )
66                 $post_data['post_status'] = 'draft';
67         if ( isset($post_data['saveasprivate']) && '' != $post_data['saveasprivate'] )
68                 $post_data['post_status'] = 'private';
69         if ( isset($post_data['publish']) && ( '' != $post_data['publish'] ) && ( !isset($post_data['post_status']) || $post_data['post_status'] != 'private' ) )
70                 $post_data['post_status'] = 'publish';
71         if ( isset($post_data['advanced']) && '' != $post_data['advanced'] )
72                 $post_data['post_status'] = 'draft';
73         if ( isset($post_data['pending']) && '' != $post_data['pending'] )
74                 $post_data['post_status'] = 'pending';
75
76         if ( isset( $post_data['ID'] ) )
77                 $post_id = $post_data['ID'];
78         else
79                 $post_id = false;
80         $previous_status = $post_id ? get_post_field( 'post_status', $post_id ) : false;
81
82         // Posts 'submitted for approval' present are submitted to $_POST the same as if they were being published.
83         // Change status from 'publish' to 'pending' if user lacks permissions to publish or to resave published posts.
84         if ( isset($post_data['post_status']) && ('publish' == $post_data['post_status'] && !current_user_can( $ptype->cap->publish_posts )) )
85                 if ( $previous_status != 'publish' || !current_user_can( 'edit_post', $post_id ) )
86                         $post_data['post_status'] = 'pending';
87
88         if ( ! isset($post_data['post_status']) )
89                 $post_data['post_status'] = $previous_status;
90
91         if (!isset( $post_data['comment_status'] ))
92                 $post_data['comment_status'] = 'closed';
93
94         if (!isset( $post_data['ping_status'] ))
95                 $post_data['ping_status'] = 'closed';
96
97         foreach ( array('aa', 'mm', 'jj', 'hh', 'mn') as $timeunit ) {
98                 if ( !empty( $post_data['hidden_' . $timeunit] ) && $post_data['hidden_' . $timeunit] != $post_data[$timeunit] ) {
99                         $post_data['edit_date'] = '1';
100                         break;
101                 }
102         }
103
104         if ( !empty( $post_data['edit_date'] ) ) {
105                 $aa = $post_data['aa'];
106                 $mm = $post_data['mm'];
107                 $jj = $post_data['jj'];
108                 $hh = $post_data['hh'];
109                 $mn = $post_data['mn'];
110                 $ss = $post_data['ss'];
111                 $aa = ($aa <= 0 ) ? date('Y') : $aa;
112                 $mm = ($mm <= 0 ) ? date('n') : $mm;
113                 $jj = ($jj > 31 ) ? 31 : $jj;
114                 $jj = ($jj <= 0 ) ? date('j') : $jj;
115                 $hh = ($hh > 23 ) ? $hh -24 : $hh;
116                 $mn = ($mn > 59 ) ? $mn -60 : $mn;
117                 $ss = ($ss > 59 ) ? $ss -60 : $ss;
118                 $post_data['post_date'] = sprintf( "%04d-%02d-%02d %02d:%02d:%02d", $aa, $mm, $jj, $hh, $mn, $ss );
119                 $post_data['post_date_gmt'] = get_gmt_from_date( $post_data['post_date'] );
120         }
121
122         return $post_data;
123 }
124
125 /**
126  * Update an existing post with values provided in $_POST.
127  *
128  * @since 1.5.0
129  *
130  * @param array $post_data Optional.
131  * @return int Post ID.
132  */
133 function edit_post( $post_data = null ) {
134
135         if ( empty($post_data) )
136                 $post_data = &$_POST;
137
138         // Clear out any data in internal vars.
139         unset( $post_data['filter'] );
140
141         $post_ID = (int) $post_data['post_ID'];
142         $post = get_post( $post_ID );
143         $post_data['post_type'] = $post->post_type;
144         $post_data['post_mime_type'] = $post->post_mime_type;
145
146         $ptype = get_post_type_object($post_data['post_type']);
147         if ( !current_user_can( $ptype->cap->edit_post, $post_ID ) ) {
148                 if ( 'page' == $post_data['post_type'] )
149                         wp_die( __('You are not allowed to edit this page.' ));
150                 else
151                         wp_die( __('You are not allowed to edit this post.' ));
152         }
153
154         // Autosave shouldn't save too soon after a real save
155         if ( 'autosave' == $post_data['action'] ) {
156                 $post =& get_post( $post_ID );
157                 $now = time();
158                 $then = strtotime($post->post_date_gmt . ' +0000');
159                 $delta = AUTOSAVE_INTERVAL / 2;
160                 if ( ($now - $then) < $delta )
161                         return $post_ID;
162         }
163
164         $post_data = _wp_translate_postdata( true, $post_data );
165         if ( is_wp_error($post_data) )
166                 wp_die( $post_data->get_error_message() );
167         if ( 'autosave' != $post_data['action']  && 'auto-draft' == $post_data['post_status'] )
168                 $post_data['post_status'] = 'draft';
169
170         if ( isset($post_data['visibility']) ) {
171                 switch ( $post_data['visibility'] ) {
172                         case 'public' :
173                                 $post_data['post_password'] = '';
174                                 break;
175                         case 'password' :
176                                 unset( $post_data['sticky'] );
177                                 break;
178                         case 'private' :
179                                 $post_data['post_status'] = 'private';
180                                 $post_data['post_password'] = '';
181                                 unset( $post_data['sticky'] );
182                                 break;
183                 }
184         }
185
186         // Post Formats
187         if ( current_theme_supports( 'post-formats' ) && isset( $post_data['post_format'] ) ) {
188                 $formats = get_theme_support( 'post-formats' );
189                 if ( is_array( $formats ) ) {
190                         $formats = $formats[0];
191                         if ( in_array( $post_data['post_format'], $formats ) ) {
192                                 set_post_format( $post_ID, $post_data['post_format'] );
193                         } elseif ( '0' == $post_data['post_format'] ) {
194                                 set_post_format( $post_ID, false );
195                         }
196                 }
197         }
198
199         // Meta Stuff
200         if ( isset($post_data['meta']) && $post_data['meta'] ) {
201                 foreach ( $post_data['meta'] as $key => $value ) {
202                         if ( !$meta = get_post_meta_by_id( $key ) )
203                                 continue;
204                         if ( $meta->post_id != $post_ID )
205                                 continue;
206                         if ( is_protected_meta( $value['key'] ) )
207                                 continue;
208                         update_meta( $key, $value['key'], $value['value'] );
209                 }
210         }
211
212         if ( isset($post_data['deletemeta']) && $post_data['deletemeta'] ) {
213                 foreach ( $post_data['deletemeta'] as $key => $value ) {
214                         if ( !$meta = get_post_meta_by_id( $key ) )
215                                 continue;
216                         if ( $meta->post_id != $post_ID )
217                                 continue;
218                         if ( is_protected_meta( $meta->meta_key ) )
219                                 continue;
220                         delete_meta( $key );
221                 }
222         }
223
224         add_meta( $post_ID );
225
226         update_post_meta( $post_ID, '_edit_last', $GLOBALS['current_user']->ID );
227
228         wp_update_post( $post_data );
229
230         // Reunite any orphaned attachments with their parent
231         if ( !$draft_ids = get_user_option( 'autosave_draft_ids' ) )
232                 $draft_ids = array();
233         if ( $draft_temp_id = (int) array_search( $post_ID, $draft_ids ) )
234                 _relocate_children( $draft_temp_id, $post_ID );
235
236         // Now that we have an ID we can fix any attachment anchor hrefs
237         _fix_attachment_links( $post_ID );
238
239         wp_set_post_lock( $post_ID, $GLOBALS['current_user']->ID );
240
241         if ( current_user_can( $ptype->cap->edit_others_posts ) ) {
242                 if ( ! empty( $post_data['sticky'] ) )
243                         stick_post( $post_ID );
244                 else
245                         unstick_post( $post_ID );
246         }
247
248         return $post_ID;
249 }
250
251 /**
252  * Process the post data for the bulk editing of posts.
253  *
254  * Updates all bulk edited posts/pages, adding (but not removing) tags and
255  * categories. Skips pages when they would be their own parent or child.
256  *
257  * @since 2.7.0
258  *
259  * @param array $post_data Optional, the array of post data to process if not provided will use $_POST superglobal.
260  * @return array
261  */
262 function bulk_edit_posts( $post_data = null ) {
263         global $wpdb;
264
265         if ( empty($post_data) )
266                 $post_data = &$_POST;
267
268         if ( isset($post_data['post_type']) )
269                 $ptype = get_post_type_object($post_data['post_type']);
270         else
271                 $ptype = get_post_type_object('post');
272
273         if ( !current_user_can( $ptype->cap->edit_posts ) ) {
274                 if ( 'page' == $ptype->name )
275                         wp_die( __('You are not allowed to edit pages.'));
276                 else
277                         wp_die( __('You are not allowed to edit posts.'));
278         }
279
280         if ( -1 == $post_data['_status'] ) {
281                 $post_data['post_status'] = null;
282                 unset($post_data['post_status']);
283         } else {
284                 $post_data['post_status'] = $post_data['_status'];
285         }
286         unset($post_data['_status']);
287
288         $post_IDs = array_map( 'intval', (array) $post_data['post'] );
289
290         $reset = array( 'post_author', 'post_status', 'post_password', 'post_parent', 'page_template', 'comment_status', 'ping_status', 'keep_private', 'tax_input', 'post_category', 'sticky' );
291         foreach ( $reset as $field ) {
292                 if ( isset($post_data[$field]) && ( '' == $post_data[$field] || -1 == $post_data[$field] ) )
293                         unset($post_data[$field]);
294         }
295
296         if ( isset($post_data['post_category']) ) {
297                 if ( is_array($post_data['post_category']) && ! empty($post_data['post_category']) )
298                         $new_cats = array_map( 'absint', $post_data['post_category'] );
299                 else
300                         unset($post_data['post_category']);
301         }
302
303         $tax_input = array();
304         if ( isset($post_data['tax_input'])) {
305                 foreach ( $post_data['tax_input'] as $tax_name => $terms ) {
306                         if ( empty($terms) )
307                                 continue;
308                         if ( is_taxonomy_hierarchical( $tax_name ) )
309                                 $tax_input[$tax_name] = array_map( 'absint', $terms );
310                         else {
311                                 $tax_input[$tax_name] = preg_replace( '/\s*,\s*/', ',', rtrim( trim($terms), ' ,' ) );
312                                 $tax_input[$tax_name] = explode(',', $tax_input[$tax_name]);
313                         }
314                 }
315         }
316
317         if ( isset($post_data['post_parent']) && ($parent = (int) $post_data['post_parent']) ) {
318                 $pages = $wpdb->get_results("SELECT ID, post_parent FROM $wpdb->posts WHERE post_type = 'page'");
319                 $children = array();
320
321                 for ( $i = 0; $i < 50 && $parent > 0; $i++ ) {
322                         $children[] = $parent;
323
324                         foreach ( $pages as $page ) {
325                                 if ( $page->ID == $parent ) {
326                                         $parent = $page->post_parent;
327                                         break;
328                                 }
329                         }
330                 }
331         }
332
333         $updated = $skipped = $locked = array();
334         foreach ( $post_IDs as $post_ID ) {
335                 $post_type_object = get_post_type_object( get_post_type( $post_ID ) );
336
337                 if ( !isset( $post_type_object ) || ( isset($children) && in_array($post_ID, $children) ) || !current_user_can( $post_type_object->cap->edit_post, $post_ID ) ) {
338                         $skipped[] = $post_ID;
339                         continue;
340                 }
341
342                 if ( wp_check_post_lock( $post_ID ) ) {
343                         $locked[] = $post_ID;
344                         continue;
345                 }
346
347                 $post = get_post( $post_ID );
348                 $tax_names = get_object_taxonomies( $post );
349                 foreach ( $tax_names as $tax_name ) {
350                         $taxonomy_obj = get_taxonomy($tax_name);
351                         if (  isset( $tax_input[$tax_name]) && current_user_can( $taxonomy_obj->cap->assign_terms ) )
352                                 $new_terms = $tax_input[$tax_name];
353                         else
354                                 $new_terms = array();
355
356                         if ( $taxonomy_obj->hierarchical )
357                                 $current_terms = (array) wp_get_object_terms( $post_ID, $tax_name, array('fields' => 'ids') );
358                         else
359                                 $current_terms = (array) wp_get_object_terms( $post_ID, $tax_name, array('fields' => 'names') );
360
361                         $post_data['tax_input'][$tax_name] = array_merge( $current_terms, $new_terms );
362                 }
363
364                 if ( isset($new_cats) && in_array( 'category', $tax_names ) ) {
365                         $cats = (array) wp_get_post_categories($post_ID);
366                         $post_data['post_category'] = array_unique( array_merge($cats, $new_cats) );
367                         unset( $post_data['tax_input']['category'] );
368                 }
369
370                 $post_data['post_mime_type'] = $post->post_mime_type;
371                 $post_data['guid'] = $post->guid;
372
373                 $post_data['ID'] = $post_ID;
374                 $updated[] = wp_update_post( $post_data );
375
376                 if ( isset( $post_data['sticky'] ) && current_user_can( $ptype->cap->edit_others_posts ) ) {
377                         if ( 'sticky' == $post_data['sticky'] )
378                                 stick_post( $post_ID );
379                         else
380                                 unstick_post( $post_ID );
381                 }
382
383         }
384
385         return array( 'updated' => $updated, 'skipped' => $skipped, 'locked' => $locked );
386 }
387
388 /**
389  * Default post information to use when populating the "Write Post" form.
390  *
391  * @since 2.0.0
392  *
393  * @param string $post_type A post type string, defaults to 'post'.
394  * @return object stdClass object containing all the default post data as attributes
395  */
396 function get_default_post_to_edit( $post_type = 'post', $create_in_db = false ) {
397         global $wpdb;
398
399         $post_title = '';
400         if ( !empty( $_REQUEST['post_title'] ) )
401                 $post_title = esc_html( stripslashes( $_REQUEST['post_title'] ));
402
403         $post_content = '';
404         if ( !empty( $_REQUEST['content'] ) )
405                 $post_content = esc_html( stripslashes( $_REQUEST['content'] ));
406
407         $post_excerpt = '';
408         if ( !empty( $_REQUEST['excerpt'] ) )
409                 $post_excerpt = esc_html( stripslashes( $_REQUEST['excerpt'] ));
410
411         if ( $create_in_db ) {
412                 // Cleanup old auto-drafts more than 7 days old
413                 $old_posts = $wpdb->get_col( "SELECT ID FROM $wpdb->posts WHERE post_status = 'auto-draft' AND DATE_SUB( NOW(), INTERVAL 7 DAY ) > post_date" );
414                 foreach ( (array) $old_posts as $delete )
415                         wp_delete_post( $delete, true ); // Force delete
416                 $post_id = wp_insert_post( array( 'post_title' => __( 'Auto Draft' ), 'post_type' => $post_type, 'post_status' => 'auto-draft' ) );
417                 $post = get_post( $post_id );
418                 if ( current_theme_supports( 'post-formats' ) && post_type_supports( $post->post_type, 'post-formats' ) && get_option( 'default_post_format' ) )
419                         set_post_format( $post, get_option( 'default_post_format' ) );
420         } else {
421                 $post->ID = 0;
422                 $post->post_author = '';
423                 $post->post_date = '';
424                 $post->post_date_gmt = '';
425                 $post->post_password = '';
426                 $post->post_type = $post_type;
427                 $post->post_status = 'draft';
428                 $post->to_ping = '';
429                 $post->pinged = '';
430                 $post->comment_status = get_option( 'default_comment_status' );
431                 $post->ping_status = get_option( 'default_ping_status' );
432                 $post->post_pingback = get_option( 'default_pingback_flag' );
433                 $post->post_category = get_option( 'default_category' );
434                 $post->page_template = 'default';
435                 $post->post_parent = 0;
436                 $post->menu_order = 0;
437         }
438
439         $post->post_content = apply_filters( 'default_content', $post_content, $post );
440         $post->post_title   = apply_filters( 'default_title',   $post_title, $post   );
441         $post->post_excerpt = apply_filters( 'default_excerpt', $post_excerpt, $post );
442         $post->post_name = '';
443
444         return $post;
445 }
446
447 /**
448  * Get the default page information to use.
449  *
450  * @since 2.5.0
451  *
452  * @return object stdClass object containing all the default post data as attributes
453  */
454 function get_default_page_to_edit() {
455         $page = get_default_post_to_edit();
456         $page->post_type = 'page';
457         return $page;
458 }
459
460 /**
461  * Get an existing post and format it for editing.
462  *
463  * @since 2.0.0
464  *
465  * @param unknown_type $id
466  * @return unknown
467  */
468 function get_post_to_edit( $id ) {
469
470         $post = get_post( $id, OBJECT, 'edit' );
471
472         if ( $post->post_type == 'page' )
473                 $post->page_template = get_post_meta( $id, '_wp_page_template', true );
474
475         return $post;
476 }
477
478 /**
479  * Determine if a post exists based on title, content, and date
480  *
481  * @since 2.0.0
482  *
483  * @param string $title Post title
484  * @param string $content Optional post content
485  * @param string $date Optional post date
486  * @return int Post ID if post exists, 0 otherwise.
487  */
488 function post_exists($title, $content = '', $date = '') {
489         global $wpdb;
490
491         $post_title = stripslashes( sanitize_post_field( 'post_title', $title, 0, 'db' ) );
492         $post_content = stripslashes( sanitize_post_field( 'post_content', $content, 0, 'db' ) );
493         $post_date = stripslashes( sanitize_post_field( 'post_date', $date, 0, 'db' ) );
494
495         $query = "SELECT ID FROM $wpdb->posts WHERE 1=1";
496         $args = array();
497
498         if ( !empty ( $date ) ) {
499                 $query .= ' AND post_date = %s';
500                 $args[] = $post_date;
501         }
502
503         if ( !empty ( $title ) ) {
504                 $query .= ' AND post_title = %s';
505                 $args[] = $post_title;
506         }
507
508         if ( !empty ( $content ) ) {
509                 $query .= 'AND post_content = %s';
510                 $args[] = $post_content;
511         }
512
513         if ( !empty ( $args ) )
514                 return $wpdb->get_var( $wpdb->prepare($query, $args) );
515
516         return 0;
517 }
518
519 /**
520  * Creates a new post from the "Write Post" form using $_POST information.
521  *
522  * @since 2.1.0
523  *
524  * @return unknown
525  */
526 function wp_write_post() {
527         global $user_ID;
528
529
530         if ( isset($_POST['post_type']) )
531                 $ptype = get_post_type_object($_POST['post_type']);
532         else
533                 $ptype = get_post_type_object('post');
534
535         if ( !current_user_can( $ptype->cap->edit_posts ) ) {
536                 if ( 'page' == $ptype->name )
537                         return new WP_Error( 'edit_pages', __( 'You are not allowed to create pages on this site.' ) );
538                 else
539                         return new WP_Error( 'edit_posts', __( 'You are not allowed to create posts or drafts on this site.' ) );
540         }
541
542         $_POST['post_mime_type'] = '';
543
544         // Clear out any data in internal vars.
545         unset( $_POST['filter'] );
546
547         // Check for autosave collisions
548         // Does this need to be updated? ~ Mark
549         $temp_id = false;
550         if ( isset($_POST['temp_ID']) ) {
551                 $temp_id = (int) $_POST['temp_ID'];
552                 if ( !$draft_ids = get_user_option( 'autosave_draft_ids' ) )
553                         $draft_ids = array();
554                 foreach ( $draft_ids as $temp => $real )
555                         if ( time() + $temp > 86400 ) // 1 day: $temp is equal to -1 * time( then )
556                                 unset($draft_ids[$temp]);
557
558                 if ( isset($draft_ids[$temp_id]) ) { // Edit, don't write
559                         $_POST['post_ID'] = $draft_ids[$temp_id];
560                         unset($_POST['temp_ID']);
561                         update_user_option( $user_ID, 'autosave_draft_ids', $draft_ids );
562                         return edit_post();
563                 }
564         }
565
566         // Edit don't write if we have a post id.
567         if ( isset( $_POST['ID'] ) ) {
568                 $_POST['post_ID'] = $_POST['ID'];
569                 unset ( $_POST['ID'] );
570         }
571         if ( isset( $_POST['post_ID'] ) ) {
572                 return edit_post();
573         }
574
575         $translated = _wp_translate_postdata( false );
576         if ( is_wp_error($translated) )
577                 return $translated;
578
579         if ( isset($_POST['visibility']) ) {
580                 switch ( $_POST['visibility'] ) {
581                         case 'public' :
582                                 $_POST['post_password'] = '';
583                                 break;
584                         case 'password' :
585                                 unset( $_POST['sticky'] );
586                                 break;
587                         case 'private' :
588                                 $_POST['post_status'] = 'private';
589                                 $_POST['post_password'] = '';
590                                 unset( $_POST['sticky'] );
591                                 break;
592                 }
593         }
594
595         // Create the post.
596         $post_ID = wp_insert_post( $_POST );
597         if ( is_wp_error( $post_ID ) )
598                 return $post_ID;
599
600         if ( empty($post_ID) )
601                 return 0;
602
603         add_meta( $post_ID );
604
605         add_post_meta( $post_ID, '_edit_last', $GLOBALS['current_user']->ID );
606
607         // Reunite any orphaned attachments with their parent
608         // Does this need to be udpated? ~ Mark
609         if ( !$draft_ids = get_user_option( 'autosave_draft_ids' ) )
610                 $draft_ids = array();
611         if ( $draft_temp_id = (int) array_search( $post_ID, $draft_ids ) )
612                 _relocate_children( $draft_temp_id, $post_ID );
613         if ( $temp_id && $temp_id != $draft_temp_id )
614                 _relocate_children( $temp_id, $post_ID );
615
616         // Update autosave collision detection
617         if ( $temp_id ) {
618                 $draft_ids[$temp_id] = $post_ID;
619                 update_user_option( $user_ID, 'autosave_draft_ids', $draft_ids );
620         }
621
622         // Now that we have an ID we can fix any attachment anchor hrefs
623         _fix_attachment_links( $post_ID );
624
625         wp_set_post_lock( $post_ID, $GLOBALS['current_user']->ID );
626
627         return $post_ID;
628 }
629
630 /**
631  * Calls wp_write_post() and handles the errors.
632  *
633  * @since 2.0.0
634  *
635  * @return unknown
636  */
637 function write_post() {
638         $result = wp_write_post();
639         if ( is_wp_error( $result ) )
640                 wp_die( $result->get_error_message() );
641         else
642                 return $result;
643 }
644
645 //
646 // Post Meta
647 //
648
649 /**
650  * {@internal Missing Short Description}}
651  *
652  * @since 1.2.0
653  *
654  * @param unknown_type $post_ID
655  * @return unknown
656  */
657 function add_meta( $post_ID ) {
658         global $wpdb;
659         $post_ID = (int) $post_ID;
660
661         $metakeyselect = isset($_POST['metakeyselect']) ? stripslashes( trim( $_POST['metakeyselect'] ) ) : '';
662         $metakeyinput = isset($_POST['metakeyinput']) ? stripslashes( trim( $_POST['metakeyinput'] ) ) : '';
663         $metavalue = isset($_POST['metavalue']) ? maybe_serialize( stripslashes_deep( $_POST['metavalue'] ) ) : '';
664         if ( is_string($metavalue) )
665                 $metavalue = trim( $metavalue );
666
667         if ( ('0' === $metavalue || !empty ( $metavalue ) ) && ((('#NONE#' != $metakeyselect) && !empty ( $metakeyselect) ) || !empty ( $metakeyinput) ) ) {
668                 // We have a key/value pair. If both the select and the
669                 // input for the key have data, the input takes precedence:
670
671                 if ('#NONE#' != $metakeyselect)
672                         $metakey = $metakeyselect;
673
674                 if ( $metakeyinput)
675                         $metakey = $metakeyinput; // default
676
677                 if ( is_protected_meta( $metakey ) )
678                         return false;
679
680                 wp_cache_delete($post_ID, 'post_meta');
681                 $wpdb->insert( $wpdb->postmeta, array( 'post_id' => $post_ID, 'meta_key' => $metakey, 'meta_value' => $metavalue ) );
682                 $meta_id = $wpdb->insert_id;
683                 do_action( 'added_postmeta', $meta_id, $post_ID, $metakey, $metavalue );
684
685                 return $meta_id;
686         }
687         return false;
688 } // add_meta
689
690 /**
691  * {@internal Missing Short Description}}
692  *
693  * @since 1.2.0
694  *
695  * @param unknown_type $mid
696  * @return unknown
697  */
698 function delete_meta( $mid ) {
699         global $wpdb;
700         $mid = (int) $mid;
701
702         $post_id = $wpdb->get_var( $wpdb->prepare("SELECT post_id FROM $wpdb->postmeta WHERE meta_id = %d", $mid) );
703
704         do_action( 'delete_postmeta', $mid );
705         wp_cache_delete($post_id, 'post_meta');
706         $rval = $wpdb->query( $wpdb->prepare("DELETE FROM $wpdb->postmeta WHERE meta_id = %d", $mid) );
707         do_action( 'deleted_postmeta', $mid );
708
709         return $rval;
710 }
711
712 /**
713  * Get a list of previously defined keys.
714  *
715  * @since 1.2.0
716  *
717  * @return unknown
718  */
719 function get_meta_keys() {
720         global $wpdb;
721
722         $keys = $wpdb->get_col( "
723                         SELECT meta_key
724                         FROM $wpdb->postmeta
725                         GROUP BY meta_key
726                         ORDER BY meta_key" );
727
728         return $keys;
729 }
730
731 /**
732  * {@internal Missing Short Description}}
733  *
734  * @since 2.1.0
735  *
736  * @param unknown_type $mid
737  * @return unknown
738  */
739 function get_post_meta_by_id( $mid ) {
740         global $wpdb;
741         $mid = (int) $mid;
742
743         $meta = $wpdb->get_row( $wpdb->prepare("SELECT * FROM $wpdb->postmeta WHERE meta_id = %d", $mid) );
744         if ( empty($meta) )
745                 return false;
746         if ( is_serialized_string( $meta->meta_value ) )
747                 $meta->meta_value = maybe_unserialize( $meta->meta_value );
748         return $meta;
749 }
750
751 /**
752  * {@internal Missing Short Description}}
753  *
754  * Some postmeta stuff.
755  *
756  * @since 1.2.0
757  *
758  * @param unknown_type $postid
759  * @return unknown
760  */
761 function has_meta( $postid ) {
762         global $wpdb;
763
764         return $wpdb->get_results( $wpdb->prepare("SELECT meta_key, meta_value, meta_id, post_id
765                         FROM $wpdb->postmeta WHERE post_id = %d
766                         ORDER BY meta_key,meta_id", $postid), ARRAY_A );
767
768 }
769
770 /**
771  * {@internal Missing Short Description}}
772  *
773  * @since 1.2.0
774  *
775  * @param unknown_type $meta_id
776  * @param unknown_type $meta_key Expect Slashed
777  * @param unknown_type $meta_value Expect Slashed
778  * @return unknown
779  */
780 function update_meta( $meta_id, $meta_key, $meta_value ) {
781         global $wpdb;
782
783         $meta_key = stripslashes($meta_key);
784
785         if ( is_protected_meta( $meta_key ) )
786                 return false;
787
788         if ( '' === trim( $meta_value ) )
789                 return false;
790
791         $post_id = $wpdb->get_var( $wpdb->prepare("SELECT post_id FROM $wpdb->postmeta WHERE meta_id = %d", $meta_id) );
792
793         $meta_value = maybe_serialize( stripslashes_deep( $meta_value ) );
794         $meta_id = (int) $meta_id;
795
796         $data  = compact( 'meta_key', 'meta_value' );
797         $where = compact( 'meta_id' );
798
799         do_action( 'update_postmeta', $meta_id, $post_id, $meta_key, $meta_value );
800         $rval = $wpdb->update( $wpdb->postmeta, $data, $where );
801         wp_cache_delete($post_id, 'post_meta');
802         do_action( 'updated_postmeta', $meta_id, $post_id, $meta_key, $meta_value );
803
804         return $rval;
805 }
806
807 //
808 // Private
809 //
810
811 /**
812  * Replace hrefs of attachment anchors with up-to-date permalinks.
813  *
814  * @since 2.3.0
815  * @access private
816  *
817  * @param unknown_type $post_ID
818  * @return unknown
819  */
820 function _fix_attachment_links( $post_ID ) {
821         global $_fix_attachment_link_id;
822
823         $post = & get_post( $post_ID, ARRAY_A );
824
825         $search = "#<a[^>]+rel=('|\")[^'\"]*attachment[^>]*>#ie";
826
827         // See if we have any rel="attachment" links
828         if ( 0 == preg_match_all( $search, $post['post_content'], $anchor_matches, PREG_PATTERN_ORDER ) )
829                 return;
830
831         $i = 0;
832         $search = "#[\s]+rel=(\"|')(.*?)wp-att-(\d+)\\1#i";
833         foreach ( $anchor_matches[0] as $anchor ) {
834                 if ( 0 == preg_match( $search, $anchor, $id_matches ) )
835                         continue;
836
837                 $id = (int) $id_matches[3];
838
839                 // While we have the attachment ID, let's adopt any orphans.
840                 $attachment = & get_post( $id, ARRAY_A );
841                 if ( ! empty( $attachment) && ! is_object( get_post( $attachment['post_parent'] ) ) ) {
842                         $attachment['post_parent'] = $post_ID;
843                         // Escape data pulled from DB.
844                         $attachment = add_magic_quotes( $attachment );
845                         wp_update_post( $attachment );
846                 }
847
848                 $post_search[$i] = $anchor;
849                  $_fix_attachment_link_id = $id;
850                 $post_replace[$i] = preg_replace_callback( "#href=(\"|')[^'\"]*\\1#", '_fix_attachment_links_replace_cb', $anchor );
851                 ++$i;
852         }
853
854         $post['post_content'] = str_replace( $post_search, $post_replace, $post['post_content'] );
855
856         // Escape data pulled from DB.
857         $post = add_magic_quotes( $post);
858
859         return wp_update_post( $post);
860 }
861
862 function _fix_attachment_links_replace_cb($match) {
863         global $_fix_attachment_link_id;
864         return stripslashes( 'href='.$match[1] ).get_attachment_link( $_fix_attachment_link_id ).stripslashes( $match[1] );
865 }
866
867 /**
868  * Move child posts to a new parent.
869  *
870  * @since 2.3.0
871  * @access private
872  *
873  * @param unknown_type $old_ID
874  * @param unknown_type $new_ID
875  * @return unknown
876  */
877 function _relocate_children( $old_ID, $new_ID ) {
878         global $wpdb;
879         $old_ID = (int) $old_ID;
880         $new_ID = (int) $new_ID;
881
882         $children = $wpdb->get_col( $wpdb->prepare("
883                 SELECT post_id
884                 FROM $wpdb->postmeta
885                 WHERE meta_key = '_wp_attachment_temp_parent'
886                 AND meta_value = %d", $old_ID) );
887
888         foreach ( $children as $child_id ) {
889                 $wpdb->update($wpdb->posts, array('post_parent' => $new_ID), array('ID' => $child_id) );
890                 delete_post_meta($child_id, '_wp_attachment_temp_parent');
891         }
892 }
893
894 /**
895  * Get all the possible statuses for a post_type
896  *
897  * @since 2.5.0
898  *
899  * @param string $type The post_type you want the statuses for
900  * @return array As array of all the statuses for the supplied post type
901  */
902 function get_available_post_statuses($type = 'post') {
903         $stati = wp_count_posts($type);
904
905         return array_keys(get_object_vars($stati));
906 }
907
908 /**
909  * Run the wp query to fetch the posts for listing on the edit posts page
910  *
911  * @since 2.5.0
912  *
913  * @param array|bool $q Array of query variables to use to build the query or false to use $_GET superglobal.
914  * @return array
915  */
916 function wp_edit_posts_query( $q = false ) {
917         if ( false === $q )
918                 $q = $_GET;
919         $q['m'] = isset($q['m']) ? (int) $q['m'] : 0;
920         $q['cat'] = isset($q['cat']) ? (int) $q['cat'] : 0;
921         $post_stati  = get_post_stati();
922
923         if ( isset($q['post_type']) && in_array( $q['post_type'], get_post_types() ) )
924                 $post_type = $q['post_type'];
925         else
926                 $post_type = 'post';
927
928         $avail_post_stati = get_available_post_statuses($post_type);
929
930         if ( isset($q['post_status']) && in_array( $q['post_status'], $post_stati ) ) {
931                 $post_status = $q['post_status'];
932                 $perm = 'readable';
933         }
934
935         if ( isset($q['orderby']) )
936                 $orderby = $q['orderby'];
937         elseif ( isset($q['post_status']) && in_array($q['post_status'], array('pending', 'draft')) )
938                 $orderby = 'modified';
939
940         if ( isset($q['order']) )
941                 $order = $q['order'];
942         elseif ( isset($q['post_status']) && 'pending' == $q['post_status'] )
943                 $order = 'ASC';
944
945         $per_page = 'edit_' . $post_type . '_per_page';
946         $posts_per_page = (int) get_user_option( $per_page );
947         if ( empty( $posts_per_page ) || $posts_per_page < 1 )
948                 $posts_per_page = 20;
949
950         $posts_per_page = apply_filters( $per_page, $posts_per_page );
951         $posts_per_page = apply_filters( 'edit_posts_per_page', $posts_per_page, $post_type );
952
953         $query = compact('post_type', 'post_status', 'perm', 'order', 'orderby', 'posts_per_page');
954
955         // Hierarchical types require special args.
956         if ( is_post_type_hierarchical( $post_type ) && !isset($orderby) ) {
957                 $query['orderby'] = 'menu_order title';
958                 $query['order'] = 'asc';
959                 $query['posts_per_page'] = -1;
960                 $query['posts_per_archive_page'] = -1;
961         }
962
963         if ( ! empty( $q['show_sticky'] ) )
964                 $query['post__in'] = (array) get_option( 'sticky_posts' );
965
966         wp( $query );
967
968         return $avail_post_stati;
969 }
970
971 /**
972  * Get default post mime types
973  *
974  * @since 2.9.0
975  *
976  * @return array
977  */
978 function get_post_mime_types() {
979         $post_mime_types = array(       //      array( adj, noun )
980                 'image' => array(__('Images'), __('Manage Images'), _n_noop('Image <span class="count">(%s)</span>', 'Images <span class="count">(%s)</span>')),
981                 'audio' => array(__('Audio'), __('Manage Audio'), _n_noop('Audio <span class="count">(%s)</span>', 'Audio <span class="count">(%s)</span>')),
982                 'video' => array(__('Video'), __('Manage Video'), _n_noop('Video <span class="count">(%s)</span>', 'Video <span class="count">(%s)</span>')),
983         );
984
985         return apply_filters('post_mime_types', $post_mime_types);
986 }
987
988 /**
989  * {@internal Missing Short Description}}
990  *
991  * @since 2.5.0
992  *
993  * @param unknown_type $type
994  * @return unknown
995  */
996 function get_available_post_mime_types($type = 'attachment') {
997         global $wpdb;
998
999         $types = $wpdb->get_col($wpdb->prepare("SELECT DISTINCT post_mime_type FROM $wpdb->posts WHERE post_type = %s", $type));
1000         return $types;
1001 }
1002
1003 /**
1004  * {@internal Missing Short Description}}
1005  *
1006  * @since 2.5.0
1007  *
1008  * @param unknown_type $q
1009  * @return unknown
1010  */
1011 function wp_edit_attachments_query( $q = false ) {
1012         if ( false === $q )
1013                 $q = $_GET;
1014
1015         $q['m']   = isset( $q['m'] ) ? (int) $q['m'] : 0;
1016         $q['cat'] = isset( $q['cat'] ) ? (int) $q['cat'] : 0;
1017         $q['post_type'] = 'attachment';
1018         $post_type = get_post_type_object( 'attachment' );
1019         $states = 'inherit';
1020         if ( current_user_can( $post_type->cap->read_private_posts ) )
1021                 $states .= ',private';
1022
1023         $q['post_status'] = isset( $q['status'] ) && 'trash' == $q['status'] ? 'trash' : $states;
1024         $media_per_page = (int) get_user_option( 'upload_per_page' );
1025         if ( empty( $media_per_page ) || $media_per_page < 1 )
1026                 $media_per_page = 20;
1027         $q['posts_per_page'] = apply_filters( 'upload_per_page', $media_per_page );
1028
1029         $post_mime_types = get_post_mime_types();
1030         $avail_post_mime_types = get_available_post_mime_types('attachment');
1031
1032         if ( isset($q['post_mime_type']) && !array_intersect( (array) $q['post_mime_type'], array_keys($post_mime_types) ) )
1033                 unset($q['post_mime_type']);
1034
1035         if ( isset($q['detached']) )
1036                 add_filter('posts_where', '_edit_attachments_query_helper');
1037
1038         wp( $q );
1039
1040         if ( isset($q['detached']) )
1041                 remove_filter('posts_where', '_edit_attachments_query_helper');
1042
1043         return array($post_mime_types, $avail_post_mime_types);
1044 }
1045
1046 function _edit_attachments_query_helper($where) {
1047         return $where .= ' AND post_parent < 1';
1048 }
1049
1050 /**
1051  * {@internal Missing Short Description}}
1052  *
1053  * @uses get_user_option()
1054  * @since 2.5.0
1055  *
1056  * @param unknown_type $id
1057  * @param unknown_type $page
1058  * @return unknown
1059  */
1060 function postbox_classes( $id, $page ) {
1061         if ( isset( $_GET['edit'] ) && $_GET['edit'] == $id )
1062                 return '';
1063
1064         if ( $closed = get_user_option('closedpostboxes_'.$page ) ) {
1065                 if ( !is_array( $closed ) ) {
1066                         return '';
1067                 }
1068                 return in_array( $id, $closed )? 'closed' : '';
1069         } else {
1070                 return '';
1071         }
1072 }
1073
1074 /**
1075  * {@internal Missing Short Description}}
1076  *
1077  * @since 2.5.0
1078  *
1079  * @param int|object $id    Post ID or post object.
1080  * @param string $title (optional) Title
1081  * @param string $name (optional) Name
1082  * @return array With two entries of type string
1083  */
1084 function get_sample_permalink($id, $title = null, $name = null) {
1085         $post = &get_post($id);
1086         if ( !$post->ID )
1087                 return array('', '');
1088
1089         $ptype = get_post_type_object($post->post_type);
1090
1091         $original_status = $post->post_status;
1092         $original_date = $post->post_date;
1093         $original_name = $post->post_name;
1094
1095         // Hack: get_permalink would return ugly permalink for
1096         // drafts, so we will fake, that our post is published
1097         if ( in_array($post->post_status, array('draft', 'pending')) ) {
1098                 $post->post_status = 'publish';
1099                 $post->post_name = sanitize_title($post->post_name ? $post->post_name : $post->post_title, $post->ID);
1100         }
1101
1102         // If the user wants to set a new name -- override the current one
1103         // Note: if empty name is supplied -- use the title instead, see #6072
1104         if ( !is_null($name) )
1105                 $post->post_name = sanitize_title($name ? $name : $title, $post->ID);
1106
1107         $post->post_name = wp_unique_post_slug($post->post_name, $post->ID, $post->post_status, $post->post_type, $post->post_parent);
1108
1109         $post->filter = 'sample';
1110
1111         $permalink = get_permalink($post, true);
1112
1113         // Replace custom post_type Token with generic pagename token for ease of use.
1114         $permalink = str_replace("%$post->post_type%", '%pagename%', $permalink);
1115
1116         // Handle page hierarchy
1117         if ( $ptype->hierarchical ) {
1118                 $uri = get_page_uri($post);
1119                 $uri = untrailingslashit($uri);
1120                 $uri = strrev( stristr( strrev( $uri ), '/' ) );
1121                 $uri = untrailingslashit($uri);
1122                 if ( !empty($uri) )
1123                         $uri .= '/';
1124                 $permalink = str_replace('%pagename%', "{$uri}%pagename%", $permalink);
1125         }
1126
1127         $permalink = array($permalink, apply_filters('editable_slug', $post->post_name));
1128         $post->post_status = $original_status;
1129         $post->post_date = $original_date;
1130         $post->post_name = $original_name;
1131         unset($post->filter);
1132
1133         return $permalink;
1134 }
1135
1136 /**
1137  * sample permalink html
1138  *
1139  * intended to be used for the inplace editor of the permalink post slug on in the post (and page?) editor.
1140  *
1141  * @since 2.5.0
1142  *
1143  * @param int|object $id Post ID or post object.
1144  * @param string $new_title (optional) New title
1145  * @param string $new_slug (optional) New slug
1146  * @return string intended to be used for the inplace editor of the permalink post slug on in the post (and page?) editor.
1147  */
1148 function get_sample_permalink_html( $id, $new_title = null, $new_slug = null ) {
1149         global $wpdb;
1150         $post = &get_post($id);
1151
1152         list($permalink, $post_name) = get_sample_permalink($post->ID, $new_title, $new_slug);
1153
1154         if ( 'publish' == $post->post_status ) {
1155                 $ptype = get_post_type_object($post->post_type);
1156                 $view_post = $ptype->labels->view_item;
1157                 $title = __('Click to edit this part of the permalink');
1158         } else {
1159                 $title = __('Temporary permalink. Click to edit this part.');
1160         }
1161
1162         if ( false === strpos($permalink, '%postname%') && false === strpos($permalink, '%pagename%') ) {
1163                 $return = '<strong>' . __('Permalink:') . "</strong>\n" . '<span id="sample-permalink">' . $permalink . "</span>\n";
1164                 if ( '' == get_option( 'permalink_structure' ) && current_user_can( 'manage_options' ) && !( 'page' == get_option('show_on_front') && $id == get_option('page_on_front') ) )
1165                         $return .= '<span id="change-permalinks"><a href="options-permalink.php" class="button" target="_blank">' . __('Change Permalinks') . "</a></span>\n";
1166                 if ( isset($view_post) )
1167                         $return .= "<span id='view-post-btn'><a href='$permalink' class='button' target='_blank'>$view_post</a></span>\n";
1168
1169                 $return = apply_filters('get_sample_permalink_html', $return, $id, $new_title, $new_slug);
1170
1171                 return $return;
1172         }
1173
1174         if ( function_exists('mb_strlen') ) {
1175                 if ( mb_strlen($post_name) > 30 ) {
1176                         $post_name_abridged = mb_substr($post_name, 0, 14). '&hellip;' . mb_substr($post_name, -14);
1177                 } else {
1178                         $post_name_abridged = $post_name;
1179                 }
1180         } else {
1181                 if ( strlen($post_name) > 30 ) {
1182                         $post_name_abridged = substr($post_name, 0, 14). '&hellip;' . substr($post_name, -14);
1183                 } else {
1184                         $post_name_abridged = $post_name;
1185                 }
1186         }
1187
1188         $post_name_html = '<span id="editable-post-name" title="' . $title . '">' . $post_name_abridged . '</span>';
1189         $display_link = str_replace(array('%pagename%','%postname%'), $post_name_html, $permalink);
1190         $view_link = str_replace(array('%pagename%','%postname%'), $post_name, $permalink);
1191         $return =  '<strong>' . __('Permalink:') . "</strong>\n";
1192         $return .= '<span id="sample-permalink">' . $display_link . "</span>\n";
1193         $return .= '&lrm;'; // Fix bi-directional text display defect in RTL languages.
1194         $return .= '<span id="edit-slug-buttons"><a href="#post_name" class="edit-slug button hide-if-no-js" onclick="editPermalink(' . $id . '); return false;">' . __('Edit') . "</a></span>\n";
1195         $return .= '<span id="editable-post-name-full">' . $post_name . "</span>\n";
1196         if ( isset($view_post) )
1197                 $return .= "<span id='view-post-btn'><a href='$view_link' class='button' target='_blank'>$view_post</a></span>\n";
1198
1199         $return = apply_filters('get_sample_permalink_html', $return, $id, $new_title, $new_slug);
1200
1201         return $return;
1202 }
1203
1204 /**
1205  * Output HTML for the post thumbnail meta-box.
1206  *
1207  * @since 2.9.0
1208  *
1209  * @param int $thumbnail_id ID of the attachment used for thumbnail
1210  * @return string html
1211  */
1212 function _wp_post_thumbnail_html( $thumbnail_id = NULL ) {
1213         global $content_width, $_wp_additional_image_sizes, $post_ID;
1214         $set_thumbnail_link = '<p class="hide-if-no-js"><a title="' . esc_attr__( 'Set featured image' ) . '" href="' . esc_url( get_upload_iframe_src('image') ) . '" id="set-post-thumbnail" class="thickbox">%s</a></p>';
1215         $content = sprintf($set_thumbnail_link, esc_html__( 'Set featured image' ));
1216
1217         if ( $thumbnail_id && get_post( $thumbnail_id ) ) {
1218                 $old_content_width = $content_width;
1219                 $content_width = 266;
1220                 if ( !isset( $_wp_additional_image_sizes['post-thumbnail'] ) )
1221                         $thumbnail_html = wp_get_attachment_image( $thumbnail_id, array( $content_width, $content_width ) );
1222                 else
1223                         $thumbnail_html = wp_get_attachment_image( $thumbnail_id, 'post-thumbnail' );
1224                 if ( !empty( $thumbnail_html ) ) {
1225                         $ajax_nonce = wp_create_nonce( "set_post_thumbnail-$post_ID" );
1226                         $content = sprintf($set_thumbnail_link, $thumbnail_html);
1227                         $content .= '<p class="hide-if-no-js"><a href="#" id="remove-post-thumbnail" onclick="WPRemoveThumbnail(\'' . $ajax_nonce . '\');return false;">' . esc_html__( 'Remove featured image' ) . '</a></p>';
1228                 }
1229                 $content_width = $old_content_width;
1230         }
1231
1232         return apply_filters( 'admin_post_thumbnail_html', $content );
1233 }
1234
1235 /**
1236  * Check to see if the post is currently being edited by another user.
1237  *
1238  * @since 2.5.0
1239  *
1240  * @param int $post_id ID of the post to check for editing
1241  * @return bool|int False: not locked or locked by current user. Int: user ID of user with lock.
1242  */
1243 function wp_check_post_lock( $post_id ) {
1244         if ( !$post = get_post( $post_id ) )
1245                 return false;
1246
1247         if ( !$lock = get_post_meta( $post->ID, '_edit_lock', true ) )
1248                 return false;
1249
1250         $lock = explode( ':', $lock );
1251         $time = $lock[0];
1252         $user = isset( $lock[1] ) ? $lock[1] : get_post_meta( $post->ID, '_edit_last', true );
1253
1254         $time_window = apply_filters( 'wp_check_post_lock_window', AUTOSAVE_INTERVAL * 2 );
1255
1256         if ( $time && $time > time() - $time_window && $user != get_current_user_id() )
1257                 return $user;
1258         return false;
1259 }
1260
1261 /**
1262  * Mark the post as currently being edited by the current user
1263  *
1264  * @since 2.5.0
1265  *
1266  * @param int $post_id ID of the post to being edited
1267  * @return bool Returns false if the post doesn't exist of there is no current user
1268  */
1269 function wp_set_post_lock( $post_id ) {
1270         if ( !$post = get_post( $post_id ) )
1271                 return false;
1272         if ( 0 == ($user_id = get_current_user_id()) )
1273                 return false;
1274
1275         $now = time();
1276         $lock = "$now:$user_id";
1277
1278         update_post_meta( $post->ID, '_edit_lock', $lock );
1279 }
1280
1281 /**
1282  * Outputs the notice message to say that someone else is editing this post at the moment.
1283  *
1284  * @since 2.8.5
1285  * @return none
1286  */
1287 function _admin_notice_post_locked() {
1288         global $post;
1289
1290         $lock = explode( ':', get_post_meta( $post->ID, '_edit_lock', true ) );
1291         $user = isset( $lock[1] ) ? $lock[1] : get_post_meta( $post->ID, '_edit_last', true );
1292         $last_user = get_userdata( $user );
1293         $last_user_name = $last_user ? $last_user->display_name : __('Somebody');
1294
1295         switch ($post->post_type) {
1296                 case 'post':
1297                         $message = __( 'Warning: %s is currently editing this post' );
1298                         break;
1299                 case 'page':
1300                         $message = __( 'Warning: %s is currently editing this page' );
1301                         break;
1302                 default:
1303                         $message = __( 'Warning: %s is currently editing this.' );
1304         }
1305
1306         $message = sprintf( $message, esc_html( $last_user_name ) );
1307         echo "<div class='error'><p>$message</p></div>";
1308 }
1309
1310 /**
1311  * Creates autosave data for the specified post from $_POST data.
1312  *
1313  * @package WordPress
1314  * @subpackage Post_Revisions
1315  * @since 2.6.0
1316  *
1317  * @uses _wp_translate_postdata()
1318  * @uses _wp_post_revision_fields()
1319  *
1320  * @return unknown
1321  */
1322 function wp_create_post_autosave( $post_id ) {
1323         $translated = _wp_translate_postdata( true );
1324         if ( is_wp_error( $translated ) )
1325                 return $translated;
1326
1327         // Only store one autosave.  If there is already an autosave, overwrite it.
1328         if ( $old_autosave = wp_get_post_autosave( $post_id ) ) {
1329                 $new_autosave = _wp_post_revision_fields( $_POST, true );
1330                 $new_autosave['ID'] = $old_autosave->ID;
1331                 $new_autosave['post_author'] = get_current_user_id();
1332                 return wp_update_post( $new_autosave );
1333         }
1334
1335         // _wp_put_post_revision() expects unescaped.
1336         $_POST = stripslashes_deep($_POST);
1337
1338         // Otherwise create the new autosave as a special post revision
1339         return _wp_put_post_revision( $_POST, true );
1340 }
1341
1342 /**
1343  * Save draft or manually autosave for showing preview.
1344  *
1345  * @package WordPress
1346  * @since 2.7.0
1347  *
1348  * @uses wp_write_post()
1349  * @uses edit_post()
1350  * @uses get_post()
1351  * @uses current_user_can()
1352  * @uses wp_create_post_autosave()
1353  *
1354  * @return str URL to redirect to show the preview
1355  */
1356 function post_preview() {
1357
1358         $post_ID = (int) $_POST['post_ID'];
1359         $status = get_post_status( $post_ID );
1360         if ( 'auto-draft' == $status )
1361                 wp_die( __('Preview not available. Please save as a draft first.') );
1362
1363         if ( isset($_POST['catslist']) )
1364                 $_POST['post_category'] = explode(",", $_POST['catslist']);
1365
1366         if ( isset($_POST['tags_input']) )
1367                 $_POST['tags_input'] = explode(",", $_POST['tags_input']);
1368
1369         if ( $_POST['post_type'] == 'page' || empty($_POST['post_category']) )
1370                 unset($_POST['post_category']);
1371
1372         $_POST['ID'] = $post_ID;
1373         $post = get_post($post_ID);
1374
1375         if ( 'page' == $post->post_type ) {
1376                 if ( !current_user_can('edit_page', $post_ID) )
1377                         wp_die(__('You are not allowed to edit this page.'));
1378         } else {
1379                 if ( !current_user_can('edit_post', $post_ID) )
1380                         wp_die(__('You are not allowed to edit this post.'));
1381         }
1382
1383         if ( 'draft' == $post->post_status ) {
1384                 $id = edit_post();
1385         } else { // Non drafts are not overwritten.  The autosave is stored in a special post revision.
1386                 $id = wp_create_post_autosave( $post->ID );
1387                 if ( ! is_wp_error($id) )
1388                         $id = $post->ID;
1389         }
1390
1391         if ( is_wp_error($id) )
1392                 wp_die( $id->get_error_message() );
1393
1394         if ( $_POST['post_status'] == 'draft'  ) {
1395                 $url = add_query_arg( 'preview', 'true', get_permalink($id) );
1396         } else {
1397                 $nonce = wp_create_nonce('post_preview_' . $id);
1398                 $url = add_query_arg( array( 'preview' => 'true', 'preview_id' => $id, 'preview_nonce' => $nonce ), get_permalink($id) );
1399         }
1400
1401         return $url;
1402 }
1403
1404 /**
1405  * Adds the TinyMCE editor used on the Write and Edit screens.
1406  *
1407  * @package WordPress
1408  * @since 2.7.0
1409  *
1410  * TinyMCE is loaded separately from other Javascript by using wp-tinymce.php. It outputs concatenated
1411  * and optionaly pre-compressed version of the core and all default plugins. Additional plugins are loaded
1412  * directly by TinyMCE using non-blocking method. Custom plugins can be refreshed by adding a query string
1413  * to the URL when queueing them with the mce_external_plugins filter.
1414  *
1415  * @param bool $teeny optional Output a trimmed down version used in Press This.
1416  * @param mixed $settings optional An array that can add to or overwrite the default TinyMCE settings.
1417  */
1418 function wp_tiny_mce( $teeny = false, $settings = false ) {
1419         global $concatenate_scripts, $compress_scripts, $tinymce_version, $editor_styles;
1420
1421         if ( ! user_can_richedit() )
1422                 return;
1423
1424         $baseurl = includes_url('js/tinymce');
1425
1426         $mce_locale = ( '' == get_locale() ) ? 'en' : strtolower( substr(get_locale(), 0, 2) ); // only ISO 639-1
1427
1428         /*
1429         The following filter allows localization scripts to change the languages displayed in the spellchecker's drop-down menu.
1430         By default it uses Google's spellchecker API, but can be configured to use PSpell/ASpell if installed on the server.
1431         The + sign marks the default language. More information:
1432         http://wiki.moxiecode.com/index.php/TinyMCE:Plugins/spellchecker
1433         */
1434         $mce_spellchecker_languages = apply_filters('mce_spellchecker_languages', '+English=en,Danish=da,Dutch=nl,Finnish=fi,French=fr,German=de,Italian=it,Polish=pl,Portuguese=pt,Spanish=es,Swedish=sv');
1435
1436         if ( $teeny ) {
1437                 $plugins = apply_filters( 'teeny_mce_plugins', array('inlinepopups', 'fullscreen', 'wordpress', 'wplink', 'wpdialogs') );
1438                 $ext_plugins = '';
1439         } else {
1440                 $plugins = array( 'inlinepopups', 'spellchecker', 'paste', 'wordpress', 'fullscreen', 'wpeditimage', 'wpgallery', 'tabfocus', 'wplink', 'wpdialogs' );
1441
1442                 /*
1443                 The following filter takes an associative array of external plugins for TinyMCE in the form 'plugin_name' => 'url'.
1444                 It adds the plugin's name to TinyMCE's plugins init and the call to PluginManager to load the plugin.
1445                 The url should be absolute and should include the js file name to be loaded. Example:
1446                 array( 'myplugin' => 'http://my-site.com/wp-content/plugins/myfolder/mce_plugin.js' )
1447                 If the plugin uses a button, it should be added with one of the "$mce_buttons" filters.
1448                 */
1449                 $mce_external_plugins = apply_filters('mce_external_plugins', array());
1450
1451                 $ext_plugins = '';
1452                 if ( ! empty($mce_external_plugins) ) {
1453
1454                         /*
1455                         The following filter loads external language files for TinyMCE plugins.
1456                         It takes an associative array 'plugin_name' => 'path', where path is the
1457                         include path to the file. The language file should follow the same format as
1458                         /tinymce/langs/wp-langs.php and should define a variable $strings that
1459                         holds all translated strings.
1460                         When this filter is not used, the function will try to load {mce_locale}.js.
1461                         If that is not found, en.js will be tried next.
1462                         */
1463                         $mce_external_languages = apply_filters('mce_external_languages', array());
1464
1465                         $loaded_langs = array();
1466                         $strings = '';
1467
1468                         if ( ! empty($mce_external_languages) ) {
1469                                 foreach ( $mce_external_languages as $name => $path ) {
1470                                         if ( @is_file($path) && @is_readable($path) ) {
1471                                                 include_once($path);
1472                                                 $ext_plugins .= $strings . "\n";
1473                                                 $loaded_langs[] = $name;
1474                                         }
1475                                 }
1476                         }
1477
1478                         foreach ( $mce_external_plugins as $name => $url ) {
1479
1480                                 if ( is_ssl() ) $url = str_replace('http://', 'https://', $url);
1481
1482                                 $plugins[] = '-' . $name;
1483
1484                                 $plugurl = dirname($url);
1485                                 $strings = $str1 = $str2 = '';
1486                                 if ( ! in_array($name, $loaded_langs) ) {
1487                                         $path = str_replace( WP_PLUGIN_URL, '', $plugurl );
1488                                         $path = WP_PLUGIN_DIR . $path . '/langs/';
1489
1490                                         if ( function_exists('realpath') )
1491                                                 $path = trailingslashit( realpath($path) );
1492
1493                                         if ( @is_file($path . $mce_locale . '.js') )
1494                                                 $strings .= @file_get_contents($path . $mce_locale . '.js') . "\n";
1495
1496                                         if ( @is_file($path . $mce_locale . '_dlg.js') )
1497                                                 $strings .= @file_get_contents($path . $mce_locale . '_dlg.js') . "\n";
1498
1499                                         if ( 'en' != $mce_locale && empty($strings) ) {
1500                                                 if ( @is_file($path . 'en.js') ) {
1501                                                         $str1 = @file_get_contents($path . 'en.js');
1502                                                         $strings .= preg_replace( '/([\'"])en\./', '$1' . $mce_locale . '.', $str1, 1 ) . "\n";
1503                                                 }
1504
1505                                                 if ( @is_file($path . 'en_dlg.js') ) {
1506                                                         $str2 = @file_get_contents($path . 'en_dlg.js');
1507                                                         $strings .= preg_replace( '/([\'"])en\./', '$1' . $mce_locale . '.', $str2, 1 ) . "\n";
1508                                                 }
1509                                         }
1510
1511                                         if ( ! empty($strings) )
1512                                                 $ext_plugins .= "\n" . $strings . "\n";
1513                                 }
1514
1515                                 $ext_plugins .= 'tinyMCEPreInit.load_ext("' . $plugurl . '", "' . $mce_locale . '");' . "\n";
1516                                 $ext_plugins .= 'tinymce.PluginManager.load("' . $name . '", "' . $url . '");' . "\n";
1517                         }
1518                 }
1519         }
1520
1521         if ( $teeny ) {
1522                 $mce_buttons = apply_filters( 'teeny_mce_buttons', array('bold, italic, underline, blockquote, separator, strikethrough, bullist, numlist,justifyleft, justifycenter, justifyright, undo, redo, link, unlink, fullscreen') );
1523                 $mce_buttons = implode($mce_buttons, ',');
1524                 $mce_buttons_2 = $mce_buttons_3 = $mce_buttons_4 = '';
1525         } else {
1526                 $mce_buttons = apply_filters('mce_buttons', array('bold', 'italic', 'strikethrough', '|', 'bullist', 'numlist', 'blockquote', '|', 'justifyleft', 'justifycenter', 'justifyright', '|', 'link', 'unlink', 'wp_more', '|', 'spellchecker', 'fullscreen', 'wp_adv' ));
1527                 $mce_buttons = implode($mce_buttons, ',');
1528
1529                 $mce_buttons_2 = array( 'formatselect', 'underline', 'justifyfull', 'forecolor', '|', 'pastetext', 'pasteword', 'removeformat', '|', 'charmap', '|', 'outdent', 'indent', '|', 'undo', 'redo', 'wp_help' );
1530                 $mce_buttons_2 = apply_filters('mce_buttons_2', $mce_buttons_2);
1531                 $mce_buttons_2 = implode($mce_buttons_2, ',');
1532
1533                 $mce_buttons_3 = apply_filters('mce_buttons_3', array());
1534                 $mce_buttons_3 = implode($mce_buttons_3, ',');
1535
1536                 $mce_buttons_4 = apply_filters('mce_buttons_4', array());
1537                 $mce_buttons_4 = implode($mce_buttons_4, ',');
1538         }
1539         $no_captions = (bool) apply_filters( 'disable_captions', '' );
1540
1541         // TinyMCE init settings
1542         $initArray = array (
1543                 'mode' => 'specific_textareas',
1544                 'editor_selector' => 'theEditor',
1545                 'width' => '100%',
1546                 'theme' => 'advanced',
1547                 'skin' => 'wp_theme',
1548                 'theme_advanced_buttons1' => $mce_buttons,
1549                 'theme_advanced_buttons2' => $mce_buttons_2,
1550                 'theme_advanced_buttons3' => $mce_buttons_3,
1551                 'theme_advanced_buttons4' => $mce_buttons_4,
1552                 'language' => $mce_locale,
1553                 'spellchecker_languages' => $mce_spellchecker_languages,
1554                 'theme_advanced_toolbar_location' => 'top',
1555                 'theme_advanced_toolbar_align' => 'left',
1556                 'theme_advanced_statusbar_location' => 'bottom',
1557                 'theme_advanced_resizing' => true,
1558                 'theme_advanced_resize_horizontal' => false,
1559                 'dialog_type' => 'modal',
1560                 'formats' => "{
1561                         alignleft : [
1562                                 {selector : 'p,h1,h2,h3,h4,h5,h6,td,th,div,ul,ol,li', styles : {textAlign : 'left'}},
1563                                 {selector : 'img,table', classes : 'alignleft'}
1564                         ],
1565                         aligncenter : [
1566                                 {selector : 'p,h1,h2,h3,h4,h5,h6,td,th,div,ul,ol,li', styles : {textAlign : 'center'}},
1567                                 {selector : 'img,table', classes : 'aligncenter'}
1568                         ],
1569                         alignright : [
1570                                 {selector : 'p,h1,h2,h3,h4,h5,h6,td,th,div,ul,ol,li', styles : {textAlign : 'right'}},
1571                                 {selector : 'img,table', classes : 'alignright'}
1572                         ],
1573                         strikethrough : {inline : 'del'}
1574                 }",
1575                 'relative_urls' => false,
1576                 'remove_script_host' => false,
1577                 'convert_urls' => false,
1578                 'apply_source_formatting' => false,
1579                 'remove_linebreaks' => true,
1580                 'gecko_spellcheck' => true,
1581                 'entities' => '38,amp,60,lt,62,gt',
1582                 'accessibility_focus' => true,
1583                 'tabfocus_elements' => 'major-publishing-actions',
1584                 'media_strict' => false,
1585                 'paste_remove_styles' => true,
1586                 'paste_remove_spans' => true,
1587                 'paste_strip_class_attributes' => 'all',
1588                 'paste_text_use_dialog' => true,
1589                 'wpeditimage_disable_captions' => $no_captions,
1590                 'plugins' => implode( ',', $plugins ),
1591         );
1592
1593         if ( ! empty( $editor_styles ) && is_array( $editor_styles ) ) {
1594                 $mce_css = array();
1595                 $style_uri = get_stylesheet_directory_uri();
1596                 if ( ! is_child_theme() ) {
1597                         foreach ( $editor_styles as $file )
1598                                 $mce_css[] = "$style_uri/$file";
1599                 } else {
1600                         $style_dir    = get_stylesheet_directory();
1601                         $template_uri = get_template_directory_uri();
1602                         $template_dir = get_template_directory();
1603                         foreach ( $editor_styles as $file ) {
1604                                 if ( file_exists( "$template_dir/$file" ) )
1605                                         $mce_css[] = "$template_uri/$file";
1606                                 if ( file_exists( "$style_dir/$file" ) )
1607                                         $mce_css[] = "$style_uri/$file";
1608                         }
1609                 }
1610                 $mce_css = implode( ',', $mce_css );
1611         } else {
1612                 $mce_css = '';
1613         }
1614
1615         $mce_css = trim( apply_filters( 'mce_css', $mce_css ), ' ,' );
1616
1617         if ( ! empty($mce_css) )
1618                 $initArray['content_css'] = $mce_css;
1619
1620         if ( is_array($settings) )
1621                 $initArray = array_merge($initArray, $settings);
1622
1623         // For people who really REALLY know what they're doing with TinyMCE
1624         // You can modify initArray to add, remove, change elements of the config before tinyMCE.init
1625         // Setting "valid_elements", "invalid_elements" and "extended_valid_elements" can be done through "tiny_mce_before_init".
1626         // Best is to use the default cleanup by not specifying valid_elements, as TinyMCE contains full set of XHTML 1.0.
1627         if ( $teeny ) {
1628                 $initArray = apply_filters('teeny_mce_before_init', $initArray);
1629         } else {
1630                 $initArray = apply_filters('tiny_mce_before_init', $initArray);
1631         }
1632
1633         if ( empty($initArray['theme_advanced_buttons3']) && !empty($initArray['theme_advanced_buttons4']) ) {
1634                 $initArray['theme_advanced_buttons3'] = $initArray['theme_advanced_buttons4'];
1635                 $initArray['theme_advanced_buttons4'] = '';
1636         }
1637
1638         if ( ! isset($concatenate_scripts) )
1639                 script_concat_settings();
1640
1641         $language = $initArray['language'];
1642
1643         $compressed = $compress_scripts && $concatenate_scripts && isset($_SERVER['HTTP_ACCEPT_ENCODING'])
1644                 && false !== strpos( strtolower($_SERVER['HTTP_ACCEPT_ENCODING']), 'gzip');
1645
1646         /**
1647          * Deprecated
1648          *
1649          * The tiny_mce_version filter is not needed since external plugins are loaded directly by TinyMCE.
1650          * These plugins can be refreshed by appending query string to the URL passed to mce_external_plugins filter.
1651          * If the plugin has a popup dialog, a query string can be added to the button action that opens it (in the plugin's code).
1652          */
1653         $version = apply_filters('tiny_mce_version', '');
1654         $version = 'ver=' . $tinymce_version . $version;
1655
1656         if ( 'en' != $language )
1657                 include_once(ABSPATH . WPINC . '/js/tinymce/langs/wp-langs.php');
1658
1659         $mce_options = '';
1660         foreach ( $initArray as $k => $v ) {
1661                 if ( is_bool($v) ) {
1662                         $val = $v ? 'true' : 'false';
1663                         $mce_options .= $k . ':' . $val . ', ';
1664                         continue;
1665                 } elseif ( !empty($v) && is_string($v) && ( '{' == $v{0} || '[' == $v{0} ) ) {
1666                         $mce_options .= $k . ':' . $v . ', ';
1667                         continue;
1668                 }
1669
1670                 $mce_options .= $k . ':"' . $v . '", ';
1671         }
1672
1673         $mce_options = rtrim( trim($mce_options), '\n\r,' ); ?>
1674
1675 <script type="text/javascript">
1676 /* <![CDATA[ */
1677 tinyMCEPreInit = {
1678         base : "<?php echo $baseurl; ?>",
1679         suffix : "",
1680         query : "<?php echo $version; ?>",
1681         mceInit : {<?php echo $mce_options; ?>},
1682         load_ext : function(url,lang){var sl=tinymce.ScriptLoader;sl.markDone(url+'/langs/'+lang+'.js');sl.markDone(url+'/langs/'+lang+'_dlg.js');}
1683 };
1684 /* ]]> */
1685 </script>
1686
1687 <?php
1688         if ( $compressed )
1689                 echo "<script type='text/javascript' src='$baseurl/wp-tinymce.php?c=1&amp;$version'></script>\n";
1690         else
1691                 echo "<script type='text/javascript' src='$baseurl/tiny_mce.js?$version'></script>\n";
1692
1693         if ( 'en' != $language && isset($lang) )
1694                 echo "<script type='text/javascript'>\n$lang\n</script>\n";
1695         else
1696                 echo "<script type='text/javascript' src='$baseurl/langs/wp-langs-en.js?$version'></script>\n";
1697 ?>
1698
1699 <script type="text/javascript">
1700 /* <![CDATA[ */
1701 <?php
1702         if ( $ext_plugins )
1703                 echo "$ext_plugins\n";
1704
1705         if ( ! $compressed ) {
1706 ?>
1707 (function(){var t=tinyMCEPreInit,sl=tinymce.ScriptLoader,ln=t.mceInit.language,th=t.mceInit.theme,pl=t.mceInit.plugins;sl.markDone(t.base+'/langs/'+ln+'.js');sl.markDone(t.base+'/themes/'+th+'/langs/'+ln+'.js');sl.markDone(t.base+'/themes/'+th+'/langs/'+ln+'_dlg.js');tinymce.each(pl.split(','),function(n){if(n&&n.charAt(0)!='-'){sl.markDone(t.base+'/plugins/'+n+'/langs/'+ln+'.js');sl.markDone(t.base+'/plugins/'+n+'/langs/'+ln+'_dlg.js');}});})();
1708 <?php } ?>
1709 tinyMCE.init(tinyMCEPreInit.mceInit);
1710 /* ]]> */
1711 </script>
1712 <?php
1713
1714         // Load additional inline scripts based on active plugins.
1715         if ( in_array( 'wpdialogs', $plugins ) ) {
1716                 wp_print_scripts( array( 'wpdialogs-popup' ) );
1717                 wp_print_styles('wp-jquery-ui-dialog');
1718         }
1719         if ( in_array( 'wplink', $plugins ) ) {
1720                 require_once ABSPATH . 'wp-admin/includes/internal-linking.php';
1721                 add_action('tiny_mce_preload_dialogs', 'wp_link_dialog');
1722                 wp_print_scripts('wplink');
1723                 wp_print_styles('wplink');
1724         }
1725 }
1726 function wp_tiny_mce_preload_dialogs() { ?>
1727         <div id="preloaded-dialogs" style="display:none;">
1728 <?php   do_action('tiny_mce_preload_dialogs'); ?>
1729         </div>
1730 <?php }