1738 lines
60 KiB
PHP
1738 lines
60 KiB
PHP
<?php
|
|
defined('ABSPATH') || die('No direct script access allowed!');
|
|
|
|
if (!class_exists('JuUpdater', false)) :
|
|
|
|
/**
|
|
* Class JuUpdater
|
|
* This class that holds most of the update plugin functionality for Media Folder.
|
|
*/
|
|
class JuUpdater
|
|
{
|
|
|
|
/**
|
|
* The URL of the plugin's metadata file.
|
|
*
|
|
* @var string
|
|
*/
|
|
public $metadataUrl = '';
|
|
|
|
/**
|
|
* Full path of the main plugin file.
|
|
*
|
|
* @var string
|
|
*/
|
|
public $pluginAbsolutePath = '';
|
|
|
|
/**
|
|
* Plugin filename relative to the plugins directory. Many WP APIs use this to identify plugins.
|
|
*
|
|
* @var string
|
|
*/
|
|
public $pluginFile = '';
|
|
|
|
/**
|
|
* Plugin slug.
|
|
*
|
|
* @var string
|
|
*/
|
|
public $slug = '';
|
|
|
|
/**
|
|
* How often to check for updates (in hours).
|
|
*
|
|
* @var string
|
|
*/
|
|
public $checkPeriod = 12;
|
|
|
|
/**
|
|
* Where to store the update info.
|
|
*
|
|
* @var string
|
|
*/
|
|
public $optionName = '';
|
|
|
|
/**
|
|
* For MU plugins, the plugin filename relative to the mu-plugins directory.
|
|
*
|
|
* @var string
|
|
*/
|
|
public $muPluginFile = '';
|
|
|
|
/**
|
|
* Set to TRUE to enable error reporting. Errors are raised using trigger_error()
|
|
*
|
|
* @var string
|
|
*/
|
|
public $debugMode = false;
|
|
|
|
/**
|
|
* Check less often if we already know that an update is available.
|
|
*
|
|
* @var string
|
|
*/
|
|
public $throttleRedundantChecks = false;
|
|
|
|
/**
|
|
* Full path of the main plugin file.
|
|
*
|
|
* @var string
|
|
*/
|
|
public $throttledCheckPeriod = 72;
|
|
|
|
/**
|
|
* Cron hook
|
|
*
|
|
* @var string
|
|
*/
|
|
private $cronHook = null;
|
|
|
|
/**
|
|
* Cache installed version
|
|
*
|
|
* @var string
|
|
*/
|
|
private $cachedInstalledVersion = null;
|
|
|
|
/**
|
|
* Juupdater version
|
|
*
|
|
* @var string
|
|
*/
|
|
public $juversion = '1.0.0';
|
|
|
|
/**
|
|
* JuUpdater constructor.
|
|
*
|
|
* @param string $metadataUrl Meta data URL
|
|
* @param string $pluginFile Plugin file
|
|
* @param string $slug Plugin slug
|
|
* @param integer $checkPeriod Check Period
|
|
* @param string $optionName Option Name
|
|
* @param string $muPluginFile MuPlugin file
|
|
*
|
|
* @return void
|
|
*/
|
|
public function __construct(
|
|
$metadataUrl,
|
|
$pluginFile,
|
|
$slug = '',
|
|
$checkPeriod = 12,
|
|
$optionName = '',
|
|
$muPluginFile = ''
|
|
) {
|
|
$this->metadataUrl = $metadataUrl;
|
|
$this->pluginAbsolutePath = $pluginFile;
|
|
$this->pluginFile = plugin_basename($this->pluginAbsolutePath);
|
|
$this->muPluginFile = $muPluginFile;
|
|
$this->checkPeriod = $checkPeriod;
|
|
$this->slug = $slug;
|
|
$this->optionName = $optionName;
|
|
$this->debugMode = defined('WP_DEBUG') && WP_DEBUG;
|
|
|
|
//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;
|
|
}
|
|
|
|
//Backwards compatibility: If the plugin is a mu-plugin but no $muPluginFile is specified, assume
|
|
//it's the same as $pluginFile given that it's not in a subdirectory (WP only looks in the base dir).
|
|
if (empty($this->muPluginFile) && (strpbrk($this->pluginFile, '/\\') === false) && $this->isMuPlugin()) {
|
|
$this->muPluginFile = $this->pluginFile;
|
|
}
|
|
|
|
|
|
$this->installHooks();
|
|
}
|
|
|
|
/**
|
|
* 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, 'maybeCheckForUpdates'));
|
|
|
|
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'));
|
|
add_action('load-update-core.php', array($this, 'maybeCheckForUpdates'));
|
|
add_action('load-plugins.php', array($this, 'maybeCheckForUpdates'));
|
|
add_action('load-update.php', array($this, 'maybeCheckForUpdates'));
|
|
//This hook fires after a bulk update is complete.
|
|
add_action('upgrader_process_complete', array($this, 'maybeCheckForUpdates'), 11, 0);
|
|
} else {
|
|
//Periodic checks are disabled.
|
|
wp_clear_scheduled_hook($this->cronHook);
|
|
}
|
|
|
|
//Rename the update directory to be the same as the existing directory.
|
|
add_filter('upgrader_source_selection', array($this, 'fixDirectoryName'), 10, 3);
|
|
add_action('admin_enqueue_scripts', array($this, 'juLoadCustomWpAdminScript'), 0);
|
|
add_action('wp_ajax_ju_add_token', array($this, 'juAddToken'));
|
|
add_action('wp_ajax_ju_logout', array($this, 'juLogout'));
|
|
|
|
add_action('admin_init', array($this, 'juAddButton'));
|
|
add_filter('http_response', array($this, 'httpResponse'), 10, 3);
|
|
}
|
|
|
|
/**
|
|
* Display a better error message when the plugin can't be updated
|
|
*
|
|
* @param array $response HTTP response.
|
|
* @param array $r HTTP request arguments.
|
|
* @param string $url The request URL.
|
|
*
|
|
* @return mixed
|
|
*/
|
|
public function httpResponse($response, $r, $url)
|
|
{
|
|
if (isset($response['headers']['x-ju-error'])) {
|
|
$response['response']['message'] = str_repeat(' ', 5) . $response['headers']['x-ju-error'];
|
|
}
|
|
return $response;
|
|
}
|
|
|
|
/**
|
|
* Add a connect button in settings page
|
|
*
|
|
* @return void
|
|
*/
|
|
public function juAddButton()
|
|
{
|
|
global $pagenow;
|
|
if ($pagenow === 'options-general.php') {
|
|
register_setting('JoomUnited live updates', '_ju_settings');
|
|
add_settings_section('juupdater-connect', '', array($this, 'showSettings'), 'general');
|
|
add_settings_field(
|
|
'joom_live_update',
|
|
'Live updates status',
|
|
array($this, 'joomConnect'),
|
|
'general',
|
|
'juupdater-connect'
|
|
);
|
|
add_thickbox();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Show setting title
|
|
*
|
|
* @return void
|
|
*/
|
|
public function showSettings()
|
|
{
|
|
echo '<h3>Joomunited live updates</h3>';
|
|
}
|
|
|
|
/**
|
|
* Show connect or disconnect button
|
|
*
|
|
* @return void
|
|
*/
|
|
public function joomConnect()
|
|
{
|
|
$token = get_option('ju_user_token');
|
|
if (empty($token)) {
|
|
echo '<p>To enable live update please link your joomunited account</p>';
|
|
$link = JU_BASE . 'index.php?option=com_juupdater&view=login&tmpl=component&site=' . admin_url() . '&TB_iframe=true&width=600&height=550';
|
|
echo '<a href="' . esc_html($link) . '" class="thickbox button">Link my Joomunited account</a>';
|
|
} else {
|
|
echo '<p>Live update are enabled click here if you want to disable it</p>';
|
|
echo '<span class="button button-primary ju-btn-disconnect">
|
|
Disconnect my Joomunited account</span>';
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Update token
|
|
*
|
|
* @return void
|
|
*/
|
|
public function juAddToken()
|
|
{
|
|
if (empty($_POST['ju_updater_nonce'])
|
|
|| !wp_verify_nonce($_POST['ju_updater_nonce'], 'ju_updater_nonce')) {
|
|
die();
|
|
}
|
|
|
|
if (!current_user_can('manage_options')) {
|
|
wp_send_json(array('status' => false, 'msg' => esc_html__('Not have permission!', 'wpmf')));
|
|
}
|
|
|
|
if (isset($_POST['token'])) {
|
|
update_option('ju_user_token', $_POST['token']);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Remove token
|
|
*
|
|
* @return void
|
|
*/
|
|
public function juLogout()
|
|
{
|
|
if (empty($_POST['ju_updater_nonce']) || !wp_verify_nonce($_POST['ju_updater_nonce'], 'ju_updater_nonce')) {
|
|
die();
|
|
}
|
|
update_option('ju_user_token', '');
|
|
}
|
|
|
|
/**
|
|
* Add script file
|
|
*
|
|
* @return void
|
|
*/
|
|
public function juLoadCustomWpAdminScript()
|
|
{
|
|
global $pagenow;
|
|
if ($pagenow === 'plugins.php' || $pagenow === 'options-general.php') {
|
|
wp_register_script(
|
|
'check_token',
|
|
plugins_url('/juupdater/js/check_token.js', dirname(__FILE__)),
|
|
array(),
|
|
$this->juversion
|
|
);
|
|
wp_enqueue_script('check_token');
|
|
}
|
|
|
|
if ($pagenow === 'update-core.php') {
|
|
wp_register_script(
|
|
'ju_update_core',
|
|
plugins_url('/juupdater/js/ju_update_core.js', dirname(__FILE__)),
|
|
array(),
|
|
$this->juversion
|
|
);
|
|
wp_enqueue_script('ju_update_core');
|
|
}
|
|
|
|
$params = $this->localizeScript();
|
|
wp_localize_script('check_token', 'updaterparams', $params);
|
|
wp_localize_script('ju_update_core', 'updaterparams', $params);
|
|
}
|
|
|
|
/**
|
|
* Localize a script.
|
|
*
|
|
* @return array
|
|
*/
|
|
public function localizeScript()
|
|
{
|
|
global $wp_version;
|
|
if (version_compare($wp_version, '4.8', '>=')) {
|
|
$version = '4.8.0';
|
|
} elseif (version_compare($wp_version, '4.6', '>=')) {
|
|
$version = '4.6.0';
|
|
} else {
|
|
$version = 'old';
|
|
}
|
|
$token = get_option('ju_user_token');
|
|
return array(
|
|
'ajaxurl' => admin_url('admin-ajax.php'),
|
|
'token' => $token,
|
|
'ju_base' => JU_BASE,
|
|
'ju_content_url' => admin_url(),
|
|
'version' => $version,
|
|
'ju_updater_nonce' => wp_create_nonce('ju_updater_nonce')
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Add our custom schedule to the array of Cron schedules used by WP.
|
|
*
|
|
* @param array $schedules Schedule
|
|
*
|
|
* @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.
|
|
*
|
|
* @return PluginInfo
|
|
*/
|
|
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);
|
|
|
|
$url = $this->metadataUrl;
|
|
if (!empty($queryArgs)) {
|
|
$url = add_query_arg($queryArgs, $url);
|
|
}
|
|
|
|
$result = wp_remote_get(
|
|
$url,
|
|
$options
|
|
);
|
|
|
|
//Try to parse the response
|
|
$pluginInfo = null;
|
|
if (!is_wp_error($result) && isset($result['response']['code'])
|
|
&& ($result['response']['code'] === 200) && !empty($result['body'])) {
|
|
$pluginInfo = JuPluginInfo::fromJson($result['body'], $this->debugMode);
|
|
if (empty($pluginInfo)) {
|
|
return null;
|
|
}
|
|
$pluginInfo->filename = $this->pluginFile;
|
|
$pluginInfo->slug = $this->slug;
|
|
}
|
|
|
|
$pluginInfo = apply_filters('puc_request_info_result-' . $this->slug, $pluginInfo, $result);
|
|
return $pluginInfo;
|
|
}
|
|
|
|
/**
|
|
* Retrieve the latest update (if any) from the configured API endpoint.
|
|
*
|
|
* @uses PluginUpdateChecker::requestInfo()
|
|
*
|
|
* @return PluginUpdate An instance of PluginUpdate, or NULL when no updates are available.
|
|
*/
|
|
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 JuPluginUpdate::fromPluginInfo($pluginInfo);
|
|
}
|
|
|
|
/**
|
|
* Get the currently installed version of the plugin.
|
|
*
|
|
* @return string Version number.
|
|
*/
|
|
public function getInstalledVersion()
|
|
{
|
|
if (isset($this->cachedInstalledVersion)) {
|
|
return $this->cachedInstalledVersion;
|
|
}
|
|
|
|
$pluginHeader = $this->getPluginHeader();
|
|
if (isset($pluginHeader['Version'])) {
|
|
$this->cachedInstalledVersion = $pluginHeader['Version'];
|
|
return $pluginHeader['Version'];
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get plugin's metadata from its file header.
|
|
*
|
|
* @return array
|
|
*/
|
|
protected function getPluginHeader()
|
|
{
|
|
if (!is_file($this->pluginAbsolutePath)) {
|
|
//This can happen if the plugin filename is wrong.
|
|
return array();
|
|
}
|
|
|
|
if (!function_exists('get_plugin_data')) {
|
|
require_once(ABSPATH . '/wp-admin/includes/plugin.php');
|
|
}
|
|
return get_plugin_data($this->pluginAbsolutePath, false, false);
|
|
}
|
|
|
|
/**
|
|
* Check for plugin updates.
|
|
* The results are stored in the DB option specified in $optionName.
|
|
*
|
|
* @return PluginUpdate|null
|
|
*/
|
|
public function checkForUpdates()
|
|
{
|
|
$installedVersion = $this->getInstalledVersion();
|
|
//Fail silently if we can't find the plugin or read its header.
|
|
if ($installedVersion === null) {
|
|
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;
|
|
//Save before checking in case something goes wrong
|
|
$this->setUpdateState($state);
|
|
|
|
$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" or when doing cron.
|
|
*
|
|
* You can override the default behaviour by using the "puc_check_now-$slug" filter.
|
|
* The filter callback will be passed three parameters:
|
|
* - Current decision. TRUE = check updates now, FALSE = don't check now.
|
|
* - Last check time as a Unix timestamp.
|
|
* - Configured check period in hours.
|
|
* Return TRUE to check for updates immediately, or FALSE to cancel.
|
|
*
|
|
* This method is declared public because it's a hook callback. Calling it directly is not recommended.
|
|
*
|
|
* @return void
|
|
*/
|
|
public function maybeCheckForUpdates()
|
|
{
|
|
if (empty($this->checkPeriod)) {
|
|
return;
|
|
}
|
|
|
|
$currentFilter = current_filter();
|
|
if (in_array($currentFilter, array('load-update-core.php', 'upgrader_process_complete'))) {
|
|
//Check more often when the user visits "Dashboard -> Updates" or does a bulk update.
|
|
$timeout = 60;
|
|
} elseif (in_array($currentFilter, array('load-plugins.php', 'load-update.php'))) {
|
|
//Also check more often on the "Plugins" page and /wp-admin/update.php.
|
|
$timeout = 3600;
|
|
} elseif ($this->throttleRedundantChecks && ($this->getUpdate() !== null)) {
|
|
//Check less frequently if it's already known that an update is available.
|
|
$timeout = $this->throttledCheckPeriod * 3600;
|
|
} elseif (defined('DOING_CRON') && constant('DOING_CRON')) {
|
|
//WordPress cron schedules are not exact, so lets do an update check even
|
|
//if slightly less than $checkPeriod hours have elapsed since the last check.
|
|
$cronFuzziness = 20 * 60;
|
|
$timeout = $this->checkPeriod * 3600 - $cronFuzziness;
|
|
} else {
|
|
$timeout = $this->checkPeriod * 3600;
|
|
}
|
|
|
|
$state = $this->getUpdateState();
|
|
$shouldCheck = empty($state) ||
|
|
!isset($state->lastCheck) ||
|
|
((time() - $state->lastCheck) >= $timeout);
|
|
|
|
//Let plugin authors substitute their own algorithm.
|
|
if ((!empty($state) && isset($state->lastCheck))) {
|
|
$lc = $state->lastCheck;
|
|
} else {
|
|
$lc = 0;
|
|
}
|
|
$shouldCheck = apply_filters(
|
|
'puc_check_now-' . $this->slug,
|
|
$shouldCheck,
|
|
$lc,
|
|
$this->checkPeriod
|
|
);
|
|
|
|
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 = JuPluginUpdate::fromObject($state->update);
|
|
}
|
|
return $state;
|
|
}
|
|
|
|
/**
|
|
* Persist the update checker state to the DB.
|
|
*
|
|
* @param StdClass $state State
|
|
*
|
|
* @return void
|
|
*/
|
|
private function setUpdateState($state)
|
|
{
|
|
if (isset($state->update) && is_object($state->update) && method_exists($state->update, 'toStdClass')) {
|
|
$update = $state->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.
|
|
*
|
|
* @return void
|
|
*/
|
|
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 Result
|
|
* @param string $action Action
|
|
* @param array|object $args Params
|
|
*
|
|
* @return mixed
|
|
*/
|
|
public function injectInfo($result, $action = null, $args = null)
|
|
{
|
|
$relevant = ($action === 'plugin_information') && isset($args->slug) && (
|
|
($args->slug === $this->slug) || ($args->slug === dirname($this->pluginFile))
|
|
);
|
|
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();
|
|
//No update notifications for mu-plugins unless explicitly enabled. The MU plugin file
|
|
//is usually different from the main plugin file so the update wouldn't show up properly anyway.
|
|
if (!empty($update) && empty($this->muPluginFile) && $this->isMuPlugin()) {
|
|
$update = null;
|
|
}
|
|
|
|
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();
|
|
}
|
|
|
|
$wpUpdate = $update->toWpFormat();
|
|
$pluginFile = $this->pluginFile;
|
|
|
|
if ($this->isMuPlugin()) {
|
|
/**
|
|
* WP does not support automatic update installation for mu-plugins,
|
|
* but we can still display a notice.
|
|
*/
|
|
$wpUpdate->package = null;
|
|
$pluginFile = $this->muPluginFile;
|
|
}
|
|
$updates->response[$pluginFile] = $wpUpdate;
|
|
} elseif (isset($updates, $updates->response)) {
|
|
unset($updates->response[$this->pluginFile]);
|
|
if (!empty($this->muPluginFile)) {
|
|
unset($updates->response[$this->muPluginFile]);
|
|
}
|
|
}
|
|
|
|
return $updates;
|
|
}
|
|
|
|
/**
|
|
* Rename the update directory to match the existing plugin directory.
|
|
*
|
|
* When WordPress installs a plugin or theme update, it assumes that the ZIP file will contain
|
|
* exactly one directory, and that the directory name will be the same as the directory where
|
|
* the plugin/theme is currently installed.
|
|
*
|
|
* GitHub and other repositories provide ZIP downloads, but they often use directory names like
|
|
* "project-branch" or "project-tag-hash". We need to change the name to the actual plugin folder.
|
|
*
|
|
* @param string $source The directory to copy to /wp-content/plugins. Usually a subdirectory of $remoteSource.
|
|
* @param string $remoteSource WordPress has extracted the update to this directory.
|
|
* @param WP_Upgrader $upgrader Upgrader
|
|
*
|
|
* @return string|WP_Error
|
|
*/
|
|
public function fixDirectoryName($source, $remoteSource, $upgrader)
|
|
{
|
|
global $wp_filesystem;
|
|
//Basic sanity checks.
|
|
if (!isset($source, $remoteSource, $upgrader, $upgrader->skin, $wp_filesystem)) {
|
|
return $source;
|
|
}
|
|
|
|
//Figure out which plugin is being upgraded.
|
|
$pluginFile = null;
|
|
$skin = $upgrader->skin;
|
|
if ($skin instanceof Plugin_Upgrader_Skin) {
|
|
if (isset($skin->plugin) && is_string($skin->plugin) && ($skin->plugin !== '')) {
|
|
$pluginFile = $skin->plugin;
|
|
}
|
|
} elseif (isset($skin->plugin_info) && is_array($skin->plugin_info)) {
|
|
//This case is tricky because Bulk_Plugin_Upgrader_Skin (etc) doesn't actually store the plugin
|
|
//filename anywhere. Instead, it has the plugin headers in $plugin_info. So the best we can
|
|
//do is compare those headers to the headers of installed plugins.
|
|
if (!function_exists('get_plugins')) {
|
|
require_once(ABSPATH . '/wp-admin/includes/plugin.php');
|
|
}
|
|
$installedPlugins = get_plugins();
|
|
$matches = array();
|
|
foreach ($installedPlugins as $pluginBasename => $headers) {
|
|
$diff1 = array_diff_assoc($headers, $skin->plugin_info);
|
|
$diff2 = array_diff_assoc($skin->plugin_info, $headers);
|
|
if (empty($diff1) && empty($diff2)) {
|
|
$matches[] = $pluginBasename;
|
|
}
|
|
}
|
|
//It's possible (though very unlikely) that there could be two plugins with identical
|
|
//headers. In that case, we can't unambiguously identify the plugin that's being upgraded.
|
|
if (count($matches) !== 1) {
|
|
return $source;
|
|
}
|
|
$pluginFile = reset($matches);
|
|
} elseif (!empty($this->upgradedPluginFile)) {
|
|
$pluginFile = $this->upgradedPluginFile;
|
|
}
|
|
//If WordPress is upgrading anything other than our plugin, leave the directory name unchanged.
|
|
if (empty($pluginFile) || ($pluginFile !== $this->pluginFile)) {
|
|
return $source;
|
|
}
|
|
//Rename the source to match the existing plugin directory.
|
|
$pluginDirectoryName = dirname($this->pluginFile);
|
|
if (($pluginDirectoryName === '.') || ($pluginDirectoryName === '/')) {
|
|
return $source;
|
|
}
|
|
$correctedSource = trailingslashit($remoteSource) . $pluginDirectoryName . '/';
|
|
if ($source !== $correctedSource) {
|
|
/**
|
|
* The update archive should contain a single directory
|
|
* that contains the rest of plugin files. Otherwise,
|
|
* WordPress will try to copy the entire working directory ($source == $remoteSource). We can't rename
|
|
* $remoteSource because that would break WordPress code that cleans up temporary files after update.
|
|
*/
|
|
|
|
$sourceFiles = $wp_filesystem->dirlist($remoteSource);
|
|
if (is_array($sourceFiles)) {
|
|
$sourceFiles = array_keys($sourceFiles);
|
|
$firstFilePath = trailingslashit($remoteSource) . $sourceFiles[0];
|
|
|
|
if ((count($sourceFiles) > 1) || (!$wp_filesystem->is_dir($firstFilePath))) {
|
|
return new WP_Error(
|
|
'puc-incorrect-directory-structure',
|
|
sprintf(
|
|
'The directory structure of the update is incorrect.
|
|
All plugin files should be inside ' .
|
|
'a directory named <span class="code">%s</span>,
|
|
not at the root of the ZIP file.',
|
|
htmlentities($this->slug, ENT_COMPAT, 'UTF-8')
|
|
)
|
|
);
|
|
}
|
|
}
|
|
|
|
$upgrader->skin->feedback(sprintf(
|
|
'Renaming %s to %s…',
|
|
'<span class="code">' . basename($source) . '</span>',
|
|
'<span class="code">' . $pluginDirectoryName . '</span>'
|
|
));
|
|
|
|
if ($wp_filesystem->move($source, $correctedSource, true)) {
|
|
$upgrader->skin->feedback('Plugin directory successfully renamed.');
|
|
return $correctedSource;
|
|
} else {
|
|
return new WP_Error(
|
|
'puc-rename-failed',
|
|
'Unable to rename the update to match the existing plugin directory.'
|
|
);
|
|
}
|
|
}
|
|
|
|
return $source;
|
|
}
|
|
|
|
/**
|
|
* 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 PluginUpdate|null
|
|
*/
|
|
public function getUpdate()
|
|
{
|
|
$state = $this->getUpdateState();
|
|
//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, '>')) {
|
|
$update->filename = $this->pluginFile;
|
|
return $update;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* 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 Plugin file
|
|
*
|
|
* @return array
|
|
*/
|
|
public function addCheckForUpdatesLink($pluginMeta, $pluginFile)
|
|
{
|
|
$isRelevant = ($pluginFile === $this->pluginFile) || (!empty($this->muPluginFile)
|
|
&& $pluginFile === $this->muPluginFile);
|
|
|
|
/**
|
|
* Filter check capability of current user to update plugins
|
|
*
|
|
* @param boolean The current user has the given capability
|
|
* @param string Action name
|
|
*
|
|
* @return boolean
|
|
*
|
|
* @ignore Hook already documented
|
|
*/
|
|
$updater_capability = apply_filters('ju_updater_user_can', current_user_can('update_plugins'), 'update_plugins');
|
|
if ($isRelevant && $updater_capability) {
|
|
$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);
|
|
}
|
|
|
|
$ju_token = get_option('ju_user_token');
|
|
$link = JU_BASE . 'index.php?option=com_juupdater&view=login&tmpl=component&site=' . admin_url() . '
|
|
&TB_iframe=true&width=300&height=305';
|
|
|
|
if (empty($ju_token)) {
|
|
$pluginMeta[] = sprintf(
|
|
'<span style="color: #ff6200" class="dashicons dashicons-warning"></span>In order to access updates please link your account : <a class="thickbox ju_update" href="%s">%s</a>',
|
|
esc_attr($link),
|
|
'JoomUnited Login'
|
|
);
|
|
}
|
|
}
|
|
return $pluginMeta;
|
|
}
|
|
|
|
/**
|
|
* Check for updates when the user clicks the "Check for updates" link.
|
|
*
|
|
* @see self::addCheckForUpdatesLink()
|
|
*
|
|
* @return void
|
|
*/
|
|
public function handleManualCheck()
|
|
{
|
|
/**
|
|
* Filter check capability of current user to update plugins
|
|
*
|
|
* @param boolean The current user has the given capability
|
|
* @param string Action name
|
|
*
|
|
* @return boolean
|
|
*
|
|
* @ignore Hook already documented
|
|
*/
|
|
$updater_capability = apply_filters('ju_updater_user_can', current_user_can('update_plugins'), 'update_plugins');
|
|
// phpcs:ignore WordPress.Security.NonceVerification.Recommended -- No action, nonce is not required
|
|
$shouldCheck = isset($_GET['puc_check_for_updates'], $_GET['puc_slug']) && $_GET['puc_slug'] === $this->slug && $updater_capability && 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 self::handleManualCheck()
|
|
*
|
|
* You can change the result message by using the "puc_manual_check_message-$slug" filter.
|
|
*
|
|
* @return void
|
|
*/
|
|
public function displayManualCheckResult()
|
|
{
|
|
// phpcs:ignore WordPress.Security.NonceVerification.Recommended -- No action, nonce is not required
|
|
if (isset($_GET['puc_update_check_result'], $_GET['puc_slug']) && ($_GET['puc_slug'] === $this->slug)) {
|
|
// phpcs:ignore WordPress.Security.NonceVerification.Recommended -- No action, nonce is not required
|
|
$status = strval($_GET['puc_update_check_result']);
|
|
if ($status === 'no_update') {
|
|
$message = 'This plugin is up to date.';
|
|
} elseif ($status === 'update_available') {
|
|
$message = 'A new version of this plugin is available.';
|
|
} else {
|
|
$message = sprintf('Unknown update checker status "%s"', htmlentities($status, ENT_COMPAT, 'UTF-8'));
|
|
}
|
|
printf(
|
|
'<div class="updated"><p>%s</p></div>',
|
|
esc_html(apply_filters('puc_manual_check_message-' . $this->slug, $message, $status))
|
|
);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Check if the plugin file is inside the mu-plugins directory.
|
|
*
|
|
* @return boolean
|
|
*/
|
|
protected function isMuPlugin()
|
|
{
|
|
static $cachedResult = null;
|
|
|
|
if ($cachedResult === null) {
|
|
//Convert both paths to the canonical form before comparison.
|
|
$muPluginDir = realpath(WPMU_PLUGIN_DIR);
|
|
$pluginPath = realpath($this->pluginAbsolutePath);
|
|
if (false === $muPluginDir) {
|
|
// mu-plugins not exists, fix strpos warning on php 7.3
|
|
return false;
|
|
}
|
|
$cachedResult = (strpos($pluginPath, $muPluginDir) === 0);
|
|
}
|
|
|
|
return $cachedResult;
|
|
}
|
|
|
|
/**
|
|
* 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 Filter argument
|
|
*
|
|
* @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 Callback
|
|
*
|
|
* @return void
|
|
*/
|
|
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 Callback
|
|
*
|
|
* @return void
|
|
*/
|
|
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 Callback
|
|
*
|
|
* @return void
|
|
*/
|
|
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 Tag
|
|
* @param callable $callback Callback
|
|
* @param integer $priority Priority
|
|
* @param integer $acceptedArgs AcceptedArgs
|
|
*
|
|
* @return void
|
|
*/
|
|
public function addFilter($tag, $callback, $priority = 10, $acceptedArgs = 1)
|
|
{
|
|
add_filter('puc_' . $tag . '-' . $this->slug, $callback, $priority, $acceptedArgs);
|
|
}
|
|
}
|
|
|
|
endif;
|
|
|
|
if (!class_exists('JuPluginInfo', false)) :
|
|
|
|
/**
|
|
* A container class for holding and transforming various plugin metadata.
|
|
*/
|
|
#[AllowDynamicProperties]
|
|
class JuPluginInfo // phpcs:ignore Generic.Files.OneClassPerFile.MultipleFound -- some classes have no function
|
|
{
|
|
|
|
/**
|
|
* Plugin name
|
|
*
|
|
* @var string
|
|
*/
|
|
public $name;
|
|
|
|
/**
|
|
* Plugin slug
|
|
*
|
|
* @var string
|
|
*/
|
|
public $slug;
|
|
|
|
/**
|
|
* Plugin version
|
|
*
|
|
* @var string
|
|
*/
|
|
public $version;
|
|
|
|
/**
|
|
* Plugin icon
|
|
*
|
|
* @var array
|
|
*/
|
|
public $icons = array();
|
|
|
|
/**
|
|
* Plugin homepage
|
|
*
|
|
* @var string
|
|
*/
|
|
public $homepage;
|
|
|
|
/**
|
|
* Plugin section
|
|
*
|
|
* @var string
|
|
*/
|
|
public $sections;
|
|
|
|
/**
|
|
* Plugin banners
|
|
*
|
|
* @var string
|
|
*/
|
|
public $banners;
|
|
|
|
/**
|
|
* Plugin download uRL
|
|
*
|
|
* @var string
|
|
*/
|
|
public $download_url;
|
|
|
|
/**
|
|
* Plugin author
|
|
*
|
|
* @var string
|
|
*/
|
|
public $author;
|
|
|
|
/**
|
|
* Plugin author homepage
|
|
*
|
|
* @var string
|
|
*/
|
|
public $author_homepage;
|
|
|
|
/**
|
|
* Plugin requires
|
|
*
|
|
* @var string
|
|
*/
|
|
public $requires;
|
|
|
|
/**
|
|
* Plugin testted
|
|
*
|
|
* @var string
|
|
*/
|
|
public $tested;
|
|
|
|
/**
|
|
* Plugin upgrade notice
|
|
*
|
|
* @var string
|
|
*/
|
|
public $upgrade_notice;
|
|
|
|
/**
|
|
* Plugin rating
|
|
*
|
|
* @var string
|
|
*/
|
|
public $rating;
|
|
|
|
/**
|
|
* Plugin num ratings
|
|
*
|
|
* @var string
|
|
*/
|
|
public $num_ratings;
|
|
|
|
/**
|
|
* Plugin downloaded
|
|
*
|
|
* @var string
|
|
*/
|
|
public $downloaded;
|
|
|
|
/**
|
|
* Plugin active installs
|
|
*
|
|
* @var string
|
|
*/
|
|
public $active_installs;
|
|
|
|
/**
|
|
* Plugin last updated
|
|
*
|
|
* @var string
|
|
*/
|
|
public $last_updated;
|
|
|
|
/**
|
|
* The native WP.org API returns numeric plugin IDs, but they're not used for anything.
|
|
*
|
|
* @var integer
|
|
*/
|
|
public $id = 0;
|
|
|
|
/**
|
|
* Plugin filename relative to the plugins directory.
|
|
*
|
|
* @var string
|
|
*/
|
|
public $filename;
|
|
|
|
/**
|
|
* 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 boolean $triggerErrors Trigger rrrors
|
|
*
|
|
* @return JuPluginInfo|null|PluginInfo
|
|
*/
|
|
public static function fromJson($json, $triggerErrors = false)
|
|
{
|
|
$apiResponse = json_decode($json);
|
|
if (empty($apiResponse) || !is_object($apiResponse)) {
|
|
return null;
|
|
}
|
|
|
|
//Very, very basic validation.
|
|
$valid = isset($apiResponse->name) && !empty($apiResponse->name)
|
|
&& isset($apiResponse->version) && !empty($apiResponse->version);
|
|
if (!$valid) {
|
|
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',
|
|
'active_installs',
|
|
'homepage',
|
|
'last_updated',
|
|
);
|
|
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' => '');
|
|
}
|
|
|
|
if (!empty($this->banners)) {
|
|
//WP expects an array with two keys: "high" and "low". Both are optional.
|
|
//Docs: https://wordpress.org/plugins/about/faq/#banners
|
|
$info->banners = is_object($this->banners) ? get_object_vars($this->banners) : $this->banners;
|
|
$info->banners = array_intersect_key($info->banners, array('high' => true, 'low' => true));
|
|
}
|
|
|
|
return $info;
|
|
}
|
|
}
|
|
|
|
endif;
|
|
|
|
if (!class_exists('JuPluginUpdate', false)) :
|
|
|
|
/**
|
|
* A simple container class for holding information about an available update.
|
|
*/
|
|
class JuPluginUpdate // phpcs:ignore Generic.Files.OneClassPerFile.MultipleFound -- some classes have no function
|
|
{
|
|
|
|
/**
|
|
* Plugin id
|
|
*
|
|
* @var integer
|
|
*/
|
|
public $id = 0;
|
|
|
|
/**
|
|
* Plugin slug
|
|
*
|
|
* @var string
|
|
*/
|
|
public $slug;
|
|
|
|
/**
|
|
* Plugin version
|
|
*
|
|
* @var string
|
|
*/
|
|
public $version;
|
|
|
|
/**
|
|
* WP tested version
|
|
*
|
|
* @var string
|
|
*/
|
|
public $tested;
|
|
|
|
/**
|
|
* Plugin homepage
|
|
*
|
|
* @var string
|
|
*/
|
|
public $homepage;
|
|
|
|
/**
|
|
* Plugin download url
|
|
*
|
|
* @var string
|
|
*/
|
|
public $download_url;
|
|
|
|
/**
|
|
* Plugin upgrade notice
|
|
*
|
|
* @var string
|
|
*/
|
|
public $upgrade_notice;
|
|
|
|
/**
|
|
* Plugin icon
|
|
*
|
|
* @var array
|
|
*/
|
|
public $icons = array();
|
|
|
|
/**
|
|
* Plugin filename relative to the plugins directory.
|
|
*
|
|
* @var string
|
|
*/
|
|
public $filename;
|
|
|
|
/**
|
|
* Plugin default fields
|
|
*
|
|
* @var array
|
|
*/
|
|
private static $fields = array(
|
|
'id',
|
|
'slug',
|
|
'version',
|
|
'tested',
|
|
'homepage',
|
|
'download_url',
|
|
'upgrade_notice',
|
|
'filename',
|
|
'icons'
|
|
);
|
|
|
|
/**
|
|
* Create a new instance of PluginUpdate from its JSON-encoded representation.
|
|
*
|
|
* @param string $json Json
|
|
* @param boolean $triggerErrors Trigger errors
|
|
*
|
|
* @return 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 = JuPluginInfo::fromJson($json, $triggerErrors);
|
|
if ($pluginInfo !== null) {
|
|
return self::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 PluginInfo $info Plugin infomations
|
|
*
|
|
* @return PluginUpdate
|
|
*/
|
|
public static function fromPluginInfo($info)
|
|
{
|
|
return self::fromObject($info);
|
|
}
|
|
|
|
/**
|
|
* Create a new instance of PluginUpdate by copying the necessary fields from
|
|
* another object.
|
|
*
|
|
* @param StdClass|PluginInfo|PluginUpdate $object The source object.
|
|
*
|
|
* @return JuPluginUpdate|PluginUpdate
|
|
*/
|
|
public static function fromObject($object)
|
|
{
|
|
$update = new self();
|
|
$fields = self::$fields;
|
|
if (!empty($object->slug)) {
|
|
$fields = apply_filters('puc_retain_fields-' . $object->slug, $fields);
|
|
}
|
|
|
|
foreach ($fields as $field) {
|
|
if (property_exists($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();
|
|
$fields = self::$fields;
|
|
if (!empty($this->slug)) {
|
|
$fields = apply_filters('puc_retain_fields-' . $this->slug, $fields);
|
|
}
|
|
|
|
foreach ($fields as $field) {
|
|
if (property_exists($this, $field)) {
|
|
$object->$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;
|
|
$token = get_option('ju_user_token');
|
|
$update->id = $this->id;
|
|
$update->slug = $this->slug;
|
|
$update->new_version = $this->version;
|
|
$update->tested = $this->tested;
|
|
$update->url = $this->homepage;
|
|
if (!empty($token)) {
|
|
$update->package = $this->download_url . '&token=' . $token . '&siteurl=' . get_option('siteurl');
|
|
} else {
|
|
$update->package = $this->download_url;
|
|
}
|
|
$update->plugin = $this->filename;
|
|
if (!empty($this->upgrade_notice)) {
|
|
$update->upgrade_notice = $this->upgrade_notice;
|
|
}
|
|
|
|
if (!empty($this->icons)) {
|
|
$update->icons = is_object($this->icons) ? get_object_vars($this->icons) : $this->icons;
|
|
$update->icons = array_intersect_key($update->icons, array('svg' => true, '1x' => true, '2x' => true, 'default' => true));
|
|
}
|
|
return $update;
|
|
}
|
|
}
|
|
|
|
endif;
|
|
|
|
if (!class_exists('Jufactory', 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 Jufactory::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 Jufactory::getLatestClassVersion()}
|
|
* to get the class name and then create it with <code>new $class(...)</code>.
|
|
*/
|
|
class Jufactory // phpcs:ignore Generic.Files.OneClassPerFile.MultipleFound -- some classes have no function
|
|
{
|
|
|
|
/**
|
|
* Class versions
|
|
*
|
|
* @var array
|
|
*/
|
|
protected static $classVersions = array();
|
|
|
|
/**
|
|
* Check sorted
|
|
*
|
|
* @var boolean
|
|
*/
|
|
protected static $sorted = false;
|
|
|
|
/**
|
|
* Create a new instance of PluginUpdateChecker.
|
|
*
|
|
* @param array $metadataUrl Meta data Url
|
|
* @param string $pluginFile Plugin file
|
|
* @param string $slug Slug of plugin
|
|
* @param integer $checkPeriod Check Period
|
|
* @param string $optionName Option name
|
|
* @param string $muPluginFile Mu plugin file
|
|
*
|
|
* @return PluginUpdateChecker
|
|
*/
|
|
public static function buildUpdateChecker(
|
|
$metadataUrl,
|
|
$pluginFile,
|
|
$slug = '',
|
|
$checkPeriod = 12,
|
|
$optionName = '',
|
|
$muPluginFile = ''
|
|
) {
|
|
$class = self::getLatestClassVersion('PluginUpdateChecker');
|
|
return new $class($metadataUrl, $pluginFile, $slug, $checkPeriod, $optionName, $muPluginFile);
|
|
}
|
|
|
|
/**
|
|
* Get the specific class name for the latest available version of a class.
|
|
*
|
|
* @param string $class Class
|
|
*
|
|
* @return string|null
|
|
*/
|
|
public static function getLatestClassVersion($class)
|
|
{
|
|
if (!self::$sorted) {
|
|
self::sortVersions();
|
|
}
|
|
|
|
if (isset(self::$classVersions[$class])) {
|
|
return reset(self::$classVersions[$class]);
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Sort available class versions in descending order (i.e. newest first).
|
|
*
|
|
* @return void
|
|
*/
|
|
protected static function sortVersions()
|
|
{
|
|
foreach (self::$classVersions as $class => $versions) {
|
|
uksort($versions, array(__CLASS__, 'compareVersions'));
|
|
self::$classVersions[$class] = $versions;
|
|
}
|
|
self::$sorted = true;
|
|
}
|
|
|
|
/**
|
|
* Compare versions
|
|
*
|
|
* @param string $a Version
|
|
* @param string $b Version
|
|
*
|
|
* @return mixed
|
|
*/
|
|
protected static function compareVersions($a, $b)
|
|
{
|
|
return - version_compare($a, $b);
|
|
}
|
|
|
|
/**
|
|
* Register a version of a class.
|
|
*
|
|
* @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'.
|
|
*
|
|
* @return void
|
|
*/
|
|
public static function addVersion($generalClass, $versionedClass, $version)
|
|
{
|
|
if (!isset(self::$classVersions[$generalClass])) {
|
|
self::$classVersions[$generalClass] = array();
|
|
}
|
|
self::$classVersions[$generalClass][$version] = $versionedClass;
|
|
self::$sorted = false;
|
|
}
|
|
}
|
|
|
|
endif;
|
|
|
|
//Register classes defined in this file with the factory.
|
|
Jufactory::addVersion('PluginUpdateChecker', 'JuUpdater', '2.1');
|
|
Jufactory::addVersion('PluginUpdate', 'JuPluginUpdate', '2.1');
|
|
Jufactory::addVersion('PluginInfo', 'JuPluginInfo', '2.1');
|
|
|
|
/**
|
|
* 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('PluginUpdateChecker', false)) {
|
|
|
|
/**
|
|
* Class PluginUpdateChecker
|
|
*/
|
|
class PluginUpdateChecker extends JuUpdater // phpcs:ignore Generic.Files.OneClassPerFile.MultipleFound -- some classes have no function
|
|
{
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!class_exists('PluginUpdate', false)) {
|
|
|
|
/**
|
|
* Class PluginUpdate
|
|
*/
|
|
class PluginUpdate extends JuPluginUpdate // phpcs:ignore Generic.Files.OneClassPerFile.MultipleFound -- some classes have no function
|
|
{
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!class_exists('PluginInfo', false)) {
|
|
|
|
/**
|
|
* Class PluginInfo
|
|
*/
|
|
class PluginInfo extends JuPluginInfo // phpcs:ignore Generic.Files.OneClassPerFile.MultipleFound -- some classes have no function
|
|
{
|
|
|
|
}
|
|
|
|
}
|