it-swarm.com.de

Importieren Sie eine Wordpress XML-Datei aus der Datei Functions.php

Ich entwickle ein Thema, das eine andere Methode zum Hinzufügen von Inhalten hat. Aus diesem Grund werden bei der Standardinstallation von Wordpress keine Inhalte angezeigt. Ich habe mich gefragt, ob es möglich ist, eine XML-Datei über eine interne Funktion und/oder Hooks automatisch zu importieren, nachdem das Thema aktiviert wurde.

Benutzer installiert Theme > Benutzer aktiviert Theme > Code hinter den Kulissen lädt eine XML-Datei und führt einen stillen Import des Inhalts durch

Um derzeit eine XML-Datei zu importieren, müssen Sie das Wordpress-Import-Plugin für Wordpress installieren und die Datei dann manuell importieren. Wählen Sie einen Benutzer aus, dem der importierte Inhalt zugeordnet werden soll, und entscheiden Sie, ob Sie Medienanhänge importieren möchten. Ich finde diesen Schritt für die Arten von Kunden, auf die ich abziele, zu verwirrend und möchte die Notwendigkeit für diesen Schritt effektiv beseitigen.

Ich habe einige Eingriffe in das Wordpress-Importer-Skript vorgenommen und es gibt viele Funktionsaufrufe. Was muss ich tun, um die Teile, für die Benutzereingaben erforderlich sind, zu entfernen und eine Datei mithilfe der Klasse und ihres Methodenverzeichnisses zu importieren? Ich bin mir nicht sicher, wo ich anfangen soll.

Meine Kunden sind Gewerbetreibende, so dass sie selbst durch das Importieren einer XML-Datei überfordert sind und sie nicht die Zeit haben, dies zu tun. Es besteht daher die Möglichkeit von Fehlern, insbesondere wenn sie versuchen, mehr als einmal zu importieren, was zu doppelten Seiten führt.

Danke im Voraus.

Bearbeiten/Verdeutlichen

Hier scheint es viel Verwirrung zu geben. Ich frage nicht, wie ich überprüfen soll, ob ein Thema aktiviert wurde. Ich habe diesen Teil sortiert. Ich frage mich, wie ich eine XML-Importdatei analysieren und automatisch ohne Benutzeraufwand importieren würde. Ich möchte im Wesentlichen das Wordpress-Import-Plugin automatisieren, mit dem Sie die XML-Datei bereits manuell importieren können, den Autor auswählen und Anhänge in meine functions.php herunterladen und importieren.

Anstatt ein Plugin zu benötigen oder meine Kunden mit mangelnden Computerkenntnissen oder dem Wunsch, zu lernen, wie man es mit dem Plugin macht.

6

Ihre Frage ist etwas spezifisch, wenn Sie "nur" einige Posts/Seiten automatisch importieren möchten. Es gibt andere Möglichkeiten, dies zu tun, als eine XML-Exportdatei zu verwenden.

Wenn Sie nur Textbeiträge haben, sollten Sie LOAD DATA INFILE verwenden. Zuerst musst du deine Beiträge exportieren.

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(),
        // for multiside
        '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( 'Cannot create export directory. Aborting.' );
}

// empty the export dir else MySQL throws errors
$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>Cannot export {$table} into {$outfile}</p>";
        }
    }
}

Dies erstellt ein Verzeichnis in Ihrem Themenordner (stellen Sie sicher, dass es beschreibbar ist!) Und exportiert die Posts und Kommentare (mit Meta) in Dump-Dateien. Verwenden Sie das Array export, um zu definieren, was Sie exportieren möchten. Ich habe die meisten Dinge mehr oder weniger logisch gruppiert (wenn du die Posts exportieren willst, dann solltest du auch Postsmeta exportieren und so weiter).

Der Vorteil dieser Lösung besteht darin, dass Sie mit der Anweisung SELECT bestimmte Dinge definieren können (z. B. nur Beiträge aus einer bestimmten Kategorie oder nur Seiten oder nur verworfene Beiträge).

Jetzt möchten Sie dieses Zeug in einen neuen Blog importieren

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>Cannot import data from file {$file} into table {$wpdb->$match[1]}</p>";
}

Diese Lösung ist gut, wenn die Posts keine Anhänge wie Bilder enthielten. Ein weiteres Problem ist, dass keine Benutzer und keine Kategorien importiert werden. Stellen Sie sicher, dass beide vor dem Start des Imports erstellt wurden (oder beziehen Sie Benutzer und Kategorien in Ihren Export ein). Es ist eine sehr grobe Methode, um Dinge zu importieren, es wird vorhandene Sachen überschreiben!

Wenn Sie die Anhänge auch exportieren möchten, müssen Sie etwas mehr Arbeit leisten.

(Anmerkung: Bitte lesen Sie die vollständige Antwort und die allerletzten Worte am Ende! Dieses Thema ist nicht für Anfänger gedacht, und ich schreibe nicht bei jeder riskanten Codezeile eine Warnung

Das WordPress Importer Plugin scheint eine gute Möglichkeit zu sein, das gesamte Material zu importieren und die Anhänge automatisch zu importieren/herunterzuladen. Schauen wir uns also an, was dieses Plugin bewirken wird.

Zuerst fragt das Plugin nach einer XML-Datei, die hochgeladen werden soll. Anschließend wird die XML-Datei analysiert und nach einer Autorenzuordnung gefragt, ob die Anhänge heruntergeladen werden sollen oder nicht.

Für einen automatischen Start des Plugins müssen wir einige Dinge ändern. Zuerst müssen wir den Upload-Prozess überspringen. Das ist ganz einfach, weil Sie die XML-Datei mit dem Thema bündeln können und wissen, wo sich die XML-Datei befindet. Dann müssen wir die Fragen überspringen, die nach dem Hochladen der XML-Datei erscheinen. Wir können unsere eigenen Werte vordefinieren und an den Importprozess übergeben.

Beginnen Sie mit einer Kopie des Plugins. Erstellen Sie ein Verzeichnis in Ihrem Thema wie autoimport und kopieren Sie die Dateien wordpress-importer.php und parsers.php in dieses Verzeichnis. Es ist eine gute Idee, die Datei wordpress-importer.php in autoimporter.php umzubenennen. Fügen Sie in Ihrer Themenfunktion einen Funktionsaufruf hinzu, um den automatisierten Impoprt auszulösen

/**
 * Auto import a XML file
 */
add_action( 'after_setup_theme', 'autoimport' );

function autoimport() {
    // get the file
    require_once TEMPLATEPATH . '/autoimport/autoimporter.php';

    if ( ! class_exists( 'Auto_Importer' ) )
        die( 'Auto_Importer not found' );

    // call the function
    $args = array(
        'file'        => TEMPLATEPATH . '/autoimport/import.xml',
        'map_user_id' => 1
    );

    auto_import( $args );

}

Zuerst richten wir einige Argumente ein. Das erste ist der vollständige Pfad zur XML-Datei. Die zweite ist die ID eines existierenden Benutzers. Wir benötigen diesen Benutzer für die Autorenzuordnung. Dies ist der Benutzer, dem alle Beiträge zugeordnet werden, wenn keine neuen Autoren erstellt werden sollen.

Jetzt müssen wir verstehen, wie das Plugin funktioniert. Öffnen Sie Ihre umbenannte Plugin-Datei und scrollen Sie bis zum Ende. Es gibt eine Funktion wordpress_importer_init() und einen Aktionsaufruf. Entfernen Sie beide, es wird nicht mehr benötigt. Gehen Sie nun zum Anfang der Datei und entfernen Sie den Plugin-Header (den Kommentar am Anfang der Datei). Benennen Sie danach die Klasse WP_Importer in Auto_Importer um, und vergessen Sie nicht, die Anweisung function_exists und die erste Methode WP_Importer anzupassen (dies ist der Konstruktor im PHP4-Stil).

Später werden wir die XML-Datei direkt an den Klassenkonstruktor übergeben, ändern Sie die erste Methode dazu

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

function Auto_Importer( $args ) {

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

        // for windows systems
        $file = str_replace( '\\', '/', $args['file'] );

        $this->xmlfile = $file;
    }

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

}

Jetzt müssen wir einige Methoden in der Klasse entfernen und ändern. Die erste Methode ist die Methode dispatch(). Diese Methode zeigt Ihnen, wie die Klasse funktioniert. Es macht drei Schritte. Laden Sie zuerst die XML-Datei hoch, verarbeiten Sie sie dann und importieren Sie zuletzt die Daten.

Fall Null ist der erste Schritt, es ist die Begrüßung. Dies ist der Teil, den Sie sehen, wenn Sie den Import zum ersten Mal aufrufen. Sie werden aufgefordert, eine Datei hochzuladen. Fall zwei übernimmt den Upload und zeigt ein Formular für die Importoptionen an. Fall drei erledigt endlich den Import. Mit anderen Worten: In den ersten beiden Schritten werden nur Daten abgefragt, die wir selbst bereitstellen können. Wir brauchen nur Schritt 3 (Fall 2) und müssen die in Schritt 1 und 2 abgefragten Daten bereitstellen.

In Schritt zwei sehen Sie einen Funktionsaufruf für wp_import_handle_upload(). Diese Funktion richtet einige Informationen zur XML-Datei ein. Wir können diese Funktion nicht mehr verwenden, da wir keine Datei hochgeladen haben. Also müssen wir die Funktion kopieren und modifizieren. Erstellen Sie eine neue Methode in der Klasse

function import_handle_upload() {

    $url = get_template_directory_uri() . str_replace( TEMPLATEPATH, '', $this->xmlfile );
    $type = 'application/xml'; // we know the mime type of our file
    $file = $this->xmlfile;
    $filename = basename( $this->xmlfile );

    // Construct the object array
    $object = array( 'post_title' => $filename,
            'post_content' => $url,
            'post_mime_type' => $type,
            'guid' => $url,
            'context' => 'import',
            'post_status' => 'private'
    );

    // Save the data
    $id = wp_insert_attachment( $object, $file );

    // schedule a cleanup for one day from now in case of failed import or missing wp_import_cleanup() call
    wp_schedule_single_event( time() + DAY_IN_SECONDS, 'importer_scheduled_cleanup', array( $id ) );

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

Und ersetze den Funktionsaufruf $file = wp_import_handle_upload(); in der Methode handle_upload() durch unsere neue Methode $file = $this->import_handle_upload();

Wir haben jetzt den Upload-Prozess durch unsere eigene Datei ersetzt (die bereits existieren sollte). Fahren Sie fort und entfernen Sie nicht mehr benötigte Methoden. Die Methoden gereet(), header() und footer() werden nicht mehr benötigt (Kopf- und Fußzeile geben nur Text aus) und können aus der Klasse entfernt werden. Entfernen Sie in der Methode dispatch() die Aufrufe dieser Methoden ($this->header() und $this->footer()).

Der erste Schritt ist erledigt, jetzt müssen wir uns um den zweiten Schritt kümmern, die Importoptionen. Bei den Importoptionen werden Sie gefragt, ob das Herunterladen der Anhänge und das Zuordnen der Autoren zulässig sein soll.

Der erste Teil ist einfach. Setzen Sie diesen Wert auf true, wenn die Anhänge heruntergeladen werden sollen, oder auf false, wenn dies nicht der Fall ist. Die Autorenzuordnung ist etwas komplizierter. Wenn neue Benutzer (die Autoren aus der Importdatei) erstellt werden dürfen, erstellen Sie diese. Wenn nicht, weisen Sie die Posts einem vorhandenen Benutzer zu. Dies geschieht in der Methode get_author_mapping(). Wir müssen die $_POST-Daten durch vorhandene Daten ersetzen. Hier brauchen wir eine einfache Lösung, also ordnen wir einfach alle neuen Autoren einem vorhandenen zu, wenn es nicht erlaubt ist, neue Benutzer anzulegen. Oder legen Sie einfach alle neuen Benutzer an. Stellen Sie im zweiten Fall sicher, dass alle neuen Benutzer Dummy-Benutzer sind. Wenn nicht, erhalten sie jedes Mal, wenn Sie sie importieren, eine E-Mail mit Login und Passwort für den neuen Blog !! Ich erkläre nicht jede Codezeile, hier ist die komplett neu geschriebene Methode

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 adds strtolower to sanitize_user. Need to sanitize here to stop breakage in 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( __( 'Failed to create new user for %s. Their posts will be attributed to the current user.', '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 />';
            }
        }

        // failsafe: if the user_id was invalid, default to the current user
        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();
        }
    }
}

Es bleibt noch einiges zu tun. Fügen Sie zuerst eine Funktion auto_import() hinzu

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

}

Fügen Sie diese Funktion nach der Klasse ein. Diese Funktion verfehlt einige Fehlerbehandlungen und -prüfungen (z. B. für ein Argument für eine leere Datei).

Wenn Sie die Klasse jetzt ausführen, werden viele Fehlermeldungen angezeigt. Der erste ist, dass die Klasse fehlt. Dies liegt daran, dass am Anfang eine if-Anweisung steht.

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

Wir müssen es entfernen, sonst würde die Datei nicht vollständig analysiert. Dann gibt es einige Funktionen, die an dieser Stelle nicht geladen sind. Wir müssen einige Dateien hinzufügen.

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

Grundsätzlich ist das alles. Ich teste dies auf einer lokalen Installation mit den Testdaten XML von WordPress. Es funktioniert für mich, aber es ist keine perfekte Lösung für die Produktion!

Und noch ein paar letzte Worte zum Einrichten einiger Optionen. Es gibt zwei Optionen, die von einem Filter geändert werden können:

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

Ich glaube, ich muss es nicht erklären. Fügen Sie diese Filter in Ihre functions.php ein und richten Sie true oder false ein (der erste ist der PHP5.3-Stil, der zweite ist der WP-Stil).

Allerletzte Worte

Ich setze alles zusammen in diese Kern . Verwenden Sie es auf eigenes Risiko! Ich bin für nichts verantwortlich! . Bitte schauen Sie sich die Dateien im Gist an, ich habe hier nicht jeden kleinen Schritt erklärt.

Denkt, ich habe es nicht getan: Setze einen Wert, z. in den (Thema) Optionen nach dem Import. Ansonsten startet der Import jedes Mal, wenn das Theme aktiviert wird.

Vielleicht werde ich in Zukunft daran arbeiten, einige Dinge aufräumen und weitere Tests durchführen.

18
Ralf912

Gestatten Sie mir, hier noch einmal zwei Dinge vorzustellen:

(a) "Ich frage nicht, wie ich ... Ich habe diesen Teil sortiert ..."

"" Ich habe im Laufe der Zeit gelernt, mit der Tatsache einverstanden zu sein, dass der Ansatz zur Behebung von Problemen nicht unbedingt eine „sichtbare Assoziation“ mit dem vorliegenden Problem erfordert.

(b) "... müsste ich tun, um die Teile zu entfernen ..." "... Kunden sind Handwerker, also sogar etwas so Einfaches wie ..."

"" Warum es dem Kunden leichter machen auf Kosten von es sich selbst schwer machen? Ich könnte auf jeden Fall "Dienste" nach den zu erbringenden Leistungen anbieten und eine Remote-Verbindung herstellen, um dies für sie [kostenpflichtig] zu tun, anstatt "... das Import-Plugin zu hacken ...". Ich meine, fragen Sie sich, ob es sich in Ihrem aktuellen Schema wirklich lohnt. WENN Sie jedoch bereit sind, sich anzustrengen, probieren Sie den folgenden Code aus. Wenn du kannst, dann:

Ich stimme sowohl mit Chrisguitarguy als auch mit Amolv überein.

Wie Chris hervorhob, gibt es viele Möglichkeiten, einen Output zu erzielen. Das ist nur einer. Obwohl es mühsam langwierig werden kann, lesen Sie vor allem die letzten Zeilen.

<?php 
/* I usually dump ONE line in functions.php  */
require_once (TEMPLATEPATH . '/includes/whatever.php');

/* and then in that loc CHECK FIRST*/
if ((is_admin() && isset($_GET['activated']) && $pagenow == 'themes.php')||(is_admin() && isset($_GET['upgrade']) && $pagenow == 'admin.php' && $_GET['page'] == 'admin-options.php')) 
{

global $wpdb, $wp_rewrite, $hey;

// create tables
your_tables();

// insert value defaults
your_values();

// insert link defaults
your_links();

// pages and tpl
your_pages();

// create category or categories
// wp_create_categories     $categories, $post_id = ''
// wp_create_category   $cat_name, $parent

//flush rewrite
$wp_rewrite->flush_rules();

}

// create them db tables
function your_tables() {
global $wpdb, $hey;

$collate = '';
if($wpdb->supports_collation()) {
if(!empty($wpdb->charset)) $collate = "DEFAULT CHARACTER SET $wpdb->charset";
if(!empty($wpdb->collate)) $collate .= " COLLATE $wpdb->collate";
}

$sql = "CREATE TABLE IF NOT EXISTS ". $wpdb->prefix . "table1_name" ." (
`id` INT(10) NOT NULL auto_increment,
`some_name1` VARCHAR(255) NOT NULL,
`some_name2` VARCHAR(255) NOT NULL,
`some_name3` LONGTEXT,
`some_name4` LONGTEXT NOT NULL,
`some_name5` VARCHAR(255) DEFAULT NULL,
`some_name6` VARCHAR(255) DEFAULT NULL,
`some_name7` DATETIME NOT NULL DEFAULT '0000-00-00 00:00:00',
`some_name8` DATETIME NOT NULL DEFAULT '0000-00-00 00:00:00',
PRIMARY KEY id  (`id`)) $collate;";

$wpdb->query($sql);


$sql = "CREATE TABLE IF NOT EXISTS ". $wpdb->prefix . "table2_name" ." (
`meta_id` INT(10) NOT NULL AUTO_INCREMENT,
`some_name1` INT(10) NOT NULL,
`some_name2` INT(10) NOT NULL,
`some_name3` VARCHAR(255) NOT NULL,
`some_name4` INT(10) NOT NULL,
PRIMARY KEY id  (`meta_id`)) $collate;";

$wpdb->query($sql);

// and so on and so forth

/* Insert default/ALL data into tables */
// BUT CHECK FIRST IF DATA EXISTS. IF = YES DONT Push IN ANYTHING

$sql = "SELECT field_id " . "FROM " . $wpdb->prefix . "table1_name LIMIT 1";

$wpdb->get_results($sql);

if($wpdb->num_rows == 0) {

// more code will follow
// i have to get going now

} 

?>

HINWEIS

  • Wenn Sie schon eine Weile mit WP zusammen sind, ist es unnötig zu erwähnen, dass SICHERN SIE IHRE DB ZUERST .

  • phpMyAdmin hat rohe Power und macht es ziemlich einfach, Dinge sorgfältig zu vermasseln.

  • Obwohl der Aufwand anfangs entmutigend sein könnte, könnten Sie ihn, wenn Sie ihn richtig machen, wie ein Uhrwerk funktionieren lassen ...

Endlich

Wie schiebe ich 2000 Datenzeilen in 20 Sekunden in die letzten 2 Zeilen innerhalb dieser 2 geschweiften Klammern?

phpMyAdmin "DB links auswählen" "Alle TABELLEN rechts auswählen" "Exportieren ▼

➝ Custom: display all options
➝ View output as text = ON
➝ Save output to a file = OFF
➝ Compression = NONE
➝ Format = SQL
➝ Dump Table = STRUCTURE & DATA
➝ Add DROP TABLE... = OFF (Important!)
➝ Syntax to use = "both of the above"

»» GO!
  • Vom nächsten Bildschirm aus könnte ich den 'STRUCTURE'-Teil in $ sql = "...." für your_tables() und den' DATA'-Teil in $sql für your_data() kopieren.

  • Für den Rest der WP Standardeinstellungen verwende ich update_option(...) & update_post_meta(...)

4
user32057

in functions.php kann der Zustand überprüft werden

if( isset($_GET['activated']) && 'themes.php' == $GLOBALS['pagenow']) )
{ 
  // check duplicates 
   // call import class 
   //xml import code 
   // do whatever you want to 
}

Sobald Ihr Theme aktiviert ist, werden automatisch Daten importiert.

0
amolv

Es gibt kein Thema-Äquivalent zu register_activation_hook für Plugins - es gibt ein paar Hacks . Warum? Weil ein Thema eine Haut ist. Nur Funktionen, die speziell mit der Anzeige von Inhalten zusammenhängen, sollten in ein Thema integriert werden, nicht in den Inhalt selbst.

Wie geht das? Verwenden Sie das Beispiel oben , um eine Rückruffunktion einmal auszuführen. Der WordPress-Importer bearbeitet XML-Dateien. Es gibt vieleverschiedeneMöglichkeiten zu XML ​​analysieren in PHP. Treffen Sie Ihre Wahl, analysieren Sie die Datei, tun Sie, was Sie wollen.

0
chrisguitarguy