Difficulty: Intermediate
Project: Flipnzee Auctions Plugin
Lesson Implemented: Lesson 28

Introduction

In the previous lessons, we transformed our custom Auctions page into a professional WordPress administration screen by adding pagination and search functionality.

Although administrators could now search for auctions, they still could not sort the table by different columns. WordPress users expect to be able to click column headings like ID, Start Price, or Created At to sort data.

In this implementation, we enhanced our custom WP_List_Table by making its columns sortable.

Step 1 — Define the Sortable Columns

The first step was to tell WordPress which columns should be sortable.

Inside:

admin/class-auctions-table.php

we added a new method:

public function get_sortable_columns() {

	return array(
		'id'            => array( 'id', true ),
		'listing_id'    => array( 'listing_id', false ),
		'start_price'   => array( 'start_price', false ),
		'reserve_price' => array( 'reserve_price', false ),
		'buy_now_price' => array( 'buy_now_price', false ),
		'status'        => array( 'status', false ),
		'created_at'    => array( 'created_at', false ),
	);
}

Each array entry tells WordPress which database column should be used for sorting.

Step 2 — Enable Sorting in prepare_items()

Defining sortable columns alone is not enough.

Inside prepare_items(), we updated the column headers:

From:

$this->_column_headers = array(
	$this->get_columns(),
	array(),
	array(),
);

To:

$this->_column_headers = array(
	$this->get_columns(),
	array(),
	$this->get_sortable_columns(),
);

This small change tells WP_List_Table to convert the column headings into clickable links.

Step 3 — Read Sorting Parameters

Next, we needed to determine which column the administrator clicked.

Inside prepare_items(), we added:

$orderby = isset( $_GET['orderby'] )
	? sanitize_key(
		wp_unslash( $_GET['orderby'] )
	)
	: 'created_at';

$order = isset( $_GET['order'] )
	? strtoupper(
		sanitize_text_field(
			wp_unslash( $_GET['order'] )
		)
	)
	: 'DESC';

Why?

When a user clicks a sortable column, WordPress automatically appends parameters such as:

orderby=start_price
order=ASC

We safely read these values before using them.

Step 4 — Pass Sorting Information to the Database Layer

Previously, our manager class received only:

• page size
• offset
• search term

We extended the call to include:

Flipnzee_Auction_Manager::get_all_auctions(
	$per_page,
	$offset,
	$search,
	$orderby,
	$order
);

Now the database query knows exactly how to sort the results.

Step 5 — Update the Manager Method

Inside:

includes/class-auction-manager.php

we modified the method signature:

public static function get_all_auctions(
	$per_page = 20,
	$offset = 0,
	$search = '',
	$orderby = 'created_at',
	$order = 'DESC'
)

This allows sorting preferences to be passed from the table class.

Step 6 — Validate the Column Name

Unlike values, SQL column names cannot be protected using prepared statements.

Instead, we created a whitelist:

$allowed_columns = array(
	'id',
	'listing_id',
	'start_price',
	'reserve_price',
	'buy_now_price',
	'status',
	'created_at',
);

We then verified the requested column:

if ( ! in_array( $orderby, $allowed_columns, true ) ) {
	$orderby = 'created_at';
}

This prevents invalid or malicious column names from being used.

Step 7 — Validate the Sort Direction

We also limited the sort direction:

$order = ( 'ASC' === strtoupper( $order ) )
	? 'ASC'
	: 'DESC';

Only two values are accepted:

• ASC
• DESC

Anything else automatically falls back to descending order.

Step 8 — Update the SQL Query

Previously, every query ended with:

ORDER BY created_at DESC

We replaced it with:

ORDER BY {$orderby} {$order}

Both the search query and the default query were updated so that sorting works in every situation.

Step 9 — Test the Feature

After uploading the updated plugin, we verified that:

• ID became clickable
• Listing ID became clickable
• Start Price became clickable
• Reserve Price became clickable
• Buy Now Price became clickable
• Status became clickable
• Created At became clickable

Clicking a column heading automatically updated the URL and changed the sort order.

Challenges Encountered

This lesson involved several small debugging tasks before everything worked correctly.

Some of the issues included:

• Accidentally duplicating the search query inside get_all_auctions().
• Forgetting to replace ORDER BY created_at DESC with the dynamic sorting variables.
• Leaving the third element of _column_headers empty, which prevented WordPress from displaying clickable column headings.

By resolving these issues one by one, the sortable table behaved exactly as expected.

What We Learned

This implementation introduced several important WordPress concepts:

• Using get_sortable_columns()
• Registering sortable columns with WP_List_Table
• Reading URL parameters safely
• Passing sorting information between classes
• Validating SQL identifiers using a whitelist
• Restricting sort directions
• Building flexible SQL queries while maintaining security

These are common techniques used in professional WordPress plugins that display tabular data.

Final Result

After completing this implementation, the Flipnzee Auctions plugin now provides a much more user-friendly administration interface.

Administrators can click any supported column heading to reorder the table, making it easier to analyse auction data and locate important records.

Combined with the search and pagination features implemented in earlier lessons, the Auctions page now closely resembles the polished interfaces found throughout the WordPress admin dashboard.

Download Source Code

Download the starting version of the plugin before implementing sortable columns:

Download the completed version containing fully functional sortable columns:

Series: Building the Flipnzee Auctions WordPress Plugin
Lesson: 27
Difficulty: Intermediate

Introduction

In Lesson 26, we successfully added a professional search box above the auctions table. Although the interface looked complete, typing a search term did not actually filter the records.

In this lesson, we’ll connect the search box to the database so administrators can search auctions directly from the WordPress dashboard. This brings our custom WP_List_Table much closer to the functionality of WordPress’ built-in administration screens.

What You’ll Learn

By the end of this lesson, you’ll know how to:

• Read search keywords submitted by WP_List_Table
• Pass search terms to your database query
• Filter auction records using SQL
• Keep pagination working while searching
• Display only matching auctions

Why Search Matters

Imagine managing hundreds or even thousands of auctions.

Without search, finding Auction ID 357 or Listing ID 8421 would require scrolling through multiple pages.

A search box allows administrators to instantly locate records, improving productivity and making the plugin feel much more professional.

How WordPress Search Works

When you click the Search button, WordPress automatically sends the search keyword as a GET parameter named:

s

For example:

admin.php?page=flipnzee-all-auctions&s=44

Your plugin simply needs to:

1. Read $_REQUEST['s']
2. Pass it to the database
3. Display matching records

Step 1 — Read the Search Term

Inside the table class, retrieve the search keyword submitted by WordPress.

Example:

$search = isset( $_REQUEST['s'] )
	? sanitize_text_field(
		wp_unslash( $_REQUEST['s'] )
	)
	: '';

Always sanitize user input before using it.

Step 2 — Pass the Search Term

Modify the call to retrieve auctions.

Instead of:

Flipnzee_Auction_Manager::get_all_auctions(
	$per_page,
	$offset
);

pass the search term as well:

Flipnzee_Auction_Manager::get_all_auctions(
	$per_page,
	$offset,
	$search
);

Step 3 — Update the SQL Query

Inside the Auction Manager, check whether a search keyword exists.

If it does, filter the results.

Example SQL:

WHERE
	id LIKE ?
	OR listing_id LIKE ?
	OR status LIKE ?

This allows administrators to search by:

• Auction ID
• Listing ID
• Auction Status

Step 4 — Keep Pagination Working

Searching should not disable pagination.

Instead of counting every auction:

SELECT COUNT(*)

count only the matching records.

This keeps the page numbers accurate.

Step 5 — Test the Feature

Create several auctions.

Then try searches like:

44

draft

21

The table should immediately display only the matching auctions.

Security Considerations

Never place raw user input directly into SQL queries.

Always use:

• sanitize_text_field()
• wp_unslash()
• $wpdb->prepare()
• $wpdb->esc_like()

These functions protect your plugin against SQL injection attacks.

Common Mistakes

Many developers accidentally:

• Forget to sanitize the search term
• Build SQL using string concatenation
• Break pagination after filtering
• Ignore empty search values

Avoiding these mistakes results in a more secure and reliable plugin.

Expected Result

After completing this lesson:

• ✅ Search box filters auctions
• ✅ Pagination still works
• ✅ Database queries remain secure
• ✅ Administrators can quickly find auction records
• ✅ The Auctions page behaves much more like WordPress core admin tables

Conclusion

Adding a search box was only the first step. Connecting it to the database transforms it into a practical tool for managing real auction data.

With searchable, paginated listings now in place, the Flipnzee Auctions plugin continues to evolve from a learning project into a production-ready WordPress plugin.

Lesson 27 Implementation — Adding Functional Search to the Flipnzee Auctions Table

In the Next Lesson

We’ll further enhance the Auctions table by allowing administrators to sort auctions by clicking the table headers, such as:

• Auction ID
• Listing ID
• Start Price
• Status
• Created Date

This is another feature users expect from professional WordPress plugins and will make navigating large auction datasets even easier.

In the previous lesson, we transformed our Edit Auction page into a fully editable form. Administrators can now modify auction values such as the listing ID, prices, and status.

However, clicking Save Changes currently results in a blank page because our plugin does not yet know how to process the submitted form.

In this lesson, we’ll complete the editing workflow by processing the form submission, updating the database, and redirecting the administrator back to the Edit Auction page with a success message.

Learning Objectives

By the end of this lesson you will be able to:

• Register a new WordPress admin_post action.
• Process an Edit Auction form securely.
• Verify nonces before updating the database.
• Sanitize user input.
• Update an existing database record using $wpdb->update().
• Redirect back to the Edit page with a success message.

Current Workflow

At the moment our workflow looks like this:

Edit Auction
      ↓
Modify Fields
      ↓
Click Save Changes
      ↓
Blank Screen

After this lesson it will become:

Edit Auction
      ↓
Modify Fields
      ↓
Click Save Changes
      ↓
Update Database
      ↓
Redirect Back
      ↓
Success Message

Step 1 – Register a New Admin Action

Open:

admin/class-admin-posts.php

Inside the constructor, add another action:

add_action(
	'admin_post_flipnzee_update_auction',
	array( $this, 'handle_update_auction' )
);

Your constructor should now contain both actions:

public function __construct() {

	add_action(
		'admin_post_flipnzee_create_auction',
		array( $this, 'handle_create_auction' )
	);

	add_action(
		'admin_post_flipnzee_update_auction',
		array( $this, 'handle_update_auction' )
	);
}

Step 2 – Create the Update Handler

Inside the same class, add:

public function handle_update_auction() {

	check_admin_referer(
		'flipnzee_update_auction',
		'flipnzee_nonce'
	);

	$auction_id = absint( $_POST['auction_id'] );

	$listing_id = absint( $_POST['listing_id'] );

	$start_price = floatval( $_POST['start_price'] );

	$reserve_price = floatval( $_POST['reserve_price'] );

	$buy_now_price = floatval( $_POST['buy_now_price'] );

	$status = sanitize_text_field(
		wp_unslash( $_POST['status'] )
	);

	$updated = Flipnzee_Auction_Manager::update_auction(
		$auction_id,
		$listing_id,
		$start_price,
		$reserve_price,
		$buy_now_price,
		$status
	);

	$message = $updated
		? 'updated'
		: 'error';

	wp_safe_redirect(

		admin_url(

			'admin.php?page=flipnzee-edit-auction&auction_id=' .
			$auction_id .
			'&message=' .
			$message
		)

	);

	exit;
}

Notice how every value is sanitized before being passed to the Auction Manager.

Step 3 – Add the Update Method

Open:

includes/class-auction-manager.php

Add the following method beneath create_auction():

public static function update_auction(
	$auction_id,
	$listing_id,
	$start_price,
	$reserve_price,
	$buy_now_price,
	$status
) {

	global $wpdb;

	$table = $wpdb->prefix . 'flipnzee_auctions';

	$result = $wpdb->update(

		$table,

		array(

			'listing_id'    => $listing_id,
			'start_price'   => $start_price,
			'reserve_price' => $reserve_price,
			'buy_now_price' => $buy_now_price,
			'status'        => $status,

		),

		array(
			'id' => $auction_id,
		),

		array(
			'%d',
			'%f',
			'%f',
			'%f',
			'%s',
		),

		array(
			'%d',
		)

	);

	return false !== $result;
}

This method updates only the selected auction.

Step 4 – Display a Success Message

Open:

admin/class-admin.php

Inside edit_auction_page(), immediately after the <h1> heading, add:

<?php

$message = isset( $_GET['message'] )
	? sanitize_text_field(
		wp_unslash( $_GET['message'] )
	)
	: '';

if ( 'updated' === $message ) :
?>

	<div class="notice notice-success is-dismissible">
		<p>Auction updated successfully.</p>
	</div>

<?php elseif ( 'error' === $message ) : ?>

	<div class="notice notice-error is-dismissible">
		<p>Unable to update auction.</p>
	</div>

<?php endif; ?>

Now the administrator receives immediate feedback after saving changes.

Step 5 – Test the Plugin

Create a fresh ZIP and upload the updated plugin.

Go to:

Flipnzee Auctions → All Auctions

Click Edit.

Change one or more values.

Click Save Changes.

You should now:

• Return to the Edit page.
• See a success message.
• See the updated values displayed in the form.

Why Redirect Instead of Printing a Message?

Professional WordPress plugins generally follow the POST → Redirect → GET pattern.

Instead of displaying output immediately after processing a form, they redirect back to the appropriate page.

Benefits include:

• Preventing duplicate form submissions.
• Cleaner browser history.
• Easier refresh behaviour.
• Better user experience.

Lesson Summary

In this lesson we completed the Edit Auction workflow.

The plugin now processes form submissions securely, validates the nonce, sanitizes user input, updates the database, and redirects the administrator back to the Edit Auction page with an appropriate success or error message.

This represents another major milestone because the plugin now supports both creating and updating auction records.

Key Takeaways

• Register a dedicated admin_post action for each form.
• Always verify nonces before processing requests.
• Sanitize every submitted value.
• Use $wpdb->update() to modify existing database rows.
• Redirect after processing forms.

Common Mistakes

• Forgetting to register the new admin_post action.
• Omitting nonce verification.
• Forgetting to sanitize submitted values.
• Redirecting before calling exit.
• Returning output instead of redirecting.

Git Commands Used

git add .

git commit -m "Lesson 21: Update auctions"

git push

Testing Checklist

Before moving to the next lesson, verify that:

• ✅ Edit page opens correctly.
• ✅ Auction values can be modified.
• ✅ Clicking Save Changes updates the database.
• ✅ Success message appears.
• ✅ Refreshing the page does not resubmit the form.
• ✅ No PHP warnings or notices appear.

Project Status

✅ Dashboard

✅ Add Auction

✅ Save Auction

✅ View Auctions

✅ WP_List_Table

✅ Row Actions

✅ Edit Auction Form

✅ Update Auction

⬜ Delete Auction

⬜ Auction Scheduling

⬜ Bid Engine

⬜ Escrow Workflow

Developer’s Notebook

WordPress encourages developers to separate the user interface from business logic. In this lesson, the form is responsible only for collecting user input, while the admin_post handler processes and validates the request before delegating the database update to the Auction Manager. This separation of responsibilities makes the plugin easier to test, maintain, and extend in future lessons.

Introduction

In the previous lesson, we migrated our auction list to WordPress’s WP_List_Table framework.

Although the table now uses WordPress’s native administration interface, each row is still read-only.

Professional WordPress plugins allow administrators to perform actions directly from the list table. Common actions include viewing details, editing records, deleting items, or changing their status.

In this lesson, we’ll add our first row actions to the auction list, preparing the plugin for editing and deleting auctions in the next lessons.

Learning Objectives

By the end of this lesson, you’ll be able to:

• Understand row actions in WP_List_Table.
• Override the column_id() method.
• Add custom row actions.
• Build administrator-friendly interfaces.
• Prepare the plugin for editing and deleting auctions.

What Are Row Actions?

When you open the Posts page in WordPress, each post displays actions such as:

Edit | Quick Edit | Trash | View

These are called row actions.

Instead of placing buttons in separate columns, WordPress displays contextual links directly beneath the primary column.

We’ll adopt the same approach.

Step 1 – Choose the Primary Column

For our plugin, the Auction ID will become the primary column.

Every action related to an auction will appear beneath its ID.

Step 2 – Add a Custom Column Method

Open:

admin/class-auctions-table.php

Add the following method inside the class.

public function column_id( $item ) {

	$actions = array(

		'view' => sprintf(
			'<a href="#">View</a>'
		),

		'edit' => sprintf(
			'<a href="#">Edit</a>'
		),

		'delete' => sprintf(
			'<a href="#">Delete</a>'
		),

	);

	return sprintf(
		'%1$s %2$s',
		$item->id,
		$this->row_actions( $actions )
	);
}

Understanding row_actions()

The WordPress base class automatically formats our links into the familiar style used throughout the administration area.

Instead of manually creating HTML, we simply pass an array of actions.

WordPress handles the rest.

Step 3 – Test the Table

Create a fresh ZIP.

Upload the plugin.

Open:

Flipnzee Auctions → All Auctions

Each auction should now display:

1

View | Edit | Delete

directly beneath the Auction ID.

Although these links don’t perform any actions yet, they establish the navigation we’ll build upon in future lessons.

Why Placeholder Links?

You might wonder why the links currently point to #.

This allows us to focus on one concept at a time.

Today’s goal is to understand how row actions are rendered.

In the next lessons, we’ll replace each placeholder with working functionality.

Lesson Summary

In this lesson, we enhanced the auction list by introducing row actions through the column_id() method.

The auction table now follows the same interaction model used throughout the WordPress administration area, giving users familiar controls while preparing the plugin for more advanced features.

Key Takeaways

• ✓ Row actions belong beneath the primary column.
• ✓ Override column_id() to customize the first column.
• ✓ Use row_actions() instead of manually building links.
• ✓ Keep one lesson focused on one new concept.

Common Mistakes

• Forgetting to create the column_id() method.
• Returning only the ID without row actions.
• Placing action links inside separate columns.
• Trying to implement edit and delete functionality before creating the row actions.

Git Commands Used

git add .

git commit -m "Lesson 18: Add row actions to auction list"

git push

Testing Checklist

Before moving to the next lesson, verify:

• ✅ Plugin activates successfully.
• ✅ Dashboard still loads.
• ✅ Add Auction still works.
• ✅ All Auctions page loads correctly.
• ✅ Every auction displays its ID.
• ✅ View, Edit, and Delete appear beneath each Auction ID.
• ✅ No PHP warnings or fatal errors.

Project Status

✅ Dashboard

✅ Add Auction

✅ Save Auctions

✅ View Auctions

✅ WP_List_Table

✅ Row Actions

⬜ View Auction

⬜ Edit Auction

⬜ Delete Auction

⬜ Bid Engine

⬜ Escrow Workflow

Project Evolution

Our administration interface is becoming increasingly similar to native WordPress screens. Instead of treating auctions as static records, administrators can now see contextual actions associated with each auction. While the actions are placeholders today, the underlying structure is now in place. Future lessons will simply connect these links to real functionality without redesigning the interface.

Developer’s Notebook

One of the strengths of WP_List_Table is that it encourages consistency across the WordPress administration area. By adopting row actions rather than adding separate action columns, our plugin immediately feels more familiar to WordPress users. This small architectural decision improves usability while reducing unnecessary visual clutter.

Looking Ahead

In Lesson 19, we’ll replace the placeholder Edit link with a fully functional auction editing page. Administrators will be able to modify auction details directly from the dashboard, making Flipnzee Auctions feel even more like a native WordPress application.