Don’t mess with my Toot Toot
Last night a question was asked on twitter about the potential for adding alternative content types for WordPress. I replied.
I went so far as to suggest that it should be pretty easy to add a new content type and in return received a challenge, and this post is the result. I have written a plugin to add a very simple new type of post and I am going to try and explain the component parts of that plugin here. I don’t intend to include a lot of code; my intent is to explain the general process that I used, but the plugin will be attached to the end of the post for them that want to see how I did it.
There may be better and easier ways of doing it than this but this is my version.
What I decided to create
I needed this really simple. The point of the plugin was not to make a finished article but just to demonstrate how to, so I decided to create a twitter clone of sorts. Two fields would be editable, title and content, the content would be limited to 140 characters, and there would be no drafts or editing. Adding and deleting only.
These new posts would be called Toots.
Defining the new post type
To add a new type of content there are really two options: create a new table, or use the existing posts table.
The posts table was fairly recently amended to allow alternative post types. This, in combination with the fact that there are already a lot of functions that can be used instead of having to write my own made it a no-brainer for this exercise. I haven’t used any database code at all.
Adding a different type of post is very very simple. Once all the form handling, and validation is removed this small function is what actually makes the magic happen:
function new_toot( $title , $content ) { global $user_ID; //get the relevent post vars and save away // Create post object $my_post = array(); $my_post['post_title'] = $title; $my_post['post_content'] = $content; $my_post['post_status'] = 'publish'; $my_post['post_date'] = date('Y-m-d H:i:s'); $my_post['post_author'] = $user_ID; $my_post['post_type'] = 'toot'; $my_post['post_category'] = array(0); //Insert the post into the database return wp_insert_post( $my_post ); }
All that really happens here is that I create an array and pass it to wp_insert_post. A function that already exists in WordPress. Deleting a post is even easier.
Managing this content means adding a new write panel and a new manage page which respectively pass commands to the plugin and trigger the add and delete functions. So far so simple.
Theme pages
The next part of adding new content types is new theme pages, and defining a hierarchy of theme pages. So first it is necessary to create a custom URL.
I’ve written before about the process of creating a custom URL but there are effectively three processes involved:
- Tell WordPress to flush out the existing URL rules
- This triggers a process to reacquire them, at which point you can insert the new rules
- Add to the list of query string values that WordPress looks for, so you can use this to make decisions later
So when a user enters blogname/toots/19/ for example you can access this with $wp_query->get(’toots’) and use it to make decisions.
With that data available the template selection process can be interrupted and if a specific toot has been chosen, as per the URL above, a single toot page can be served and if toot is selected without an ID a toot archive can be served, or it can fall back to the home page, or archive page.
Displaying the content: creating a loop
Obviously this is all academic if the content can’t be output, so we need a loop:
When WordPress first loads the plugin creates a new query, in the same way as posts are created, but instead stores them in the $toot_list global variable, instead of the $posts global variable.
When the template selection happens, if a specific toot has been selected then a new query is carried out that replaces the current list, so only one toot is available.
The remaining functionality is handled by a list of functions that access the $toot_list global variable. I won’t list them all but the key ones are included here:
have_toots
This replicates that have_posts function that is part of the loop. It checks the global $toot_list to see if there are toots to display.
the_toot
This is the second part of the loop. This gets the next toot and makes it available to the other functions using the $toot global variable. This is equivalent to the $post global variable.
So the toot loop looks like this:
if (have_toots()) : while (have_toots()) : the_toot();
You can see it is practically the same as the normal post loop, but with toots instead of posts.
the_toot_title
The is the equivalent the_title, it echos the title.
the_toot_date
The it echos the date.
the_toot_content
The echos the content.
the_toot_rewind
The echos the content.
So a full loop might look like:
<?php if (have_toots()) : while (have_toots()) : the_toot(); ?> <h3><?php the_toot_date(); ?>: <?php the_toot_title(); ?></h3> <p><?php the_toot_content(); ?></p> <?php endwhile; ?> <?php endif; ?>
There is obviously more that would be done to make a fully complete new content type but hopefully this demonstrates how you can go about it, should you want to take things further.
