ꦫꦣꦺꦤ꧀ꦄꦤ꧀ꦠꦱꦺꦤ

PATH: home / letacommog / winwithd / wp-content / plugins / paid-member-subscriptions / includes / admin

<?php

// Exit if accessed directly
if ( ! defined( 'ABSPATH' ) ) exit;

if ( ! class_exists( 'pms_PluginUpdateChecker' ) ):

/**
     * A custom plugin update checker.
     *
     * @author Janis Elsts
     * @copyright 2010
     * @version 1.0
     * @access public
     */
    class pms_PluginUpdateChecker {

/**
         * The URL of the plugin's metadata file
         *
         * @access public
         * @var string
         */
        public $metadataUrl = '';

/**
         * Plugin filename relative to the plugins directory
         *
         * @access public
         * @var string
         */
        public $pluginFile = '';

/**
         * Plugin slug
         *
         * @access public
         * @var string
         */
        public $slug = '';

/**
         * How often to check for updates (in hours)
         *
         * @access public
         * @var int
         */
        public $checkPeriod = 12;

/**
         * Where to store the update info
         *
         * @access public
         * @var int
         */
        public $optionName = '';

/**
         * 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'.
         * @return void
         */
        function __construct($metadataUrl, $pluginFile, $slug = '', $checkPeriod = 12, $optionName = '') {
            $this->metadataUrl = $metadataUrl;
            $this->pluginFile = plugin_basename($pluginFile);
            $this->checkPeriod = $checkPeriod;
            $this->slug = $slug;
            $this->optionName = $optionName;

//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;
            }

$this->installHooks();
        }

/**
         * Install the hooks required to run periodic update checks and inject update info
         * into WP data structures.
         *
         * @return void
         */
        function installHooks(){
            //Override requests for plugin information
            add_filter('plugins_api', array(&$this, 'injectInfo'), 10, 3);
            // add_filter('init', array(&$this, 'checkForUpdates') );

//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+

//Set up the periodic update checks
            $cronHook = 'check_plugin_updates-' . $this->slug;

if ( $this->checkPeriod > 0 ){

//Trigger the check via Cron
                add_filter('cron_schedules', array(&$this, '_addCustomSchedule'));
                if ( !wp_next_scheduled($cronHook) && !defined('WP_INSTALLING') ) {
                    $scheduleName = 'every' . $this->checkPeriod . 'hours';
                    wp_schedule_event(time(), $scheduleName, $cronHook);
                }
                add_action($cronHook, array(&$this, 'checkForUpdates'));

//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') );

} else {
                //Periodic checks are disabled.
                wp_clear_scheduled_hook($cronHook);
            }
        }

/**
         * Add our custom schedule to the array of Cron schedules used by WP.
         *
         * @param array $schedules
         * @return array
         */
        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;
        }

/**
         * Retrieve plugin info from the configured API endpoint.
         *
         * @uses wp_remote_get()
         *
         * @param array $queryArgs Additional query arguments to append to the request. Optional.
         * @return PMSPluginInfo
         */
        function requestInfo($queryArgs = array()){
            //Query args to append to the URL. Plugins can add their own by using a filter callback (see addQueryArgFilter()).
            $queryArgs['installed_version'] = $this->getInstalledVersion();
            $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, array());

//The plugin info should be at 'http://your-api.com/url/here/$slug/info.json'
            $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 = PMSPluginInfo::fromJson( $result['body'], $this->pluginFile );
            }

$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 PMSPluginUpdate An instance of PMSPluginUpdate, or NULL when no updates are available.
         */
        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;

$parts = parse_url( $this->metadataUrl );
            parse_str($parts['query'], $query);

PMS_Submenu_Page_Addons::add_on_check_serial_number( $query['localSerialNumber'], 'pms' );

return PMSPluginUpdate::fromPluginInfo( $pluginInfo );
        }

/**
         * Get the currently installed version of the plugin.
         *
         * @return string Version number.
         */
        function getInstalledVersion(){
            if ( !function_exists('get_plugins') ){
                require_once( ABSPATH . '/wp-admin/includes/plugin.php' );
            }
            $allPlugins = get_plugins();
            if ( array_key_exists($this->pluginFile, $allPlugins) && array_key_exists('Version', $allPlugins[$this->pluginFile]) ){
                return $allPlugins[$this->pluginFile]['Version'];
            } else {
                return ''; //This should never happen.
            };
        }

/**
         * Check for plugin updates.
         * The results are stored in the DB option specified in $optionName.
         *
         * @return void
         */
        function checkForUpdates(){
            $state = get_option($this->optionName);

if ( empty($state) ){
                $state = new StdClass;
                $state->lastCheck = 0;
                $state->checkedVersion = '';
                $state->update = null;
            }

$state->lastCheck = time();
            $state->checkedVersion = $this->getInstalledVersion();
            update_option($this->optionName, $state); //Save before checking in case something goes wrong

$state->update = $this->requestUpdate();

update_option($this->optionName, $state);
        }

/**
         * Check for updates only if the configured check interval has already elapsed.
         *
         * @return void
         */
        function maybeCheckForUpdates(){
            if ( empty($this->checkPeriod) ){
                return;
            }

$state = get_option($this->optionName);

$shouldCheck =
                empty($state) ||
                !isset($state->lastCheck) ||
                ( (time() - $state->lastCheck) >= $this->checkPeriod*3600 );

if ( $shouldCheck ){
                $this->checkForUpdates();
            }
        }

/**
         * Intercept plugins_api() calls that request information about our plugin and
         * use the configured API endpoint to satisfy them.
         *
         * @see plugins_api()
         *
         * @param mixed $result
         * @param string $action
         * @param array|object $args
         * @return mixed
         */
        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();

if ($pluginInfo){
                return $pluginInfo->toWpFormat();
            }

return $result;
        }

/**
         * Insert the latest update (if any) into the update list maintained by WP.
         *
         * @param array $updates Update list.
         * @return array Modified update list.
         */
        function injectUpdate($updates){
            $state = get_option($this->optionName);

if ( isset( $state->update) && !is_null( $state->update ) ) {
                $class = get_class( $state->update );

if ( $class == '__PHP_Incomplete_Class' || $class == 'PluginUpdate' ) {
                    $this->checkForUpdates();
                    wp_cache_delete( $this->optionName );
                    $state = get_option( $this->optionName );
                }
            }

//Is there an update to insert?
            if ( !empty($state) && isset($state->update) && !empty($state->update) ) {
                //Only insert updates that are actually newer than the currently installed version.
                if ( version_compare( $state->update->version, $this->getInstalledVersion(), '>' ) )
                    $updates->response[$this->pluginFile] = $state->update->toWpFormat();

}

return $updates;
        }

/**
         * 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.
         *
         * @uses add_filter() This method is a convenience wrapper for add_filter().
         *
         * @param callback $callback
         * @return void
         */
        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.
         *
         * @uses add_filter() This method is a convenience wrapper for add_filter().
         *
         * @param callback $callback
         * @return void
         */
        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.
         *
         * @uses add_filter() This method is a convenience wrapper for add_filter().
         *
         * @param callback $callback
         * @return void
         */
        function addResultFilter($callback){
            add_filter('puc_request_info_result-'.$this->slug, $callback, 10, 2);
        }
    }

endif;

if ( !class_exists( 'PMSPluginInfo' ) ) :

/**
     * A container class for holding and transforming various plugin metadata.
     *
     * @author Janis Elsts
     * @copyright 2010
     * @version 1.0
     * @access public
     */
    class PMSPluginInfo {
        //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.

/**
         * Create a new instance of PMSPluginInfo from JSON-encoded plugin info
         * returned by an external update API.
         *
         * @param string $json Valid JSON string representing plugin info.
         * @return PMSPluginInfo New instance of PMSPluginInfo, or NULL on error.
         */
        public static function fromJson( $json, $plugin_file ){
            $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 PMSPluginInfo();
            foreach(get_object_vars( $apiResponse ) as $key => $value ){
                $info->$key = $value;
            }

$info->plugin = $plugin_file;

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', 'plugin', 'version', 'requires', 'tested', 'rating', 'upgrade_notice',
                'num_ratings', 'downloaded', 'homepage', 'last_updated',
            );

foreach( $sameFormat as $field ) {
                if ( isset($this->$field) )
                    $info->$field = $this->$field;
            }

//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;
        }
    }

endif;

if ( !class_exists('PMSPluginUpdate') ):

/**
     * A simple container class for holding information about an available update.
     *
     * @author Janis Elsts
     * @copyright 2010
     * @version 1.0
     * @access public
     */
    class PMSPluginUpdate {
        public $id = 0;
        public $slug;
        public $version;
        public $homepage;
        public $download_url;
        public $upgrade_notice;

/**
         * Create a new instance of PMSPluginUpdate from its JSON-encoded representation.
         *
         * @param string $json
         * @return PMSPluginUpdate
         */
        public static function fromJson( $json ) {
            //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 = PMSPluginInfo::fromJson( $json );

if ( $pluginInfo != null )
                return PMSPluginUpdate::fromPluginInfo( $pluginInfo );
            else
                return null;
        }

/**
         * Create a new instance of PMSPluginUpdate based on an instance of PMSPluginInfo.
         * Basically, this just copies a subset of fields from one object to another.
         *
         * @param PMSPluginInfo $info
         * @return PMSPluginUpdate
         */
        public static function fromPluginInfo( $info ){
            $update = new PMSPluginUpdate();

$copyFields = array( 'id', 'slug', 'plugin', 'version', 'homepage', 'download_url', 'upgrade_notice' );

foreach( $copyFields as $field )
                $update->$field = $info->$field;

return $update;
        }

/**
         * 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->plugin;

if ( !empty($this->upgrade_notice) )
                $update->upgrade_notice = $this->upgrade_notice;

//add an icon to the update screen for the pro version (this is specific to PB, don't have a good solution for making it global)
            $update->icons = array( "2x" =>"https://ps.w.org/paid-member-subscriptions/assets/icon-256x256.png?rev=1077372");

return $update;
        }
    }

endif;
?>

[+] ..
[-] class-admin-addons.php [edit]
[-] class-admin-payments-list-table.php [edit]
[+] views
[-] class-admin-members-add-new-bulk-list-table.php [edit]
[+] export
[-] class-admin-payments.php [edit]
[-] class-admin-export.php [edit]
[-] class-admin-settings.php [edit]
[+] meta-boxes
[-] class-admin-member-payments-list-table.php [edit]
[-] class-admin-member-subscription-list-table.php [edit]
[-] class-update-checker.php [edit]
[-] class-admin-basic-info.php [edit]
[-] class-admin-subscription-plans.php [edit]
[-] class-admin-members-list-table.php [edit]
[-] class-admin-setup-wizard.php [edit]
[-] class-admin-uninstall.php [edit]
[-] class-admin-payments-log-list-table.php [edit]
[-] class-admin-reports.php [edit]
[-] class-admin-members.php [edit]