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