wpimport.plugin.php

<?php

namespace Habari;

if ( !defined( 'HABARI_PATH' ) ) { die( 'No direct access' ); }

	// define IMPORT_BATCH in your config.php to limit each batch of DB results
	if ( !defined('IMPORT_BATCH') ) {
		define('IMPORT_BATCH', 100);
	}

	/**
	 * Habari WPImporter class
	 * Used to import users, posts, and comments from a WP database
	 *
	 * @property array $suppoerted_importers The type of importers this plugin supports
	 * @property array $default_values The defaults to using when importing the database
	 * @property mixed $data The data associated to this block
	 * @property integer $id The id of this block in the database
	 *
	 */
	class WPImport extends Plugin implements Importer {

		private $supported_importers = array();

		private $default_values = array(
			'db_name' => '',
			'db_host' => 'localhost',
			'db_user' => '',
			'db_pass' => '',
			'db_prefix' => 'wp_',
			'category_import' => true,
			'import_index' => 0,
			'error' => '',
		);

		/**
		 * Prepare the plugin for functioning by initializing the supported importers array
		 *
		 */
		public function action_init ( ) {

			$this->supported_importers[] = _t('WordPress Database');

		}

		/**
		 * Filters the importer types add those this plugin provides
		 *
		 * @param array The names of the importer types available
		 *
		 * @return array The importer types array with those supplied by this plugin added
		 */
		public function filter_import_names ( $import_names ) {

			return array_merge( $import_names, $this->supported_importers );

		}

		/**
		 * Filters the inputs to create the output for the page
		 *
		 * @param string The current html for the page
		 * @param string The name of the importer being used
		 * @param integer The current import stage
		 * @param integer The current step of the import
		 *
		 * @return string The built html for the page
		 */
		public function filter_import_stage ( $stage_output, $import_name, $stage, $step ) {

			// only act on this filter if the import_name is one we handle
			if ( !in_array( $import_name, $this->supported_importers ) ) {
				// it's a filter, always return the output another plugin might have generated
				return $stage_output;
			}

			// the values we'll hand to each stage for processing
			$inputs = array();

			// validate input and figure out which stage we're at
			switch ( $stage ) {

				case 1:

					if ( isset( $_POST['wpimport'] ) ) {

						$inputs = $_POST->filter_keys( array( 'db_name', 'db_user', 'db_host', 'db_pass', 'db_prefix', 'category_import', 'import_index' ) );
						$inputs = $inputs->getArrayCopy();

						// try to connect to the db with the given values
						if ( $this->wp_connect( $inputs['db_host'], $inputs['db_name'], $inputs['db_user'], $inputs['db_pass'] ) ) {

							// we've got good connection info, bump to stage 2
							$stage = 2;

						}
						else {

							// add a warning to the stack
							$inputs['error'] = _t('Could not connect to the WordPress database using the values supplied. Please correct them and try again.');

						}

					}

					break;

			}


			// now dispatch the right stage
			switch ( $stage ) {

				case 1:
				default:
					$output = $this->stage1( $inputs, $import_name );
					break;

				case 2:
					$output = $this->stage2( $inputs );
					break;

			}

			// return the output for the importer to display
			return $output;

		}

		/**
		 * Builds and returns the form used to get the credentials for the databas
		 * being imported.
		 *
		 * @param array The variables the importer needs to function
		 * @param string The name of the importer being used
		 *
		 * @return string The output of the created form
		 */
		private function stage1 ( $inputs, $import_name ) {

			$inputs = array_merge( $this->default_values, $inputs );

			// if there is a error, display it
			if ( $inputs['error'] != '' ) {
				$error = '<p class="error">' . $inputs['error'] . '</p>';
			}
			else {
				// blank it out just so we can use the value in output
				$error = '';
			}

			$output = '<p>' . _t( 'Habari will attempt to import from a WordPress database.') . '</p>';
			$output .= $error;

			// get the FormUI form
			$form = $this->get_form( $inputs, $import_name );

			// append the output of the form
			$output .= $form->get();

//			$output .= '<div class="item clear">';
//			$output .= 	'<span class="pct25"><label for="db_name">' . _t( 'Database Name' ) . '</label></span><span class="pct40"><input type="text" name="db_name" id="db_name" value="' . $inputs['db_name'] . '"></span>';
//			$output .= '</div>';

//			$output .= '<div class="item clear">';
//			$output .= 	'<span class="pct25"><label for="db_host">' . _t( 'Database Host' ) . '</label></span><span class="pct40"><input type="text" name="db_host" id="db_host" value="' . $inputs['db_host'] . '"></span>';
//			$output .= '</div>';

//			$output .= '<div class="item clear">';
//			$output .= 	'<span class="pct25"><label for="db_user">' . _t( 'Database User' ) . '</label></span><span class="pct40"><input type="text" name="db_user" id="db_user" value="' . $inputs['db_user'] . '"></span>';
//			$output .= '</div>';

//			$output .= '<div class="item clear">';
//			$output .= 	'<span class="pct25"><label for="db_pass">' . _t( 'Database Password' ) . '</label></span><span class="pct40"><input type="text" name="db_pass" id="db_pass" value="' . $inputs['db_pass'] . '"></span>';
//			$output .= '</div>';

//			$output .= '<div class="item clear">';
//			$output .= 	'<span class="pct25"><label for="db_prefix">' . _t( 'Table Prefix' ) . '</label></span><span class="pct40"><input type="text" name="db_prefix" id="db_prefix" value="' . $inputs['db_prefix'] . '"></span>';
//			$output .= '</div>';

//			$output .= '<div class="item clear">';
//			$output .= 	'<span class="pct25"><label for="category_import">' . _t( 'Import Categories as Tags' ) . '</label></span><span class="pct40"><input type="checkbox" name="category_import" id="category_import" value="true" ' . ( ( $inputs['category_import'] == true ) ? 'checked="checked"' : '' ) . '></span>';
//			$output .= '</div>';

//			$output .= '<div class="item clear transparent">';
//			$output .=	'<input type="submit" class="button" name="wpimport" value="' . _t( 'Import' ) . '">';
//			$output .= '</div>';

			return $output;

		}

		/**
		 * Starts the import process using the database credentials input in stage one
		 * @param array The variables the importer needs to function
		 *
		 * @return string The javascript for the page and eny html for the page
		 */
		private function stage2 ( $inputs ) {

			// make sure we have all our default values
			$inputs = array_merge( $this->default_values, $inputs );

			// the first thing we import are users, so get that URL to kick off the ajax process
			$ajax_url = URL::get( 'auth_ajax', array( 'context' => 'wp_import_users' ) );

			// the variables we'll hand to the ajax call are all the input values
			$vars = $inputs;

			EventLog::log( _t('Starting import from "%s"', array( $inputs['db_name'] ) ) );

			$output = '<p>' . _t('Import in Progress') . '</p>';
			$output .= '<div id="import_progress">' . _t( 'Starting Import&hellip;' ) . '</div>';
			$output .= $this->get_ajax( $ajax_url, $vars );

			return $output;

		}

		/**
		 * Builds and returns the javascript for the current stage of the importer
		 * @param string The url that will be called with the script
		 * @param array The variables the importer needs to function
		 *
		 * @return string The built javascript
		 */
		private function get_ajax ( $url, $vars = array() ) {

			// generate the vars we'll use
			$ajax_vars = array();
			foreach ( $vars as $k => $v ) {
				$ajax_vars[] = $k . ': "' . $v . '"';
			}
			$ajax_vars = implode( ',', $ajax_vars );

			$output = <<<WP_IMPORT_AJAX
				<script type="text/javascript">
					$(document).ready( function() {
						$('#import_progress').load(
							"{$url}",
							{
								{$ajax_vars}
							}
						);
					} );
				</script>
WP_IMPORT_AJAX;

			return $output;

		}

		/**
		 * Builds and returns the form for the second stage of the importer
		 * @param array The list of options to set to open the database being imported
		 * @param string The name of the current importer
		 *
		 * @return FormUI The FormUI element used to chose the importer
		 */
		private function get_form ( $inputs, $import_name ) {
			// this isn't used right now because we can't use formui in an importer, there's already a form
			$form = new FormUI('wp_importer');

			$form->append( FormControlStatic::create( '<p>' . _t( 'Habari will attempt to import from a WordPress database.') . '</p>' ) );

			$form->append( FormControlLabel::wrap( _t( 'Database Name'),
				FormControlText::create( 'db_name' )->set_value( $inputs['db_name'] )
			));

			$form->append( FormControlLabel::wrap( _t( 'Database Host'),
				FormControlText::create( 'db_host' )->set_value( $inputs['db_host'] )
			));

			$form->append( FormControlLabel::wrap( _t( 'Database User'),
				FormControlText::create( 'db_user' )->set_value( $inputs['db_user'] )
			));

			$form->append( FormControlLabel::wrap( _t( 'Database Password'),
				FormControlText::create( 'db_pass' )->set_value( $inputs['db_pass'] )
			));

			$form->append( FormControlLabel::wrap( _t( 'Table Prefix'),
				FormControlText::create( 'db_prefix' )->set_value( $inputs['db_prefix'] )
			));

			$form->append( FormControlLabel::wrap( _t( 'Import Categories as Tags' ),
				FormControlCheckbox::create( 'category_import' )->set_value( $inputs['category_import'] )
			));

			$form->append( FormControlData::create( 'stage' )->set_value( 1 ) );

			$form->append( FormControlHidden::create( 'importer' )->set_value( $import_name ) );

			$form->append( FormControlSubmit::create( 'wpimport' )->set_caption( _t( 'Import' ) )->add_class( 'button' ) );

			$form->set_wrap_each( '<div>%s</div>' );

			return $form;

		}

		/**
		 * Connects to the WP database
		 *
		 * @param string The host the db is on
		 * @param string The name of the db
		 * @param string The user name for the db
		 * @param string The password for the db
		 *
		 * @return Habari\DatabaseConnection The PDO connection to the db
		 */
		private function wp_connect ( $db_host, $db_name, $db_user, $db_pass ) {

			// build the connection string, since we stupidly have to use it twice
			$connection_string = 'mysql:host=' . $db_host . ';dbname=' . $db_name;

			try {
				$wpdb = DatabaseConnection::ConnectionFactory( $connection_string );
				$wpdb->connect( $connection_string, $db_user, $db_pass );

				// @todo make sure preifx_* tables exist?

				return $wpdb;
			}
			catch ( \Exception $e ) {
				// just hide connection errors, it's enough that we errored out
				return false;
			}

		}

		/**
		 * Ajax handler to import users from the db.
		 * Echos the script for the next step of the import when done
		 *
		 */
		public function action_auth_ajax_wp_import_users ( ) {

			// get the values post'd in
			$inputs = $_POST->filter_keys( array( 'db_name', 'db_host', 'db_user', 'db_pass', 'db_prefix', 'category_import', 'import_index' ) );
			$inputs = $inputs->getArrayCopy();

			// make sure we have all our default values
			$inputs = array_merge( $this->default_values, $inputs );

			// get the wpdb
			$wpdb = $this->wp_connect( $inputs['db_host'], $inputs['db_name'], $inputs['db_user'], $inputs['db_pass'] );

			// if we couldn't connect, error out
			if ( !$wpdb ) {
				EventLog::log( _t( 'Failed to import from "%s"', array( $inputs['db_name'] ) ) );
				Session::error( _t( 'Failed to import from "%s"', array( $inputs['db_name'] ) ) );
				echo '<p>' . _t( 'Failed to connect using the given database connection details.' ) . '</p>';
			}

			// we connected just fine, let's get moving!

			// begin a transaction. if we error out at any point, we want to roll back to before import began
			DB::begin_transaction();

			// fetch all the users from the wordpress database
			$wp_users = $wpdb->get_results( 'select id, user_login, user_pass, user_email, user_url, display_name from ' . $inputs['db_prefix'] . 'users' );

			echo '<p>' . _t( 'Importing Users&hellip;' ) . '</p>';

			foreach ( $wp_users as $wp_user ) {

				// see if a user with this username already exists
				$user = User::get_by_name( $wp_user->user_login );

				if ( $user !== false ) {

					// if the user exists, save their old ID into an info attribute
					$user->info->wp_id = intval( $wp_user->id );

					// and update
					$user->update();

					echo '<p>' . _t( 'Associated imported user %1$s with existing user %2$s', array( $wp_user->user_login, $user->username ) ) . '</p>';

					EventLog::log( _t( 'Associated imported user %1$s with existing user %2$s', array( $wp_user->user_login, $user->username ) ) );

				}
				else {

					// no user exists, we need to create one
					try {

						$u = new User();
						$u->username = $wp_user->user_login;
						$u->email = $wp_user->user_email;

						// set their password so the user will be able to login. they're auto-added to the 'authenticated' ACL group
						$u->password = Utils::crypt( $wp_user->user_pass );

						$u->info->wp_id = intval( $wp_user->id );
						$u->info->displayname = $wp_user->display_name;

						if ( $wp_user->user_url != '' ) {
							$u->info->url = $wp_user->user_url;
						}

						// and save it
						$u->insert();

						echo '<p>' . _t( 'Created new user %1$s. Their old ID was %2$d.', array( $u->username, $wp_user->id ) ) . '</p>';

						EventLog::log( _t( 'Created new user %1$s. Their old ID was %2$d.', array( $u->username, $wp_user->id ) ) );

					}
					catch ( \Exception $e ) {

						// no idea why we might error out, but catch it if we do
						EventLog::log( $e->getMessage, 'err' );

						echo '<p class="error">' . _t( 'There was an error importing user %s. See the EventLog for the error message. ', array( $wp_user->user_login ) ) . '</p>';

						echo '<p>' . _t( 'Rolling back changes&hellip;' ) . '</p>';

						// rollback all changes before we return so the import hasn't changed anything yet
						DB::rollback();

						// and return so they don't get AJAX to send them on to the next step
						return false;

					}

				}

			}


			// if we've finished without an error, commit the import
			DB::commit();

			// get the next ajax url
			$ajax_url = URL::get( 'auth_ajax', array( 'context' => 'wp_import_posts' ) );

			// and spit out ajax to send them to the next step - posts!
			echo $this->get_ajax( $ajax_url, $inputs );

		}

		/**
		 * Ajax handler to import posts from the db.
		 * Echos the script for the next step of the import when done
		 *
		 */
		public function action_auth_ajax_wp_import_posts ( ) {

			// get the values post'd in
			$inputs = $_POST->filter_keys( array( 'db_name', 'db_host', 'db_user', 'db_pass', 'db_prefix', 'category_import', 'import_index' ) );
			$inputs = $inputs->getArrayCopy();

			// make sure we have all our default values
			$inputs = array_merge( $this->default_values, $inputs );

			// get the wpdb
			$wpdb = $this->wp_connect( $inputs['db_host'], $inputs['db_name'], $inputs['db_user'], $inputs['db_pass'] );

			// if we couldn't connect, error out
			if ( !$wpdb ) {
				EventLog::log( _t( 'Failed to import from "%s"', array( $inputs['db_name'] ) ) );
				Session::error( _t( 'Failed to import from "%s"', array( $inputs['db_name'] ) ) );
				echo '<p>' . _t( 'Failed to connect using the given database connection details.' ) . '</p>';
			}

			// we connected just fine, let's get moving!

			// begin a transaction. if we error out at any point, we want to roll back to before import began
			DB::begin_transaction();

			// fetch the number of posts from the wordpress database so we can batch things up
			$num_posts = $wpdb->get_value( 'select count(id) from ' . $inputs['db_prefix'] . 'posts' );

			// figure out the LIMIT we're at
			$min = $inputs['import_index'] * IMPORT_BATCH;
			$max = min( $min + IMPORT_BATCH, $num_posts );		// for display only


			echo '<p>' . _t( 'Importing posts %1$d - %2$d of %3$d.', array( $min, $max, $num_posts ) ) . '</p>';

			// get all the imported users so we can link old post authors to new post authors
			$users = DB::get_results( 'select user_id, value from {userinfo} where name = :name', array( ':name' => 'wp_id' ) );

			// create an easy user map of old ID -> new ID
			$user_map = array();
			foreach ( $users as $info ) {
				$user_map[ $info->value ] = $info->user_id;
			}

			// get all the post IDs we've imported so far to make sure we don't duplicate any
			$post_map = DB::get_column( 'select value from {postinfo} where name = :name', array( ':name' => 'wp_id' ) );



			// now we're ready to start importing posts
			$posts = $wpdb->get_results( 'select id, post_author, post_date, post_content, post_title, post_status, comment_status, post_name, post_modified, guid, post_type from ' . $inputs['db_prefix'] . 'posts order by id asc limit ' . $min . ', ' . IMPORT_BATCH );

			foreach ( $posts as $post ) {

				// if this post is already in the list we've imported, skip it
				if ( in_array( $post->id, $post_map ) ) {
					continue;
				}

				// set up the big taxonomy sql query
				// if this turns out to be incredibly slow we should refactor it into a big join, but they're all keys so it seems zippy enough for me
				$taxonomy_query = 'select name, slug from ' . $inputs['db_prefix'] . 'terms where term_id in ( select term_id from ' . $inputs['db_prefix'] . 'term_taxonomy where taxonomy = :taxonomy and term_taxonomy_id in ( select term_taxonomy_id from ' . $inputs['db_prefix'] . 'term_relationships where object_id = :object_id ) )';

				// get all the textual tag names for this post
				$tags = $wpdb->get_results( $taxonomy_query, array( ':taxonomy' => 'post_tag', ':object_id' => $post->id ) );

				// should we import categories as tags too?
				if ( $inputs['category_import'] ) {
					// then do the same as above for the category taxonomy
					$categories = $wpdb->get_results( $taxonomy_query, array( ':taxonomy' => 'category', ':object_id' => $post->id ) );
				}

				// create the new post
				$p = new Post( array(
					'title' => MultiByte::convert_encoding( $post->post_title ),
					'content' => MultiByte::convert_encoding( $post->post_content ),
					'user_id' => $user_map[ $post->post_author ],
					'pubdate' => DateTime::create( $post->post_date ),
					'updated' => DateTime::create( $post->post_modified ),
					'slug' => MultiByte::convert_encoding( $post->post_name ),
				) );

				// figure out the post type
				switch ( $post->post_type ) {

					case 'post':
						$p->content_type = Post::type( 'entry' );
						break;

					case 'page':
						$p->content_type = Post::type( 'page' );
						break;

					default:
						// we're not importing other types - continue 2 to break out of the switch and the loop and continue to the next post
						continue 2;

				}

				// figure out the post status
				switch ( $post->post_status ) {

					case 'publish':
						$p->status = Post::status( 'published' );
						break;

					case 'future':
						$p->status = Post::status( 'scheduled' );
						break;

					case 'pending':		// means pending-review, not pending as in scheduled
					case 'draft':
						$p->status = Post::status( 'draft' );
						break;

					default:
						// Post::status() returns false if it doesn't recognize the status type
						$status = Post::status( $post->post_status );		// store in a temp value because if you try and set ->status to an invalid value the Post class freaks

						if ( $status == false ) {
							// we're not importing statuses we don't recognize - continue 2 to break out of the switch and the loop and continue to the next post
							continue 2;
						}
						else {
							$p->status = $status;
						}

						break;

				}

				// if comments are closed, disable them on the new post
				if ( $post->comment_status == 'closed' ) {
					$p->info->comments_disabled = true;
				}

				// save the old post ID in info
				$p->info->wp_id = $post->id;

				// since we're not using it, save the old GUID too
				$p->info->wp_guid = $post->guid;


				// now that we've got all the pieces in place, save the post
				try {
					$p->insert();

					// now that the post is in the db we can add tags to it

					// first, if we want to import categories as tags, add them to the array
					if ( $inputs['category_import'] ) {
						$tags = array_merge( $tags, $categories );
					}

					// now for the tags!
					foreach ( $tags as $tag ) {

						// try to get the tag by slug, which is the key and therefore the most unique
						$t = Tags::get_by_slug( $tag->slug );

						// if we didn't get back a tag, create a new one
						if ( $t == false ) {
							$t = Tag::create( array(
								'term' => $tag->slug,
								'term_display' => $tag->name
							) );
						}

						// now that we have a tag (one way or the other), associate this post with it
						$t->associate( 'post', $p->id );

					}

				}
				catch ( \Exception $e ) {

					EventLog::log( $e->getMessage(), 'err' );

					echo '<p class="error">' . _t( 'There was an error importing post %s. See the EventLog for the error message.', array( $post->post_title ) );

					echo '<p>' . _t( 'Rolling back changes&hellip;' ) . '</p>';

					// rollback all changes before we return so the import hasn't changed anything yet
					DB::rollback();

					// and return so they don't get AJAX to send them on to the next step
					return false;

				}

			}


			// if we've finished without an error, commit the import
			DB::commit();

			if ( $max < $num_posts ) {

				// if there are more posts to import

				// get the next ajax url
				$ajax_url = URL::get( 'auth_ajax', array( 'context' => 'wp_import_posts' ) );

				// bump the import index by one so we get a new batch next time
				$inputs['import_index']++;


			}
			else {

				// move on to importing comments

				// get the next ajax url
				$ajax_url = URL::get( 'auth_ajax', array( 'context' => 'wp_import_comments' ) );

				// reset the import index so we start at the first comment
				$inputs['import_index'] = 0;

			}

			// and spit out ajax to send them to the next step - posts!
			echo $this->get_ajax( $ajax_url, $inputs );

		}

		/**
		 * Ajax handler to import comments from the db.
		 * Echos the script for the next step of the import when done
		 *
		 */
		public function action_auth_ajax_wp_import_comments ( ) {

			// get the values post'd in
			$inputs = $_POST->filter_keys( array( 'db_name', 'db_host', 'db_user', 'db_pass', 'db_prefix', 'category_import', 'import_index' ) );
			$inputs = $inputs->getArrayCopy();

			// make sure we have all our default values
			$inputs = array_merge( $this->default_values, $inputs );

			// get the wpdb
			$wpdb = $this->wp_connect( $inputs['db_host'], $inputs['db_name'], $inputs['db_user'], $inputs['db_pass'] );

			// if we couldn't connect, error out
			if ( !$wpdb ) {
				EventLog::log( _t( 'Failed to import from "%s"', array( $inputs['db_name'] ) ) );
				Session::error( _t( 'Failed to import from "%s"', array( $inputs['db_name'] ) ) );
				echo '<p>' . _t( 'Failed to connect using the given database connection details.' ) . '</p>';
			}

			// we connected just fine, let's get moving!

			// begin a transaction. if we error out at any point, we want to roll back to before import began
			DB::begin_transaction();

			// fetch the number of comments from the wordpress database so we can batch things up
			$num_comments = $wpdb->get_value( 'select count(comment_id) from ' . $inputs['db_prefix'] . 'comments' );

			// figure out the LIMIT we're at
			$min = $inputs['import_index'] * IMPORT_BATCH;
			$max = min( $min + IMPORT_BATCH, $num_comments );		// for display only


			echo '<p>' . _t( 'Importing comments %1$d - %2$d of %3$d.', array( $min, $max, $num_comments ) ) . '</p>';

			// get all the imported users so we can link old comment authors to new comment authors
			$users = DB::get_results( 'select user_id, value from {userinfo} where name = :name', array( ':name' => 'wp_id' ) );

			// create an easy user map of old ID -> new ID
			$user_map = array();
			foreach ( $users as $info ) {
				$user_map[ $info->value ] = $info->user_id;
			}

			// get all the imported posts so we can link old post IDs to new post IDs
			$posts = DB::get_results( 'select post_id, value from {postinfo} where name = :name', array( ':name' => 'wp_id' ) );

			// create an easy post map of old ID -> new ID
			$post_map = array();
			foreach ( $posts as $info ) {
				$post_map[ $info->value ] = $info->post_id;
			}

			// get all the comment IDs we've imported so far to make sure we don't duplicate any
			$comment_map = DB::get_column( 'select value from {commentinfo} where name = :name', array( ':name' => 'wp_id' ) );



			// now we're ready to start importing comments
			$comments = $wpdb->get_results( 'select comment_id, comment_post_id, comment_author, comment_author_email, comment_author_url, comment_author_ip, comment_date, comment_content, comment_karma, comment_approved, comment_agent, comment_type, comment_parent, user_id from ' . $inputs['db_prefix'] . 'comments order by comment_id asc limit ' . $min . ', ' . IMPORT_BATCH );

			foreach ( $comments as $comment ) {

				// if this post is already in the list we've imported, skip it
				if ( in_array( $comment->id, $comment_map ) ) {
					continue;
				}

				// if the post this comment belongs to is not in the list of imported posts, skip it
				if ( !isset( $post_map[ $comment->comment_post_id ] ) ) {
					continue;
				}

				// create the new comment
				$c = new Comment( array(
					'content' => MultiByte::convert_encoding( $comment->comment_content ),
					'name' => MultiByte::convert_encoding( $comment->comment_author ),
					'email' => MultiByte::convert_encoding( $comment->comment_author_email ),
					'url' => MultiByte::convert_encoding( $comment->comment_author_url ),
					'date' => DateTime::create( $comment->comment_date ),
					'post_id' => $post_map[ $comment->comment_post_id ],
				) );

				// figure out the comment type
				switch ( $comment->comment_type ) {

					case 'pingback':
						$c->type = Comment::type( 'pingback' );
						break;

					case 'trackback':
						$c->type = Comment::type( 'trackback' );
						break;

					default:
					case 'comment':
						$c->type = Comment::type( 'comment' );
						break;

				}

				// figure out the comment status
				switch ( $comment->comment_approved ) {

					case '1':
						$c->status = Comment::status( 'approved' );
						break;

					case '':
					case '0':
						$c->status = Comment::status( 'unapproved' );
						break;

					case 'spam':
						$c->status = Comment::status( 'spam' );
						break;

					default:
						// Comment::status() returns false if it doesn't recognize the status type
						$status = Comment::status( $comment->comment_status );		// store in a temp value because if you try and set ->status to an invalid value the Comment class freaks

						if ( $status == false ) {
							// we're not importing statuses we don't recognize - continue 2 to break out of the switch and the loop and continue to the next comment
							continue 2;
						}
						else {
							$c->status = $status;
						}

						break;

				}

				// save the old comment ID in info
				$c->info->wp_id = $comment->comment_id;

				// save the old post ID in info
				$c->info->wp_post_id = $comment->comment_post_id;

				// save the old comment karma - but only if it is something
				if ( $comment->comment_karma != '0' ) {
					$c->info->wp_karma = $comment->comment_karma;
				}

				// save the old comment user agent - but only if it is something
				if ( $comment->comment_agent != '' ) {
					$c->info->wp_agent = $comment->comment_agent;
				}


				// now that we've got all the pieces in place, save the comment
				try {
					$c->insert();
				}
				catch ( \Exception $e ) {

					EventLog::log( $e->getMessage(), 'err' );

					echo '<p class="error">' . _t( 'There was an error importing comment ID %d. See the EventLog for the error message.', array( $comment->comment_id ) );

					echo '<p>' . _t( 'Rolling back changes&hellip;' ) . '</p>';

					// rollback all changes before we return so the import hasn't changed anything yet
					DB::rollback();

					// and return so they don't get AJAX to send them on to the next step
					return false;

				}

			}


			// if we've finished without an error, commit the import
			DB::commit();

			if ( $max < $num_comments ) {

				// if there are more posts to import

				// get the next ajax url
				$ajax_url = URL::get( 'auth_ajax', array( 'context' => 'wp_import_comments' ) );

				// bump the import index by one so we get a new batch next time
				$inputs['import_index']++;


			}
			else {

				// display the completed message!

				EventLog::log( _t( 'Import completed from "%s"', array( $inputs['db_name'] ) ) );
				echo '<p>' . _t( 'Import is complete.' ) . '</p>';

				return;

			}

			// and spit out ajax to send them to the next step - posts!
			echo $this->get_ajax( $ajax_url, $inputs );

		}


	}

?>