a22573bf0b
- WordPress core y plugins - Tema Twenty Twenty-Four configurado - Plugin allow-unfiltered-html.php simplificado - .gitignore configurado para excluir wp-config.php y uploads 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude <noreply@anthropic.com>
1170 lines
36 KiB
PHP
Executable File
1170 lines
36 KiB
PHP
Executable File
<?php
|
|
|
|
/**
|
|
* Thrive Themes - https://thrivethemes.com
|
|
*
|
|
* @package thrive-dashboard
|
|
*/
|
|
if ( ! defined( 'ABSPATH' ) ) {
|
|
exit; // Silence is golden!
|
|
}
|
|
/**
|
|
* Plugin Update Checker Library 1.3.2
|
|
* http://w-shadow.com/
|
|
*
|
|
* Copyright 2013 Janis Elsts
|
|
* Licensed under the GNU GPL license.
|
|
* http://www.gnu.org/licenses/gpl.html
|
|
*/
|
|
|
|
if ( ! class_exists( 'TVE_PluginUpdateChecker_1_3_2', false ) ) {
|
|
|
|
/**
|
|
* A custom plugin update checker.
|
|
*
|
|
* @author Janis Elsts
|
|
* @copyright 2013
|
|
* @version 1.3.1
|
|
* @access public
|
|
*/
|
|
class TVE_PluginUpdateChecker_1_3_2 {
|
|
protected $secret_key = '@#$()%*%$^&*(#@$%@#$%93827456MASDFJIK3245';
|
|
|
|
public $metadataUrl = ''; //The URL of the plugin's metadata file.
|
|
public $pluginAbsolutePath = ''; //Full path of the main plugin file.
|
|
public $pluginFile = ''; //Plugin filename relative to the plugins directory. Many WP APIs use this to identify plugins.
|
|
public $slug = ''; //Plugin slug.
|
|
public $checkPeriod = 12; //How often to check for updates (in hours).
|
|
public $optionName = ''; //Where to store the update info.
|
|
|
|
public $debugMode = false; //Set to TRUE to enable error reporting. Errors are raised using trigger_error()
|
|
//and should be logged to the standard PHP error log.
|
|
|
|
private $cronHook = null;
|
|
private $debugBarPlugin = null;
|
|
private $cachedInstalledVersion = null;
|
|
private $php_version = 0;
|
|
private $site_url = null;
|
|
private $channel = null;
|
|
private $ttw_id = 0;
|
|
private $required_php_version = '5.3.0';
|
|
private $wp_version = '';
|
|
|
|
protected $api_slug = '';
|
|
|
|
/**
|
|
* Class constructor.
|
|
*
|
|
* @param string $metadataUrl The URL of the plugin's metadata file.
|
|
* @param string $pluginFile Fully qualified path to the main plugin file.
|
|
* @param string $slug The plugin's 'slug'. If not specified, the filename part of $pluginFile sans '.php' will be used as the slug.
|
|
* @param integer $checkPeriod How often to check for updates (in hours). Defaults to checking every 12 hours. Set to 0 to disable automatic update checks.
|
|
* @param string $optionName Where to store book-keeping info about update checks. Defaults to 'external_updates-$slug'.
|
|
*/
|
|
public function __construct( $metadataUrl, $pluginFile, $slug = '', $checkPeriod = 12, $optionName = '', $api_slug = '' ) {
|
|
$this->metadataUrl = $metadataUrl;
|
|
$this->pluginAbsolutePath = $pluginFile;
|
|
$this->pluginFile = plugin_basename( $this->pluginAbsolutePath );
|
|
$this->checkPeriod = $checkPeriod;
|
|
$this->slug = $slug;
|
|
$this->optionName = $optionName;
|
|
$this->debugMode = defined( 'WP_DEBUG' ) && WP_DEBUG;
|
|
$this->api_slug = $api_slug;
|
|
$this->php_version = PHP_VERSION;
|
|
$this->site_url = home_url();
|
|
$this->channel = tvd_get_update_channel();
|
|
$this->ttw_id = class_exists( 'TD_TTW_Connection', false ) && TD_TTW_Connection::get_instance()->is_connected() ? TD_TTW_Connection::get_instance()->ttw_id : 0;
|
|
$this->wp_version = get_bloginfo( 'version' );
|
|
|
|
//If no slug is specified, use the name of the main plugin file as the slug.
|
|
//For example, 'my-cool-plugin/cool-plugin.php' becomes 'cool-plugin'.
|
|
if ( empty( $this->slug ) ) {
|
|
$this->slug = basename( $this->pluginFile, '.php' );
|
|
}
|
|
|
|
if ( empty( $this->optionName ) ) {
|
|
$this->optionName = 'external_updates-' . $this->slug;
|
|
}
|
|
|
|
if ( ! function_exists( 'get_plugin_data' ) ) {
|
|
require_once( ABSPATH . '/wp-admin/includes/plugin.php' );
|
|
}
|
|
|
|
$this->installHooks();
|
|
|
|
if ( version_compare( $this->php_version, $this->required_php_version ) === - 1 ) {
|
|
add_action( 'admin_notices', array( $this, 'php_version_notice' ) );
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Install the hooks required to run periodic update checks and inject update info
|
|
* into WP data structures.
|
|
*
|
|
* @return void
|
|
*/
|
|
protected function installHooks() {
|
|
//Override requests for plugin information
|
|
add_filter( 'plugins_api', array( $this, 'injectInfo' ), 20, 3 );
|
|
|
|
//Insert our update info into the update array maintained by WP
|
|
add_filter( 'site_transient_update_plugins', array( $this, 'injectUpdate' ) ); //WP 3.0+
|
|
add_filter( 'transient_update_plugins', array( $this, 'injectUpdate' ) ); //WP 2.8+
|
|
|
|
add_filter( 'plugin_row_meta', array( $this, 'addCheckForUpdatesLink' ), 10, 2 );
|
|
add_action( 'admin_init', array( $this, 'handleManualCheck' ) );
|
|
add_action( 'all_admin_notices', array( $this, 'displayManualCheckResult' ) );
|
|
|
|
//Clear the version number cache when something - anything - is upgraded or WP clears the update cache.
|
|
add_filter( 'upgrader_post_install', array( $this, 'clearCachedVersion' ) );
|
|
add_action( 'delete_site_transient_update_plugins', array( $this, 'clearCachedVersion' ) );
|
|
|
|
//Set up the periodic update checks
|
|
$this->cronHook = 'check_plugin_updates-' . $this->slug;
|
|
if ( $this->checkPeriod > 0 ) {
|
|
|
|
//Trigger the check via Cron.
|
|
//Try to use one of the default schedules if possible as it's less likely to conflict
|
|
//with other plugins and their custom schedules.
|
|
$defaultSchedules = array(
|
|
1 => 'hourly',
|
|
12 => 'twicedaily',
|
|
24 => 'daily',
|
|
);
|
|
if ( array_key_exists( $this->checkPeriod, $defaultSchedules ) ) {
|
|
$scheduleName = $defaultSchedules[ $this->checkPeriod ];
|
|
} else {
|
|
//Use a custom cron schedule.
|
|
$scheduleName = 'every' . $this->checkPeriod . 'hours';
|
|
add_filter( 'cron_schedules', array( $this, '_addCustomSchedule' ) );
|
|
}
|
|
|
|
if ( ! wp_next_scheduled( $this->cronHook ) && ! defined( 'WP_INSTALLING' ) ) {
|
|
wp_schedule_event( time(), $scheduleName, $this->cronHook );
|
|
}
|
|
add_action( $this->cronHook, array( $this, 'checkForUpdates' ) );
|
|
|
|
register_deactivation_hook( $this->pluginFile, array( $this, '_removeUpdaterCron' ) );
|
|
|
|
//In case Cron is disabled or unreliable, we also manually trigger
|
|
//the periodic checks while the user is browsing the Dashboard.
|
|
add_action( 'admin_init', array( $this, 'maybeCheckForUpdates' ) );
|
|
|
|
//Like WordPress itself, we check more often on certain pages.
|
|
add_action( 'load-update-core.php', array( $this, 'maybeCheckForUpdates' ) );
|
|
|
|
} else {
|
|
//Periodic checks are disabled.
|
|
wp_clear_scheduled_hook( $this->cronHook );
|
|
}
|
|
|
|
if ( did_action( 'plugins_loaded' ) ) {
|
|
$this->initDebugBarPanel();
|
|
} else {
|
|
add_action( 'plugins_loaded', array( $this, 'initDebugBarPanel' ) );
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Displays an error notice informing the users that the environment PHP Version is not compatible with Thrive Suite PHP Version
|
|
*/
|
|
public function php_version_notice() {
|
|
$plugin_data = get_plugin_data( $this->pluginAbsolutePath, false, false );
|
|
|
|
$message = __( $plugin_data['Name'] . ' requires PHP version ' . $this->required_php_version . '. Your current version is ' . $this->php_version . '. Please contact your hosting provider and ask them to update your PHP.', 'thrive-dash' );
|
|
|
|
echo wp_kses_post( sprintf( '<div class="error"><p>%s</p></div>', $message ) );
|
|
}
|
|
|
|
/**
|
|
* Add our custom schedule to the array of Cron schedules used by WP.
|
|
*
|
|
* @param array $schedules
|
|
*
|
|
* @return array
|
|
*/
|
|
public function _addCustomSchedule( $schedules ) {
|
|
if ( $this->checkPeriod && ( $this->checkPeriod > 0 ) ) {
|
|
$scheduleName = 'every' . $this->checkPeriod . 'hours';
|
|
$schedules[ $scheduleName ] = array(
|
|
'interval' => $this->checkPeriod * 3600,
|
|
'display' => sprintf( 'Every %d hours', $this->checkPeriod ),
|
|
);
|
|
}
|
|
|
|
return $schedules;
|
|
}
|
|
|
|
/**
|
|
* Remove the scheduled cron event that the library uses to check for updates.
|
|
*
|
|
* @return void
|
|
*/
|
|
public function _removeUpdaterCron() {
|
|
wp_clear_scheduled_hook( $this->cronHook );
|
|
}
|
|
|
|
/**
|
|
* Get the name of the update checker's WP-cron hook. Mostly useful for debugging.
|
|
*
|
|
* @return string
|
|
*/
|
|
public function getCronHookName() {
|
|
return $this->cronHook;
|
|
}
|
|
|
|
/**
|
|
* Retrieve plugin info from the configured API endpoint.
|
|
*
|
|
* @param array $queryArgs Additional query arguments to append to the request. Optional.
|
|
*
|
|
* @return TVE_PluginInfo
|
|
* @uses wp_remote_get()
|
|
*
|
|
*/
|
|
public function requestInfo( $queryArgs = array() ) {
|
|
//Query args to append to the URL. Plugins can add their own by using a filter callback (see addQueryArgFilter()).
|
|
$installedVersion = $this->getInstalledVersion();
|
|
$queryArgs['installed_version'] = ( $installedVersion !== null ) ? $installedVersion : '';
|
|
$queryArgs = apply_filters( 'puc_request_info_query_args-' . $this->slug, $queryArgs );
|
|
|
|
//Various options for the wp_remote_get() call. Plugins can filter these, too.
|
|
$options = array(
|
|
'timeout' => 10, //seconds
|
|
'headers' => array(
|
|
'Accept' => 'application/json',
|
|
),
|
|
);
|
|
$options = apply_filters( 'puc_request_info_options-' . $this->slug, $options );
|
|
|
|
//The plugin info should be at 'http://your-api.com/url/here/$slug/info.json'
|
|
$url = $this->metadataUrl;
|
|
|
|
/**
|
|
* prepare the POST parameters
|
|
*/
|
|
$options['body'] = $queryArgs;
|
|
$options['body']['api_slug'] = $this->api_slug;
|
|
$options['body']['client_php_version'] = $this->php_version;
|
|
$options['body']['channel'] = $this->channel;
|
|
$options['body']['client_site_url'] = $this->site_url;
|
|
$options['body']['ttw_id'] = (string) $this->ttw_id;
|
|
$options['body']['wp_version'] = (string) $this->wp_version;
|
|
$url = add_query_arg( array( 'p' => $this->calc_hash( $options['body'] ) ), $url );
|
|
|
|
$result = wp_remote_post(
|
|
$url,
|
|
$options
|
|
);
|
|
|
|
//Try to parse the response
|
|
$pluginInfo = new StdClass();
|
|
if ( ! is_wp_error( $result ) && isset( $result['response']['code'] ) && ( $result['response']['code'] == 200 ) && ! empty( $result['body'] ) ) {
|
|
$pluginInfo = TVE_PluginInfo_1_3::fromJson( $result['body'], $this->debugMode );
|
|
} else if ( $this->debugMode ) {
|
|
$message = sprintf( "The URL %s does not point to a valid plugin metadata file. ", $url );
|
|
if ( is_wp_error( $result ) ) {
|
|
$message .= "WP HTTP error: " . $result->get_error_message();
|
|
} else if ( isset( $result['response']['code'] ) ) {
|
|
$message .= "HTTP response code is " . $result['response']['code'] . " (expected: 200)";
|
|
} else {
|
|
$message .= "wp_remote_get() returned an unexpected result.";
|
|
}
|
|
trigger_error( esc_html( $message ), E_USER_WARNING );
|
|
}
|
|
|
|
$pluginInfo = apply_filters( 'puc_request_info_result-' . $this->slug, $pluginInfo, $result );
|
|
|
|
return $pluginInfo;
|
|
}
|
|
|
|
public function calc_hash( $data ) {
|
|
return md5( $this->secret_key . serialize( $data ) . $this->secret_key );
|
|
}
|
|
|
|
/**
|
|
* Retrieve the latest update (if any) from the configured API endpoint.
|
|
*
|
|
* @return TVE_PluginUpdate An instance of PluginUpdate, or NULL when no updates are available.
|
|
* @uses PluginUpdateChecker::requestInfo()
|
|
*
|
|
*/
|
|
public function requestUpdate() {
|
|
//For the sake of simplicity, this function just calls requestInfo()
|
|
//and transforms the result accordingly.
|
|
$pluginInfo = $this->requestInfo( array( 'checking_for_updates' => '1' ) );
|
|
if ( $pluginInfo == null ) {
|
|
return null;
|
|
}
|
|
|
|
return TVE_PluginUpdate_1_3::fromPluginInfo( $pluginInfo );
|
|
}
|
|
|
|
/**
|
|
* Get the currently installed version of the plugin.
|
|
*
|
|
* @return string Version number.
|
|
*/
|
|
public function getInstalledVersion() {
|
|
if ( isset( $this->cachedInstalledVersion ) ) {
|
|
return $this->cachedInstalledVersion;
|
|
}
|
|
|
|
if ( ! is_file( $this->pluginAbsolutePath ) ) {
|
|
//This can happen if the plugin filename is wrong.
|
|
if ( $this->debugMode ) {
|
|
trigger_error(
|
|
sprintf(
|
|
"Can't to read the Version header for %s. The file does not exist.",
|
|
$this->pluginFile
|
|
),
|
|
E_USER_WARNING
|
|
);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
$pluginHeader = get_plugin_data( $this->pluginAbsolutePath, false, false );
|
|
if ( isset( $pluginHeader['Version'] ) ) {
|
|
$this->cachedInstalledVersion = $pluginHeader['Version'];
|
|
|
|
return $pluginHeader['Version'];
|
|
} else {
|
|
//This can happen if the filename points to something that is not a plugin.
|
|
if ( $this->debugMode ) {
|
|
trigger_error(
|
|
sprintf(
|
|
"Can't to read the Version header for %s. The filename is incorrect or is not a plugin.",
|
|
$this->pluginFile
|
|
),
|
|
E_USER_WARNING
|
|
);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Check for plugin updates.
|
|
* The results are stored in the DB option specified in $optionName.
|
|
*
|
|
* @return TVE_PluginUpdate|null
|
|
*/
|
|
public function checkForUpdates() {
|
|
$installedVersion = $this->getInstalledVersion();
|
|
//Fail silently if we can't find the plugin or read its header.
|
|
if ( $installedVersion === null ) {
|
|
if ( $this->debugMode ) {
|
|
trigger_error(
|
|
sprintf( 'Skipping update check for %s - installed version unknown.', $this->pluginFile ),
|
|
E_USER_WARNING
|
|
);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
$state = $this->getUpdateState();
|
|
if ( empty( $state ) ) {
|
|
$state = new StdClass;
|
|
$state->lastCheck = 0;
|
|
$state->checkedVersion = '';
|
|
$state->update = null;
|
|
}
|
|
|
|
$state->lastCheck = time();
|
|
$state->checkedVersion = $installedVersion;
|
|
$this->setUpdateState( $state ); //Save before checking in case something goes wrong
|
|
|
|
$state->update = $this->requestUpdate();
|
|
$this->setUpdateState( $state );
|
|
|
|
return $this->getUpdate();
|
|
}
|
|
|
|
/**
|
|
* Check for updates if the configured check interval has already elapsed.
|
|
* Will use a shorter check interval on certain admin pages like "Dashboard -> Updates".
|
|
*
|
|
* @return void
|
|
*/
|
|
public function maybeCheckForUpdates() {
|
|
if ( empty( $this->checkPeriod ) ) {
|
|
return;
|
|
}
|
|
$state = $this->getUpdateState();
|
|
|
|
//Check more often when the user visits Dashboard -> Updates.
|
|
if ( current_filter() == 'load-update-core.php' ) {
|
|
$timeout = 60;
|
|
} else {
|
|
$timeout = $this->checkPeriod * 3600;
|
|
}
|
|
|
|
$shouldCheck
|
|
= empty( $state )
|
|
||
|
|
! isset( $state->lastCheck )
|
|
|| ( ( time() - $state->lastCheck ) >= $timeout );
|
|
|
|
if ( $shouldCheck ) {
|
|
$this->checkForUpdates();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Load the update checker state from the DB.
|
|
*
|
|
* @return StdClass|null
|
|
*/
|
|
public function getUpdateState() {
|
|
$state = get_site_option( $this->optionName, null );
|
|
if ( empty( $state ) || ! is_object( $state ) ) {
|
|
$state = null;
|
|
}
|
|
|
|
if ( ! empty( $state ) && isset( $state->update ) && is_object( $state->update ) ) {
|
|
$state->update = TVE_PluginUpdate_1_3::fromObject( $state->update );
|
|
}
|
|
|
|
return $state;
|
|
}
|
|
|
|
|
|
/**
|
|
* Persist the update checker state to the DB.
|
|
*
|
|
* @param StdClass $state
|
|
*
|
|
* @return void
|
|
*/
|
|
private function setUpdateState( $state ) {
|
|
if ( isset( $state->update ) && is_object( $state->update ) && method_exists( $state->update, 'toStdClass' ) ) {
|
|
$update = $state->update;
|
|
/** @var TVE_PluginUpdate $update */
|
|
$state->update = $update->toStdClass();
|
|
}
|
|
update_site_option( $this->optionName, $state );
|
|
}
|
|
|
|
/**
|
|
* Reset update checker state - i.e. last check time, cached update data and so on.
|
|
*
|
|
* Call this when your plugin is being uninstalled, or if you want to
|
|
* clear the update cache.
|
|
*/
|
|
public function resetUpdateState() {
|
|
delete_site_option( $this->optionName );
|
|
}
|
|
|
|
/**
|
|
* Intercept plugins_api() calls that request information about our plugin and
|
|
* use the configured API endpoint to satisfy them.
|
|
*
|
|
* @param mixed $result
|
|
* @param string $action
|
|
* @param array|object $args
|
|
*
|
|
* @return mixed
|
|
* @see plugins_api()
|
|
*
|
|
*/
|
|
public function injectInfo( $result, $action = null, $args = null ) {
|
|
$relevant = ( $action == 'plugin_information' ) && isset( $args->slug ) && ( $args->slug == $this->slug );
|
|
if ( ! $relevant ) {
|
|
return $result;
|
|
}
|
|
|
|
$pluginInfo = $this->requestInfo();
|
|
$pluginInfo = apply_filters( 'puc_pre_inject_info-' . $this->slug, $pluginInfo );
|
|
if ( $pluginInfo ) {
|
|
return $pluginInfo->toWpFormat();
|
|
}
|
|
|
|
return $result;
|
|
}
|
|
|
|
/**
|
|
* Insert the latest update (if any) into the update list maintained by WP.
|
|
*
|
|
* @param StdClass $updates Update list.
|
|
*
|
|
* @return StdClass Modified update list.
|
|
*/
|
|
public function injectUpdate( $updates ) {
|
|
//Is there an update to insert?
|
|
$update = $this->getUpdate();
|
|
if ( ! empty( $update ) ) {
|
|
//Let plugins filter the update info before it's passed on to WordPress.
|
|
$update = apply_filters( 'puc_pre_inject_update-' . $this->slug, $update );
|
|
if ( ! is_object( $updates ) ) {
|
|
$updates = new StdClass();
|
|
$updates->response = array();
|
|
}
|
|
$updates->response[ $this->pluginFile ] = $update->toWpFormat();
|
|
// WP 4.2 added a check using the 'plugin' field of the update response without checking if it exists
|
|
$updates->response[ $this->pluginFile ]->plugin = $this->pluginFile;
|
|
} else if ( isset( $updates, $updates->response ) ) {
|
|
unset( $updates->response[ $this->pluginFile ] );
|
|
/* This line ensures that WordPress will always show the "Enable auto-updates" link for Thrive plugins, even if there is no update available */
|
|
$updates->no_update[ $this->pluginFile ] = (object) array(
|
|
'slug' => $this->slug,
|
|
'plugin' => '',
|
|
);
|
|
}
|
|
|
|
return $updates;
|
|
}
|
|
|
|
/**
|
|
* Get the details of the currently available update, if any.
|
|
*
|
|
* If no updates are available, or if the last known update version is below or equal
|
|
* to the currently installed version, this method will return NULL.
|
|
*
|
|
* Uses cached update data. To retrieve update information straight from
|
|
* the metadata URL, call requestUpdate() instead.
|
|
*
|
|
* @return TVE_PluginUpdate|null
|
|
*/
|
|
public function getUpdate() {
|
|
$state = $this->getUpdateState();
|
|
/** @var StdClass $state */
|
|
|
|
//Is there an update available insert?
|
|
if ( ! empty( $state ) && isset( $state->update ) && ! empty( $state->update ) ) {
|
|
$update = $state->update;
|
|
//Check if the update is actually newer than the currently installed version.
|
|
$installedVersion = $this->getInstalledVersion();
|
|
if ( ( $installedVersion !== null ) && version_compare( $update->version, $installedVersion, '>' ) ) {
|
|
|
|
global $wp_version;
|
|
|
|
if ( ! empty( $update->requires ) && version_compare( $wp_version, $update->requires, '<' ) ) {
|
|
$update->upgrade_notice = static::get_wp_version_error_message();
|
|
}
|
|
|
|
$plugin_data = get_plugin_data( $this->pluginAbsolutePath );
|
|
|
|
/**
|
|
* @todo Remove this check after a while
|
|
*/
|
|
if ( class_exists( 'TD_TTW_Messages_Manager', false ) ) {
|
|
|
|
$update_message = TD_TTW_Messages_Manager::get_update_message( $state, $plugin_data );
|
|
$can_see_updates = TD_TTW_Update_Manager::can_see_updates();
|
|
if ( null === $update_message || ( ! $can_see_updates && strpos( $update_message, 'thrv-deny-updates' ) !== false ) ) {
|
|
return null;
|
|
}
|
|
|
|
$update->upgrade_notice .= $update_message;
|
|
}
|
|
|
|
if ( ! empty( $update->upgrade_notice ) ) {
|
|
remove_action( 'in_plugin_update_message-' . $this->pluginFile, array(
|
|
$this,
|
|
'upgrade_notice',
|
|
), 10 );
|
|
add_action( 'in_plugin_update_message-' . $this->pluginFile, array(
|
|
$this,
|
|
'upgrade_notice',
|
|
), 10, 2 );
|
|
}
|
|
|
|
return $update;
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Message to be displayed when the user has an older version of wordpress
|
|
*
|
|
* @return string
|
|
*/
|
|
public static function get_wp_version_error_message() {
|
|
return '<br><br><strong>Error:</strong> This plugin <strong>requires a newer version of WordPress</strong>. <a href="' . admin_url( 'update-core.php' ) . '" target="_parent">Click here to update WordPress</a>.';
|
|
}
|
|
|
|
/**
|
|
* Output an upgrade notice
|
|
*
|
|
* @param $plugin_data
|
|
* @param $response
|
|
*/
|
|
public function upgrade_notice( $plugin_data, $response ) {
|
|
echo ( $response && $response->upgrade_notice ) ? $response->upgrade_notice : '';
|
|
}
|
|
|
|
/**
|
|
* Add a "Check for updates" link to the plugin row in the "Plugins" page. By default,
|
|
* the new link will appear after the "Visit plugin site" link.
|
|
*
|
|
* You can change the link text by using the "puc_manual_check_link-$slug" filter.
|
|
* Returning an empty string from the filter will disable the link.
|
|
*
|
|
* @param array $pluginMeta Array of meta links.
|
|
* @param string $pluginFile
|
|
*
|
|
* @return array
|
|
*/
|
|
public function addCheckForUpdatesLink( $pluginMeta, $pluginFile ) {
|
|
$in_plugin_admin = ! is_multisite() || is_network_admin();
|
|
if ( $in_plugin_admin && $pluginFile == $this->pluginFile && current_user_can( 'update_plugins' ) ) {
|
|
$linkUrl = wp_nonce_url(
|
|
add_query_arg(
|
|
array(
|
|
'puc_check_for_updates' => 1,
|
|
'puc_slug' => $this->slug,
|
|
),
|
|
is_network_admin() ? network_admin_url( 'plugins.php' ) : admin_url( 'plugins.php' )
|
|
),
|
|
'puc_check_for_updates'
|
|
);
|
|
|
|
$linkText = apply_filters( 'puc_manual_check_link-' . $this->slug, 'Check for updates' );
|
|
if ( ! empty( $linkText ) ) {
|
|
$pluginMeta[] = sprintf( '<a href="%s">%s</a>', esc_attr( $linkUrl ), $linkText );
|
|
}
|
|
}
|
|
|
|
return $pluginMeta;
|
|
}
|
|
|
|
/**
|
|
* Check for updates when the user clicks the "Check for updates" link.
|
|
*
|
|
* @return void
|
|
* @see static::addCheckForUpdatesLink()
|
|
*
|
|
*/
|
|
public function handleManualCheck() {
|
|
$shouldCheck
|
|
= isset( $_GET['puc_check_for_updates'], $_GET['puc_slug'] )
|
|
&& $_GET['puc_slug'] == $this->slug
|
|
&& current_user_can( 'update_plugins' )
|
|
&& check_admin_referer( 'puc_check_for_updates' );
|
|
|
|
if ( $shouldCheck ) {
|
|
$update = $this->checkForUpdates();
|
|
$status = ( $update === null ) ? 'no_update' : 'update_available';
|
|
wp_redirect( add_query_arg(
|
|
array(
|
|
'puc_update_check_result' => $status,
|
|
'puc_slug' => $this->slug,
|
|
),
|
|
is_network_admin() ? network_admin_url( 'plugins.php' ) : admin_url( 'plugins.php' )
|
|
) );
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Display the results of a manual update check.
|
|
*
|
|
* @see static::handleManualCheck()
|
|
*
|
|
* You can change the result message by using the "puc_manual_check_message-$slug" filter.
|
|
*/
|
|
public function displayManualCheckResult() {
|
|
if ( isset( $_GET['puc_update_check_result'], $_GET['puc_slug'] ) && ( $_GET['puc_slug'] == $this->slug ) ) {
|
|
$status = sanitize_text_field( $_GET['puc_update_check_result'] );
|
|
if ( $status == 'no_update' ) {
|
|
$message = 'This plugin is up to date.';
|
|
} else if ( $status == 'update_available' ) {
|
|
$message = 'A new version of this plugin is available.';
|
|
} else {
|
|
$message = sprintf( 'Unknown update checker status "%s"', htmlentities( $status ) );
|
|
}
|
|
printf(
|
|
'<div class="updated"><p>%s</p></div>',
|
|
apply_filters( 'puc_manual_check_message-' . $this->slug, $message, $status )
|
|
);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Clear the cached plugin version. This method can be set up as a filter (hook) and will
|
|
* return the filter argument unmodified.
|
|
*
|
|
* @param mixed $filterArgument
|
|
*
|
|
* @return mixed
|
|
*/
|
|
public function clearCachedVersion( $filterArgument = null ) {
|
|
$this->cachedInstalledVersion = null;
|
|
|
|
return $filterArgument;
|
|
}
|
|
|
|
/**
|
|
* Register a callback for filtering query arguments.
|
|
*
|
|
* The callback function should take one argument - an associative array of query arguments.
|
|
* It should return a modified array of query arguments.
|
|
*
|
|
* @param callable $callback
|
|
*
|
|
* @return void
|
|
* @uses add_filter() This method is a convenience wrapper for add_filter().
|
|
*
|
|
*/
|
|
public function addQueryArgFilter( $callback ) {
|
|
add_filter( 'puc_request_info_query_args-' . $this->slug, $callback );
|
|
}
|
|
|
|
/**
|
|
* Register a callback for filtering arguments passed to wp_remote_get().
|
|
*
|
|
* The callback function should take one argument - an associative array of arguments -
|
|
* and return a modified array or arguments. See the WP documentation on wp_remote_get()
|
|
* for details on what arguments are available and how they work.
|
|
*
|
|
* @param callable $callback
|
|
*
|
|
* @return void
|
|
* @uses add_filter() This method is a convenience wrapper for add_filter().
|
|
*
|
|
*/
|
|
public function addHttpRequestArgFilter( $callback ) {
|
|
add_filter( 'puc_request_info_options-' . $this->slug, $callback );
|
|
}
|
|
|
|
/**
|
|
* Register a callback for filtering the plugin info retrieved from the external API.
|
|
*
|
|
* The callback function should take two arguments. If the plugin info was retrieved
|
|
* successfully, the first argument passed will be an instance of PluginInfo. Otherwise,
|
|
* it will be NULL. The second argument will be the corresponding return value of
|
|
* wp_remote_get (see WP docs for details).
|
|
*
|
|
* The callback function should return a new or modified instance of PluginInfo or NULL.
|
|
*
|
|
* @param callable $callback
|
|
*
|
|
* @return void
|
|
* @uses add_filter() This method is a convenience wrapper for add_filter().
|
|
*
|
|
*/
|
|
public function addResultFilter( $callback ) {
|
|
add_filter( 'puc_request_info_result-' . $this->slug, $callback, 10, 2 );
|
|
}
|
|
|
|
/**
|
|
* Register a callback for one of the update checker filters.
|
|
*
|
|
* Identical to add_filter(), except it automatically adds the "puc_" prefix
|
|
* and the "-$plugin_slug" suffix to the filter name. For example, "request_info_result"
|
|
* becomes "puc_request_info_result-your_plugin_slug".
|
|
*
|
|
* @param string $tag
|
|
* @param callable $callback
|
|
* @param int $priority
|
|
* @param int $acceptedArgs
|
|
*/
|
|
public function addFilter( $tag, $callback, $priority = 10, $acceptedArgs = 1 ) {
|
|
add_filter( 'puc_' . $tag . '-' . $this->slug, $callback, $priority, $acceptedArgs );
|
|
}
|
|
|
|
/**
|
|
* Initialize the update checker Debug Bar plugin/add-on thingy.
|
|
*/
|
|
public function initDebugBarPanel() {
|
|
if ( class_exists( 'Debug_Bar' ) ) {
|
|
require_once dirname( __FILE__ ) . '/debug-bar-plugin.php';
|
|
$this->debugBarPlugin = new PucDebugBarPlugin( $this );
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
if ( ! class_exists( 'TVE_PluginInfo_1_3', false ) ) {
|
|
|
|
/**
|
|
* A container class for holding and transforming various plugin metadata.
|
|
*
|
|
* @author Janis Elsts
|
|
* @copyright 2012
|
|
* @version 1.3
|
|
* @access public
|
|
*/
|
|
class TVE_PluginInfo_1_3 {
|
|
//Most fields map directly to the contents of the plugin's info.json file.
|
|
//See the relevant docs for a description of their meaning.
|
|
public $name;
|
|
public $slug;
|
|
public $version;
|
|
public $homepage;
|
|
public $sections;
|
|
public $download_url;
|
|
|
|
public $author;
|
|
public $author_homepage;
|
|
|
|
public $requires;
|
|
public $tested;
|
|
|
|
public $icons;
|
|
public $channel;
|
|
public $upgrade_notice;
|
|
|
|
public $rating;
|
|
public $num_ratings;
|
|
public $downloaded;
|
|
public $last_updated;
|
|
|
|
public $id = 0; //The native WP.org API returns numeric plugin IDs, but they're not used for anything.
|
|
|
|
/**
|
|
* Create a new instance of PluginInfo from JSON-encoded plugin info
|
|
* returned by an external update API.
|
|
*
|
|
* @param string $json Valid JSON string representing plugin info.
|
|
* @param bool $triggerErrors
|
|
*
|
|
* @return TVE_PluginInfo|null New instance of PluginInfo, or NULL on error.
|
|
*/
|
|
public static function fromJson( $json, $triggerErrors = false ) {
|
|
/** @var StdClass $apiResponse */
|
|
$apiResponse = json_decode( $json );
|
|
if ( empty( $apiResponse ) || ! is_object( $apiResponse ) ) {
|
|
if ( $triggerErrors ) {
|
|
trigger_error(
|
|
"Failed to parse plugin metadata. Try validating your .json file with http://jsonlint.com/",
|
|
E_USER_NOTICE
|
|
);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
//Very, very basic validation.
|
|
$valid = isset( $apiResponse->name ) && ! empty( $apiResponse->name ) && isset( $apiResponse->version ) && ! empty( $apiResponse->version );
|
|
if ( ! $valid ) {
|
|
if ( $triggerErrors ) {
|
|
trigger_error(
|
|
"The plugin metadata file does not contain the required 'name' and/or 'version' keys.",
|
|
E_USER_NOTICE
|
|
);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
$info = new self();
|
|
foreach ( get_object_vars( $apiResponse ) as $key => $value ) {
|
|
$info->$key = $value;
|
|
}
|
|
|
|
return $info;
|
|
}
|
|
|
|
/**
|
|
* Transform plugin info into the format used by the native WordPress.org API
|
|
*
|
|
* @return object
|
|
*/
|
|
public function toWpFormat() {
|
|
$info = new StdClass;
|
|
|
|
//The custom update API is built so that many fields have the same name and format
|
|
//as those returned by the native WordPress.org API. These can be assigned directly.
|
|
$sameFormat = array(
|
|
'name',
|
|
'slug',
|
|
'version',
|
|
'requires',
|
|
'tested',
|
|
'rating',
|
|
'upgrade_notice',
|
|
'num_ratings',
|
|
'downloaded',
|
|
'homepage',
|
|
'last_updated',
|
|
'requires',
|
|
);
|
|
foreach ( $sameFormat as $field ) {
|
|
if ( isset( $this->$field ) ) {
|
|
$info->$field = $this->$field;
|
|
} else {
|
|
$info->$field = null;
|
|
}
|
|
}
|
|
|
|
//Other fields need to be renamed and/or transformed.
|
|
$info->download_link = $this->download_url;
|
|
|
|
if ( ! empty( $this->author_homepage ) ) {
|
|
$info->author = sprintf( '<a href="%s">%s</a>', $this->author_homepage, $this->author );
|
|
} else {
|
|
$info->author = $this->author;
|
|
}
|
|
|
|
if ( is_object( $this->sections ) ) {
|
|
$info->sections = get_object_vars( $this->sections );
|
|
} elseif ( is_array( $this->sections ) ) {
|
|
$info->sections = $this->sections;
|
|
} else {
|
|
$info->sections = array( 'description' => '' );
|
|
}
|
|
|
|
return $info;
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( ! class_exists( 'TVE_PluginUpdate_1_3', false ) ) {
|
|
|
|
/**
|
|
* A simple container class for holding information about an available update.
|
|
*
|
|
* @author Janis Elsts
|
|
* @copyright 2012
|
|
* @version 1.2
|
|
* @access public
|
|
*/
|
|
class TVE_PluginUpdate_1_3 {
|
|
public $id = 0;
|
|
public $slug;
|
|
public $version;
|
|
public $homepage;
|
|
public $download_url;
|
|
public $upgrade_notice;
|
|
public $tested;
|
|
public $icons;
|
|
public $requires;
|
|
|
|
private static $fields
|
|
= array(
|
|
'id',
|
|
'slug',
|
|
'version',
|
|
'homepage',
|
|
'download_url',
|
|
'upgrade_notice',
|
|
'tested',
|
|
'requires',
|
|
'icons',
|
|
);
|
|
|
|
/**
|
|
* Create a new instance of PluginUpdate from its JSON-encoded representation.
|
|
*
|
|
* @param string $json
|
|
* @param bool $triggerErrors
|
|
*
|
|
* @return TVE_PluginUpdate|null
|
|
*/
|
|
public static function fromJson( $json, $triggerErrors = false ) {
|
|
//Since update-related information is simply a subset of the full plugin info,
|
|
//we can parse the update JSON as if it was a plugin info string, then copy over
|
|
//the parts that we care about.
|
|
$pluginInfo = TVE_PluginInfo_1_3::fromJson( $json, $triggerErrors );
|
|
if ( $pluginInfo != null ) {
|
|
return static::fromPluginInfo( $pluginInfo );
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Create a new instance of PluginUpdate based on an instance of PluginInfo.
|
|
* Basically, this just copies a subset of fields from one object to another.
|
|
*
|
|
* @param TVE_PluginInfo $info
|
|
*
|
|
* @return TVE_PluginUpdate
|
|
*/
|
|
public static function fromPluginInfo( $info ) {
|
|
return static::fromObject( $info );
|
|
}
|
|
|
|
/**
|
|
* Create a new instance of PluginUpdate by copying the necessary fields from
|
|
* another object.
|
|
*
|
|
* @param StdClass|TVE_PluginInfo|TVE_PluginUpdate $object The source object.
|
|
*
|
|
* @return TVE_PluginUpdate The new copy.
|
|
*/
|
|
public static function fromObject( $object ) {
|
|
$update = new self();
|
|
foreach ( static::$fields as $field ) {
|
|
if ( isset( $object->$field ) ) {
|
|
$update->$field = $object->$field;
|
|
}
|
|
}
|
|
|
|
return $update;
|
|
}
|
|
|
|
/**
|
|
* Create an instance of StdClass that can later be converted back to
|
|
* a PluginUpdate. Useful for serialization and caching, as it avoids
|
|
* the "incomplete object" problem if the cached value is loaded before
|
|
* this class.
|
|
*
|
|
* @return StdClass
|
|
*/
|
|
public function toStdClass() {
|
|
$object = new StdClass();
|
|
foreach ( static::$fields as $field ) {
|
|
$object->$field = isset( $this->$field ) ? $this->$field : '';
|
|
}
|
|
|
|
return $object;
|
|
}
|
|
|
|
|
|
/**
|
|
* Transform the update into the format used by WordPress native plugin API.
|
|
*
|
|
* @return object
|
|
*/
|
|
public function toWpFormat() {
|
|
$update = new StdClass;
|
|
|
|
$update->id = $this->id;
|
|
$update->slug = $this->slug;
|
|
$update->new_version = $this->version;
|
|
$update->url = $this->homepage;
|
|
$update->package = $this->download_url;
|
|
|
|
if ( ! empty( $this->tested ) ) {
|
|
$update->tested = $this->tested;
|
|
}
|
|
|
|
if ( ! empty( $this->requires ) ) {
|
|
$update->requires = $this->requires;
|
|
}
|
|
|
|
if ( ! empty( $this->icons ) ) {
|
|
$update->icons = $this->icons;
|
|
}
|
|
|
|
if ( ! empty( $this->upgrade_notice ) ) {
|
|
$update->upgrade_notice = $this->upgrade_notice;
|
|
}
|
|
|
|
return $update;
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( ! class_exists( 'TVE_PucFactory', false ) ) {
|
|
|
|
/**
|
|
* A factory that builds instances of other classes from this library.
|
|
*
|
|
* When multiple versions of the same class have been loaded (e.g. PluginUpdateChecker 1.2
|
|
* and 1.3), this factory will always use the latest available version. Register class
|
|
* versions by calling {@link PucFactory::addVersion()}.
|
|
*
|
|
* At the moment it can only build instances of the PluginUpdateChecker class. Other classes
|
|
* are intended mainly for internal use and refer directly to specific implementations. If you
|
|
* want to instantiate one of them anyway, you can use {@link PucFactory::getLatestClassVersion()}
|
|
* to get the class name and then create it with <code>new $class(...)</code>.
|
|
*/
|
|
class TVE_PucFactory {
|
|
protected static $classVersions = array();
|
|
protected static $sorted = false;
|
|
|
|
/**
|
|
* Create a new instance of PluginUpdateChecker.
|
|
*
|
|
* @param $metadataUrl
|
|
* @param $pluginFile
|
|
* @param string $slug
|
|
* @param int $checkPeriod
|
|
* @param string $optionName
|
|
*
|
|
* @return TVE_PluginUpdateChecker
|
|
* @see PluginUpdateChecker::__construct()
|
|
*
|
|
*/
|
|
public static function buildUpdateChecker( $metadataUrl, $pluginFile, $slug = '', $checkPeriod = 12, $optionName = '' ) {
|
|
$class = static::getLatestClassVersion( 'PluginUpdateChecker' );
|
|
|
|
return new $class( $metadataUrl, $pluginFile, $slug, $checkPeriod, $optionName );
|
|
}
|
|
|
|
/**
|
|
* Get the specific class name for the latest available version of a class.
|
|
*
|
|
* @param string $class
|
|
*
|
|
* @return string|null
|
|
*/
|
|
public static function getLatestClassVersion( $class ) {
|
|
if ( ! static::$sorted ) {
|
|
static::sortVersions();
|
|
}
|
|
|
|
if ( isset( static::$classVersions[ $class ] ) ) {
|
|
return reset( static::$classVersions[ $class ] );
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Sort available class versions in descending order (i.e. newest first).
|
|
*/
|
|
protected static function sortVersions() {
|
|
foreach ( static::$classVersions as $class => $versions ) {
|
|
uksort( $versions, array( __CLASS__, 'compareVersions' ) );
|
|
static::$classVersions[ $class ] = $versions;
|
|
}
|
|
static::$sorted = true;
|
|
}
|
|
|
|
protected static function compareVersions( $a, $b ) {
|
|
return - version_compare( $a, $b );
|
|
}
|
|
|
|
/**
|
|
* Register a version of a class.
|
|
*
|
|
* @access private This method is only for internal use by the library.
|
|
*
|
|
* @param string $generalClass Class name without version numbers, e.g. 'PluginUpdateChecker'.
|
|
* @param string $versionedClass Actual class name, e.g. 'PluginUpdateChecker_1_2'.
|
|
* @param string $version Version number, e.g. '1.2'.
|
|
*/
|
|
public static function addVersion( $generalClass, $versionedClass, $version ) {
|
|
if ( ! isset( static::$classVersions[ $generalClass ] ) ) {
|
|
static::$classVersions[ $generalClass ] = array();
|
|
}
|
|
static::$classVersions[ $generalClass ][ $version ] = $versionedClass;
|
|
static::$sorted = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
//Register classes defined in this file with the factory.
|
|
TVE_PucFactory::addVersion( 'PluginUpdateChecker', 'TVE_PluginUpdateChecker_1_3_2', '1.3.2' );
|
|
TVE_PucFactory::addVersion( 'PluginUpdate', 'TVE_PluginUpdate_1_3', '1.3' );
|
|
TVE_PucFactory::addVersion( 'PluginInfo', 'TVE_PluginInfo_1_3', '1.3' );
|
|
|
|
/**
|
|
* Create non-versioned variants of the update checker classes. This allows for backwards
|
|
* compatibility with versions that did not use a factory, and it simplifies doc-comments.
|
|
*/
|
|
if ( ! class_exists( 'TVE_PluginUpdateChecker', false ) ) {
|
|
class TVE_PluginUpdateChecker extends TVE_PluginUpdateChecker_1_3_2 {
|
|
}
|
|
}
|
|
|
|
if ( ! class_exists( 'TVE_PluginUpdate', false ) ) {
|
|
class TVE_PluginUpdate extends TVE_PluginUpdate_1_3 {
|
|
}
|
|
}
|
|
|
|
if ( ! class_exists( 'TVE_PluginInfo', false ) ) {
|
|
class TVE_PluginInfo extends TVE_PluginInfo_1_3 {
|
|
}
|
|
}
|