<?php
// Create the function to use in the action hook
function remove_dashboard_widgets() {
	global $wp_meta_boxes;
	if ( !array( $wp_meta_boxes ) ) return;
	foreach ( $wp_meta_boxes as $widget_section => $widget_locations ) {
		if ( $widget_section == 'dashboard' ) {
			foreach ( $widget_locations as $widget_location => $widget_types ) {
				foreach ( $widget_types as $widget_type => $widgets ) {
					foreach ( $widgets as $widget_name => $widget ) {
						remove_meta_box( $widget_name, $widget_section, $widget_location );
					}				
				}
			}
		}
	}
} 
// Hoook into the 'wp_dashboard_setup' action to register our function
add_action('wp_dashboard_setup', 'remove_dashboard_widgets', 11 );
?>

The post Removing All Dashboard Widgets appeared first on WordPress and Ajax.

Here’s a code snippet I use quite regularly (please add in your own custom prefix).

<?php
/* Filter for the content - Custom */
add_action( 'init', 'city_the_content', 1 );
function city_the_content() {
	//Create our own version of the_content so that others can't accidentally loop into our output - Taken from default-filters.php, shortcodes.php, and media.php
	if ( !has_filter( 'city_the_content', 'wptexturize' ) ) {
		add_filter( 'city_the_content', 'wptexturize'        );
		add_filter( 'city_the_content', 'convert_smilies'    );
		add_filter( 'city_the_content', 'convert_chars'      );
		add_filter( 'city_the_content', 'wpautop'            );
		add_filter( 'city_the_content', 'shortcode_unautop'  );
		add_filter( 'city_the_content', 'prepend_attachment' );
		$vidembed = new WP_Embed();
		add_filter( 'city_the_content', array( &$vidembed, 'run_shortcode'), 8 );
		add_filter( 'city_the_content', array( &$vidembed, 'autoembed'), 8 );
		add_filter( 'city_the_content', 'do_shortcode', 11);
	} //end has_filter
} //end city_the_content
?>

Some sample use-cases:

• Run on excerpts
• Run on Widget text output
• Run on just about any text, really

It applies the same formatting rules, and even includes the fancy oEmbed capabilities.

Enjoy.

The post A Custom the_content Filter appeared first on WordPress and Ajax.

The problem with social media icons is that they are loaded from external sources, and are typically in iFrame format. These can delay a page load (in my experience) by as much as a minute.

While the page load doesn’t decrease with this technique, it allows the content to render, thus giving the visitor the impression that the site is loading rather fast.

Here’s some bare code you are free to expand upon. It’s basic, not necessarily secure, and not really optimized. However, if you’re a competent enough dev, you should be able to re-factor it to suit your use-case.

I placed the below code in a theme’s functions.php file. If you do decide to re-factor the code, please place a pastebin link so others can learn your technique as well.

<?php
//Ajax actions for lazy load
add_action( 'wp_ajax_nopriv_koop_lazy_load', 'koop_ajax_lazy_load' );
add_action( 'wp_ajax_koop_lazy_load', 'koop_ajax_lazy_load' );
function koop_ajax_lazy_load() {
	//Ajax response
	$post_id = intval( $_POST[ 'pid' ] );
	$permalink = get_permalink( $post_id );
	ob_start();
	?>
    <a href="https://twitter.com/share" class="twitter-share-button" data-count="horizontal">Tweet</a><script type="text/javascript" src="http://platform.twitter.com/widgets.js"></script>
    <?php
	$twitter = ob_get_clean();
	die( $twitter );
} //end koop_ajax_lazy_load

//Add the DIV to the content
add_filter( 'the_content', 'koop_the_content' );
function koop_the_content( $content ) {
	global $post;
	ob_start();
?>
	<div id='koop_lazy_load' rel='<?php echo absint( $post->ID ); ?>'>
    <input type='hidden' value='<?php echo esc_url( admin_url( 'admin-ajax.php' ) ); ?>' name='koop_ajax_url' id='koop_ajax_url' />
    </div>
<?php
	$return = $content . ob_get_clean();
	return $return;
} //end koop_the_content
add_action( 'wp_print_scripts', 'koop_print_scripts' );
//Load jQuery
function koop_print_scripts() {
	wp_enqueue_script( 'jquery' );
}
//Load our lazy loader script
add_action( 'wp_footer', 'koop_head', 100 );
function koop_head() {
	?>
    <script type="text/javascript">
    	jQuery( document ).ready( function( $ ) {
			var post_id = $( '#koop_lazy_load' ).attr( 'rel' );
			var koop_ajax_url = $( '#koop_ajax_url' ).val();
			//Do ajax
		$.post( koop_ajax_url, { action: 'koop_lazy_load', pid: post_id },
			function( response ){
				$( "#koop_lazy_load" ).html( response );
			} //end ajax response
		 ); //end ajax
		} );
    </script>
    
    <?php
} //end koop_head
?>

The code creates an empty container DIV below the post content. jQuery captures the post ID, sends an Ajax request, and the response contains the HTML for all the social media icons necessary. A sample Twitter button is included in the code.

The post Easy Lazy Loading Via Ajax appeared first on WordPress and Ajax.

I’m all ears for a better way

//Removes a cron based on a hook name
function delete_cron_hooks( $hooks = array(), $blog_id = 0 ) {
	if ( is_multisite() && $blog_id != 0 ) {				
		switch_to_blog( $blog_id );
	}
	$crons = get_option( 'cron' );
	if ( !$crons ) return false;
	foreach ( $crons as $timestamp => $cron ) {
		foreach ( $hooks as $hook ) {
			if ( isset( $cron[ $hook ] ) ) {
				unset( $crons[ $timestamp ] );
			}
		}
	}

	update_option( 'cron', $crons );
	
	
} //end delete_cron

The post Delete Cron Jobs from WordPress appeared first on WordPress and Ajax.

Both videos also demonstrate how to utilize the WordPress commercial plugin BackupBuddy to help transferring sites into and outside of a network a breeze.

How to set up WordPress Multisite Domain Mapping

How to set up and use BackupBuddy with WordPress Multisite

The post WordPress Multisite Explained appeared first on WordPress and Ajax.

The post wp_print_r – My favorite debugging function that isn’t included in core appeared first on WordPress and Ajax.

From their site:

jQuery is fast becoming a must-have skill for front-end developers. The purpose of this book is to provide an overview of the jQuery JavaScript library; when you’re done with the book, you should be able to complete basic tasks using jQuery, and have a solid basis from which to continue your learning. This book was designed as material to be used in a classroom setting, but you may find it useful for individual study.

Source: jQuery Fundamentals

The post jQuery Fundamentals appeared first on WordPress and Ajax.

One danger before receiving final payment is the person ripping off your code through the plugin/theme editor. While this is tedious to do, it is still a real and scary possibility.

To deactivate the plugin/theme editor, just add the following line into your dev site’s wp-config file:

define( 'DISALLOW_FILE_EDIT' , true );

That’s it. Simple and sweet. Hat tip to Brad Williams for the suggestion (here’s also the Trac discussion).

The post Quick Tip: Disallow File Editing on Client Dev Sites appeared first on WordPress and Ajax.

For my upcoming release of Ajax Edit Comments, I coded an upgrade class that immensely simplified the process for me.

First, I’ll share the code to the upgrade class and then go over implementation. Please note that this class is still a work in progress, and it being GPL, you’re welcome to expand on it. I do ask that if you do this, please share the changes with me so I can better improve the class.

Here are the current features of the class:

1. Automatic updates work automagically upon successful instantiation.
2. Filters to overwrite common parameters.
3. Two public methods to check upgrades manually and perform remote requests.

The Upgrade Class

<?php
//Plugin Upgrade Class
if ( !class_exists( "PluginUpgrade" ) ) :
class PluginUpgrade {
			private $plugin_url = false;
			private $remote_url = false;
			private $version = false;
			private $plugin_slug = false;
			private $plugin_path = false;
			private $time_upgrade_check = false;
			private $plugins = '';
			
			function __construct( $args = array() ) {
				//Load defaults
				extract( wp_parse_args( $args, array( 
					'remote_url' => false,
					'version' => false,
					'plugin_slug' => false,
					'plugin_path' => false,
					'plugin_url' => false,
					'time' => 43200
				) ) );
				$this->plugin_url = $plugin_url;
				$this->remote_url = $remote_url;
				$this->version = $version;
				$this->plugin_slug = $plugin_slug;
				$this->plugin_path = $plugin_path;
				$this->time_upgrade_check = apply_filters( "pu_time_{$plugin_slug}", $time );
				
				//Get plugins for upgrading
				$this->plugins = $this->get_plugin_options();
				
				add_action( 'admin_init', array( &$this, 'init' ), 1 );
				add_action( "after_plugin_row_{$plugin_path}", array( &$this, 'plugin_row' ) );
				
				
			} //end constructor
			public function init() {
				//Set up update checking and hook in the filter for automatic updates
				//Do upgrade stuff
				//todo check is_admin() ?
				if (current_user_can("administrator")) {
					$this->check_periodic_updates();
					if ( isset( $this->plugins[ $this->plugin_slug ]->new_version ) ) {
						if( !version_compare( $this->version, $this->plugins[ $this->plugin_slug ]->new_version, '>=' ) ) {
							add_filter( 'site_transient_update_plugins', array( &$this, 'update_plugins_filter' ),1000 );
						}
					}
				}
			}
			//Performs a periodic upgrade check to see if the plugin needs to be upgraded or not
			private function check_periodic_updates() {	
				$last_update = isset( $this->plugins[ $this->plugin_slug ]->last_update ) ? $this->plugins[ $this->plugin_slug ]->last_update : false;
				if ( !$last_update ) { $last_update = $this->check_for_updates(); }
				if( ( time() - $last_update ) > $this->time_upgrade_check ){
						$this->check_for_updates();
				}
			} //end check_periodic_updates
			public function get_remote_version() {
				if ( isset( $this->plugins[ $this->plugin_slug ]->new_version ) ) {
					return $this->plugins[ $this->plugin_slug ]->new_version;
				}
				return false;
			}
			private function get_plugin_options() {
				//Get plugin options
				if ( is_multisite() ) {
					$options = get_site_option( 'pu_plugins' );
				} else {
					$options = get_option( 'pu_plugins' );
				}
				if ( !$options ) {
					$options = array();
				}
				return $options;
			}
			private function save_plugin_options() {
				//Get plugin options
				if ( is_multisite() ) {
					update_site_option( 'pu_plugins', $this->plugins );
				} else {
					$options = update_option( 'pu_plugins', $this->plugins );
				}
			}
			public function check_for_updates( $manual = false ) {
				if ( !is_array( $this->plugins ) ) return false;
				//Check to see that plugin options exist
				if ( !isset( $this->plugins[ $this->plugin_slug ] ) ) {

					$plugin_options = new stdClass;
					$plugin_options->url = $this->plugin_url;
					$plugin_options->slug = $this->plugin_slug;
					$plugin_options->package = '';
					$plugin_options->new_version = $this->version;
					$plugin_options->last_update = time();
					$plugin_options->id = "0";
					
					$this->plugins[ $this->plugin_slug ] = $plugin_options;
					$this->save_plugin_options();
				}
												

				$current_plugin = $this->plugins[ $this->plugin_slug ];
				if( ( time() - $current_plugin->last_update ) > $this->time_upgrade_check || $manual ) {
					//Check for updates
					$version_info = $this->perform_remote_request( 'get_version' );
					if ( is_wp_error( $version_info ) ) return false;
					//$version_info should be an array with keys ['version'] and ['download_url'] 
					if ( isset( $version_info->version ) && isset( $version_info->download_url ) ) {
						$current_plugin->new_version = $version_info->version;
						$current_plugin->package = $version_info->download_url;
						$this->plugins[ $this->plugin_slug ] = $current_plugin;
						$this->save_plugin_options();
					}
				}
				return $this->plugins[ $this->plugin_slug ];
			} //end check_for_updates
			
			public function plugin_row( $plugin_name ) {
				do_action( "pu_plugin_row_{$this->plugin_slug}", $plugin_name );
			}
			public function perform_remote_request( $action, $body = array(), $headers = array(), $return_format = 'json' ) {
			
				$body = wp_parse_args( $body, array( 
					'action' => $action,
					'wp-version' => get_bloginfo( 'version' ),
					'referer' => site_url()
				) ) ;
				$body = http_build_query( apply_filters( "pu_remote_body_{$this->plugin_slug}", $body ) );
				
				$headers = wp_parse_args( $headers, array( 
					'Content-Type' => 'application/x-www-form-urlencoded',
					'Content-Length' => strlen( $body )
				) );
				$headers = apply_filters( "pu_remote_headers_{$this->plugin_slug}", $headers );
				
				$post = array( 'headers' => $headers, 'body' => $body );
				//Retrieve response
				$response = wp_remote_post( esc_url( $this->remote_url ), $post );
				$response_code = wp_remote_retrieve_response_code( $response );
				$response_body = wp_remote_retrieve_body( $response );
				
				if ( $response_code != 200 || is_wp_error( $response_body ) ) {
					return false;
				}
				
				if ( $return_format != 'json' ) {
					return $response_body;
				} else {
					return json_decode( $response_body );
				}
				return false;
			} //end perform_remote_request
		
		//Return an updated version to WordPress when it runs its update checker
		public function update_plugins_filter( $value ) {
			if ( isset( $this->plugins[ $this->plugin_slug ] ) && $this->plugin_path ) {
				$value->response[ $this->plugin_path ] = $this->plugins[ $this->plugin_slug ];
			}
			return $value;
		}
		
} //end class
endif;
?>

Instantiating the Class

Somewhere in your plugin, you would instantiate the class (assuming you’ve included the class in with your plugin):

<?php
$args = array(
	'remote_url' => 'http://domain.com/remoteupgrade.php',
	'version' => '4.2.0.0',
	'plugin_slug' => 'wp-ajax-edit-comments',
	'plugin_path' => 'wp-ajax-edit-comments/wp-ajax-edit-comments.php',
	'plugin_url' => 'http://www.ajaxeditcomments.com',
	'time' => 43200
);
				
$upgrade = new PluginUpgrade( $args );
?>

The class accepts six parameters upon instantiation.

1. remote_url: A URL that the upgrader will ping to retrieve update information. I’ll get into this in a bit.
2. version: A string version number of the current plugin installed.
3. plugin_slug: A unique slug that identified your plugin.
4. plugin_path: The path to your plugin from the /plugins/ directory.
5. plugin_url: The URL to your plugin.
6. time: An integer in seconds that dictates how long to wait between upgrade checks. Default is 12 hours (or 43200 seconds).

On the remote side of it, assuming a URL with the http://domain.com/remoteupgrade.php path, you’ll need to return a JSON string of the new plugin’s version and a download URL.

When sending an update request, the class automatically passes an action POST variable to the remote_url. The default action for checking for upgrades is get_version.

At the remote_url location, you would do a check for an action variable and do something based on the action.

Here’s an example:

<?php
$action = $_POST['action'];
switch ( $action ) {
	case 'get_version': 
		echo json_encode( array( 
			'version' => '4.3.0.0',
			'download_url' => 'http://domain.com/downloads/wp-ajax-edit-comments.zip'
			) );
		break;
	case 'some_other_action':
		//...//
		break
} //end switch
?>

The upgrade class assumes two JSON variables being returned: version and download_url. How you get those values in your remote_url is up to you.

Public Methods

The class has two public methods to assist in performing other requests besides checking for plugin updates.

perform_remote_request

The perform_remote_request method allows you to perform an arbitrary remote request on the remote_url you specified. Again, this is action based.

Here’s an example:

$result = $upgrade->perform_remote_request( 'authkey_check', array( 'key' => $key ) );

The first argument is an action name. The second and third arguments are optional, and allow you to set header/body arguments respectively. A fourth argument is also optional, and allows you to specify the return format (e.g., json).

Here’s an example I have of retrieving a remote changelog:

$result = $upgrade->perform_remote_request( 'changelog', array(), array(), 'html' );

check_for_updates

If your plugin has an option to check for updates manually (without having to wait until the magic 12 hour mark), you can call the check_for_updates method. Just pass a true to the method to skip the time check.

$plugin_info = $upgrade->check_for_updates( true );

Class Hooks

• pu_remote_body_{$plugin_slug} – Filter – Allows you to add default body arguments for the remote request
• pu_remote_headers_{$plugin_slug} – Filter – Allows you to add default header arguments for the remote request
• pu_time_{$plugin_slug} – Filter – Allows you to overwrite the default time between upgrade checks

Conclusion

In summary, the class allows you to:

1. Automagically set up automatic upgrades upon instantiation. This requires you to pass some parameters back based on your remote_url.
2. Perform manual upgrade checks.
3. Perform arbitrary remote requests to your remote_url.
4. Set default headers/body arguments per filters.

I hope this can help get the ball rolling for other plugin authors.

The post WordPress Upgrade Class for Commercial or Client Plugins appeared first on WordPress and Ajax.

A formula for success:

1. Put together an idea and outline for a book that hasn’t been covered in-depth before.
2. Gather three of the most talented WordPress developers/writers and have them write the book.
3. Release the book and watch the Elves return back to Middle Earth to rejoice with men.

Professional Plugin Development, written by Ozh Richard, Justin Tadlock, and Brad Williams, is a much-needed and very timely book.

Even after releasing my own book (ahem), there were several that have approached me saying they needed a start-from-the-basics WordPress plugin development book. And while Professional Plugin Development does teach the basics of plugin development, it quickly moves on to much more complex topics.

The book covers the topics I care most about, such as:

• WordPress Plugin Foundation and Best Practices
• WordPress Security
• WordPress Actions and Filters (aka, hooks)
• And… (ahem) Ajax

But the book goes beyond basic plugin development. It teaches you about plugin options, CRON for scheduling common tasks, storing data (whether it is via post types, transients, or options), the HTTP API (for retrieving remote data), users (how to set up roles and capabilities), localization (err, internationalization), and how to test plugin performance.

For a novice PHP and WordPress developer, this is a good starting point. But don’t think of this book as your way to learn PHP, jQuery, or even basic WordPress (there’s WordPress for Dummies for that).

This is a book written by developers for developers. And I must say that I learned a lot from this book, and I’ve been developing WordPress plugins and themes for almost six years.

Here are the things I learned most from this book:

• The Why. I’ve used a lot of the techniques from the book before, but now I have a better understanding of why the techniques should be implemented. An example is security and WordPress coding best practices.
• Rewrites and Cron. These two topics escape me (no pun intended) for some reason, but I have a much better understanding of how everything works behind the scenes.
• Security. Security can not be stressed enough, and very solid security tips are sprinkled throughout the book (and the topic even receives treatment via its own dedicated chapter).
• Multisite. I’ve been working with multisite for almost a year now, and it’s a topic I’m still learning in-depth. The chapter gives a great explanation of terms and common pitfalls.

Last, but certainly not least, the book goes into great detail for what you should do after you’ve released a plugin, whether you want to release it for free in the official WordPress repo, or have it available exclusively on your own site (whether commercial or free). The book explains marketing, how to set up automatic updates (albeit a bit glossed over), and how to get the plugin on the official repo.

Professional Plugin Development (Amazon.com, non-affiliate) is a highly recommended purchase. It’s currently available for pre-order, but will be out soon. You can also pick up the ebook (Wrox.com, non-affiliate) at Wrox. Make sure you use the coupon code FROST to get a nice discount.

The post WordPress Professional Plugin Development Book Review appeared first on WordPress and Ajax.