iframe-proxy | Sunbelt Computer Software

738 lines (629 loc) · 23.3 KB
class Import_Command extends WP_CLI_Command {
	private $blog_users = [];
	public $processed_posts = [];
	 * Imports content from a given WXR file.
	 * Provides a command line interface to the WordPress Importer plugin, for
	 * performing data migrations.
	 * Use `define( 'IMPORT_DEBUG', true );` for more verbosity during importing.
	 * ## OPTIONS
	 * <file>...
	 * : Path to one or more valid WXR files for importing. Directories are also accepted.
	 * A URL to a WXR file is also accepted. Use '-' to import from STDIN.
	 * --authors=<authors>
	 * : How the author mapping should be handled. Options are 'create', 'mapping.csv', or 'skip'. The first will create any non-existent users from the WXR file. The second will read author mapping associations from a CSV, or create a CSV for editing if the file path doesn't exist. The CSV requires two columns, and a header row like "old_user_login,new_user_login". The last option will skip any author mapping.
	 * [--skip=<data-type>]
	 * : Skip importing specific data. Supported options are: 'attachment' and 'image_resize' (skip time-consuming thumbnail generation).
	 * [--rewrite_urls]
	 * : Change all imported URLs that currently link to the previous site so that they now link to this site
	 * Requires WordPress Importer version 0.9.1 or newer.
	 * [--importer=<importer>]
	 * : Use a custom importer class instead of the default WP_Import. The class must exist and be a subclass of WP_Import.
	 * [--source-dir=<dir>]
	 * : A local directory to search for attachment files before downloading them from their original URLs. When specified, the importer matches attachment filenames (by basename only) against files in this directory, and uses any local match instead of fetching the file over the network. Useful when attachment files are already available locally, e.g. from a previous site's uploads directory.
	 * ## EXAMPLES
	 *     # Import content from a WXR file
	 *     $ wp import example.wordpress.2016-06-21.xml --authors=create
	 *     Starting the import process...
	 *     Processing post #1 ("Hello world!") (post_type: post)
	 *     -- 1 of 1
	 *     -- Tue, 21 Jun 2016 05:31:12 +0000
	 *     -- Imported post as post_id #1
	 *     Success: Finished importing from 'example.wordpress.2016-06-21.xml' file.
	 *     # Import content from a WXR file via HTTP
	 *     $ wp import https://raw.githubusercontent.com/WordPress/theme-test-data/refs/heads/master/theme-preview.xml --authors=skip
	 *     Starting the import process...
	 *     Downloading 'https://raw.githubusercontent.com/WordPress/theme-test-data/refs/heads/master/theme-preview.xml'...
	 *     Success: Finished importing from 'https://raw.githubusercontent.com/WordPress/theme-test-data/refs/heads/master/theme-preview.xml' file.
	 *     # Import content from STDIN
	 *     $ wp export --stdout | wp import - --authors=skip
	 *     Starting the import process...
	 *     Success: Finished importing from 'STDIN' file.
	 *     # Import using locally available attachment files to avoid re-downloading
	 *     $ wp import export.xml --authors=skip --source-dir=/path/to/uploads
	 *     Starting the import process...
	 *     -- Using local file for 'https://example.com/wp-content/uploads/2024/01/image.jpg'.
	 *     Success: Finished importing from 'export.xml' file.
	 * @param array<string> $args Positional arguments.
	 * @param array{authors: 'create'|'mappings.csv'|'skip', skip?: string, rewrite_urls?: bool, importer?: string, 'source-dir'?: string} $assoc_args Associative arguments.
	public function __invoke( $args, $assoc_args ) {
		$defaults   = array(
			'authors'      => null,
			'skip'         => [],
			'rewrite_urls' => null,
			'importer'     => 'WP_Import',
			'source-dir'   => '',
		$assoc_args = wp_parse_args( $assoc_args, $defaults );
		if ( ! is_array( $assoc_args['skip'] ) ) {
			$assoc_args['skip'] = explode( ',', $assoc_args['skip'] );
		 * @var array{authors: 'create'|'mappings.csv'|'skip', skip: array<string>, rewrite_urls: bool, importer: class-string<WP_Import>, 'source-dir': string} $assoc_args
		$source_dir = $assoc_args['source-dir'];
		if ( $source_dir ) {
			if ( ! is_dir( $source_dir ) ) {
				WP_CLI::error( "The source directory '$source_dir' does not exist or is not a directory." );
			if ( ! is_readable( $source_dir ) ) {
				WP_CLI::error( "The source directory '$source_dir' is not readable." );
		$importer = $this->is_importer_available();
		if ( is_wp_error( $importer ) ) {
			WP_CLI::error( $importer );
		$importer_class = $assoc_args['importer'];
		if ( 'WP_Import' !== $importer_class ) {
			if ( ! class_exists( $importer_class, false ) ) {
				WP_CLI::error( "Importer class '$importer_class' does not exist." );
			if ( ! is_subclass_of( $importer_class, 'WP_Import' ) ) {
				WP_CLI::error( "Importer class '$importer_class' must be a subclass of WP_Import." );
		$this->add_wxr_filters();
		WP_CLI::log( 'Starting the import process...' );
		$new_args   = [];
		$temp_files = []; // Map of temp_file_path => original source (URL or 'STDIN')
		foreach ( $args as $arg ) {
			// Handle STDIN input
			if ( '-' === $arg ) {
				if ( ! \WP_CLI\Utils\has_stdin() ) {
					WP_CLI::warning( 'Unable to import from STDIN. No data provided.' );
					continue;
				$stdin_handle = fopen( 'php://stdin', 'rb' );
				if ( false === $stdin_handle ) {
					WP_CLI::warning( 'Unable to import from STDIN. Could not open STDIN stream.' );
					continue;
				$temp_file = wp_tempnam( 'wp-import-stdin' );
				if ( ! $temp_file ) {
					fclose( $stdin_handle );
					WP_CLI::warning( 'Unable to import from STDIN. Could not create temporary file.' );
					continue;
				$temp_handle = fopen( $temp_file, 'wb' );
				if ( false === $temp_handle ) {
					fclose( $stdin_handle );
					unlink( $temp_file );
					WP_CLI::warning( 'Unable to import from STDIN. Could not open temporary file for writing.' );
					continue;
				$bytes_copied = stream_copy_to_stream( $stdin_handle, $temp_handle );
				fclose( $stdin_handle );
				fclose( $temp_handle );
				if ( false === $bytes_copied || 0 === $bytes_copied ) {
					unlink( $temp_file );
					WP_CLI::warning( 'Unable to import from STDIN. No data provided.' );
					continue;
				$new_args[]               = $temp_file;
				$temp_files[ $temp_file ] = 'STDIN';
				continue;
			// Handle HTTP/HTTPS/FTP URLs
			$scheme = wp_parse_url( $arg, PHP_URL_SCHEME );
			if ( $scheme && in_array( strtolower( $scheme ), [ 'http', 'https', 'ftp', 'ftps' ], true ) ) {
				WP_CLI::log( "Downloading '{$arg}'..." );
				$temp_file = download_url( $arg );
				if ( is_wp_error( $temp_file ) ) {
					WP_CLI::warning( sprintf( "Unable to import from URL '%s'. %s", $arg, $temp_file->get_error_message() ) );
					continue;
				$new_args[]               = $temp_file;
				$temp_files[ $temp_file ] = $arg;
				continue;
			if ( is_dir( $arg ) ) {
				$dir   = WP_CLI\Path::trailingslashit( $arg );
				$files = glob( $dir . '*.wxr' );
				if ( ! empty( $files ) ) {
					$new_args = array_merge( $new_args, $files );
				$files = glob( $dir . '*.xml' );
				if ( ! empty( $files ) ) {
					$new_args = array_merge( $new_args, $files );
				if ( empty( $files ) ) {
					WP_CLI::warning( "No files found in the import directory '$arg'." );
			} else {
				if ( ! file_exists( $arg ) ) {
					WP_CLI::warning( "File '$arg' doesn't exist." );
					continue;
				if ( is_readable( $arg ) ) {
					$new_args[] = $arg;
					continue;
				WP_CLI::warning( "Cannot read file '$arg'." );
		if ( empty( $new_args ) ) {
			WP_CLI::error( 'Import failed due to missing or unreadable file/s.' );
		$args = $new_args;
		foreach ( $args as $file ) {
			$display_name = isset( $temp_files[ $file ] ) ? $temp_files[ $file ] : null;
			$ret          = $this->import_wxr( $file, $assoc_args, $display_name );
			if ( is_wp_error( $ret ) ) {
				$this->cleanup_temp_files( $temp_files );
				WP_CLI::error( $ret );
			} else {
				WP_CLI::log( '' ); // WXR import ends with HTML, so make sure message is on next line
				$source = null !== $display_name ? $display_name : $file;
				WP_CLI::success( "Finished importing from '$source' file." );
		$this->cleanup_temp_files( $temp_files );
	 * Imports a WXR file.
	 * @param string $file Path or URL to the WXR file being imported.
	 * @param array{authors: string, skip: array<string>, rewrite_urls: ?bool, importer: class-string<WP_Import>, 'source-dir': string} $args Arguments controlling the import behavior.
	 * @param string|null $display_name Optional display name for the source (e.g. URL or 'STDIN').
	private function import_wxr( $file, $args, $display_name = null ) {
		$source_dir = $args['source-dir'];
		if ( $source_dir ) {
			$source_dir_filter = $this->get_source_dir_filter( $source_dir );
			add_filter( 'pre_http_request', $source_dir_filter, 10, 3 );
		$importer_class = $args['importer'];
		/** @var WP_Import $wp_import */
		$wp_import                  = new $importer_class();
		$wp_import->processed_posts = $this->processed_posts;
		$import_data                = $wp_import->parse( $file );
		// Prepare the data to be used in process_author_mapping();
		$wp_import->get_authors_from_import( $import_data );
		// We no longer need the original data, so unset to avoid using excess
		// memory.
		unset( $import_data );
		 * @var array<object{user_email: string, user_login: string}> $author_data
		$author_data = [];
		foreach ( $wp_import->authors as $wxr_author ) {
			$author = new \stdClass();
			// Always in the WXR
			$author->user_login = $wxr_author['author_login'];
			// Should be in the WXR; no guarantees
			if ( isset( $wxr_author['author_email'] ) ) {
				$author->user_email = $wxr_author['author_email'];
			if ( isset( $wxr_author['author_display_name'] ) ) {
				$author->display_name = $wxr_author['author_display_name'];
			if ( isset( $wxr_author['author_first_name'] ) ) {
				$author->first_name = $wxr_author['author_first_name'];
			if ( isset( $wxr_author['author_last_name'] ) ) {
				$author->last_name = $wxr_author['author_last_name'];
			$author_data[] = $author;
		 * @var array<object{user_email: string, user_login: string}> $author_data
		// Build the author mapping
		$author_mapping = $this->process_author_mapping( $args['authors'], $author_data );
		if ( is_wp_error( $author_mapping ) ) {
			return $author_mapping;
		$author_in  = wp_list_pluck( $author_mapping, 'old_user_login' );
		$author_out = wp_list_pluck( $author_mapping, 'new_user_login' );
		unset( $author_mapping, $author_data );
		// $user_select needs to be an array of user IDs
		$user_select         = [];
		$invalid_user_select = [];
		foreach ( $author_out as $author_login ) {
			$user = get_user_by( 'login', $author_login );
			if ( $user ) {
				$user_select[] = $user->ID;
			} else {
				$invalid_user_select[] = $author_login;
		if ( ! empty( $invalid_user_select ) ) {
			return new WP_Error( 'invalid-author-mapping', sprintf( 'These user_logins are invalid: %s', implode( ',', $invalid_user_select ) ) );
		unset( $author_out );
		// Drive the import
		$wp_import->fetch_attachments = ! in_array( 'attachment', $args['skip'], true );
		$_GET  = array(
			'import' => 'wordpress',
			'step'   => 2,
		$_POST = array(
			'imported_authors'  => $author_in,
			'user_map'          => $user_select,
			'fetch_attachments' => $wp_import->fetch_attachments,
		if ( in_array( 'image_resize', $args['skip'], true ) ) {
			add_filter( 'intermediate_image_sizes_advanced', array( $this, 'filter_set_image_sizes' ) );
		$GLOBALS['wpcli_import_current_file'] = null !== $display_name ? basename( $display_name ) : basename( $file );
		$reflection          = new \ReflectionMethod( $wp_import, 'import' );
		$number_of_arguments = $reflection->getNumberOfParameters();
		if ( null !== $args['rewrite_urls'] && $number_of_arguments < 2 ) {
			WP_CLI::error( 'URL rewriting requires WordPress Importer version 0.9.1 or newer.' );
		if ( $number_of_arguments > 1 ) {
			$wp_import->import(
					'rewrite_urls' => $args['rewrite_urls'],
			$wp_import->import( $file );
		$this->processed_posts += $wp_import->processed_posts;
		if ( $source_dir && isset( $source_dir_filter ) ) {
			remove_filter( 'pre_http_request', $source_dir_filter, 10 );
		return true;
	 * Builds the pre_http_request filter callback for serving attachment files from a local source directory.
	 * @param string $source_dir Path to the local directory to search for attachment files.
	 * @return callable
	private function get_source_dir_filter( $source_dir ) {
		return function ( $pre, $args, $url ) use ( $source_dir ) {
			if ( ! isset( $args['stream'], $args['filename'] ) || ! $args['stream'] || ! $args['filename'] ) {
				return $pre;
			$url_path = wp_parse_url( $url, PHP_URL_PATH );
			if ( ! is_string( $url_path ) || '' === $url_path ) {
				return $pre;
			$decoded_url_path = rawurldecode( $url_path );
			// basename() can return '' for paths like '/', so guard against that.
			$file_name = basename( $decoded_url_path );
			if ( ! $file_name || '.' === $file_name || '..' === $file_name ) {
				return $pre;
			$local_file = rtrim( $source_dir, '/\\' ) . DIRECTORY_SEPARATOR . $file_name;
			if ( ! file_exists( $local_file ) || ! is_readable( $local_file ) ) {
				return $pre;
			// phpcs:ignore WordPress.WP.AlternativeFunctions.file_system_operations_copy
			if ( ! copy( $local_file, $args['filename'] ) ) {
				return $pre;
			WP_CLI::log( "-- Using local file for '$url'." );
			return array(
				'headers'  => array( 'x-local-source' => 'true' ),
				'body'     => '',
				'response' => array(
					'code'    => 200,
					'message' => 'OK',
				'cookies'  => array(),
				'filename' => $args['filename'],
	public function filter_set_image_sizes( $sizes ) {
		// Return null here to prevent the core image resizing logic from running.
		return null;
	 * Removes temporary files created during import.
	 * @param array<string, string> $temp_files Map of temp_file_path => original source.
	private function cleanup_temp_files( array $temp_files ) {
		foreach ( $temp_files as $temp_file => $_ ) {
			if ( file_exists( $temp_file ) ) {
				// phpcs:ignore WordPress.WP.AlternativeFunctions.unlink_unlink
				unlink( $temp_file );
	 * Defines useful verbosity filters for the WXR importer.
	private function add_wxr_filters() {
		add_filter(
			'wp_import_posts',
			function ( $posts ) {
				global $wpcli_import_counts;
				$wpcli_import_counts['current_post'] = 0;
				$wpcli_import_counts['total_posts']  = count( $posts );
				return $posts;
		add_filter(
			'wp_import_post_comments',
			function ( $comments ) {
				global $wpcli_import_counts;
				$wpcli_import_counts['current_comment'] = 0;
				$wpcli_import_counts['total_comments']  = count( $comments );
				return $comments;
		add_filter(
			'wp_import_post_data_raw',
			function ( $post ) {
				global $wpcli_import_counts, $wpcli_import_current_file;
				$wpcli_import_counts['current_post']++;
				WP_CLI::log( '' );
				WP_CLI::log( '' );
				WP_CLI::log( sprintf( 'Processing post #%d ("%s") (post_type: %s)', $post['post_id'], $post['post_title'], $post['post_type'] ) );
				WP_CLI::log( sprintf( '-- %s of %s (in file %s)', number_format( $wpcli_import_counts['current_post'] ), number_format( $wpcli_import_counts['total_posts'] ), $wpcli_import_current_file ) );
				WP_CLI::log( '-- ' . date( 'r' ) ); // phpcs:ignore WordPress.DateTime.RestrictedFunctions.date_date
				return $post;
		add_action(
			'wp_import_insert_post',
			function ( $post_id ) {
				global $wpcli_import_counts;
				if ( is_wp_error( $post_id ) ) {
					WP_CLI::warning( '-- Error importing post: ' . $post_id->get_error_code() );
				} else {
					WP_CLI::log( "-- Imported post as post_id #{$post_id}" );
				if ( 0 === ( $wpcli_import_counts['current_post'] % 500 ) ) {
					// @phpstan-ignore function.deprecated
					WP_CLI\Utils\wp_clear_object_cache();
					WP_CLI::log( '-- Cleared object cache.' );
		add_action(
			'wp_import_insert_term',
			function ( $t, $import_term ) {
				WP_CLI::log( "-- Created term \"{$import_term['name']}\"" );
		add_action(
			'wp_import_set_post_terms',
			function ( $tt_ids, $term_ids, $taxonomy ) {
				WP_CLI::log( '-- Added terms (' . implode( ',', $term_ids ) . ") for taxonomy \"{$taxonomy}\"" );
		add_action(
			'wp_import_insert_comment',
			function ( $comment_id ) {
				global $wpcli_import_counts;
				$wpcli_import_counts['current_comment']++;
				WP_CLI::log( sprintf( '-- Added comment #%d (%s of %s)', $comment_id, number_format( $wpcli_import_counts['current_comment'] ), number_format( $wpcli_import_counts['total_comments'] ) ) );
		add_action(
			'import_post_meta',
			function ( $post_id, $key ) {
				WP_CLI::log( "-- Added post_meta $key" );
	 * Determines whether the requested importer is available.
	private function is_importer_available() {
		require_once ABSPATH . 'wp-admin/includes/plugin.php';
		if ( class_exists( 'WP_Import' ) ) {
			return true;
		$plugins            = get_plugins();
		$wordpress_importer = 'wordpress-importer/wordpress-importer.php';
		if ( array_key_exists( $wordpress_importer, $plugins ) ) {
			$error_msg = "WordPress Importer needs to be activated. Try 'wp plugin activate wordpress-importer'.";
			$error_msg = "WordPress Importer needs to be installed. Try 'wp plugin install wordpress-importer --activate'.";
		return new WP_Error( 'importer-missing', $error_msg );
	 * Processes how the authors should be mapped
	 * @param string          $authors_arg The `--author` argument originally passed to command
	 * @param array<\WP_User|object{user_email: string, user_login: string}> $author_data An array of WP_User-esque author objects
	 * @return array<\WP_User>|WP_Error Author mapping array if successful, WP_Error if something bad happened
	private function process_author_mapping( $authors_arg, $author_data ) {
		// Provided an author mapping file (method checks validity)
		if ( file_exists( $authors_arg ) ) {
			return $this->read_author_mapping_file( $authors_arg );
		// Provided a file reference, but the file doesn't yet exist
		if ( false !== stripos( $authors_arg, '.csv' ) ) {
			return $this->create_author_mapping_file( $authors_arg, $author_data );
		switch ( $authors_arg ) {
			// Create authors if they don't yet exist; maybe match on email or user_login
			case 'create':
				return $this->create_authors_for_mapping( $author_data );
			// Skip any sort of author mapping
			case 'skip':
				return [];
			default:
				return new WP_Error( 'invalid-argument', "'authors' argument is invalid." );
	 * Reads an author mapping file.
	private function read_author_mapping_file( $file ) {
		$author_mapping = [];
		 * @var array{old_user_login?: \WP_User, new_user_login?: \WP_User} $author
		// TODO: Fix type upstream.
		// @phpstan-ignore varTag.nativeType
		foreach ( new \WP_CLI\Iterators\CSV( $file ) as $i => $author ) {
			if ( ! array_key_exists( 'old_user_login', $author ) || ! array_key_exists( 'new_user_login', $author ) ) {
				return new WP_Error( 'invalid-author-mapping', "Author mapping file isn't properly formatted." );
			$author_mapping[] = $author;
		return $author_mapping;
	 * Creates an author mapping file, based on provided author data.
	 * @return WP_Error      The file was just now created, so some action needs to be taken
	private function create_author_mapping_file( $file, $author_data ) {
		if ( touch( $file ) ) {
			$author_mapping = [];
			foreach ( $author_data as $author ) {
				$author_mapping[] = array(
					'old_user_login' => $author->user_login,
					'new_user_login' => $this->suggest_user( $author->user_login, $author->user_email ),
			$file_resource = fopen( $file, 'w' );
			if ( ! $file_resource ) {
				return new WP_Error( 'author-mapping-error', "Couldn't create author mapping file." );
			\WP_CLI\Utils\write_csv( $file_resource, $author_mapping, array( 'old_user_login', 'new_user_login' ) );
			return new WP_Error( 'author-mapping-error', sprintf( 'Please update author mapping file before continuing: %s', $file ) );
			return new WP_Error( 'author-mapping-error', "Couldn't create author mapping file." );
	 * Creates users if they don't exist, and build an author mapping file.
	 * @param array<\WP_User|object{user_email: string, user_login: string}> $author_data
	private function create_authors_for_mapping( $author_data ) {
		$author_mapping = [];
		foreach ( $author_data as $author ) {
			if ( isset( $author->user_email ) ) {
				$user = get_user_by( 'email', $author->user_email );
				if ( $user instanceof WP_User ) {
					$author_mapping[] = array(
						'old_user_login' => $author->user_login,
						'new_user_login' => $user->user_login,
					continue;
			$user = get_user_by( 'login', $author->user_login );
			if ( $user instanceof WP_User ) {
				$author_mapping[] = array(
					'old_user_login' => $author->user_login,
					'new_user_login' => $user->user_login,
				continue;
			$user = array(
				'user_login' => '',
				'user_email' => '',
				'user_pass'  => wp_generate_password(),
			$user = array_merge( $user, (array) $author );
			$user_id = wp_insert_user( $user );
			if ( is_wp_error( $user_id ) ) {
				return $user_id;
			 * @var \WP_User $user
			$user             = get_user_by( 'id', $user_id );
			$author_mapping[] = array(
				'old_user_login' => $author->user_login,
				'new_user_login' => $user->user_login,
		return $author_mapping;
	 * Suggests a blog user based on the levenshtein distance.
	 * @return string|\WP_User
	private function suggest_user( $author_user_login, $author_user_email = '' ) {
		if ( ! isset( $this->blog_users ) ) {
			$this->blog_users = get_users();
		$shortest    = -1;
		$shortestavg = [];
		$threshold = floor( ( strlen( $author_user_login ) / 100 ) * 10 ); // 10 % of the strlen are valid
		$closest   = '';
		foreach ( $this->blog_users as $user ) {
			// Before we resort to an algorithm, let's try for an exact match
			if ( $author_user_email && $user->user_email === $author_user_email ) {
				return $user->user_login;
			$levs        = [];
			$levs[]      = levenshtein( $author_user_login, $user->display_name );
			$levs[]      = levenshtein( $author_user_login, $user->user_login );
			$levs[]      = levenshtein( $author_user_login, $user->user_email );
			$email_parts = explode( '@', $user->user_email );
			$email_login = array_shift( $email_parts );
			$levs[]      = levenshtein( $author_user_login, $email_login );
			rsort( $levs );
			$lev = array_pop( $levs );
			if ( 0 === $lev ) {
				$closest  = $user->user_login;
				$shortest = 0;
			if ( ( $lev <= $shortest || $shortest < 0 ) && $lev <= $threshold ) {
				$closest  = $user->user_login;
				$shortest = $lev;
			$shortestavg[] = $lev;
		// in case all usernames have a common pattern
		if ( $shortest > ( array_sum( $shortestavg ) / count( $shortestavg ) ) ) {
			return '';
		return $closest;
Sunbelt Computer Software

PL/B Language Development and Support

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Uh oh!

Sunbelt Computer Software

PL/B Language Development and Support

Uh oh!

FilesExpand file tree

Import_Command.php

Latest commit

History

Import_Command.php

File metadata and controls
