Importar archivo XML de WordPress desde functions.php automáticamente

Tu pregunta es un poco específica si "solo" quieres importar automáticamente algunas entradas/páginas. Hay otras formas de hacer esto además de usar un archivo de exportación XML.

Si tienes publicaciones de solo texto, entonces deberías usar LOAD DATA INFILE. Primero tienes que exportar tus publicaciones.

global $wpdb, $wp_filesystem;

$tables = array(
        'posts'    => array( 'posts', 'postmeta' ),
        'comments' => array( 'comments', 'commentmeta' ),
        'terms'    => array( 'terms', 'term_taxonomy', 'term_relationships' ),
        'users'    => array( 'user', 'usermeta' ),
        'links'    => array( 'links' ),
        'options'  => array( 'options' ),
        'other'    => array(),
        // para multisitio
        'multiside' => array( 'blogs', 'signups', 'site', 'sitemeta', 'sitecategories', 'registration_log', 'blog_versions' )

);

$exports = array( 'posts', 'comments', 'users' );

$exportdir = TEMPLATEPATH . '/export';

if ( ! is_dir( $exportdir ) ) {
    $mkdir = wp_mkdir_p( $exportdir );
    if ( false == $mkdir || ! is_dir( $exportdir ) )
        throw new Exception( 'No se puede crear el directorio de exportación. Abortando.' );
}

// vaciar el directorio de exportación o MySQL arrojará errores
$files = glob( $exportdir . '/*' );
if ( ! empty( $files ) ) {
    foreach( $files as $file )
        unlink( $file );
}

foreach ( $exports as $export ) {

    if ( ! isset( $tables[$export] ) )
        continue;

    if ( ! empty( $tables[$export] ) ) {
        foreach ( $tables[$export] as $table ) {

            $outfile =  sprintf( '%s/%s_dump.sql', $exportdir, $table );
            $sql = "SELECT * FROM {$wpdb->$table} INTO OUTFILE '%s'";
            $res = $wpdb->query( $wpdb->prepare( $sql, $outfile ) );

            if ( is_wp_error( $res ) )
                echo "<p>No se puede exportar {$table} en {$outfile}</p>";
        }
    }
}

Esto creará un directorio en la carpeta de tu tema (¡asegúrate de que tenga permisos de escritura!) y exportará las publicaciones y comentarios (con sus metadatos) a archivos de volcado. Usa el array export para definir lo que quieres exportar. Agrupé la mayoría de las cosas de manera más o menos lógica (si quieres exportar las publicaciones, también deberías exportar postmeta y así sucesivamente).

El beneficio de esta solución es que con la sentencia SELECT puedes definir cosas particulares (por ejemplo, solo publicaciones de una categoría especial o solo páginas o solo publicaciones en la papelera).

Ahora quieres importar esto en un nuevo blog

global $wpdb;

$exportdir = TEMPLATEPATH . '/export';

$files = glob( $exportdir . '/*_dump.sql' );

foreach ( $files as $file ) {

    preg_match( '#/([^/]+)_dump.sql$#is', $file, $match );

    if ( ! isset( $match[1] ) )
        continue;

    $sql = "LOAD DATA LOCAL INFILE '%s' INTO TABLE {$wpdb->$match[1]};";

    $res = $wpdb->query( $wpdb->prepare( $sql, $file ) );

    if ( is_wp_error( $res ) )
        echo "<p>No se pueden importar datos del archivo {$file} en la tabla {$wpdb->$match[1]}</p>";
}

Esta solución es buena si las publicaciones no contienen ningún adjunto como imágenes. Otro problema es que no se importarán usuarios ni categorías. Asegúrate de que ambos estén creados antes de que comience la importación (o incluye usuarios y categorías en tu exportación). Es un método muy rudimentario para importar cosas, ¡sobrescribirá lo existente!

Si quieres exportar también los adjuntos, tienes que hacer un poco más de trabajo.

(Nota al margen: ¡Por favor lee la respuesta completa y las Últimas Palabras al final! Este tema no es para principiantes y no escribiré una advertencia en cada línea de código riesgosa)

El plugin WordPress Importer parece ser una buena forma de importar todo y descargar automáticamente los adjuntos. Así que echemos un vistazo a lo que hace este plugin.

Primero, el plugin solicita un archivo XML para cargar. Luego analiza el archivo XML y pregunta por un mapeo de autores y si los adjuntos deben descargarse o no.

Para una ejecución automática del plugin necesitamos cambiar algunas cosas. Primero tenemos que omitir el proceso de carga. Eso es bastante fácil porque puedes agrupar el archivo XML con el tema y sabes dónde está el archivo XML. Luego tenemos que omitir las preguntas que aparecen después de cargar el archivo XML. Podemos predefinir nuestros propios valores y pasarlos al proceso de importación.

Comienza con una copia del plugin. Crea un directorio en tu tema como autoimport y copia los archivos wordpress-importer.php y parsers.php en él. Es una buena idea renombrar el archivo wordpress-importer.php a algo como autoimporter.php. En las funciones de tu tema agrega una llamada a función para activar la importación automática

/**
 * Importación automática de un archivo XML
 */
add_action( 'after_setup_theme', 'autoimport' );

function autoimport() {
    // obtener el archivo
    require_once TEMPLATEPATH . '/autoimport/autoimporter.php';

    if ( ! class_exists( 'Auto_Importer' ) )
        die( 'Auto_Importer no encontrado' );

    // llamar a la función
    $args = array(
        'file'        => TEMPLATEPATH . '/autoimport/import.xml',
        'map_user_id' => 1
    );

    auto_import( $args );

}

Primero configuramos algunos argumentos. Lo primero es la ruta completa al archivo XML. El segundo es el ID de un usuario existente. Necesitamos este usuario para el mapeo de autores, este es el usuario al que se mapearán todas las publicaciones cuando no se deban crear nuevos autores.

Ahora tenemos que entender cómo funciona el plugin. Abre tu archivo de plugin renombrado y desplázate hasta el final. Hay una función wordpress_importer_init() y una llamada a acción. Elimina ambas, ya no son necesarias. Ahora ve a la parte superior del archivo y elimina el encabezado del plugin (el comentario al principio del archivo). Después de eso, renombra la clase WP_Importer a algo como Auto_Importer, no olvides ajustar la declaración function_exists y el primer método WP_Importer (este es el constructor en estilo PHP4).

Más adelante pasaremos el archivo XML directamente al constructor de la clase, modifica el primer método a esto

var $xmlfile = '';
var $map_user_id = 0;

function Auto_Importer( $args ) {

    if ( file_exists( $args['file'] ) ) {

        // para sistemas windows
        $file = str_replace( '\\', '/', $args['file'] );

        $this->xmlfile = $file;
    }

    if ( isset( $args['map_user_id'] ) )
        $this->map_user_id = $args['map_user_id'];

}

Ahora tenemos que eliminar y modificar algunos métodos dentro de la clase. El primer método es el método dispatch(). Este método te dice cómo funciona la clase. Hace tres pasos. Primero carga el archivo XML, luego lo procesa y finalmente importa los datos.

El caso cero es el primer paso, es el saludo. Esta es la parte que ves si llamas a la importación por primera vez. Preguntará por un archivo para cargar. El caso dos maneja la carga y muestra un formulario para las opciones de importación. El caso tres finalmente hace la importación. En otras palabras: los dos primeros pasos solo piden datos que podemos proporcionar nosotros mismos. Solo necesitamos el paso 3 (caso 2) y tenemos que proporcionar los datos solicitados en los pasos uno y dos.

En el paso dos ves una llamada a función a wp_import_handle_upload(). Esta función configura algunas informaciones sobre el archivo xml. Ya no podemos usar esta función porque no hemos cargado un archivo. Así que tenemos que copiar y modificar la función. Crea un nuevo método dentro de la clase

function import_handle_upload() {

    $url = get_template_directory_uri() . str_replace( TEMPLATEPATH, '', $this->xmlfile );
    $type = 'application/xml'; // conocemos el tipo mime de nuestro archivo
    $file = $this->xmlfile;
    $filename = basename( $this->xmlfile );

    // Construir el array de objeto
    $object = array( 'post_title' => $filename,
            'post_content' => $url,
            'post_mime_type' => $type,
            'guid' => $url,
            'context' => 'import',
            'post_status' => 'private'
    );

    // Guardar los datos
    $id = wp_insert_attachment( $object, $file );

    // programar una limpieza para un día después en caso de importación fallida o falta de llamada wp_import_cleanup()
    wp_schedule_single_event( time() + DAY_IN_SECONDS, 'importer_scheduled_cleanup', array( $id ) );

    return array( 'file' => $file, 'id' => $id );
}

Y reemplaza la llamada a función $file = wp_import_handle_upload(); en el método handle_upload() con nuestro nuevo método $file = $this->import_handle_upload();

Hemos reemplazado el proceso de carga con nuestro propio archivo (que ya debería existir). Continúa y elimina más métodos innecesarios. Los métodos gereet(), header() y footer() ya no son necesarios (header y footer solo imprimen texto) y pueden eliminarse de la clase. En el método dispatch() elimina las llamadas a estos métodos ($this->header() y $this->footer()).

El primer paso está hecho, ahora tenemos que ocuparnos del segundo paso, las opciones de importación. Las opciones de importación preguntan si se debe permitir descargar los adjuntos y mapear los autores.

La primera parte es fácil. Establece en verdadero si los adjuntos deben descargarse o falso si no. El mapeo de autores es un poco más complicado. Si se permite crear nuevos usuarios (los autores del archivo de importación), créalos. Si no, asigna las publicaciones a un usuario existente. Esto se hace en el método get_author_mapping(). Tenemos que reemplazar los datos $_POST con datos existentes. Aquí necesitamos una solución simple, así que simplemente mapeamos todos los nuevos autores a uno existente si no se permite crear nuevos usuarios. O simplemente creamos todos los nuevos usuarios. En el segundo caso, ¡asegúrate de que todos los nuevos usuarios sean usuarios ficticios. Si no, ¡cada vez que los importes recibirán un correo con usuario y contraseña del nuevo blog!! No explicaré cada línea de código, aquí está el método completamente reescrito

function get_author_mapping( $map_users_id ) {
    if ( empty( $this->authors ) )
        return;

    $create_users = $this->allow_create_users();

    foreach ( (array) $this->authors as $i => $data ) {

        $old_login = $data['author_login'];

        // Multisitio agrega strtolower a sanitize_user. Necesitamos sanitizar aquí para evitar problemas en process_posts.
        $santized_old_login = sanitize_user( $old_login, true );
        $old_id = isset( $this->authors[$old_login]['author_id'] ) ? intval($this->authors[$old_login]['author_id']) : false;

        if ( ! $create_users ) {
            $user = get_userdata( intval($map_users_id) );
            if ( isset( $user->ID ) ) {
                if ( $old_id )
                    $this->processed_authors[$old_id] = $user->ID;
                $this->author_mapping[$santized_old_login] = $user->ID;
            }
        } else if ( $create_users ) {
            if ( ! empty($this->authors[$i]) ) {
                $user_id = wp_create_user( $this->authors[$i]['author_login'], wp_generate_password() );
            } else if ( $this->version != '1.0' ) {
                $user_data = array(
                    'user_login' => $old_login,
                    'user_pass' => wp_generate_password(),
                    'user_email' => isset( $this->authors[$old_login]['author_email'] ) ? $this->authors[$old_login]['author_email'] : '',
                    'display_name' => $this->authors[$old_login]['author_display_name'],
                    'first_name' => isset( $this->authors[$old_login]['author_first_name'] ) ? $this->authors[$old_login]['author_first_name'] : '',
                    'last_name' => isset( $this->authors[$old_login]['author_last_name'] ) ? $this->authors[$old_login]['author_last_name'] : '',
                );
                $user_id = wp_insert_user( $user_data );
            }

            if ( ! is_wp_error( $user_id ) ) {
                if ( $old_id )
                    $this->processed_authors[$old_id] = $user_id;
                $this->author_mapping[$santized_old_login] = $user_id;
            } else {
                printf( __( 'Error al crear nuevo usuario para %s. Sus publicaciones se atribuirán al usuario actual.', 'wordpress-importer' ), esc_html($this->authors[$old_login]['author_display_name']) );
                if ( defined('IMPORT_DEBUG') && IMPORT_DEBUG )
                    echo ' ' . $user_id->get_error_message();
                echo '<br />';
            }
        }

        // seguro: si el user_id era inválido, usar el usuario actual
        if ( ! isset( $this->author_mapping[$santized_old_login] ) ) {
            if ( $old_id )
                $this->processed_authors[$old_id] = (int) get_current_user_id();
            $this->author_mapping[$santized_old_login] = (int) get_current_user_id();
        }
    }
}

Queda algo de trabajo por hacer. Primero añadir una función auto_import()

function auto_import( $args ) {

    $defaults = array( 'file' => '', 'map_user_id' => 0);
    $args = wp_parse_args( $args, $defaults );

    $autoimport = new Auto_Importer( $args );
    $autoimport->do_import();

}

Coloca esta función después de la clase. Esta función carece de manejo de errores y comprobaciones (por ejemplo, para un argumento de archivo vacío).

Si ahora ejecutas la clase, obtendrás muchos mensajes de error. El primero es que falta la clase. Esto se debe a que hay una declaración if al principio.

if ( ! defined( 'WP_LOAD_IMPORTERS' ) )
    return;

Tenemos que eliminarlo, de lo contrario el archivo no se analizará completamente. Luego hay algunas funciones que no se cargan en este punto. Tenemos que incluir algunos archivos.

$required = array(
    'post_exists'                     => ABSPATH . 'wp-admin/includes/post.php',
    'wp_generate_attachment_metadata' => ABSPATH . 'wp-admin/includes/image.php',
    'comment_exists'                  => ABSPATH . 'wp-admin/includes/comment.php'
);

foreach ( $required as $func => $req_file ) {
    if ( ! function_exists( $func ) )
        require_once $req_file;
}

Básicamente eso es todo. Probé esto en una instalación local con los datos de prueba XML de WordPress. Funciona para mí, pero ¡no es una solución perfecta para producción!

Y algunas últimas palabras sobre la configuración de algunas opciones. Hay dos opciones que se pueden modificar mediante un filtro:

add_filter( 'import_allow_create_users', function() { return false; } );
add_filter( 'import_allow_fetch_attachments', '__return_false' );

Creo que no necesito explicarlo. Pon estos filtros en tu functions.php y configura verdadero o falso (el primero es estilo PHP5.3, el segundo es estilo WP).

Últimas Palabras

He reunido todo en este gist. ¡Úsalo bajo tu propio riesgo! ¡No soy responsable de nada!. Por favor mira los archivos en el gist, no he explicado cada pequeño paso aquí.

Cosas que no he hecho: Establecer un valor, por ejemplo, en las opciones (del tema) después de importar. De lo contrario, la importación comenzará cada vez que se active el tema.

Quizás trabaje en ello en el futuro, limpie algunas cosas y haga más pruebas.