readme.txt 0000666 00000050675 15213303300 0006551 0 ustar 00 === One Click Demo Import ===
Contributors: capuderg, cyman, Prelc
Tags: import, content, demo, data, widgets, settings, redux, theme options
Requires at least: 4.0.0
Tested up to: 4.7
Stable tag: 2.2.1
License: GPLv3 or later
Import your demo content, widgets and theme settings with one click. Theme authors! Enable simple demo import for your theme demo data.
== Description ==
The best feature of this plugin is, that theme authors can define import files in their themes and so all you (the user of the theme) have to do is click on the "Import Demo Data" button.
> **Are you a theme author?**
>
> Setup One Click Demo Imports for your theme and your users will thank you for it!
>
> [Follow this easy guide on how to setup this plugin for your themes!](http://proteusthemes.github.io/one-click-demo-import/)
>
> Also [sign up to the newsletter](http://proteusthemes.github.io/one-click-demo-import/#ocdi-newsletter-signup), so we can inform you about any updates, changes or improvements.
> **Are you a theme user?**
>
> Contact the author of your theme and [let them know about this plugin](http://proteusthemes.github.io/one-click-demo-import/theme-users.html). Theme authors can make any theme compatible with this plugin in 15 minutes and make it much more user-friendly.
>
> "[Where can I find the contact of the theme author?](http://proteusthemes.github.io/one-click-demo-import/theme-users.html)"
This plugin will create a submenu page under Appearance with the title **Import demo data**.
If the theme you are using does not have any predefined import files, then you will be presented with three file upload inputs. First one is required and you will have to upload a demo content XML file, for the actual demo import. The second one is optional and will ask you for a WIE or JSON file for widgets import. You create that file using the [Widget Importer & Exporter](https://wordpress.org/plugins/widget-importer-exporter/) plugin. The third one is also optional and will import the customizer settings, select the DAT file which you can generate from [Customizer Export/Import](https://wordpress.org/plugins/customizer-export-import/) plugin (the customizer settings will be imported only if the export file was created from the same theme). The final one is optional as well and will import your Redux framework settings. You can generate the export json file with the [Redux framework](https://wordpress.org/plugins/redux-framework/) plugin.
This plugin is using the improved WP import 2.0 that is still in development and can be found here: https://github.com/humanmade/WordPress-Importer.
All progress of this plugin's work is logged in a log file in the default WP upload directory, together with the demo import files used in the importing process.
NOTE: There is no setting to "connect" authors from the demo import file to the existing users in your WP site (like there is in the original WP Importer plugin). All demo content will be imported under the current user.
**Do you want to contribute?**
Please refer to the official [GitHub repository](https://github.com/proteusthemes/one-click-demo-import) of this plugin.
== Installation ==
**From your WordPress dashboard**
1. Visit 'Plugins > Add New',
2. Search for 'One Click Demo Import' and install the plugin,
3. Activate 'One Click Demo Import' from your Plugins page.
**From WordPress.org**
1. Download 'One Click Demo Import'.
2. Upload the 'one-click-demo-import' directory to your '/wp-content/plugins/' directory, using your favorite method (ftp, sftp, scp, etc...)
3. Activate 'One Click Demo Import' from your Plugins page.
**Once the plugin is activated you will find the actual import page in: Appearance -> Import Demo Data.**
== Frequently Asked Questions ==
= I have activated the plugin. Where is the "Import Demo Data" page? =
You will find the import page in *wp-admin -> Appearance -> Import Demo Data*.
= Where are the demo import files and the log files saved? =
The files used in the demo import will be saved to the default WordPress uploads directory. An example of that directory would be: `../wp-content/uploads/2016/03/`.
The log file will also be registered in the *wp-admin -> Media* section, so you can access it easily.
= How to predefine demo imports? =
This question is for theme authors. To predefine demo imports, you just have to add the following code structure, with your own values to your theme (using the `pt-ocdi/import_files` filter):
`
function ocdi_import_files() {
return array(
array(
'import_file_name' => 'Demo Import 1',
'categories' => array( 'Category 1', 'Category 2' ),
'import_file_url' => 'http://www.your_domain.com/ocdi/demo-content.xml',
'import_widget_file_url' => 'http://www.your_domain.com/ocdi/widgets.json',
'import_customizer_file_url' => 'http://www.your_domain.com/ocdi/customizer.dat',
'import_redux' => array(
array(
'file_url' => 'http://www.your_domain.com/ocdi/redux.json',
'option_name' => 'redux_option_name',
),
),
'import_preview_image_url' => 'http://www.your_domain.com/ocdi/preview_import_image1.jpg',
'import_notice' => __( 'After you import this demo, you will have to setup the slider separately.', 'your-textdomain' ),
),
array(
'import_file_name' => 'Demo Import 2',
'categories' => array( 'New category', 'Old category' ),
'import_file_url' => 'http://www.your_domain.com/ocdi/demo-content2.xml',
'import_widget_file_url' => 'http://www.your_domain.com/ocdi/widgets2.json',
'import_customizer_file_url' => 'http://www.your_domain.com/ocdi/customizer2.dat',
'import_redux' => array(
array(
'file_url' => 'http://www.your_domain.com/ocdi/redux.json',
'option_name' => 'redux_option_name',
),
array(
'file_url' => 'http://www.your_domain.com/ocdi/redux2.json',
'option_name' => 'redux_option_name_2',
),
),
'import_preview_image_url' => 'http://www.your_domain.com/ocdi/preview_import_image2.jpg',
'import_notice' => __( 'A special note for this import.', 'your-textdomain' ),
),
);
}
add_filter( 'pt-ocdi/import_files', 'ocdi_import_files' );
`
You can set content import, widgets, customizer and Redux framework import files. You can also define a preview image, which will be used only when multiple demo imports are defined, so that the user will see the difference between imports. Categories can be assigned to each demo import, so that they can be filtered easily.
= How to automatically assign "Front page", "Posts page" and menu locations after the importer is done? =
You can do that, with the `pt-ocdi/after_import` action hook. The code would look something like this:
`
function ocdi_after_import_setup() {
// Assign menus to their locations.
$main_menu = get_term_by( 'name', 'Main Menu', 'nav_menu' );
set_theme_mod( 'nav_menu_locations', array(
'main-menu' => $main_menu->term_id,
)
);
// Assign front page and posts page (blog page).
$front_page_id = get_page_by_title( 'Home' );
$blog_page_id = get_page_by_title( 'Blog' );
update_option( 'show_on_front', 'page' );
update_option( 'page_on_front', $front_page_id->ID );
update_option( 'page_for_posts', $blog_page_id->ID );
}
add_action( 'pt-ocdi/after_import', 'ocdi_after_import_setup' );
`
= What about using local import files (from theme folder)? =
You have to use the same filter as in above example, but with a slightly different array keys: `local_*`. The values have to be absolute paths (not URLs) to your import files. To use local import files, that reside in your theme folder, please use the below code. Note: make sure your import files are readable!
`
function ocdi_import_files() {
return array(
array(
'import_file_name' => 'Demo Import 1',
'categories' => array( 'Category 1', 'Category 2' ),
'local_import_file' => trailingslashit( get_template_directory() ) . 'ocdi/demo-content.xml',
'local_import_widget_file' => trailingslashit( get_template_directory() ) . 'ocdi/widgets.json',
'local_import_customizer_file' => trailingslashit( get_template_directory() ) . 'ocdi/customizer.dat',
'local_import_redux' => array(
array(
'file_path' => trailingslashit( get_template_directory() ) . 'ocdi/redux.json',
'option_name' => 'redux_option_name',
),
),
'import_preview_image_url' => 'http://www.your_domain.com/ocdi/preview_import_image1.jpg',
'import_notice' => __( 'After you import this demo, you will have to setup the slider separately.', 'your-textdomain' ),
),
array(
'import_file_name' => 'Demo Import 2',
'categories' => array( 'New category', 'Old category' ),
'local_import_file' => trailingslashit( get_template_directory() ) . 'ocdi/demo-content2.xml',
'local_import_widget_file' => trailingslashit( get_template_directory() ) . 'ocdi/widgets2.json',
'local_import_customizer_file' => trailingslashit( get_template_directory() ) . 'ocdi/customizer2.dat',
'local_import_redux' => array(
array(
'file_path' => trailingslashit( get_template_directory() ) . 'ocdi/redux.json',
'option_name' => 'redux_option_name',
),
array(
'file_path' => trailingslashit( get_template_directory() ) . 'ocdi/redux2.json',
'option_name' => 'redux_option_name_2',
),
),
'import_preview_image_url' => 'http://www.your_domain.com/ocdi/preview_import_image2.jpg',
'import_notice' => __( 'A special note for this import.', 'your-textdomain' ),
),
);
}
add_filter( 'pt-ocdi/import_files', 'ocdi_import_files' );
`
= How to handle different "after import setups" depending on which predefined import was selected? =
This question might be asked by a theme author wanting to implement different after import setups for multiple predefined demo imports. Lets say we have predefined two demo imports with the following names: 'Demo Import 1' and 'Demo Import 2', the code for after import setup would be (using the `pt-ocdi/after_import` filter):
`
function ocdi_after_import( $selected_import ) {
echo "This will be displayed on all after imports!";
if ( 'Demo Import 1' === $selected_import['import_file_name'] ) {
echo "This will be displayed only on after import if user selects Demo Import 1";
// Set logo in customizer
set_theme_mod( 'logo_img', get_template_directory_uri() . '/assets/images/logo1.png' );
}
elseif ( 'Demo Import 2' === $selected_import['import_file_name'] ) {
echo "This will be displayed only on after import if user selects Demo Import 2";
// Set logo in customizer
set_theme_mod( 'logo_img', get_template_directory_uri() . '/assets/images/logo2.png' );
}
}
add_action( 'pt-ocdi/after_import', 'ocdi_after_import' );
`
= Can I add some code before the widgets get imported? =
Of course you can, use the `pt-ocdi/before_widgets_import` action. You can also target different predefined demo imports like in the example above. Here is a simple example code of the `pt-ocdi/before_widgets_import` action:
`
function ocdi_before_widgets_import( $selected_import ) {
echo "Add your code here that will be executed before the widgets get imported!";
}
add_action( 'pt-ocdi/before_widgets_import', 'ocdi_before_widgets_import' );
`
= I'm a theme author and I want to change the plugin intro text, how can I do that? =
You can change the plugin intro text by using the `pt-ocdi/plugin_intro_text` filter:
`
function ocdi_plugin_intro_text( $default_text ) {
$default_text .= '
This is a custom text added to this plugin intro text.
';
return $default_text;
}
add_filter( 'pt-ocdi/plugin_intro_text', 'ocdi_plugin_intro_text' );
`
To add some text in a separate "box", you should wrap your text in a div with a class of 'ocdi__intro-text', like in the code example above.
= How to disable generation of smaller images (thumbnails) during the content import =
This will greatly improve the time needed to import the content (images), but only the original sized images will be imported. You can disable it with a filter, so just add this code to your theme function.php file:
`add_filter( 'pt-ocdi/regenerate_thumbnails_in_content_import', '__return_false' );`
= How to change the location, title and other parameters of the plugin page? =
As a theme author you do not like the location of the "Import Demo Data" plugin page in *Appearance -> Import Demo Data*? You can change that with the filter below. Apart from the location, you can also change the title or the page/menu and some other parameters as well.
`
function ocdi_plugin_page_setup( $default_settings ) {
$default_settings['parent_slug'] = 'themes.php';
$default_settings['page_title'] = esc_html__( 'One Click Demo Import' , 'pt-ocdi' );
$default_settings['menu_title'] = esc_html__( 'Import Demo Data' , 'pt-ocdi' );
$default_settings['capability'] = 'import';
$default_settings['menu_slug'] = 'pt-one-click-demo-import';
return $default_settings;
}
add_filter( 'pt-ocdi/plugin_page_setup', 'ocdi_plugin_page_setup' );
`
= How to do something before the content import executes? =
In version 2.0.0 there is a new action hook: `pt-ocdi/before_content_import`, which will let you hook before the content import starts. An example of the code would look like this:
`
function ocdi_before_content_import( $selected_import ) {
if ( 'Demo Import 1' === $selected_import['import_file_name'] ) {
// Here you can do stuff for the "Demo Import 1" before the content import starts.
echo "before import 1";
}
else {
// Here you can do stuff for all other imports before the content import starts.
echo "before import 2";
}
}
add_action( 'pt-ocdi/before_content_import', 'ocdi_before_content_import' );
`
= How can I enable the `customize_save*` wp action hooks in the customizer import? =
It's easy, just add this to your theme:
`add_action( 'pt-ocdi/enable_wp_customize_save_hooks', '__return_true' );`
This will enable the following WP hooks when importing the customizer data: `customize_save`, `customize_save_*`, `customize_save_after`.
= How to configure the multi grid layout import popup confirmation? =
If you want to disable the popup confirmation modal window, use this filter:
`add_filter( 'pt-ocdi/enable_grid_layout_import_popup_confirmation', '__return_false' );`
If you want to just change some options for the jQuery modal window we use for the popup confirmation, then use this filter:
`
function my_theme_ocdi_confirmation_dialog_options ( $options ) {
return array_merge( $options, array(
'width' => 300,
'dialogClass' => 'wp-dialog',
'resizable' => false,
'height' => 'auto',
'modal' => true,
) );
}
add_filter( 'pt-ocdi/confirmation_dialog_options', 'my_theme_ocdi_confirmation_dialog_options', 10, 1 );
`
= How can I disable the ProteusThemes branding notice after successful demo import? =
You can disable the branding notice with a WP filter. All you need to do is add this bit of code to your theme:
`add_filter( 'pt-ocdi/disable_pt_branding', '__return_true' );`
and the notice will not be displayed.
= I can't activate the plugin, because of a fatal error, what can I do? =
*Update: since version 1.2.0, there is now a admin error notice, stating that the minimal PHP version required for this plugin is 5.3.2.*
You want to activate the plugin, but this error shows up:
*Plugin could not be activated because it triggered a fatal error*
This happens, because your hosting server is using a very old version of PHP. This plugin requires PHP version of at least **5.3.x**, but we recommend version *5.6.x* or better yet *7.x*. Please contact your hosting company and ask them to update the PHP version for your site.
= Issues with the import, that we can't fix in the plugin =
Please visit this [docs page](https://github.com/proteusthemes/one-click-demo-import/blob/master/docs/import-problems.md), for more answers to issues with importing data.
== Screenshots ==
1. Example of multiple predefined demo imports, that a user can choose from.
2. How the import page looks like, when only one demo import is predefined.
3. Example of how the import page looks like, when no demo imports are predefined a.k.a manual import.
== Changelog ==
= 2.2.1 =
*Release Date - 3 April 2017*
* Fix image importing error for server compressed files,
* Fix remapping of featured images,
* Fix custom post type existing posts check (no more multiple imports for custom post types).
= 2.2.0 =
*Release Date - 5 February 2017*
* Add ProteusThemes branding notice after successful import,
* Fix after import error reporting (duplicate errors were shown),
* Fix some undefined variables in the plugin, causing PHP notices.
= 2.1.0 =
*Release Date - 8 January 2017*
* Add grid layout import confirmation popup options filter,
* Fix term meta data double import,
* Fix WooCommerce product attributes import.
= 2.0.2 =
*Release Date - 13 December 2016*
* Fix issue with customizer options import
= 2.0.1 =
*Release Date - 12 December 2016*
* Fix issue with some browsers (Safari and IE) not supporting some FormData methods.
= 2.0.0 =
*Release Date - 10 December 2016*
* Add new layout for multiple predefined demo imports (a grid layout instead of the dropdown selector),
* Add support for Redux framework import,
* Change the code structure of the plugin (plugin rewrite, namespaces, autoloading),
* Now the whole import (content, widgets, customizer, redux) goes through even if something goes wrong in the content import (before content import errors blocked further import),
* Add `pt-ocdi/before_content_import` action hook, that theme authors can use to hook into before the content import starts,
* Fix frontend error reporting through multiple AJAX calls,
* Fix post formats (video/quote/gallery,...) not importing,
* Fix customizer import does not save some options (because of the missing WP actions - these can be enabled via a filter, more in the FAQ section).
= 1.4.0 =
*Release Date - 29 October 2016*
* Add support for WP term meta data in content importer,
* Fix the issue of having both plugins (OCDI and the new WP importer v2) activated at the same time.
= 1.3.0 =
*Release Date - 1 October 2016*
* Import/plugin page re-design. Updated the plugin page styles to match WordPress (thanks to Oliver Juhas).
= 1.2.0 =
*Release Date - 9 July 2016*
* Now also accepts predefined local import files (from theme folder),
* Fixes PHP fatal error on plugin activation, for sites using PHP versions older then 5.3.2 (added admin error notice),
* Register log file in *wp-admin -> Media*, so that it's easier to access,
* No more "[WARNING] Could not find the author for ..." messages in the log file.
= 1.1.3 =
*Release Date - 17 June 2016*
* Updated plugin design,
* Changed the plugin page setup filter name from `pt-ocdi/plugin-page-setup` to `pt-ocdi/plugin_page_setup` (mind the underscore characters instead of dashes).
= 1.1.2 =
*Release Date - 12 June 2016*
* An 'import notice' field has been added to the predefined demo import settings. This notice is displayed above the import button (it also accepts HTML),
* Now displays proper error message, if the file-system method is not set to "direct",
* This plugin is now compatible with the new [Humanmade content importer plugin](https://github.com/humanmade/WordPress-Importer),
* Added a filter to the plugin page creation, so that theme authors can now change the location of the plugin page (Demo data import) and some other parameters as well.
= 1.1.1 =
*Release Date - 22 May 2016*
* Preview import images can now be defined for multiple predefined import files (check FAQ "How to predefine demo imports?" for more info),
* You can now also import customizer settings.
= 1.1.0 =
*Release Date - 14 May 2016*
* Content import now imports in multiple AJAX calls, so there should be no more server timeout errors,
* The setting for generation of multiple image sizes in the content import is again enabled by default,
* Plugin textdomain was loaded, so that translations can be made.
= 1.0.3 =
*Release Date - 27 April 2016*
* Added filter to enable image regeneration,
* Added filter to change the plugin intro text,
* Added action to execute custom code before widget import,
* Disabled author imports.
= 1.0.2 =
*Release Date - 15 April 2016*
* Monkey fix for WP version 4.5. - disabled generation of multiple image sizes in the content import.
= 1.0.1 =
*Release Date - 2 April 2016*
Small code fixes:
* Fixed undefined variable bug,
* Fixed naming of downloaded files and their filters.
= 1.0.0 =
*Release Date - 25 March 2016*
* Initial release!
assets/js/main.js 0000666 00000022622 15213303300 0007742 0 ustar 00 jQuery( function ( $ ) {
'use strict';
/**
* ---------------------------------------
* ------------- Events ------------------
* ---------------------------------------
*/
/**
* No or Single predefined demo import button click.
*/
$( '.js-ocdi-import-data' ).on( 'click', function () {
// Reset response div content.
$( '.js-ocdi-ajax-response' ).empty();
// Prepare data for the AJAX call
var data = new FormData();
data.append( 'action', 'ocdi_import_demo_data' );
data.append( 'security', ocdi.ajax_nonce );
data.append( 'selected', $( '#ocdi__demo-import-files' ).val() );
if ( $('#ocdi__content-file-upload').length ) {
data.append( 'content_file', $('#ocdi__content-file-upload')[0].files[0] );
}
if ( $('#ocdi__widget-file-upload').length ) {
data.append( 'widget_file', $('#ocdi__widget-file-upload')[0].files[0] );
}
if ( $('#ocdi__customizer-file-upload').length ) {
data.append( 'customizer_file', $('#ocdi__customizer-file-upload')[0].files[0] );
}
if ( $('#ocdi__redux-file-upload').length ) {
data.append( 'redux_file', $('#ocdi__redux-file-upload')[0].files[0] );
data.append( 'redux_option_name', $('#ocdi__redux-option-name').val() );
}
// AJAX call to import everything (content, widgets, before/after setup)
ajaxCall( data );
});
/**
* Grid Layout import button click.
*/
$( '.js-ocdi-gl-import-data' ).on( 'click', function () {
var selectedImportID = $( this ).val();
var $itemContainer = $( this ).closest( '.js-ocdi-gl-item' );
// If the import confirmation is enabled, then do that, else import straight away.
if ( ocdi.import_popup ) {
displayConfirmationPopup( selectedImportID, $itemContainer );
}
else {
gridLayoutImport( selectedImportID, $itemContainer );
}
});
/**
* Grid Layout categories navigation.
*/
(function () {
// Cache selector to all items
var $items = $( '.js-ocdi-gl-item-container' ).find( '.js-ocdi-gl-item' ),
fadeoutClass = 'ocdi-is-fadeout',
fadeinClass = 'ocdi-is-fadein',
animationDuration = 200;
// Hide all items.
var fadeOut = function () {
var dfd = jQuery.Deferred();
$items
.addClass( fadeoutClass );
setTimeout( function() {
$items
.removeClass( fadeoutClass )
.hide();
dfd.resolve();
}, animationDuration );
return dfd.promise();
};
var fadeIn = function ( category, dfd ) {
var filter = category ? '[data-categories*="' + category + '"]' : 'div';
if ( 'all' === category ) {
filter = 'div';
}
$items
.filter( filter )
.show()
.addClass( 'ocdi-is-fadein' );
setTimeout( function() {
$items
.removeClass( fadeinClass );
dfd.resolve();
}, animationDuration );
};
var animate = function ( category ) {
var dfd = jQuery.Deferred();
var promise = fadeOut();
promise.done( function () {
fadeIn( category, dfd );
} );
return dfd;
};
$( '.js-ocdi-nav-link' ).on( 'click', function( event ) {
event.preventDefault();
// Remove 'active' class from the previous nav list items.
$( this ).parent().siblings().removeClass( 'active' );
// Add the 'active' class to this nav list item.
$( this ).parent().addClass( 'active' );
var category = this.hash.slice(1);
// show/hide the right items, based on category selected
var $container = $( '.js-ocdi-gl-item-container' );
$container.css( 'min-width', $container.outerHeight() );
var promise = animate( category );
promise.done( function () {
$container.removeAttr( 'style' );
} );
} );
}());
/**
* Grid Layout search functionality.
*/
$( '.js-ocdi-gl-search' ).on( 'keyup', function( event ) {
if ( 0 < $(this).val().length ) {
// Hide all items.
$( '.js-ocdi-gl-item-container' ).find( '.js-ocdi-gl-item' ).hide();
// Show just the ones that have a match on the import name.
$( '.js-ocdi-gl-item-container' ).find( '.js-ocdi-gl-item[data-name*="' + $(this).val().toLowerCase() + '"]' ).show();
}
else {
$( '.js-ocdi-gl-item-container' ).find( '.js-ocdi-gl-item' ).show();
}
} );
/**
* ---------------------------------------
* --------Helper functions --------------
* ---------------------------------------
*/
/**
* Prepare grid layout import data and execute the AJAX call.
*
* @param int selectedImportID The selected import ID.
* @param obj $itemContainer The jQuery selected item container object.
*/
function gridLayoutImport( selectedImportID, $itemContainer ) {
// Reset response div content.
$( '.js-ocdi-ajax-response' ).empty();
// Hide all other import items.
$itemContainer.siblings( '.js-ocdi-gl-item' ).fadeOut( 500 );
$itemContainer.animate({
opacity: 0
}, 500, 'swing', function () {
$itemContainer.animate({
opacity: 1
}, 500 )
});
// Hide the header with category navigation and search box.
$itemContainer.closest( '.js-ocdi-gl' ).find( '.js-ocdi-gl-header' ).fadeOut( 500 );
// Append a title for the selected demo import.
$itemContainer.parent().prepend( '
' + ocdi.texts.selected_import_title + '
' );
// Remove the import button of the selected item.
$itemContainer.find( '.js-ocdi-gl-import-data' ).remove();
// Prepare data for the AJAX call
var data = new FormData();
data.append( 'action', 'ocdi_import_demo_data' );
data.append( 'security', ocdi.ajax_nonce );
data.append( 'selected', selectedImportID );
// AJAX call to import everything (content, widgets, before/after setup)
ajaxCall( data );
}
/**
* Display the confirmation popup.
*
* @param int selectedImportID The selected import ID.
* @param obj $itemContainer The jQuery selected item container object.
*/
function displayConfirmationPopup( selectedImportID, $itemContainer ) {
var $dialogContiner = $( '#js-ocdi-modal-content' );
var currentFilePreviewImage = ocdi.import_files[ selectedImportID ]['import_preview_image_url'] || ocdi.theme_screenshot;
var previewImageContent = '';
var importNotice = ocdi.import_files[ selectedImportID ]['import_notice'] || '';
var importNoticeContent = '';
var dialogOptions = $.extend(
{
'dialogClass': 'wp-dialog',
'resizable': false,
'height': 'auto',
'modal': true
},
ocdi.dialog_options,
{
'buttons':
[
{
text: ocdi.texts.dialog_no,
click: function() {
$(this).dialog('close');
}
},
{
text: ocdi.texts.dialog_yes,
class: 'button button-primary',
click: function() {
$(this).dialog('close');
gridLayoutImport( selectedImportID, $itemContainer );
}
}
]
});
if ( '' === currentFilePreviewImage ) {
previewImageContent = '
' +
previewImageContent +
importNoticeContent
);
// Display the confirmation popup.
$dialogContiner.dialog( dialogOptions );
}
/**
* The main AJAX call, which executes the import process.
*
* @param FormData data The data to be passed to the AJAX call.
*/
function ajaxCall( data ) {
$.ajax({
method: 'POST',
url: ocdi.ajax_url,
data: data,
contentType: false,
processData: false,
beforeSend: function() {
$( '.js-ocdi-ajax-loader' ).show();
}
})
.done( function( response ) {
if ( 'undefined' !== typeof response.status && 'newAJAX' === response.status ) {
ajaxCall( data );
}
else if ( 'undefined' !== typeof response.status && 'customizerAJAX' === response.status ) {
// Fix for data.set and data.delete, which they are not supported in some browsers.
var newData = new FormData();
newData.append( 'action', 'ocdi_import_customizer_data' );
newData.append( 'security', ocdi.ajax_nonce );
// Set the wp_customize=on only if the plugin filter is set to true.
if ( true === ocdi.wp_customize_on ) {
newData.append( 'wp_customize', 'on' );
}
ajaxCall( newData );
}
else if ( 'undefined' !== typeof response.status && 'afterAllImportAJAX' === response.status ) {
// Fix for data.set and data.delete, which they are not supported in some browsers.
var newData = new FormData();
newData.append( 'action', 'ocdi_after_import_data' );
newData.append( 'security', ocdi.ajax_nonce );
ajaxCall( newData );
}
else if ( 'undefined' !== typeof response.message ) {
$( '.js-ocdi-ajax-response' ).append( '
' );
$( '.js-ocdi-ajax-loader' ).hide();
});
}
} );
assets/css/main.css 0000666 00000012115 15213303300 0010266 0 ustar 00 /* Overriding WordPress native styles */
.ocdi {
max-width: none;
}
.ocdi h2 {
text-align: inherit;
}
.ocdi h2:first-child,
.ocdi h3:first-child {
margin-top: 0;
}
.ocdi hr {
margin: 2.62em 0;
}
.feature-section + hr {
margin-top: 0;
}
#wpbody select {
height: auto;
padding: .62em;
line-height: inherit;
}
.ocdi .notice {
display: block !important;
}
/* Plugin elements */
.ocdi__demo-import-files {
width: 100%;
}
.ocdi__demo-import-preview-image-message {
font-style: italic;
}
/* Plugin title */
.ocdi__title:before {
width: auto;
height: auto;
font-size: inherit;
}
/* Plugin intro text */
.ocdi__intro-text ul {
padding: 0 4%;
list-style-type: square;
}
/* Plugin multi select import and Plugin file upload containers */
.ocdi__file-upload,
.ocdi__multi-select-import,
.ocdi__demo-import-notice:not(:empty) {
padding: 4%;
margin: 1.62em 0;
background-color: #ffffff;
border: 1px solid #e5e5e5;
}
.ocdi__file-upload {
margin: 0;
margin-bottom: -1px;
}
.ocdi__file-upload span {
font-size: .81em;
font-weight: normal;
opacity: .66;
}
.ocdi__demo-import-notice:not(:empty) {
border: 0;
border-left: 4px solid #00a0d2;
-webkit-box-shadow: 0 1px 1px 0 rgba(0,0,0,.1);
box-shadow: 0 1px 1px 0 rgba(0,0,0,.1);
}
[dir="rtl"] .ocdi__demo-import-notice:not(:empty) {
border: 0;
border-right: 4px solid #00a0d2;
}
/* Plugin button */
.ocdi__button-container {
margin-top: 1.62em;
}
/* AJAX loader */
p.ocdi__ajax-loader {
font-size: 1.5em;
display: none;
}
.ocdi__ajax-loader .spinner {
display: inline-block;
float: none;
visibility: visible;
margin-bottom: 6px;
}
/* New grid layout */
.ocdi__gl-navigation li a {
-webkit-box-shadow: none;
box-shadow: none;
}
.ocdi__gl-item {
float: left;
width: 100%;
margin: 0 0 20px 0;
position: relative;
border: 1px solid #ddd;
-webkit-box-shadow: 0 1px 1px -1px rgba(0,0,0,0.1);
box-shadow: 0 1px 1px -1px rgba(0,0,0,0.1);
-webkit-box-sizing: border-box;
-moz-box-sizing: border-box;
box-sizing: border-box;
}
.ocdi__gl-item-image-container {
display: block;
overflow: hidden;
position: relative;
-webkit-backface-visibility: hidden;
-webkit-transition: opacity 0.2s ease-in-out;
transition: opacity 0.2s ease-in-out;
}
.ocdi__gl-item-image-container::after {
content: "";
display: block;
padding-top: 66.66666%;
}
.ocdi__gl-item-image {
height: auto;
position: absolute;
left: 0;
top: 0;
width: 100%;
-webkit-transition: opacity 0.2s ease-in-out;
transition: opacity 0.2s ease-in-out;
}
.ocdi__gl-item-image--no-image {
display: inline-block;
width: 50%;
text-align: center;
position: absolute;
top: 45%;
right: 25%;
left: 25%;
}
.ocdi__gl-item-footer {
height: 30px;
margin: 0;
padding: 10px;
-webkit-box-shadow: inset 0 1px 0 rgba(0,0,0,0.1);
box-shadow: inset 0 1px 0 rgba(0,0,0,0.1);
background: #ffffff;
background: rgba(255,255,255,0.65);
}
h4.ocdi__gl-item-title {
width: 70%;
overflow: hidden;
white-space: nowrap;
text-overflow: ellipsis;
display: inline-block;
margin: 6px 0 0 0;
}
.ocdi__gl-item-button {
float: right;
}
.ocdi__gl-header {
display: inline-block;
width: calc(100% - 40px);
background-color: #ffffff;
margin-bottom: 20px;
padding: 0 20px;
}
.ocdi__gl-navigation {
font-size: 13px;
width: 100%;
float: left;
}
.ocdi__gl-navigation ul {
list-style-type: none;
margin: 0;
padding: 0;
overflow: hidden;
}
.ocdi__gl-navigation li {
float: left;
margin: 0 15px;
}
.ocdi__gl-navigation li.active a,
.ocdi__gl-navigation li.active a:hover {
border-bottom: 4px solid #666666;
}
.ocdi__gl-navigation li a {
display: block;
text-align: center;
text-decoration: none;
color: #444444;
border-bottom: 4px solid #ffffff;
padding: 15px 0;
}
.ocdi__gl-navigation li a:hover {
color: #00a0d2;
border-bottom: 4px solid #ffffff;
cursor:pointer;
}
.ocdi__gl-search-input {
width: 100%;
margin: 10px 0;
}
@media (min-width: 640px) {
.ocdi__gl-navigation {
width: calc(100% - 180px);
}
.ocdi__gl-navigation li {
margin: 0;
}
.ocdi__gl-navigation li a {
padding: 15px;
}
.ocdi__gl-search-input {
display: inline-block;
width: 180px;
height: 30px;
margin: 0;
margin-top: 11px;
}
.ocdi__gl-item-container {
margin-right: -20px;
}
.ocdi__gl-item {
width: calc(50% - 20px);
margin: 0 20px 20px 0;
}
}
@media (min-width: 1120px) {
.ocdi__gl-item-container {
margin-right: -30px;
}
.ocdi__gl-item {
width: calc(33.333% - 30px);
margin: 0 30px 30px 0;
}
}
/* Grid animations */
@keyframes ocdi-fade {
from {
opacity: 1;
}
to {
opacity: 0;
}
}
.ocdi-is-fadeout {
animation: ocdi-fade linear 200ms 1 forwards;
}
.ocdi-is-fadein {
animation: ocdi-fade linear 200ms 1 reverse forwards;
}
/* Grid layout modal window */
.ocdi__modal-image-container {
width: 100%;
height: 180px;
margin: 0;
overflow: hidden;
}
.ocdi__modal-item-title {
margin-top: 0.5em;
font-weight: bold;
}
.ocdi__modal-image-container img {
width: 100%;
}
.ocdi__modal-notice.ocdi__demo-import-notice:not(:empty) {
border: 1px solid #e5e5e5;
border-left: 4px solid #00a0d2;
margin: 1em 0 0;
}
/* Redux */
.ocdi__redux-option-name-label {
margin-right: 5px;
}
inc/Helpers.php 0000666 00000052456 15213303300 0007436 0 ustar 00 ',
$import_file_info['import_file_name'],
''
)
);
}
}
else {
// Set the filename string for content import file.
$content_filename = apply_filters( 'pt-ocdi/downloaded_content_file_prefix', 'demo-content-import-file_' ) . self::$demo_import_start_time . apply_filters( 'pt-ocdi/downloaded_content_file_suffix_and_file_extension', '.xml' );
// Download the content import file.
$downloaded_files['content'] = $downloader->download_file( $import_file_info['import_file_url'], $content_filename );
// Return from this function if there was an error.
if ( is_wp_error( $downloaded_files['content'] ) ) {
return $downloaded_files['content'];
}
}
// ----- Set widget file path -----
// Get widgets file as well. If defined!
if ( ! empty( $import_file_info['import_widget_file_url'] ) ) {
// Set the filename string for widgets import file.
$widget_filename = apply_filters( 'pt-ocdi/downloaded_widgets_file_prefix', 'demo-widgets-import-file_' ) . self::$demo_import_start_time . apply_filters( 'pt-ocdi/downloaded_widgets_file_suffix_and_file_extension', '.json' );
// Download the widgets import file.
$downloaded_files['widgets'] = $downloader->download_file( $import_file_info['import_widget_file_url'], $widget_filename );
// Return from this function if there was an error.
if ( is_wp_error( $downloaded_files['widgets'] ) ) {
return $downloaded_files['widgets'];
}
}
else if ( ! empty( $import_file_info['local_import_widget_file'] ) ) {
if ( file_exists( $import_file_info['local_import_widget_file'] ) ) {
$downloaded_files['widgets'] = $import_file_info['local_import_widget_file'];
}
}
// ----- Set customizer file path -----
// Get customizer import file as well. If defined!
if ( ! empty( $import_file_info['import_customizer_file_url'] ) ) {
// Setup filename path to save the customizer content.
$customizer_filename = apply_filters( 'pt-ocdi/downloaded_customizer_file_prefix', 'demo-customizer-import-file_' ) . self::$demo_import_start_time . apply_filters( 'pt-ocdi/downloaded_customizer_file_suffix_and_file_extension', '.dat' );
// Download the customizer import file.
$downloaded_files['customizer'] = $downloader->download_file( $import_file_info['import_customizer_file_url'], $customizer_filename );
// Return from this function if there was an error.
if ( is_wp_error( $downloaded_files['customizer'] ) ) {
return $downloaded_files['customizer'];
}
}
else if ( ! empty( $import_file_info['local_import_customizer_file'] ) ) {
if ( file_exists( $import_file_info['local_import_customizer_file'] ) ) {
$downloaded_files['customizer'] = $import_file_info['local_import_customizer_file'];
}
}
// ----- Set Redux file paths -----
// Get Redux import file as well. If defined!
if ( ! empty( $import_file_info['import_redux'] ) && is_array( $import_file_info['import_redux'] ) ) {
$redux_items = array();
// Setup filename paths to save the Redux content.
foreach ( $import_file_info['import_redux'] as $index => $redux_item ) {
$redux_filename = apply_filters( 'pt-ocdi/downloaded_redux_file_prefix', 'demo-redux-import-file_' ) . $index . '-' . self::$demo_import_start_time . apply_filters( 'pt-ocdi/downloaded_redux_file_suffix_and_file_extension', '.json' );
// Download the Redux import file.
$file_path = $downloader->download_file( $redux_item['file_url'], $redux_filename );
// Return from this function if there was an error.
if ( is_wp_error( $file_path ) ) {
return $file_path;
}
$redux_items[] = array(
'option_name' => $redux_item['option_name'],
'file_path' => $file_path,
);
}
// Download the Redux import file.
$downloaded_files['redux'] = $redux_items;
}
else if ( ! empty( $import_file_info['local_import_redux'] ) ) {
$redux_items = array();
// Setup filename paths to save the Redux content.
foreach ( $import_file_info['local_import_redux'] as $redux_item ) {
if ( file_exists( $redux_item['file_path'] ) ) {
$redux_items[] = $redux_item;
}
}
// Download the Redux import file.
$downloaded_files['redux'] = $redux_items;
}
return $downloaded_files;
}
/**
* Write content to a file.
*
* @param string $content content to be saved to the file.
* @param string $file_path file path where the content should be saved.
* @return string|WP_Error path to the saved file or WP_Error object with error message.
*/
public static function write_to_file( $content, $file_path ) {
// Verify WP file-system credentials.
$verified_credentials = self::check_wp_filesystem_credentials();
if ( is_wp_error( $verified_credentials ) ) {
return $verified_credentials;
}
// By this point, the $wp_filesystem global should be working, so let's use it to create a file.
global $wp_filesystem;
if ( ! $wp_filesystem->put_contents( $file_path, $content ) ) {
return new \WP_Error(
'failed_writing_file_to_server',
sprintf(
__( 'An error occurred while writing file to your server! Tried to write a file to: %s%s.', 'pt-ocdi' ),
' ',
$file_path
)
);
}
// Return the file path on successful file write.
return $file_path;
}
/**
* Append content to the file.
*
* @param string $content content to be saved to the file.
* @param string $file_path file path where the content should be saved.
* @param string $separator_text separates the existing content of the file with the new content.
* @return boolean|WP_Error, path to the saved file or WP_Error object with error message.
*/
public static function append_to_file( $content, $file_path, $separator_text = '' ) {
// Verify WP file-system credentials.
$verified_credentials = self::check_wp_filesystem_credentials();
if ( is_wp_error( $verified_credentials ) ) {
return $verified_credentials;
}
// By this point, the $wp_filesystem global should be working, so let's use it to create a file.
global $wp_filesystem;
$existing_data = '';
if ( file_exists( $file_path ) ) {
$existing_data = $wp_filesystem->get_contents( $file_path );
}
// Style separator.
$separator = PHP_EOL . '---' . $separator_text . '---' . PHP_EOL;
if ( ! $wp_filesystem->put_contents( $file_path, $existing_data . $separator . $content . PHP_EOL ) ) {
return new \WP_Error(
'failed_writing_file_to_server',
sprintf(
__( 'An error occurred while writing file to your server! Tried to write a file to: %s%s.', 'pt-ocdi' ),
' ',
$file_path
)
);
}
return true;
}
/**
* Get data from a file
*
* @param string $file_path file path where the content should be saved.
* @return string $data, content of the file or WP_Error object with error message.
*/
public static function data_from_file( $file_path ) {
// Verify WP file-system credentials.
$verified_credentials = self::check_wp_filesystem_credentials();
if ( is_wp_error( $verified_credentials ) ) {
return $verified_credentials;
}
// By this point, the $wp_filesystem global should be working, so let's use it to read a file.
global $wp_filesystem;
$data = $wp_filesystem->get_contents( $file_path );
if ( ! $data ) {
return new \WP_Error(
'failed_reading_file_from_server',
sprintf(
__( 'An error occurred while reading a file from your server! Tried reading file from path: %s%s.', 'pt-ocdi' ),
' ',
$file_path
)
);
}
// Return the file data.
return $data;
}
/**
* Helper function: check for WP file-system credentials needed for reading and writing to a file.
*
* @return boolean|WP_Error
*/
private static function check_wp_filesystem_credentials() {
// Check if the file-system method is 'direct', if not display an error.
if ( ! ( 'direct' === get_filesystem_method() ) ) {
return new \WP_Error(
'no_direct_file_access',
sprintf(
__( 'This WordPress page does not have %sdirect%s write file access. This plugin needs it in order to save the demo import xml file to the upload directory of your site. You can change this setting with these instructions: %s.', 'pt-ocdi' ),
'',
'',
'How to set direct filesystem method'
)
);
}
// Get plugin page settings.
$plugin_page_setup = apply_filters( 'pt-ocdi/plugin_page_setup', array(
'parent_slug' => 'themes.php',
'page_title' => esc_html__( 'One Click Demo Import' , 'pt-ocdi' ),
'menu_title' => esc_html__( 'Import Demo Data' , 'pt-ocdi' ),
'capability' => 'import',
'menu_slug' => 'pt-one-click-demo-import',
)
);
// Get user credentials for WP file-system API.
$demo_import_page_url = wp_nonce_url( $plugin_page_setup['parent_slug'] . '?page=' . $plugin_page_setup['menu_slug'], $plugin_page_setup['menu_slug'] );
if ( false === ( $creds = request_filesystem_credentials( $demo_import_page_url, '', false, false, null ) ) ) {
return new \WP_error(
'filesystem_credentials_could_not_be_retrieved',
__( 'An error occurred while retrieving reading/writing permissions to your server (could not retrieve WP filesystem credentials)!', 'pt-ocdi' )
);
}
// Now we have credentials, try to get the wp_filesystem running.
if ( ! WP_Filesystem( $creds ) ) {
return new \WP_Error(
'wrong_login_credentials',
__( 'Your WordPress login credentials don\'t allow to use WP_Filesystem!', 'pt-ocdi' )
);
}
return true;
}
/**
* Get log file path
*
* @return string, path to the log file
*/
public static function get_log_path() {
$upload_dir = wp_upload_dir();
$upload_path = apply_filters( 'pt-ocdi/upload_file_path', trailingslashit( $upload_dir['path'] ) );
$log_path = $upload_path . apply_filters( 'pt-ocdi/log_file_prefix', 'log_file_' ) . self::$demo_import_start_time . apply_filters( 'pt-ocdi/log_file_suffix_and_file_extension', '.txt' );
self::register_file_as_media_attachment( $log_path );
return $log_path;
}
/**
* Register file as attachment to the Media page.
*
* @param string $log_path log file path.
* @return void
*/
public static function register_file_as_media_attachment( $log_path ) {
// Check the type of file.
$log_mimes = array( 'txt' => 'text/plain' );
$filetype = wp_check_filetype( basename( $log_path ), apply_filters( 'pt-ocdi/file_mimes', $log_mimes ) );
// Prepare an array of post data for the attachment.
$attachment = array(
'guid' => self::get_log_url( $log_path ),
'post_mime_type' => $filetype['type'],
'post_title' => apply_filters( 'pt-ocdi/attachment_prefix', esc_html__( 'One Click Demo Import - ', 'pt-ocdi' ) ) . preg_replace( '/\.[^.]+$/', '', basename( $log_path ) ),
'post_content' => '',
'post_status' => 'inherit',
);
// Insert the file as attachment in Media page.
$attach_id = wp_insert_attachment( $attachment, $log_path );
}
/**
* Get log file url
*
* @param string $log_path log path to use for the log filename.
* @return string, url to the log file.
*/
public static function get_log_url( $log_path ) {
$upload_dir = wp_upload_dir();
$upload_url = apply_filters( 'pt-ocdi/upload_file_url', trailingslashit( $upload_dir['url'] ) );
return $upload_url . basename( $log_path );
}
/**
* Check if the AJAX call is valid.
*/
public static function verify_ajax_call() {
check_ajax_referer( 'ocdi-ajax-verification', 'security' );
// Check if user has the WP capability to import data.
if ( ! current_user_can( 'import' ) ) {
wp_die(
sprintf(
__( '%sYour user role isn\'t high enough. You don\'t have permission to import demo data.%s', 'pt-ocdi' ),
'
',
'
'
)
);
}
}
/**
* Process uploaded files and return the paths to these files.
*
* @param array $uploaded_files $_FILES array form an AJAX request.
* @param string $log_file_path path to the log file.
* @return array of paths to the content import and widget import files.
*/
public static function process_uploaded_files( $uploaded_files, $log_file_path ) {
// Variable holding the paths to the uploaded files.
$selected_import_files = array();
// Upload settings to disable form and type testing for AJAX uploads.
$upload_overrides = array(
'test_form' => false,
'test_type' => false,
);
// Handle demo content and widgets file upload.
$content_file_info = wp_handle_upload( $_FILES['content_file'], $upload_overrides );
$widget_file_info = wp_handle_upload( $_FILES['widget_file'], $upload_overrides );
$customizer_file_info = wp_handle_upload( $_FILES['customizer_file'], $upload_overrides );
$redux_file_info = wp_handle_upload( $_FILES['redux_file'], $upload_overrides );
if ( empty( $content_file_info['file'] ) || isset( $content_file_info['error'] ) ) {
// Write error to log file and send an AJAX response with the error.
self::log_error_and_send_ajax_response(
__( 'Please upload XML file for content import. If you want to import widgets or customizer settings only, please use Widget Importer & Exporter or the Customizer Export/Import plugin.', 'pt-ocdi' ),
$log_file_path,
esc_html__( 'Upload files', 'pt-ocdi' )
);
}
// Set uploaded content file.
$selected_import_files['content'] = $content_file_info['file'];
// Process widget import file.
if ( $widget_file_info && ! isset( $widget_file_info['error'] ) ) {
// Set uploaded widget file.
$selected_import_files['widgets'] = $widget_file_info['file'];
}
else {
// Add this error to log file.
$log_added = self::append_to_file(
sprintf(
__( 'Widget file was not uploaded. Error: %s', 'pt-ocdi' ),
$widget_file_info['error']
),
$log_file_path,
esc_html__( 'Upload files' , 'pt-ocdi' )
);
}
// Process Customizer import file.
if ( $customizer_file_info && ! isset( $customizer_file_info['error'] ) ) {
// Set uploaded customizer file.
$selected_import_files['customizer'] = $customizer_file_info['file'];
}
else {
// Add this error to log file.
$log_added = self::append_to_file(
sprintf(
__( 'Customizer file was not uploaded. Error: %s', 'pt-ocdi' ),
$customizer_file_info['error']
),
$log_file_path,
esc_html__( 'Upload files' , 'pt-ocdi' )
);
}
// Process Redux import file.
if ( $redux_file_info && ! isset( $redux_file_info['error'] ) ) {
if ( isset( $_POST['redux_option_name'] ) && empty( $_POST['redux_option_name'] ) ) {
// Write error to log file and send an AJAX response with the error.
self::log_error_and_send_ajax_response(
esc_html__( 'Missing Redux option name! Please also enter the Redux option name!', 'pt-ocdi' ),
$log_file_path,
esc_html__( 'Upload files', 'pt-ocdi' )
);
}
// Set uploaded Redux file.
$selected_import_files['redux'] = array(
array(
'option_name' => $_POST['redux_option_name'],
'file_path' => $redux_file_info['file'],
),
);
}
else {
// Add this error to log file.
$log_added = self::append_to_file(
sprintf(
__( 'Redux file was not uploaded. Error: %s', 'pt-ocdi' ),
$redux_file_info['error']
),
$log_file_path,
esc_html__( 'Upload files' , 'pt-ocdi' )
);
}
// Add this message to log file.
$log_added = self::append_to_file(
__( 'The import files were successfully uploaded!', 'pt-ocdi' ) . self::import_file_info( $selected_import_files ),
$log_file_path,
esc_html__( 'Upload files' , 'pt-ocdi' )
);
// Return array with paths of uploaded files.
return $selected_import_files;
}
/**
* Get import file information and max execution time.
*
* @param array $selected_import_files array of selected import files.
*/
public static function import_file_info( $selected_import_files ) {
$redux_file_string = '';
if ( ! empty( $selected_import_files['redux'] ) ) {
$redux_file_string = array_reduce( $selected_import_files['redux'], function( $string, $item ) {
return sprintf( '%1$s%2$s -> %3$s %4$s', $string, $item['option_name'], $item['file_path'], PHP_EOL );
}, '' );
}
return PHP_EOL .
sprintf(
__( 'Initial max execution time = %s', 'pt-ocdi' ),
ini_get( 'max_execution_time' )
) . PHP_EOL .
sprintf(
__( 'Files info:%1$sSite URL = %2$s%1$sData file = %3$s%1$sWidget file = %4$s%1$sCustomizer file = %5$s%1$sRedux files:%1$s%6$s', 'pt-ocdi' ),
PHP_EOL,
get_site_url(),
$selected_import_files['content'],
empty( $selected_import_files['widgets'] ) ? esc_html__( 'not defined!', 'pt-ocdi' ) : $selected_import_files['widgets'],
empty( $selected_import_files['customizer'] ) ? esc_html__( 'not defined!', 'pt-ocdi' ) : $selected_import_files['customizer'],
empty( $redux_file_string ) ? esc_html__( 'not defined!', 'pt-ocdi' ) : $redux_file_string
);
}
/**
* Write the error to the log file and send the AJAX response.
*
* @param string $error_text text to display in the log file and in the AJAX response.
* @param string $log_file_path path to the log file.
* @param string $separator title separating the old and new content.
*/
public static function log_error_and_send_ajax_response( $error_text, $log_file_path, $separator = '' ) {
// Add this error to log file.
$log_added = self::append_to_file(
$error_text,
$log_file_path,
$separator
);
// Send JSON Error response to the AJAX call.
wp_send_json( $error_text );
}
/**
* Set the $demo_import_start_time class variable with the current date and time string.
*/
public static function set_demo_import_start_time() {
self::$demo_import_start_time = date( apply_filters( 'pt-ocdi/date_format_for_file_names', 'Y-m-d__H-i-s' ) );
}
/**
* Get the category list of all categories used in the predefined demo imports array.
*
* @param array $demo_imports Array of demo import items (arrays).
* @return array|boolean List of all the categories or false if there aren't any.
*/
public static function get_all_demo_import_categories( $demo_imports ) {
$categories = array();
foreach ( $demo_imports as $item ) {
if ( ! empty( $item['categories'] ) && is_array( $item['categories'] ) ) {
foreach ( $item['categories'] as $category ) {
$categories[ sanitize_key( $category ) ] = $category;
}
}
}
if ( empty( $categories ) ) {
return false;
}
return $categories;
}
/**
* Return the concatenated string of demo import item categories.
* These should be separated by comma and sanitized properly.
*
* @param array $item The predefined demo import item data.
* @return string The concatenated string of categories.
*/
public static function get_demo_import_item_categories( $item ) {
$sanitized_categories = array();
if ( isset( $item['categories'] ) ) {
foreach ( $item['categories'] as $category ) {
$sanitized_categories[] = sanitize_key( $category );
}
}
if ( ! empty( $sanitized_categories ) ) {
return implode( ',', $sanitized_categories );
}
return false;
}
/**
* Set the OCDI transient with the current importer data.
*
* @param array $data Data to be saved to the transient.
*/
public static function set_ocdi_import_data_transient( $data ) {
set_transient( 'ocdi_importer_data', $data, 0.1 * HOUR_IN_SECONDS );
}
}
inc/WidgetImporter.php 0000666 00000031000 15213303300 0010757 0 ustar 00 get_log_file_path();
// Import widgets and return result.
if ( ! empty( $widget_import_file_path ) ) {
$results = self::import_widgets( $widget_import_file_path );
}
// Check for errors, else write the results to the log file.
if ( is_wp_error( $results ) ) {
$error_message = $results->get_error_message();
// Add any error messages to the frontend_error_messages variable in OCDI main class.
$ocdi->append_to_frontend_error_messages( $error_message );
// Write error to log file.
Helpers::append_to_file(
$error_message,
$log_file_path,
esc_html__( 'Importing widgets', 'pt-ocdi' )
);
}
else {
ob_start();
self::format_results_for_log( $results );
$message = ob_get_clean();
// Add this message to log file.
$log_added = Helpers::append_to_file(
$message,
$log_file_path,
esc_html__( 'Importing widgets' , 'pt-ocdi' )
);
}
}
/**
* Imports widgets from a json file.
*
* @param string $data_file path to json file with WordPress widget export data.
*/
private static function import_widgets( $data_file ) {
// Get widgets data from file.
$data = self::process_import_file( $data_file );
// Return from this function if there was an error.
if ( is_wp_error( $data ) ) {
return $data;
}
// Import the widget data and save the results.
return self::import_data( $data );
}
/**
* Process import file - this parses the widget data and returns it.
*
* @param string $file path to json file.
* @return object $data decoded JSON string
*/
private static function process_import_file( $file ) {
// File exists?
if ( ! file_exists( $file ) ) {
return new \WP_Error(
'widget_import_file_not_found',
__( 'Error: Widget import file could not be found.', 'pt-ocdi' )
);
}
// Get file contents and decode.
$data = Helpers::data_from_file( $file );
// Return from this function if there was an error.
if ( is_wp_error( $data ) ) {
return $data;
}
return json_decode( $data );
}
/**
* Import widget JSON data
*
* @global array $wp_registered_sidebars
* @param object $data JSON widget data.
* @return array $results
*/
private static function import_data( $data ) {
global $wp_registered_sidebars;
// Have valid data? If no data or could not decode.
if ( empty( $data ) || ! is_object( $data ) ) {
return new \WP_Error(
'corrupted_widget_import_data',
__( 'Error: Widget import data could not be read. Please try a different file.', 'pt-ocdi' )
);
}
// Hook before import.
do_action( 'pt-ocdi/widget_importer_before_widgets_import' );
$data = apply_filters( 'pt-ocdi/before_widgets_import_data', $data );
// Get all available widgets site supports.
$available_widgets = self::available_widgets();
// Get all existing widget instances.
$widget_instances = array();
foreach ( $available_widgets as $widget_data ) {
$widget_instances[ $widget_data['id_base'] ] = get_option( 'widget_' . $widget_data['id_base'] );
}
// Begin results.
$results = array();
// Loop import data's sidebars.
foreach ( $data as $sidebar_id => $widgets ) {
// Skip inactive widgets (should not be in export file).
if ( 'wp_inactive_widgets' == $sidebar_id ) {
continue;
}
// Check if sidebar is available on this site. Otherwise add widgets to inactive, and say so.
if ( isset( $wp_registered_sidebars[ $sidebar_id ] ) ) {
$sidebar_available = true;
$use_sidebar_id = $sidebar_id;
$sidebar_message_type = 'success';
$sidebar_message = '';
}
else {
$sidebar_available = false;
$use_sidebar_id = 'wp_inactive_widgets'; // Add to inactive if sidebar does not exist in theme.
$sidebar_message_type = 'error';
$sidebar_message = __( 'Sidebar does not exist in theme (moving widget to Inactive)', 'pt-ocdi' );
}
// Result for sidebar.
$results[ $sidebar_id ]['name'] = ! empty( $wp_registered_sidebars[ $sidebar_id ]['name'] ) ? $wp_registered_sidebars[ $sidebar_id ]['name'] : $sidebar_id; // Sidebar name if theme supports it; otherwise ID.
$results[ $sidebar_id ]['message_type'] = $sidebar_message_type;
$results[ $sidebar_id ]['message'] = $sidebar_message;
$results[ $sidebar_id ]['widgets'] = array();
// Loop widgets.
foreach ( $widgets as $widget_instance_id => $widget ) {
$fail = false;
// Get id_base (remove -# from end) and instance ID number.
$id_base = preg_replace( '/-[0-9]+$/', '', $widget_instance_id );
$instance_id_number = str_replace( $id_base . '-', '', $widget_instance_id );
// Does site support this widget?
if ( ! $fail && ! isset( $available_widgets[ $id_base ] ) ) {
$fail = true;
$widget_message_type = 'error';
$widget_message = __( 'Site does not support widget', 'pt-ocdi' ); // Explain why widget not imported.
}
// Filter to modify settings object before conversion to array and import.
// Leave this filter here for backwards compatibility with manipulating objects (before conversion to array below).
// Ideally the newer wie_widget_settings_array below will be used instead of this.
$widget = apply_filters( 'pt-ocdi/widget_settings', $widget ); // Object.
// Convert multidimensional objects to multidimensional arrays.
// Some plugins like Jetpack Widget Visibility store settings as multidimensional arrays.
// Without this, they are imported as objects and cause fatal error on Widgets page.
// If this creates problems for plugins that do actually intend settings in objects then may need to consider other approach: https://wordpress.org/support/topic/problem-with-array-of-arrays.
// It is probably much more likely that arrays are used than objects, however.
$widget = json_decode( json_encode( $widget ), true );
// Filter to modify settings array.
// This is preferred over the older wie_widget_settings filter above.
// Do before identical check because changes may make it identical to end result (such as URL replacements).
$widget = apply_filters( 'pt-ocdi/widget_settings_array', $widget );
// Does widget with identical settings already exist in same sidebar?
if ( ! $fail && isset( $widget_instances[ $id_base ] ) ) {
// Get existing widgets in this sidebar.
$sidebars_widgets = get_option( 'sidebars_widgets' );
$sidebar_widgets = isset( $sidebars_widgets[ $use_sidebar_id ] ) ? $sidebars_widgets[ $use_sidebar_id ] : array(); // Check Inactive if that's where will go.
// Loop widgets with ID base.
$single_widget_instances = ! empty( $widget_instances[ $id_base ] ) ? $widget_instances[ $id_base ] : array();
foreach ( $single_widget_instances as $check_id => $check_widget ) {
// Is widget in same sidebar and has identical settings?
if ( in_array( "$id_base-$check_id", $sidebar_widgets ) && (array) $widget == $check_widget ) {
$fail = true;
$widget_message_type = 'warning';
$widget_message = __( 'Widget already exists', 'pt-ocdi' ); // Explain why widget not imported.
break;
}
}
}
// No failure.
if ( ! $fail ) {
// Add widget instance.
$single_widget_instances = get_option( 'widget_' . $id_base ); // All instances for that widget ID base, get fresh every time.
$single_widget_instances = ! empty( $single_widget_instances ) ? $single_widget_instances : array( '_multiwidget' => 1 ); // Start fresh if have to.
$single_widget_instances[] = $widget; // Add it.
// Get the key it was given.
end( $single_widget_instances );
$new_instance_id_number = key( $single_widget_instances );
// If key is 0, make it 1.
// When 0, an issue can occur where adding a widget causes data from other widget to load, and the widget doesn't stick (reload wipes it).
if ( '0' === strval( $new_instance_id_number ) ) {
$new_instance_id_number = 1;
$single_widget_instances[ $new_instance_id_number ] = $single_widget_instances[0];
unset( $single_widget_instances[0] );
}
// Move _multiwidget to end of array for uniformity.
if ( isset( $single_widget_instances['_multiwidget'] ) ) {
$multiwidget = $single_widget_instances['_multiwidget'];
unset( $single_widget_instances['_multiwidget'] );
$single_widget_instances['_multiwidget'] = $multiwidget;
}
// Update option with new widget.
update_option( 'widget_' . $id_base, $single_widget_instances );
// Assign widget instance to sidebar.
$sidebars_widgets = get_option( 'sidebars_widgets' ); // Which sidebars have which widgets, get fresh every time.
$new_instance_id = $id_base . '-' . $new_instance_id_number; // Use ID number from new widget instance.
$sidebars_widgets[ $use_sidebar_id ][] = $new_instance_id; // Add new instance to sidebar.
update_option( 'sidebars_widgets', $sidebars_widgets ); // Save the amended data.
// After widget import action.
$after_widget_import = array(
'sidebar' => $use_sidebar_id,
'sidebar_old' => $sidebar_id,
'widget' => $widget,
'widget_type' => $id_base,
'widget_id' => $new_instance_id,
'widget_id_old' => $widget_instance_id,
'widget_id_num' => $new_instance_id_number,
'widget_id_num_old' => $instance_id_number,
);
do_action( 'pt-ocdi/widget_importer_after_single_widget_import', $after_widget_import );
// Success message.
if ( $sidebar_available ) {
$widget_message_type = 'success';
$widget_message = __( 'Imported', 'pt-ocdi' );
}
else {
$widget_message_type = 'warning';
$widget_message = __( 'Imported to Inactive', 'pt-ocdi' );
}
}
// Result for widget instance.
$results[ $sidebar_id ]['widgets'][ $widget_instance_id ]['name'] = isset( $available_widgets[ $id_base ]['name'] ) ? $available_widgets[ $id_base ]['name'] : $id_base; // Widget name or ID if name not available (not supported by site).
$results[ $sidebar_id ]['widgets'][ $widget_instance_id ]['title'] = ! empty( $widget['title'] ) ? $widget['title'] : __( 'No Title', 'pt-ocdi' ); // Show "No Title" if widget instance is untitled.
$results[ $sidebar_id ]['widgets'][ $widget_instance_id ]['message_type'] = $widget_message_type;
$results[ $sidebar_id ]['widgets'][ $widget_instance_id ]['message'] = $widget_message;
}
}
// Hook after import.
do_action( 'pt-ocdi/widget_importer_after_widgets_import' );
// Return results.
return apply_filters( 'pt-ocdi/widget_import_results', $results );
}
/**
* Available widgets.
*
* Gather site's widgets into array with ID base, name, etc.
*
* @global array $wp_registered_widget_controls
* @return array $available_widgets, Widget information
*/
private static function available_widgets() {
global $wp_registered_widget_controls;
$widget_controls = $wp_registered_widget_controls;
$available_widgets = array();
foreach ( $widget_controls as $widget ) {
if ( ! empty( $widget['id_base'] ) && ! isset( $available_widgets[ $widget['id_base'] ] ) ) {
$available_widgets[ $widget['id_base'] ]['id_base'] = $widget['id_base'];
$available_widgets[ $widget['id_base'] ]['name'] = $widget['name'];
}
}
return apply_filters( 'pt-ocdi/available_widgets', $available_widgets );
}
/**
* Format results for log file
*
* @param array $results widget import results.
*/
private static function format_results_for_log( $results ) {
if ( empty( $results ) ) {
esc_html_e( 'No results for widget import!', 'pt-ocdi' );
}
// Loop sidebars.
foreach ( $results as $sidebar ) {
echo esc_html( $sidebar['name'] ) . ' : ' . esc_html( $sidebar['message'] ) . PHP_EOL . PHP_EOL;
// Loop widgets.
foreach ( $sidebar['widgets'] as $widget ) {
echo esc_html( $widget['name'] ) . ' - ' . esc_html( $widget['title'] ) . ' - ' . esc_html( $widget['message'] ) . PHP_EOL;
}
echo PHP_EOL;
}
}
}
inc/Logger.php 0000666 00000002605 15213303300 0007242 0 ustar 00 error_output( $level, $message, $context = array() );
if ( $this->level_to_numeric( $level ) < $this->level_to_numeric( $this->min_level ) ) {
return;
}
printf(
'[%s] %s' . PHP_EOL,
strtoupper( $level ),
$message
);
}
/**
* Save messages for error output.
* Only the messages greater then Error.
*
* @param mixed $level level of reporting.
* @param string $message log message.
* @param array $context context to the log message.
*/
public function error_output( $level, $message, array $context = array() ) {
if ( $this->level_to_numeric( $level ) < $this->level_to_numeric( 'error' ) ) {
return;
}
$this->error_output .= sprintf(
'[%s] %s ',
strtoupper( $level ),
$message
);
}
}
inc/Downloader.php 0000666 00000007325 15213303300 0010125 0 ustar 00 set_download_directory_path( $download_directory_path );
}
/**
* Download file from a given URL.
*
* @param string $url URL of file to download.
* @param string $filename Filename of the file to save.
* @return string|WP_Error Full path to the downloaded file or WP_Error object with error message.
*/
public function download_file( $url, $filename ) {
$content = $this->get_content_from_url( $url );
// Check if there was an error and break out.
if ( is_wp_error( $content ) ) {
return $content;
}
return Helpers::write_to_file( $content, $this->download_directory_path . $filename );
}
/**
* Helper function: get content from an URL.
*
* @param string $url URL to the content file.
* @return string|WP_Error, content from the URL or WP_Error object with error message.
*/
private function get_content_from_url( $url ) {
// Test if the URL to the file is defined.
if ( empty( $url ) ) {
return new \WP_Error(
'missing_url',
__( 'Missing URL for downloading a file!', 'pt-ocdi' )
);
}
// Get file content from the server.
$response = wp_remote_get(
$url,
array( 'timeout' => apply_filters( 'pt-ocdi/timeout_for_downloading_import_file', 20 ) )
);
// Test if the get request was not successful.
if ( is_wp_error( $response ) || 200 !== $response['response']['code'] ) {
// Collect the right format of error data (array or WP_Error).
$response_error = $this->get_error_from_response( $response );
return new \WP_Error(
'download_error',
sprintf(
__( 'An error occurred while fetching file from: %1$s%2$s%3$s!%4$sReason: %5$s - %6$s.', 'pt-ocdi' ),
'',
$url,
'',
' ',
$response_error['error_code'],
$response_error['error_message']
) . ' ' .
apply_filters( 'pt-ocdi/message_after_file_fetching_error', '' )
);
}
// Return content retrieved from the URL.
return wp_remote_retrieve_body( $response );
}
/**
* Helper function: get the right format of response errors.
*
* @param array|WP_Error $response Array or WP_Error or the response.
* @return array Error code and error message.
*/
private function get_error_from_response( $response ) {
$response_error = array();
if ( is_array( $response ) ) {
$response_error['error_code'] = $response['response']['code'];
$response_error['error_message'] = $response['response']['message'];
}
else {
$response_error['error_code'] = $response->get_error_code();
$response_error['error_message'] = $response->get_error_message();
}
return $response_error;
}
/**
* Get download_directory_path attribute.
*/
public function get_download_directory_path() {
return $this->download_directory_path;
}
/**
* Set download_directory_path attribute.
* If no valid path is specified, the default WP upload directory will be used.
*
* @param string $download_directory_path Path, where the files will be saved.
*/
public function set_download_directory_path( $download_directory_path ) {
if ( file_exists( $download_directory_path ) ) {
$this->download_directory_path = $download_directory_path;
}
else {
$upload_dir = wp_upload_dir();
$this->download_directory_path = apply_filters( 'pt-ocdi/upload_file_path', trailingslashit( $upload_dir['path'] ) );
}
}
}
inc/ReduxImporter.php 0000666 00000004415 15213303300 0010635 0 ustar 00 get_log_file_path();
// Redux plugin is not active!
if ( ! class_exists( 'ReduxFramework' ) ) {
$error_message = esc_html__( 'The Redux plugin is not activated, so the Redux import was skipped!', 'pt-ocdi' );
// Add any error messages to the frontend_error_messages variable in OCDI main class.
$ocdi->append_to_frontend_error_messages( $error_message );
// Write error to log file.
Helpers::append_to_file(
$error_message,
$log_file_path,
esc_html__( 'Importing Redux settings' , 'pt-ocdi' )
);
return;
}
foreach ( $import_data as $redux_item ) {
$redux_options_raw_data = Helpers::data_from_file( $redux_item['file_path'] );
$redux_options_data = json_decode( $redux_options_raw_data, true );
$redux_framework = \ReduxFrameworkInstances::get_instance( $redux_item['option_name'] );
if ( isset( $redux_framework->args['opt_name'] ) ) {
// Import Redux settings.
$redux_framework->set_options( $redux_options_data );
// Add this message to log file.
$log_added = Helpers::append_to_file(
sprintf( esc_html__( 'Redux settings import for: %s finished successfully!', 'pt-ocdi' ), $redux_item['option_name'] ),
$log_file_path,
esc_html__( 'Importing Redux settings' , 'pt-ocdi' )
);
}
else {
$error_message = sprintf( esc_html__( 'The Redux option name: %s, was not found in this WP site, so it was not imported!', 'pt-ocdi' ), $redux_item['option_name'] );
// Add any error messages to the frontend_error_messages variable in OCDI main class.
$ocdi->append_to_frontend_error_messages( $error_message );
// Write error to log file.
Helpers::append_to_file(
$error_message,
$log_file_path,
esc_html__( 'Importing Redux settings' , 'pt-ocdi' )
);
}
}
}
}
inc/Importer.php 0000666 00000012530 15213303300 0007622 0 ustar 00 include_required_files();
// Set the WordPress Importer v2 as the importer used in this plugin.
// More: https://github.com/humanmade/WordPress-Importer.
$this->importer = new WXRImporter( $importer_options );
// Set logger to the importer.
$this->logger = $logger;
if ( ! empty( $this->logger ) ) {
$this->set_logger( $this->logger );
}
// Get the OCDI (main plugin class) instance.
$this->ocdi = OneClickDemoImport::get_instance();
}
/**
* Include required files.
*/
private function include_required_files() {
if ( ! class_exists( '\WP_Importer' ) ) {
defined( 'WP_LOAD_IMPORTERS' ) || define( 'WP_LOAD_IMPORTERS', true );
require ABSPATH . '/wp-admin/includes/class-wp-importer.php';
}
}
/**
* Imports content from a WordPress export file.
*
* @param string $data_file path to xml file, file with WordPress export data.
*/
public function import( $data_file ) {
$this->importer->import( $data_file );
}
/**
* Set the logger used in the import
*
* @param object $logger logger instance.
*/
public function set_logger( $logger ) {
$this->importer->set_logger( $logger );
}
/**
* Get all protected variables from the WXR_Importer needed for continuing the import.
*/
public function get_importer_data() {
return $this->importer->get_importer_data();
}
/**
* Sets all protected variables from the WXR_Importer needed for continuing the import.
*
* @param array $data with set variables.
*/
public function set_importer_data( $data ) {
$this->importer->set_importer_data( $data );
}
/**
* Import content from an WP XML file.
*
* @param string $import_file_path Path to the import file.
*/
public function import_content( $import_file_path ) {
$this->microtime = microtime( true );
// Increase PHP max execution time. Just in case, even though the AJAX calls are only 25 sec long.
set_time_limit( apply_filters( 'pt-ocdi/set_time_limit_for_demo_data_import', 300 ) );
// Disable import of authors.
add_filter( 'wxr_importer.pre_process.user', '__return_false' );
// Check, if we need to send another AJAX request and set the importing author to the current user.
add_filter( 'wxr_importer.pre_process.post', array( $this, 'new_ajax_request_maybe' ) );
// Disables generation of multiple image sizes (thumbnails) in the content import step.
if ( ! apply_filters( 'pt-ocdi/regenerate_thumbnails_in_content_import', true ) ) {
add_filter( 'intermediate_image_sizes_advanced', '__return_null' );
}
// Import content.
if ( ! empty( $import_file_path ) ) {
ob_start();
$this->import( $import_file_path );
$message = ob_get_clean();
}
// Return any error messages for the front page output (errors, critical, alert and emergency level messages only).
return $this->logger->error_output;
}
/**
* Check if we need to create a new AJAX request, so that server does not timeout.
*
* @param array $data current post data.
* @return array
*/
public function new_ajax_request_maybe( $data ) {
$time = microtime( true ) - $this->microtime;
// We should make a new ajax call, if the time is right.
if ( $time > apply_filters( 'pt-ocdi/time_for_one_ajax_call', 25 ) ) {
$response = array(
'status' => 'newAJAX',
'message' => 'Time for new AJAX request!: ' . $time,
);
// Add any output to the log file and clear the buffers.
$message = ob_get_clean();
// Add any error messages to the frontend_error_messages variable in OCDI main class.
if ( ! empty( $message ) ) {
$this->ocdi->append_to_frontend_error_messages( $message );
}
// Add message to log file.
$log_added = Helpers::append_to_file(
__( 'New AJAX call!' , 'pt-ocdi' ) . PHP_EOL . $message,
$this->ocdi->get_log_file_path(),
''
);
// Set the current importer stat, so it can be continued on the next AJAX call.
$this->set_current_importer_data();
// Send the request for a new AJAX call.
wp_send_json( $response );
}
// Set importing author to the current user.
// Fixes the [WARNING] Could not find the author for ... log warning messages.
$current_user_obj = wp_get_current_user();
$data['post_author'] = $current_user_obj->user_login;
return $data;
}
/**
* Set current state of the content importer, so we can continue the import with new AJAX request.
*/
private function set_current_importer_data() {
$data = array_merge( $this->ocdi->get_current_importer_data(), $this->get_importer_data() );
Helpers::set_ocdi_import_data_transient( $data );
}
}
inc/OneClickDemoImport.php 0000666 00000043221 15213303300 0011511 0 ustar 00 'themes.php',
'page_title' => esc_html__( 'One Click Demo Import' , 'pt-ocdi' ),
'menu_title' => esc_html__( 'Import Demo Data' , 'pt-ocdi' ),
'capability' => 'import',
'menu_slug' => 'pt-one-click-demo-import',
)
);
$this->plugin_page = add_submenu_page(
$plugin_page_setup['parent_slug'],
$plugin_page_setup['page_title'],
$plugin_page_setup['menu_title'],
$plugin_page_setup['capability'],
$plugin_page_setup['menu_slug'],
apply_filters( 'pt-ocdi/plugin_page_display_callback_function', array( $this, 'display_plugin_page' ) )
);
}
/**
* Plugin page display.
* Output (HTML) is in another file.
*/
public function display_plugin_page() {
require_once PT_OCDI_PATH . 'views/plugin-page.php';
}
/**
* Enqueue admin scripts (JS and CSS)
*
* @param string $hook holds info on which admin page you are currently loading.
*/
public function admin_enqueue_scripts( $hook ) {
// Enqueue the scripts only on the plugin page.
if ( $this->plugin_page === $hook ) {
wp_enqueue_script( 'jquery-ui-dialog' );
wp_enqueue_style( 'wp-jquery-ui-dialog' );
wp_enqueue_script( 'ocdi-main-js', PT_OCDI_URL . 'assets/js/main.js' , array( 'jquery', 'jquery-ui-dialog' ), PT_OCDI_VERSION );
// Get theme data.
$theme = wp_get_theme();
wp_localize_script( 'ocdi-main-js', 'ocdi',
array(
'ajax_url' => admin_url( 'admin-ajax.php' ),
'ajax_nonce' => wp_create_nonce( 'ocdi-ajax-verification' ),
'import_files' => $this->import_files,
'wp_customize_on' => apply_filters( 'pt-ocdi/enable_wp_customize_save_hooks', false ),
'import_popup' => apply_filters( 'pt-ocdi/enable_grid_layout_import_popup_confirmation', true ),
'theme_screenshot' => $theme->get_screenshot(),
'texts' => array(
'missing_preview_image' => esc_html__( 'No preview image defined for this import.', 'pt-ocdi' ),
'dialog_title' => esc_html__( 'Are you sure?', 'pt-ocdi' ),
'dialog_no' => esc_html__( 'Cancel', 'pt-ocdi' ),
'dialog_yes' => esc_html__( 'Yes, import!', 'pt-ocdi' ),
'selected_import_title' => esc_html__( 'Selected demo import:', 'pt-ocdi' ),
),
'dialog_options' => apply_filters( 'pt-ocdi/confirmation_dialog_options', array() )
)
);
wp_enqueue_style( 'ocdi-main-css', PT_OCDI_URL . 'assets/css/main.css', array() , PT_OCDI_VERSION );
}
}
/**
* Main AJAX callback function for:
* 1). prepare import files (uploaded or predefined via filters)
* 2). execute 'before content import' actions (before import WP action)
* 3). import content
* 4). execute 'after content import' actions (before widget import WP action, widget import, customizer import, after import WP action)
*/
public function import_demo_data_ajax_callback() {
// Try to update PHP memory limit (so that it does not run out of it).
ini_set( 'memory_limit', apply_filters( 'pt-ocdi/import_memory_limit', '350M' ) );
// Verify if the AJAX call is valid (checks nonce and current_user_can).
Helpers::verify_ajax_call();
// Is this a new AJAX call to continue the previous import?
$use_existing_importer_data = $this->use_existing_importer_data();
if ( ! $use_existing_importer_data ) {
// Create a date and time string to use for demo and log file names.
Helpers::set_demo_import_start_time();
// Define log file path.
$this->log_file_path = Helpers::get_log_path();
// Get selected file index or set it to 0.
$this->selected_index = empty( $_POST['selected'] ) ? 0 : absint( $_POST['selected'] );
/**
* 1). Prepare import files.
* Manually uploaded import files or predefined import files via filter: pt-ocdi/import_files
*/
if ( ! empty( $_FILES ) ) { // Using manual file uploads?
// Get paths for the uploaded files.
$this->selected_import_files = Helpers::process_uploaded_files( $_FILES, $this->log_file_path );
// Set the name of the import files, because we used the uploaded files.
$this->import_files[ $this->selected_index ]['import_file_name'] = esc_html__( 'Manually uploaded files', 'pt-ocdi' );
}
elseif ( ! empty( $this->import_files[ $this->selected_index ] ) ) { // Use predefined import files from wp filter: pt-ocdi/import_files.
// Download the import files (content, widgets and customizer files).
$this->selected_import_files = Helpers::download_import_files( $this->import_files[ $this->selected_index ] );
// Check Errors.
if ( is_wp_error( $this->selected_import_files ) ) {
// Write error to log file and send an AJAX response with the error.
Helpers::log_error_and_send_ajax_response(
$this->selected_import_files->get_error_message(),
$this->log_file_path,
esc_html__( 'Downloaded files', 'pt-ocdi' )
);
}
// Add this message to log file.
$log_added = Helpers::append_to_file(
sprintf(
__( 'The import files for: %s were successfully downloaded!', 'pt-ocdi' ),
$this->import_files[ $this->selected_index ]['import_file_name']
) . Helpers::import_file_info( $this->selected_import_files ),
$this->log_file_path,
esc_html__( 'Downloaded files' , 'pt-ocdi' )
);
}
else {
// Send JSON Error response to the AJAX call.
wp_send_json( esc_html__( 'No import files specified!', 'pt-ocdi' ) );
}
}
// Save the initial import data as a transient, so other import parts (in new AJAX calls) can use that data.
Helpers::set_ocdi_import_data_transient( $this->get_current_importer_data() );
if ( ! $this->before_import_executed ) {
$this->before_import_executed = true;
/**
* 2). Execute the actions hooked to the 'pt-ocdi/before_content_import_execution' action:
*
* Default actions:
* 1 - Before content import WP action (with priority 10).
*/
do_action( 'pt-ocdi/before_content_import_execution', $this->selected_import_files, $this->import_files, $this->selected_index );
}
/**
* 3). Import content.
* Returns any errors greater then the "warning" logger level, that will be displayed on front page.
*/
$this->append_to_frontend_error_messages( $this->importer->import_content( $this->selected_import_files['content'] ) );
/**
* 4). Execute the actions hooked to the 'pt-ocdi/after_content_import_execution' action:
*
* Default actions:
* 1 - Before widgets import setup (with priority 10).
* 2 - Import widgets (with priority 20).
* 3 - Import Redux data (with priority 30).
*/
do_action( 'pt-ocdi/after_content_import_execution', $this->selected_import_files, $this->import_files, $this->selected_index );
// Save the import data as a transient, so other import parts (in new AJAX calls) can use that data.
Helpers::set_ocdi_import_data_transient( $this->get_current_importer_data() );
// Request the customizer import AJAX call.
if ( ! empty( $this->selected_import_files['customizer'] ) ) {
wp_send_json( array( 'status' => 'customizerAJAX' ) );
}
// Request the after all import AJAX call.
if ( false !== has_action( 'pt-ocdi/after_all_import_execution' ) ) {
wp_send_json( array( 'status' => 'afterAllImportAJAX' ) );
}
// Send a JSON response with final report.
$this->final_response();
}
/**
* AJAX callback for importing the customizer data.
* This request has the wp_customize set to 'on', so that the customizer hooks can be called
* (they can only be called with the $wp_customize instance). But if the $wp_customize is defined,
* then the widgets do not import correctly, that's why the customizer import has its own AJAX call.
*/
public function import_customizer_data_ajax_callback() {
// Verify if the AJAX call is valid (checks nonce and current_user_can).
Helpers::verify_ajax_call();
// Get existing import data.
if ( $this->use_existing_importer_data() ) {
/**
* Execute the customizer import actions.
*
* Default actions:
* 1 - Customizer import (with priority 10).
*/
do_action( 'pt-ocdi/customizer_import_execution', $this->selected_import_files );
}
// Request the after all import AJAX call.
if ( false !== has_action( 'pt-ocdi/after_all_import_execution' ) ) {
wp_send_json( array( 'status' => 'afterAllImportAJAX' ) );
}
// Send a JSON response with final report.
$this->final_response();
}
/**
* AJAX callback for the after all import action.
*/
public function after_all_import_data_ajax_callback() {
// Verify if the AJAX call is valid (checks nonce and current_user_can).
Helpers::verify_ajax_call();
// Get existing import data.
if ( $this->use_existing_importer_data() ) {
/**
* Execute the after all import actions.
*
* Default actions:
* 1 - after_import action (with priority 10).
*/
do_action( 'pt-ocdi/after_all_import_execution', $this->selected_import_files, $this->import_files, $this->selected_index );
}
// Send a JSON response with final report.
$this->final_response();
}
/**
* Send a JSON response with final report.
*/
private function final_response() {
// Delete importer data transient for current import.
delete_transient( 'ocdi_importer_data' );
// Display final messages (success or error messages).
if ( empty( $this->frontend_error_messages ) ) {
$response['message'] = '';
if ( ! apply_filters( 'pt-ocdi/disable_pt_branding', false ) ) {
$twitter_status = esc_html__( 'Just used One Click Demo Import plugin and it was awesome! Thanks @ProteusThemes! #OCDI https://www.proteusthemes.com/', 'pt-ocdi' );
$response['message'] .= sprintf(
__( '%1$s%6$sWasn\'t this a great One Click Demo Import experience?%7$s Created and maintained by %3$sProteusThemes%4$s. %2$s%5$sClick to Tweet!%4$s%8$s', 'pt-ocdi' ),
'
'
);
}
$response['message'] .= sprintf(
__( '%1$s%3$sThat\'s it, all done!%4$s%2$sThe demo import has finished. Please check your page and make sure that everything has imported correctly. If it did, you can deactivate the %3$sOne Click Demo Import%4$s plugin, because it has done its job.%5$s', 'pt-ocdi' ),
'
',
' ',
'',
'',
'
'
);
}
else {
$response['message'] = $this->frontend_error_messages_display() . ' ';
$response['message'] .= sprintf(
__( '%1$sThe demo import has finished, but there were some import errors.%2$sMore details about the errors can be found in this %3$s%5$slog file%6$s%4$s%7$s', 'pt-ocdi' ),
'
'
);
}
wp_send_json( $response );
}
/**
* Get content importer data, so we can continue the import with this new AJAX request.
*
* @return boolean
*/
private function use_existing_importer_data() {
if ( $data = get_transient( 'ocdi_importer_data' ) ) {
$this->frontend_error_messages = empty( $data['frontend_error_messages'] ) ? array() : $data['frontend_error_messages'];
$this->log_file_path = empty( $data['log_file_path'] ) ? '' : $data['log_file_path'];
$this->selected_index = empty( $data['selected_index'] ) ? 0 : $data['selected_index'];
$this->selected_import_files = empty( $data['selected_import_files'] ) ? array() : $data['selected_import_files'];
$this->before_import_executed = empty( $data['before_import_executed'] ) ? false : $data['before_import_executed'];
$this->importer->set_importer_data( $data );
return true;
}
return false;
}
/**
* Get the current state of selected data.
*
* @return array
*/
public function get_current_importer_data() {
return array(
'frontend_error_messages' => $this->frontend_error_messages,
'log_file_path' => $this->log_file_path,
'selected_index' => $this->selected_index,
'selected_import_files' => $this->selected_import_files,
'before_import_executed' => $this->before_import_executed,
);
}
/**
* Getter function to retrieve the private log_file_path value.
*
* @return string The log_file_path value.
*/
public function get_log_file_path() {
return $this->log_file_path;
}
/**
* Setter function to append additional value to the private frontend_error_messages value.
*
* @param string $additional_value The additional value that will be appended to the existing frontend_error_messages.
*/
public function append_to_frontend_error_messages( $text ) {
$lines = array();
if ( ! empty( $text ) ) {
$text = str_replace( ' ', PHP_EOL, $text );
$lines = explode( PHP_EOL, $text );
}
foreach ( $lines as $line ) {
if ( ! empty( $line ) && ! in_array( $line , $this->frontend_error_messages ) ) {
$this->frontend_error_messages[] = $line;
}
}
}
/**
* Display the frontend error messages.
*
* @return string Text with HTML markup.
*/
public function frontend_error_messages_display() {
$output = '';
if ( ! empty( $this->frontend_error_messages ) ) {
foreach ( $this->frontend_error_messages as $line ) {
$output .= esc_html( $line );
$output .= ' ';
}
}
return $output;
}
/**
* Load the plugin textdomain, so that translations can be made.
*/
public function load_textdomain() {
load_plugin_textdomain( 'pt-ocdi', false, plugin_basename( dirname( __FILE__ ) ) . '/languages' );
}
/**
* Get data from filters, after the theme has loaded and instantiate the importer.
*/
public function setup_plugin_with_filter_data() {
// Get info of import data files and filter it.
$this->import_files = Helpers::validate_import_file_info( apply_filters( 'pt-ocdi/import_files', array() ) );
/**
* Register all default actions (before content import, widget, customizer import and other actions)
* to the 'before_content_import_execution' and the 'pt-ocdi/after_content_import_execution' action hook.
*/
$import_actions = new ImportActions();
$import_actions->register_hooks();
// Importer options array.
$importer_options = apply_filters( 'pt-ocdi/importer_options', array(
'fetch_attachments' => true,
) );
// Logger options for the logger used in the importer.
$logger_options = apply_filters( 'pt-ocdi/logger_options', array(
'logger_min_level' => 'warning',
) );
// Configure logger instance and set it to the importer.
$logger = new Logger();
$logger->min_level = $logger_options['logger_min_level'];
// Create importer instance with proper parameters.
$this->importer = new Importer( $importer_options, $logger );
}
}
inc/WXRImporter.php 0000666 00000007707 15213303300 0010235 0 ustar 00 mapping['user_slug'][ $current_user_obj->user_login ] = $current_user_obj->ID;
// WooCommerce product attributes registration.
if ( class_exists( 'WooCommerce' ) ) {
add_filter( 'wxr_importer.pre_process.term', array( $this, 'woocommerce_product_attributes_registration' ), 10, 1 );
}
}
/**
* Get all protected variables from the WXR_Importer needed for continuing the import.
*/
public function get_importer_data() {
return array(
'mapping' => $this->mapping,
'requires_remapping' => $this->requires_remapping,
'exists' => $this->exists,
'user_slug_override' => $this->user_slug_override,
'url_remap' => $this->url_remap,
'featured_images' => $this->featured_images,
);
}
/**
* Sets all protected variables from the WXR_Importer needed for continuing the import.
*
* @param array $data with set variables.
*/
public function set_importer_data( $data ) {
$this->mapping = empty( $data['mapping'] ) ? array() : $data['mapping'];
$this->requires_remapping = empty( $data['requires_remapping'] ) ? array() : $data['requires_remapping'];
$this->exists = empty( $data['exists'] ) ? array() : $data['exists'];
$this->user_slug_override = empty( $data['user_slug_override'] ) ? array() : $data['user_slug_override'];
$this->url_remap = empty( $data['url_remap'] ) ? array() : $data['url_remap'];
$this->featured_images = empty( $data['featured_images'] ) ? array() : $data['featured_images'];
}
/**
* Hook into the pre-process term filter of the content import and register the
* custom WooCommerce product attributes, so that the terms can then be imported normally.
*
* This should probably be removed once the WP importer 2.0 support is added in WooCommerce.
*
* Fixes: [WARNING] Failed to import pa_size L warnings in content import.
* Code from: woocommerce/includes/admin/class-wc-admin-importers.php (ver 2.6.9).
*
* Github issue: https://github.com/proteusthemes/one-click-demo-import/issues/71
*
* @param array $date The term data to import.
* @return array The unchanged term data.
*/
public function woocommerce_product_attributes_registration( $data ) {
global $wpdb;
if ( strstr( $data['taxonomy'], 'pa_' ) ) {
if ( ! taxonomy_exists( $data['taxonomy'] ) ) {
$attribute_name = wc_sanitize_taxonomy_name( str_replace( 'pa_', '', $data['taxonomy'] ) );
// Create the taxonomy
if ( ! in_array( $attribute_name, wc_get_attribute_taxonomies() ) ) {
$attribute = array(
'attribute_label' => $attribute_name,
'attribute_name' => $attribute_name,
'attribute_type' => 'select',
'attribute_orderby' => 'menu_order',
'attribute_public' => 0
);
$wpdb->insert( $wpdb->prefix . 'woocommerce_attribute_taxonomies', $attribute );
delete_transient( 'wc_attribute_taxonomies' );
}
// Register the taxonomy now so that the import works!
register_taxonomy(
$data['taxonomy'],
apply_filters( 'woocommerce_taxonomy_objects_' . $data['taxonomy'], array( 'product' ) ),
apply_filters( 'woocommerce_taxonomy_args_' . $data['taxonomy'], array(
'hierarchical' => true,
'show_ui' => false,
'query_var' => true,
'rewrite' => false,
) )
);
}
}
return $data;
}
}
inc/CustomizerImporter.php 0000666 00000016167 15213303300 0011721 0 ustar 00 get_log_file_path();
// Try to import the customizer settings.
$results = self::import_customizer_options( $customizer_import_file_path );
// Check for errors, else write the results to the log file.
if ( is_wp_error( $results ) ) {
$error_message = $results->get_error_message();
// Add any error messages to the frontend_error_messages variable in OCDI main class.
$ocdi->append_to_frontend_error_messages( $error_message );
// Write error to log file.
Helpers::append_to_file(
$error_message,
$log_file_path,
esc_html__( 'Importing customizer settings', 'pt-ocdi' )
);
}
else {
// Add this message to log file.
$log_added = Helpers::append_to_file(
esc_html__( 'Customizer settings import finished!', 'pt-ocdi' ),
$log_file_path,
esc_html__( 'Importing customizer settings' , 'pt-ocdi' )
);
}
}
/**
* Imports uploaded mods and calls WordPress core customize_save actions so
* themes that hook into them can act before mods are saved to the database.
*
* Update: WP core customize_save actions were removed, because of some errors.
*
* @since 1.1.1
* @param string $import_file_path Path to the import file.
* @return void|WP_Error
*/
public static function import_customizer_options( $import_file_path ) {
// Setup global vars.
global $wp_customize;
// Setup internal vars.
$template = get_template();
// Make sure we have an import file.
if ( ! file_exists( $import_file_path ) ) {
return new \WP_Error(
'missing_cutomizer_import_file',
sprintf(
esc_html__( 'Error: The customizer import file is missing! File path: %s', 'pt-ocdi' ),
$import_file_path
)
);
}
// Get the upload data.
$raw = Helpers::data_from_file( $import_file_path );
// Make sure we got the data.
if ( is_wp_error( $raw ) ) {
return $raw;
}
$data = unserialize( $raw );
// Data checks.
if ( ! is_array( $data ) && ( ! isset( $data['template'] ) || ! isset( $data['mods'] ) ) ) {
return new \WP_Error(
'customizer_import_data_error',
esc_html__( 'Error: The customizer import file is not in a correct format. Please make sure to use the correct customizer import file.', 'pt-ocdi' )
);
}
if ( $data['template'] !== $template ) {
return new \WP_Error(
'customizer_import_wrong_theme',
esc_html__( 'Error: The customizer import file is not suitable for current theme. You can only import customizer settings for the same theme or a child theme.', 'pt-ocdi' )
);
}
// Import images.
if ( apply_filters( 'pt-ocdi/customizer_import_images', true ) ) {
$data['mods'] = self::import_customizer_images( $data['mods'] );
}
// Import custom options.
if ( isset( $data['options'] ) ) {
// Require modified customizer options class.
if ( ! class_exists( '\WP_Customize_Setting' ) ) {
require_once ABSPATH . 'wp-includes/class-wp-customize-setting.php';
}
foreach ( $data['options'] as $option_key => $option_value ) {
$option = new CustomizerOption( $wp_customize, $option_key, array(
'default' => '',
'type' => 'option',
'capability' => 'edit_theme_options',
) );
$option->import( $option_value );
}
}
// Should the customizer import use the WP customize_save* hooks?
$use_wp_customize_save_hooks = apply_filters( 'pt-ocdi/enable_wp_customize_save_hooks', false );
if ( $use_wp_customize_save_hooks ) {
do_action( 'customize_save', $wp_customize );
}
// Loop through the mods and save the mods.
foreach ( $data['mods'] as $key => $val ) {
if ( $use_wp_customize_save_hooks ) {
do_action( 'customize_save_' . $key, $wp_customize );
}
set_theme_mod( $key, $val );
}
if ( $use_wp_customize_save_hooks ) {
do_action( 'customize_save_after', $wp_customize );
}
}
/**
* Helper function: Customizer import - imports images for settings saved as mods.
*
* @since 1.1.1
* @param array $mods An array of customizer mods.
* @return array The mods array with any new import data.
*/
private static function import_customizer_images( $mods ) {
foreach ( $mods as $key => $val ) {
if ( self::customizer_is_image_url( $val ) ) {
$data = self::customizer_sideload_image( $val );
if ( ! is_wp_error( $data ) ) {
$mods[ $key ] = $data->url;
// Handle header image controls.
if ( isset( $mods[ $key . '_data' ] ) ) {
$mods[ $key . '_data' ] = $data;
update_post_meta( $data->attachment_id, '_wp_attachment_is_custom_header', get_stylesheet() );
}
}
}
}
return $mods;
}
/**
* Helper function: Customizer import
* Taken from the core media_sideload_image function and
* modified to return an array of data instead of html.
*
* @since 1.1.1.
* @param string $file The image file path.
* @return array An array of image data.
*/
private static function customizer_sideload_image( $file ) {
$data = new \stdClass();
if ( ! function_exists( 'media_handle_sideload' ) ) {
require_once( ABSPATH . 'wp-admin/includes/media.php' );
require_once( ABSPATH . 'wp-admin/includes/file.php' );
require_once( ABSPATH . 'wp-admin/includes/image.php' );
}
if ( ! empty( $file ) ) {
// Set variables for storage, fix file filename for query strings.
preg_match( '/[^\?]+\.(jpe?g|jpe|gif|png)\b/i', $file, $matches );
$file_array = array();
$file_array['name'] = basename( $matches[0] );
// Download file to temp location.
$file_array['tmp_name'] = download_url( $file );
// If error storing temporarily, return the error.
if ( is_wp_error( $file_array['tmp_name'] ) ) {
return $file_array['tmp_name'];
}
// Do the validation and storage stuff.
$id = media_handle_sideload( $file_array, 0 );
// If error storing permanently, unlink.
if ( is_wp_error( $id ) ) {
unlink( $file_array['tmp_name'] );
return $id;
}
// Build the object to return.
$meta = wp_get_attachment_metadata( $id );
$data->attachment_id = $id;
$data->url = wp_get_attachment_url( $id );
$data->thumbnail_url = wp_get_attachment_thumb_url( $id );
$data->height = $meta['height'];
$data->width = $meta['width'];
}
return $data;
}
/**
* Checks to see whether a string is an image url or not.
*
* @since 1.1.1
* @param string $string The string to check.
* @return bool Whether the string is an image url or not.
*/
private static function customizer_is_image_url( $string = '' ) {
if ( is_string( $string ) ) {
if ( preg_match( '/\.(jpg|jpeg|png|gif)/i', $string ) ) {
return true;
}
}
return false;
}
}
inc/ImportActions.php 0000666 00000011606 15213303300 0010617 0 ustar 00 do_import_action( 'pt-ocdi/before_content_import', $import_files[ $selected_index ] );
}
/**
* Execute the action: 'pt-ocdi/before_widgets_import'.
*
* @param array $selected_import_files Actual selected import files (content, widgets, customizer, redux).
* @param array $import_files The filtered import files defined in `pt-ocdi/import_files` filter.
* @param int $selected_index Selected index of import.
*/
public function before_widget_import_action( $selected_import_files, $import_files, $selected_index ) {
$this->do_import_action( 'pt-ocdi/before_widgets_import', $import_files[ $selected_index ] );
}
/**
* Execute the action: 'pt-ocdi/after_import'.
*
* @param array $selected_import_files Actual selected import files (content, widgets, customizer, redux).
* @param array $import_files The filtered import files defined in `pt-ocdi/import_files` filter.
* @param int $selected_index Selected index of import.
*/
public function after_import_action( $selected_import_files, $import_files, $selected_index ) {
$this->do_import_action( 'pt-ocdi/after_import', $import_files[ $selected_index ] );
}
/**
* Register the do_action hook, so users can hook to these during import.
*
* @param string $action The action name to be executed.
* @param array $selected_import The data of selected import from `pt-ocdi/import_files` filter.
*/
private function do_import_action( $action, $selected_import ) {
if ( false !== has_action( $action ) ) {
$ocdi = OneClickDemoImport::get_instance();
$log_file_path = $ocdi->get_log_file_path();
ob_start();
do_action( $action, $selected_import );
$message = ob_get_clean();
// Add this message to log file.
$log_added = Helpers::append_to_file(
$message,
$log_file_path,
$action
);
}
}
}
inc/CustomizerOption.php 0000666 00000000751 15213303300 0011360 0 ustar 00 update( $value );
}
}
one-click-demo-import.php 0000666 00000005261 15213303300 0011351 0 ustar 00 set_plugin_constants();
// Composer autoloader.
require_once PT_OCDI_PATH . 'vendor/autoload.php';
// Instantiate the main plugin class *Singleton*.
$pt_one_click_demo_import = OCDI\OneClickDemoImport::get_instance();
}
}
/**
* Display an admin error notice when PHP is older the version 5.3.2.
* Hook it to the 'admin_notices' action.
*/
public function old_php_admin_error_notice() {
$message = sprintf( esc_html__( 'The %2$sOne Click Demo Import%3$s plugin requires %2$sPHP 5.3.2+%3$s to run properly. Please contact your hosting company and ask them to update the PHP version of your site to at least PHP 5.3.2.%4$s Your current version of PHP: %2$s%1$s%3$s', 'pt-ocdi' ), phpversion(), '', '', ' ' );
printf( '
%1$s
', wp_kses_post( $message ) );
}
/**
* Set plugin constants.
*
* Path/URL to root of this plugin, with trailing slash and plugin version.
*/
private function set_plugin_constants() {
// Path/URL to root of this plugin, with trailing slash.
if ( ! defined( 'PT_OCDI_PATH' ) ) {
define( 'PT_OCDI_PATH', plugin_dir_path( __FILE__ ) );
}
if ( ! defined( 'PT_OCDI_URL' ) ) {
define( 'PT_OCDI_URL', plugin_dir_url( __FILE__ ) );
}
// Action hook to set the plugin version constant.
add_action( 'admin_init', array( $this, 'set_plugin_version_constant' ) );
}
/**
* Set plugin version constant -> PT_OCDI_VERSION.
*/
public function set_plugin_version_constant() {
if ( ! defined( 'PT_OCDI_VERSION' ) ) {
$plugin_data = get_plugin_data( __FILE__ );
define( 'PT_OCDI_VERSION', $plugin_data['Version'] );
}
}
}
// Instantiate the plugin class.
$ocdi_plugin = new OCDI_Plugin();
languages/pt-ocdi.pot 0000666 00000017667 15213303300 0010610 0 ustar 00 # Copyright (C) 2017 ProteusThemes
# This file is distributed under the GPL 2.0.
msgid ""
msgstr ""
"Project-Id-Version: One Click Demo Import 2.2.1\n"
"Report-Msgid-Bugs-To: http://support.proteusthemes.com/\n"
"POT-Creation-Date: 2016-05-14 09:53:17+00:00\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=utf-8\n"
"Content-Transfer-Encoding: 8bit\n"
"PO-Revision-Date: 2017-MO-DA HO:MI+ZONE\n"
"Last-Translator: FULL NAME \n"
"Language-Team: LANGUAGE \n"
"X-Generator: grunt-wp-i18n 0.5.4\n"
"X-Poedit-KeywordsList: "
"__;_e;_x:1,2c;_ex:1,2c;_n:1,2;_nx:1,2,4c;_n_noop:1,2;_nx_noop:1,2,3c;esc_"
"attr__;esc_html__;esc_attr_e;esc_html_e;esc_attr_x:1,2c;esc_html_x:1,2c;\n"
"Language: en\n"
"Plural-Forms: nplurals=2; plural=(n != 1);\n"
"X-Poedit-Country: United States\n"
"X-Poedit-SourceCharset: UTF-8\n"
"X-Poedit-Basepath: ../\n"
"X-Poedit-SearchPath-0: .\n"
"X-Poedit-Bookmarks: \n"
"X-Textdomain-Support: yes\n"
#: inc/CustomizerImporter.php:37 inc/CustomizerImporter.php:45
msgid "Importing customizer settings"
msgstr ""
#: inc/CustomizerImporter.php:43
msgid "Customizer settings import finished!"
msgstr ""
#: inc/CustomizerImporter.php:73
msgid "Error: The customizer import file is missing! File path: %s"
msgstr ""
#: inc/CustomizerImporter.php:93
msgid ""
"Error: The customizer import file is not in a correct format. Please make "
"sure to use the correct customizer import file."
msgstr ""
#: inc/CustomizerImporter.php:99
msgid ""
"Error: The customizer import file is not suitable for current theme. You "
"can only import customizer settings for the same theme or a child theme."
msgstr ""
#: inc/Downloader.php:58
msgid "Missing URL for downloading a file!"
msgstr ""
#: inc/Downloader.php:76
msgid ""
"An error occurred while fetching file from: %1$s%2$s%3$s!%4$sReason: %5$s - "
"%6$s."
msgstr ""
#: inc/Helpers.php:75
msgid "\"import_file_url\" or \"local_import_file\" for %s%s%s are not defined!"
msgstr ""
#: inc/Helpers.php:203 inc/Helpers.php:246
msgid ""
"An error occurred while writing file to your server! Tried to write a file "
"to: %s%s."
msgstr ""
#: inc/Helpers.php:280
msgid ""
"An error occurred while reading a file from your server! Tried reading file "
"from path: %s%s."
msgstr ""
#: inc/Helpers.php:303
msgid ""
"This WordPress page does not have %sdirect%s write file access. This plugin "
"needs it in order to save the demo import xml file to the upload directory "
"of your site. You can change this setting with these instructions: %s."
msgstr ""
#. Plugin Name of the plugin/theme
msgid "One Click Demo Import"
msgstr ""
#: inc/Helpers.php:315 inc/OneClickDemoImport.php:132
msgid "Import Demo Data"
msgstr ""
#: inc/Helpers.php:327
msgid ""
"An error occurred while retrieving reading/writing permissions to your "
"server (could not retrieve WP filesystem credentials)!"
msgstr ""
#: inc/Helpers.php:335
msgid "Your WordPress login credentials don't allow to use WP_Filesystem!"
msgstr ""
#: inc/Helpers.php:375
msgid "One Click Demo Import - "
msgstr ""
#: inc/Helpers.php:409
msgid ""
"%sYour user role isn't high enough. You don't have permission to import "
"demo data.%s"
msgstr ""
#: inc/Helpers.php:444
msgid ""
"Please upload XML file for content import. If you want to import widgets or "
"customizer settings only, please use Widget Importer & Exporter or the "
"Customizer Export/Import plugin."
msgstr ""
#: inc/Helpers.php:446 inc/Helpers.php:466 inc/Helpers.php:483
#: inc/Helpers.php:494 inc/Helpers.php:514 inc/Helpers.php:522
msgid "Upload files"
msgstr ""
#: inc/Helpers.php:462
msgid "Widget file was not uploaded. Error: %s"
msgstr ""
#: inc/Helpers.php:479
msgid "Customizer file was not uploaded. Error: %s"
msgstr ""
#: inc/Helpers.php:492
msgid "Missing Redux option name! Please also enter the Redux option name!"
msgstr ""
#: inc/Helpers.php:510
msgid "Redux file was not uploaded. Error: %s"
msgstr ""
#: inc/Helpers.php:520
msgid "The import files were successfully uploaded!"
msgstr ""
#: inc/Helpers.php:546
msgid "Initial max execution time = %s"
msgstr ""
#: inc/Helpers.php:550
msgid ""
"Files info:%1$sSite URL = %2$s%1$sData file = %3$s%1$sWidget file = "
"%4$s%1$sCustomizer file = %5$s%1$sRedux files:%1$s%6$s"
msgstr ""
#: inc/Helpers.php:554 inc/Helpers.php:555 inc/Helpers.php:556
msgid "not defined!"
msgstr ""
#: inc/Importer.php:173
msgid "New AJAX call!"
msgstr ""
#: inc/OneClickDemoImport.php:183
msgid "No preview image defined for this import."
msgstr ""
#: inc/OneClickDemoImport.php:184
msgid "Are you sure?"
msgstr ""
#: inc/OneClickDemoImport.php:185
msgid "Cancel"
msgstr ""
#: inc/OneClickDemoImport.php:186
msgid "Yes, import!"
msgstr ""
#: inc/OneClickDemoImport.php:187
msgid "Selected demo import:"
msgstr ""
#: inc/OneClickDemoImport.php:234
msgid "Manually uploaded files"
msgstr ""
#: inc/OneClickDemoImport.php:247 inc/OneClickDemoImport.php:258
msgid "Downloaded files"
msgstr ""
#: inc/OneClickDemoImport.php:254
msgid "The import files for: %s were successfully downloaded!"
msgstr ""
#: inc/OneClickDemoImport.php:263
msgid "No import files specified!"
msgstr ""
#: inc/OneClickDemoImport.php:382
msgid ""
"Just used One Click Demo Import plugin and it was awesome! Thanks "
"@ProteusThemes! #OCDI https://www.proteusthemes.com/"
msgstr ""
#: inc/OneClickDemoImport.php:385
msgid ""
"%1$s%6$sWasn't this a great One Click Demo Import experience?%7$s Created "
"and maintained by %3$sProteusThemes%4$s. %2$s%5$sClick to Tweet!%4$s%8$s"
msgstr ""
#: inc/OneClickDemoImport.php:398
msgid ""
"%1$s%3$sThat's it, all done!%4$s%2$sThe demo import has finished. Please "
"check your page and make sure that everything has imported correctly. If it "
"did, you can deactivate the %3$sOne Click Demo Import%4$s plugin, because "
"it has done its job.%5$s"
msgstr ""
#: inc/OneClickDemoImport.php:409
msgid ""
"%1$sThe demo import has finished, but there were some import "
"errors.%2$sMore details about the errors can be found in this %3$s%5$slog "
"file%6$s%4$s%7$s"
msgstr ""
#: inc/ReduxImporter.php:23
msgid "The Redux plugin is not activated, so the Redux import was skipped!"
msgstr ""
#: inc/ReduxImporter.php:32 inc/ReduxImporter.php:53 inc/ReduxImporter.php:66
msgid "Importing Redux settings"
msgstr ""
#: inc/ReduxImporter.php:51
msgid "Redux settings import for: %s finished successfully!"
msgstr ""
#: inc/ReduxImporter.php:57
msgid ""
"The Redux option name: %s, was not found in this WP site, so it was not "
"imported!"
msgstr ""
#: inc/WidgetImporter.php:40 inc/WidgetImporter.php:52
msgid "Importing widgets"
msgstr ""
#: inc/WidgetImporter.php:88
msgid "Error: Widget import file could not be found."
msgstr ""
#: inc/WidgetImporter.php:118
msgid "Error: Widget import data could not be read. Please try a different file."
msgstr ""
#: inc/WidgetImporter.php:157
msgid "Sidebar does not exist in theme (moving widget to Inactive)"
msgstr ""
#: inc/WidgetImporter.php:178
msgid "Site does not support widget"
msgstr ""
#: inc/WidgetImporter.php:211
msgid "Widget already exists"
msgstr ""
#: inc/WidgetImporter.php:269
msgid "Imported"
msgstr ""
#: inc/WidgetImporter.php:273
msgid "Imported to Inactive"
msgstr ""
#: inc/WidgetImporter.php:279
msgid "No Title"
msgstr ""
#: inc/WidgetImporter.php:326
msgid "No results for widget import!"
msgstr ""
#: one-click-demo-import.php:51
msgid ""
"The %2$sOne Click Demo Import%3$s plugin requires %2$sPHP 5.3.2+%3$s to run "
"properly. Please contact your hosting company and ask them to update the "
"PHP version of your site to at least PHP 5.3.2.%4$s Your current version of "
"PHP: %2$s%1$s%3$s"
msgstr ""
#. Plugin URI of the plugin/theme
msgid "https://wordpress.org/plugins/one-click-demo-import/"
msgstr ""
#. Description of the plugin/theme
msgid ""
"Import your content, widgets and theme settings with one click. Theme "
"authors! Enable simple demo import for your theme demo data."
msgstr ""
#. Author of the plugin/theme
msgid "ProteusThemes"
msgstr ""
#. Author URI of the plugin/theme
msgid "http://www.proteusthemes.com"
msgstr "" vendor/autoload.php 0000666 00000000262 15213303300 0010354 0 ustar 00 log( 'emergency', $message, $context );
}
/**
* Action must be taken immediately.
*
* Example: Entire website down, database unavailable, etc. This should
* trigger the SMS alerts and wake you up.
*
* @param string $message
* @param array $context
* @return null
*/
public function alert( $message, array $context = array() ) {
return $this->log( 'alert', $message, $context );
}
/**
* Critical conditions.
*
* Example: Application component unavailable, unexpected exception.
*
* @param string $message
* @param array $context
* @return null
*/
public function critical( $message, array $context = array() ) {
return $this->log( 'critical', $message, $context );
}
/**
* Runtime errors that do not require immediate action but should typically
* be logged and monitored.
*
* @param string $message
* @param array $context
* @return null
*/
public function error( $message, array $context = array()) {
return $this->log( 'error', $message, $context );
}
/**
* Exceptional occurrences that are not errors.
*
* Example: Use of deprecated APIs, poor use of an API, undesirable things
* that are not necessarily wrong.
*
* @param string $message
* @param array $context
* @return null
*/
public function warning( $message, array $context = array() ) {
return $this->log( 'warning', $message, $context );
}
/**
* Normal but significant events.
*
* @param string $message
* @param array $context
* @return null
*/
public function notice( $message, array $context = array() ) {
return $this->log( 'notice', $message, $context );
}
/**
* Interesting events.
*
* Example: User logs in, SQL logs.
*
* @param string $message
* @param array $context
* @return null
*/
public function info( $message, array $context = array() ) {
return $this->log( 'info', $message, $context );
}
/**
* Detailed debug information.
*
* @param string $message
* @param array $context
* @return null
*/
public function debug( $message, array $context = array() ) {
return $this->log( 'debug', $message, $context );
}
/**
* Logs with an arbitrary level.
*
* @param mixed $level
* @param string $message
* @param array $context
* @return null
*/
public function log( $level, $message, array $context = array() ) {
$this->messages[] = array(
'timestamp' => time(),
'level' => $level,
'message' => $message,
'context' => $context,
);
}
}
vendor/proteusthemes/wp-content-importer-v2/src/WXRImportInfo.php 0000666 00000000451 15213303300 0021213 0 ustar 00 ` tag at the start of the file.
*
* @var string
*/
protected $version = '1.0';
// information to import from WXR file
protected $categories = array();
protected $tags = array();
protected $base_url = '';
// TODO: REMOVE THESE
protected $processed_terms = array();
protected $processed_posts = array();
protected $processed_menu_items = array();
protected $menu_item_orphans = array();
protected $missing_menu_items = array();
// NEW STYLE
protected $mapping = array();
protected $requires_remapping = array();
protected $exists = array();
protected $user_slug_override = array();
protected $url_remap = array();
protected $featured_images = array();
/**
* Logger instance.
*
* @var WP_Importer_Logger
*/
protected $logger;
/**
* Constructor
*
* @param array $options {
* @var bool $prefill_existing_posts Should we prefill `post_exists` calls? (True prefills and uses more memory, false checks once per imported post and takes longer. Default is true.)
* @var bool $prefill_existing_comments Should we prefill `comment_exists` calls? (True prefills and uses more memory, false checks once per imported comment and takes longer. Default is true.)
* @var bool $prefill_existing_terms Should we prefill `term_exists` calls? (True prefills and uses more memory, false checks once per imported term and takes longer. Default is true.)
* @var bool $update_attachment_guids Should attachment GUIDs be updated to the new URL? (True updates the GUID, which keeps compatibility with v1, false doesn't update, and allows deduplication and reimporting. Default is false.)
* @var bool $fetch_attachments Fetch attachments from the remote server. (True fetches and creates attachment posts, false skips attachments. Default is false.)
* @var bool $aggressive_url_search Should we search/replace for URLs aggressively? (True searches all posts' content for old URLs and replaces, false checks for `` only. Default is false.)
* @var int $default_author User ID to use if author is missing or invalid. (Default is null, which leaves posts unassigned.)
* }
*/
public function __construct( $options = array() ) {
// Initialize some important variables
$empty_types = array(
'post' => array(),
'comment' => array(),
'term' => array(),
'user' => array(),
);
$this->mapping = $empty_types;
$this->mapping['user_slug'] = array();
$this->mapping['term_id'] = array();
$this->requires_remapping = $empty_types;
$this->exists = $empty_types;
$this->options = wp_parse_args( $options, array(
'prefill_existing_posts' => true,
'prefill_existing_comments' => true,
'prefill_existing_terms' => true,
'update_attachment_guids' => false,
'fetch_attachments' => false,
'aggressive_url_search' => false,
'default_author' => null,
) );
}
public function set_logger( $logger ) {
$this->logger = $logger;
}
/**
* Get a stream reader for the file.
*
* @param string $file Path to the XML file.
* @return XMLReader|WP_Error Reader instance on success, error otherwise.
*/
protected function get_reader( $file ) {
// Avoid loading external entities for security
$old_value = null;
if ( function_exists( 'libxml_disable_entity_loader' ) ) {
// $old_value = libxml_disable_entity_loader( true );
}
$reader = new \XMLReader();
$status = $reader->open( $file );
if ( ! is_null( $old_value ) ) {
// libxml_disable_entity_loader( $old_value );
}
if ( ! $status ) {
return new \WP_Error( 'wxr_importer.cannot_parse', __( 'Could not open the file for parsing', 'wordpress-importer' ) );
}
return $reader;
}
/**
* The main controller for the actual import stage.
*
* @param string $file Path to the WXR file for importing
*/
public function get_preliminary_information( $file ) {
// Let's run the actual importer now, woot
$reader = $this->get_reader( $file );
if ( is_wp_error( $reader ) ) {
return $reader;
}
// Set the version to compatibility mode first
$this->version = '1.0';
// Start parsing!
$data = new WXRImportInfo();
while ( $reader->read() ) {
// Only deal with element opens
if ( $reader->nodeType !== \XMLReader::ELEMENT ) {
continue;
}
switch ( $reader->name ) {
case 'wp:wxr_version':
// Upgrade to the correct version
$this->version = $reader->readString();
if ( version_compare( $this->version, self::MAX_WXR_VERSION, '>' ) ) {
$this->logger->warning( sprintf(
__( 'This WXR file (version %s) is newer than the importer (version %s) and may not be supported. Please consider updating.', 'wordpress-importer' ),
$this->version,
self::MAX_WXR_VERSION
) );
}
// Handled everything in this node, move on to the next
$reader->next();
break;
case 'generator':
$data->generator = $reader->readString();
$reader->next();
break;
case 'title':
$data->title = $reader->readString();
$reader->next();
break;
case 'wp:base_site_url':
$data->siteurl = $reader->readString();
$reader->next();
break;
case 'wp:base_blog_url':
$data->home = $reader->readString();
$reader->next();
break;
case 'wp:author':
$node = $reader->expand();
$parsed = $this->parse_author_node( $node );
if ( is_wp_error( $parsed ) ) {
$this->log_error( $parsed );
// Skip the rest of this post
$reader->next();
break;
}
$data->users[] = $parsed;
// Handled everything in this node, move on to the next
$reader->next();
break;
case 'item':
$node = $reader->expand();
$parsed = $this->parse_post_node( $node );
if ( is_wp_error( $parsed ) ) {
$this->log_error( $parsed );
// Skip the rest of this post
$reader->next();
break;
}
if ( $parsed['data']['post_type'] === 'attachment' ) {
$data->media_count++;
} else {
$data->post_count++;
}
$data->comment_count += count( $parsed['comments'] );
// Handled everything in this node, move on to the next
$reader->next();
break;
case 'wp:category':
case 'wp:tag':
case 'wp:term':
$data->term_count++;
// Handled everything in this node, move on to the next
$reader->next();
break;
}
}
$data->version = $this->version;
return $data;
}
/**
* The main controller for the actual import stage.
*
* @param string $file Path to the WXR file for importing
*/
public function parse_authors( $file ) {
// Let's run the actual importer now, woot
$reader = $this->get_reader( $file );
if ( is_wp_error( $reader ) ) {
return $reader;
}
// Set the version to compatibility mode first
$this->version = '1.0';
// Start parsing!
$authors = array();
while ( $reader->read() ) {
// Only deal with element opens
if ( $reader->nodeType !== \XMLReader::ELEMENT ) {
continue;
}
switch ( $reader->name ) {
case 'wp:wxr_version':
// Upgrade to the correct version
$this->version = $reader->readString();
if ( version_compare( $this->version, self::MAX_WXR_VERSION, '>' ) ) {
$this->logger->warning( sprintf(
__( 'This WXR file (version %s) is newer than the importer (version %s) and may not be supported. Please consider updating.', 'wordpress-importer' ),
$this->version,
self::MAX_WXR_VERSION
) );
}
// Handled everything in this node, move on to the next
$reader->next();
break;
case 'wp:author':
$node = $reader->expand();
$parsed = $this->parse_author_node( $node );
if ( is_wp_error( $parsed ) ) {
$this->log_error( $parsed );
// Skip the rest of this post
$reader->next();
break;
}
$authors[] = $parsed;
// Handled everything in this node, move on to the next
$reader->next();
break;
}
}
return $authors;
}
/**
* The main controller for the actual import stage.
*
* @param string $file Path to the WXR file for importing
*/
public function import( $file ) {
add_filter( 'import_post_meta_key', array( $this, 'is_valid_meta_key' ) );
add_filter( 'http_request_timeout', array( &$this, 'bump_request_timeout' ) );
$result = $this->import_start( $file );
if ( is_wp_error( $result ) ) {
return $result;
}
// Let's run the actual importer now, woot
$reader = $this->get_reader( $file );
if ( is_wp_error( $reader ) ) {
return $reader;
}
// Set the version to compatibility mode first
$this->version = '1.0';
// Reset other variables
$this->base_url = '';
// Start parsing!
while ( $reader->read() ) {
// Only deal with element opens
if ( $reader->nodeType !== \XMLReader::ELEMENT ) {
continue;
}
switch ( $reader->name ) {
case 'wp:wxr_version':
// Upgrade to the correct version
$this->version = $reader->readString();
if ( version_compare( $this->version, self::MAX_WXR_VERSION, '>' ) ) {
$this->logger->warning( sprintf(
__( 'This WXR file (version %s) is newer than the importer (version %s) and may not be supported. Please consider updating.', 'wordpress-importer' ),
$this->version,
self::MAX_WXR_VERSION
) );
}
// Handled everything in this node, move on to the next
$reader->next();
break;
case 'wp:base_site_url':
$this->base_url = $reader->readString();
// Handled everything in this node, move on to the next
$reader->next();
break;
case 'item':
$node = $reader->expand();
$parsed = $this->parse_post_node( $node );
if ( is_wp_error( $parsed ) ) {
$this->log_error( $parsed );
// Skip the rest of this post
$reader->next();
break;
}
$this->process_post( $parsed['data'], $parsed['meta'], $parsed['comments'], $parsed['terms'] );
// Handled everything in this node, move on to the next
$reader->next();
break;
case 'wp:author':
$node = $reader->expand();
$parsed = $this->parse_author_node( $node );
if ( is_wp_error( $parsed ) ) {
$this->log_error( $parsed );
// Skip the rest of this post
$reader->next();
break;
}
$status = $this->process_author( $parsed['data'], $parsed['meta'] );
if ( is_wp_error( $status ) ) {
$this->log_error( $status );
}
// Handled everything in this node, move on to the next
$reader->next();
break;
case 'wp:category':
$node = $reader->expand();
$parsed = $this->parse_term_node( $node, 'category' );
if ( is_wp_error( $parsed ) ) {
$this->log_error( $parsed );
// Skip the rest of this post
$reader->next();
break;
}
$status = $this->process_term( $parsed['data'], $parsed['meta'] );
// Handled everything in this node, move on to the next
$reader->next();
break;
case 'wp:tag':
$node = $reader->expand();
$parsed = $this->parse_term_node( $node, 'tag' );
if ( is_wp_error( $parsed ) ) {
$this->log_error( $parsed );
// Skip the rest of this post
$reader->next();
break;
}
$status = $this->process_term( $parsed['data'], $parsed['meta'] );
// Handled everything in this node, move on to the next
$reader->next();
break;
case 'wp:term':
$node = $reader->expand();
$parsed = $this->parse_term_node( $node );
if ( is_wp_error( $parsed ) ) {
$this->log_error( $parsed );
// Skip the rest of this post
$reader->next();
break;
}
$status = $this->process_term( $parsed['data'], $parsed['meta'] );
// Handled everything in this node, move on to the next
$reader->next();
break;
default:
// Skip this node, probably handled by something already
break;
}
}
// Now that we've done the main processing, do any required
// post-processing and remapping.
$this->post_process();
if ( $this->options['aggressive_url_search'] ) {
$this->replace_attachment_urls_in_content();
}
$this->remap_featured_images();
$this->import_end();
}
/**
* Log an error instance to the logger.
*
* @param WP_Error $error Error instance to log.
*/
protected function log_error( WP_Error $error ) {
$this->logger->warning( $error->get_error_message() );
// Log the data as debug info too
$data = $error->get_error_data();
if ( ! empty( $data ) ) {
$this->logger->debug( var_export( $data, true ) );
}
}
/**
* Parses the WXR file and prepares us for the task of processing parsed data
*
* @param string $file Path to the WXR file for importing
*/
protected function import_start( $file ) {
if ( ! is_file( $file ) ) {
return new \WP_Error( 'wxr_importer.file_missing', __( 'The file does not exist, please try again.', 'wordpress-importer' ) );
}
// Suspend bunches of stuff in WP core
wp_defer_term_counting( true );
wp_defer_comment_counting( true );
wp_suspend_cache_invalidation( true );
// Prefill exists calls if told to
if ( $this->options['prefill_existing_posts'] ) {
$this->prefill_existing_posts();
}
if ( $this->options['prefill_existing_comments'] ) {
$this->prefill_existing_comments();
}
if ( $this->options['prefill_existing_terms'] ) {
$this->prefill_existing_terms();
}
/**
* Begin the import.
*
* Fires before the import process has begun. If you need to suspend
* caching or heavy processing on hooks, do so here.
*/
do_action( 'import_start' );
}
/**
* Performs post-import cleanup of files and the cache
*/
protected function import_end() {
// Re-enable stuff in core
wp_suspend_cache_invalidation( false );
wp_cache_flush();
foreach ( get_taxonomies() as $tax ) {
delete_option( "{$tax}_children" );
_get_term_hierarchy( $tax );
}
wp_defer_term_counting( false );
wp_defer_comment_counting( false );
/**
* Complete the import.
*
* Fires after the import process has finished. If you need to update
* your cache or re-enable processing, do so here.
*/
do_action( 'import_end' );
}
/**
* Set the user mapping.
*
* @param array $mapping List of map arrays (containing `old_slug`, `old_id`, `new_id`)
*/
public function set_user_mapping( $mapping ) {
foreach ( $mapping as $map ) {
if ( empty( $map['old_slug'] ) || empty( $map['old_id'] ) || empty( $map['new_id'] ) ) {
$this->logger->warning( __( 'Invalid author mapping', 'wordpress-importer' ) );
$this->logger->debug( var_export( $map, true ) );
continue;
}
$old_slug = $map['old_slug'];
$old_id = $map['old_id'];
$new_id = $map['new_id'];
$this->mapping['user'][ $old_id ] = $new_id;
$this->mapping['user_slug'][ $old_slug ] = $new_id;
}
}
/**
* Set the user slug overrides.
*
* Allows overriding the slug in the import with a custom/renamed version.
*
* @param string[] $overrides Map of old slug to new slug.
*/
public function set_user_slug_overrides( $overrides ) {
foreach ( $overrides as $original => $renamed ) {
$this->user_slug_override[ $original ] = $renamed;
}
}
/**
* Parse a post node into post data.
*
* @param DOMElement $node Parent node of post data (typically `item`).
* @return array|WP_Error Post data array on success, error otherwise.
*/
protected function parse_post_node( $node ) {
$data = array();
$meta = array();
$comments = array();
$terms = array();
foreach ( $node->childNodes as $child ) {
// We only care about child elements
if ( $child->nodeType !== XML_ELEMENT_NODE ) {
continue;
}
switch ( $child->tagName ) {
case 'wp:post_type':
$data['post_type'] = $child->textContent;
break;
case 'title':
$data['post_title'] = $child->textContent;
break;
case 'guid':
$data['guid'] = $child->textContent;
break;
case 'dc:creator':
$data['post_author'] = $child->textContent;
break;
case 'content:encoded':
$data['post_content'] = $child->textContent;
break;
case 'excerpt:encoded':
$data['post_excerpt'] = $child->textContent;
break;
case 'wp:post_id':
$data['post_id'] = $child->textContent;
break;
case 'wp:post_date':
$data['post_date'] = $child->textContent;
break;
case 'wp:post_date_gmt':
$data['post_date_gmt'] = $child->textContent;
break;
case 'wp:comment_status':
$data['comment_status'] = $child->textContent;
break;
case 'wp:ping_status':
$data['ping_status'] = $child->textContent;
break;
case 'wp:post_name':
$data['post_name'] = $child->textContent;
break;
case 'wp:status':
$data['post_status'] = $child->textContent;
if ( $data['post_status'] === 'auto-draft' ) {
// Bail now
return new \WP_Error(
'wxr_importer.post.cannot_import_draft',
__( 'Cannot import auto-draft posts' ),
$data
);
}
break;
case 'wp:post_parent':
$data['post_parent'] = $child->textContent;
break;
case 'wp:menu_order':
$data['menu_order'] = $child->textContent;
break;
case 'wp:post_password':
$data['post_password'] = $child->textContent;
break;
case 'wp:is_sticky':
$data['is_sticky'] = $child->textContent;
break;
case 'wp:attachment_url':
$data['attachment_url'] = $child->textContent;
break;
case 'wp:postmeta':
$meta_item = $this->parse_meta_node( $child );
if ( ! empty( $meta_item ) ) {
$meta[] = $meta_item;
}
break;
case 'wp:comment':
$comment_item = $this->parse_comment_node( $child );
if ( ! empty( $comment_item ) ) {
$comments[] = $comment_item;
}
break;
case 'category':
$term_item = $this->parse_category_node( $child );
if ( ! empty( $term_item ) ) {
$terms[] = $term_item;
}
break;
}
}
return compact( 'data', 'meta', 'comments', 'terms' );
}
/**
* Create new posts based on import information
*
* Posts marked as having a parent which doesn't exist will become top level items.
* Doesn't create a new post if: the post type doesn't exist, the given post ID
* is already noted as imported or a post with the same title and date already exists.
* Note that new/updated terms, comments and meta are imported for the last of the above.
*/
protected function process_post( $data, $meta, $comments, $terms ) {
/**
* Pre-process post data.
*
* @param array $data Post data. (Return empty to skip.)
* @param array $meta Meta data.
* @param array $comments Comments on the post.
* @param array $terms Terms on the post.
*/
$data = apply_filters( 'wxr_importer.pre_process.post', $data, $meta, $comments, $terms );
if ( empty( $data ) ) {
return false;
}
$original_id = isset( $data['post_id'] ) ? (int) $data['post_id'] : 0;
$parent_id = isset( $data['post_parent'] ) ? (int) $data['post_parent'] : 0;
$author_id = isset( $data['post_author'] ) ? (int) $data['post_author'] : 0;
// Have we already processed this?
if ( isset( $this->mapping['post'][ $original_id ] ) ) {
return;
}
$post_type_object = get_post_type_object( $data['post_type'] );
// Is this type even valid?
if ( ! $post_type_object ) {
$this->logger->warning( sprintf(
__( 'Failed to import "%s": Invalid post type %s', 'wordpress-importer' ),
$data['post_title'],
$data['post_type']
) );
return false;
}
$post_exists = $this->post_exists( $data );
if ( $post_exists ) {
$this->logger->info( sprintf(
__( '%s "%s" already exists.', 'wordpress-importer' ),
$post_type_object->labels->singular_name,
$data['post_title']
) );
// Even though this post already exists, new comments might need importing
$this->process_comments( $comments, $original_id, $data, $post_exists );
return false;
}
// Map the parent post, or mark it as one we need to fix
$requires_remapping = false;
if ( $parent_id ) {
if ( isset( $this->mapping['post'][ $parent_id ] ) ) {
$data['post_parent'] = $this->mapping['post'][ $parent_id ];
} else {
$meta[] = array( 'key' => '_wxr_import_parent', 'value' => $parent_id );
$requires_remapping = true;
$data['post_parent'] = 0;
}
}
// Map the author, or mark it as one we need to fix
$author = sanitize_user( $data['post_author'], true );
if ( empty( $author ) ) {
// Missing or invalid author, use default if available.
$data['post_author'] = $this->options['default_author'];
} elseif ( isset( $this->mapping['user_slug'][ $author ] ) ) {
$data['post_author'] = $this->mapping['user_slug'][ $author ];
} else {
$meta[] = array( 'key' => '_wxr_import_user_slug', 'value' => $author );
$requires_remapping = true;
$data['post_author'] = (int) get_current_user_id();
}
// Does the post look like it contains attachment images?
if ( preg_match( self::REGEX_HAS_ATTACHMENT_REFS, $data['post_content'] ) ) {
$meta[] = array( 'key' => '_wxr_import_has_attachment_refs', 'value' => true );
$requires_remapping = true;
}
// Whitelist to just the keys we allow
$postdata = array(
'import_id' => $data['post_id'],
);
$allowed = array(
'post_author' => true,
'post_date' => true,
'post_date_gmt' => true,
'post_content' => true,
'post_excerpt' => true,
'post_title' => true,
'post_status' => true,
'post_name' => true,
'comment_status' => true,
'ping_status' => true,
'guid' => true,
'post_parent' => true,
'menu_order' => true,
'post_type' => true,
'post_password' => true,
);
foreach ( $data as $key => $value ) {
if ( ! isset( $allowed[ $key ] ) ) {
continue;
}
$postdata[ $key ] = $data[ $key ];
}
$postdata = apply_filters( 'wp_import_post_data_processed', $postdata, $data );
if ( 'attachment' === $postdata['post_type'] ) {
if ( ! $this->options['fetch_attachments'] ) {
$this->logger->notice( sprintf(
__( 'Skipping attachment "%s", fetching attachments disabled' ),
$data['post_title']
) );
return false;
}
$remote_url = ! empty( $data['attachment_url'] ) ? $data['attachment_url'] : $data['guid'];
$post_id = $this->process_attachment( $postdata, $meta, $remote_url );
} else {
$post_id = wp_insert_post( $postdata, true );
do_action( 'wp_import_insert_post', $post_id, $original_id, $postdata, $data );
}
if ( is_wp_error( $post_id ) ) {
$this->logger->error( sprintf(
__( 'Failed to import "%s" (%s)', 'wordpress-importer' ),
$data['post_title'],
$post_type_object->labels->singular_name
) );
$this->logger->debug( $post_id->get_error_message() );
/**
* Post processing failed.
*
* @param WP_Error $post_id Error object.
* @param array $data Raw data imported for the post.
* @param array $meta Raw meta data, already processed by {@see process_post_meta}.
* @param array $comments Raw comment data, already processed by {@see process_comments}.
* @param array $terms Raw term data, already processed.
*/
do_action( 'wxr_importer.process_failed.post', $post_id, $data, $meta, $comments, $terms );
return false;
}
// Ensure stickiness is handled correctly too
if ( $data['is_sticky'] === '1' ) {
stick_post( $post_id );
}
// map pre-import ID to local ID
$this->mapping['post'][ $original_id ] = (int) $post_id;
if ( $requires_remapping ) {
$this->requires_remapping['post'][ $post_id ] = true;
}
$this->mark_post_exists( $data, $post_id );
$this->logger->info( sprintf(
__( 'Imported "%s" (%s)', 'wordpress-importer' ),
$data['post_title'],
$post_type_object->labels->singular_name
) );
$this->logger->debug( sprintf(
__( 'Post %d remapped to %d', 'wordpress-importer' ),
$original_id,
$post_id
) );
// Handle the terms too
$terms = apply_filters( 'wp_import_post_terms', $terms, $post_id, $data );
if ( ! empty( $terms ) ) {
$term_ids = array();
foreach ( $terms as $term ) {
$taxonomy = $term['taxonomy'];
$key = sha1( $taxonomy . ':' . $term['slug'] );
if ( isset( $this->mapping['term'][ $key ] ) ) {
$term_ids[ $taxonomy ][] = (int) $this->mapping['term'][ $key ];
} else {
/**
* Fix for the post format "categories".
* The issue in this importer is, that these post formats are misused as categories in WP export
* (as the export data item in the post export item), but they are not actually
* exported as wp:category items in the XML file, so they need to be inserted on the fly (here).
*
* Maybe something better can be done in the future?
*
* Original issue reported here: https://wordpress.org/support/topic/post-format-videoquotegallery-became-format-standard/#post-8447683
*
*/
if ( 'post_format' === $taxonomy ) {
$term_exists = term_exists( $term['slug'], $taxonomy );
$term_id = is_array( $term_exists ) ? $term_exists['term_id'] : $term_exists;
if ( empty( $term_id ) ) {
$t = wp_insert_term( $term['name'], $taxonomy, array( 'slug' => $term['slug'] ) );
if ( ! is_wp_error( $t ) ) {
$term_id = $t['term_id'];
$this->mapping['term'][ $key ] = $term_id;
} else {
$this->logger->warning( sprintf(
esc_html__( 'Failed to import term: %s - %s', 'wordpress-importer' ),
esc_html( $taxonomy ),
esc_html( $term['name'] )
) );
continue;
}
}
if ( ! empty( $term_id ) ) {
$term_ids[ $taxonomy ][] = intval( $term_id );
}
} // End of fix.
else {
$meta[] = array( 'key' => '_wxr_import_term', 'value' => $term );
$requires_remapping = true;
}
}
}
foreach ( $term_ids as $tax => $ids ) {
$tt_ids = wp_set_post_terms( $post_id, $ids, $tax );
do_action( 'wp_import_set_post_terms', $tt_ids, $ids, $tax, $post_id, $data );
}
}
$this->process_comments( $comments, $post_id, $data );
$this->process_post_meta( $meta, $post_id, $data );
if ( 'nav_menu_item' === $data['post_type'] ) {
$this->process_menu_item_meta( $post_id, $data, $meta );
}
/**
* Post processing completed.
*
* @param int $post_id New post ID.
* @param array $data Raw data imported for the post.
* @param array $meta Raw meta data, already processed by {@see process_post_meta}.
* @param array $comments Raw comment data, already processed by {@see process_comments}.
* @param array $terms Raw term data, already processed.
*/
do_action( 'wxr_importer.processed.post', $post_id, $data, $meta, $comments, $terms );
}
/**
* Attempt to create a new menu item from import data
*
* Fails for draft, orphaned menu items and those without an associated nav_menu
* or an invalid nav_menu term. If the post type or term object which the menu item
* represents doesn't exist then the menu item will not be imported (waits until the
* end of the import to retry again before discarding).
*
* @param array $item Menu item details from WXR file
*/
protected function process_menu_item_meta( $post_id, $data, $meta ) {
$item_type = get_post_meta( $post_id, '_menu_item_type', true );
$original_object_id = get_post_meta( $post_id, '_menu_item_object_id', true );
$object_id = null;
$this->logger->debug( sprintf( 'Processing menu item %s', $item_type ) );
$requires_remapping = false;
switch ( $item_type ) {
case 'taxonomy':
if ( isset( $this->mapping['term_id'][ $original_object_id ] ) ) {
$object_id = $this->mapping['term_id'][ $original_object_id ];
} else {
add_post_meta( $post_id, '_wxr_import_menu_item', wp_slash( $original_object_id ) );
$requires_remapping = true;
}
break;
case 'post_type':
if ( isset( $this->mapping['post'][ $original_object_id ] ) ) {
$object_id = $this->mapping['post'][ $original_object_id ];
} else {
add_post_meta( $post_id, '_wxr_import_menu_item', wp_slash( $original_object_id ) );
$requires_remapping = true;
}
break;
case 'custom':
// Custom refers to itself, wonderfully easy.
$object_id = $post_id;
break;
default:
// associated object is missing or not imported yet, we'll retry later
$this->missing_menu_items[] = $data;
$this->logger->debug( 'Unknown menu item type' );
break;
}
if ( $requires_remapping ) {
$this->requires_remapping['post'][ $post_id ] = true;
}
if ( empty( $object_id ) ) {
// Nothing needed here.
return;
}
$this->logger->debug( sprintf( 'Menu item %d mapped to %d', $original_object_id, $object_id ) );
update_post_meta( $post_id, '_menu_item_object_id', wp_slash( $object_id ) );
}
/**
* If fetching attachments is enabled then attempt to create a new attachment
*
* @param array $post Attachment post details from WXR
* @param string $url URL to fetch attachment from
* @return int|WP_Error Post ID on success, WP_Error otherwise
*/
protected function process_attachment( $post, $meta, $remote_url ) {
// try to use _wp_attached file for upload folder placement to ensure the same location as the export site
// e.g. location is 2003/05/image.jpg but the attachment post_date is 2010/09, see media_handle_upload()
$post['upload_date'] = $post['post_date'];
foreach ( $meta as $meta_item ) {
if ( $meta_item['key'] !== '_wp_attached_file' ) {
continue;
}
if ( preg_match( '%^[0-9]{4}/[0-9]{2}%', $meta_item['value'], $matches ) ) {
$post['upload_date'] = $matches[0];
}
break;
}
// if the URL is absolute, but does not contain address, then upload it assuming base_site_url
if ( preg_match( '|^/[\w\W]+$|', $remote_url ) ) {
$remote_url = rtrim( $this->base_url, '/' ) . $remote_url;
}
$upload = $this->fetch_remote_file( $remote_url, $post );
if ( is_wp_error( $upload ) ) {
return $upload;
}
$info = wp_check_filetype( $upload['file'] );
if ( ! $info ) {
return new \WP_Error( 'attachment_processing_error', __( 'Invalid file type', 'wordpress-importer' ) );
}
$post['post_mime_type'] = $info['type'];
// WP really likes using the GUID for display. Allow updating it.
// See https://core.trac.wordpress.org/ticket/33386
if ( $this->options['update_attachment_guids'] ) {
$post['guid'] = $upload['url'];
}
// as per wp-admin/includes/upload.php
$post_id = wp_insert_attachment( $post, $upload['file'] );
if ( is_wp_error( $post_id ) ) {
return $post_id;
}
$attachment_metadata = wp_generate_attachment_metadata( $post_id, $upload['file'] );
wp_update_attachment_metadata( $post_id, $attachment_metadata );
// Map this image URL later if we need to
$this->url_remap[ $remote_url ] = $upload['url'];
// If we have a HTTPS URL, ensure the HTTP URL gets replaced too
if ( substr( $remote_url, 0, 8 ) === 'https://' ) {
$insecure_url = 'http' . substr( $remote_url, 5 );
$this->url_remap[ $insecure_url ] = $upload['url'];
}
if ( $this->options['aggressive_url_search'] ) {
// remap resized image URLs, works by stripping the extension and remapping the URL stub.
/*if ( preg_match( '!^image/!', $info['type'] ) ) {
$parts = pathinfo( $remote_url );
$name = basename( $parts['basename'], ".{$parts['extension']}" ); // PATHINFO_FILENAME in PHP 5.2
$parts_new = pathinfo( $upload['url'] );
$name_new = basename( $parts_new['basename'], ".{$parts_new['extension']}" );
$this->url_remap[$parts['dirname'] . '/' . $name] = $parts_new['dirname'] . '/' . $name_new;
}*/
}
return $post_id;
}
/**
* Parse a meta node into meta data.
*
* @param DOMElement $node Parent node of meta data (typically `wp:postmeta` or `wp:commentmeta`).
* @return array|null Meta data array on success, or null on error.
*/
protected function parse_meta_node( $node ) {
foreach ( $node->childNodes as $child ) {
// We only care about child elements
if ( $child->nodeType !== XML_ELEMENT_NODE ) {
continue;
}
switch ( $child->tagName ) {
case 'wp:meta_key':
$key = $child->textContent;
break;
case 'wp:meta_value':
$value = $child->textContent;
break;
}
}
if ( empty( $key ) || empty( $value ) ) {
return null;
}
return compact( 'key', 'value' );
}
/**
* Process and import post meta items.
*
* @param array $meta List of meta data arrays
* @param int $post_id Post to associate with
* @param array $post Post data
* @return int|WP_Error Number of meta items imported on success, error otherwise.
*/
protected function process_post_meta( $meta, $post_id, $post ) {
if ( empty( $meta ) ) {
return true;
}
foreach ( $meta as $meta_item ) {
/**
* Pre-process post meta data.
*
* @param array $meta_item Meta data. (Return empty to skip.)
* @param int $post_id Post the meta is attached to.
*/
$meta_item = apply_filters( 'wxr_importer.pre_process.post_meta', $meta_item, $post_id );
if ( empty( $meta_item ) ) {
return false;
}
$key = apply_filters( 'import_post_meta_key', $meta_item['key'], $post_id, $post );
$value = false;
if ( '_edit_last' === $key ) {
$value = intval( $meta_item['value'] );
if ( ! isset( $this->mapping['user'][ $value ] ) ) {
// Skip!
continue;
}
$value = $this->mapping['user'][ $value ];
}
if ( $key ) {
// export gets meta straight from the DB so could have a serialized string
if ( ! $value ) {
$value = maybe_unserialize( $meta_item['value'] );
}
add_post_meta( $post_id, $key, $value );
do_action( 'import_post_meta', $post_id, $key, $value );
// if the post has a featured image, take note of this in case of remap
if ( '_thumbnail_id' === $key ) {
$this->featured_images[ $post_id ] = (int) $value;
}
}
}
return true;
}
/**
* Parse a comment node into comment data.
*
* @param DOMElement $node Parent node of comment data (typically `wp:comment`).
* @return array Comment data array.
*/
protected function parse_comment_node( $node ) {
$data = array(
'commentmeta' => array(),
);
foreach ( $node->childNodes as $child ) {
// We only care about child elements
if ( $child->nodeType !== XML_ELEMENT_NODE ) {
continue;
}
switch ( $child->tagName ) {
case 'wp:comment_id':
$data['comment_id'] = $child->textContent;
break;
case 'wp:comment_author':
$data['comment_author'] = $child->textContent;
break;
case 'wp:comment_author_email':
$data['comment_author_email'] = $child->textContent;
break;
case 'wp:comment_author_IP':
$data['comment_author_IP'] = $child->textContent;
break;
case 'wp:comment_author_url':
$data['comment_author_url'] = $child->textContent;
break;
case 'wp:comment_user_id':
$data['comment_user_id'] = $child->textContent;
break;
case 'wp:comment_date':
$data['comment_date'] = $child->textContent;
break;
case 'wp:comment_date_gmt':
$data['comment_date_gmt'] = $child->textContent;
break;
case 'wp:comment_content':
$data['comment_content'] = $child->textContent;
break;
case 'wp:comment_approved':
$data['comment_approved'] = $child->textContent;
break;
case 'wp:comment_type':
$data['comment_type'] = $child->textContent;
break;
case 'wp:comment_parent':
$data['comment_parent'] = $child->textContent;
break;
case 'wp:commentmeta':
$meta_item = $this->parse_meta_node( $child );
if ( ! empty( $meta_item ) ) {
$data['commentmeta'][] = $meta_item;
}
break;
}
}
return $data;
}
/**
* Process and import comment data.
*
* @param array $comments List of comment data arrays.
* @param int $post_id Post to associate with.
* @param array $post Post data.
* @return int|WP_Error Number of comments imported on success, error otherwise.
*/
protected function process_comments( $comments, $post_id, $post, $post_exists = false ) {
$comments = apply_filters( 'wp_import_post_comments', $comments, $post_id, $post );
if ( empty( $comments ) ) {
return 0;
}
$num_comments = 0;
// Sort by ID to avoid excessive remapping later
usort( $comments, array( $this, 'sort_comments_by_id' ) );
foreach ( $comments as $key => $comment ) {
/**
* Pre-process comment data
*
* @param array $comment Comment data. (Return empty to skip.)
* @param int $post_id Post the comment is attached to.
*/
$comment = apply_filters( 'wxr_importer.pre_process.comment', $comment, $post_id );
if ( empty( $comment ) ) {
return false;
}
$original_id = isset( $comment['comment_id'] ) ? (int) $comment['comment_id'] : 0;
$parent_id = isset( $comment['comment_parent'] ) ? (int) $comment['comment_parent'] : 0;
$author_id = isset( $comment['comment_user_id'] ) ? (int) $comment['comment_user_id'] : 0;
// if this is a new post we can skip the comment_exists() check
// TODO: Check comment_exists for performance
if ( $post_exists ) {
$existing = $this->comment_exists( $comment );
if ( $existing ) {
$this->mapping['comment'][ $original_id ] = $existing;
continue;
}
}
// Remove meta from the main array
$meta = isset( $comment['commentmeta'] ) ? $comment['commentmeta'] : array();
unset( $comment['commentmeta'] );
// Map the parent comment, or mark it as one we need to fix
$requires_remapping = false;
if ( $parent_id ) {
if ( isset( $this->mapping['comment'][ $parent_id ] ) ) {
$comment['comment_parent'] = $this->mapping['comment'][ $parent_id ];
} else {
// Prepare for remapping later
$meta[] = array( 'key' => '_wxr_import_parent', 'value' => $parent_id );
$requires_remapping = true;
// Wipe the parent for now
$comment['comment_parent'] = 0;
}
}
// Map the author, or mark it as one we need to fix
if ( $author_id ) {
if ( isset( $this->mapping['user'][ $author_id ] ) ) {
$comment['user_id'] = $this->mapping['user'][ $author_id ];
} else {
// Prepare for remapping later
$meta[] = array( 'key' => '_wxr_import_user', 'value' => $author_id );
$requires_remapping = true;
// Wipe the user for now
$comment['user_id'] = 0;
}
}
// Run standard core filters
$comment['comment_post_ID'] = $post_id;
$comment = wp_filter_comment( $comment );
// wp_insert_comment expects slashed data
$comment_id = wp_insert_comment( wp_slash( $comment ) );
$this->mapping['comment'][ $original_id ] = $comment_id;
if ( $requires_remapping ) {
$this->requires_remapping['comment'][ $comment_id ] = true;
}
$this->mark_comment_exists( $comment, $comment_id );
/**
* Comment has been imported.
*
* @param int $comment_id New comment ID
* @param array $comment Comment inserted (`comment_id` item refers to the original ID)
* @param int $post_id Post parent of the comment
* @param array $post Post data
*/
do_action( 'wp_import_insert_comment', $comment_id, $comment, $post_id, $post );
// Process the meta items
foreach ( $meta as $meta_item ) {
$value = maybe_unserialize( $meta_item['value'] );
add_comment_meta( $comment_id, wp_slash( $meta_item['key'] ), wp_slash( $value ) );
}
/**
* Post processing completed.
*
* @param int $post_id New post ID.
* @param array $comment Raw data imported for the comment.
* @param array $meta Raw meta data, already processed by {@see process_post_meta}.
* @param array $post_id Parent post ID.
*/
do_action( 'wxr_importer.processed.comment', $comment_id, $comment, $meta, $post_id );
$num_comments++;
}
return $num_comments;
}
protected function parse_category_node( $node ) {
$data = array(
// Default taxonomy to "category", since this is a `` tag
'taxonomy' => 'category',
);
$meta = array();
if ( $node->hasAttribute( 'domain' ) ) {
$data['taxonomy'] = $node->getAttribute( 'domain' );
}
if ( $node->hasAttribute( 'nicename' ) ) {
$data['slug'] = $node->getAttribute( 'nicename' );
}
$data['name'] = $node->textContent;
if ( empty( $data['slug'] ) ) {
return null;
}
// Just for extra compatibility
if ( $data['taxonomy'] === 'tag' ) {
$data['taxonomy'] = 'post_tag';
}
return $data;
}
/**
* Callback for `usort` to sort comments by ID
*
* @param array $a Comment data for the first comment
* @param array $b Comment data for the second comment
* @return int
*/
public static function sort_comments_by_id( $a, $b ) {
if ( empty( $a['comment_id'] ) ) {
return 1;
}
if ( empty( $b['comment_id'] ) ) {
return -1;
}
return $a['comment_id'] - $b['comment_id'];
}
protected function parse_author_node( $node ) {
$data = array();
$meta = array();
foreach ( $node->childNodes as $child ) {
// We only care about child elements
if ( $child->nodeType !== XML_ELEMENT_NODE ) {
continue;
}
switch ( $child->tagName ) {
case 'wp:author_login':
$data['user_login'] = $child->textContent;
break;
case 'wp:author_id':
$data['ID'] = $child->textContent;
break;
case 'wp:author_email':
$data['user_email'] = $child->textContent;
break;
case 'wp:author_display_name':
$data['display_name'] = $child->textContent;
break;
case 'wp:author_first_name':
$data['first_name'] = $child->textContent;
break;
case 'wp:author_last_name':
$data['last_name'] = $child->textContent;
break;
}
}
return compact( 'data', 'meta' );
}
protected function process_author( $data, $meta ) {
/**
* Pre-process user data.
*
* @param array $data User data. (Return empty to skip.)
* @param array $meta Meta data.
*/
$data = apply_filters( 'wxr_importer.pre_process.user', $data, $meta );
if ( empty( $data ) ) {
return false;
}
// Have we already handled this user?
$original_id = isset( $data['ID'] ) ? $data['ID'] : 0;
$original_slug = $data['user_login'];
if ( isset( $this->mapping['user'][ $original_id ] ) ) {
$existing = $this->mapping['user'][ $original_id ];
// Note the slug mapping if we need to too
if ( ! isset( $this->mapping['user_slug'][ $original_slug ] ) ) {
$this->mapping['user_slug'][ $original_slug ] = $existing;
}
return false;
}
if ( isset( $this->mapping['user_slug'][ $original_slug ] ) ) {
$existing = $this->mapping['user_slug'][ $original_slug ];
// Ensure we note the mapping too
$this->mapping['user'][ $original_id ] = $existing;
return false;
}
// Allow overriding the user's slug
$login = $original_slug;
if ( isset( $this->user_slug_override[ $login ] ) ) {
$login = $this->user_slug_override[ $login ];
}
$userdata = array(
'user_login' => sanitize_user( $login, true ),
'user_pass' => wp_generate_password(),
);
$allowed = array(
'user_email' => true,
'display_name' => true,
'first_name' => true,
'last_name' => true,
);
foreach ( $data as $key => $value ) {
if ( ! isset( $allowed[ $key ] ) ) {
continue;
}
$userdata[ $key ] = $data[ $key ];
}
$user_id = wp_insert_user( wp_slash( $userdata ) );
if ( is_wp_error( $user_id ) ) {
$this->logger->error( sprintf(
__( 'Failed to import user "%s"', 'wordpress-importer' ),
$userdata['user_login']
) );
$this->logger->debug( $user_id->get_error_message() );
/**
* User processing failed.
*
* @param WP_Error $user_id Error object.
* @param array $userdata Raw data imported for the user.
*/
do_action( 'wxr_importer.process_failed.user', $user_id, $userdata );
return false;
}
if ( $original_id ) {
$this->mapping['user'][ $original_id ] = $user_id;
}
$this->mapping['user_slug'][ $original_slug ] = $user_id;
$this->logger->info( sprintf(
__( 'Imported user "%s"', 'wordpress-importer' ),
$userdata['user_login']
) );
$this->logger->debug( sprintf(
__( 'User %d remapped to %d', 'wordpress-importer' ),
$original_id,
$user_id
) );
// TODO: Implement meta handling once WXR includes it
/**
* User processing completed.
*
* @param int $user_id New user ID.
* @param array $userdata Raw data imported for the user.
*/
do_action( 'wxr_importer.processed.user', $user_id, $userdata );
}
protected function parse_term_node( $node, $type = 'term' ) {
$data = array();
$meta = array();
$tag_name = array(
'id' => 'wp:term_id',
'taxonomy' => 'wp:term_taxonomy',
'slug' => 'wp:term_slug',
'parent' => 'wp:term_parent',
'name' => 'wp:term_name',
'description' => 'wp:term_description',
);
$taxonomy = null;
// Special casing!
switch ( $type ) {
case 'category':
$tag_name['slug'] = 'wp:category_nicename';
$tag_name['parent'] = 'wp:category_parent';
$tag_name['name'] = 'wp:cat_name';
$tag_name['description'] = 'wp:category_description';
$tag_name['taxonomy'] = null;
$data['taxonomy'] = 'category';
break;
case 'tag':
$tag_name['slug'] = 'wp:tag_slug';
$tag_name['parent'] = null;
$tag_name['name'] = 'wp:tag_name';
$tag_name['description'] = 'wp:tag_description';
$tag_name['taxonomy'] = null;
$data['taxonomy'] = 'post_tag';
break;
}
foreach ( $node->childNodes as $child ) {
// We only care about child elements
if ( $child->nodeType !== XML_ELEMENT_NODE ) {
continue;
}
$key = array_search( $child->tagName, $tag_name );
if ( $key ) {
$data[ $key ] = $child->textContent;
} else if ( $child->tagName == 'wp:termmeta' ) {
$meta_item = $this->parse_meta_node( $child );
if ( ! empty( $meta_item ) ) {
$meta[] = $meta_item;
}
}
}
if ( empty( $data['taxonomy'] ) ) {
return null;
}
// Compatibility with WXR 1.0
if ( $data['taxonomy'] === 'tag' ) {
$data['taxonomy'] = 'post_tag';
}
return compact( 'data', 'meta' );
}
protected function process_term( $data, $meta ) {
/**
* Pre-process term data.
*
* @param array $data Term data. (Return empty to skip.)
* @param array $meta Meta data.
*/
$data = apply_filters( 'wxr_importer.pre_process.term', $data, $meta );
if ( empty( $data ) ) {
return false;
}
$original_id = isset( $data['id'] ) ? (int) $data['id'] : 0;
/* FIX for OCDI!
* As of WP 4.5, export.php returns the SLUG for the term's parent,
* rather than an integer ID (this differs from a post_parent)
* wp_insert_term and wp_update_term use the key: 'parent' and an integer value 'id'
*/
$term_slug = isset( $data['slug'] ) ? $data['slug'] : '';
$parent_slug = isset( $data['parent'] ) ? $data['parent'] : '';
$mapping_key = sha1( $data['taxonomy'] . ':' . $data['slug'] );
$existing = $this->term_exists( $data );
if ( $existing ) {
$this->mapping['term'][ $mapping_key ] = $existing;
$this->mapping['term_id'][ $original_id ] = $existing;
$this->mapping['term_slug'][ $term_slug ] = $existing;
return false;
}
// WP really likes to repeat itself in export files
if ( isset( $this->mapping['term'][ $mapping_key ] ) ) {
return false;
}
$termdata = array();
$allowed = array(
'slug' => true,
'description' => true,
'parent' => true, // The parent_id may have already been set, so pass this back to the newly inserted term.
);
// Map the parent comment, or mark it as one we need to fix
$requires_remapping = false;
if ( $parent_slug ) {
if ( isset( $this->mapping['term_slug'][ $parent_slug ] ) ) {
$data['parent'] = $this->mapping['term_slug'][ $parent_slug ];
} else {
// Prepare for remapping later
$meta[] = array( 'key' => '_wxr_import_parent', 'value' => $parent_slug );
$requires_remapping = true;
// Wipe the parent id for now
$data['parent'] = 0;
}
}
foreach ( $data as $key => $value ) {
if ( ! isset( $allowed[ $key ] ) ) {
continue;
}
$termdata[ $key ] = $data[ $key ];
}
$result = wp_insert_term( $data['name'], $data['taxonomy'], $termdata );
if ( is_wp_error( $result ) ) {
$this->logger->warning( sprintf(
__( 'Failed to import %s %s', 'wordpress-importer' ),
$data['taxonomy'],
$data['name']
) );
$this->logger->debug( $result->get_error_message() );
do_action( 'wp_import_insert_term_failed', $result, $data );
/**
* Term processing failed.
*
* @param WP_Error $result Error object.
* @param array $data Raw data imported for the term.
* @param array $meta Meta data supplied for the term.
*/
do_action( 'wxr_importer.process_failed.term', $result, $data, $meta );
return false;
}
$term_id = $result['term_id'];
// Now prepare to map this new term.
$this->mapping['term'][ $mapping_key ] = $term_id;
$this->mapping['term_id'][ $original_id ] = $term_id;
$this->mapping['term_slug'][ $term_slug ] = $term_id;
/*
* Fix for OCDI!
* The parent will be updated later in post_process_terms
* we will need both the term_id AND the term_taxonomy to retrieve existing
* term attributes. Those attributes will be returned with the corrected parent,
* using wp_update_term.
* Pass both the term_id along with the term_taxonomy as key=>value
* in the requires_remapping['term'] array.
*/
if ( $requires_remapping ) {
$this->requires_remapping['term'][ $term_id ] = $data['taxonomy'];
}
$this->logger->info( sprintf(
__( 'Imported "%s" (%s)', 'wordpress-importer' ),
$data['name'],
$data['taxonomy']
) );
$this->logger->debug( sprintf(
__( 'Term %d remapped to %d', 'wordpress-importer' ),
$original_id,
$term_id
) );
// Actuall process of the term meta data.
$this->process_term_meta( $meta, $term_id, $data );
do_action( 'wp_import_insert_term', $term_id, $data );
/**
* Term processing completed.
*
* @param int $term_id New term ID.
* @param array $data Raw data imported for the term.
*/
do_action( 'wxr_importer.processed.term', $term_id, $data );
}
/**
* Process and import term meta items.
*
* @param array $meta List of meta data arrays
* @param int $term_id Term ID to associate with
* @param array $term Term data
* @return int|bool Number of meta items imported on success, false otherwise.
*/
protected function process_term_meta( $meta, $term_id, $term ) {
if ( empty( $meta ) ) {
return true;
}
foreach ( $meta as $meta_item ) {
/**
* Pre-process term meta data.
*
* @param array $meta_item Meta data. (Return empty to skip.)
* @param int $term_id Term the meta is attached to.
*/
$meta_item = apply_filters( 'wxr_importer.pre_process.term_meta', $meta_item, $term_id );
if ( empty( $meta_item ) ) {
continue;
}
$key = apply_filters( 'import_term_meta_key', $meta_item['key'], $term_id, $term );
$value = false;
if ( $key ) {
// Export gets meta straight from the DB so could have a serialized string.
if ( ! $value ) {
$value = maybe_unserialize( $meta_item['value'] );
}
$result = add_term_meta( $term_id, $key, $value );
if ( is_wp_error( $result ) ) {
$this->logger->warning( sprintf(
__( 'Failed to add metakey: %s, metavalue: %s to term_id: %d', 'wordpress-importer' ),
$key,
$value,
$term_id
) );
do_action( 'wxr_importer.process_failed.termmeta', $result, $meta_item, $term_id, $term );
}
else {
$this->logger->debug( sprintf(
__( 'Meta for term_id %d : %s => %s ; successfully added!', 'wordpress-importer' ),
$term_id,
$key,
$value
) );
}
do_action( 'import_term_meta', $term_id, $key, $value );
}
}
return true;
}
/**
* Attempt to download a remote file attachment
*
* @param string $url URL of item to fetch
* @param array $post Attachment details
* @return array|WP_Error Local file location details on success, WP_Error otherwise
*/
protected function fetch_remote_file( $url, $post ) {
// extract the file name and extension from the url
$file_name = basename( $url );
// get placeholder file in the upload dir with a unique, sanitized filename
$upload = wp_upload_bits( $file_name, 0, '', $post['upload_date'] );
if ( $upload['error'] ) {
return new \WP_Error( 'upload_dir_error', $upload['error'] );
}
// fetch the remote url and write it to the placeholder file
$response = wp_remote_get( $url, array(
'stream' => true,
'filename' => $upload['file'],
) );
// request failed
if ( is_wp_error( $response ) ) {
unlink( $upload['file'] );
return $response;
}
$code = (int) wp_remote_retrieve_response_code( $response );
// make sure the fetch was successful
if ( $code !== 200 ) {
unlink( $upload['file'] );
return new \WP_Error(
'import_file_error',
sprintf(
__( 'Remote server returned %1$d %2$s for %3$s', 'wordpress-importer' ),
$code,
get_status_header_desc( $code ),
$url
)
);
}
$filesize = filesize( $upload['file'] );
$headers = wp_remote_retrieve_headers( $response );
// OCDI fix!
// Smaller images with server compression do not pass this rule.
// More info here: https://github.com/proteusthemes/WordPress-Importer/pull/2
//
// if ( isset( $headers['content-length'] ) && $filesize !== (int) $headers['content-length'] ) {
// unlink( $upload['file'] );
// return new \WP_Error( 'import_file_error', __( 'Remote file is incorrect size', 'wordpress-importer' ) );
// }
if ( 0 === $filesize ) {
unlink( $upload['file'] );
return new \WP_Error( 'import_file_error', __( 'Zero size file downloaded', 'wordpress-importer' ) );
}
$max_size = (int) $this->max_attachment_size();
if ( ! empty( $max_size ) && $filesize > $max_size ) {
unlink( $upload['file'] );
$message = sprintf( __( 'Remote file is too large, limit is %s', 'wordpress-importer' ), size_format( $max_size ) );
return new \WP_Error( 'import_file_error', $message );
}
return $upload;
}
protected function post_process() {
// Time to tackle any left-over bits
if ( ! empty( $this->requires_remapping['post'] ) ) {
$this->post_process_posts( $this->requires_remapping['post'] );
}
if ( ! empty( $this->requires_remapping['comment'] ) ) {
$this->post_process_comments( $this->requires_remapping['comment'] );
}
if ( ! empty( $this->requires_remapping['term'] ) ) {
$this->post_process_terms( $this->requires_remapping['term'] );
}
}
protected function post_process_posts( $todo ) {
foreach ( $todo as $post_id => $_ ) {
$this->logger->debug( sprintf(
// Note: title intentionally not used to skip extra processing
// for when debug logging is off
__( 'Running post-processing for post %d', 'wordpress-importer' ),
$post_id
) );
$data = array();
$parent_id = get_post_meta( $post_id, '_wxr_import_parent', true );
if ( ! empty( $parent_id ) ) {
// Have we imported the parent now?
if ( isset( $this->mapping['post'][ $parent_id ] ) ) {
$data['post_parent'] = $this->mapping['post'][ $parent_id ];
} else {
$this->logger->warning( sprintf(
__( 'Could not find the post parent for "%s" (post #%d)', 'wordpress-importer' ),
get_the_title( $post_id ),
$post_id
) );
$this->logger->debug( sprintf(
__( 'Post %d was imported with parent %d, but could not be found', 'wordpress-importer' ),
$post_id,
$parent_id
) );
}
}
$author_slug = get_post_meta( $post_id, '_wxr_import_user_slug', true );
if ( ! empty( $author_slug ) ) {
// Have we imported the user now?
if ( isset( $this->mapping['user_slug'][ $author_slug ] ) ) {
$data['post_author'] = $this->mapping['user_slug'][ $author_slug ];
} else {
$this->logger->warning( sprintf(
__( 'Could not find the author for "%s" (post #%d)', 'wordpress-importer' ),
get_the_title( $post_id ),
$post_id
) );
$this->logger->debug( sprintf(
__( 'Post %d was imported with author "%s", but could not be found', 'wordpress-importer' ),
$post_id,
$author_slug
) );
}
}
$has_attachments = get_post_meta( $post_id, '_wxr_import_has_attachment_refs', true );
if ( ! empty( $has_attachments ) ) {
$post = get_post( $post_id );
$content = $post->post_content;
// Replace all the URLs we've got
$new_content = str_replace( array_keys( $this->url_remap ), $this->url_remap, $content );
if ( $new_content !== $content ) {
$data['post_content'] = $new_content;
}
}
if ( get_post_type( $post_id ) === 'nav_menu_item' ) {
$this->post_process_menu_item( $post_id );
}
// Do we have updates to make?
if ( empty( $data ) ) {
$this->logger->debug( sprintf(
__( 'Post %d was marked for post-processing, but none was required.', 'wordpress-importer' ),
$post_id
) );
continue;
}
// Run the update
$data['ID'] = $post_id;
$result = wp_update_post( $data, true );
if ( is_wp_error( $result ) ) {
$this->logger->warning( sprintf(
__( 'Could not update "%s" (post #%d) with mapped data', 'wordpress-importer' ),
get_the_title( $post_id ),
$post_id
) );
$this->logger->debug( $result->get_error_message() );
continue;
}
// Clear out our temporary meta keys
delete_post_meta( $post_id, '_wxr_import_parent' );
delete_post_meta( $post_id, '_wxr_import_user_slug' );
delete_post_meta( $post_id, '_wxr_import_has_attachment_refs' );
}
}
protected function post_process_menu_item( $post_id ) {
$menu_object_id = get_post_meta( $post_id, '_wxr_import_menu_item', true );
if ( empty( $menu_object_id ) ) {
// No processing needed!
return;
}
$menu_item_type = get_post_meta( $post_id, '_menu_item_type', true );
switch ( $menu_item_type ) {
case 'taxonomy':
if ( isset( $this->mapping['term_id'][ $menu_object_id ] ) ) {
$menu_object = $this->mapping['term_id'][ $menu_object_id ];
}
break;
case 'post_type':
if ( isset( $this->mapping['post'][ $menu_object_id ] ) ) {
$menu_object = $this->mapping['post'][ $menu_object_id ];
}
break;
default:
// Cannot handle this.
return;
}
if ( ! empty( $menu_object ) ) {
update_post_meta( $post_id, '_menu_item_object_id', wp_slash( $menu_object ) );
} else {
$this->logger->warning( sprintf(
__( 'Could not find the menu object for "%s" (post #%d)', 'wordpress-importer' ),
get_the_title( $post_id ),
$post_id
) );
$this->logger->debug( sprintf(
__( 'Post %d was imported with object "%d" of type "%s", but could not be found', 'wordpress-importer' ),
$post_id,
$menu_object_id,
$menu_item_type
) );
}
delete_post_meta( $post_id, '_wxr_import_menu_item' );
}
protected function post_process_comments( $todo ) {
foreach ( $todo as $comment_id => $_ ) {
$data = array();
$parent_id = get_comment_meta( $comment_id, '_wxr_import_parent', true );
if ( ! empty( $parent_id ) ) {
// Have we imported the parent now?
if ( isset( $this->mapping['comment'][ $parent_id ] ) ) {
$data['comment_parent'] = $this->mapping['comment'][ $parent_id ];
} else {
$this->logger->warning( sprintf(
__( 'Could not find the comment parent for comment #%d', 'wordpress-importer' ),
$comment_id
) );
$this->logger->debug( sprintf(
__( 'Comment %d was imported with parent %d, but could not be found', 'wordpress-importer' ),
$comment_id,
$parent_id
) );
}
}
$author_id = get_comment_meta( $comment_id, '_wxr_import_user', true );
if ( ! empty( $author_id ) ) {
// Have we imported the user now?
if ( isset( $this->mapping['user'][ $author_id ] ) ) {
$data['user_id'] = $this->mapping['user'][ $author_id ];
} else {
$this->logger->warning( sprintf(
__( 'Could not find the author for comment #%d', 'wordpress-importer' ),
$comment_id
) );
$this->logger->debug( sprintf(
__( 'Comment %d was imported with author %d, but could not be found', 'wordpress-importer' ),
$comment_id,
$author_id
) );
}
}
// Do we have updates to make?
if ( empty( $data ) ) {
continue;
}
// Run the update
$data['comment_ID'] = $comment_ID;
$result = wp_update_comment( wp_slash( $data ) );
if ( empty( $result ) ) {
$this->logger->warning( sprintf(
__( 'Could not update comment #%d with mapped data', 'wordpress-importer' ),
$comment_id
) );
continue;
}
// Clear out our temporary meta keys
delete_comment_meta( $comment_id, '_wxr_import_parent' );
delete_comment_meta( $comment_id, '_wxr_import_user' );
}
}
/**
* There is no explicit 'top' or 'root' for a hierarchy of WordPress terms
* Terms without a parent, or parent=0 are either unconnected (orphans)
* or top-level siblings without an explicit root parent
* An unconnected term (orphan) should have a null parent_slug
* Top-level siblings without an explicit root parent, shall be identified
* with the parent_slug: top
* [we'll map parent_slug: top into parent 0]
*/
protected function post_process_terms( $terms_to_be_remapped ) {
$this->mapping['term_slug']['top'] = 0;
// The term_id and term_taxonomy are passed-in with $this->requires_remapping['term'].
foreach ( $terms_to_be_remapped as $termid => $term_taxonomy ) {
// Basic check.
if( empty( $termid ) || ! is_numeric( $termid ) ) {
$this->logger->warning( sprintf(
__( 'Faulty term_id provided in terms-to-be-remapped array %s', 'wordpress-importer' ),
$termid
) );
continue;
}
// This cast to integer may be unnecessary.
$term_id = (int) $termid;
if( empty( $term_taxonomy ) ){
$this->logger->warning( sprintf(
__( 'No taxonomy provided in terms-to-be-remapped array for term #%d', 'wordpress-importer' ),
$term_id
) );
continue;
}
$data = array();
$parent_slug = get_term_meta( $term_id, '_wxr_import_parent', true );
if ( empty( $parent_slug ) ) {
$this->logger->warning( sprintf(
__( 'No parent_slug identified in remapping-array for term: %d', 'wordpress-importer' ),
$term_id
) );
continue;
}
if ( ! isset( $this->mapping['term_slug'][ $parent_slug ] ) || ! is_numeric( $this->mapping['term_slug'][ $parent_slug ] ) ) {
$this->logger->warning( sprintf(
__( 'The term(%d)"s parent_slug (%s) is not found in the remapping-array.', 'wordpress-importer' ),
$term_id,
$parent_slug
) );
continue;
}
$mapped_parent = (int) $this->mapping['term_slug'][ $parent_slug ];
$termattributes = get_term_by( 'id', $term_id, $term_taxonomy, ARRAY_A );
// Note: the default OBJECT return results in a reserved-word clash with 'parent' [$termattributes->parent], so instead return an associative array.
if ( empty( $termattributes ) ) {
$this->logger->warning( sprintf(
__( 'No data returned by get_term_by for term_id #%d', 'wordpress-importer' ),
$term_id
) );
continue;
}
// Check if the correct parent id is already correctly mapped.
if ( isset( $termattributes['parent'] ) && $termattributes['parent'] == $mapped_parent ) {
// Clear out our temporary meta key.
delete_term_meta( $term_id, '_wxr_import_parent' );
continue;
}
// Otherwise set the mapped parent and update the term.
$termattributes['parent'] = $mapped_parent;
$result = wp_update_term( $term_id, $termattributes['taxonomy'], $termattributes );
if ( is_wp_error( $result ) ) {
$this->logger->warning( sprintf(
__( 'Could not update "%s" (term #%d) with mapped data', 'wordpress-importer' ),
$termattributes['name'],
$term_id
) );
$this->logger->debug( $result->get_error_message() );
continue;
}
// Clear out our temporary meta key.
delete_term_meta( $term_id, '_wxr_import_parent' );
$this->logger->debug( sprintf(
__( 'Term %d was successfully updated with parent %d', 'wordpress-importer' ),
$term_id,
$mapped_parent
) );
}
}
/**
* Use stored mapping information to update old attachment URLs
*/
protected function replace_attachment_urls_in_content() {
global $wpdb;
// make sure we do the longest urls first, in case one is a substring of another
uksort( $this->url_remap, array( $this, 'cmpr_strlen' ) );
foreach ( $this->url_remap as $from_url => $to_url ) {
// remap urls in post_content
$query = $wpdb->prepare( "UPDATE {$wpdb->posts} SET post_content = REPLACE(post_content, %s, %s)", $from_url, $to_url );
$wpdb->query( $query );
// remap enclosure urls
$query = $wpdb->prepare( "UPDATE {$wpdb->postmeta} SET meta_value = REPLACE(meta_value, %s, %s) WHERE meta_key='enclosure'", $from_url, $to_url );
$result = $wpdb->query( $query );
}
}
/**
* Update _thumbnail_id meta to new, imported attachment IDs
*/
function remap_featured_images() {
if ( empty( $this->featured_images ) ) {
return;
}
$this->logger->info( esc_html__( 'Starting remapping of featured images', 'wordpress-importer' ) );
// Cycle through posts that have a featured image.
foreach ( $this->featured_images as $post_id => $value ) {
if ( isset( $this->mapping['post'][ $value ] ) ) {
$new_id = $this->mapping['post'][ $value ];
// Only update if there's a difference.
if ( $new_id !== $value ) {
$this->logger->info( sprintf( esc_html__( 'Remapping featured image ID %d to new ID %d for post ID %d', 'wordpress-importer' ), $value, $new_id, $post_id ) );
update_post_meta( $post_id, '_thumbnail_id', $new_id );
}
}
}
}
/**
* Decide if the given meta key maps to information we will want to import
*
* @param string $key The meta key to check
* @return string|bool The key if we do want to import, false if not
*/
public function is_valid_meta_key( $key ) {
// skip attachment metadata since we'll regenerate it from scratch
// skip _edit_lock as not relevant for import
if ( in_array( $key, array( '_wp_attached_file', '_wp_attachment_metadata', '_edit_lock' ) ) ) {
return false;
}
return $key;
}
/**
* Decide what the maximum file size for downloaded attachments is.
* Default is 0 (unlimited), can be filtered via import_attachment_size_limit
*
* @return int Maximum attachment file size to import
*/
protected function max_attachment_size() {
return apply_filters( 'import_attachment_size_limit', 0 );
}
/**
* Added to http_request_timeout filter to force timeout at 60 seconds during import
*
* @access protected
* @return int 60
*/
function bump_request_timeout($val) {
return 60;
}
// return the difference in length between two strings
function cmpr_strlen( $a, $b ) {
return strlen( $b ) - strlen( $a );
}
/**
* Prefill existing post data.
*
* This preloads all GUIDs into memory, allowing us to avoid hitting the
* database when we need to check for existence. With larger imports, this
* becomes prohibitively slow to perform SELECT queries on each.
*
* By preloading all this data into memory, it's a constant-time lookup in
* PHP instead. However, this does use a lot more memory, so for sites doing
* small imports onto a large site, it may be a better tradeoff to use
* on-the-fly checking instead.
*/
protected function prefill_existing_posts() {
global $wpdb;
$posts = $wpdb->get_results( "SELECT ID, guid FROM {$wpdb->posts}" );
foreach ( $posts as $item ) {
$this->exists['post'][ $item->guid ] = $item->ID;
}
}
/**
* Does the post exist?
*
* @param array $data Post data to check against.
* @return int|bool Existing post ID if it exists, false otherwise.
*/
protected function post_exists( $data ) {
// Constant-time lookup if we prefilled
$exists_key = $data['guid'];
if ( $this->options['prefill_existing_posts'] ) {
// OCDI: fix for custom post types. The guids in the prefilled section are escaped, so these ones should be as well.
$exists_key = htmlentities( $exists_key );
return isset( $this->exists['post'][ $exists_key ] ) ? $this->exists['post'][ $exists_key ] : false;
}
// No prefilling, but might have already handled it
if ( isset( $this->exists['post'][ $exists_key ] ) ) {
return $this->exists['post'][ $exists_key ];
}
// Still nothing, try post_exists, and cache it
$exists = post_exists( $data['post_title'], $data['post_content'], $data['post_date'] );
$this->exists['post'][ $exists_key ] = $exists;
return $exists;
}
/**
* Mark the post as existing.
*
* @param array $data Post data to mark as existing.
* @param int $post_id Post ID.
*/
protected function mark_post_exists( $data, $post_id ) {
$exists_key = $data['guid'];
$this->exists['post'][ $exists_key ] = $post_id;
}
/**
* Prefill existing comment data.
*
* @see self::prefill_existing_posts() for justification of why this exists.
*/
protected function prefill_existing_comments() {
global $wpdb;
$posts = $wpdb->get_results( "SELECT comment_ID, comment_author, comment_date FROM {$wpdb->comments}" );
foreach ( $posts as $item ) {
$exists_key = sha1( $item->comment_author . ':' . $item->comment_date );
$this->exists['comment'][ $exists_key ] = $item->comment_ID;
}
}
/**
* Does the comment exist?
*
* @param array $data Comment data to check against.
* @return int|bool Existing comment ID if it exists, false otherwise.
*/
protected function comment_exists( $data ) {
$exists_key = sha1( $data['comment_author'] . ':' . $data['comment_date'] );
// Constant-time lookup if we prefilled
if ( $this->options['prefill_existing_comments'] ) {
return isset( $this->exists['comment'][ $exists_key ] ) ? $this->exists['comment'][ $exists_key ] : false;
}
// No prefilling, but might have already handled it
if ( isset( $this->exists['comment'][ $exists_key ] ) ) {
return $this->exists['comment'][ $exists_key ];
}
// Still nothing, try comment_exists, and cache it
$exists = comment_exists( $data['comment_author'], $data['comment_date'] );
$this->exists['comment'][ $exists_key ] = $exists;
return $exists;
}
/**
* Mark the comment as existing.
*
* @param array $data Comment data to mark as existing.
* @param int $comment_id Comment ID.
*/
protected function mark_comment_exists( $data, $comment_id ) {
$exists_key = sha1( $data['comment_author'] . ':' . $data['comment_date'] );
$this->exists['comment'][ $exists_key ] = $comment_id;
}
/**
* Prefill existing term data.
*
* @see self::prefill_existing_posts() for justification of why this exists.
*/
protected function prefill_existing_terms() {
global $wpdb;
$query = "SELECT t.term_id, tt.taxonomy, t.slug FROM {$wpdb->terms} AS t";
$query .= " JOIN {$wpdb->term_taxonomy} AS tt ON t.term_id = tt.term_id";
$terms = $wpdb->get_results( $query );
foreach ( $terms as $item ) {
$exists_key = sha1( $item->taxonomy . ':' . $item->slug );
$this->exists['term'][ $exists_key ] = $item->term_id;
}
}
/**
* Does the term exist?
*
* @param array $data Term data to check against.
* @return int|bool Existing term ID if it exists, false otherwise.
*/
protected function term_exists( $data ) {
$exists_key = sha1( $data['taxonomy'] . ':' . $data['slug'] );
// Constant-time lookup if we prefilled
if ( $this->options['prefill_existing_terms'] ) {
return isset( $this->exists['term'][ $exists_key ] ) ? $this->exists['term'][ $exists_key ] : false;
}
// No prefilling, but might have already handled it
if ( isset( $this->exists['term'][ $exists_key ] ) ) {
return $this->exists['term'][ $exists_key ];
}
// Still nothing, try comment_exists, and cache it
$exists = term_exists( $data['slug'], $data['taxonomy'] );
if ( is_array( $exists ) ) {
$exists = $exists['term_id'];
}
$this->exists['term'][ $exists_key ] = $exists;
return $exists;
}
/**
* Mark the term as existing.
*
* @param array $data Term data to mark as existing.
* @param int $term_id Term ID.
*/
protected function mark_term_exists( $data, $term_id ) {
$exists_key = sha1( $data['taxonomy'] . ':' . $data['slug'] );
$this->exists['term'][ $exists_key ] = $term_id;
}
}
vendor/proteusthemes/wp-content-importer-v2/src/WPImporterLoggerCLI.php 0000666 00000001546 15213303300 0022272 0 ustar 00 level_to_numeric( $level ) < $this->level_to_numeric( $this->min_level ) ) {
return;
}
printf(
'[%s] %s' . PHP_EOL,
strtoupper( $level ),
$message
);
}
public static function level_to_numeric( $level ) {
$levels = array(
'emergency' => 8,
'alert' => 7,
'critical' => 6,
'error' => 5,
'warning' => 4,
'notice' => 3,
'info' => 2,
'debug' => 1,
);
if ( ! isset( $levels[ $level ] ) ) {
return 0;
}
return $levels[ $level ];
}
}
vendor/proteusthemes/wp-content-importer-v2/README.md 0000666 00000001322 15213303300 0016501 0 ustar 00 # WP content importer used in OCDI
List of files used in OCDI plugin (from the original repo):
- class-logger-cli.php,
- class-logger.php,
- class-wxr-importer.php
One click demo import plugin page: https://wordpress.org/plugins/one-click-demo-import/
One click demo import github page: https://github.com/proteusthemes/one-click-demo-import
## Changelog
*October 29th 2016*
- Cleaned up this forked repo, to only include the thing we need in the OCDI plugin.
- Changed the class names and use psr-4 autoloading in composer.json
*October 26th 2016*
- made a fork form the original repo
- merged a pull request for "term meta data" from the original repo: https://github.com/humanmade/WordPress-Importer/pull/18
vendor/proteusthemes/wp-content-importer-v2/composer.json 0000666 00000000756 15213303300 0017756 0 ustar 00 {
"name": "proteusthemes/wp-content-importer-v2",
"description": "WP content importer v2 forked from humanmade/wordpress-importer.",
"keywords": ["wp", "wordpress", "proteusthemes", "theme", "import", "content"],
"license": "GPL-2.0+",
"authors": [
{
"name" : "Contributors",
"homepage" : "https://github.com/humanmade/WordPress-Importer/graphs/contributors"
}
],
"autoload": {
"psr-4": {
"ProteusThemes\\WPContentImporter2\\": "src/"
}
}
} vendor/composer/autoload_namespaces.php 0000666 00000000225 15213303300 0014401 0 ustar 00
array (
'ProteusThemes\\WPContentImporter2\\' => 33,
),
'O' =>
array (
'OCDI\\' => 5,
),
);
public static $prefixDirsPsr4 = array (
'ProteusThemes\\WPContentImporter2\\' =>
array (
0 => __DIR__ . '/..' . '/proteusthemes/wp-content-importer-v2/src',
),
'OCDI\\' =>
array (
0 => __DIR__ . '/../..' . '/inc',
),
);
public static function getInitializer(ClassLoader $loader)
{
return \Closure::bind(function () use ($loader) {
$loader->prefixLengthsPsr4 = ComposerStaticInit06f9575de8b884f593be69967ce35df0::$prefixLengthsPsr4;
$loader->prefixDirsPsr4 = ComposerStaticInit06f9575de8b884f593be69967ce35df0::$prefixDirsPsr4;
}, null, ClassLoader::class);
}
}
vendor/composer/autoload_classmap.php 0000666 00000000223 15213303300 0014063 0 ustar 00 = 50600 && !defined('HHVM_VERSION') && (!function_exists('zend_loader_file_encoded') || !zend_loader_file_encoded());
if ($useStaticLoader) {
require_once __DIR__ . '/autoload_static.php';
call_user_func(\Composer\Autoload\ComposerStaticInit06f9575de8b884f593be69967ce35df0::getInitializer($loader));
} else {
$map = require __DIR__ . '/autoload_namespaces.php';
foreach ($map as $namespace => $path) {
$loader->set($namespace, $path);
}
$map = require __DIR__ . '/autoload_psr4.php';
foreach ($map as $namespace => $path) {
$loader->setPsr4($namespace, $path);
}
$classMap = require __DIR__ . '/autoload_classmap.php';
if ($classMap) {
$loader->addClassMap($classMap);
}
}
$loader->register(true);
return $loader;
}
}
vendor/composer/ClassLoader.php 0000666 00000032213 15213303300 0012570 0 ustar 00
* Jordi Boggiano
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace Composer\Autoload;
/**
* ClassLoader implements a PSR-0, PSR-4 and classmap class loader.
*
* $loader = new \Composer\Autoload\ClassLoader();
*
* // register classes with namespaces
* $loader->add('Symfony\Component', __DIR__.'/component');
* $loader->add('Symfony', __DIR__.'/framework');
*
* // activate the autoloader
* $loader->register();
*
* // to enable searching the include path (eg. for PEAR packages)
* $loader->setUseIncludePath(true);
*
* In this example, if you try to use a class in the Symfony\Component
* namespace or one of its children (Symfony\Component\Console for instance),
* the autoloader will first look for the class under the component/
* directory, and it will then fallback to the framework/ directory if not
* found before giving up.
*
* This class is loosely based on the Symfony UniversalClassLoader.
*
* @author Fabien Potencier
* @author Jordi Boggiano
* @see http://www.php-fig.org/psr/psr-0/
* @see http://www.php-fig.org/psr/psr-4/
*/
class ClassLoader
{
// PSR-4
private $prefixLengthsPsr4 = array();
private $prefixDirsPsr4 = array();
private $fallbackDirsPsr4 = array();
// PSR-0
private $prefixesPsr0 = array();
private $fallbackDirsPsr0 = array();
private $useIncludePath = false;
private $classMap = array();
private $classMapAuthoritative = false;
private $missingClasses = array();
private $apcuPrefix;
public function getPrefixes()
{
if (!empty($this->prefixesPsr0)) {
return call_user_func_array('array_merge', $this->prefixesPsr0);
}
return array();
}
public function getPrefixesPsr4()
{
return $this->prefixDirsPsr4;
}
public function getFallbackDirs()
{
return $this->fallbackDirsPsr0;
}
public function getFallbackDirsPsr4()
{
return $this->fallbackDirsPsr4;
}
public function getClassMap()
{
return $this->classMap;
}
/**
* @param array $classMap Class to filename map
*/
public function addClassMap(array $classMap)
{
if ($this->classMap) {
$this->classMap = array_merge($this->classMap, $classMap);
} else {
$this->classMap = $classMap;
}
}
/**
* Registers a set of PSR-0 directories for a given prefix, either
* appending or prepending to the ones previously set for this prefix.
*
* @param string $prefix The prefix
* @param array|string $paths The PSR-0 root directories
* @param bool $prepend Whether to prepend the directories
*/
public function add($prefix, $paths, $prepend = false)
{
if (!$prefix) {
if ($prepend) {
$this->fallbackDirsPsr0 = array_merge(
(array) $paths,
$this->fallbackDirsPsr0
);
} else {
$this->fallbackDirsPsr0 = array_merge(
$this->fallbackDirsPsr0,
(array) $paths
);
}
return;
}
$first = $prefix[0];
if (!isset($this->prefixesPsr0[$first][$prefix])) {
$this->prefixesPsr0[$first][$prefix] = (array) $paths;
return;
}
if ($prepend) {
$this->prefixesPsr0[$first][$prefix] = array_merge(
(array) $paths,
$this->prefixesPsr0[$first][$prefix]
);
} else {
$this->prefixesPsr0[$first][$prefix] = array_merge(
$this->prefixesPsr0[$first][$prefix],
(array) $paths
);
}
}
/**
* Registers a set of PSR-4 directories for a given namespace, either
* appending or prepending to the ones previously set for this namespace.
*
* @param string $prefix The prefix/namespace, with trailing '\\'
* @param array|string $paths The PSR-4 base directories
* @param bool $prepend Whether to prepend the directories
*
* @throws \InvalidArgumentException
*/
public function addPsr4($prefix, $paths, $prepend = false)
{
if (!$prefix) {
// Register directories for the root namespace.
if ($prepend) {
$this->fallbackDirsPsr4 = array_merge(
(array) $paths,
$this->fallbackDirsPsr4
);
} else {
$this->fallbackDirsPsr4 = array_merge(
$this->fallbackDirsPsr4,
(array) $paths
);
}
} elseif (!isset($this->prefixDirsPsr4[$prefix])) {
// Register directories for a new namespace.
$length = strlen($prefix);
if ('\\' !== $prefix[$length - 1]) {
throw new \InvalidArgumentException("A non-empty PSR-4 prefix must end with a namespace separator.");
}
$this->prefixLengthsPsr4[$prefix[0]][$prefix] = $length;
$this->prefixDirsPsr4[$prefix] = (array) $paths;
} elseif ($prepend) {
// Prepend directories for an already registered namespace.
$this->prefixDirsPsr4[$prefix] = array_merge(
(array) $paths,
$this->prefixDirsPsr4[$prefix]
);
} else {
// Append directories for an already registered namespace.
$this->prefixDirsPsr4[$prefix] = array_merge(
$this->prefixDirsPsr4[$prefix],
(array) $paths
);
}
}
/**
* Registers a set of PSR-0 directories for a given prefix,
* replacing any others previously set for this prefix.
*
* @param string $prefix The prefix
* @param array|string $paths The PSR-0 base directories
*/
public function set($prefix, $paths)
{
if (!$prefix) {
$this->fallbackDirsPsr0 = (array) $paths;
} else {
$this->prefixesPsr0[$prefix[0]][$prefix] = (array) $paths;
}
}
/**
* Registers a set of PSR-4 directories for a given namespace,
* replacing any others previously set for this namespace.
*
* @param string $prefix The prefix/namespace, with trailing '\\'
* @param array|string $paths The PSR-4 base directories
*
* @throws \InvalidArgumentException
*/
public function setPsr4($prefix, $paths)
{
if (!$prefix) {
$this->fallbackDirsPsr4 = (array) $paths;
} else {
$length = strlen($prefix);
if ('\\' !== $prefix[$length - 1]) {
throw new \InvalidArgumentException("A non-empty PSR-4 prefix must end with a namespace separator.");
}
$this->prefixLengthsPsr4[$prefix[0]][$prefix] = $length;
$this->prefixDirsPsr4[$prefix] = (array) $paths;
}
}
/**
* Turns on searching the include path for class files.
*
* @param bool $useIncludePath
*/
public function setUseIncludePath($useIncludePath)
{
$this->useIncludePath = $useIncludePath;
}
/**
* Can be used to check if the autoloader uses the include path to check
* for classes.
*
* @return bool
*/
public function getUseIncludePath()
{
return $this->useIncludePath;
}
/**
* Turns off searching the prefix and fallback directories for classes
* that have not been registered with the class map.
*
* @param bool $classMapAuthoritative
*/
public function setClassMapAuthoritative($classMapAuthoritative)
{
$this->classMapAuthoritative = $classMapAuthoritative;
}
/**
* Should class lookup fail if not found in the current class map?
*
* @return bool
*/
public function isClassMapAuthoritative()
{
return $this->classMapAuthoritative;
}
/**
* APCu prefix to use to cache found/not-found classes, if the extension is enabled.
*
* @param string|null $apcuPrefix
*/
public function setApcuPrefix($apcuPrefix)
{
$this->apcuPrefix = function_exists('apcu_fetch') && ini_get('apc.enabled') ? $apcuPrefix : null;
}
/**
* The APCu prefix in use, or null if APCu caching is not enabled.
*
* @return string|null
*/
public function getApcuPrefix()
{
return $this->apcuPrefix;
}
/**
* Registers this instance as an autoloader.
*
* @param bool $prepend Whether to prepend the autoloader or not
*/
public function register($prepend = false)
{
spl_autoload_register(array($this, 'loadClass'), true, $prepend);
}
/**
* Unregisters this instance as an autoloader.
*/
public function unregister()
{
spl_autoload_unregister(array($this, 'loadClass'));
}
/**
* Loads the given class or interface.
*
* @param string $class The name of the class
* @return bool|null True if loaded, null otherwise
*/
public function loadClass($class)
{
if ($file = $this->findFile($class)) {
includeFile($file);
return true;
}
}
/**
* Finds the path to the file where the class is defined.
*
* @param string $class The name of the class
*
* @return string|false The path if found, false otherwise
*/
public function findFile($class)
{
// class map lookup
if (isset($this->classMap[$class])) {
return $this->classMap[$class];
}
if ($this->classMapAuthoritative || isset($this->missingClasses[$class])) {
return false;
}
if (null !== $this->apcuPrefix) {
$file = apcu_fetch($this->apcuPrefix.$class, $hit);
if ($hit) {
return $file;
}
}
$file = $this->findFileWithExtension($class, '.php');
// Search for Hack files if we are running on HHVM
if (false === $file && defined('HHVM_VERSION')) {
$file = $this->findFileWithExtension($class, '.hh');
}
if (null !== $this->apcuPrefix) {
apcu_add($this->apcuPrefix.$class, $file);
}
if (false === $file) {
// Remember that this class does not exist.
$this->missingClasses[$class] = true;
}
return $file;
}
private function findFileWithExtension($class, $ext)
{
// PSR-4 lookup
$logicalPathPsr4 = strtr($class, '\\', DIRECTORY_SEPARATOR) . $ext;
$first = $class[0];
if (isset($this->prefixLengthsPsr4[$first])) {
$subPath = $class;
while (false !== $lastPos = strrpos($subPath, '\\')) {
$subPath = substr($subPath, 0, $lastPos);
$search = $subPath.'\\';
if (isset($this->prefixDirsPsr4[$search])) {
foreach ($this->prefixDirsPsr4[$search] as $dir) {
$length = $this->prefixLengthsPsr4[$first][$search];
if (file_exists($file = $dir . DIRECTORY_SEPARATOR . substr($logicalPathPsr4, $length))) {
return $file;
}
}
}
}
}
// PSR-4 fallback dirs
foreach ($this->fallbackDirsPsr4 as $dir) {
if (file_exists($file = $dir . DIRECTORY_SEPARATOR . $logicalPathPsr4)) {
return $file;
}
}
// PSR-0 lookup
if (false !== $pos = strrpos($class, '\\')) {
// namespaced class name
$logicalPathPsr0 = substr($logicalPathPsr4, 0, $pos + 1)
. strtr(substr($logicalPathPsr4, $pos + 1), '_', DIRECTORY_SEPARATOR);
} else {
// PEAR-like class name
$logicalPathPsr0 = strtr($class, '_', DIRECTORY_SEPARATOR) . $ext;
}
if (isset($this->prefixesPsr0[$first])) {
foreach ($this->prefixesPsr0[$first] as $prefix => $dirs) {
if (0 === strpos($class, $prefix)) {
foreach ($dirs as $dir) {
if (file_exists($file = $dir . DIRECTORY_SEPARATOR . $logicalPathPsr0)) {
return $file;
}
}
}
}
}
// PSR-0 fallback dirs
foreach ($this->fallbackDirsPsr0 as $dir) {
if (file_exists($file = $dir . DIRECTORY_SEPARATOR . $logicalPathPsr0)) {
return $file;
}
}
// PSR-0 include paths.
if ($this->useIncludePath && $file = stream_resolve_include_path($logicalPathPsr0)) {
return $file;
}
return false;
}
}
/**
* Scope isolated include.
*
* Prevents access to $this/self from included files.
*/
function includeFile($file)
{
include $file;
}
vendor/composer/LICENSE 0000666 00000002056 15213303300 0010672 0 ustar 00
Copyright (c) Nils Adermann, Jordi Boggiano
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is furnished
to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
vendor/composer/autoload_psr4.php 0000666 00000000447 15213303300 0013160 0 ustar 00 array($vendorDir . '/proteusthemes/wp-content-importer-v2/src'),
'OCDI\\' => array($baseDir . '/inc'),
);
 ?>)