Auto-Expire Posts: ACF Date Picker To Draft Magic

Aug 4, 2025 by ADMIN 50 views

Expire Posts to Draft Automatically Using ACF Date Picker

Hey guys! Ever needed a way to automatically set your posts to draft once they reach a certain date? Maybe you're running time-sensitive promotions or offers and want them to disappear from your site without having to manually unpublish them. Well, you're in the right place! This article will guide you through a nifty way to automatically expire your posts and set them to draft using the Advanced Custom Fields (ACF) date picker. We'll dive into a simple yet effective code snippet that gets the job done, making your life as a WordPress wizard a whole lot easier.

The Problem: Manual Post Expiration

Let's face it, manually managing post expiration dates can be a real pain. Imagine you have dozens, or even hundreds, of posts with specific expiration dates. Keeping track of each one and manually setting them to draft is not only tedious but also prone to human error. You might forget to unpublish a post, leaving outdated information on your site, or worse, miss an important deadline. This is where automation comes to the rescue. By leveraging ACF and a bit of custom code, we can automate the post expiration process, ensuring your content stays fresh and relevant without you having to lift a finger.

The Solution: ACF Date Picker and Custom Code

The solution involves using the Advanced Custom Fields (ACF) plugin to add a date picker field to your posts. This field will store the expiration date. Then, we'll use a custom code snippet to check the current date against the expiration date and automatically set the post to draft if the expiration date has passed. This approach is flexible, reliable, and keeps your site running smoothly. We'll break down the code step-by-step, making it easy to understand and implement, even if you're not a coding guru.

Setting Up the ACF Date Picker

First things first, you'll need to have the Advanced Custom Fields plugin installed and activated on your WordPress site. If you haven't already, head over to the WordPress plugin repository and get it sorted. Once ACF is up and running, follow these steps to create your date picker field:

Go to Custom Fields in your WordPress admin menu.
Click Add New to create a new field group.
Give your field group a descriptive name, like "Post Expiration".
Click Add Field and configure the field as follows:
- Field Type: Date Picker
- Field Label: Expiration Date
- Field Name: expiration_date (This is important! We'll use this in our code later.)
- Return Format: YYYY-MM-DD (This format is recommended for easy comparison in the code.)
Under Location, choose the post types you want this field to apply to (e.g., Posts, Offers, etc.).
Click Save Changes.

Now, when you create or edit a post of the selected type, you'll see the "Expiration Date" field, allowing you to set the date when the post should be automatically set to draft. This date picker field is the cornerstone of our automated expiration system, providing a user-friendly way to manage post lifecycles directly from the post editor.

The Code: Automating Post Expiration

Alright, let's get to the juicy part – the code! This snippet will handle the magic of checking the expiration date and setting the post to draft. Add this code to your theme's functions.php file or, even better, use a code snippets plugin to keep things organized. This ensures that your custom code remains active even when you switch themes. Here's the code we'll be using:

<?php

// Schedule the event if it's not already scheduled
if (! wp_next_scheduled('expire_posts')) {
    wp_schedule_event(time(), 'daily', 'expire_posts');
}

// Function to expire posts
add_action('expire_posts', 'set_expired_posts_to_draft');

function set_expired_posts_to_draft() {
    $args = array(
        'post_type'      => 'any', // Check all post types
        'posts_per_page' => -1,    // Get all posts
        'post_status'    => 'publish', // Only published posts
        'meta_key'       => 'expiration_date', // Our ACF date field
        'meta_value'     => date('Y-m-d'), // Today's date
        'meta_compare'   => '<=', // Date is less than or equal to today
    );

    $expired_posts = new WP_Query($args);

    if ($expired_posts->have_posts()) {
        while ($expired_posts->have_posts()) {
            $expired_posts->the_post();
            $post_id = get_the_ID();
            wp_update_post(array(
                'ID'          => $post_id,
                'post_status' => 'draft', // Set post status to draft
            ));
        }
        wp_reset_postdata();
    }
}

?>

Let's break down this code piece by piece:

Scheduling the Event:
```
if (! wp_next_scheduled('expire_posts')) {
    wp_schedule_event(time(), 'daily', 'expire_posts');
}
```
This section checks if the expire_posts event is already scheduled. If not, it schedules it to run daily using wp_schedule_event(). This ensures that our expiration check runs automatically every day. The function wp_next_scheduled() is crucial here; it prevents duplicate scheduling, which could lead to performance issues.
Hooking the Function:
```
add_action('expire_posts', 'set_expired_posts_to_draft');
```
This line hooks our set_expired_posts_to_draft() function to the expire_posts action. This means that when the expire_posts event is triggered (which happens daily, thanks to the previous step), our function will be executed. This add_action() hook is the linchpin that connects the scheduled event to our custom logic, ensuring that the post expiration process runs seamlessly in the background.
The Main Function: set_expired_posts_to_draft()

This is where the magic happens. This function is responsible for querying posts, checking their expiration dates, and setting them to draft.
- Setting Up the Query Arguments:
```
$args = array(
    'post_type'      => 'any', // Check all post types
    'posts_per_page' => -1,    // Get all posts
    'post_status'    => 'publish', // Only published posts
    'meta_key'       => 'expiration_date', // Our ACF date field
    'meta_value'     => date('Y-m-d'), // Today's date
    'meta_compare'   => '<=', // Date is less than or equal to today
);
```
  We define an array of arguments for our WP_Query. Let's break down each argument:
  - post_type: Set to 'any' to check all post types.
  - posts_per_page: Set to -1 to retrieve all posts that match our criteria.
  - post_status: Set to 'publish' to only check published posts.
  - meta_key: Set to 'expiration_date', which is the name of our ACF date picker field.
  - meta_value: Set to date('Y-m-d'), which gets the current date in the YYYY-MM-DD format.
  - meta_compare: Set to '<=', which means we're looking for posts where the expiration date is less than or equal to today's date.
  These arguments are the key to filtering the posts we need to expire. By targeting posts with an expiration_date that has already passed, we ensure that only relevant content is set to draft, keeping your site up-to-date and your content strategy on track.
- Running the Query:
```
$expired_posts = new WP_Query($args);
```
  We create a new instance of WP_Query using our $args array. This query will return all posts that match our criteria (i.e., published posts with an expiration date in the past).
- Looping Through Expired Posts:
```
if ($expired_posts->have_posts()) {
    while ($expired_posts->have_posts()) {
        $expired_posts->the_post();
        $post_id = get_the_ID();
        wp_update_post(array(
            'ID'          => $post_id,
            'post_status' => 'draft',
        ));
    }
    wp_reset_postdata();
}
```
  This section checks if we have any expired posts. If so, it loops through each post, gets its ID, and uses wp_update_post() to update the post status to 'draft'. wp_reset_postdata() is then called to reset the global $post object, preventing any potential conflicts with other queries on your site. This loop is the engine that drives the expiration process, systematically setting outdated posts to draft and keeping your content fresh.

Putting It All Together

To recap, here's how this setup works:

You install and activate the Advanced Custom Fields plugin.
You create a date picker field named expiration_date using ACF.
You add the code snippet to your theme's functions.php file or use a code snippets plugin.
When you publish a post, you set an expiration date using the date picker field.
Every day, the wp_schedule_event() function triggers the expire_posts action.
The set_expired_posts_to_draft() function queries for posts with an expiration date in the past and sets them to draft.

That's it! You've successfully automated post expiration on your WordPress site. This system is both elegant and effective, freeing you from the burden of manual content management and ensuring that your site always presents the most current information.

Enhancements and Considerations

While this code snippet does the job, there are a few enhancements and considerations to keep in mind:

Email Notifications: You could add code to send an email notification when a post is set to draft. This can be useful for keeping content creators informed about the status of their posts. Implementing email notifications adds a layer of communication to the process, ensuring that all stakeholders are aware of content changes and can take appropriate action if needed.
Custom Post Status: Instead of setting the post to draft, you could create a custom post status like "Expired" for better organization and filtering. Using a custom post status provides a more granular approach to content management, allowing you to easily identify and manage expired content separately from drafts and published posts. This can be particularly useful for reporting and content auditing.
Performance: For very large sites with thousands of posts, you might want to optimize the query to run more efficiently. Consider adding indexes to your database or using a more targeted query to reduce the load on your server. Optimizing the query ensures that the expiration process remains performant even as your site grows, preventing any slowdowns or performance bottlenecks.
Time Zones: Be mindful of time zones when setting expiration dates. The code uses the server's time zone, so make sure it aligns with your needs. Time zone considerations are crucial for accurate post expiration, especially for sites with a global audience. Ensuring that your server's time zone is correctly configured is essential for the reliability of your automated expiration system.

Conclusion

Automating post expiration with ACF and a bit of custom code is a fantastic way to keep your WordPress site organized and up-to-date. No more manual unpublishing! This method is efficient, reliable, and saves you valuable time. So, go ahead and implement this on your site, and enjoy the peace of mind that comes with automated content management. You've just leveled up your WordPress game, guys! By automating this essential task, you're not only saving time and effort but also ensuring that your website always provides the most relevant and timely information to your audience. Happy coding, and may your content always be fresh!