Import automat fișier XML WordPress din functions.php

Întrebarea ta este puțin specifică dacă vrei "doar" să imporți automat niște articole/pagini. Există alte modalități de a face acest lucru decât folosind un fișier de export XML.

Dacă ai articole doar cu text, atunci ar trebui să folosești LOAD DATA INFILE. Mai întâi trebuie să îți exporti articolele.

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(),
        // pentru multisite
        '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( 'Nu se poate crea directorul de export. Se întrerupe.' );
}

// golim directorul de export altfel MySQL va arunca erori
$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>Nu se poate exporta {$table} în {$outfile}</p>";
        }
    }
}

Aceasta va crea un director în folderul temei tale (asigură-te că are drepturi de scriere!) și va exporta articolele și comentariile (cu meta datele lor) în fișiere dump. Folosește array-ul export pentru a defini ce vrei să exporți. Am grupat majoritatea lucrurilor mai mult sau mai puțin logic (dacă vrei să exporți articolele, atunci ar trebui să exporți și postmeta și așa mai departe).

Beneficiul acestei soluții este că, cu instrucțiunea SELECT poți defini lucruri specifice (de exemplu, doar articole dintr-o anumită categorie sau doar pagini sau doar articole șterse).

Acum vrei să imporți aceste lucruri într-un nou 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>Nu se poate importa datele din fișierul {$file} în tabela {$wpdb->$match[1]}</p>";
}

Această soluție este bună dacă articolele nu conțin atașamente precum imagini. O altă problemă este că niciun utilizator și nicio categorie nu vor fi importate. Asigură-te că ambele sunt create înainte de a începe importul (sau include utilizatori și categorii în exportul tău). Este o metodă foarte brută de a importa lucruri, va suprascrie elementele existente!

Dacă vrei să exporți și atașamentele, trebuie să faci un pic mai multă muncă.

(Notă laterală: Te rog să citești întregul răspuns și Cuvintele Finale la sfârșit! Acest subiect nu este pentru începători și nu voi scrie un avertisment la fiecare linie de cod riscantă)

Plugin-ul WordPress Importer pare a fi o modalitate bună de a importa totul și de a descărca automat atașamentele. Așadar, să vedem ce va face acest plugin.

Mai întâi, pluginul cere un fișier XML pentru încărcare. Apoi parsează fișierul XML și întreabă despre maparea autorului și dacă atașamentele ar trebui descărcate sau nu.

Pentru o rulare automată a pluginului, trebuie să schimbăm câteva lucruri. Mai întâi trebuie să sărim peste procesul de încărcare. Asta e destul de ușor pentru că poți include fișierul XML în temă și știi unde se află fișierul XML. Apoi trebuie să sărim peste întrebările care apar după încărcarea fișierului XML. Putem predefini propriile noastre valori și să le transmitem procesului de import.

Începe cu o copie a pluginului. Creează un director în tema ta, de exemplu autoimport și copiază fișierele wordpress-importer.php și parsers.php în el. Este o idee bună să redenumești fișierul wordpress-importer.php în ceva de genul autoimporter.php. În funcțiile temei, adaugă un apel de funcție pentru a declanșa importul automat

/**
 * Import automat un fișier XML
 */
add_action( 'after_setup_theme', 'autoimport' );

function autoimport() {
    // obține fișierul
    require_once TEMPLATEPATH . '/autoimport/autoimporter.php';

    if ( ! class_exists( 'Auto_Importer' ) )
        die( 'Auto_Importer nu a fost găsit' );

    // apelează funcția
    $args = array(
        'file'        => TEMPLATEPATH . '/autoimport/import.xml',
        'map_user_id' => 1
    );

    auto_import( $args );

}

Mai întâi setăm câteva argumente. Primul lucru este calea completă către fișierul XML. Al doilea este ID-ul unui utilizator existent. Avem nevoie de acest utilizator pentru maparea autorului, acesta este utilizatorul căruia îi vor fi atribuite toate articolele atunci când nu se doresc creări de autori noi.

Acum trebuie să înțelegem cum funcționează pluginul. Deschide fișierul pluginului redenumit și derulează până la sfârșit. Există o funcție wordpress_importer_init() și un apel de acțiune. Elimină ambele, nu mai sunt necesare. Acum mergi în partea de sus a fișierului și elimină antetul pluginului (comentariul de la începutul fișierului). După aceea, redenumește clasa WP_Importer în ceva de genul Auto_Importer, nu uita să ajustezi declarația function_exists și prima metodă WP_Importer (aceasta este constructorul în stil PHP4).

Mai târziu vom transmite fișierul XML direct constructorului clasei, modifică prima metodă astfel

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

function Auto_Importer( $args ) {

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

        // pentru sistemele Windows
        $file = str_replace( '\\', '/', $args['file'] );

        $this->xmlfile = $file;
    }

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

}

Acum trebuie să eliminăm și să modificăm câteva metode din interiorul clasei. Prima metodă este metoda dispatch(). Această metodă îți spune cum funcționează clasa. Ea face trei pași. Mai întâi încarcă fișierul XML, apoi îl procesează și în final importă datele.

Cazul zero este primul pas, este salutul. Aceasta este partea pe care o vezi dacă apelezi importul pentru prima dată. Va cere un fișier pentru încărcare. Cazul doi gestionează încărcarea și afișează un formular pentru opțiunile de import. Cazul trei efectuează în final importul. Cu alte cuvinte: primii doi pași doar solicită date pe care le putem furniza noi înșine. Avem nevoie doar de pasul 3 (cazul 2) și trebuie să furnizăm datele solicitate în pasul unu și doi.

În pasul doi vezi un apel de funcție la wp_import_handle_upload(). Această funcție stabilește câteva informații despre fișierul xml. Nu mai putem folosi această funcție pentru că nu am încărcat un fișier. Așadar, trebuie să copiem și să modificăm funcția. Creează o nouă metodă în cadrul clasei

function import_handle_upload() {

    $url = get_template_directory_uri() . str_replace( TEMPLATEPATH, '', $this->xmlfile );
    $type = 'application/xml'; // știm tipul mime al fișierului nostru
    $file = $this->xmlfile;
    $filename = basename( $this->xmlfile );

    // Construim array-ul obiectului
    $object = array( 'post_title' => $filename,
            'post_content' => $url,
            'post_mime_type' => $type,
            'guid' => $url,
            'context' => 'import',
            'post_status' => 'private'
    );

    // Salvăm datele
    $id = wp_insert_attachment( $object, $file );

    // programăm o curățare pentru peste o zi de acum, în caz de import eșuat sau apel lipsă wp_import_cleanup()
    wp_schedule_single_event( time() + DAY_IN_SECONDS, 'importer_scheduled_cleanup', array( $id ) );

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

Și înlocuiește apelul funcției $file = wp_import_handle_upload(); în metoda handle_upload() cu noua noastră metodă $file = $this->import_handle_upload();

Am înlocuit acum procesul de încărcare cu propriul nostru fișier (care ar trebui să existe deja). Continuă și elimină mai multe metode inutile. Metodele greet(), header() și footer() nu mai sunt necesare (header și footer doar afișează câteva text) și pot fi eliminate din clasă. În metoda dispatch() elimină apelurile către aceste metode ($this->header() și $this->footer()).

Primul pas este gata, acum trebuie să ne ocupăm de al doilea pas, opțiunile de import. Opțiunile de import întreabă dacă ar trebui permisă descărcarea atașamentelor și maparea autorilor.

Prima parte este ușoară. Setează true dacă atașamentele ar trebui descărcate sau false dacă nu. Maparea autorilor este un pic mai complicată. Dacă este permisă crearea de utilizatori noi (autorii din fișierul de import), creează-i. Dacă nu, atribuie articolele unui utilizator existent. Acest lucru se face în metoda get_author_mapping(). Trebuie să înlocuim datele $_POST cu date existente. Aici avem nevoie de o soluție simplă, așa că pur și simplu mapăm toți autorii noi către unul existent dacă nu este permisă crearea de utilizatori noi. Sau pur și simplu creează toți utilizatorii noi. În al doilea caz, asigură-te că toți utilizatorii noi sunt utilizatori dummy. Dacă nu, de fiecare dată când îi imporți, ei vor primi un email cu datele de autentificare în noul blog!! Nu voi explica fiecare linie de cod, iată metoda rescrisă complet

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'];

        // Multisite adaugă strtolower la sanitize_user. Trebuie să facem sanitize aici pentru a evita erori în 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( __( 'Nu s-a putut crea un utilizator nou pentru %s. Articolele lor vor fi atribuite utilizatorului curent.', '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 />';
            }
        }

        // fallback: dacă user_id a fost invalid, folosește utilizatorul curent
        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();
        }
    }
}

Mai avem ceva de lucru. Adăugăm o funcție auto_import() mai întâi

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();

}

Plasează această funcție după clasă. Această funcție are nevoie de gestionare și verificare a erorilor (de exemplu, pentru un argument de fișier gol).

Dacă acum rulezi clasa, vei primi o mulțime de mesaje de eroare. Primul este că clasa lipsește. Acest lucru se datorează faptului că există o declarație if la început.

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

Trebuie să o eliminăm, altfel fișierul nu ar fi analizat complet. Apoi există câteva funcții care nu sunt încărcate în acest moment. Trebuie să includem câteva fișiere.

$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;
}

Practic, asta e tot. Am testat acest lucru pe o instalare locală cu datele de test XML de la WordPress. Funcționează pentru mine, dar nu este o soluție perfectă pentru producție!

Și câteva ultime cuvinte despre setarea unor opțiuni. Există două opțiuni care pot fi modificate de un filtru:

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

Cred că nu trebuie să le explic. Pune aceste filtre în functions.php și setează true sau false (primul este în stil PHP5.3, al doilea în stil WP).

Cuvintele Finale

Am pus totul împreună în acest gist. Folosește-l pe propria răspundere! Nu sunt responsabil pentru nimic!. Te rog să te uiți la fișierele din gist, nu am explicat fiecare mic pas aici.

Lucruri pe care nu le-am făcut: Setați o valoare, de exemplu, în opțiunile (temei) după import. Altfel, importul va începe de fiecare dată când tema este activată.

Poate voi lucra la asta în viitor, voi curăța câteva lucruri și voi rula mai multe teste.