Anyway, since this is a premium plugin we need a way to notify people of plugin updates. Frankly, I have never needed to do this, so I needed to figure it out. Luckily, I have a copy of Professional WordPress Plugin Development and in Chapter 9 there is very simple example of exactly what I wanted to do. Unluckily, the example doesn’t work… well, not entirely. It was always reporting an update, even if it was on the latest version. But I had enough information to trace down what was happening and figure out what I needed to change. By the way, the example code for the book is available from the publisher’s website.

So, without further adieu, this is a modified version of what I did:

This is the code I added to my plugin:

function my_plugin_plugins_api( $false, $action, $args ) {

	$plugin_slug = plugin_basename( __FILE__ );

	// Check if this plugins API is about this plugin
	if( $args->slug != $plugin_slug )
		return false;

	// POST data to send to your API
	$args = array(
		'action' 	=> 'get-plugin-information'
	);

	// Send request for detailed information
	$response = $this->my_plugin_api_request( $args );

	return $response;

}
add_filter( 'plugins_api', 'my_plugin_plugins_api', 10, 3 );

function my_plugin_update_plugins( $transient ) {

	// Check if the transient contains the 'checked' information
	// If no, just return its value without hacking it
	if ( empty( $transient->checked ) )
		return $transient;

	// The transient contains the 'checked' information
	// Now append to it information form your own API
	$plugin_path = plugin_basename( __FILE__ );

	// POST data to send to your API
	$args = array(
		'action' 	=> 'check-latest-version'
	);

	// Send request checking for an update
	$response = $this->my_plugin_api_request( $args );

	// If there is a new version, modify the transient
	if( version_compare( $response->new_version, $transient->checked[$plugin_path], '>' ) )
		 $transient->response[$plugin_path] = $response;

	return $transient;

}
add_filter( 'pre_set_site_transient_update_plugins', 'my_plugin_update_plugins' );

function my_plugin_api_request( $args ) {

	// Send request
	$request = wp_remote_post( http://api.url/location, array( 'body' => $args ) );

	if ( is_wp_error( $request ) || 200 != wp_remote_retrieve_response_code( $request ) )
		return false;

	$response = unserialize( wp_remote_retrieve_body( $request ) );

	if ( is_object( $response ) )
		return $response;
	else
		return false;

}

Then I setup a WordPress install for my API and created a custom template for the API page

/**
 * Template Name: API
**/

$action = $_REQUEST['action'];

// Create new object
$response = new stdClass;

switch( $action ) {

    // API is asked for the existence of a new version of the plugin
    case 'check-latest-version':
        $response->slug = 'my_plugin_slug';
        $response->new_version = '1.0.2';
        $response->url = 'http://plugin.url/';
        $response->package = 'http://plugin.url/download/location';
		break;

    // Request for detailed information
    case 'get-plugin-information':
        $response->name = 'my_plugin_name';
        $response->slug = 'my_plugin_slug';
        $response->requires = '3.3';
        $response->tested = '3.3.1';
	$response->rating = 100.0; //just for fun, gives us a 5-star rating :)
        $response->num_ratings = 1000000000; //just for fun, a lot of people rated it :)
        $response->downloaded = 1000000000; //just for fun, a lot of people downloaded it :)
        $response->last_updated = "2012-04-15";
        $response->added = "2012-02-01";
		$response->homepage = "http://plugin.url/";
        $response->sections = array(
            'description' =>  'Add a description of your plugin',
            'changelog' =>  'Add a list of changes to your plugin'
        );
        $response->download_link = 'http://plugin.url/download/location';
        break;

}

echo serialize( $response );

This isn’t exactly what I did, but it’s much more basic. Here are some things you can think about. First, the IssueM plugin uses an API key, so I send the API Key to api to verify the user has the right to update the plugin (say they don’t pay next year or something). The download_link setting is dynamic, for IssueM, it’s something like http://api.url/download/location?api=API_KEY. Then I have a separate script at the download location that will also verify the API Key and will send the latest IssueM plugin (which is located in a hidden directory). I also didn’t hard-code the downloaded argument, I actually track the downloads by using the dynamic download script. So my $response->downloaded actually equals get_option( ‘my_plugin_downloads’ ).

The download script I setup looks something like this:

/**
 * Template Name: Download Latest Version
 *
**/

$downloads = get_option( 'my_plugin_downloads', 100 );
update_option( 'my_plugin_downloads', ++$downloads );

$file = '/physical/location/of/your/file.zip';
$file_content = file_get_contents( $file );

header( 'Content-type: application/force-download' );
header( 'Content-Disposition: attachment; filename="my_plugin.zip"' );

echo $file_content;

exit;

You can completely customize and expand this code to do whatever you want. By adding extra arguments being sent to your API, you could have several plugins in this same repository. You can send API key information, host information, and anything else you’d need/want.

Name: Carson White

Email: carsonwhite@sti-creative.com

Comments: Hi,

We carried out a preliminary analysis on your website and discovered the following areas of concern.
1.    Your website attracts limited traffic, which affects potential sales.
2.    Your keywords don’t feature in Google first page, which affects visibility.
3.    Your back links are not good enough, which affects link popularity.
4.    Your website is not properly promoted, which affects the overall score.
We are a Search Engine Optimization service provider and can assist you in overcoming the above mentioned problems. We can perform a more detailed analysis on your website and provide you the plan of action of how we can promote the same.

Please let us know if you require the SEO REPORT on your website at no cost.

Best Regards,
Carson
Systems Technology International Inc.
Michigan: 39555 Orchard Hill Place, Suite 461, Novi, Michigan-48375
New York: 9921 4th Ave, Brooklyn, NY 11209
www (dot) sti-cs (dot) com

Notice: Under The Bill 1618 Title iii passed by the 105th US Congress this mail may not be considered SPAM as long as the contact information is included and a method to be removed from our mailing list stated. If you are not interested in receiving our e-mails then please reply with REMOVE in the subject line and your ID will be removed from our mailing list. We apologize for the inconvenience caused to you.

And my reply…

Hi Carson,

I’ve carried out a preliminary analysis of your email and discovered the following areas of concern.
1.    You think we are suckers.
2.    You most likely implement black-hat “SEO” services that end up hurting companies, rather than helping them.
3     You probably over charge your clients for a service that none of them need. Google actually does a pretty good job of figuring out what is important and what isn’t… without people trying to game the system.
4.    You emailed us about our site not ranking well, but how do you explain finding our site?
5.    The bill S.1618 Title III was passed by the Senate, but was not passed by the House. It takes both the House and the Senate to pass a law. Furthermore, a similar bill, H.R. 3888 was passed by the House, but was not passed by the Senate, thus and again, not making it law. Therefore, your email is SPAM.

We are intelligent human beings and can assist you in overcoming the above mentioned problems. We can help develop a training in ethics, philosophy, and logic and provide you with a plan of action of how to stop SPAMMING and SCAMMING innocent businesses.

Please let us know if you require these lessons at much cost.

Best Regards,

Lew Ayotte
Full Throttle Development, LLC
http://fullthrottledevelopment.com
http://twitter.com/full_throttle
http://twitter.com/lewayotte

For some reason he never replied.

However, SPAMMERS knowing exactly how WordPress works and how to inject comment SPAM into WordPress. Though, if you do not have comments automatically approved, they definitely should not appear… if a comment does get injected, the WordPress administrator (and author) should receive a notification of a pending comment. So, there is a simple way in WordPress Multi-Site to just set all comment and ping submissions to false. Just stick this little bit of code into a php file in the mu-plugins directory:

add_filter( 'pings_open', '__return_false', 10, 2 );
add_filter( 'comments_open', '__return_false', 10, 2 );

One of the Multi-Site installations that I have this enabled in wanted to allow comments on two of their sites. If this is something you need, just setup a mu-plugin php file that looks like this:

function comments_and_pings_closed( $open, $post_id ) {

	global $blog_id;

	$comment_sites = array( 10, 15 ); // Site IDs of site that you don't want automatically disabled

	if ( in_array( $blog_id, $comment_sites ) ) {

		return $open;

	}

	return false;

}
add_filter( 'pings_open', 'comments_and_pings_closed', 10, 2 );
add_filter( 'comments_open', 'comments_and_pings_closed', 10, 2 );

function custom_user_list_search( $query ) {

	if ( is_admin() ) {

		global $wpdb;

		if ( is_array( $qv = $query->query_vars ) && ( $s = trim( $qv['search'], '* \t\n\0\x0B' ) )
				&& ( $s = "%" . esc_sql( like_escape( $s ) ) . "%" ) ) {

			if ( !preg_match( '/' . $wpdb->usermeta . '/', $query->query_from ) )
				$query->query_from .= " INNER JOIN `" . $wpdb->usermeta . "` ON `" . $wpdb->users . "`.`ID` = `" . $wpdb->usermeta . "`.`user_id`";

			$query->query_where .= " OR ( `" . $wpdb->usermeta . "`.`meta_key` = 'last_name' AND `" . $wpdb->usermeta . "`.`meta_value` LIKE '" . $s . "' ) ";

		}

	}

	return $query;
}
add_filter( 'pre_user_query', 'custom_user_list_search', 15 );

I will probably expand this a little and create a WordPress plugin for it (if I can find the time).

NOTE: The trim regex should be this – ‘* \t\n\r\0\x0B’ – but the plugin I’m using is stripping the \r

This is a pretty big problem, all these social networks rate limit their connections (close to 300 requests per hour). So making 4000 requests in an hour could cause them to ban the user, or worse, ban leenk.me. So I’ve had to implement a rate limit of my own. I thought about doing this with iptables to block anyone who exceeds a certain number of requests per hour, but the violating users wouldn’t know what happened. I really wanted needed a way to prevent them from over-connecting to the social networks.

This is where the WordPress Transients API comes in. The transients API is very similar to the Options API but with the added feature of an expiration time. This is basically how the transients API works in WordPress:

// Save a transient to the DB
set_transient( $transient_name, $transient_value, $expiration );

• $transient_name – A unique identifier for your cached data.
• $transient_value – Data to save, either a regular variable or an array/object. The API will handle serialization of complex data for you.
• $expiration – Number of seconds to keep the data before refreshing.

// Get value of a transient from the DB
$transient_value = get_transient( $transient_name );

// Delete a transient from the DB
delete_transient( $transient_name );

The only problem with WP Transients is that there isn’t a good way to create “rolling transients” (as I call them). A rolling transient is a transient that rolls in time. In other words, I want to rate-limit a users connection by 1 hour from their current API call, but if the users does not make any API calls within the hour the transient should expire.

This is how I implemented “rolling transients”:

$call_limit = 350; // API calls (in an hour)
$time_limit = 60 * 60; // 1 hour (in seconds)
$transient_name = $host  . "_rate_limit"; // Using their host name as the unique identifier

// Check to see if there are any transients that match the name, if not create a new one
if ( false === ( $calls = get_transient( $transient_name ) ) ) {
	$calls[] = time();
	set_transient( $transient, $calls, $time_limit ); // Use an array of time() stamps for rolling effect
} else {
	// There is already a transient with this name
	$calls[] = time(); // Add a new time() stamp to the $calls array
	set_transient( $transient, $calls, $time_limit ); // Reset the transient (w/ expiration time)

	$call_count = count( $calls ); // How many calls have been made

	if ( $call_limit < $call_count ) { // If we're over the call limit, remove expired timestamps
		// Shift time from first element of array
		while ( $call = array_shift( $calls ) ) {
			// If time is >= current time - time limit, then it belongs in the array
			// Add it back and reset the transient
			if ( $call >= ( time() - $time_limit ) ) {
				array_unshift( $calls, $call );
				set_transient( $transient, $calls, $time_limit );
				break; // Stop processing, we're within the time_limit time now.
			}
		}

		// If we're still over the call limit, they've made too many requests in the time limit
		if ( $call_limit <= count( $calls ) ) {
			// The session needs to be killed
			die('Error: You have exceeded your rate limit for API calls, only ' . $call_limit . ' API calls are allowed every ' . $time_limit . ' seconds.');
		}
	}
}

With this code, you now have rolling transients... if your users exceed the number of calls within the past hour they will be rejected. If not, the transient will expire as it should. Let me know if you found this useful or if you have any tips for making it better (it seems a little "hacky" to me).

Regardless, this is my patch for the week – http://core.trac.wordpress.org/ticket/14996

If you insert a Video/Audio/Media link and have an apostrophe in the title, the link will have tried to escape the apostrophe with a backslash. My patch removes the unnecessary backslash. Pretty simple to fix.

I was working with a client a few weeks ago. They wanted to create a customer portal that allowed their customers to upload files to their website. Once their clients have uploaded the files, they needed to be able to download and delete the files from the server. There were a few plugins in the WordPress repository that had some form of media uploading, but none of them seemed to use WordPress’ built-in functions. So, I dug in a bit and figured out how WordPress does it so I could easily replicate that functionality.

The main function that to know about is media_handle_upload(). It is the bread and butter of WordPress’ media upload. It takes up to 4 arguments and returns one variable.

From the media.php file:

@param string $file_id Index into the {@link $_FILES} array of the upload
@param int $post_id The post ID the media is associated with
@param array $post_data allows you to overwrite some of the attachment
@param array $overrides allows you to override the {@link wp_handle_upload()} behavior
@return int the ID of the attachment

For my basic needs, I only needed to worry about the first two arguments, $file_id and $post_id … and really the the $post_id is optional unless you want to associate the file as an attachment to a specific post (which I did).

The media_handle_upload() function is is part of wp-admin, so for good measure I included wp-admin/includes/admin.php. This probably isn’t necessary if you’re in the backend — but if you have a front-end page that your logged in clients will use, then you will need to do the same.

What The Client Needed

A membership portal that allowed clients to log in, go to the “upload” section, and upload a file. Then to be able to go to a “files” section to retrieve and delete the files. To do this I created two theme templates, “Client Files” and “Client File Upload”.

File Upload

First a simple form with a file input…

	<form id="file-form" enctype="multipart/form-data" action="<?php echo $_SERVER['REQUEST_URI']; ?>" method="POST">
	<p id="async-upload-wrap">
	<label for="async-upload">Upload</label>
	<input type="file" id="async-upload" name="async-upload"> <input type="submit" value="Upload" name="html-upload">
	</p>

	<p>
	<input type="hidden" name="post_id" id="post_id" value="1199" />
	<?php wp_nonce_field('client-file-upload'); ?>
	<input type="hidden" name="redirect_to" value="<?php echo $_SERVER['REQUEST_URI']; ?>" />
	</p>

	<p>
	<input type="submit" value="Save all changes" name="save" style="display: none;">
	</p>
	</form>

The form calls itself, so I needed a function to check if the form has been submitted and calls the media_handle_upload() function…

if ( isset( $_POST['html-upload'] ) && !empty( $_FILES ) ) {
	require_once(ABSPATH . 'wp-admin/includes/admin.php');
	$id = media_handle_upload('async-upload', 1199); //post id of Client Files page
	unset($_FILES);
	if ( is_wp_error($id) ) {
		$errors['upload_error'] = $id;
		$id = false;
	}

	if ($errors) {
		echo "<p>There was an error uploading your file.</p>";
	} else {
		echo "<p>Your file has been uploaded.</p>";
	}
}

I chose to hard code the post ID 1199 in this code. Not the best solution, but it serves its purpose. 1199 is the page ID of the page I created to have all the attachments associated with. This solves the next problem, how to display all the uploaded files. This way my client can download and delete them the files from an easy to access page.

Client Files

The client files page is another template, I actually set it as a private page and added some permissions so only the administrator can see the page. Since all the attachments uploaded should be associated with this page, I needed to create a special query that got all those attachments and display them in a neatly organized table…

$args = array(
	'post_type' => 'attachment',
	'numberposts' => null,
	'post_status' => null,
	'post_parent' => 1199 //Post ID of Client Files page
);
$attachments = get_posts($args);

if ($attachments) { ?>
<form id="file-form" action="<?php echo $_SERVER['REQUEST_URI']; ?>" method="POST">
	<table style="width: 100%;">
	<tr>
		<td style="width: 50px; text-align:center;">Delete?</td>
		<td style="width: 150px;">Attachment</td>
		<td style="width: 50px;">Username</td>
		<td style="width: 150px;">Name</td>
	</tr>

	<?php
	foreach ($attachments as $attachment) {
	?>
	<tr>
		<td style="text-align:center;"><input type="checkbox" id="attachment_id" name="attachment_ids[]" value="<?php echo $attachment->ID ?>" /></td>
		<td><a href="<?php get_the_attachment_link($attachment->ID); ?>"><?php echo apply_filters('the_title', $attachment->post_title); ?></a></td>
		<td><?php the_author_meta( 'user_login', $attachment->post_author ); ?></td>
		<td><?php the_author_meta( 'first_name', $attachment->post_author ); ?> <?php the_author_meta( 'last_name', $attachment->post_author ); ?></td>
	</tr>
<?php
}
?>

	<tr>
		<td colspan="4">
		<input type="submit" value="Delete" name="html-delete">
		</td>
	</tr>
</table>

Just like the previous template, this form calls itself whenever the client tries to delete a file. So I needed to add a test to see if the delete function was called with the attachment ID(s) to delete. The form is using an array, so the client can delete multiple files at once.

if ( isset( $_POST['html-delete'] ) ) {
	if ( isset( $_POST['attachment_ids'] ) ) {
		foreach ($_POST['attachment_ids'] as $id) {
			wp_delete_attachment($id, true);
		}
	}
}

And that’s it… it is actually quite simple. Using the media_handle_upload() function reduces a lot of extra work. There is no sense in re-inventing the wheel and usually with WordPress you don’t have to.

I’ve stripped down this code a bit for this tutorial. You should be able to use it as a framework for creating your own pages. Obviously you should keep security in mind, making sure people have the right permissions to see these pages, etc.

Let me know if you have any questions, I’d love to hear your feedback!

If you found this post, useful, please consider donating 1$ to help fund my and my wife’s adoption… click here for details.

The first line I needed to change was the PHP function call strip_tags(). I need to set it to allow the <a> tag… very simple to do:

Original Line:

$text = strip_tags($text);

New Line:

$text = strip_tags($text, '<a>');

The second line I needed to change was where WordPress splits the excerpt up into separate words. This was a bit tricky because you run into an issue where you could be cutting of the </a>, which could screw up your entire page. I decided the best thing to do would be to treat the entire hyperlink as a single word. So, <a href=”http://lewayotte.com/”>My Website</a>, would count as a single word. By default, WordPress creates a 55 word excerpt. That is pretty easy to change as well.

Original Line:

$words = preg_split('/[\n\r\t ]', $text, $excerpt_length + 1, PREG_SPLIT_NO_EMPTY );

New Line:

$words = preg_split('/(<a.*?a>)|\n|\r|\t|\s/', $text, $excerpt_length + 1, PREG_SPLIT_NO_EMPTY|PREG_SPLIT_DELIM_CAPTURE );

Next, you simple need to remove the current wp_trim_excerpt filter and add a new one that points to your new function. Here is what the entire block of code looks like for me:

<?php
function new_wp_trim_excerpt($text) {
	$raw_excerpt = $text;
	if ( '' == $text ) {
		$text = get_the_content('');

		$text = strip_shortcodes( $text );

		$text = apply_filters('the_content', $text);
		$text = str_replace(']]>', ']]>', $text);
		$text = strip_tags($text, '<a>');
		$excerpt_length = apply_filters('excerpt_length', 55);

		$excerpt_more = apply_filters('excerpt_more', ' ' . '[...]');
		$words = preg_split('/(<a.*?a>)|\n|\r|\t|\s/', $text, $excerpt_length + 1, PREG_SPLIT_NO_EMPTY|PREG_SPLIT_DELIM_CAPTURE );
		if ( count($words) > $excerpt_length ) {
			array_pop($words);
			$text = implode(' ', $words);
			$text = $text . $excerpt_more;
		} else {
			$text = implode(' ', $words);
		}
	}
	return apply_filters('new_wp_trim_excerpt', $text, $raw_excerpt);

}
remove_filter('get_the_excerpt', 'wp_trim_excerpt');
add_filter('get_the_excerpt', 'new_wp_trim_excerpt');

Regular Expression Explained

I changed /[\n\r\t\s ]/ to /(<a.*?a>)|\n|\r|\t|\s/ because I needed to capture everything in the <a> HTML tags and count it as a single word. \n, \r, \t, \s are all pretty basic regex characters that preg_split() is using to break up the content. (<a.*?a>) is what captures everything in the <a> tag. The .* means all “characters” adding the ? to .* makes it “non-greedy.” This for the case where there are multiple hyperlinks in the content. It prevents the regex from thinking <a href=”link1″>link 1</a>, <a href=”link2″>link 2</a> is a single word. The parenthesis simply group the <a.*?a> together, so it doesn’t try to split those items separately and then I needed to add PREG_SPLIT_DELIM_CAPTURE to preg_split, or preg_split would have just removed the link as garbage.

You should be able to use this as a pretty solid base for adding other HTML tags.

When I first researched this there weren’t many plugins for WordPress Multi-Site that handled AD/LDAP authentication. I was planning on writing one myself, but I found one yesterday by Clifton Griffin called Simple LDAP Login. I installed in on a development website, put in the necessary information and BAM it worked… but it wasn’t really designed for WordPress Multi-Site. What I needed was every site to use the Active Directory authentication, without having to set each site up individually. So I paired down the code a bit (to just what I needed) and stuck the files in the mu-plugins dir.

Clifton used the opensource PHP LDAP Class in his plugin, which works great. So, in my version, I stripped out everything I didn’t need/want like auto account creation, non-AD functionality, etc. Basically, I just needed to authenticate users via Active Directory.

So I stuck this code into a file in my mu-plugins folder. Now whenever anyone tries to authenticate it, uses Active Directory instead of WordPress’ user table:

<?php
require_once( WPMU_PLUGIN_DIR . '/simple-ldap-login/adLDAP.php' );

define( 'DOMAIN_CONTROLLERS', 	'active.directory.controller.domain' );
define( 'SECURITY_MODE', 		'high' );
define( 'ACCOUNT_SUFFIX', 		'@account.edu');
define( 'BASE_DN', 				'OU=OUOU,DC=DCDC,DC=EDU' );
define( 'USE_TLS',				false );
define( 'USE_SSL', 				true );

//Authenticate function
function sll_authenticate( $user, $username, $password ) {
	if ( is_a( $user, 'WP_User' ) ) { return $user; }

	//Failed, should we let it continue to lower priority authenticate methods?
	if( "high" === SECURITY_MODE ) {
		remove_filter('authenticate', 'wp_authenticate_username_password', 20, 3);
	}

	if ( empty( $username ) || empty( $password ) ) {
		$error = new WP_Error();

		if ( empty( $username ) )
			$error->add( 'empty_username', __( 'ERROR: The username field is empty.' ) );

		if ( empty($password) )
			$error->add( 'empty_password', __( 'ERROR: The password field is empty.' ) );

		return $error;
	}

	if( sll_can_authenticate( $username, $password ) ) {
			$user = get_userdatabylogin( $username );

			if ( !$user || ( strtolower( $user->user_login ) != strtolower( $username ) ) ) {
				do_action( 'wp_login_failed', $username );
				return new WP_Error( 'invalid_username', __( 'Login Error An error occurred while attempting to log in. If this continues please contact coeweb@uga.edu for support.' ) );
			} else {
				//we're ready to return the user
				return new WP_User( $user->ID );
			}
	} else {
		return new WP_Error( 'invalid_username', __( 'Login Error An error occurred while attempting to log in. If this continues please contact coeweb@uga.edu for support.' ) );
	}
}
add_filter( 'authenticate', 'sll_authenticate', 1, 3 );

function sll_can_authenticate( $username, $password ) {
	$sll_options = array(
		'account_suffix'		=>	ACCOUNT_SUFFIX,
		'base_dn'				=>	BASE_DN,
		'use_tls'				=>	USE_TLS,
		'use_ssl'				=>	USE_SSL,
		'domain_controllers'	=>	explode( ';', DOMAIN_CONTROLLERS )
	);

	$adldap = new adLDAP( $sll_options );

	$result = false;
	$result = $adldap->authenticate( $username, $password );

	return $result;
}

From Matt Mullenweg’s hands, to your eyes; read’em and weep!

Today I ran into this problem with a WPMS site that I am developing. I needed to pull posts from the “news” site onto the main site. I used switch_to_blog() to do this, but when I tried to get specific category permalinks with get_category_links() it would automatically include “/blog/” in the URL.

This is because of the way that the $wp_rewrite variable is initialized and an attempt to reduce overhead when using switch_to_blog(). So, John’s plugin does come with a risk of added overhead, but I’m currently dealing with a 30 site installation and don’t see much of  a cost. If you were really picky, you could modify his code a bit to only work in real specific situations.

If you get  a chance, jump on over to twitter and thank him for this little plugin. It saved me a little more development work, although it also meant I wasted 2 hours tracking down the problem :).

Generally speaking, in WPMS / WPMU you can get the content of one site by switching to that site ID using the switch_to_blog($id) function. However, this does not work with Event Calendar 3, because of the way it builds it’s global $ec3 variable.

The problem is, when you are on site id 1, the $ec3 creates a variable that points to the schedule table for site id 1. Even if you run switch_to_blog(2), $ec3 still tries to get the schedule from site id 1. So it was returning an empty calendar. The easiest way to fix this (until EC3 updates their code) was to re-instantiate the global $ec3 variable. Basically this is what I did:

switch_to_blog(10);
global $ec3;
$ec3 = new ec3_Options();
ec3_get_calendar();
restore_current_blog();

This re-instantiates the $ec3 variable for the schedule I needed to get from that specific site ID. It should be a fairly simple fix for EC3. Until then, this is the easiest fix if you need to do what I’m doing.

Luckily there are two filters that can be used to set the arguments your client needs and maintain the ability for them to modify the widget location from the WordPress backend.

1. widget_tag_cloud_args – lets you set the wp_tag_cloud arguments
2. wp_tag_cloud – lets you edit the wp_tag_cloud output

So, for my clients need’s, I just needed to set the small and large font size arguments and change the widget output a little to fit their sidebar properly. I added these lines to the theme’s function.php:

function tag_cloud_args() {
	$args = array( 'smallest' => 8, 'largest' => 14 );
	return $args;
}
add_filter('widget_tag_cloud_args', 'tag_cloud_args');

function tag_cloud($return) {
	$return = "<div class="box menu tags">" . $return . "</div>";
	return $return;
}
add_filter('wp_tag_cloud', 'tag_cloud');

As with any function in WordPress, be sure to check out the codex for all the Tag Cloud Arguments that you can use.

I’m working on a project, that requires people to add excerpt text in a page. By default excerpts are not enabled in WordPress for pages but there is a simple function you can add to your functions.php file to enable Page Excerpts.

Locate you functions.php file in your theme’s directory and add this line of code to it:

add_post_type_support('page', 'excerpt');

Now you will see the Excerpt box below the Content box on your pages. For more information about the add_post_type_support function, check out the WordPress Codex. Have fun!

WordPress MU currently has a minimum limit of four characters set in its core. Unfortunately, this limit is still imposed in WordPress MS 3.0. The limit is probably there because usernames were used for the domain too and WP-Devs didn’t want to conflict with country codes. But that is not an issue for my client, so I wanted to kill the limit (without touching core).

Basically, I wrote a quick mu-plugin that unset the error message when someone tries to add a user with fewer than four characters. Doing this removes any halts that would stop processing the new user. Here is my code:

function remove_username_char_limit($result) {
  if ( is_wp_error( $result[ 'errors' ] ) && !empty( $result[ 'errors' ]->errors ) ) {

    // Get all the error messages from $result
    $messages = $result['errors']->get_error_messages();
    $i = 0;
    foreach ( $messages as $message ) {

      // Check if any message is the char limit message
      if ( 0 == strcasecmp("Username must be at least 4 characters", $message)) {
        // Unset whole 'user_name' error array if only 1 message exists
        // and that message is the char limit error
        if ( 1 == count($messages) ) {
          unset( $result['errors']->errors['user_name'] );
        } else {
          // Otherwise just unset the char limit message
          unset( $result['errors']->errors['user_name'][$i] );
        }
      }	

      $i++;
    }
  }

  return $result;
}
add_action('wpmu_validate_user_signup', 'remove_username_char_limit');