WordPress has tons of APIs to do tons of things. It really does. One of the cool ones that I’ve been using a lot lately, has been around for a bit. It’s the Ajax API. Sure, you could write your own Ajaxy thing but why do that when WordPress lets you do it all very simply.
This tutorial will show you how to replicate the functionality that is presented in the “Like” button at Facebook. It assumes that you have WordPress set to require users to be logged in to take such actions. It wouldn’t make much sense for someone to not be logged in for such functionality. Obviously, you could do something else with Ajax (polls? Loading new content?) that doesn’t have the same assumption, but in this case… we’re assuming a user is logged in and the $current_user global is set.
Getting Started
Let’s start with the basic PHP class (you do write good object-oriented code, right?)
1 2 3 4 5 6 7 8 | class My_Like_Button { function __construct() { } } $my_like_button = new My_Like_Button; |
This code is just a basic skeleton that provides a constructor (the __construct() method, which I’ll use later. It also instantiates a new My_Like_Button object and assigns it to the $my_like_button variable for use in the global scope. Obviously, you can use whatever strikes your fancy for the class name or the global variable.
Building the HTML for the Like Button
Next, we need the basic HTML structure that will be used in our theme for the Like button. For the sake of simplicity, I’m not providing any CSS, but feel free to do as you wish. We need to add this as a new method in our class.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 | function like_button() { if( !is_user_logged_in() ) return false; global $current_user; $html = '<form action="" method="post"> <input type="hidden" name="like_post_id" id="like_post_id" value="' . get_the_ID() .'"> <input type="hidden" name="like_user_id" id="like_user_id" value="' . $current_user->ID . '"> <input type="button" name="like_this_post" id="like_this_post" value="Like" /> </form>'; return $html; } |
This form provides two hidden form fields using get_the_ID() and the $current_user object. Having done this (and after ensuring there is a logged in user), we can now drop this into our theme in the Loop as a template tag:
1 | <?php echo $my_like_button->like_button(); ?> |
Sending the Ajax Request with jQuery
This is useless by itself. We need something to handle the Ajax. But before we get there, we need to understand how Ajax works within the WordPress context.
All requests must go to wp-admin/admin-ajax.php. Forget the confusion about why you would send a front-end Ajax request to the back-end. You just do.
On the back-end, you’ll have to define functions that will hook into the Ajax API to let WordPress know how to handle the request. More on that in a minute. Let’s build some jQuery to send this to admin-ajax.php.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 | function js() { wp_enqueue_script( 'jquery' ); wp_print_scripts(); ?> <script> jQuery(document).ready(function(){ jQuery('#like_this_post').click(function(){ var like_post_id = jQuery('#like_post_id').val(); var like_user_id = jQuery('#like_user_id').val(); jQuery.post( '<?php echo get_option('siteurl') . '/wp-admin/admin-ajax.php' ?>', { action : 'register_like', user_id : like_user_id, post_id : like_post_id, _wpnonce : '<?php echo wp_create_nonce('nonce-register_like'); ?>', }, function(response) { alert(response); } ); }); }); </script> <?php } |
This is just a PHP function that we can use to throw some jQuery (using the .post() method for our Ajax call) into the head. Note the nonce. You must include this for security. Additionally, you must have an action set. The action is used by WordPress to route the Ajax request.
Finally, we’re passing two extra pieces of data – user_id which is the WordPress user ID and the post_id which is the WordPress post ID of the current $post object inside the Loop. Both of these are supplied in the hidden form fields we created earlier.
Let’s add a new method for hooks and call it in our constructor, so that hooks are executed when the object is instantiated:
1 2 3 4 5 6 7 8 9 | function __construct() { $this->hooks(); } function hooks() { add_action( 'wp_head', array( $this, 'js' ) ); } |
Supplying the Ajax Handler
Having hooked the jQuery into WordPress, we now need something on the other end to handle the request and return something back to our page. For this, let’s create a method called handle_like().
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 | function handle_like() { global $wpdb; $user_id = (int) $_POST['user_id']; $post_id = (int) $_POST['post_id']; if( !is_user_logged_in() ) return false; if( !wp_verify_nonce( $_POST['_wpnonce'], 'nonce-register_like' ) ) die( 'Go away, asshole!' ); /* Here is where we do some sort of database operation to associate the Like of the given post with the user who performed the action Make sure you check for errors. In order to return data, you must echo something that the originating page can see. True or false only makes sense on this page and not back there. Typically, you'd output some sort of JSON, XML or plain text. */ $meta_id = add_post_meta( $post_id, 'user_liked', $user_id ); if( !$meta_id ) echo "Like not recorded"; else echo "Like recorded"; exit; } |
In this method, it’s important that all data be sanitized to avoid security problems. I’m performing the most basic of data security here by casting the $_POST variables for the users ID and the post ID to integers.
We’re also checking to make sure the user is logged in. This is why using the built in WordPress Ajax API is actually kind of important. If you build your own Ajax handler, there’s no way to reliable tie in to WordPress to use other APIs like the User API.
Finally, make sure you verify the nonce so you know the request is coming from a legitimate source.
The three security procedures I just listed will largely prevent SQL Injection, ensure authenticated users and eliminate the possibility of Cross Site Request Forgery (CSRF) and generally should be used in all WordPress plugin development.
Simply though, the above method takes the post ID, the user ID and creates a new record in the postmeta table. On success, it will print a success method readable by the original sending page and vica versa on failure.
Note: You must use die() or exit() at the end of the method to make sure the Ajax response exits properly.
Tying the Handler into WordPress
Now that we have a handler method to do our bidding, we need to make sure WordPress knows about it so it routes Ajax requests to the proper place. To do this, we leverage the wp_ajax_{$action} hook.
Remember earlier, while building the jQuery Ajax request, I mentioned that an action POST variable had to be set? WordPress looks to this variable to create a dynamic hook that we can use our new Ajax callback to hook into.
1 |
Because our action in the js() method was set to register_like, the hook WordPress creates dynamically is wp_ajax_register_like and we can use that to hook our Ajax handler onto.
Wrapping it all Together
Easy right? Use jQuery to send data, wp-admin/admin-ajax.php to receive the Ajax request and pass it on to an appropriate handler function, and send data back to the original page. On the receiving end, you can use normal means to handle the returned data as you wish.
You can download the full code used here at Github.
Today, I feel like a proud poppa. I don’t want to get too celebratory and put out some kind of aura that our battle against SOPA and PIPA are over. In fact, neither are over. But I’ll get to that in a minute, because yesterday was AMAZING!
