You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
626 lines
17 KiB
PHP
626 lines
17 KiB
PHP
<?php
|
|
/**
|
|
* The Import Export Class
|
|
*
|
|
* @since 0.9.0
|
|
* @package RankMath
|
|
* @subpackage RankMath\Admin
|
|
* @author Rank Math <support@rankmath.com>
|
|
*/
|
|
|
|
namespace RankMath\Admin;
|
|
|
|
use RankMath\Helper;
|
|
use RankMath\Runner;
|
|
use RankMath\Traits\Ajax;
|
|
use RankMath\Traits\Hooker;
|
|
use RankMath\Helpers\Param;
|
|
use RankMath\Admin\Importers\Detector;
|
|
|
|
defined( 'ABSPATH' ) || exit;
|
|
|
|
/**
|
|
* Import_Export class.
|
|
*/
|
|
class Import_Export implements Runner {
|
|
|
|
use Hooker, Ajax;
|
|
|
|
/**
|
|
* Register hooks.
|
|
*/
|
|
public function hooks() {
|
|
$this->action( 'admin_init', 'handler' );
|
|
$this->action( 'admin_enqueue_scripts', 'enqueue', 1 );
|
|
$this->filter( 'rank_math/tools/pages', 'add_status_page', 30 );
|
|
$this->filter( 'rank_math/export/settings', 'export_other_panels', 10, 2 );
|
|
$this->action( 'rank_math/import/settings/pre_import', 'run_backup', 10, 0 );
|
|
|
|
$this->ajax( 'create_backup', 'create_backup' );
|
|
$this->ajax( 'delete_backup', 'delete_backup' );
|
|
$this->ajax( 'restore_backup', 'restore_backup' );
|
|
$this->ajax( 'clean_plugin', 'clean_plugin' );
|
|
$this->ajax( 'import_plugin', 'import_plugin' );
|
|
}
|
|
|
|
/**
|
|
* Add subpage to Status & Tools screen.
|
|
*
|
|
* @param array $pages Pages.
|
|
* @return array New pages.
|
|
*/
|
|
public function add_status_page( $pages ) {
|
|
if ( Helper::is_advanced_mode() ) {
|
|
$pages['import_export'] = [
|
|
'url' => 'status',
|
|
'args' => 'view=import_export',
|
|
'cap' => 'manage_options',
|
|
'title' => __( 'Import & Export', 'rank-math' ),
|
|
'class' => '\\RankMath\\Admin\\Import_Export',
|
|
];
|
|
}
|
|
|
|
return $pages;
|
|
}
|
|
|
|
/**
|
|
* Display Import/Export tools page.
|
|
*
|
|
* @return void
|
|
*/
|
|
public function display() {
|
|
include $this->get_view( 'main' );
|
|
}
|
|
|
|
/**
|
|
* Display panels for Import/Export tools.
|
|
*
|
|
* @return void
|
|
*/
|
|
public function show_panels() {
|
|
foreach ( (array) $this->get_panels() as $panel ) {
|
|
if ( ! isset( $panel['view'] ) || ! file_exists( $panel['view'] ) ) {
|
|
continue;
|
|
}
|
|
|
|
echo '<div class="' . ( isset( $panel['class'] ) ? esc_attr( $panel['class'] ) : '' ) . '">';
|
|
include $panel['view'];
|
|
echo '</div>';
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get list of panels.
|
|
*
|
|
* @return array
|
|
*/
|
|
public function get_panels() {
|
|
$dir = dirname( __FILE__ ) . '/views/import-export/';
|
|
|
|
$panels = [
|
|
'import-export' => [
|
|
'view' => $dir . 'import-export-panel.php',
|
|
'class' => 'import-export-settings',
|
|
],
|
|
'plugins' => [
|
|
'view' => $dir . 'plugins-panel.php',
|
|
'class' => 'import-plugins',
|
|
],
|
|
'backup' => [
|
|
'view' => $dir . 'backup-panel.php',
|
|
'class' => 'settings-backup',
|
|
],
|
|
];
|
|
|
|
return apply_filters( 'rank_math/admin/import_export_panels', $panels );
|
|
}
|
|
|
|
/**
|
|
* Get view file.
|
|
*
|
|
* @param string $view View filename.
|
|
*
|
|
* @return string Complete path to view
|
|
*/
|
|
public function get_view( $view ) {
|
|
$view = sanitize_key( $view );
|
|
return rank_math()->admin_dir() . "views/import-export/{$view}.php";
|
|
}
|
|
|
|
/**
|
|
* Enqueue files & add JSON.
|
|
*
|
|
* @return void
|
|
*/
|
|
public function enqueue() {
|
|
if ( ! $this->is_import_export_page() ) {
|
|
return;
|
|
}
|
|
|
|
\RankMath\Tools\Update_Score::get()->enqueue();
|
|
|
|
wp_enqueue_script( 'rank-math-import-export', rank_math()->plugin_url() . 'assets/admin/js/import-export.js', [], rank_math()->version, true );
|
|
wp_enqueue_style( 'cmb2-styles' );
|
|
wp_enqueue_style( 'rank-math-common' );
|
|
wp_enqueue_style( 'rank-math-cmb2' );
|
|
|
|
Helper::add_json( 'importSettingsConfirm', esc_html__( 'Are you sure you want to import settings into Rank Math? Don\'t worry, your current configuration will be saved as a backup.', 'rank-math' ) );
|
|
|
|
// Translators: %s is the plugin name.
|
|
Helper::add_json( 'importPluginConfirm', esc_html__( 'Are you sure you want to import data from %s?', 'rank-math' ) );
|
|
Helper::add_json( 'importPluginSelectAction', esc_html__( 'Select data to import.', 'rank-math' ) );
|
|
Helper::add_json( 'restoreConfirm', esc_html__( 'Are you sure you want to restore this backup? Your current configuration will be overwritten.', 'rank-math' ) );
|
|
Helper::add_json( 'deleteBackupConfirm', esc_html__( 'Are you sure you want to delete this backup?', 'rank-math' ) );
|
|
|
|
// Translators: %s is the plugin name.
|
|
Helper::add_json( 'cleanPluginConfirm', esc_html__( 'Are you sure you want erase all traces of %s?', 'rank-math' ) );
|
|
}
|
|
|
|
/**
|
|
* Check if we're on the Tools > Import & Export admin page.
|
|
*
|
|
* @return boolean
|
|
*/
|
|
private function is_import_export_page() {
|
|
return Param::get( 'page' ) === 'rank-math-status' && Param::get( 'view' ) === 'import_export';
|
|
}
|
|
|
|
/**
|
|
* Handle import or export.
|
|
*/
|
|
public function handler() {
|
|
$object_id = Param::post( 'object_id' );
|
|
if ( false === $object_id ) {
|
|
return;
|
|
}
|
|
|
|
if ( ! Helper::has_cap( 'general' ) ) {
|
|
return false;
|
|
}
|
|
|
|
if ( 'export-plz' === $object_id && check_admin_referer( 'rank-math-export-settings' ) ) {
|
|
$this->export();
|
|
}
|
|
|
|
if ( isset( $_FILES['import-me'] ) && 'import-plz' === $object_id && check_admin_referer( 'rank-math-import-settings' ) ) {
|
|
$this->import();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Handles AJAX run plugin clean.
|
|
*/
|
|
public function clean_plugin() {
|
|
$this->verify_nonce( 'rank-math-ajax-nonce' );
|
|
$this->has_cap_ajax( 'general' );
|
|
|
|
$result = Detector::run_by_slug( Param::post( 'pluginSlug' ), 'cleanup' );
|
|
|
|
if ( $result['status'] ) {
|
|
/* translators: Plugin name */
|
|
$this->success( sprintf( esc_html__( 'Cleanup of %s data successfully done.', 'rank-math' ), $result['importer']->get_plugin_name() ) );
|
|
}
|
|
|
|
/* translators: Plugin name */
|
|
$this->error( sprintf( esc_html__( 'Cleanup of %s data failed.', 'rank-math' ), $result['importer']->get_plugin_name() ) );
|
|
}
|
|
|
|
/**
|
|
* Handles AJAX run plugin import.
|
|
*/
|
|
public function import_plugin() {
|
|
$this->verify_nonce( 'rank-math-ajax-nonce' );
|
|
$this->has_cap_ajax( 'general' );
|
|
|
|
$perform = Param::post( 'perform', '', FILTER_SANITIZE_SPECIAL_CHARS, FILTER_FLAG_STRIP_LOW | FILTER_FLAG_STRIP_HIGH | FILTER_FLAG_STRIP_BACKTICK );
|
|
if ( ! $this->is_action_allowed( $perform ) ) {
|
|
$this->error( esc_html__( 'Action not allowed.', 'rank-math' ) );
|
|
}
|
|
|
|
try {
|
|
$result = Detector::run_by_slug( Param::post( 'pluginSlug' ), 'import', $perform );
|
|
$this->success( $result );
|
|
} catch ( \Exception $e ) {
|
|
$this->error( $e->getMessage() );
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Handles AJAX create backup.
|
|
*/
|
|
public function create_backup() {
|
|
$this->verify_nonce( 'rank-math-ajax-nonce' );
|
|
$this->has_cap_ajax( 'general' );
|
|
|
|
$key = $this->run_backup();
|
|
if ( is_null( $key ) ) {
|
|
$this->error( esc_html__( 'Unable to create backup this time.', 'rank-math' ) );
|
|
}
|
|
|
|
$this->success(
|
|
[
|
|
'key' => $key,
|
|
/* translators: Backup formatted date */
|
|
'backup' => sprintf( esc_html__( 'Backup: %s', 'rank-math' ), date_i18n( 'M jS Y, H:i a', $key ) ),
|
|
'message' => esc_html__( 'Backup created successfully.', 'rank-math' ),
|
|
]
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Handles AJAX delete backup.
|
|
*/
|
|
public function delete_backup() {
|
|
$this->verify_nonce( 'rank-math-ajax-nonce' );
|
|
$this->has_cap_ajax( 'general' );
|
|
|
|
$key = Param::post( 'key', '', FILTER_SANITIZE_SPECIAL_CHARS, FILTER_FLAG_STRIP_LOW | FILTER_FLAG_STRIP_HIGH | FILTER_FLAG_STRIP_BACKTICK );
|
|
if ( ! $key ) {
|
|
$this->error( esc_html__( 'No backup key found to delete.', 'rank-math' ) );
|
|
}
|
|
|
|
$this->run_backup( 'delete', $key );
|
|
$this->success( esc_html__( 'Backup successfully deleted.', 'rank-math' ) );
|
|
}
|
|
|
|
/**
|
|
* Handles AJAX restore backup.
|
|
*/
|
|
public function restore_backup() {
|
|
$this->verify_nonce( 'rank-math-ajax-nonce' );
|
|
$this->has_cap_ajax( 'general' );
|
|
|
|
$key = Param::post( 'key', '', FILTER_SANITIZE_SPECIAL_CHARS, FILTER_FLAG_STRIP_LOW | FILTER_FLAG_STRIP_HIGH | FILTER_FLAG_STRIP_BACKTICK );
|
|
if ( ! $key ) {
|
|
$this->error( esc_html__( 'No backup key found to restore.', 'rank-math' ) );
|
|
}
|
|
|
|
if ( ! $this->run_backup( 'restore', $key ) ) {
|
|
$this->error( esc_html__( 'Backup does not exist.', 'rank-math' ) );
|
|
}
|
|
|
|
$this->success( esc_html__( 'Backup restored successfully.', 'rank-math' ) );
|
|
}
|
|
|
|
/**
|
|
* Run backup actions.
|
|
*
|
|
* @param string $action Action to perform.
|
|
* @param array $key Key to backup.
|
|
* @return mixed
|
|
*/
|
|
public function run_backup( $action = 'add', $key = null ) {
|
|
$backups = $this->get_backups();
|
|
|
|
// Restore.
|
|
if ( 'restore' === $action ) {
|
|
if ( ! isset( $backups[ $key ] ) ) {
|
|
return false;
|
|
}
|
|
|
|
$this->do_import_data( $backups[ $key ], true );
|
|
|
|
return true;
|
|
}
|
|
|
|
// Add.
|
|
if ( 'add' === $action ) {
|
|
$key = current_time( 'U' );
|
|
$backups = [ $key => $this->get_export_data() ] + $backups;
|
|
}
|
|
|
|
// Delete.
|
|
if ( 'delete' === $action && isset( $backups[ $key ] ) ) {
|
|
unset( $backups[ $key ] );
|
|
}
|
|
|
|
update_option( 'rank_math_backups', $backups, false );
|
|
|
|
return $key;
|
|
}
|
|
|
|
/**
|
|
* Handle export.
|
|
*/
|
|
private function export() {
|
|
$panels = Param::post( 'panels', [], FILTER_DEFAULT, FILTER_REQUIRE_ARRAY );
|
|
$data = $this->get_export_data( $panels );
|
|
$filename = 'rank-math-settings-' . date_i18n( 'Y-m-d-H-i-s' ) . '.json';
|
|
|
|
header( 'Content-Type: application/json' );
|
|
header( 'Content-Disposition: attachment; filename=' . $filename );
|
|
header( 'Cache-Control: no-cache, no-store, must-revalidate' );
|
|
header( 'Pragma: no-cache' );
|
|
header( 'Expires: 0' );
|
|
|
|
echo wp_json_encode( $data );
|
|
exit;
|
|
}
|
|
|
|
/**
|
|
* Handle import.
|
|
*/
|
|
private function import() {
|
|
$file = $this->has_valid_file();
|
|
if ( false === $file ) {
|
|
return false;
|
|
}
|
|
|
|
// Parse Options.
|
|
$wp_filesystem = Helper::get_filesystem();
|
|
if ( is_null( $wp_filesystem ) || ! Helper::is_filesystem_direct() ) {
|
|
Helper::add_notification( esc_html__( 'Uploaded file could not be read.', 'rank-math' ), [ 'type' => 'error' ] );
|
|
return false;
|
|
}
|
|
|
|
$settings = $wp_filesystem->get_contents( $file['file'] );
|
|
$settings = json_decode( $settings, true );
|
|
|
|
\unlink( $file['file'] );
|
|
|
|
if ( is_array( $settings ) && $this->do_import_data( $settings ) ) {
|
|
Helper::add_notification( esc_html__( 'Settings successfully imported. Your old configuration has been saved as a backup.', 'rank-math' ), [ 'type' => 'success' ] );
|
|
return;
|
|
}
|
|
|
|
Helper::add_notification( esc_html__( 'No settings found to be imported.', 'rank-math' ), [ 'type' => 'info' ] );
|
|
}
|
|
|
|
/**
|
|
* Import has valid file.
|
|
*
|
|
* @return mixed
|
|
*/
|
|
private function has_valid_file() {
|
|
// Add upload hooks.
|
|
$this->filter( 'upload_mimes', 'allow_txt_upload', 10, 2 );
|
|
$this->filter( 'wp_check_filetype_and_ext', 'filetype_and_ext', 10, 4 );
|
|
|
|
// Do the upload.
|
|
$file = wp_handle_upload( $_FILES['import-me'], [ 'test_form' => false ] );
|
|
|
|
// Remove upload hooks.
|
|
$this->remove_filter( 'upload_mimes', 'allow_txt_upload', 10 );
|
|
$this->remove_filter( 'wp_check_filetype_and_ext', 'filetype_and_ext', 10 );
|
|
|
|
if ( is_wp_error( $file ) ) {
|
|
Helper::add_notification( esc_html__( 'Settings could not be imported:', 'rank-math' ) . ' ' . $file->get_error_message(), [ 'type' => 'error' ] );
|
|
return false;
|
|
}
|
|
|
|
if ( isset( $file['error'] ) ) {
|
|
Helper::add_notification( esc_html__( 'Settings could not be imported:', 'rank-math' ) . ' ' . $file['error'], [ 'type' => 'error' ] );
|
|
return false;
|
|
}
|
|
|
|
if ( ! isset( $file['file'] ) ) {
|
|
Helper::add_notification( esc_html__( 'Settings could not be imported: Upload failed.', 'rank-math' ), [ 'type' => 'error' ] );
|
|
return false;
|
|
}
|
|
|
|
return $file;
|
|
}
|
|
|
|
/**
|
|
* Filters the "real" file type of the given file.
|
|
*
|
|
* @param array $types {
|
|
* Values for the extension, mime type, and corrected filename.
|
|
*
|
|
* @type string|false $ext File extension, or false if the file doesn't match a mime type.
|
|
* @type string|false $type File mime type, or false if the file doesn't match a mime type.
|
|
* @type string|false $proper_filename File name with its correct extension, or false if it cannot be determined.
|
|
* }
|
|
* @param string $file Full path to the file.
|
|
* @param string $filename The name of the file (may differ from $file due to
|
|
* $file being in a tmp directory).
|
|
* @param string[] $mimes Array of mime types keyed by their file extension regex.
|
|
*
|
|
* @return array
|
|
*/
|
|
public function filetype_and_ext( $types, $file, $filename, $mimes ) {
|
|
if ( false !== strpos( $filename, '.json' ) ) {
|
|
$types['ext'] = 'json';
|
|
$types['type'] = 'application/json';
|
|
} elseif ( false !== strpos( $filename, '.txt' ) ) {
|
|
$types['ext'] = 'txt';
|
|
$types['type'] = 'text/plain';
|
|
}
|
|
|
|
return $types;
|
|
}
|
|
|
|
/**
|
|
* Allow txt & json file upload.
|
|
*
|
|
* @param array $types Mime types keyed by the file extension regex corresponding to those types.
|
|
* @param int|WP_User|null $user User ID, User object or null if not provided (indicates current user).
|
|
*
|
|
* @return array
|
|
*/
|
|
public function allow_txt_upload( $types, $user ) {
|
|
$types['json'] = 'application/json';
|
|
$types['txt'] = 'text/plain';
|
|
|
|
return $types;
|
|
}
|
|
|
|
/**
|
|
* Does import data.
|
|
*
|
|
* @param array $data Import data.
|
|
* @param bool $suppress_hooks Suppress hooks or not.
|
|
* @return bool
|
|
*/
|
|
private function do_import_data( array $data, $suppress_hooks = false ) {
|
|
$this->run_import_hooks( 'pre_import', $data, $suppress_hooks );
|
|
|
|
// Import options.
|
|
$down = $this->set_options( $data );
|
|
|
|
// Import capabilities.
|
|
if ( ! empty( $data['role-manager'] ) ) {
|
|
$down = true;
|
|
Helper::set_capabilities( $data['role-manager'] );
|
|
}
|
|
|
|
// Import redirections.
|
|
if ( ! empty( $data['redirections'] ) ) {
|
|
$down = true;
|
|
$this->set_redirections( $data['redirections'] );
|
|
}
|
|
|
|
$this->run_import_hooks( 'after_import', $data, $suppress_hooks );
|
|
|
|
return $down;
|
|
}
|
|
|
|
/**
|
|
* Set options from data.
|
|
*
|
|
* @param array $data An array of data.
|
|
*/
|
|
private function set_options( $data ) {
|
|
$set = false;
|
|
$hash = [
|
|
'modules' => 'rank_math_modules',
|
|
'general' => 'rank-math-options-general',
|
|
'titles' => 'rank-math-options-titles',
|
|
'sitemap' => 'rank-math-options-sitemap',
|
|
];
|
|
|
|
foreach ( $hash as $key => $option_key ) {
|
|
if ( ! empty( $data[ $key ] ) ) {
|
|
$set = true;
|
|
update_option( $option_key, $data[ $key ] );
|
|
}
|
|
}
|
|
|
|
return $set;
|
|
}
|
|
|
|
/**
|
|
* Set redirections.
|
|
*
|
|
* @param array $redirections An array of redirections to import.
|
|
*/
|
|
private function set_redirections( $redirections ) {
|
|
foreach ( $redirections as $key => $redirection ) {
|
|
$matched = \RankMath\Redirections\DB::match_redirections_source( $redirection['sources'] );
|
|
if ( ! empty( $matched ) ) {
|
|
continue;
|
|
}
|
|
|
|
$sources = maybe_unserialize( $redirection['sources'] );
|
|
if ( ! is_array( $sources ) ) {
|
|
continue;
|
|
}
|
|
|
|
\RankMath\Redirections\DB::add(
|
|
[
|
|
'url_to' => $redirection['url_to'],
|
|
'sources' => $sources,
|
|
'header_code' => $redirection['header_code'],
|
|
'hits' => $redirection['hits'],
|
|
'created' => $redirection['created'],
|
|
'updated' => $redirection['updated'],
|
|
]
|
|
);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Run import hooks
|
|
*
|
|
* @param string $hook Hook to fire.
|
|
* @param array $data Import data.
|
|
* @param bool $suppress Suppress hooks or not.
|
|
*/
|
|
private function run_import_hooks( $hook, $data, $suppress ) {
|
|
if ( ! $suppress ) {
|
|
/**
|
|
* Fires while importing settings.
|
|
*
|
|
* @since 0.9.0
|
|
*
|
|
* @param array $data Import data.
|
|
*/
|
|
$this->do_action( 'import/settings/' . $hook, $data );
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Gets export data.
|
|
*
|
|
* @param array $panels Which panels to export. All panels will be exported if this param is empty.
|
|
* @return array
|
|
*/
|
|
private function get_export_data( array $panels = [] ) {
|
|
if ( ! $panels ) {
|
|
$panels = [ 'general', 'titles', 'sitemap', 'role-manager', 'redirections' ];
|
|
}
|
|
|
|
$settings = rank_math()->settings->all_raw();
|
|
foreach ( $panels as $panel ) {
|
|
if ( isset( $settings[ $panel ] ) ) {
|
|
$data[ $panel ] = $settings[ $panel ];
|
|
continue;
|
|
}
|
|
|
|
$data = $this->do_filter( 'export/settings', $data, $panel );
|
|
}
|
|
|
|
$data['modules'] = get_option( 'rank_math_modules', [] );
|
|
|
|
return $data;
|
|
}
|
|
|
|
/**
|
|
* Export other panels.
|
|
*
|
|
* @param array $data Gathered data.
|
|
* @param string $panel Panel id.
|
|
*
|
|
* @return array
|
|
*/
|
|
public function export_other_panels( $data, $panel ) {
|
|
if ( 'role-manager' === $panel ) {
|
|
$data['role-manager'] = Helper::get_roles_capabilities();
|
|
}
|
|
|
|
if ( 'redirections' === $panel ) {
|
|
$items = \RankMath\Redirections\DB::get_redirections( [ 'limit' => 1000 ] );
|
|
|
|
$data['redirections'] = $items['redirections'];
|
|
}
|
|
|
|
return $data;
|
|
}
|
|
|
|
/**
|
|
* Check if given action is in the list of allowed actions.
|
|
*
|
|
* @param string $perform Action to check.
|
|
*
|
|
* @return bool
|
|
*/
|
|
private function is_action_allowed( $perform ) {
|
|
$allowed = [ 'settings', 'postmeta', 'termmeta', 'usermeta', 'redirections', 'blocks', 'deactivate', 'locations', 'news', 'video', 'recalculate' ];
|
|
return $perform && in_array( $perform, $allowed, true );
|
|
}
|
|
|
|
/**
|
|
* Get backups from the database.
|
|
*/
|
|
public function get_backups() {
|
|
$backups = get_option( 'rank_math_backups', [] );
|
|
if ( empty( $backups ) ) {
|
|
$backups = [];
|
|
} elseif ( ! is_array( $backups ) ) {
|
|
$backups = (array) $backups;
|
|
}
|
|
|
|
return $backups;
|
|
}
|
|
}
|