In the previous lesson, we added Auction Start and Auction End fields to the Add Auction and Edit Auction forms. However, administrators still could not see these values from the All Auctions page.

In this implementation lesson, we’ll enhance the auction management table by displaying both dates in a clean, human-readable format. We’ll also ensure that missing or invalid dates are handled gracefully.

What We’ll Build

By the end of this lesson, the All Auctions table will display:

• Auction Start
• Auction End
• Properly formatted dates
• A dash (—) whenever no date has been configured

Instead of displaying raw database values such as:

2026-07-02 14:06:00

the table will display:

02 Jul 2026 14:06

which is much easier for administrators to read.

Step 1: Add the New Columns

Open:

admin/class-auctions-table.php

Locate the get_columns() method.

Add two new columns:

'auction_start' => 'Auction Start',
'auction_end'   => 'Auction End',

Your auctions table will now include two additional headings.

Step 2: Format the Dates

Locate the column_default() method.

Instead of returning the raw database value, we’ll format the dates using WordPress’ wp_date() function.

For the Auction Start column:

case 'auction_start':

    $timestamp = strtotime( $item->auction_start );

    if (
        empty( $item->auction_start ) ||
        '0000-00-00 00:00:00' === $item->auction_start ||
        false === $timestamp
    ) {
        return '—';
    }

    return wp_date(
        'd M Y H:i',
        $timestamp
    );

Repeat the same logic for the Auction End column:

case 'auction_end':

    $timestamp = strtotime( $item->auction_end );

    if (
        empty( $item->auction_end ) ||
        '0000-00-00 00:00:00' === $item->auction_end ||
        false === $timestamp
    ) {
        return '—';
    }

    return wp_date(
        'd M Y H:i',
        $timestamp
    );

Why Use wp_date()?

Although PHP provides the date() function, WordPress recommends using wp_date() because it:

• Respects the site’s configured timezone
• Produces consistent output across WordPress
• Follows WordPress coding standards
• Makes plugins more portable

Step 3: Handle Missing Dates Gracefully

Many auctions may not yet have a configured start or end time.

Instead of showing confusing values like:

0000-00-00 00:00:00

or

30 Nov -0001 00:00

our implementation simply displays:

—

This creates a much cleaner interface for administrators.

Step 4: Make the Columns Sortable

To improve usability, add the new columns to the sortable columns list.

Inside get_sortable_columns():

'auction_start' => array( 'auction_start', false ),
'auction_end'   => array( 'auction_end', false ),

Then update the list of allowed database columns inside:

includes/class-auction-manager.php

Add:

'auction_start',
'auction_end',

to the $allowed_columns array.

This allows administrators to sort auctions by either start or end date.

Step 5: Test the Implementation

Create a few auctions with different schedules.

Verify that:

• Auction Start displays correctly.
• Auction End displays correctly.
• Empty dates display as —.
• Clicking the column headings sorts the table.
• Existing auctions without dates continue to work normally.

Final Result

The All Auctions page now provides administrators with immediate visibility into the auction schedule without opening each auction individually.

The table is easier to scan, easier to sort, and provides a much more professional management experience.

Troubleshooting Tips

If you encounter unexpected date values:

• Verify that the database contains valid DATETIME values.
• Use wp_date() instead of date().
• Check that strtotime() returns a valid timestamp.
• Display — whenever the date is empty, invalid, or equal to 0000-00-00 00:00:00.

A quick syntax check can also help before packaging the plugin:

php -l admin/class-auctions-table.php

If the command reports:

No syntax errors detected

your PHP syntax is valid.

What We Learned

In this lesson, we learned how to:

• Extend a custom WP_List_Table
• Add new columns to an admin table
• Format database dates for display
• Use wp_date() following WordPress best practices
• Handle empty and invalid dates gracefully
• Make custom columns sortable

These improvements make the Flipnzee Auctions plugin feel much closer to a polished, production-ready WordPress plugin while laying the groundwork for future features such as automatic auction activation, countdown timers, and bid management.

Download Source Code

Download the starting version of the plugin before the lesson:

Download the completed version after this lesson:

In Lesson 33, we transformed the Flipnzee Auctions plugin from a basic auction management system into one capable of supporting scheduled auctions.

Instead of auctions existing only in a draft, active, or closed state, administrators can now define exact start and end dates. This lays the foundation for future automation, where auctions will open and close automatically without manual intervention.

What We Implemented

During this lesson we added support for:

• Auction Start Date & Time
• Auction End Date & Time
• Saving schedule information while creating auctions
• Editing scheduled auctions
• Updating the schedule after creation
• Database support for scheduling

This is a major step toward building a production-ready auction platform.

Step 1 – Extend the Database

The first task was updating the auction table to store scheduling information.

Inside includes/class-database.php we added two new columns:

auction_start DATETIME NULL,
auction_end DATETIME NULL,

These fields allow every auction to have:

• Start date
• End date

Both fields are optional, making the feature flexible.

Step 2 – Update the Add Auction Form

Next we modified the Add Auction screen.

Two new fields were added:

• Auction Start
• Auction End

Both use HTML5’s built-in datetime picker.

<input type="datetime-local">

Benefits:

• Native browser calendar
• Native time selector
• No JavaScript library required

Step 3 – Save the Schedule

Adding form fields is not enough.

We also updated:

admin/class-admin-posts.php

to read:

$_POST['auction_start']
$_POST['auction_end']

The values are sanitized using:

sanitize_text_field()

before being sent to the Auction Manager.

Step 4 – Update create_auction()

The next task was modifying:

Flipnzee_Auction_Manager::create_auction()

Its function signature changed from:

create_auction(
    $listing_id,
    $start_price,
    $reserve_price,
    $buy_now_price
)

to:

create_auction(
    $listing_id,
    $start_price,
    $reserve_price,
    $buy_now_price,
    $auction_start,
    $auction_end
)

The SQL INSERT statement now stores:

'auction_start'
'auction_end'

alongside the other auction fields.

Step 5 – Update the Edit Auction Screen

Once scheduling could be saved, administrators also needed the ability to edit it.

Inside:

admin/class-admin.php

we added two additional form fields:

• Auction Start
• Auction End

The stored values are displayed using:

str_replace(
    ' ',
    'T',
    $auction->auction_start
)

This converts the MySQL format:

2026-07-02 14:30:00

into the format expected by HTML5:

2026-07-02T14:30

Without this conversion, the datetime picker would appear empty.

Step 6 – Update update_auction()

The update method also required changes.

Its function signature was expanded to accept:

$auction_start
$auction_end

The SQL UPDATE statement now saves:

'auction_start'
'auction_end'

along with:

• Listing ID
• Prices
• Status

This allows administrators to modify auction schedules after creation.

Step 7 – Verify Everything

After completing the implementation we tested:

Creating Auctions

✔ Auction created successfully.

Editing Auctions

✔ Auction Start displayed correctly.

✔ Auction End displayed correctly.

Saving Changes

✔ Updated schedule persisted successfully.

No PHP syntax errors were reported during testing.

What We Learned

This lesson introduced several useful concepts:

• Extending existing database tables
• Working with HTML5 datetime inputs
• Handling date/time values safely
• Updating SQL INSERT statements
• Updating SQL UPDATE statements
• Passing additional parameters between classes
• Displaying MySQL datetime values inside HTML forms

Current Progress

The plugin now supports:

• Creating auctions
• Editing auctions
• Searching auctions
• Sorting auctions
• Status filtering
• Bulk deletion
• Auction scheduling

The scheduling functionality is now fully functional from an administrator’s perspective.

Download Source Code

Download the starting version of the plugin before the lesson:

Download the completed version after this lesson:

What’s Next?

In the next lesson, we’ll complete the scheduling feature by displaying Auction Start and Auction End directly in the All Auctions table. This will allow administrators to view an auction’s schedule at a glance without opening the edit screen.

After that, we’ll be ready to begin implementing automatic auction opening and closing, bringing the plugin one step closer to a production-ready auction platform.

Plugin: Flipnzee Auctions
Implementation Stage: Lesson 26
Difficulty: Intermediate
Prerequisites: Lessons 1–25 completed

Introduction

In Lesson 26, we improved the usability of the All Auctions page by adding a search box to the auctions table. WordPress’ WP_List_Table class includes a built-in search box method, allowing administrators to quickly search records without creating a custom user interface.

During implementation, we also encountered and resolved a PHP syntax error that prevented the plugin from activating. This demonstrates why validating PHP files after every change is an important part of plugin development.

Objective

By the end of this implementation, the plugin will:

• Display a professional search box above the auctions table.
• Continue supporting pagination.
• Prepare the plugin for full search functionality in the next implementation step.

Step 1 — Open the Admin Page File

Open:

admin/class-admin.php

Locate the following method:

public function all_auctions_page() {

This method is responsible for displaying the All Auctions page inside the WordPress admin area.

Step 2 — Wrap the Table Inside a Form

Replace the existing table output with a GET form:

<form method="get">

	<input
		type="hidden"
		name="page"
		value="flipnzee-all-auctions"
	>

	<?php

	$table->search_box(
		'Search Auctions',
		'flipnzee-search'
	);

	$table->display();

	?>

</form>

Using a GET form allows WordPress to send the search term as part of the page URL.

Step 3 — Display Success Messages

Before displaying the table, retrieve the message parameter:

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

Display the success notice:

<?php if ( 'deleted' === $message ) : ?>

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

<?php endif; ?>

This keeps the interface consistent with earlier lessons where auctions could be added, edited, or deleted.

Step 4 — Keep the Search Box Inside the Method

One mistake encountered during implementation was accidentally placing:

$message = ...

outside the all_auctions_page() method.

Doing so resulted in the following PHP parse error:

PHP Parse error:
syntax error,
unexpected variable "$message",
expecting "function" or "const"

The fix was simply moving the code back inside the method.

Step 5 — Validate the PHP File

Before uploading the updated plugin, validate the modified file.

From the project root:

php -l admin/class-admin.php

or from inside the admin folder:

php -l class-admin.php

Expected output:

No syntax errors detected in class-admin.php

Step 6 — Test the Plugin

After uploading the updated plugin:

1. Activate the plugin.
2. Navigate to:

Flipnzee Auctions → All Auctions

You should now see:

• A search box above the auctions table.
• Pagination continuing to work.
• Existing auctions displaying normally.

At this stage, the search box is visible but not yet filtering results. That functionality will be added in the next implementation.

Troubleshooting

During this implementation, the following issue occurred:

Problem

The plugin could not be activated because of a PHP syntax error.

Cause

The $message variable and notice code had been placed outside the all_auctions_page() method.

Solution

Move the code back inside the method and validate the file using:

php -l

before uploading the plugin again.

Result

At the end of this implementation:

• ✅ Search box added
• ✅ Pagination still functional
• ✅ Plugin activates correctly
• ✅ Admin interface looks more professional
• ✅ Foundation prepared for database search in the next implementation

Source Code

At the beginning of this article, you can download the plugin source code before implementing Lesson 26.

At the end of this article, you can download the updated source code after completing Lesson 26 and compare the changes with your own implementation.

Next: In the next implementation article, we’ll connect the search box to the database query so administrators can search auctions by ID, Listing ID, or Status while keeping pagination fully functional.