simplemap/classes/ft-ps-client.php

<?php
/**
 * FullThrottle Premium Support Client
 * Curious? Send me an email and you can beta it for me (glenn@fullthrottledevelopment.com)
 */
 
if ( ! class_exists( 'FT_Premium_Support_Client' ) ) {
	
	class FT_Premium_Support_Client {
		
		var $server_url;
		var $product_id;
		var $plugin_support_page_ids;
		var $confirming_request;
		var $receiving_sso;
		var $learn_more_link;
		var $ps_status = false;
		var $sso_status = false;
		var $paypal_button = false;
		var $site_url;
		var $plugin_basename = false;
		var $plugin_slug = false;
		
		// Constructer fires on admin page loads
		function ft_premium_support_client( $config=array() ) {

			// Populate properties
			$this->server_url 				= isset( $config['server_url'] ) ? $config['server_url'] : false;
			$this->product_id 				= isset( $config['product_id'] ) ? $config['product_id'] : false;
			$this->plugin_support_page_ids 	= isset( $config['plugin_support_page_ids'] ) ? $config['plugin_support_page_ids'] : false;
			$this->plugin_basename			= isset( $config['plugin_basename'] ) ? $config['plugin_basename'] : false;
			$this->plugin_slug				= isset( $config['plugin_slug'] ) ? $config['plugin_slug'] : false;
			$this->learn_more_link			= isset( $config['learn_more_link'] ) ? $config['learn_more_link'] : false;
			$this->confirming_request 		= isset( $_GET['ft-ps-confirm-request'] ) ? $_GET['ft-ps-confirm-request'] : false;
			$this->receiving_sso 			= isset( $_POST['ft-ps-receiving-sso'] ) ? $_POST['ft-ps-receiving-sso'] : false;
			$this->site_url					= site_url();

			// Register actions
			add_action( 'admin_head', array( &$this, 'init' ) );
			add_action( 'init', array( &$this, 'check_premium_upgrades' ) );

		}
		
		// Checks for premium upgrades
		function check_premium_upgrades() {
			// Build key
			$exp_option_key = '_ftpssu_' . md5( 'ftpssue-' . $this->product_id . '-' . sanitize_title_with_dashes( $this->site_url ) . '-' . sanitize_title_with_dashes( $this->server_url ) );

			// Check server for auto update?
			if ( $expires = get_option( $exp_option_key ) ) {

				if ( $expires > strtotime( 'now' ) )
					$ft_ps_client_auto_update = new FT_Premium_Support_PluginUpdate_Checker( $this->server_url . '?ft-pss-upgrade-request=1&ft-pss-upgrade-request-product-id=' . $this->product_id . '&ft-pss-upgrade-request-site=' . $this->site_url . '&exp=' . $expires, $this->plugin_basename, $this->plugin_slug, 1 );
				else
					delete_option( 'external_updates-' . $this->plugin_slug );
			
			}
		
		}
		
		// Inits the client if we're on the support page or receiving a request from the server
		function init() {
		
			global $current_screen;

			// Return false if we don't have initial config settings and this isn't a request from the host server
			if ( ( ! $this->server_url || ! $this->product_id || ! isset( $this->plugin_support_page_ids ) ) && ( ! $this->confirming_request || ! $this->receiving_sso ) )
				return;

			// Fire in the hole!
			if ( $this->receiving_sso )
				$this->receive_sso();
			elseif ( $this->confirming_request )
				$this->confirm_request();
			elseif ( in_array( $current_screen->id, $this->plugin_support_page_ids ) )
				$this->init_premium_support();
		
		}
		
		// This function inits premium support process
		function init_premium_support() {

			global $current_user;
			wp_get_current_user();
			
			// Check for premium support, sso, and paypal button transients
			$status_key = md5( 'ft_premium_support_' . $this->product_id . '_' . sanitize_title_with_dashes( $this->site_url )  . '_' . sanitize_title_with_dashes( $this->server_url ) ) ;
			$sso_key = md5( 'ft_premium_sso_' . $current_user->ID . '_' . $this->product_id . '_' . sanitize_title_with_dashes( $this->site_url )  . '_' . sanitize_title_with_dashes( $this->server_url ) );
			$paypal_button_key = md5( 'ft_premium_signup_' . $this->product_id . '_' . sanitize_title_with_dashes( $this->site_url )  . '_' . sanitize_title_with_dashes( $this->server_url ) );
			$exp_option_key = '_ftpssu_' . md5( 'ftpssue-' . $this->product_id . '-' . sanitize_title_with_dashes( $this->site_url ) . '-' . sanitize_title_with_dashes( $this->server_url ) );

			// If we haven't set the status in the last 24 hours, or we haven't set a SSO for the current user in the last 3 hours, do it now.
			if ( false === ( $ps_status = get_transient( $status_key ) ) || false === ( $sso_status = get_transient( $sso_key ) ) ) {

				$body['ft-ps-status-request'] = true;
				$body['site'] = urlencode( $this->site_url );
				$body['user'] = $current_user->ID;
				$body['product'] = $this->product_id;
				$body['email'] = urlencode( $current_user->user_email );
				$body['nicename'] = urlencode( $current_user->user_nicename );

				// Ping server for response
				if ( $request = wp_remote_post( $this->server_url, array( 'body' => $body, 'timeout' => 20 ) ) ) {

					if ( isset( $request['response']['code'] ) && 200 == $request['response']['code'] ) {

						// Response found a server, lets see if it hit a script we recognize
						$response = json_decode( $request['body'] );

						// Set the paypal button
						if ( ! empty( $response->paypal_button->args ) && ! empty( $response->paypal_button->base) )
							$this->paypal_button = add_query_arg( get_object_vars( $response->paypal_button->args ), $response->paypal_button->base );

						// Set the expired flag
						$this->support_expired = isset( $response->support_expired ) ? $response->support_expired : false;

						// Do we have a premium status?
						if ( isset( $response->support_status ) && $response->support_status ) {
							
							// We have a premium support license for this domain / product combination. Set the transient and property
							set_transient( $status_key, $response->support_status, 60*60*24 );	
							//set_transient( $status_key, $response->support_status, 60 );	
							$this->ps_status = $response->support_status;

							// Did we get a user sso back as well? Set the property if we did
							if ( isset( $response->user_sso ) && '' != $response->user_sso ) {
								set_transient( $sso_key, $response->user_sso, 60*60*2.9 );
								//set_transient( $sso_key, $response->user_sso, 60 );
								$this->sso_status = $response->user_sso;
							}
							
							// Set an auto update option with expiration date
							if ( isset( $response->support_status->exp_date )  && ! empty( $response->support_status->exp_date ) ) {
								update_option( $exp_option_key, $response->support_status->exp_date );
								
								// Check server for auto update?
								if ( $this->ps_status ) {
									delete_option( 'external_updates-' . $this->plugin_slug );
									$ft_ps_client_auto_update = new FT_Premium_Support_PluginUpdate_Checker( $this->server_url . '?ft-pss-premium-request=1&ft-pss-upgrade-request-product-id=' . $this->product_id . '&ft-pss-upgrade-request-site=' . $this->site_url . '&exp=' . $response->support_status->exp_date, SIMPLEMAP_PATH, $this->plugin_slug, 1 );
								}
							
							}
										
						} else {

							// No premium support so lets delete the keys
							delete_option( 'external_updates-' . $this->plugin_slug );
							delete_option( $exp_option_key );
						}
					}
				}
			} else {
				
				// Transients exist, therefore permission exists, set properties
				$this->ps_status = $ps_status;
				$this->sso_status = $sso_status;
				
			}

			// Check server for auto update?
			if ( $this->ps_status )
				$ft_ps_client_auto_update = new FT_Premium_Support_PluginUpdate_Checker( $this->server_url . '?ft-pss-upgrade-request=1&ft-pss-upgrade-request-product-id=' . $this->product_id . '&ft-pss-upgrade-request-site=' . $this->site_url, $this->plugin_basename, 'simplemap', 1 	);

                        // Maybe Nag Renewal
                        $this->maybe_trigger_renewal_nag(); 
		
		}

                function maybe_trigger_renewal_nag() {
                        // Has support expired?
                        if ( ! empty( $this->support_expired ) && ! is_object( $this->support_expired ) ) {
                                add_action( 'admin_notices', array( $this, 'support_expired' ) );
                                return;
                        }

                        if ( ! empty( $this->ps_status->exp_date ) ) {
                                $onemonthout = $this->ps_status->exp_date - 2628000;
                                // If we are within a month of expiration date
                                if ( $onemonthout <= strtotime( 'now' ) ) {
                                       add_action( 'admin_notices', array( $this, 'renew_soon' ) ); 
                                }
                        }

                }

                function support_expired() {
                        $link = ( $this->paypal_button ) ? esc_url( $this->paypal_button ) : 'http://simplemap-plugin.com';
                        echo "<div class='update-nag'>" . sprintf( __( "<strong style='color:red;'>Your license for SimpleMap has expired!</strong><br />You need to renew your license now for continued support and upgrades: <a href='%s' target='_blank'>Renew my license now</a>." ), $link ) . "</div>";  
                }

                function renew_soon() {
                        $link = ( $this->paypal_button ) ? esc_url( $this->paypal_button ) : 'http://simplemap-plugin.com';
                        echo "<div class='update-nag'>" . sprintf( __( "<strong style='color:red;'>SimpleMap is expiring soon!</strong><br />You will need to renew your license for continued support and upgrades: <a href='%s' target='_blank'>Renew my license now</a>." ), $link ) . "</div>";  
                }
		
	}
	
}

if ( !class_exists( 'FT_Premium_Support_PluginUpdate_Checker' ) ) :
	
/**
 * A custom plugin update checker. 
 * 
 * @author Janis Elsts
 * @copyright 2010
 * @version 1.0
 * @access public
 */
class FT_Premium_Support_PluginUpdate_Checker {
	
	var $metadataUrl = ''; //The URL of the plugin's metadata file.
	var $pluginFile = '';  //Plugin filename relative to the plugins directory.
	var $slug = '';        //Plugin slug.
	var $checkPeriod = 12; //How often to check for updates (in hours).
	var $optionName = '';  //Where to store the update info.
	
	/**
	 * 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 	= $pluginFile;
		$this->checkPeriod 	= $checkPeriod;
		$this->slug 		= $slug;
		
		//If no slug is specified, use the name of the main plugin file as the slug.
		//For example, 'my-cool-plugin/cool-plugin.php' becomes 'cool-plugin'.
		if ( empty( $this->slug ) ){
			$this->slug = basename( $this->pluginFile, '.php' );
		}
		
		if ( empty( $this->optionName ) ) {
			$this->optionName = 'external_updates-' . $this->slug;
		}
		
		if ( '' == $optionName )
			$this->optionName = 'external_updates-' . $this->slug;
		else
			$this->optionName 	= $optionName;
		
		$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 );
		
		//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 PluginInfo
	 */
	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, $options );

		//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
		$ft_premium_support_plugin_info = null;
		if ( !is_wp_error( $result ) && isset( $result['response']['code'] ) && ( $result['response']['code'] == 200 ) && !empty( $result['body'] ) ){
			$ft_premium_support_plugin_info = FT_Premium_Support_PluginInfo::fromJson( $result['body'] );
		}
		
		$ft_premium_support_plugin_info = apply_filters( 'puc_request_info_result-' . $this->slug, $ft_premium_support_plugin_info, $result );
		
		return $ft_premium_support_plugin_info;
	}
	
	/**
	 * 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.
	 */
	function requestUpdate() {
		//For the sake of simplicity, this function just calls requestInfo() 
		//and transforms the result accordingly.
		$ft_premium_support_plugin_info = $this->requestInfo( array( 'checking_for_updates' => '1' ) );
		
		if ( $ft_premium_support_plugin_info == null )
			return null;
		
		return FT_Premium_Support_PluginUpdate::fromPluginInfo( $ft_premium_support_plugin_info );
	}
	
	/**
	 * 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;
		}

		$ft_premium_support_plugin_info = $this->requestInfo();

		if ( $ft_premium_support_plugin_info )
			return $ft_premium_support_plugin_info->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 );

		//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( 'FT_Premium_Support_PluginInfo' ) ) :

/**
 * A container class for holding and transforming various plugin metadata.
 * 
 * @author Janis Elsts
 * @copyright 2010
 * @version 1.0
 * @access public
 */
class FT_Premium_Support_PluginInfo {
	
	//Most fields map directly to the contents of the plugin's info.json file.
	//See the relevant docs for a description of their meaning.  
	var $name;
	var $slug;
	var $version;
	var $homepage;
	var $sections;
	var $download_url;

	var $author;
	var $author_homepage;
	
	var $requires;
	var $tested;
	var $upgrade_notice;
	
	var $rating;
	var $num_ratings;
	var $downloaded;
	var $last_updated;
	
	var $id = 0; //The native WP.org API returns numeric plugin IDs, but they're not used for anything.
		
	/**
	 * Create a new instance of PluginInfo from JSON-encoded plugin info 
	 * returned by an external update API.
	 * 
	 * @param string $json Valid JSON string representing plugin info. 
	 * @return PluginInfo New instance of PluginInfo, or NULL on error.
	 */
	function fromJson( $json ){
		$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 FT_Premium_Support_PluginInfo();
		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
	 */
	function toWpFormat(){
		$info = new StdClass;
		
		//The custom update API is built so that many fields have the same name and format
		//as those returned by the native WordPress.org API. These can be assigned directly. 
		$sameFormat = array(
			'name', 'slug', 'version', 'requires', 'tested', 'rating', 'upgrade_notice',
			'num_ratings', 'downloaded', 'homepage', 'last_updated',
		);
		
		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( 'FT_Premium_Support_PluginUpdate' ) ):

/**
 * A simple container class for holding information about an available update.
 * 
 * @author Janis Elsts
 * @copyright 2010
 * @version 1.0
 * @access public
 */
class FT_Premium_Support_PluginUpdate {
	
	var $id = 0;
	var $slug;
	var $version;
	var $homepage;
	var $download_url;
	var $upgrade_notice;
	
	/**
	 * Create a new instance of PluginUpdate from its JSON-encoded representation.
	 * 
	 * @param string $json
	 * @return PluginUpdate
	 */
	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.
		$ft_premium_support_plugin_info = FT_Premium_Support_PluginInfo::fromJson( $json );
		if ( $ft_premium_support_plugin_info != null )
			return FT_Premium_Support_PluginUpdate::fromPluginInfo( $ft_premium_support_plugin_info );
		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
	 * @return PluginUpdate
	 */
	function fromPluginInfo( $info ){
		
		$update = new FT_Premium_Support_PluginUpdate();
		$copyFields = array( 'id', 'slug', '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
	 */
	function toWpFormat(){
		
		$update = new StdClass;
		
		$update->id	 			= $this->id;
		$update->slug 			= $this->slug;
		$update->new_version 	= $this->version;
		$update->url 			= $this->homepage;
		$update->package 		= $this->download_url;
		
		if ( ! empty( $this->upgrade_notice ) )
			$update->upgrade_notice = $this->upgrade_notice;
		
		return $update;
		
	}
	
}
	
endif;

/**
 * Checks for premium support
 */
function url_has_ftps_for_item( &$ps_object ) {
	
	if ( is_object( $ps_object ) && $ps_object->ps_status )
		return true;
		
	return false;

}

/**
 * Return paypal button
 */
function get_ftps_paypal_button( &$ps_object ) {

	if ( is_object( $ps_object ) && isset( $ps_object->paypal_button ) )
		return $ps_object->paypal_button;
		
	return false;
}

/**
 * Return learn more link
 */
function get_ftps_learn_more_link( &$ps_object ) {

	if ( is_object( $ps_object ) && isset( $ps_object->learn_more_link ) )
		return $ps_object->learn_more_link;
		
	return false;
}

/**
 * Return SSO key
 */
function get_ftps_sso_key( &$ps_object ) {

	if ( is_object( $ps_object ) && isset( $ps_object->sso_status ) )
		return $ps_object->sso_status;
		
	return false;
}

/**
 * Return this site URL that has premium support
 */
function get_ftps_site( &$ps_object ) {
	
	if ( is_object( $ps_object ) && isset( $ps_object->ps_status->site ) )
		return $ps_object->ps_status->site;
		
	return false;
}

/**
 * Return purchase date
 */
function get_ftps_purchase_date( &$ps_object ) {

	if ( is_object( $ps_object ) && isset( $ps_object->ps_status->purchase_date ) )
		return $ps_object->ps_status->purchase_date;
		
	return false;
}

/**
 * Return expiration date
 */
function get_ftps_exp_date( &$ps_object ) {

	if ( is_object( $ps_object ) && isset( $ps_object->ps_status->exp_date ) )
		return $ps_object->ps_status->exp_date;
		
	return false;
}

/**
 * Return email of person who purchased premium support
 */
function get_ftps_email( &$ps_object ) {

	if ( is_object( $ps_object ) && isset( $ps_object->ps_status->email ) )
		return $ps_object->ps_status->email;
		
	return false;
}

/**
 * Return name of person who purchased premium support
 */
function get_ftps_name( &$ps_object ) {

	if ( is_object( $ps_object ) && isset( $ps_object->ps_status->name ) )
		return $ps_object->ps_status->name;
		
	return false;
}

?>