Introduction

WordPress, as a platform, has moved from only being a blogging platform, to a platform for a wide variety of websites. One major reason for this, is how easily WordPress can be customized and extended. This enables programmers to create far more functional sites than a normal blog. In the following tutorial we are going to create a plugin which will make wordpress an article voting site and also create a widget to display the top voted posts.

Creating the Plugin

To create a plugin create a file voteme.php in your wp-content/plugins/voteme folder. To create a plugin we have to add the plugin header as follows

<?php
/*
Plugin Name: Vote Me
Plugin URI:
Description: This plugin to add vote in posts
Author: Abbas
Version: 0.1
Author URI:
*/

We will also define some named constants for our plugin base url, and the plugin path as follows:

define('VOTEMESURL', WP_PLUGIN_URL."/".dirname( plugin_basename( __FILE__ ) ) );
define('VOTEMEPATH', WP_PLUGIN_DIR."/".dirname( plugin_basename( __FILE__ ) ) );

Also, create a js folder in your voteme folder, and add a file voteme.js file in it.

The folder structure of the plugin would be as follows.

We will now enqueue the scripts by with ‘wp_enqueue_scripts’ and enqueue our JS file, and localize it to store the WP Ajax url which we will use for our ajax calls.

function voteme_enqueuescripts()
	{
		wp_enqueue_script('voteme', VOTEMESURL.'/js/voteme.js', array('jquery'));
		wp_localize_script( 'voteme', 'votemeajax', array( 'ajaxurl' => admin_url( 'admin-ajax.php' ) ) );
	}
add_action('wp_enqueue_scripts', voteme_enqueuescripts);

After this we should be able to see our plugin in the plugin list and we should activate it.

Adding the vote link to posts

Now we will add a link to all the posts displaying the current votes and a link to add the vote by ajax.
Following is the code

function voteme_getvotelink()
{
$votemelink = "";
$post_ID = get_the_ID();
$votemecount = get_post_meta($post_ID, '_votemecount', true) != '' ? get_post_meta($post_ID, '_votemecount', true) : '0';
$link = $votemecount.' <a onclick="votemeaddvote('.$post_ID.');">'.'Vote'.'</a>';
$votemelink = '<div id="voteme-'.$post_ID.'">';
$votemelink .= '<span>'.$link.'</span>';
$votemelink .= '</div>';
return $votemelink;
}
function voteme_printvotelink($content)
{
return $content.voteme_getvotelink();
}
add_filter('the_content', voteme_printvotelink);

Here, we create a function voteme_getvote link which first gets the current post id and then reads the post meta _votemecount using get_post_meta. We use the post meta _votemecount to store the votes for a particular post. Then we create a link by adding the JavaScript function votemeaddvote on the click of the link. The function votemeaddvote we will see shortly.

Next, we use the WordPress filter the_content to hook our function to add this link after each post. You will be able to see the number of votes and vote link below each post now.

Adding votes using Ajax

As we have added the vote link to every posts its time we make it functional to actually add votes. The JavaScript function which does the AJAX vote posting is below

function votemeaddvote(postId)
{
	jQuery.ajax({
	type: 'POST',
	url: votemeajax.ajaxurl,
	data: {
	action: 'voteme_addvote',
	postid: postId
},
success:function(data, textStatus, XMLHttpRequest){
	var linkid = '#voteme-' + postId;
	jQuery(linkid).html('');
	jQuery(linkid).append(data);
	},
	error: function(MLHttpRequest, textStatus, errorThrown){
		alert(errorThrown);
		}
	});
}

This sends an AJAX request to WordPress, and sends the action as voteme_addvote and the post ID. If the AJAX call is successful it just adds the data in the div for that post. If there is an error it will just display the error.

To handle the AJAX request we will have to create a function as follows

function voteme_addvote()
	{
		$results = '';
		global $wpdb;
		$post_ID = $_POST['postid'];
		$votemecount = get_post_meta($post_ID, '_votemecount', true) != '' ? get_post_meta($post_ID, '_votemecount', true) : '0';
		$votemecountNew = $votemecount + 1;
		update_post_meta($post_ID, '_votemecount', $votemecountNew);
		$results.='<div class="votescore" >'.$votemecountNew.'</div>';
		// Return the String
		die($results);
	}
		// creating Ajax call for WordPress
		add_action( 'wp_ajax_nopriv_voteme_addvote', 'voteme_addvote' );
		add_action( 'wp_ajax_voteme_addvote', 'voteme_addvote' );

In function voteme_addvote we get the post ID from the posted data and then get the current vote count for that post. Then we increment the vote by 1 and update the post meta again. Then we create a div with the new vote details and sent that back by using die($results);

To register this function to handle AJAX request for action: ‘voteme_addvote’ using the following wordpress hooks

		// creating Ajax call for WordPress
		add_action( 'wp_ajax_nopriv_voteme_addvote', 'voteme_addvote' );
		add_action( 'wp_ajax_voteme_addvote', 'voteme_addvote' );

Now we’ll be able to click the vote link to add the vote on the post with AJAX.

Customizing WordPress admin to show post votes

It would be very convenient for the admin to be able to see the votes on the post edit page. Then from there he would be able to see the post details, and also the vote details on that page.

To add the vote details we need to add a hook on the filter ‘manage_edit-post_columns’ to add the Votes as a column on the post edit page as follows.

add_filter( 'manage_edit-post_columns', 'voteme_extra_post_columns' );
function voteme_extra_post_columns( $columns ) {
$columns[ 'votemecount' ] = __( 'Votes' );
return $columns;
}

Now we need to provide the value to display for this column. To do this we need to hook into the filter manage_posts_custom_column. When we hook into this filter our function voteme_post_column_row is called and with the post column name. Here we only process out column votemecount and give the value for it. We read the value from our custom column _votemecount and echo it. The complete code for this is as follows.

function voteme_post_column_row( $column ) {
	if ( $column != 'votemecount' )
	return;
	global $post;
	$post_id = $post->ID;
	$votemecount = get_post_meta($post_id, '_votemecount', true) != '' ? get_post_meta($post_id, '_votemecount', true) : '0';
	echo $votemecount;
}
add_action( 'manage_posts_custom_column', 'voteme_post_column_row', 10, 2 );

On the post edit page you should be able to see the vote details column.

Sorting post on basics of votes in WordPress admin

It would be convenient for the admin if we make the vote column sortable. He would be able to see the most voted posts and also the least voted posts. To do this first we must make the Vote column clickable for sorting. To do this we hook into the filter manage_edit-post_sortable_columns and add the vote column to it as follows.

add_filter( 'manage_edit-post_sortable_columns', 'voteme_post_sortable_columns' );
function voteme_post_sortable_columns( $columns )
{
	$columns[ 'votemecount' ] = votemecount;
	return $columns;
}

Then we add a hook onto the load-edit.php hook when we have the order by request for votemecount we merge the sort parameters with

'meta_key' => '_votemecount',
'orderby' => 'meta_value_num'

So that it sorts on the basics of custom column and considers that column as numeric rather than as a string. The code for it is as follows.

add_action( 'load-edit.php', 'voteme_post_edit' );
function voteme_post_edit()
{
	add_filter( 'request', 'voteme_sort_posts' );
}
	function voteme_sort_posts( $vars )
{
	if ( isset( $vars['post_type'] ) && 'post' == $vars['post_type'] )
	{
		if ( isset( $vars['orderby'] ) && 'votemecount' == $vars['orderby'] )
		{
			$vars = array_merge(
			$vars,
			array(
			'meta_key' => '_votemecount',
			'orderby' => 'meta_value_num'
			)
			);
		}
	}
return $vars;
}

Now in the admin page the vote column will be clickable and clicking on it will sort the post on the basics of votes.

Allowing only Registered users to vote

We might want that not anyone can vote on the post. We might want to check that only users who are registered on our site will be able to vote. We’ll control this via creating a setting page for our plugin as follows

// Settings
add_action('admin_menu', 'voteme_create_menu');
function voteme_create_menu() {
add_submenu_page('options-general.php','Vote Me','Vote Me','manage_options', __FILE__.'voteme_settings_page','voteme_settings_page');
}
function voteme_settings_page() {
?>
<div class="wrap">
<?php
global $blog_id;
if( isset( $_POST['votemeoptionssubmit'] ) )
{
update_option( 'votemelogincompulsory' , $_POST[ 'votemelogincompulsory' ] );
}
?>
<div id="settingsform">
<form id='votemesettingform' method="post" action="">
<h1><?php echo 'Vote Me Settings'; ?></h1>
<Input type = 'Radio' Name ='votemelogincompulsory' value= 'yes' <?php if( get_option('votemelogincompulsory') == 'yes' ) echo 'checked';?> >User Must be logged in for voting
<br/>
<Input type = 'Radio' Name ='votemelogincompulsory' value= 'no' <?php if( get_option('votemelogincompulsory') != 'yes' ) echo 'checked';?> >User might not be logged in for voting
<br/><br/>
<p class="submit">
<input type="submit" id="votemeoptionssubmit" name="votemeoptionssubmit" class="button-primary" value="<?php echo 'Save'; ?>" />
</p>
</form>
</div>
</div>
<?php }

Here we hook onto admin_menu and create our setting page to show radio buttons for whether to allow voting for registered users only. Then based on the option selected by the admin we update the option votemelogincompulsory. The settings page will look as follows.

Then, update the voteme_getvotelink function to read the option votemelogincompulsory and to show the votelink or the login link depending on the option selected by the user and wthere the user is logged in or no. The code for it is as follows

function voteme_getvotelink()
{
	$votemelink = "";
	if( get_option('votemelogincompulsory') != 'yes' || is_user_logged_in() )
	{
		$post_ID = get_the_ID();
		$votemecount = get_post_meta($post_ID, '_votemecount', true) != '' ? get_post_meta($post_ID, '_votemecount', true) : '0';
		$link = $votemecount.' <a onclick="votemeaddvote('.$post_ID.');">'.'Vote'.'</a>';
		$votemelink = '<div id="voteme-'.$post_ID.'">';
		$votemelink .= '<span>'.$link.'</span>';
		$votemelink .= '</div>';
	}
else
{
	$register_link = site_url('wp-login.php', 'login') ;
	$votemelink = '<div class="votelink" >'." <a href=".$register_link.">"."Vote"."</a>".'</div>';
}
return $votemelink;
}

Creating a widget to display Top voted posts.

Now we will create a widget to display the top voted posts. First we create a function called voteme_get_highest_voted_posts which takes the number of posts and then displays those many post in order of the highest voted posts. It also displays the number of vote for each post.

function voteme_get_highest_voted_posts($numberofpost)
{
	$output = '';
	$the_query = new WP_Query( 'meta_key=_votemecount&orderby=meta_value_num&order=DESC&posts_per_page='.$numberofpost );
	// The Loop
	while ( $the_query->have_posts() ) : $the_query->the_post();
	$output .= '<li>';
	$output .= '<a href="'.get_permalink(). '" rel="bookmark">'.get_the_title().'('.get_post_meta(get_the_ID(), '_votemecount', true).')'.'</a> ';
	$output .= '</li>';
	endwhile;
	wp_reset_postdata();
	return $output;
}

Then we create a widget which takes the number of post and the title from the user and uses the abpve function to display the top voted posts.

class VoteMeTopVotedWidget extends WP_Widget {
	function VoteMeTopVotedWidget() {
	// widget actual processes
	$widget_ops = array('classname' => 'VoteMeTopVotedWidget', 'description' => 'Widget for top voted Posts.' );
	$this->WP_Widget('VoteMeTopVotedWidget','VoteMeTopVotedWidget', $widget_ops);
}
function form($instance) {
	// outputs the options form on admin
	$defaults = array( 'title' => 'Top Voted Posts', 'numberofposts' => '5' );
	$instance = wp_parse_args( (array) $instance, $defaults );
	?>
	<p>
	<label for="<?php echo $this->get_field_id( 'title' ); ?>"><?php echo 'Title:'; ?></label>
	<input id="<?php echo $this->get_field_id( 'title' ); ?>" name="<?php echo $this->get_field_name( 'title' ); ?>" value="<?php echo $instance['title']; ?>" class="widefat" />
	</p>
	<p>
	<label for="<?php echo $this->get_field_id( 'numberofposts' ); ?>"><?php echo 'Number of Posts'; ?></label>
	<input id="<?php echo $this->get_field_id( 'numberofposts' ); ?>" name="<?php echo $this->get_field_name( 'numberofposts' ); ?>" value="<?php echo $instance['numberofposts']; ?>" class="widefat" />
	</p>
	<?php
}
function update($new_instance, $old_instance) {
	// processes widget options to be saved
	$instance = $old_instance;
	$instance['title'] = strip_tags( $new_instance['title'] );
	$instance['numberofposts'] = $new_instance['numberofposts'];
	return $instance;
}
function widget($args, $instance) {
	// outputs the content of the widget
	extract( $args );
	$title = apply_filters('widget_title', $instance['title'] );
	echo $before_widget;
	if ( $title )
	echo $before_title . $title . $after_title;
	echo '<ul>';
	echo voteme_get_highest_voted_posts($instance['numberofposts']);
	echo '</ul>';
	echo $after_widget;
}
}
function voteme_widget_init() {
	// Check for the required API functions
	if ( !function_exists('register_widget') )
	return;
	register_widget('VoteMeTopVotedWidget');
}
add_action('widgets_init', 'voteme_widget_init');

The widget will look as follows

On the front, the widget will look as follows

Conclusion.

With custom fields, WordPress makes it easy for us to extend it to use for different purposes. WordPress has good support for AJAX as we have seen in this tutorial. So, happy WordPress development!

PHP Security: Cross-site Scripting Attacks (XSS)

Every PHP programmer has the responsibility to understand how attacks can be carried out against their code to exploit possible security vulnerabilities. Learn about cross-site scripting (XSS) attacks and how you can prevent them in your PHP scripts.

An Introduction to Redis in PHP Using Predis

Redis is an open-source data structure server with an in-memory data set that does much more than simple key/value storage. This article introduces you to some of the basic yet powerful commands that Redis has to offer using the Predis library.

REST: Can you do more than spell it?

Though you’ll often see the words “REST” and “architecture” together, REST is not a specific architecture. This four-part series introduces you to REST, a set of principles that define how a server and client can communicate with each other (and external resources) in a straightforward and robust manner.

Using an Access database with PHP

Sometimes a client will already have a database and ask that we make it available on the Web, and sometimes that database is in Access. Never fear, for PHP can easily work with Access databases using an ODBC driver. Learn the essential elements you’ll need to put an existing Access database online.

Working with Files in PHP

You’re familiar with databases such as MySQL and Access, but data can also be stored in files. This article gives you an introduction into working with text and CSV files, as well as find out information about the files (such as permissions and the last time it was modified).

” … Just as PHP and MySQL have grown from the young upstarts of the web development world into mature, stable platforms for billion-dollar businesses, this book that I’ve been writing again and again for over a decade has grown up … It’s time to write PHP like the big kids do…” 

This is how Kevin Yank describes the 5th edition of his just-released book “PHP & MYSQL: Novice to Ninja“

Watch Kevin as he introduces you to his NEW book!

As part of the launch of Kevin’s book, it’s now on special with – SAVINGS of up to 50%

Kevin Yank’s done it again! He’s just completed a new 2012 edition of his best-selling book (Build Your Own Database Driven Web Site, 4th Edition) which is now titled - PHP & MySQL: Novice to Ninja. And, today you can:

• Take a sneak peek inside the book (with an excerpt from the Chapter 3 -Introducing PHP)
• Order the book, and SAVE up to 50%

Introducing PHP

PHP is a server-side language. This concept may be a little difficult to grasp, especially if you’ve only ever designed websites using client-side languages like HTML, CSS, and JavaScript.

A server-side language is similar to JavaScript in that it allows you to embed little

programs (scripts) into the HTML code of a web page. When executed, these programs give you greater control over what appears in the browser window than HTML alone can provide. The key difference between JavaScript and PHP is the stage of loading the web page at which these embedded programs are executed.

Client-side languages like JavaScript are read and executed by the web browser after downloading the web page (embedded programs and all) from the web server. In contrast, server-side languages like PHP are run by the web server, before sending the web page to the browser. Whereas client-side languages give you control over how a page behaves once it’s displayed by the browser, server-side languages let you generate customized pages on the fly before they’re even sent to the browser.

Once the web server has executed the PHP code embedded in a web page, the result takes the place of the PHP code in the page. All the browser sees is standard HTML code when it receives the page, hence the name “server-side language.” Let’s look back at the today.php example presented in Chapter 1:

<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Today&rsquo;s Date</title>
</head>
<body>
<p>Today&rsquo;s date (according to this web server) is
<?php 
echo date('l, F jS Y.'); 
?> 
</p>
</body>
</html>

Most of this is plain HTML except the line between <?php and ?> is PHP code. <?php marks the start of an embedded PHP script and ?> marks its end. The web server is asked to interpret everything between these two delimiters and convert it to regular HTML code before it sends the web page to the requesting browser. The browser is presented with the following:

Notice that all signs of the PHP code have disappeared. In its place the output of the script has appeared, and it looks just like standard HTML. This example demonstrates several advantages of server-side scripting:

<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Today&rsquo;s Date</title>
</head>
<body>
<p>Today&rsquo;s date (according to this web server) is
Sunday, April 1st 2012. </p>
</body>
</html>

Notice that all signs of the PHP code have disappeared. In its place the output of the script has appeared, and it looks just like standard HTML. This example demonstrates several advantages of server-side scripting:

No browser compatibility issues

PHP scripts are interpreted by the web server alone, so there’s no need to worry about whether the language features you’re using are supported by the visitor’s browser.

Access to server-side resources

In the above example, we placed the date according to the web server into the web page. If we had inserted the date using JavaScript, we’d only be able to display the date according to the computer on which the web browser was running. Granted, there are more impressive examples of the exploitation of server-side resources, such as inserting content pulled out of a MySQL database (hint, hint …).

Reduced load on the client

JavaScript can delay the display of a web page significantly (especially on mobile devices!), as the browser must run the script before it can display the web page. With server-side code this burden is passed to the web server, which you can make as beefy as your application requires (and your wallet can afford).

Basic Syntax and Statements

PHP syntax will be very familiar to anyone with an understanding of JavaScript, C, C++, C#, Objective-C, Java, Perl, or any other C-derived language. But if these languages are unfamiliar to you, or if you’re new to programming in general, there’s no need to worry about it.

A PHP script consists of a series of commands, or statements. Each statement is an instruction that must be followed by the web server before it can proceed to the next instruction. PHP statements, like those in the aforementioned languages, are always terminated by a semicolon (;).

This is a typical PHP statement:

echo 'This is a <strong>test</strong>!';

This is an echo statement, which is used to generate content (usually HTML code) to send to the browser. An echo statement simply takes the text it’s given and inserts it into the page’s HTML code at the position of the PHP script where it was contained.

In this case, we’ve supplied a string of text to be output: ‘This is a <strong>test</strong>!’. Notice that the string of text contains HTML tags (<strong> and </strong>), which is perfectly acceptable. So, if we take this statement and put it into a complete web page, here’s the resulting code:

<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Today&rsquo;s Date</title>
</head>
<body>
<p><?php echo 'This is a <strong>test</strong>!'; ?></p>
</body>
</html>

If you place this file on your web server and then request it using a web browser, your browser will receive this HTML code:

<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Today&rsquo;s Date</title>
</head>
<body>
<p>This is a <strong>test</strong>!</p>
</body>
</html>

The today.php example we looked at earlier contained a slightly more complex echo statement:

echo date('l, F jS Y.');

Instead of giving echo a simple string of text to output, this statement invokes a built-in function called date and passes it a string of text: ‘l, F jS Y.’. You can think of built-in functions as tasks that PHP knows how to do without you needing to spell out the details. PHP has many built-in functions that let you do everything, from sending email to working with information stored in various types of databases.

When you invoke a function in PHP—that is, ask it to do its job—you’re said to be calling that function. Most functions return a value when they’re called; PHP then behaves as if you’d actually just typed that returned value instead in your code. In this case, our echo statement contains a call to the date function, which returns the current date as a string of text (the format of which is specified by the text string in the function call). The echo statement therefore outputs the value returned by the function call.

You may wonder why we need to surround the string of text with both parentheses ((…)) and single quotes (‘…’). As in SQL, quotes are used in PHP to mark the beginning and end of strings of text, so it makes sense for them to be there. The parentheses serve two purposes. First, they indicate that date is a function that you want to call. Second, they mark the beginning and end of a list of arguments that you wish to provide, in order to tell the function what you want it to do.

In the case of the date function, you need to provide a string of text that describes the format in which you want the date to appear. Later on, we’ll look at functions that take more than one argument, and we’ll separate those arguments with commas. We’ll also consider functions that take no arguments at all. These functions will still need the parentheses, even though there will be nothing to type between them.

—

Fantastic, thanks Kevin for sharing that!

The good news is there’s loads more practical and hands-on examples just like this in the 500+ pages of the book. Which covers:

• Tutorials: Easy-to-follow tutorials with downloadable code examples
• Installation: Instructions for PHP & MySQL on Windows, Mac OS X, and Linux
• PHP coding: Learning the correct PHP syntax
• Database design: Mastering SQL database design
• Object Oriented Programming (OOP): Crash course in OOP principles.
• Building a CMS: Step-by-step guide to creating a CMS.
• Shopping Carts: Developing an e-commerce cart from scratch.
• Latest technologies: Updated for Windows 7, Mac OS X Lion, and the latest versions of PHP, MySQL, phpMyAdmin, XAMPP, MAMP, and HTML5.

Order your copy now:

• PRINT Book + Digital EPACK Bundle – for $34  (SAVE 50%)
• Digital EPACK (pdf, epub, mobi) – for $17  (SAVE 42%)

That’s it. Enjoy, and as always, we’d love to hear all your thoughts and comments.

Deploy and Release your Applications with Phing

In a previous article on PHPMaster, you gained a basic understanding of Phing. In this article, you’ll use that knowledge to write your own boilerplate build file, which can be customized and reused in your real-world applications.

Giving Your First PHP Presentation

It’s public speaking time and you’re the next one up! In this article, you’ll learn why presenting PHP can be beneficial, who can present PHP-related topics (hint: it’s not just the experts!), and what you can do to make your presentation stand out when you deliver.

Maintaining your Server with Command Line PHP

Maintaining your Server with Command Line PHP
When maintaining a server, you need to know how to write scripts and small programs to automate tasks. Two of the biggest advantages of using PHP to write scripts are: you’re already familiar with the language, and you gain the ability to reuse any code from your previous PHP projects.

An Intro to Virtual Proxies, Part 1

One of the most appealing facets of polymorphism is that it’s applicable in a wide variety of situations. Moreover, while the ability to switch out concrete implementations is a fundamental object-oriented pillar, its use is limited when involving domain objects. In this first piece of a two-part series on virtual proxies, I’ll be showcasing their use case, and later digging deeper into their complexities.

Translating WordPress Themes and Plugins

WordPress itself is translated into many languages, but this is not the case with themes, plugins, and other front-end customizations. All theme and plugin developers are responsible for adding translation support for their work.. This article will show you how to translate any WordPress theme or plugin by using internationalization and localization methods.

Thoughts of a Pragmatic Tester

Some of us write unit tests, while others choose not to. Indeed, it’s important to test common usage, situations of improper usage, and rare events. But it’s also vital that you write your tests pragmatically, using functional (acceptance) tests for application’s behavior, and unit tests for internal APIs.

An Introduction to Services

Most software applications behave like whimsical babies with an unavoidable “tendency” to grow in size and complexity over time. You’re probably wondering how to tackle the problem without hitting your head against a brick wall. This article managing this, in particular, Services, because it plays nicely with Domain Models, and therefore with Domain-Driven Design.

Using EXPLAIN to Write Better MySQL Queries

The EXPLAIN keyword is one of the most powerful tools at your disposal for understanding and optimizing troublesome MySQL queries, but it’s a sad fact that many developers rarely make use of it. In this article, you’ll learn what the output of EXPLAIN can be and how to use it to optimize your schema and queries.

6 Skills Every PHP Freelancer Should Have

PHP development is hot right now, but there’s also a lot of competition among developers. If you want to make it as an independent PHP developer, you’ve got to know more than just PHP. These six skills are essential for most freelancers, even more so for PHP developers.

Bulletproofing Database Interactions with PHPUnit’s Database Extension

If your application is data-intensive, subjecting your CRUD code to a battery of tests is good practice that helps ensure that your application is working correctly. This article will help you get started using PHPUnit’s Database extension to automate tests for your code that interacts with your database.

One of the newest ways that web designers are increasing the usability and accessibility of their websites is by employing a combination of PHP, XHTML, and jQuery programming to validate forms “on the fly” as users fill them out. With WordPress, several pieces of information are almost always required in order to post a comment. A user must provide their name, their email address, and the comment itself. Some websites even require that users supply their website information when they post a comment. That’s a lot to remember, a lot to fill out, and the room for error is pretty big. A standard WordPress installation does not validate forms until a user has already clicked the submit button, meaning they don’t see any errors until the posting process has been completed. This leads to plenty of frustration and it simply isn’t usable in the modern era of blogging and interacting.

To replace this old-fashioned way of validating forms and replying with a user error, developers have begun employing jQuery to validate forms as users fill them out. Users will see a message displayed under each form as they proceed through the commenting process, and that message will either inform them that they’ve filled out the information successfully or it will alert them to an error and advise them to make a correction. This all happens before the “submit” button is clicked, and it saves users a page load and a few minutes of frustration in the process. It’s easy to do, and the library for form validation is already written. The only thing that’s holding most users back is developing the custom plugin to make this possible in WordPress, and that’s not nearly as taxing as most might think it is.

Step 1: Create a Plugin Directory and Get the Files in Order

The process used to validate a form requires that a custom plugin be generated within WordPress. This might intimidate some users, but rest assured that this plugin is just a more extensive series of additional “functions” like those that would typically be placed within a site-specific “functions.php” file. The validation function is added to a plugin so that it can be used across themes, rather than theme-specific functions files, which would require placing this code within every single one in order to make sure it works thoughout each user-installed theme in the Dashboard.

First and foremost, navigate to /public_html/wp-content/plugins/ and create a new folder named “validation-plugin.” This will contain all of the relevant files and subfolders needed for proper operation. Open that folder and create two new subfolders for the plugin:

• js
• css

These folders are pretty self-explanatory. Inside the “js” folder, a jQuery library will be stored. Inside the “css” folder, a stylesheet will be placed, which will determine the appearance of the error or approval messages that are displayed to the commenting user.

The jQuery library needed for this process is known as the Bassistance.de Library. Once it has been downloaded, it should be placed into the “js” folder. Then create a new file called “validation.css” and place that (blank) stylesheet into the “css” folder. Finally, it’s time to create the plugin PHP file that will control the validation functions.

The PHP plugin file should be named “form-validation.php” and it should be placed outside the subfolders in the main plugin directory. This file can be left blank for now, as it will be edited directly on the server and filled with content and functions as the process continues.

Step 2: Give the Plugin a Name and Describe its Functions

Every WordPress plugin is required to contain a few lines of code which give it a name, a version, and some descriptive tags and blocks of text. This is much like the content placed in a “style.css” file, and it’s just as important. A plugin which lacks these lines of text won’t display in the WordPress Dashboard. That means it cannot be activated after completion, so be sure that each line of text is filled in completely with the proper information. These lines of text look like the following:

/**
* Plugin Name: Comment Form Validation Custom Plugin
* Plugin URI: http://your-site.com
* Description: This plugin enhances the WordPress comment form by using a jQuery library to validate the content of each text area and text box as the user types their information into them. This plugin can be used across themes and is compatible with all major browsers and even screen readers.
* Version: 1.0
* Author: Your Name (You're the Author!)
* Author URI: http://your-site-again.com
* License: GPL
*/

Each line in the above code is pretty self-explanatory. The only one which might throw some developers off is the “license” line. For novice users, this simply refers to the license under which the code is written and distributed. In this case, it has been defined as GPL, for GNU Public License. This pretty much means that anyone can use this code on their own website, or modify the code to their needs, so long as they give credit to the original author. Because WordPress is an open-source content management solution based on PHP, a GPL or GPL version 2.0 license is the most appropriate way to create, share, and minimally restrict your work.

Step 3: Bringing the jQuery Library to Life Using Plugin Functions

The next step of the process will add specific functions to the plugin’s PHP file, which will load the script and activate its functions on the comment submission website. This is done relatively simply and it looks exactly like something that would appear in a theme-specific “functions.php” file. Remember that this information and coding is based on using the appropriate plugin file directories, which were described in an earlier step of this process. The code, when completed, looks like this:

function form_validation_js() {
  if(is_single() ) {
    wp_enqueue_script(
      'jquery-validate',
      plugin_dir_url( __FILE__ ) . '/js/bassistance.js',
      array('jquery'),
      '1.8.1',
      true
    );
    form_validation_style(
      'jquery-validate',
      plugin_dir_url( __FILE__ ) . '/css/validation.css',
      array(),
     '1.0'
    );
  }
}
add_action('template_redirect', 'form_validation_script');
function print_validation_script() { ?>
< ?php } add_action('form_validation_script'); ? >

These can be customized to a user’s wishes and they can contain any punctuation or uppercase letters that a designer wants to include. Try to keep them brief and descriptive, however, as most people don’t read between the lines even when it’s well-styled using CSS code. The PHP programming part of this operation is now complete.

Step 4: Styling Error Messages with Some CSS

Now we’re going to use the stylesheet file that was created in the first step of this process. Navigate to the “css” folder and, in the “validation.css” file, add the following lines:

label.error {
  display: block;
  color: #000;
  background-color: yellow;
  padding: 10px;
}

Every error message is defined as a form label with the class “error.” This element simply styles these errors with black text, a yellow background, and design-friendly padding that keeps text from meeting the edge of the color. It can, of course, be customized according to your taste and your website’s design specifications.

Also worth noting is that this stylesheet information does not need to be placed into the plugin’s stylesheet at all. Because WordPress naturally draws its look and feel from the theme’s “style.css” file, it could be placed in that stylesheet instead. If your site uses multiple themes and switches them very often, or if you allow users to switch between your site’s installed WordPress themes, this is a great way to ensure that the comment form’s error messages blend in with each theme individually rather than inheriting a universal style from the plugin folder itself.

Be sure to test each form element and try to make it produce an error. Check out the styling, and the error message, and check for any bugs or glitches. If none exist, the process is complete and your website is now much more usable and accessible.

Role Based Access Control in PHP

Role Based Access Control is a model in which roles are created for various job functions and permissions to perform operations that are then tied to them. Users can be assigned one or multiple roles, which restrict their system access to the permissions they’ve been authorized for. In this article, you’ll learn more about RBAC and how to enhance your existing authentication system with it.

pChart Revisited with Google Analytics

Back in December, PHPMaster published an introductory article written by J Armando Jeronymo on pChart, a PHP library that creates eye-catching anti-aliased charts. A reader asked for more articles with further examples, so he has written this follow-up. It features a handy device for visually checking website statistics using Google Analytics’ GAPI.

Building a Domain Model: Integrating Data Mappers

You’ve seen how to write data models, now learn how to put them to work in synchrony with a “real” persistence layer. In this follow-up to Alejandro’s article on persistence agnosticism, you’ll develop a basic mapping module which will allow you to move data easily between a model and a MySQL database, all while keeping them neatly isolated from each other.

Error Logging with MongoDB and Analog

With the hype around document databases continuing to grow, and around MongoDB in particular, there are a lot of questions about how to migrate your applications to begin using it. The advice is usually the same – especially for existing applications: take one step at a time. This article will show how you can add logging to your existing code using MongDB and Analog.

Continuous Integration with Jenkins, Part 1

Continuous integration is a software quality-control technique that checks code integrity whenever small changes are made, rather than waiting for all the code to be finished before testing and debugging. This is the first in a two-part series that introduces Jenkins. It presents a big-picture overview of the sort of programming problems CI can solve.

It’s difficult to believe almost three years have elapsed since PHP 5.3.0. The next version should have been PHP 6.0 but unicode problems have delayed development. This latest version provides many of the features planned for version 6.0.

PHP 5.4 is available to download from the php.net website. There’s a PHP 5.3 migration guide if you want to keep your old settings. While it’s stable, you’d be advised to test your sites and applications before installing it on live servers. The PHP team often release a bug-fix version a few weeks after the initial release.

So let’s look at the best new features and improvements…

Short Array Syntax

It’s now possible to use finger-saving JavaScript-like square brackets rather than using the old array(…) construct, e.g.

$array1 = [1, 2, 3];
$array2 = [
	"one" => "first",
	"two" => "second",
	"three" => "third"
];

Traits

Traits reduce some limitations of single inheritance. In essence, traits are similar to abstract classes and can contain any number of properties and methods. A class can then use any number of traits, e.g.

trait Hello
{
    function sayHello() {
        return "Hello";
    }
}
trait World
{
    function sayWorld() {
        return "World";
    }
}
class MyWorld
{
    use Hello, World;
}
$world = new MyWorld();
echo $world->sayHello() . ' ' . $world->sayWorld();

For more information, refer to Using Traits in PHP 5.4 on PHPmaster.com.

Built-in Web Server

PHP 5.4 offers a built-in web server which runs from the Windows, Mac or Linux command line. While it’s not Apache or IIS, it’s fine for simple testing. I suspect many of the better PHP IDEs will implement support shortly.

For more information, refer to PHP 5.4′s New Built-in Web Server.

New Commands

A number of useful commands have been implemented:

1. hextobin(string $hex): coverts a hex representation of data to binary.
2. http_response_code(int $code): allows you to set or get the HTTP response code, e.g. http_response_code(404);
3. header_register_callback(string $function): allows you to register a function which is called when PHP starts sending output.
4. trait_exists(string $name [,bool $autoload]): determines whether a trait exists and, optionally, whether it should be autoloaded.

Miscellaneous Updates

If that’s not enough…

• Class members can be accessed on instantiation, e.g. (new MyClass)->MyMethod()
• <?=$variable?> is always available regardless of how your short_open_tag ini option is set.
• Binary numbers can be declared, e.g. 0b11110000
• Session upload progress has been implemented so PHP can track the state of file uploads.
• Some users are reporting speed increases of up to 25% with a memory reduction of 35%.

Compatibility Issues

Most older PHP code should run without modification but there are a few gotchas to look out for:

• Safe mode, register_globals and magic quotes have been removed. get_magic_quotes_gpc() will always return FALSE.
• trait, callable and insteadof have become reserved words.
• Several mysqli aliases have been removed.

You should also note that PHP 5.4.x will be the last edition to support Windows XP and Windows 2003.

PHP 5.4 isn’t quite as radical has 5.3, but there are enough new features to keep developers happy for a while. Let us know if you have any positive or negative experiences with the latest version.

Packaging Your Apps with Phar

Deployment of web applications can be difficult and cumbersome without the right tools. This article will introduce you to PHAR, PHP’s package format which can help you have a better deployment experience.

WordPress Plugin Development

If you’ve ever used WordPress to build a site quickly, chances are you’ve used one of the many plugins that are offered to extend the functionality of this popular blogging software. There are times, however, when you can struggle to find what you need from existing plugins. This article shows you how to create your own WordPress plugins.

Creating Web Services with PHP and SOAP, Part 1

The ability to develop software and services for a wide range of platforms is a necessary skill for programmers, and SOAP, an XML-based protocol, will help ease the burden. Learn about SOAP and make your own SOAP client and server using the NuSOAP library in the first of this two-part series.

Understanding the Observer Pattern

In this article, you’ll learn how to implement the Observer Pattern, a behavioral design pattern that defines a one-to-many relationship between objects. Therefore, when one object changes its state, all dependent objects are notified and updated automatically.

Building a Domain Model: An Introduction to Persistence Agnosticism

With tons of MVC-based frameworks proliferating like hungry ants, the “model” part continues to suffer from the symptoms of an ad hoc Database Model layer. This article will teach you another way, one that will help you focus more on keeping access code out of your domain logic, as well as maintain a clear boundary of responsibility.

Using Traits in PHP 5.4

Less code duplication, more code reuse is a goal of OOP, but sometimes it can be difficult with PHP’s single inheritance model. Traits offer a workaround to horizontally reuse code across different class hierarchies. They’re new in PHP 5.4 so learn about them today!

Tracking Upload Progress with PHP and JavaScript

A problem that has plagued web developers for years is how to add real-time information to their applications, such as a progress bar for file uploads. Learn how a new feature in PHP 5.4 can be used to create a dynamic upload progress bar without any external libraries or browser dependencies.

Where on Earth are you?

Modern geolocation applications use latitude and longitude to identify the location of people and places to within a few meters – but it’s highly unlikely you’ll answer the question “Where on Earth are you?”. Learn how to use the Yahoo! Placemaker server and write a simple program to ask users where they are before identifying their location in concrete terms.

Autoloading in PHP and the PSR-0 Standard

Including a slew of extra files at the top of your scripts can be a drag! Learn about the “history of autoloading” and the current PSR-0 standard used in many PHP frameworks such as Lithium, Symfony, and Zend, that makes lengthy include lists a thing of the past.

Under the Hood of Yii’s Component Architecture Part 2

This is Part 2 of the 3-part series that shows you some of the inner-workings of the Yii Framework’s component architecture. In this installment you’ll learn how you can do event-based programming in PHP and how Yii’s CComponent class helps facilitate it.

Computers cannot generate random numbers. A machine which works in ones and zeros is unable to magically invent its own stream of random data. However, computers can implement mathematical algorithms which produce pseudo-random numbers. They look like random numbers. They feel like random distributions. But they’re fake; the same sequence of digits is generated if you run the algorithm twice.

Planting Random Seeds

To increase the apparent randomness, most algorithms can be passed a seed — an initialization number for the random sequence. Passing the same seed twice will still generate the same set of random numbers but you can set the seed based on external input factors. The easiest option is the current time but it can be anything; the last keypress, a mouse movement, the temperature, the number of hours wasted on YouTube, or any other factor.

Random PHP Functions

PHP offers a number of random number functions. The main ones are:

1. rand() and the more efficient mt_rand() function. Both return a random number between zero and getrandmax()/mt_getrandmax(). Alternatively, you can pass minimum and maximum parameters:

   
   // random number between 0 and 10 (inclusive)
   echo mt_rand(0, 10);
   

2. srand($seed) and mt_srand($seed) to set a random number seed. This has been done automatically since PHP 4.2.0.

PHP is Too Random!

There are instances when creating a repeatable list of pseudo-random numbers is useful. It’s often used for security or verification purposes, e.g. encrypting a password before it’s transmitted or generating a hash code for a set of data. Unfortunately, PHP can be a little too random. A generated sequence will depend on your hosting platform and version of PHP. In other words, you can’t guarantee the same ‘random’ sequence will be generated twice on two different machines even if the same seed is used.

Rolling Your Own Random Class

Fortunately, we can write our own random number generator. You’ll find many algorithms on the web, but this is one of the shortest and fastest. First, we initialize our class and a random seed variable:

class Random {
	// random seed
	private static $RSeed = 0;

Next we have a seed() function for setting a new seed value. For the algorithm to work correctly, the seed should always be a positive number greater than zero but not large enough to cause mathematical overflows. The seed function takes any value but converts it to a number between 1 and 9,999,999:

	// set seed
	public static function seed($s = 0) {
		self::$RSeed = abs(intval($s)) % 9999999 + 1;
		self::num();
	}

Finally, we have our num() function for generating a random number between $min and $max. If no seed has been set it’s initialized with PHP’s own random number generator:

	// generate random number
	public static function num($min = 0, $max = 9999999) {
		if (self::$RSeed == 0) self::seed(mt_rand());
		self::$RSeed = (self::$RSeed * 125) % 2796203;
		return self::$RSeed % ($max - $min + 1) + $min;
	}
}

We can now set a seed and output a sequence of numbers:

// set seed
Random::seed(42);
// echo 10 numbers between 1 and 100
for ($i = 0; $i < 10; $i++) {
	echo Random::num(1, 100) . '<br />';
}

If you’ve copied this code exactly, you should see the following values no matter what OS or version of PHP you’re running:

76
86
14
79
73
2
87
43
62
7

Admittedly, repeatable “random” numbers isn’t something you’ll need every day — you’re more likely to require something closer to real randomness and PHP’s functions will serve you better. But there may be occasions when you find this useful.

For many years I used a code editor that is now discontinued by its developers, and the introduction of HTML5 and CSS3 led me to look for an editor that supports the new tags and properties. In this article I’ll share the criteria and process I used to find an editor suitable for making quick fixes and a development environment for large-scale projects. My initial candidate list contained over 30 popular Linux, Java, Windows and XUL software packages which had at least one stable release after January 1, 2010: Arachnophilia, Bluefish, Bluegriffon, CoffeeCup HTML Editor, Dreamweaver, Eclipse PDT, Emacs, Expression Web, Geany, gedit, HTML-Kit, jEdit, Kate, KDevelop, Komodo Edit, KWrite, Netbeans, Notepad++, Notepad2, OpenBEXI, PHPEdit, PHPEd Pro, PHPStorm, Programmer’s Notepad, PSPad, RadPHP, Scite, SeaMonkey, Vim, WebDev, WebMatrix, and Zend Studio. You can google each program for their specific details

Read More:
PHPMaster: How I Chose My Programming Editor

Web applications usually follow a synchronous communication model. However, non-interactive and long-running tasks (such as report generation) are better suited for asynchronous execution. One way to off-load tasks to run at a later time, or even on a different server, is use the Job Queue module available as a part of Zend Server 5 (though not as part of the Community Edition). Job Queue allows job scheduling based on time, priority, and even dependencies.

See the article here:
PHPMaster: Zend Job Queue