File: /data/www/welovefamily.at/welovefamily.at/htdocs_tmp/wp-content/plugins/liupdatecenter/puc.php
<?php
if (! class_exists('LiUpdateCenter_PluginUpdateChecker_1_6')):
class LiUpdateCenter_PluginUpdateChecker_1_6
{
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 $muPluginFile = ''; // For MU plugins, the plugin filename relative to the mu-plugins directory.
public $debugMode = false; // Set to TRUE to enable error reporting. Errors are raised using trigger_error()
public $errors = [];
public $throttleRedundantChecks = false; // Check less often if we already know that an update is available.
public $throttledCheckPeriod = 72;
private $cronHook = null;
private $debugBarPlugin = null;
private $cachedInstalledVersion = null;
/**
* @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'.
* @param string $muPluginFile Optional. The plugin filename relative to the mu-plugins directory.
*/
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 = $this->debugMode && defined('WP_DEBUG') && WP_DEBUG;
// If no slug is specified, use the name of the main plugin file as the slug.
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.
*/
protected function installHooks()
{
// Override requests for plugin information
add_filter('plugins_api', [$this, 'injectInfo'], 20, 3);
// Insert our update info into the update array maintained by WP
add_filter('site_transient_update_plugins', [$this, 'injectUpdate']); // WP 3.0+
add_filter('transient_update_plugins', [$this, 'injectUpdate']); // WP 2.8+
add_filter('plugin_row_meta', [$this, 'addCheckForUpdatesLink'], 10, 2);
add_action('admin_init', [$this, 'handleManualCheck']);
add_action('all_admin_notices', [$this, 'displayManualCheckResult']);
// Clear the version number cache when something - anything - is upgraded or WP clears the update cache.
add_filter('upgrader_post_install', [$this, 'clearCachedVersion']);
add_action('delete_site_transient_update_plugins', [$this, 'clearCachedVersion']);
// If Wordpress checks for Updates during a wp-cli call, we should check as well.
if (defined('WP_CLI') && WP_CLI) {
add_filter('pre_set_site_transient_update_plugins', function ($value) {
$this->wpcliCheckForUpdates();
return $value;
});
}
// 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 = [
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', [$this, '_addCustomSchedule']);
}
if (! wp_next_scheduled($this->cronHook) && ! defined('WP_INSTALLING')) {
wp_schedule_event(time(), $scheduleName, $this->cronHook);
}
add_action($this->cronHook, [$this, 'maybeCheckForUpdates']);
register_deactivation_hook($this->pluginFile, [$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', [$this, 'maybeCheckForUpdates']);
// Like WordPress itself, we check more often on certain pages.
add_action('load-update-core.php', [$this, 'maybeCheckForUpdates']);
} else {
// Periodic checks are disabled.
wp_clear_scheduled_hook($this->cronHook);
}
if (did_action('plugins_loaded')) {
$this->initDebugBarPanel();
return;
}
add_action('plugins_loaded', [$this, 'initDebugBarPanel']);
}
/**
* 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] = [
'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 LiUpdateCenter_PluginInfo
*/
public function requestInfo($queryArgs = [])
{
// 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);
$options = [
'timeout' => 10, // seconds
'headers' => [
'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);
}
$pluginInfo = null;
$response = wp_remote_get($url, $options);
$code = wp_remote_retrieve_response_code($response);
$body = wp_remote_retrieve_body($response);
if ($code == 200 && ! empty($body)) {
$pluginInfo = LiUpdateCenter_PluginInfo_1_6::fromJson($body, $this->debugMode, $this->errors);
$pluginInfo->filename = $this->pluginFile;
} else {
$message = sprintf("The URL %s does not point to a valid plugin metadata file. ", $url);
if (is_wp_error($response)) {
$message .= "WP HTTP error: " . $response->get_error_message();
} elseif ($code != 200) {
$message .= "HTTP response code was " . $code . ".";
} else {
$message .= "wp_remote_get() returned an unexpected result.";
}
$this->errors[] = ['message' => $message, 'body' => $body];
if ($this->debugMode) {
trigger_error($message, E_USER_WARNING);
}
}
$pluginInfo = apply_filters('puc_request_info_result-' . $this->slug, $pluginInfo, $response);
return $pluginInfo;
}
/**
* Retrieve the latest update (if any) from the configured API endpoint.
* @uses LiUpdateCenter_PluginUpdateChecker::requestInfo()
* @return LiUpdateCenter_PluginUpdate An instance of LiUpdateCenter_PluginUpdate, or NULL when no updates are available.
*/
public function requestUpdate()
{
$pluginInfo = $this->requestInfo(['checking_for_updates' => '1']);
return $pluginInfo !== null ? LiUpdateCenter_PluginUpdate_1_6::fromPluginInfo($pluginInfo) : null;
}
/**
* Get the currently installed version of the plugin.
* @return string Version number.
*/
public function getInstalledVersion()
{
if (isset($this->cachedInstalledVersion)) {
return $this->cachedInstalledVersion;
}
if (! function_exists('get_plugin_data')) {
require_once(ABSPATH . '/wp-admin/includes/plugin.php');
}
if (! is_file($this->pluginAbsolutePath)) {
// This can happen if the plugin filename is wrong.
$message = sprintf("Can't read the Version header for %s. The file does not exist.", $this->pluginFile);
$this->errors[] = ['message' => $message];
if ($this->debugMode) {
trigger_error($message, E_USER_WARNING);
}
return null;
}
$pluginHeader = get_plugin_data($this->pluginAbsolutePath, false, false);
if (isset($pluginHeader['Version'])) {
$this->cachedInstalledVersion = $pluginHeader['Version'];
return $pluginHeader['Version'];
}
// This can happen if the filename points to something that is not a plugin.
$message = sprintf("Can't read the Version header for %s. The filename is incorrect or is not a plugin.", $this->pluginFile);
$this->errors[] = ['message' => $message];
if ($this->debugMode) {
trigger_error($message, E_USER_WARNING);
}
return null;
}
/**
* Check for plugin updates. The results are stored in the DB option specified in $optionName.
* @return LiUpdateCenter_PluginUpdate|null
*/
public function checkForUpdates()
{
$installedVersion = $this->getInstalledVersion();
// Fail silently if we can't find the plugin or read its header.
if ($installedVersion === null) {
$message = sprintf('Skipping update check for %s - installed version unknown.', $this->pluginFile);
$this->errors[] = ['message' => $message];
if ($this->debugMode) {
trigger_error($message, E_USER_WARNING);
}
return null;
}
$state = $this->getUpdateState();
if (empty($state)) {
$state = new StdClass;
$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();
}
/**
* If Wordpress checks for Updates during a wp-cli call, we should check as well.
*/
private function wpcliCheckForUpdates()
{
$timeout = 60;
$state = $this->getUpdateState();
if (empty($state) || ! isset($state->lastCheck) || ((time() - $state->lastCheck) >= $timeout)) {
$this->checkForUpdates();
}
}
/**
* 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.
*/
public function maybeCheckForUpdates()
{
if (empty($this->checkPeriod)) {
return;
}
if (current_filter() === 'load-update-core.php') {
// Check more often when the user visits Dashboard -> Updates.
$timeout = 60;
} 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.
$shouldCheck = apply_filters(
'puc_check_now-' . $this->slug,
$shouldCheck,
(! empty($state) && isset($state->lastCheck)) ? $state->lastCheck : 0,
$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 = LiUpdateCenter_PluginUpdate_1_6::fromObject($state->update);
}
return $state;
}
/**
* Persist the update checker state to the DB.
* @param stdClass $state
*/
private function setUpdateState($state)
{
if (isset($state->update) && is_object($state->update) && method_exists($state->update, 'toStdClass')) {
$update = $state->update;
/** @var LiUpdateCenter_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
*/
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();
// 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 = [];
}
$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;
}
/**
* 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 LiUpdateCenter_PluginUpdate|null
*/
public function getUpdate()
{
$state = $this->getUpdateState();
if (empty($state->update)) {
return null;
}
// Check if the update is actually newer than the currently installed version.
$installedVersion = $this->getInstalledVersion();
if ($installedVersion !== null && version_compare($state->update->version, $installedVersion, '>')) {
$state->update->filename = $this->pluginFile;
return $state->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
* @return array
*/
public function addCheckForUpdatesLink($pluginMeta, $pluginFile)
{
$isRelevant = ($pluginFile == $this->pluginFile)
|| (! empty($this->muPluginFile) && $pluginFile == $this->muPluginFile);
if ($isRelevant && current_user_can('update_plugins')) {
$linkUrl = wp_nonce_url(
add_query_arg(
[
'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'
);
$domain = class_exists('LiUpdateCenter') ? LiUpdateCenter::TEXTDOMAIN : null;
$linkText = apply_filters('puc_manual_check_link-' . $this->slug, __('Check for update', $domain));
if (! empty($linkText)) {
$pluginMeta[] = '<a href="' . esc_attr($linkUrl) . '" title="' . __('Check for new plugin version', $domain) . '">' . $linkText . '</a>';
}
}
return $pluginMeta;
}
/**
* Check for updates when the user clicks the "Check for updates" link.
* @return void
*/
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) {
return;
}
$update = $this->checkForUpdates();
wp_redirect(add_query_arg(
[
'puc_update_check_result' => ($update === null) ? 'no_update' : 'update_available',
'puc_slug' => $this->slug,
],
is_network_admin() ? network_admin_url('plugins.php') : admin_url('plugins.php')
));
}
/**
* Display the results of a manual update check.
* 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)) {
return;
}
$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));
}
printf('<div class="updated"><p>%s</p></div>', apply_filters('puc_manual_check_message-' . $this->slug, $message, $status));
}
/**
* Check if the plugin file is inside the mu-plugins directory.
* @return bool
*/
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);
$cachedResult = $muPluginDir && $pluginPath && (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
* @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
*/
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
*/
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 LiUpdateCenter_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 LiUpdateCenter_PluginInfo or NULL.
*
* @param callable $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
* @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__) . '/src/DebugBarPlugin.php';
$this->debugBarPlugin = new LiUpdateCenter_DebugBarPlugin($this);
}
}
public function hasErrors()
{
return ! empty($this->errors);
}
public function getErrors()
{
return $this->errors;
}
}
endif;
if (! class_exists('LiUpdateCenter_PluginInfo_1_6')):
/**
* A container class for holding and transforming various plugin metadata.
*/
class LiUpdateCenter_PluginInfo_1_6
{
// 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 $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.
public $filename; // Plugin filename relative to the plugins directory.
/**
* Create a new instance of LiUpdateCenter_PluginInfo from JSON-encoded plugin info
* returned by an external update API.
* @param string $json Valid JSON string representing plugin info.
* @param bool $triggerErrors
* @param array|null $errors
* @return LiUpdateCenter_PluginInfo|LiUpdateCenter_PluginInfo_1_6|null New instance of LiUpdateCenter_PluginInfo, or NULL on error.
*/
public static function fromJson($json, $triggerErrors = false, array &$errors = null)
{
/** @var stdClass $apiResponse */
$apiResponse = json_decode($json);
if (empty($apiResponse) || ! is_object($apiResponse)) {
$message = "Failed to parse plugin metadata.";
if ($errors) {
$errors[] = $message;
}
if ($triggerErrors) {
trigger_error($message, E_USER_NOTICE);
}
return null;
}
// Very, very basic validation.
$valid = isset($apiResponse->name) && ! empty($apiResponse->name) && isset($apiResponse->version) && ! empty($apiResponse->version);
if (! $valid) {
$message = "The plugin metadata file does not contain the required 'name' and/or 'version' keys.";
if ($errors) {
$errors[] = $message;
}
if ($triggerErrors) {
trigger_error($message, 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 = [
'name',
'slug',
'version',
'requires',
'tested',
'rating',
'upgrade_notice',
'num_ratings',
'downloaded',
'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 = '<a href="' . esc_url($this->author_homepage) . '">' . esc_html($this->author) . '</a>';
} 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 = ['description' => ''];
}
return $info;
}
}
endif;
if (! class_exists('LiUpdateCenter_PluginUpdate_1_6')):
/**
* A simple container class for holding information about an available update.
*/
class LiUpdateCenter_PluginUpdate_1_6
{
public $id = 0;
public $slug;
public $version;
public $homepage;
public $download_url;
public $upgrade_notice;
public $filename; // Plugin filename relative to the plugins directory.
private static $fields = ['id', 'slug', 'version', 'homepage', 'download_url', 'upgrade_notice', 'filename'];
/**
* Create a new instance of LiUpdateCenter_PluginUpdate from its JSON-encoded representation.
* @param string $json
* @param bool $triggerErrors
* @param array|null $errors
* @return LiUpdateCenter_PluginUpdate|null
*/
public static function fromJson($json, $triggerErrors = false, array &$errors = null)
{
// 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 = LiUpdateCenter_PluginInfo_1_6::fromJson($json, $triggerErrors, $errors);
if ($pluginInfo != null) {
return self::fromPluginInfo($pluginInfo);
} else {
return null;
}
}
/**
* Create a new instance of LiUpdateCenter_PluginUpdate based on an instance of LiUpdateCenter_PluginInfo.
* Basically, this just copies a subset of fields from one object to another.
* @param LiUpdateCenter_PluginInfo $info
* @return LiUpdateCenter_PluginUpdate
*/
public static function fromPluginInfo($info)
{
return self::fromObject($info);
}
/**
* Create a new instance of LiUpdateCenter_PluginUpdate by copying the necessary fields from
* another object.
* @param StdClass|LiUpdateCenter_PluginInfo|LiUpdateCenter_PluginUpdate $object The source object.
* @return LiUpdateCenter_PluginUpdate|LiUpdateCenter_PluginUpdate_1_6 The new copy.
*/
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 LiUpdateCenter_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;
$update->id = $this->id;
$update->slug = $this->slug;
$update->new_version = $this->version;
$update->url = $this->homepage;
$update->package = $this->download_url;
$update->plugin = $this->filename;
if (! empty($this->upgrade_notice)) {
$update->upgrade_notice = $this->upgrade_notice;
}
return $update;
}
}
endif;
if (! class_exists('LiUpdateCenter_PucFactory')):
/**
* A factory that builds instances of other classes from this library.
*
* When multiple versions of the same class have been loaded (e.g. LiUpdateCenter_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 LiUpdateCenter_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 LiUpdateCenter_PucFactory
{
protected static $plugins = [];
protected static $classVersions = [];
protected static $sorted = false;
public static function build($slug, $pluginFile)
{
$options = get_site_option('liupdatecenter_settings', null);
if (empty($options['licence']) || empty($options['serverUrl'])) {
return null;
}
$serverUrl = $options['serverUrl'];
$licence = $options['licence'];
$checkPeriod = isset($options['checkPeriod']) ? intval($options['checkPeriod']) : 12;
$updateChecker = self::buildUpdateChecker(
$serverUrl . '?update_action=get_metadata&update_slug=plugin-' . $slug . '&licence=' . $licence,
$pluginFile,
$slug,
$checkPeriod
);
self::$plugins[] = $updateChecker;
return $updateChecker;
}
/**
* @return LiUpdateCenter_PluginUpdateChecker[]
*/
public static function getPlugins()
{
return self::$plugins;
}
/**
* Create a new instance of LiUpdateCenter_PluginUpdateChecker.
* @param $metadataUrl
* @param $pluginFile
* @param string $slug
* @param int $checkPeriod
* @param string $optionName
* @param string $muPluginFile
* @return LiUpdateCenter_PluginUpdateChecker
*/
protected static function buildUpdateChecker($metadataUrl, $pluginFile, $slug = '', $checkPeriod = 12, $optionName = '', $muPluginFile = '')
{
$class = self::getLatestClassVersion('LiUpdateCenter_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
* @return string|null
*/
public static function getLatestClassVersion($class)
{
if (! self::$sorted) {
self::sortVersions();
}
return isset(self::$classVersions[$class]) ? reset(self::$classVersions[$class]) : null;
}
/**
* Sort available class versions in descending order (i.e. newest first).
*/
protected static function sortVersions()
{
foreach (self::$classVersions as $class => $versions) {
uksort($versions, [__CLASS__, 'compareVersions']);
self::$classVersions[$class] = $versions;
}
self::$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. 'LiUpdateCenter_PluginUpdateChecker'.
* @param string $versionedClass Actual class name, e.g. 'LiUpdateCenter_PluginUpdateChecker_1_2'.
* @param string $version Version number, e.g. '1.2'.
*/
public static function addVersion($generalClass, $versionedClass, $version)
{
self::$sorted = false;
if (! isset(self::$classVersions[$generalClass])) {
self::$classVersions[$generalClass] = [];
}
self::$classVersions[$generalClass][$version] = $versionedClass;
}
}
endif;
LiUpdateCenter_PucFactory::addVersion('LiUpdateCenter_PluginUpdateChecker', 'LiUpdateCenter_PluginUpdateChecker_1_6', '1.6');
LiUpdateCenter_PucFactory::addVersion('LiUpdateCenter_PluginUpdate', 'LiUpdateCenter_PluginUpdate_1_6', '1.6');
LiUpdateCenter_PucFactory::addVersion('LiUpdateCenter_PluginInfo', 'LiUpdateCenter_PluginInfo_1_6', '1.6');
if (! class_exists('LiUpdateCenter_PluginUpdateChecker')) {
class LiUpdateCenter_PluginUpdateChecker extends LiUpdateCenter_PluginUpdateChecker_1_6
{
}
}
if (! class_exists('LiUpdateCenter_PluginUpdate')) {
class LiUpdateCenter_PluginUpdate extends LiUpdateCenter_PluginUpdate_1_6
{
}
}
if (! class_exists('LiUpdateCenter_PluginInfo')) {
class LiUpdateCenter_PluginInfo extends LiUpdateCenter_PluginInfo_1_6
{
}
}