In my hunt, I noticed WordPress has a built-in core function called make_clickable(). Like the name implies, it would scan the provided value and make all the URLs into clickable links. It worked just fine, but I also wanted user mentions and hashtags, so I went a step further and made my own function, aptly named make_twitter(). Check it out below:

<?php 
//place the following in functions.php or the like

function make_twitter($tweetcontent) {
  $tweetcontent = preg_replace("/[@]+([A-Za-z0-9-_]+)/", "\\0", $tweetcontent );
  $tweetcontent = preg_replace("/[#]+([A-Za-z0-9-_]+)/", "\\0", $tweetcontent );
  $tweetcontent = preg_replace("/((http)+(s)?:\/\/[^<>\s]+)/i", "\\0", $tweetcontent );
  return $tweetcontent;
}

//then use the function in your templates like so:

echo make_twitter(get_the_content()); ?>

What it does is actually pretty simple. First, place the make_twitter() function into your functions.php file (or wherever you're stashing your functions). Next, use make_twitter() in your templates. All you've gotta do is provide the tweet content, in this case my post content, so I use get_the_content().

Once my function receives the tweet, it simply runs a couple of regular expressions to sniff out the usernames, hashtags, and URLs, replacing them with proper links. On my project, I even changed the user link to the local site profile (since our accounts mirrored the Twitter account namespace).

Follw on Twitter

@wpatx – I’m running the official WordPress Austin Twitter account now, you should follow it!

Comments

Jetpack – Has a new module that allows users to subscribe to comments.
Disqus – A managed plugin that adds new community features to comments.
Intense Debate – A plugin managed by Automattic that adds social features to comments.
Social Plugin for WordPress – A light(er)weight plugin by Crowd Favorite for allowing comments via Twitter and Facebook.
Livefyre – The new kid on the block, with added features like live comments.
Akismet – Quality spam protection for your growing comment section.

Ask questions

Topic Tueday – A new question once a week that is locked to comments from users only. A point multiplier is also in effect.

Poll Your Audience

PollDaddy – A powerful and easy to use poll plugin maintained by Automattic.
WP-Polls – A lightweight poll plugin written by Lester ‘Gamerz’ Chan.

Newsletters

Mailchimp – A paid (and thus pretty awesome) email newsletter solution.
Mailchimp Subscribe Plugin – A easy widget for newsletter subscriptions.
Jetpack – Has a new module that allows users to subscribe to your blog.
Feedburner – An old-school RSS tool that offers an email newsletter digest.

Get Social

Social Bartender – Easy, WP-menu-like drag and drop setup for all your social network links.
Sociable – Configurable sharing links and widgets for all your content.
Explore – There are more social plugins than hairs on my head. Check them out and find out that works for you!
Pin it! – A Pinterest plugin for adding a ‘Pin it’ button to your content.
Easy Pinterest – Display your latest pins and boards in your WordPress sidebar.

Identity / Influence

And Me Account – A sample account from my site, showing real name, user pic, user score, percentile rank, and links to various social accounts.
Gravatar – A widely used avatar service maintained by Automattic.
Cubepoints – A lightweight point tracking system with modules that make for easy customization.
Bunchball – Full-bore gamification with badges and achievements and all that stuff.

Contests

Pick Giveaway Winner – A super simple plugin for running bespoke contests with user comments.
25 Days of Tegra – My biggest promo to date, where we gave away a device per day only to users, generating tens of thousands of user interactions.
#HackTheNews – A sample contest I ran on Android and Me where users could tweet stories with tweaked headlines, generating over 1k tweets in barely a week.
Midweek Madness – A weekly contest with usually small prizes.

Do Things with your Users

get_users – A new (since 3.1) function for working with users. Makes things super simple (compared to the old ways, at least).
update_user_meta – A super-handy function for adding and updating extra information to any user account. Use with get_user_meta.
orderby=comment_count – A parameter you can use when querying posts to return the most commented posts.

Are there any community plugins you can’t live without? Or something new you’ve seen floating around that you’d like me to investigate and talk about during my session tomorrow? It doesn’t even have to be a plugin really, feel free to leave me some broad questions about practice or strategy, I’m really just looking for some extra angles to cover to make sure everyone finds use in tomorrow’s talk.

What you’re looking at is a screen capture from my Android Tablet, the Transformer Prime. I’ve got the matching keyboard dock, so this thing is damn near feeling like a ‘real’ computer.

In the right pane, you’ll see a list of files I’ve got open, in this case some WordPress templates direct from my SFTP server. Using SFTP is a pro feature, as well as editing direct to Dropbox, both of which are well worth a dollar.

Go download it in the Android Market.

<?php 
add_filter( 'avatar_defaults', 'newavatar' );  
function newavatar ($avatar_defaults) {  
$myavatar = get_bloginfo('template_directory') . '/images/avatar.png';  
$avatar_defaults[$myavatar] = "Pigs";  
return $avatar_defaults; } ?>

This is a pretty simple one. Our function newavatar() is hooked to the avatar_defaults, and we simply add our new avatar choice, which includes a path to the image URL along with a title (pigs!). At the end, we return the defaults, which has been impregnated with our new custom avatar, and no one is ever the wiser!

Some days we only wanted users who had added their Twitter account to the profile (a piece of user meta), some days we wanted only members of a certain age to be eligible (a piece of user meta compared to a set value), and overall, we wanted all comments to be from registered users only (private comments on certain WordPress posts).

To accomplish all these things, I came up with the simple hack of creating a slew of conditional checks that surround comment_form(). If you’re not familiar, it’s a function that outputs the comment form itself and is usually found near the bottom of comments.php. It’s a pretty easy way to control who is commenting, taking away the form. Take a peek a the heavily commented code below (no pun intended) and join me after for some play by play.

<?php 
//start by checking for a couple of key pieces of info
$current_user = wp_get_current_user();
$private_comments = get_post_meta($post->ID, 'private_comments', true);
$meta_lock = get_post_meta($post->ID, 'meta_lock', true);
$time_lock = get_post_meta($post->ID, 'time_lock', true);

//if the post has the custom field 'meta_lock'
if ($meta_lock) {
  //check the current user for that meta field
  $user_meta_key =  get_user_meta($current_user->ID, $meta_lock, true);
    if ($current_user->ID AND $user_meta_key) {
      //display the comment form
      comment_form();
      //give an error message (add some flare!)
    } else { echo 'Special users only!'; }

//if the post has the custom field 'time_lock'	
} elseif ($time_lock) {
  //get the age of the user and prepare the age limits
  $user_age=date("Y-m-d", strtotime($current_user->user_registered));
  $age_limit = strtotime($time_lock);
  $account_age = strtotime($user_age);
  
  //if the current user is OLDER than the set limit
  if ($current_user->ID AND $account_age <= $age_limit) {
    //display the comment form
    comment_form();
  //give an error message (add some flare!)
  } else { echo 'Users older than '.$tegra_time.' only!'; }

//if the post has the field 'private_comments'	
} elseif ($private_comments) {
  //check if the user has an ID (aka is signed in)
  if ( $current_user->ID ) {
    //display the comment form
    comment_form();
  //give an error message (add some flare!)
  } else { echo 'Users only!'; }

//no special conditions met, just display the comment form  
} else { comment_form(); } ?>

Jeeeez that's a scary wall of text! Ok, not really, but compared to just the single line comment_form() we started with it looks pretty major. What we're doing is actually pretty simple. Anytime the template would normally call comment_form, we're getting in the way and checking some settings first.

What settings? Things we set on a post per post (or page) basis, using custom fields. If you'd like to turn on user-only comments, set a custom field 'private_comments' with any value (I usually just go with 'true'). If you'd like to restrict comments based on whether or not a user has a certain meta field, on your post set a custom field with the key 'meta_lock' and a value matching whatever user meta you'd like to filter by. This can be a user's real name, website link, bio, etc. It's a great way to push your users to fill out certain fields of their profile.

One of the funnest challenges we did was based on user age, something you'll see in the snippet above as age_lock. To use it, simply set a custom field on your post with a YYYY-MM-DD format (one year before today's date, for example). When comments.php is rendered, it'll compare the date the user registered with the date you've entered in the field 'age_lock'.

These few examples are really just to get the juices flowing, and to introduce you to the simple hack of conditionally displaying the comment form. There are an infinite number of things you could check or compare, so if you explore and find something killer make sure you come back and share it with us.

So far, I think my favorite use of this technique was tracking user tweets with the service Rowfeeder, which I then used to export a full list of Twitter usernames. Since our accounts let users link their Twitter handle, I was able to check which WordPress accounts had successfully Tweeted and then conditionally allow them to comment. Total score!

For those of us with a sizable user base contained only inside WordPress however, actually doing things with users takes a bit of elbow grease. I’m sure all the same possibilities exist, but people don’t seem to talk or write about them as often, which is where this guide comes in.

Today we’re going to look at getting WordPress to sort users by a custom meta value, something that would be useful if your users have any sort of scores, totals, or custom profile fields.

Over on Android and Me, all users have a point total. We then rank all users by that point total and assign everyone a percentile rank. To call up thousands of users based on a custom meta value seemed daunting, and it was, until I got a bit more familiar with WP_User_Query.

WP_User_Query was introduced in WordPress 3.1 and brings us an easy and flexible way to query our user database. We’ll be using the function get_users, which is basically a wrapper for WP_User_Query. You’ll notice the function includes an ‘orderby’ parameter, but the only options given are:

orderby – Sort by ‘nicename’, ‘email’, ‘url’, ‘registered’, ‘display_name’, or ‘post_count’.

Notice we’re missing ‘meta_key’ or ‘meta_value’, so we’re on our own when it comes to ordering these guys by a custom field. Also of note is ‘post_count’, which I could totally see coming in handy on certain community blogs (MAKE A NOTE!). Now that we know what we’re after and what tools we’ll need to make it happen, it’s time we get started.

The Code

<?php 
//these are the arguments for the get_users function below
$args  = array(
  'fields' => 'all_with_meta',
  'meta_query' => array(
    array(
    'key' => 'points', // the meta field (or key) we want to target
    'value' => '2',    // the value we want to target (optional)
    'compare' => '>='  // comparison method (optional:  =, >, <, etc)
    )
));

//get_users calls WP_User_Query and returns an array of matching users
$users = get_users($args);

//custom function for comparing the data we want to sort by
function cmp($a, $b){
  if ($a->points == $b->points) {
    return 0;
  }
  return ($a->points > $b->points) ? -1 : 1;
}

//usort sorts our $users array with our function cmp()
usort($users, 'cmp');

//leaving an array of $users sorted by the value of meta 'points'
foreach ($users as $user) {  
  // do something rad!
} ?>

I've commented the code above so hopefully you were able to follow along in the actual markup, but if you'd like a short summary: here we go!

I start off with a short list of arguments, or options, that get_users() needs to return the users I want. A full list of parameters can be found on the get_users page in the Codex. The key here is meta_query, which lets me specify the user meta field I'd like to target and compare. I so happen to be calling up users based on their point totals, so I call any user with points above or equal to 2 (any below that I can assume is a scrub and just rank at the bottom of the pile to save some query juice).

Once I've got my $args, I go ahead and run get_users($args). Doing so will return a full list of users that match the arguments, all handily stored in the array $users.

But what's that? They aren't sorted? While we were allowed to compare points while calling the users, no actual sorting took place. This is where we get a bit tricky. Instead of relying on WordPress to sort the users for us, something the Codex says isn't possible right now, we're going to bust out PHP's usort along with a simple custom function for comparing the points.

Our custom function, cmp(), is just a little check that runs that compares the point total of a user with the other point totals in the array. If the totals are the same, the function returns '0'. If they are different, the function returns a '1' or '-1'. That simple math is enough to let usort crunch through thousands of users in seconds, something I'd spent a couple weeks trying to figure out how to make WordPress do for me. Oh well, you know how that goes.

Now that we've got $users in order by the meta field 'points', all that's left is to do something rad. Simply use a foreach (PHP's version of The Loop) to run through the users in the array and accomplish something. In my case, it was doing even a bit more math to calculate each user's percentile in order to show what everyone's point totals really meant in relation to one another.

I know not everyone's blog has a point system, but if you've got any amount of users or even multiple authors this might come in handy. I used WP_User_Query all over the place on the WordUp Austin site. On Android and Me, I list the author pictures in the sidebar. Now, if I wanted to, I could order them by post count or point totals.

Slowly but surely I'm accumulating bits of community-focused solutions like this one and soon I'll be able to say with complete certainty that my WordPress install would slay any bbPress or BuddyPress install you can toss at it.

After a while, I realized that even without a rate limit being imposed by AppAware, some of my calls were failing. To lighten the load, I turned to the WordPress Transients API, a super simple way of saving (or caching) data for later use. Because saving a transient stores the data locally, you won’t need to make as many external calls, which is good for you and for your API partners.

What is the Transients API?

If you’re an experienced developer and you’re familiar with the concept of caching, you can probably skip this section. The code samples are below. But if you don’t know a thing about saving data locally, WordPress says: the Transients API offers a simple and standardized way of storing cached data in the database temporarily by giving it a custom name and a timeframe after which it will expire and be deleted. Also of note is that Transients are inherently sped up by caching plugins, where normal options are not.

For this reason, transients should be used to store any data that is expected to expire, or which can expire at any time. Transients should also never be assumed to be in the database, since they may not be stored there at all.

This makes transients the perfect solution to storing data you would otherwise call from a 3rd party. Ideally, when you need the data, you’ll first check to see if the transient exists. If it does, you use that data. If it doesn’t, you call for a fresh version of that data, when you then not only use, but save and timestamp for later use. Sound simple enough?

Setting and getting transients

The main functions we’ll be using are, predictably, set_transient and get_transient, both of which couldn’t be simpler. To get started, let’s look at the absolute first step, saving a transient. If you’ve ever saved meta data using update_post_meta or update_user_meta, this should look totally familiar to you.

<?php set_transient( $transient, $value, $expiration ); ?>

The function accepts three arguments, all of which are pretty straight forward. First, $transient is the name of the actual piece of data to be stored. This is the unique ID by which you'll call the data later, so make it good. The $value is the actual data being stored, aka the payload. You'll use $expiration to set the time limit on this transient, in seconds. When the time expires, so does the data.

Once you've got some data saved, you'll likely want to call it in your templates. Getting a transient is even easier than setting it:

<?php get_transient( $transient ); ?>

Here, again, $transient is the unique identifier of the data your looking for. There isn't much to explain here. When you call the transient, if the time limit hasn't expired, you'll have the data to do as you please. If the data has expired and you still need it, things get a tiny bit more complex, which brings us to my next point...

Putting it all together

Our sample case will be displaying our Klout score, via the Klout API. Like I said, this Transients API should be used for time-sensitive data, data that changes or that needs to be refreshed at a reliable interval. And while we're discussing use, it doesn't have to be external data, you could use it to store just about anything. We're just going the API route during the example to score some bonus points.

I've heavily commented the code below, but the basic path goes like this. First, we'll attempt to call the transient. If the data exists, our job is done and we use it. If the data doesn't exist or has expired, we'll call for a fresh copy from the Klout API, which we'll then save and immediately use.

The entire process is basically an if statement that uses both set_transient and get_transient.

<?php //let's get my klout score!!

//first, let's see if I've got the data already cached locally
$klout = get_transient("klout"); 
  
  //dang it! it looks like I might not. let's check with the Klout API
  if( !$klout ) {  
    $json = file_get_contents("http://api.klout.com/1/klout.json?key=[API key]&users=clarklab");
    $return = json_decode($json, true);
    $kloutscore = $return["users"][0]["kscore"]; 

    //if the Klout API gave us a score, let's save it!
    if( $kloutscore ) {
      
      //in a field named "klout", we'll save our $kloutscore, for 12 hours (60 seconds x 60 minutes x 12 hours)
      set_transient("klout", $kloutscore, 60 * 60 * 12);

      //let's also make sure to set the data you were originally looking for
      $klout = $kloutscore;  
    }  
  }
	
echo 'Now I can safely check my '.$klout.' score with transients!'; ?>

The main check is if( !$klout ), which, of course, checks to see if the value $klout is set, which we attempted to do with get_transient. If it is not, we know we need to fetch a fresh copy of the data and save it (set_transient). Since we're using a private API, you'll need to replace [API key] with your personal API key (duh).

If you wanted to get fancy, you could always work in the delete_transient function, but since these things expire with time I'm content to be the lazy type and just let decay do its work.

Go forth and cache

Equipped with your new army of drifter data you're ready to speed up page loads by reducing reliance on often slow external API calls. And if you're dealing with a rate-limited API, caching is a necessity, so you might as well do it with a supported WordPress API.

For bonus points, my example will be pulling the prices from a custom field on a WordPress post using get_post_meta. If you’re not running WordPress, you could just include the plain text prices in the script (where I set $deal_price and $old_price).

<?php
$deal_price = get_post_meta($post->ID, 'deal_price', true);
$old_price = get_post_meta($post->ID, 'old_price', true);
$discount = round(((1-($deal_price / $old_price))*100),0);
echo $discount.'%'; ?>

If you recall math class, to find a percentage you first divide the new price by the old price. Then to find the discount, you subtract from one and multiply by 100, leaving you with the actual percentage discount on the original price (rounding to zero decimal places).

Again, this is a simple one, I just wanted to log it for posterity’s sake.

The themes will be fully responsive for perfect performance on all devices and will have only a minimal set of theme options (which will be completely removable, if desired, like I would). A good bit of the design is going to be done by @angiedoes, so I know things will come out looking sharp.

Sound off in the comments below if you’ve got some extra ideas. I’m starting the builds pretty soon and I’m still open to feature suggestions…