WP_Import::process_posts PHP Method

        function process_posts()
        {
            $this->posts = apply_filters('wp_import_posts', $this->posts);
            foreach ($this->posts as $post) {
                $post = apply_filters('wp_import_post_data_raw', $post);
                if (!post_type_exists($post['post_type'])) {
                    printf(__('Failed to import “%s”: Invalid post type %s', 'wordpress-importer'), esc_html($post['post_title']), esc_html($post['post_type']));
                    echo '<br />';
                    do_action('wp_import_post_exists', $post);
                    continue;
                }
                if (isset($this->processed_posts[$post['post_id']]) && !empty($post['post_id'])) {
                    continue;
                }
                if ($post['status'] == 'auto-draft') {
                    continue;
                }
                if ('nav_menu_item' == $post['post_type']) {
                    $this->process_menu_item($post);
                    continue;
                }
                $post_type_object = get_post_type_object($post['post_type']);
                $post_exists = post_exists($post['post_title'], '', $post['post_date']);
                if ($post_exists && get_post_type($post_exists) == $post['post_type']) {
                    printf(__('%s &#8220;%s&#8221; already exists.', 'wordpress-importer'), $post_type_object->labels->singular_name, esc_html($post['post_title']));
                    echo '<br />';
                    $comment_post_ID = $post_id = $post_exists;
                } else {
                    $post_parent = (int) $post['post_parent'];
                    if ($post_parent) {
                        // if we already know the parent, map it to the new local ID
                        if (isset($this->processed_posts[$post_parent])) {
                            $post_parent = $this->processed_posts[$post_parent];
                            // otherwise record the parent for later
                        } else {
                            $this->post_orphans[intval($post['post_id'])] = $post_parent;
                            $post_parent = 0;
                        }
                    }
                    // map the post author
                    $author = sanitize_user($post['post_author'], true);
                    if (isset($this->author_mapping[$author])) {
                        $author = $this->author_mapping[$author];
                    } else {
                        $author = (int) get_current_user_id();
                    }
                    $postdata = array('import_id' => $post['post_id'], 'post_author' => $author, 'post_date' => $post['post_date'], 'post_date_gmt' => $post['post_date_gmt'], 'post_content' => $post['post_content'], 'post_excerpt' => $post['post_excerpt'], 'post_title' => $post['post_title'], 'post_status' => $post['status'], 'post_name' => $post['post_name'], 'comment_status' => $post['comment_status'], 'ping_status' => $post['ping_status'], 'guid' => $post['guid'], 'post_parent' => $post_parent, 'menu_order' => $post['menu_order'], 'post_type' => $post['post_type'], 'post_password' => $post['post_password']);
                    $original_post_ID = $post['post_id'];
                    $postdata = apply_filters('wp_import_post_data_processed', $postdata, $post);
                    if ('attachment' == $postdata['post_type']) {
                        $remote_url = !empty($post['attachment_url']) ? $post['attachment_url'] : $post['guid'];
                        // try to use _wp_attached file for upload folder placement to ensure the same location as the export site
                        // e.g. location is 2003/05/image.jpg but the attachment post_date is 2010/09, see media_handle_upload()
                        $postdata['upload_date'] = $post['post_date'];
                        if (isset($post['postmeta'])) {
                            foreach ($post['postmeta'] as $meta) {
                                if ($meta['key'] == '_wp_attached_file') {
                                    if (preg_match('%^[0-9]{4}/[0-9]{2}%', $meta['value'], $matches)) {
                                        $postdata['upload_date'] = $matches[0];
                                    }
                                    break;
                                }
                            }
                        }
                        $comment_post_ID = $post_id = $this->process_attachment($postdata, $remote_url);
                    } else {
                        $comment_post_ID = $post_id = wp_insert_post($postdata, true);
                        do_action('wp_import_insert_post', $post_id, $original_post_ID, $postdata, $post);
                    }
                    if (is_wp_error($post_id)) {
                        printf(__('Failed to import %s &#8220;%s&#8221;', 'wordpress-importer'), $post_type_object->labels->singular_name, esc_html($post['post_title']));
                        if (defined('IMPORT_DEBUG') && IMPORT_DEBUG) {
                            echo ': ' . $post_id->get_error_message();
                        }
                        echo '<br />';
                        continue;
                    }
                    if ($post['is_sticky'] == 1) {
                        stick_post($post_id);
                    }
                }
                // map pre-import ID to local ID
                $this->processed_posts[intval($post['post_id'])] = (int) $post_id;
                if (!isset($post['terms'])) {
                    $post['terms'] = array();
                }
                $post['terms'] = apply_filters('wp_import_post_terms', $post['terms'], $post_id, $post);
                // add categories, tags and other terms
                if (!empty($post['terms'])) {
                    $terms_to_set = array();
                    foreach ($post['terms'] as $term) {
                        // back compat with WXR 1.0 map 'tag' to 'post_tag'
                        $taxonomy = 'tag' == $term['domain'] ? 'post_tag' : $term['domain'];
                        $term_exists = term_exists($term['slug'], $taxonomy);
                        $term_id = is_array($term_exists) ? $term_exists['term_id'] : $term_exists;
                        if (!$term_id) {
                            $t = wp_insert_term($term['name'], $taxonomy, array('slug' => $term['slug']));
                            if (!is_wp_error($t)) {
                                $term_id = $t['term_id'];
                                do_action('wp_import_insert_term', $t, $term, $post_id, $post);
                            } else {
                                printf(__('Failed to import %s %s', 'wordpress-importer'), esc_html($taxonomy), esc_html($term['name']));
                                if (defined('IMPORT_DEBUG') && IMPORT_DEBUG) {
                                    echo ': ' . $t->get_error_message();
                                }
                                echo '<br />';
                                do_action('wp_import_insert_term_failed', $t, $term, $post_id, $post);
                                continue;
                            }
                        }
                        $terms_to_set[$taxonomy][] = intval($term_id);
                    }
                    foreach ($terms_to_set as $tax => $ids) {
                        $tt_ids = wp_set_post_terms($post_id, $ids, $tax);
                        do_action('wp_import_set_post_terms', $tt_ids, $ids, $tax, $post_id, $post);
                    }
                    unset($post['terms'], $terms_to_set);
                }
                if (!isset($post['comments'])) {
                    $post['comments'] = array();
                }
                $post['comments'] = apply_filters('wp_import_post_comments', $post['comments'], $post_id, $post);
                // add/update comments
                if (!empty($post['comments'])) {
                    $num_comments = 0;
                    $inserted_comments = array();
                    foreach ($post['comments'] as $comment) {
                        $comment_id = $comment['comment_id'];
                        $newcomments[$comment_id]['comment_post_ID'] = $comment_post_ID;
                        $newcomments[$comment_id]['comment_author'] = $comment['comment_author'];
                        $newcomments[$comment_id]['comment_author_email'] = $comment['comment_author_email'];
                        $newcomments[$comment_id]['comment_author_IP'] = $comment['comment_author_IP'];
                        $newcomments[$comment_id]['comment_author_url'] = $comment['comment_author_url'];
                        $newcomments[$comment_id]['comment_date'] = $comment['comment_date'];
                        $newcomments[$comment_id]['comment_date_gmt'] = $comment['comment_date_gmt'];
                        $newcomments[$comment_id]['comment_content'] = $comment['comment_content'];
                        $newcomments[$comment_id]['comment_approved'] = $comment['comment_approved'];
                        $newcomments[$comment_id]['comment_type'] = $comment['comment_type'];
                        $newcomments[$comment_id]['comment_parent'] = $comment['comment_parent'];
                        $newcomments[$comment_id]['commentmeta'] = isset($comment['commentmeta']) ? $comment['commentmeta'] : array();
                        if (isset($this->processed_authors[$comment['comment_user_id']])) {
                            $newcomments[$comment_id]['user_id'] = $this->processed_authors[$comment['comment_user_id']];
                        }
                    }
                    ksort($newcomments);
                    foreach ($newcomments as $key => $comment) {
                        // if this is a new post we can skip the comment_exists() check
                        if (!$post_exists || !comment_exists($comment['comment_author'], $comment['comment_date'])) {
                            if (isset($inserted_comments[$comment['comment_parent']])) {
                                $comment['comment_parent'] = $inserted_comments[$comment['comment_parent']];
                            }
                            $comment = wp_filter_comment($comment);
                            $inserted_comments[$key] = wp_insert_comment($comment);
                            do_action('wp_import_insert_comment', $inserted_comments[$key], $comment, $comment_post_ID, $post);
                            foreach ($comment['commentmeta'] as $meta) {
                                $value = maybe_unserialize($meta['value']);
                                add_comment_meta($inserted_comments[$key], $meta['key'], $value);
                            }
                            $num_comments++;
                        }
                    }
                    unset($newcomments, $inserted_comments, $post['comments']);
                }
                if (!isset($post['postmeta'])) {
                    $post['postmeta'] = array();
                }
                $post['postmeta'] = apply_filters('wp_import_post_meta', $post['postmeta'], $post_id, $post);
                // add/update post meta
                if (!empty($post['postmeta'])) {
                    foreach ($post['postmeta'] as $meta) {
                        $key = apply_filters('import_post_meta_key', $meta['key'], $post_id, $post);
                        $value = false;
                        if ('_edit_last' == $key) {
                            if (isset($this->processed_authors[intval($meta['value'])])) {
                                $value = $this->processed_authors[intval($meta['value'])];
                            } else {
                                $key = false;
                            }
                        }
                        if ($key) {
                            // export gets meta straight from the DB so could have a serialized string
                            if (!$value) {
                                $value = maybe_unserialize($meta['value']);
                            }
                            add_post_meta($post_id, $key, $value);
                            do_action('import_post_meta', $post_id, $key, $value);
                            // if the post has a featured image, take note of this in case of remap
                            if ('_thumbnail_id' == $key) {
                                $this->featured_images[$post_id] = (int) $value;
                            }
                        }
                    }
                }
            }
            unset($this->posts);
        }

 function process_posts()
 {
     $menu_items = $mo_posts = array();
     // store this for future usage as parent function unset $this->posts
     foreach ($this->posts as $post) {
         if ('nav_menu_item' == $post['post_type']) {
             $menu_items[] = $post;
         }
         if (0 === strpos($post['post_title'], 'polylang_mo_')) {
             $mo_posts[] = $post;
         }
     }
     if (!empty($mo_posts)) {
         new PLL_MO();
     }
     // just to register the polylang_mo post type before processing posts
     parent::process_posts();
     global $polylang;
     $polylang->model->clean_languages_cache();
     // to update the posts count in (cached) languages list
     $this->remap_translations($this->post_translations, $this->processed_posts);
     unset($this->post_translations);
     // language switcher menu items
     foreach ($menu_items as $item) {
         foreach ($item['postmeta'] as $meta) {
             if ('_pll_menu_item' == $meta['key']) {
                 update_post_meta($this->processed_menu_items[$item['post_id']], '_pll_menu_item', maybe_unserialize($meta['value']));
             }
         }
     }
     // merge strings translations
     foreach ($mo_posts as $post) {
         $lang_id = (int) substr($post['post_title'], 12);
         if (!empty($this->processed_terms[$lang_id])) {
             if ($strings = unserialize($post['post_content'])) {
                 $mo = new PLL_MO();
                 $mo->import_from_db($this->processed_terms[$lang_id]);
                 foreach ($strings as $msg) {
                     $mo->add_entry_or_merge($mo->make_entry($msg[0], $msg[1]));
                 }
                 $mo->export_to_db($this->processed_terms[$lang_id]);
             }
         }
         // delete the now useless imported post
         wp_delete_post($this->processed_posts[$post['post_id']], true);
     }
 }