source: trunk/www.guidonia.net/wp/wp-admin/import/wordpress.php@ 44

Last change on this file since 44 was 44, checked in by luciano, 15 years ago
File size: 25.1 KB
Line 
1<?php
2/**
3 * WordPress Importer
4 *
5 * @package WordPress
6 * @subpackage Importer
7 */
8
9/**
10 * WordPress Importer
11 *
12 * Will process the WordPress eXtended RSS files that you upload from the export
13 * file.
14 *
15 * @since unknown
16 */
17class WP_Import {
18
19 var $post_ids_processed = array ();
20 var $orphans = array ();
21 var $file;
22 var $id;
23 var $mtnames = array ();
24 var $newauthornames = array ();
25 var $allauthornames = array ();
26
27 var $author_ids = array ();
28 var $tags = array ();
29 var $categories = array ();
30
31 var $j = -1;
32 var $fetch_attachments = false;
33 var $url_remap = array ();
34
35 function header() {
36 echo '<div class="wrap">';
37 screen_icon();
38 echo '<h2>'.__('Import WordPress').'</h2>';
39 }
40
41 function footer() {
42 echo '</div>';
43 }
44
45 function unhtmlentities($string) { // From php.net for < 4.3 compat
46 $trans_tbl = get_html_translation_table(HTML_ENTITIES);
47 $trans_tbl = array_flip($trans_tbl);
48 return strtr($string, $trans_tbl);
49 }
50
51 function greet() {
52 echo '<div class="narrow">';
53 echo '<p>'.__('Howdy! Upload your WordPress eXtended RSS (WXR) file and we&#8217;ll import the posts, pages, comments, custom fields, categories, and tags into this blog.').'</p>';
54 echo '<p>'.__('Choose a WordPress WXR file to upload, then click Upload file and import.').'</p>';
55 wp_import_upload_form("admin.php?import=wordpress&amp;step=1");
56 echo '</div>';
57 }
58
59 function get_tag( $string, $tag ) {
60 global $wpdb;
61 preg_match("|<$tag.*?>(.*?)</$tag>|is", $string, $return);
62 $return = preg_replace('|^<!\[CDATA\[(.*)\]\]>$|s', '$1', $return[1]);
63 $return = $wpdb->escape( trim( $return ) );
64 return $return;
65 }
66
67 function has_gzip() {
68 return is_callable('gzopen');
69 }
70
71 function fopen($filename, $mode='r') {
72 if ( $this->has_gzip() )
73 return gzopen($filename, $mode);
74 return fopen($filename, $mode);
75 }
76
77 function feof($fp) {
78 if ( $this->has_gzip() )
79 return gzeof($fp);
80 return feof($fp);
81 }
82
83 function fgets($fp, $len=8192) {
84 if ( $this->has_gzip() )
85 return gzgets($fp, $len);
86 return fgets($fp, $len);
87 }
88
89 function fclose($fp) {
90 if ( $this->has_gzip() )
91 return gzclose($fp);
92 return fclose($fp);
93 }
94
95 function get_entries($process_post_func=NULL) {
96 set_magic_quotes_runtime(0);
97
98 $doing_entry = false;
99 $is_wxr_file = false;
100
101 $fp = $this->fopen($this->file, 'r');
102 if ($fp) {
103 while ( !$this->feof($fp) ) {
104 $importline = rtrim($this->fgets($fp));
105
106 // this doesn't check that the file is perfectly valid but will at least confirm that it's not the wrong format altogether
107 if ( !$is_wxr_file && preg_match('|xmlns:wp="http://wordpress[.]org/export/\d+[.]\d+/"|', $importline) )
108 $is_wxr_file = true;
109
110 if ( false !== strpos($importline, '<wp:base_site_url>') ) {
111 preg_match('|<wp:base_site_url>(.*?)</wp:base_site_url>|is', $importline, $url);
112 $this->base_url = $url[1];
113 continue;
114 }
115 if ( false !== strpos($importline, '<wp:category>') ) {
116 preg_match('|<wp:category>(.*?)</wp:category>|is', $importline, $category);
117 $this->categories[] = $category[1];
118 continue;
119 }
120 if ( false !== strpos($importline, '<wp:tag>') ) {
121 preg_match('|<wp:tag>(.*?)</wp:tag>|is', $importline, $tag);
122 $this->tags[] = $tag[1];
123 continue;
124 }
125 if ( false !== strpos($importline, '<item>') ) {
126 $this->post = '';
127 $doing_entry = true;
128 continue;
129 }
130 if ( false !== strpos($importline, '</item>') ) {
131 $doing_entry = false;
132 if ($process_post_func)
133 call_user_func($process_post_func, $this->post);
134 continue;
135 }
136 if ( $doing_entry ) {
137 $this->post .= $importline . "\n";
138 }
139 }
140
141 $this->fclose($fp);
142 }
143
144 return $is_wxr_file;
145
146 }
147
148 function get_wp_authors() {
149 // We need to find unique values of author names, while preserving the order, so this function emulates the unique_value(); php function, without the sorting.
150 $temp = $this->allauthornames;
151 $authors[0] = array_shift($temp);
152 $y = count($temp) + 1;
153 for ($x = 1; $x < $y; $x ++) {
154 $next = array_shift($temp);
155 if (!(in_array($next, $authors)))
156 array_push($authors, "$next");
157 }
158
159 return $authors;
160 }
161
162 function get_authors_from_post() {
163 global $current_user;
164
165 // this will populate $this->author_ids with a list of author_names => user_ids
166
167 foreach ( $_POST['author_in'] as $i => $in_author_name ) {
168
169 if ( !empty($_POST['user_select'][$i]) ) {
170 // an existing user was selected in the dropdown list
171 $user = get_userdata( intval($_POST['user_select'][$i]) );
172 if ( isset($user->ID) )
173 $this->author_ids[$in_author_name] = $user->ID;
174 }
175 elseif ( $this->allow_create_users() ) {
176 // nothing was selected in the dropdown list, so we'll use the name in the text field
177
178 $new_author_name = trim($_POST['user_create'][$i]);
179 // if the user didn't enter a name, assume they want to use the same name as in the import file
180 if ( empty($new_author_name) )
181 $new_author_name = $in_author_name;
182
183 $user_id = username_exists($new_author_name);
184 if ( !$user_id ) {
185 $user_id = wp_create_user($new_author_name, wp_generate_password());
186 }
187
188 $this->author_ids[$in_author_name] = $user_id;
189 }
190
191 // failsafe: if the user_id was invalid, default to the current user
192 if ( empty($this->author_ids[$in_author_name]) ) {
193 $this->author_ids[$in_author_name] = intval($current_user->ID);
194 }
195 }
196
197 }
198
199 function wp_authors_form() {
200?>
201<?php screen_icon(); ?>
202<h2><?php _e('Assign Authors'); ?></h2>
203<p><?php _e('To make it easier for you to edit and save the imported posts and drafts, you may want to change the name of the author of the posts. For example, you may want to import all the entries as <code>admin</code>s entries.'); ?></p>
204<?php
205 if ( $this->allow_create_users() ) {
206 echo '<p>'.__('If a new user is created by WordPress, a password will be randomly generated. Manually change the user&#8217;s details if necessary.')."</p>\n";
207 }
208
209
210 $authors = $this->get_wp_authors();
211 echo '<form action="?import=wordpress&amp;step=2&amp;id=' . $this->id . '" method="post">';
212 wp_nonce_field('import-wordpress');
213 echo '<ol id="authors">';
214 $j = -1;
215 foreach ($authors as $author) {
216 ++ $j;
217 echo '<li>'.__('Import author:').' <strong>'.$author.'</strong><br />';
218 $this->users_form($j, $author);
219 echo '</li>';
220 }
221
222 if ( $this->allow_fetch_attachments() ) {
223?>
224</ol>
225<?php screen_icon(); ?>
226<h2><?php _e('Import Attachments'); ?></h2>
227<p>
228 <input type="checkbox" value="1" name="attachments" id="import-attachments" />
229 <label for="import-attachments"><?php _e('Download and import file attachments') ?></label>
230</p>
231
232<?php
233 }
234
235 echo '<p class="submit">';
236 echo '<input type="submit" class="button" value="'. esc_attr__('Submit') .'" />'.'<br />';
237 echo '</p>';
238 echo '</form>';
239
240 }
241
242 function users_form($n, $author) {
243
244 if ( $this->allow_create_users() ) {
245 printf('<label>'.__('Create user %1$s or map to existing'), ' <input type="text" value="'. esc_attr($author) .'" name="'.'user_create['.intval($n).']'.'" maxlength="30" /></label> <br />');
246 }
247 else {
248 echo __('Map to existing').'<br />';
249 }
250
251 // keep track of $n => $author name
252 echo '<input type="hidden" name="author_in['.intval($n).']" value="' . esc_attr($author).'" />';
253
254 $users = get_users_of_blog();
255?><select name="user_select[<?php echo $n; ?>]">
256 <option value="0"><?php _e('- Select -'); ?></option>
257 <?php
258 foreach ($users as $user) {
259 echo '<option value="'.$user->user_id.'">'.$user->user_login.'</option>';
260 }
261?>
262 </select>
263 <?php
264 }
265
266 function select_authors() {
267 $is_wxr_file = $this->get_entries(array(&$this, 'process_author'));
268 if ( $is_wxr_file ) {
269 $this->wp_authors_form();
270 }
271 else {
272 echo '<h2>'.__('Invalid file').'</h2>';
273 echo '<p>'.__('Please upload a valid WXR (WordPress eXtended RSS) export file.').'</p>';
274 }
275 }
276
277 // fetch the user ID for a given author name, respecting the mapping preferences
278 function checkauthor($author) {
279 global $current_user;
280
281 if ( !empty($this->author_ids[$author]) )
282 return $this->author_ids[$author];
283
284 // failsafe: map to the current user
285 return $current_user->ID;
286 }
287
288
289
290 function process_categories() {
291 global $wpdb;
292
293 $cat_names = (array) get_terms('category', 'fields=names');
294
295 while ( $c = array_shift($this->categories) ) {
296 $cat_name = trim($this->get_tag( $c, 'wp:cat_name' ));
297
298 // If the category exists we leave it alone
299 if ( in_array($cat_name, $cat_names) )
300 continue;
301
302 $category_nicename = $this->get_tag( $c, 'wp:category_nicename' );
303 $category_description = $this->get_tag( $c, 'wp:category_description' );
304 $posts_private = (int) $this->get_tag( $c, 'wp:posts_private' );
305 $links_private = (int) $this->get_tag( $c, 'wp:links_private' );
306
307 $parent = $this->get_tag( $c, 'wp:category_parent' );
308
309 if ( empty($parent) )
310 $category_parent = '0';
311 else
312 $category_parent = category_exists($parent);
313
314 $catarr = compact('category_nicename', 'category_parent', 'posts_private', 'links_private', 'posts_private', 'cat_name', 'category_description');
315
316 $cat_ID = wp_insert_category($catarr);
317 }
318 }
319
320 function process_tags() {
321 global $wpdb;
322
323 $tag_names = (array) get_terms('post_tag', 'fields=names');
324
325 while ( $c = array_shift($this->tags) ) {
326 $tag_name = trim($this->get_tag( $c, 'wp:tag_name' ));
327
328 // If the category exists we leave it alone
329 if ( in_array($tag_name, $tag_names) )
330 continue;
331
332 $slug = $this->get_tag( $c, 'wp:tag_slug' );
333 $description = $this->get_tag( $c, 'wp:tag_description' );
334
335 $tagarr = compact('slug', 'description');
336
337 $tag_ID = wp_insert_term($tag_name, 'post_tag', $tagarr);
338 }
339 }
340
341 function process_author($post) {
342 $author = $this->get_tag( $post, 'dc:creator' );
343 if ($author)
344 $this->allauthornames[] = $author;
345 }
346
347 function process_posts() {
348 echo '<ol>';
349
350 $this->get_entries(array(&$this, 'process_post'));
351
352 echo '</ol>';
353
354 wp_import_cleanup($this->id);
355 do_action('import_done', 'wordpress');
356
357 echo '<h3>'.sprintf(__('All done.').' <a href="%s">'.__('Have fun!').'</a>', get_option('home')).'</h3>';
358 }
359
360 function process_post($post) {
361 global $wpdb;
362
363 $post_ID = (int) $this->get_tag( $post, 'wp:post_id' );
364 if ( $post_ID && !empty($this->post_ids_processed[$post_ID]) ) // Processed already
365 return 0;
366
367 set_time_limit( 60 );
368
369 // There are only ever one of these
370 $post_title = $this->get_tag( $post, 'title' );
371 $post_date = $this->get_tag( $post, 'wp:post_date' );
372 $post_date_gmt = $this->get_tag( $post, 'wp:post_date_gmt' );
373 $comment_status = $this->get_tag( $post, 'wp:comment_status' );
374 $ping_status = $this->get_tag( $post, 'wp:ping_status' );
375 $post_status = $this->get_tag( $post, 'wp:status' );
376 $post_name = $this->get_tag( $post, 'wp:post_name' );
377 $post_parent = $this->get_tag( $post, 'wp:post_parent' );
378 $menu_order = $this->get_tag( $post, 'wp:menu_order' );
379 $post_type = $this->get_tag( $post, 'wp:post_type' );
380 $post_password = $this->get_tag( $post, 'wp:post_password' );
381 $guid = $this->get_tag( $post, 'guid' );
382 $post_author = $this->get_tag( $post, 'dc:creator' );
383
384 $post_excerpt = $this->get_tag( $post, 'excerpt:encoded' );
385 $post_excerpt = preg_replace_callback('|<(/?[A-Z]+)|', create_function('$match', 'return "<" . strtolower($match[1]);'), $post_excerpt);
386 $post_excerpt = str_replace('<br>', '<br />', $post_excerpt);
387 $post_excerpt = str_replace('<hr>', '<hr />', $post_excerpt);
388
389 $post_content = $this->get_tag( $post, 'content:encoded' );
390 $post_content = preg_replace_callback('|<(/?[A-Z]+)|', create_function('$match', 'return "<" . strtolower($match[1]);'), $post_content);
391 $post_content = str_replace('<br>', '<br />', $post_content);
392 $post_content = str_replace('<hr>', '<hr />', $post_content);
393
394 preg_match_all('|<category domain="tag">(.*?)</category>|is', $post, $tags);
395 $tags = $tags[1];
396
397 $tag_index = 0;
398 foreach ($tags as $tag) {
399 $tags[$tag_index] = $wpdb->escape($this->unhtmlentities(str_replace(array ('<![CDATA[', ']]>'), '', $tag)));
400 $tag_index++;
401 }
402
403 preg_match_all('|<category>(.*?)</category>|is', $post, $categories);
404 $categories = $categories[1];
405
406 $cat_index = 0;
407 foreach ($categories as $category) {
408 $categories[$cat_index] = $wpdb->escape($this->unhtmlentities(str_replace(array ('<![CDATA[', ']]>'), '', $category)));
409 $cat_index++;
410 }
411
412 $post_exists = post_exists($post_title, '', $post_date);
413
414 if ( $post_exists ) {
415 echo '<li>';
416 printf(__('Post <em>%s</em> already exists.'), stripslashes($post_title));
417 $comment_post_ID = $post_id = $post_exists;
418 } else {
419
420 // If it has parent, process parent first.
421 $post_parent = (int) $post_parent;
422 if ($post_parent) {
423 // if we already know the parent, map it to the local ID
424 if ( $parent = $this->post_ids_processed[$post_parent] ) {
425 $post_parent = $parent; // new ID of the parent
426 }
427 else {
428 // record the parent for later
429 $this->orphans[intval($post_ID)] = $post_parent;
430 }
431 }
432
433 echo '<li>';
434
435 $post_author = $this->checkauthor($post_author); //just so that if a post already exists, new users are not created by checkauthor
436
437 $postdata = compact('post_author', 'post_date', 'post_date_gmt', 'post_content', 'post_excerpt', 'post_title', 'post_status', 'post_name', 'comment_status', 'ping_status', 'guid', 'post_parent', 'menu_order', 'post_type', 'post_password');
438 $postdata['import_id'] = $post_ID;
439 if ($post_type == 'attachment') {
440 $remote_url = $this->get_tag( $post, 'wp:attachment_url' );
441 if ( !$remote_url )
442 $remote_url = $guid;
443
444 $comment_post_ID = $post_id = $this->process_attachment($postdata, $remote_url);
445 if ( !$post_id or is_wp_error($post_id) )
446 return $post_id;
447 }
448 else {
449 printf(__('Importing post <em>%s</em>...'), stripslashes($post_title));
450 $comment_post_ID = $post_id = wp_insert_post($postdata);
451 }
452
453 if ( is_wp_error( $post_id ) )
454 return $post_id;
455
456 // Memorize old and new ID.
457 if ( $post_id && $post_ID ) {
458 $this->post_ids_processed[intval($post_ID)] = intval($post_id);
459 }
460
461 // Add categories.
462 if (count($categories) > 0) {
463 $post_cats = array();
464 foreach ($categories as $category) {
465 if ( '' == $category )
466 continue;
467 $slug = sanitize_term_field('slug', $category, 0, 'category', 'db');
468 $cat = get_term_by('slug', $slug, 'category');
469 $cat_ID = 0;
470 if ( ! empty($cat) )
471 $cat_ID = $cat->term_id;
472 if ($cat_ID == 0) {
473 $category = $wpdb->escape($category);
474 $cat_ID = wp_insert_category(array('cat_name' => $category));
475 if ( is_wp_error($cat_ID) )
476 continue;
477 }
478 $post_cats[] = $cat_ID;
479 }
480 wp_set_post_categories($post_id, $post_cats);
481 }
482
483 // Add tags.
484 if (count($tags) > 0) {
485 $post_tags = array();
486 foreach ($tags as $tag) {
487 if ( '' == $tag )
488 continue;
489 $slug = sanitize_term_field('slug', $tag, 0, 'post_tag', 'db');
490 $tag_obj = get_term_by('slug', $slug, 'post_tag');
491 $tag_id = 0;
492 if ( ! empty($tag_obj) )
493 $tag_id = $tag_obj->term_id;
494 if ( $tag_id == 0 ) {
495 $tag = $wpdb->escape($tag);
496 $tag_id = wp_insert_term($tag, 'post_tag');
497 if ( is_wp_error($tag_id) )
498 continue;
499 $tag_id = $tag_id['term_id'];
500 }
501 $post_tags[] = intval($tag_id);
502 }
503 wp_set_post_tags($post_id, $post_tags);
504 }
505 }
506
507 // Now for comments
508 preg_match_all('|<wp:comment>(.*?)</wp:comment>|is', $post, $comments);
509 $comments = $comments[1];
510 $num_comments = 0;
511 if ( $comments) { foreach ($comments as $comment) {
512 $comment_author = $this->get_tag( $comment, 'wp:comment_author');
513 $comment_author_email = $this->get_tag( $comment, 'wp:comment_author_email');
514 $comment_author_IP = $this->get_tag( $comment, 'wp:comment_author_IP');
515 $comment_author_url = $this->get_tag( $comment, 'wp:comment_author_url');
516 $comment_date = $this->get_tag( $comment, 'wp:comment_date');
517 $comment_date_gmt = $this->get_tag( $comment, 'wp:comment_date_gmt');
518 $comment_content = $this->get_tag( $comment, 'wp:comment_content');
519 $comment_approved = $this->get_tag( $comment, 'wp:comment_approved');
520 $comment_type = $this->get_tag( $comment, 'wp:comment_type');
521 $comment_parent = $this->get_tag( $comment, 'wp:comment_parent');
522
523 // if this is a new post we can skip the comment_exists() check
524 if ( !$post_exists || !comment_exists($comment_author, $comment_date) ) {
525 $commentdata = compact('comment_post_ID', 'comment_author', 'comment_author_url', 'comment_author_email', 'comment_author_IP', 'comment_date', 'comment_date_gmt', 'comment_content', 'comment_approved', 'comment_type', 'comment_parent');
526 wp_insert_comment($commentdata);
527 $num_comments++;
528 }
529 } }
530
531 if ( $num_comments )
532 printf(' '._n('(%s comment)', '(%s comments)', $num_comments), $num_comments);
533
534 // Now for post meta
535 preg_match_all('|<wp:postmeta>(.*?)</wp:postmeta>|is', $post, $postmeta);
536 $postmeta = $postmeta[1];
537 if ( $postmeta) { foreach ($postmeta as $p) {
538 $key = $this->get_tag( $p, 'wp:meta_key' );
539 $value = $this->get_tag( $p, 'wp:meta_value' );
540 $value = stripslashes($value); // add_post_meta() will escape.
541
542 $this->process_post_meta($post_id, $key, $value);
543
544 } }
545
546 do_action('import_post_added', $post_id);
547 print "</li>\n";
548 }
549
550 function process_post_meta($post_id, $key, $value) {
551 // the filter can return false to skip a particular metadata key
552 $_key = apply_filters('import_post_meta_key', $key);
553 if ( $_key ) {
554 add_post_meta( $post_id, $_key, $value );
555 do_action('import_post_meta', $post_id, $_key, $value);
556 }
557 }
558
559 function process_attachment($postdata, $remote_url) {
560 if ($this->fetch_attachments and $remote_url) {
561 printf( __('Importing attachment <em>%s</em>... '), htmlspecialchars($remote_url) );
562
563 // If the URL is absolute, but does not contain http, upload it assuming the base_site_url variable
564 if ( preg_match('/^\/[\w\W]+$/', $remote_url) )
565 $remote_url = rtrim($this->base_url,'/').$remote_url;
566
567 $upload = $this->fetch_remote_file($postdata, $remote_url);
568 if ( is_wp_error($upload) ) {
569 printf( __('Remote file error: %s'), htmlspecialchars($upload->get_error_message()) );
570 return $upload;
571 }
572 else {
573 print '('.size_format(filesize($upload['file'])).')';
574 }
575
576 if ( $info = wp_check_filetype($upload['file']) ) {
577 $postdata['post_mime_type'] = $info['type'];
578 }
579 else {
580 print __('Invalid file type');
581 return;
582 }
583
584 $postdata['guid'] = $upload['url'];
585
586 // as per wp-admin/includes/upload.php
587 $post_id = wp_insert_attachment($postdata, $upload['file']);
588 wp_update_attachment_metadata( $post_id, wp_generate_attachment_metadata( $post_id, $upload['file'] ) );
589
590 // remap the thumbnail url. this isn't perfect because we're just guessing the original url.
591 if ( preg_match('@^image/@', $info['type']) && $thumb_url = wp_get_attachment_thumb_url($post_id) ) {
592 $parts = pathinfo($remote_url);
593 $ext = $parts['extension'];
594 $name = basename($parts['basename'], ".{$ext}");
595 $this->url_remap[$parts['dirname'] . '/' . $name . '.thumbnail.' . $ext] = $thumb_url;
596 }
597
598 return $post_id;
599 }
600 else {
601 printf( __('Skipping attachment <em>%s</em>'), htmlspecialchars($remote_url) );
602 }
603 }
604
605 function fetch_remote_file($post, $url) {
606 $upload = wp_upload_dir($post['post_date']);
607
608 // extract the file name and extension from the url
609 $file_name = basename($url);
610
611 // get placeholder file in the upload dir with a unique sanitized filename
612 $upload = wp_upload_bits( $file_name, 0, '', $post['post_date']);
613 if ( $upload['error'] ) {
614 echo $upload['error'];
615 return new WP_Error( 'upload_dir_error', $upload['error'] );
616 }
617
618 // fetch the remote url and write it to the placeholder file
619 $headers = wp_get_http($url, $upload['file']);
620
621 //Request failed
622 if ( ! $headers ) {
623 @unlink($upload['file']);
624 return new WP_Error( 'import_file_error', __('Remote server did not respond') );
625 }
626
627 // make sure the fetch was successful
628 if ( $headers['response'] != '200' ) {
629 @unlink($upload['file']);
630 return new WP_Error( 'import_file_error', sprintf(__('Remote file returned error response %1$d %2$s'), $headers['response'], get_status_header_desc($headers['response']) ) );
631 }
632 elseif ( isset($headers['content-length']) && filesize($upload['file']) != $headers['content-length'] ) {
633 @unlink($upload['file']);
634 return new WP_Error( 'import_file_error', __('Remote file is incorrect size') );
635 }
636
637 $max_size = $this->max_attachment_size();
638 if ( !empty($max_size) and filesize($upload['file']) > $max_size ) {
639 @unlink($upload['file']);
640 return new WP_Error( 'import_file_error', sprintf(__('Remote file is too large, limit is %s', size_format($max_size))) );
641 }
642
643 // keep track of the old and new urls so we can substitute them later
644 $this->url_remap[$url] = $upload['url'];
645 // if the remote url is redirected somewhere else, keep track of the destination too
646 if ( $headers['x-final-location'] != $url )
647 $this->url_remap[$headers['x-final-location']] = $upload['url'];
648
649 return $upload;
650
651 }
652
653 // sort by strlen, longest string first
654 function cmpr_strlen($a, $b) {
655 return strlen($b) - strlen($a);
656 }
657
658 // update url references in post bodies to point to the new local files
659 function backfill_attachment_urls() {
660
661 // make sure we do the longest urls first, in case one is a substring of another
662 uksort($this->url_remap, array(&$this, 'cmpr_strlen'));
663
664 global $wpdb;
665 foreach ($this->url_remap as $from_url => $to_url) {
666 // remap urls in post_content
667 $wpdb->query( $wpdb->prepare("UPDATE {$wpdb->posts} SET post_content = REPLACE(post_content, '%s', '%s')", $from_url, $to_url) );
668 // remap enclosure urls
669 $result = $wpdb->query( $wpdb->prepare("UPDATE {$wpdb->postmeta} SET meta_value = REPLACE(meta_value, '%s', '%s') WHERE meta_key='enclosure'", $from_url, $to_url) );
670 }
671 }
672
673 // update the post_parent of orphans now that we know the local id's of all parents
674 function backfill_parents() {
675 global $wpdb;
676
677 foreach ($this->orphans as $child_id => $parent_id) {
678 $local_child_id = $this->post_ids_processed[$child_id];
679 $local_parent_id = $this->post_ids_processed[$parent_id];
680 if ($local_child_id and $local_parent_id) {
681 $wpdb->query( $wpdb->prepare("UPDATE {$wpdb->posts} SET post_parent = %d WHERE ID = %d", $local_parent_id, $local_child_id));
682 }
683 }
684 }
685
686 function is_valid_meta_key($key) {
687 // skip _wp_attached_file metadata since we'll regenerate it from scratch
688 if ( $key == '_wp_attached_file' )
689 return false;
690 return $key;
691 }
692
693 // give the user the option of creating new users to represent authors in the import file?
694 function allow_create_users() {
695 return apply_filters('import_allow_create_users', true);
696 }
697
698 // give the user the option of downloading and importing attached files
699 function allow_fetch_attachments() {
700 return apply_filters('import_allow_fetch_attachments', true);
701 }
702
703 function max_attachment_size() {
704 // can be overridden with a filter - 0 means no limit
705 return apply_filters('import_attachment_size_limit', 0);
706 }
707
708 function import_start() {
709 wp_defer_term_counting(true);
710 wp_defer_comment_counting(true);
711 do_action('import_start');
712 }
713
714 function import_end() {
715 do_action('import_end');
716
717 // clear the caches after backfilling
718 foreach ($this->post_ids_processed as $post_id)
719 clean_post_cache($post_id);
720
721 wp_defer_term_counting(false);
722 wp_defer_comment_counting(false);
723 }
724
725 function import($id, $fetch_attachments = false) {
726 $this->id = (int) $id;
727 $this->fetch_attachments = ($this->allow_fetch_attachments() && (bool) $fetch_attachments);
728
729 add_filter('import_post_meta_key', array($this, 'is_valid_meta_key'));
730 $file = get_attached_file($this->id);
731 $this->import_file($file);
732 }
733
734 function import_file($file) {
735 $this->file = $file;
736
737 $this->import_start();
738 $this->get_authors_from_post();
739 wp_suspend_cache_invalidation(true);
740 $this->get_entries();
741 $this->process_categories();
742 $this->process_tags();
743 $result = $this->process_posts();
744 wp_suspend_cache_invalidation(false);
745 $this->backfill_parents();
746 $this->backfill_attachment_urls();
747 $this->import_end();
748
749 if ( is_wp_error( $result ) )
750 return $result;
751 }
752
753 function handle_upload() {
754 $file = wp_import_handle_upload();
755 if ( isset($file['error']) ) {
756 echo '<p>'.__('Sorry, there has been an error.').'</p>';
757 echo '<p><strong>' . $file['error'] . '</strong></p>';
758 return false;
759 }
760 $this->file = $file['file'];
761 $this->id = (int) $file['id'];
762 return true;
763 }
764
765 function dispatch() {
766 if (empty ($_GET['step']))
767 $step = 0;
768 else
769 $step = (int) $_GET['step'];
770
771 $this->header();
772 switch ($step) {
773 case 0 :
774 $this->greet();
775 break;
776 case 1 :
777 check_admin_referer('import-upload');
778 if ( $this->handle_upload() )
779 $this->select_authors();
780 break;
781 case 2:
782 check_admin_referer('import-wordpress');
783 $result = $this->import( $_GET['id'], $_POST['attachments'] );
784 if ( is_wp_error( $result ) )
785 echo $result->get_error_message();
786 break;
787 }
788 $this->footer();
789 }
790
791 function WP_Import() {
792 // Nothing.
793 }
794}
795
796/**
797 * Register WordPress Importer
798 *
799 * @since unknown
800 * @var WP_Import
801 * @name $wp_import
802 */
803$wp_import = new WP_Import();
804
805register_importer('wordpress', 'WordPress', __('Import <strong>posts, pages, comments, custom fields, categories, and tags</strong> from a WordPress export file.'), array ($wp_import, 'dispatch'));
806
807?>
Note: See TracBrowser for help on using the repository browser.