CodeGrrl.com » Tutorials

Part 12: Paginating your entries

Amelie — Sat, 28 Apr 2007 21:59:06 +0000

Many people have asked how to paginate their blog’s front page so as to show the previous/next 5 entries, for example. This tutorial was originally posted on the forums by Amanda.

Add this code to the blog page that displays your entries after you have your MySQL connection information:
```
$blog_postnumber = 5;
```
The number after the = is the number of posts you want displayed on your blog.

Next, add this underneath the above code:

if(!isset($_GET['page'])) {
	$page = 1;
}
else {
	$page = (int)$_GET['page'];
}
$from = (($page * $blog_postnumber) - $blog_postnumber);

Assuming you have kept the code of your blog index page as it is in the past tutorials, you should have this line near the top of the page:
```
$sql = "SELECT * FROM php_blog ORDER BY timestamp DESC LIMIT 5";
```
You should change that code to the following:
```
$sql = "SELECT * FROM php_blog ORDER BY timestamp DESC LIMIT $from, $blog_postnumber";
```
The next step is to link the pages. To do this, add the following code to the bottom of your index page. It will calculate how many pages are needed based on how many posts you have, and how many you want to display on each page. It will then link the pages for you.
```
$total_results = mysql_fetch_array(mysql_query("SELECT COUNT(*) as num FROM php_blog"));
$total_pages = ceil($total_results['num'] / $blog_postnumber);
if ($page > 1) {
    $prev = ($page - 1);
    echo "<<  Newer ";
}
for($i = 1; $i <= $total_pages; $i++) {
    if ($page == $i) {
        echo "$i ";
        }
		else {
           echo "$i ";
        }
}
if ($page < $total_pages) {
   $next = ($page + 1);
   echo "Older >>";
}
```
For this last part to work, it’s assuming the page with your blog entry list is named index.php. If it’s not, you can change the index.php part in the last code. (It’s listed 3 times.)

Part 11: Categories

Amelie — Fri, 27 Apr 2007 22:12:34 +0000

This tutorial will teach you how to add simple categories to your blog.

The first thing we need to do is to add a category table to our database. We could just list the categories in the entries table, but this can cause problems if you need to rename a category. Doing it this way means that the category will change everywhere if you edit it once.

First, we need to connect to MySQL.

(Remember to add your own details)

Next we select the database to use:

mysql_select_db('db_name');

Second, we tell MySQL to add our table to the database. We will need two columns, one which will be the category ID number, and the other which will be the category name. We will give our category field a limit of 255 characters, since anything longer than that is unlikely. Our ID numbers will be automatically incremented and unique, so we must tell MySQL to do this for us. We will also tell it that the ID will be an unsigned number (i.e., it won’t be negative) and that the number won’t go over 9999 (4 digits, in other words).

This is the code we will use:

$result = mysql_query("CREATE TABLE php_blog_categories
(`category_id` smallint(4) UNSIGNED AUTO_INCREMENT NOT NULL,
`category_name` varchar(255) NOT NULL DEFAULT '',
PRIMARY KEY (`category_id`))");

Because each category ID number relates to the category name, we will assign it as our primary key. This helps MySQL to associate the different IDs to the category names, and this will help us to match entries to categories. It also makes sure that we never have a duplicate ID number.

We will run that command through MySQL. To check if it worked or not, we will add a snippet to the script, which will check whether the query was successful (true) or not. If it wasn’t, we’d like MySQL to tell us why:

if ($result == true) echo 'Table created successfully.';
else 'Table could not be created. ' . mysql_error();

Then we will close MySQL and PHP.

mysql_close();
?>

The complete table script should look like this:

Run this just like you did when creating the initial table in part 1. If you get a success message, you are ready to move onto step 2.

The next thing to do is to add a column to our entries table to show which category a post is in. We will be doing this using the category’s ID number, not the category name. Let’s say we have a category called "work", which has an ID of 1. All entries that are categorised under "work" will have the number 1 in their category column, and MySQL will translate that ID, using the table we just created, to its proper name. It sounds complicated, but it really isn’t!

We will be altering the entries table just like we did for the password in part 4. We will run a quick snippet, just like the one above, to change the table. We need to tell the table that we would like a new column called category, and that it will have the same details as the category ID table (except that it does not need to be unique - one category can contain many entries). This is the code we will use:
Run that just like above, and once again if you got a success message you are ready for the next step.
Now we must add a page that will manage categories for us. We want to be able to add, rename and delete categories, and this part will teach you how to do this.

Here is the code that we will use:
Obviously this is not the complete code, it is the outline for what we want to do. First we are checking whether any of the form buttons were pressed, and which one it was. If no button was pressed, we will get the page to show us all our existing categories.

This is the first thing we will do, even though it comes last in the code structure, as it will help you to see how the categories are processed. It’s also the easiest part

As I said, the categories will be shown, along with options of what to do with them, by default on the page.

Find this part in the code structure I posted above:
```
else {

}
```
Between the { and the }, we will get our categories from the database. This is how we will do it:

First, let’s get the details from the database.
```
$result = mysql_query("SELECT * FROM php_blog_categories");
```
Second, let’s close PHP so we can add some HTML code to format the categories before we show them. We also need to create the form that will tell PHP what we want doing with a category.
```
?>
```
Then we will reopen PHP, and start showing our results in a loop (so that we don’t have to keep repeating the database selection every time). This is the same principle we used when showing the blog entries.
Here I have closed PHP again, as it will make it easier to see what we are doing. Now we are going to create a list of all the categories, like so:
```
 
```
When run by PHP, the HTML will be ‘filled in’, and will look something like this:
```
 Work
```
That code will repeat for every category you have.

Now we go back into PHP and and close the while loop:
Then we come out of it again, and add our HTML for the edit and delete buttons and the end of the form. Underneath, we will also add a new form to add a new category.
```
 




Add new category:  
```
We then need to reopen PHP to continue the script.
```
The complete code for categories.php should look like this now:





 





 




Add new category:  




At the moment, you will most likely not have any categories, as you have just created the tables, so running the categories.php as it is will probably result in a blank page with just the buttons. Don’t worry! That is normal.
```
Next we will process category addition.

Find the following part in your code:
```
if (isset($_POST['add_category'])) {

}
```
Between those {}s, we will add our processing code.

First we will strip HTML and convert special characters as both a security precaution and to prevent problems with category names.
```
$newcat = htmlspecialchars(strip_tags($_POST['new_category']));
```
Next, we need to check if a category was submitted. If the text box was left blank, we will display an error and stop the script from going any further. You might ask why we are doing this after stripping invalid characters from the category - we do it afterwards in case the category was made up only of invalid characters. If the entire category name is stripped out, it will be as if the person didn’t enter anything at all.
```
if (empty($newcat)) {
die("No category submitted! Please go back and enter one.");
}
```
If the category is not empty, the script will be allowed to continue (it will stop and display an error if the category is empty), so we don’t need an else statement for the next part, which is to add the category to the database.

Before we add the code to the database, we need to escape quotes. On most servers this is done automatically, but if it isn’t, you’ll have problems adding new categories containing quotes.

First we need to check whether the server will escape the quotes for us. Because we only need to do something if the server doesn’t escape the quotes, that is what we will check for, hence the ! in the if statement.
```
if (!get_magic_quotes_gpc()) {
$newcat = mysql_real_escape_string($newcat);
}
```
mysql_real_escape_string() will escape the quotes for us. It is similar to addslashes() which is used in previous parts of the Build A Blog tutorials, but mysql_real_escape_string() is especially suited for MySQL databases so is better to use than addslashes().

Here is the code we will use to submit the new category to the database:
```
$insert = mysql_query("INSERT INTO php_blog_categories (`category_name`) VALUES ('$newcat')");
```
We then check to see if the category was successfully submitted:
```
if ($insert == true) echo 'Category successfully added.';
else echo 'The category could not be added to the database. ' . mysql_error();
```
Now our complete code should look like this:
```
 





 




Add new category:  
```
The next part we will do is category deletion, as editing is a little bit harder. We will do that part last.
The code to delete entries is very similar to the code to add entries - we will check to see if a value was submitted, and if that value was a number (the category ID). Then we will take that value, and delete the category to which that ID number corresponds.

So, find this part in your code:
```
elseif (isset($_POST['delete_category'])) {

}
```
As usual, we will add our new code between the braces ( { and } ).

Let’s make sure the category that was submitted is valid (i.e. a number):
```
$category = (int)$_POST['category'];
```
Next, let’s see if a category was actually chosen for deletion (again, we do this after checking that the category is a number, as if it isn’t it will have been stripped out by the above code and will be equivalent to not having chosen a category to delete).
```
if (empty($category)) {
die("No category chosen! Please go back and choose a category to delete.");
}
```
If the above did not fail, we are sure we have an ID number. Let’s delete its corresponding category from the database:
```
$delete = mysql_query("DELETE FROM php_blog_categories WHERE `category_id` = $category LIMIT 1");
```
I’ve added a LIMIT 1 to the end, because although we are meant to have unique category ID numbers, if, for whatever reason you end up with two categories with the same ID number, we only want to delete one of the entries. LIMIT 1 will make sure that this happens.

Now we will test to see if the category was deleted successfully:
```
if ($delete == true) echo 'Category successfully deleted.';
else echo 'The category could not be deleted. ' . mysql_error();
```
The complete code should now look like this:
```
 





 




Add new category:  
```

The next stage is to edit our categories. This is slightly more complicated than the other steps, as we first need to select the category we want to edit, show a form to edit it, then submit the changes to the database.

First, find the only remaining "blank" part of your code (i.e. a part which doesn’t do anything), which is this part:

elseif (isset($_POST['edit_category'])) {

}

Between the {}s we will start our new code.

Let’s make sure the category is a number and that it is not empty (this is the exact same process we used for the deleting part):

$category = (int)$_POST['category'];

if (empty($category)) {
die ("No category chosen! Please go back and choose a category to edit.");
}

Next we will get the current category name from the database:

$result = mysql_query("SELECT * FROM php_blog_categories WHERE `category_id` = $category LIMIT 1");
$row = mysql_fetch_array($result);

Let’s check that the category actually exists. If it doesn’t, we will get errors everywhere or a blank page (depends on server settings), so let’s tell the user and exit the script before this has a chance to happen.

if (!$row) {
die("There doesn't seem to be a category with the ID number submitted. Please go back and try again.");
}

The !$row part is short for if ($row == false), which would be the case if no results were found in the database corresponding to the ID number we want.

We will close PHP now, so we can use HTML properly to display a form for a new category name.

?>

We will add a hidden field now. The value of the field will be the ID number of the category, so that the database knows which category this is when the form is submitted; the name of the field will be the section of the script we are in, which is edit_category. This will enable the script to know where we are once the form has submitted.

Now we will show a field for entering a new category name, along with some text which tells us what the category is currently called.

The current category name is . To change it, enter a new name in the box below.
Rename category to:

Finally for this part, we need to reopen PHP for the script to continue:


We have now created our category editing form, but it is of no use without the processing part which we will do next.
Your edit category part should look like this:
elseif (isset($_POST['edit_category'])) {

$category = (int)$_POST['category'];

if (empty($category)) {
die ("No category chosen! Please go back and choose a category to edit.");
}

$result = mysql_query("SELECT * FROM php_blog_categories WHERE `category_id` = $category LIMIT 1");
$row = mysql_fetch_array($result);

if (!$row) {
die("There doesn't seem to be a category with the ID number submitted. Please go back and try again.");
}
?>





The current category name is . To change it, enter a new name in the box below.


Rename category to: 




The next part will go ABOVE what we have just done. In other words, it will go underneath this line:
elseif (isset($_POST['edit_category'])) {
But above this one:
$category = (int)$_POST['category'];
What we will do now is check to see if the category has been renamed, and if it has, we will change it in the database. This is almost exactly the same process as the category addition section.
First we will check whether we have pressed to rename our category, or whether want to display the form to rename it (note that there is no closing brace on the end of this line, we will add this once we have finished processing the category).
if (isset($_POST['submit_category_edit'])) {
Now we check that the category name is appropriate, by stripping HTML and converting entities:
$newcat = htmlspecialchars(strip_tags($_POST['new_name']));
Next, we check to see if a category name was submitted:
if (empty($newcat)) {
die("No new category name entered, please go back and try again.");
}
Now we will check to see if a category ID was submitted, making sure it is numeric first.
$id = (int)$_POST['edit_category'];

if (empty($id)) {
die("Invalid category!");
}
Once we are sure we have all the parts we need, we need to update the category details in the database. However, we should escape any quotes first, as we did for the category addition part:
if (!get_magic_quotes_gpc()) {
$newcat = mysql_real_escape_string($newcat);
}
This is the code we shall use update the database:
$edit = mysql_query("UPDATE php_blog_categories SET `category_name` = '$newcat' WHERE `category_id` = $id LIMIT 1");

if ($edit == true) echo 'Category successfully edited.';
else echo 'Category could not be edited. ' . mysql_error();
The last thing we will do is to close the if statement we began earlier, to test whether we were updating the category or not. We do this by adding a closing brace.
}
We also need to separate the processing part from the editing form, otherwise we will have both happening at once. So we will add an else statement after the closing brace mentioned above, like so:
else {
And then a closing brace just before this line:
elseif (isset($_POST['delete_category'])) {
The complete edit block should look like this:
elseif (isset($_POST['edit_category'])) {

if (isset($_POST['submit_category_edit'])) {

$newcat = htmlspecialchars(strip_tags($_POST['new_name']));

if (empty($newcat)) {
die("No new category name entered, please go back and try again.");
}

$id = (int)$_POST['edit_category'];

if (empty($id)) {
die("Invalid category!");
}

if (!get_magic_quotes_gpc()) {
$newcat = mysql_real_escape_string($newcat);
}

$edit = mysql_query("UPDATE php_blog_categories SET `category_name` = '$newcat' WHERE `category_id` = $id LIMIT 1");

if ($edit == true) echo 'Category successfully edited.';
else echo 'Category could not be edited. ' . mysql_error();

}
else {

$category = (int)$_POST['category'];

if (empty($category)) {
die ("No category chosen! Please go back and choose a category to edit.");
}

$result = mysql_query("SELECT * FROM php_blog_categories WHERE `category_id` = $category LIMIT 1");
$row = mysql_fetch_array($result);

if (!$row) {
die("There doesn't seem to be a category with the ID number submitted. Please go back and try again.");
}
?>




The current category name is . To change it, enter a new name in the box below.

Rename category to: 






And that’s the category management part done!
categories.php should look like this when completed:


        
        

        The current category name is . To change it, enter a new name in the box below.

        Rename category to: 


        
        

        
    

    

         


        

    
     

    

    
    Add new category:

Now we need to implement categories into our new post and edit post pages. We will start with the new post page.

Find the following part in your entry posting page:

Title:

Above that, we will add our category selection box. By default this may look slightly odd on your page, especially if you have a long category name, but you can easily change this using CSS.

We will start by getting our categories from the database. We don’t have a database connection on this page yet, so we will insert one here:


Let’s select the categories and display them in a loop:
$result = mysql_query("SELECT * FROM php_blog_categories");

echo 'Category: 
Now find this part in your post page:
$entry = nl2br($entry);
Above that, we will add our category processing, and we will make sure it’s a number (category ID):
$category = (int)$_POST['category'];
Next find this:
$sql = "INSERT INTO php_blog (timestamp,title,entry) VALUES ('$timestamp','$title','$entry')";
(This may look slightly different if you have password protection or custom fields enabled)
You need to add the category field to this query.
$sql = "INSERT INTO php_blog (timestamp,title,entry,category) VALUES ('$timestamp','$title','$entry','$category')";

Now that we have added the category to new posts, we need to be able to add it to our edit posts page as well, so we can change the category if needs be.

Please note that you can only have ONE category per entry. This tutorial will not teach you how to give your entries multiple categories (or "tags").

In your update entry page, find the following code:
```
$old_timestamp = $row['timestamp'];
$old_title = stripslashes($row['title']);
$old_entry = stripslashes($row['entry']);
$old_password = $row['password'];
```
Add this part to the end:
```
$old_category = $row['category'];
```
Next, find this part:
```
Title: 
```
Above that, we will add our categories just like we did to the post entry form. We don’t need to open a database connection since we already have one, so we will get straight to it. However, we need to make sure the current category of the entry is selected; we will do this by testing each category to see if it matches the category ID stored for that post. If it matches, we will insert the proper HTML to select the current category by default.

Here is the code for the categories:
```
Category: 
```
We need to call this $row2 and $result2 rather than our normal $result and $row, since we already have a $result and $row - those are related to the entry (not the categories), and we don’t want to overwrite them.

Now we must process the category update. This is identical to what we did to process the category in the new post page - first we look for this part in the code:
```
$entry = nl2br($entry);
```
Underneath it, we add:
```
$category = (int)$_POST['category'];
```
Now is where it differs slightly. Find this part:
```
$result = mysql_query("UPDATE php_blog SET timestamp='$timestamp', title='$title', entry='$entry', password='$password' WHERE id='$id' LIMIT 1") or print ("Can't update entry.
" . mysql_error());
```
(Again, this will differ depending on which fields you have in your database, and whether you are using password protection or not)

Let’s add the category update to that query:
```
$result = mysql_query("UPDATE php_blog SET timestamp='$timestamp', title='$title', entry='$entry', password='$password', category='$category' WHERE id='$id' LIMIT 1") or print ("Can't update entry.
" . mysql_error());
```
And we’re done!
But of course we’re not completely done yet - we want to show the category of a post on our blog front page, and on an individual entry.
To do this, find this part in both your main blog page and your individual entry page (it will appear several times in your individual entry page, and again will look different depending on the fields you have):
```
    $title = stripslashes($row['title']);
    $entry = stripslashes($row['entry']);
    $password = $row['password'];
```
Underneath this, we need to get our categories. We have them stored by ID in the entries table, so we need to convert them to their names.

To do this, we need to get the name from the categories table, using the ID stored in the entries table, like so:
```
$get_categories = mysql_query("SELECT * FROM php_blog_categories WHERE `category_id` = $row[category]");
$category = mysql_fetch_array($get_categories);
```
Now we are ready to display the category. Find these parts in your blog and individual entry pages (again, this may appear several times:
```
        



        Posted on 
```
Just add the category where you want it to show up. For example:
```
        



        Posted in  on 
```

…You probably want to show all the posts in one category now, don’t you? Well if you do, you can change the code above to link the category to its archives, like so:

Posted in  on

We will now make a category archive page, which will look pretty much exactly like the yearly archive page. We will call this page category.php (note that this is different from your category admin page, which is called categories.php. You can of course rename these files to anything you like, but in this example I will use category.php as the category archive page.

Let’s start with the MySQL connection:


We now need to check what category we are displaying, which is decided by the ?category= part in the URL. If someone has gone directly to category.php without specifying a category to display, we need to display an error just like we do in the single entry page and the archive page, when the person hasn’t specified a year or entry ID to look at.
if (!isset($_GET['category'])) {
    die("Invalid category specified.");
}
else {
    $category = (int)$_GET['category'];
}
Now that we have the category we want to display entries from, let’s collect the posts from the entries table:
$result = mysql_query("SELECT timestamp, id, title FROM php_blog WHERE category = $category ORDER BY id DESC");
We will now add up how many posts were found:
$num = mysql_num_rows($result);
…and get the category name from the categories table:
$get_category = mysql_query("SELECT * FROM php_blog_categories WHERE category_id = $category");
$get_category2 = mysql_fetch_array($get_category);
Now we can use those details as a header, for example you might want to say something like this:
echo "There are $num posts in the "$get_category2[category_name]"category
"
Let’s now show the posts. This is identical to the archive page entry code.
while ($row = mysql_fetch_array($result)) {
    $date = date("l F d Y", $row['timestamp']);
    $id = $row['id'];
    $title = stripslashes($row['title']);

    ?>

    


    
That’s the category archive done. The complete code should look like this:
There are $num posts in the "$get_category2[category_name]"category";

while($row = mysql_fetch_array($result)) {
    $date = date("l F d Y", $row['timestamp']);
    $id = $row['id'];
    $title = stripslashes($row['title']);

    ?>

You may want a little block to display all your categories and the number of posts in them, just like for the yearly archives. If you’d like to do this, here is how.

First, let’s connect to the database:


Next, let’s get our categories from the database:
$result1 = mysql_query("SELECT * FROM php_blog_categories ORDER BY category_name ASC");
Now let’s display the categories and link them to the archives:
while($row = mysql_fetch_array($result1)) {
Ah, before we can do that, we need our posts! We need to get them while inside the loop, as we need a different post count for each category.
$result2 = mysql_query("SELECT COUNT(`id`) AS entries FROM php_blog WHERE category = $row[category_id]");
$num_entries = mysql_fetch_array($result2);
Now we can proceed with showing the posts!
    echo '' . $row['category_name'] . ' (' . $num_entries['entries'] . ')
';
Let’s close that while loop and PHP in general:
}
?>
Your category archive block should look like this:
' . $row['category_name'] . ' (' . $num_entries['entries'] . ')
';

}
?>

And that’s it! Now you should have categories fully enabled in your blog!

Randomize… Pretty much anything!

Valerie — Tue, 11 Apr 2006 12:42:30 +0000

So… you want a random background image? Or a random stylesheet, even? Try this out - it’s quick, easy - and will use PHP and CSS.

First you, of course, should be able to use PHP on your site. You should also know a little bit about CSS. Those are the two things this technique will use. There are numerous ways this can be accomplished but this is the way I am currently using it on my blog site.

First, I have the area where I want the images to be randomized. This is my header image. I have a div for that and it has both an ID and a Class. This is what it looks like before I randomize it:

I use the ID to define all the basics and styles other than the image to get that out of the way and free the Class up for the random background image.

Next, add in your random PHP snippet that will essentially change the Class with each page load:

So now the whole thing looks like this:

Just change that “X” to however many images you plan to have be it 5 or 20, it is your maximum value that you want outputted. When you load the page, that random PHP snippet will pick a number between 1 and that number, so you will end up with class=”random2″ or class=”random5″ and so on. Of course, if you want to get technical, you can also change that “1″ to something, so as to randomize between, say, 3 and 7, etc.

Now you need to tell it what to do with those classes. In your CSS, define what each and every one of those classes will do. If you’ve got three images you want to rotate between, you might do something like this:

.random1 {background: url(images/image1.jpg);}
.random2 {background: url(images/image2.jpg);}
.random3 {background: url(images/image3.jpg);}

See? Easy!

That’s just the bare minimum, you could even use the CSS to randomize anything: different colored text, different margins, padding, borders, etc. If you really wanted to waste a lot of time, you could use that PHP snippet in your call for a stylesheet and load a completely different stylesheet each time, you would just start your stylesheet code and put the PHP code somewhere inside the href call for the stylesheet and have your stylesheets appropriately named. Of course, that might make your visitors want to pluck out their eyes, but you get the idea!

Skinning: Customising your skins page

Vixx — Fri, 20 May 2005 12:48:46 +0000

If you have skinned your site and offer visitors several different themes to pick from, this tutorial will show you how to customise your skins.php page so that it changes the information about the current layout according to what skin your visitor is using.

Although this means we have to use cookies and a little PHP, you don’t need to know much about them to implement this . . . although it should go without saying that you should have already implemented my skinning tutorial successfully for this to work!

Please note that I have not tested this method with any skinning tutorial other than the one I wrote myself here at CodeGrrl, but there isn’t a reason why this shouldn’t work with any other skinning method as they’re all essentially the same.

Step One:

On my own version of skins.php I have a small introduction about skins and some screencaps to show visitors what the layouts are like before you reach the heading “About This Layout”, but you can actually place this anywhere you like on the page. So wherever you want your layout information to display, add this:

About This Layout

You're currently viewing theme 1 entitled \"NAME OF SKIN\" which was uploaded on DATE OF UPLOAD.

"; } ?>

You can add as much information as you like - as you can see on my site, I talk about what resolutions and browsers the skin is optimised for, credits for images, validation details etc. etc. You can also use HTML as normal, although you will need to remember that any "s (speechmarks) need to be prefixed with a backslash ( \ ) in order for the page to display properly. For instance, if you have a link like:

Click here!

You will need to change it to:

Click here!

Step Two:

Add the snippet in Step One for every skin/layout you have, changing

if ($_COOKIE['skin'] == 1)

to:

elseif ($_COOKIE['skin'] == 2)

and so on, according to whichever skin number you’re referring to.

Step Three:

That’s it - all done! You should now have a skins.php that displays only one "About This Layout" section that changes according to what skin number your visitor has selected!

Part 10: Deleting entries

Valerie — Tue, 04 Jan 2005 12:53:12 +0000

My turn! Okay, this is my attempt at writing my first tutorial.

A lot of people have been asking how to delete the entries out of build-a-blog. So that is what this tutorial will cover. You should have followed all of the parts of the tutorial so far up to this point, this tutorial will assume that you have.

Let’s open our update.php, or whatever file you are using to change entries after they’ve been posted.

Since we’ve already got the rest of the code for this file, let’s find the part that looks something like this, towards the end of your file:

Optional: right after that, let’s put a little warning message…

Before deleting, be absolutely sure - there is no confirmation nor is there any way to reverse deletion!
(You may be shown your entry again after deleting - do not worry, it HAS been deleted. Check the main page of the blog if you are still unsure.

This is just a little note to remind you that once you will click the button, your entry will be gone. There will be no confirmation, no box asking you "are you sure?" That can be written in later.

Now we’ve got to write the actual code to delete the entry.
This is a new form, and like the update form, it will use the same page to process what you want it to do.

We need to pass the variable of the id (if you remember, the id is passed to the update form from the list of entries you clicked on to get there, so we’ll need to do the same thing here):

And we want to submit our decision, aka delete it.

Of course, your button can say whatever you want it to, just change the part for the value - just don’t use apostrophes or quotes.

Now, to process the deletion.
Let’s skip over the part from the original update form that starts as follows:

    if (isset($_POST['update'])) {

And closes like so:

    header("Location: journal.php?id=" . $id);

}

After that, skip a line and start your process. Notice that we gave our above submit button a name of "delete" this is where that comes into play.

if (isset($_POST['delete'])) {

Let’s get the id from the form:

    $id = (int)$_POST['id'];

Next, what should PHP do with the it?

    $result = mysql_query("DELETE FROM php_blog WHERE id='$id'") or print ("Can't delete entry.
" . mysql_error());

The above will also give you the output of an error if deletion is unsuccessful for any reason.

Now what do we do if deletion is successful? If the result of deletion is != (not equal to) false, then we say so. We’re also telling the code to "exit" here - without this, an error would occur after deletion. You can include a link back to your main admin page here if you like.

    if ($result != false) {
        print "The entry has been successfully deleted from the database.";
        exit;
    }
}

The end!

Okay, just kidding, let’s wrap it up. What does it look like now?
You should have two parts: part 1 is after the update form, before processing that form, and will contain your delete form; part 2 is after processing the update and it will process the delete form.

Your complete update.php should look more or less like this:

" . mysql_error());

    header("Location: journal.php?id=" . $id);

}

if (isset($_POST['delete'])) {
    $id = (int)$_POST['id'];
    $result = mysql_query("DELETE FROM php_blog WHERE id='$id'") or print ("Can't delete entry.
" . mysql_error());
    if ($result != false) {
        print "The entry has been successfully deleted from the database.";
        exit;
    }
}

if (!isset($_GET['id']) || empty($_GET['id']) || !is_numeric($_GET['id'])) {
    die("Invalid entry ID.");
}
else {
    $id = (int)$_GET['id'];
}

$result = mysql_query ("SELECT * FROM php_blog WHERE id='$id'") or print ("Can't select entry.
" . $sql . "
" . mysql_error());

while ($row = mysql_fetch_array($result)) {
    $old_timestamp = $row['timestamp'];
    $old_title = stripslashes($row['title']);
    $old_entry = stripslashes($row['entry']);
    $old_password = $row['password'];

    $old_title = str_replace('"','\'',$old_title);
    $old_entry = str_replace('
', '', $old_entry);

    $old_month = date("F",$old_timestamp);
    $old_date = date("d",$old_timestamp);
    $old_year = date("Y",$old_timestamp);
    $old_time = date("H:i",$old_timestamp);
}
?>





Date (month, day, year): 







Time: 

Title:  

Password protect?  />

<?php echo $old_entry; ?>





Before deleting, be absolutely sure - there is no confirmation nor is there any way to reverse deletion!

(You may be shown your entry again after deleting - do not worry, it HAS been deleted.  Check the main page of the blog if you are still unsure.

Now we should be all done.

Part 9: Creating a form to edit and delete comments

Julie — Thu, 30 Dec 2004 12:58:52 +0000

As you may or may not know, Michelle is currently unable to add to the Build A Blog series of tutorials, so I thought I’d try my hand at writing a new instalment. I can’t promise it will be as good as her tutorials, but I’ll do my best! This tutorial covers the creation of an admin page for editing and deleting user comments.

This code is based on Michelle’s tutorial for creating a form to edit entries. I’ve also followed her style of coding to keep this tutorial similar to the previous ones.

Before following this tutorial, you need to set up comments by following Part 7: Allowing Reader Comments.

Let’s start by creating a page called editcomments.php. This page needs to go in the same password protected directory as your blog entry and edit pages to keep it secure.

First, open PHP:


Connect to your database (change the values as applicable):
mysql_connect ('localhost', 'db_username', 'db_password') ;
mysql_select_db ('db_name');
Now, we will write an if statement to check if the edit form (which we’ll create further down the page) has been submitted, and if so, to process it by updating the database with the new posted info. Here we will also strip out HTML as a security measure:
if (isset($_POST['edit'])) {
    $name = htmlspecialchars(strip_tags($_POST['name']));
    $email = htmlspecialchars(strip_tags($_POST['email']));
    $url = htmlspecialchars(strip_tags($_POST['url']));
    $comment = htmlspecialchars(strip_tags($_POST['comment']));
    $comment = nl2br($comment);
    $id = (int)$_POST['id'];

    if (!get_magic_quotes_gpc()) {
        $name = addslashes($name);
        $url = addslashes($url);
        $comment = addslashes($comment);
    }

    $result = mysql_query("UPDATE php_blog_comments SET name='$name', email='$email', url='$url', comment='$comment' WHERE id='$id' LIMIT 1") or print ("Can't update comment.
" . $result . "
" . mysql_error());
    if ($result != false) {
        print "The comment has successfully been edited!";
    }
}
Next, another if statement to check if the delete form (again, we’ll create it further down the page) has been submitted, and if so, to process it by deleting the comment from the database and posting a success message:
if(isset($_POST['delete'])) {
    $id = (int)$_POST['id'];
    $result = mysql_query("DELETE FROM php_blog_comments WHERE id='$id' LIMIT 1") or print ("Can't delete comment.
" . $result . "
" . mysql_error());
    if ($result != false) {
        print "The comment has successfully been deleted!";
    }
}
Just like the edit entries page, the form to edit a comment only shows up if the url is http://yourdomain.com/dir/editcomments.php?id=xx where xx is the id number of the comment.  So, now we will write an if statement to check if that variable $id has been passed through the URL, and whether it’s a valid ID (i.e. it’s not zero or a letter):
if (isset($_GET['id']) && !empty($_GET['id']) && is_numeric($_GET['id'])) {
Take note that it’s necessary here to use $_GET['id'] instead of just $id, even if you have register_globals on.  $_GET holds the variables passed through the URL and not those from forms, cookies, or other methods.  For this particular statement, we only want to check for a query string (URL) variable here, so it’s important to make the distinction.
So, if $_GET['id'] is set, that means we can show the edit form for the comment with that id number.  First we select the comment from the database:
$result = mysql_query ("SELECT * FROM php_blog_comments WHERE id='$_GET[id]'") or print ("Can't select comment.
" . mysql_error());
Then use a while loop to set variables for the existing comment data:
while ($row = mysql_fetch_array($result)) {
      $old_name = stripslashes($row['name']);
      $old_email = $row['email'];
      $old_url = stripslashes($row['url']);
      $old_comment = stripslashes($row['comment']);
      $old_comment = str_replace('
', '', $old_comment);
}
And now the form, which we will fill with the values we just set.  Note that there are three submit buttons: one to save changes, one to delete the comment, and one to cancel with no changes made (it just takes you back to the edit comments menu, which we’ll create further down in the tutorial). Here we close PHP for a bit so that we can add some normal HTML, but we will reopen it as and when needed.:
?>

    

    Name: 

    E-mail: 

    URL: 

    Comment:

    <?php echo $old_comment; ?>

      



Now for the else that goes with the if $_GET['id'] above.  So everything below this is now if $_GET['id'] is not set:
}
else {
What we are creating now is the edit comments menu that shows up by default if you just go to editcomments.php with no ?id=xx.  It involves three database queries - the second and third being nested inside the first.  The first query selects from the comments table the id of each blog entry that has comments.  The second query then gets the date and title of the entry from the blog table.  The third query gets the comments from that entry.  Here it goes…
The first query.  The limit is set to 10 entries worth of comments to keep the page from being too long, but you can change it to whatever number you like, or just remove the limit completely:
$result = mysql_query("SELECT entry AS get_group FROM php_blog_comments GROUP BY get_group DESC LIMIT 10") or print ("Can't select comments.
" . $result . "
" . mysql_error());
Now start the while loop and set the value of $get_group, which in this case is the id number of an entry.  Then open a paragraph to hold each entry’s comment links (to keep things neat).  We don’t close the while loop yet because the next two are nested inside this one… we’ll close it later on:
while($row = mysql_fetch_array($result)) {
     $get_group = $row['get_group'];

     print "";
The second query, to get the timestamp and title from the blog table.  Inside the while loop, we format the date and then print the date and title.  This while loop can be closed here, because the third query doesn’t depend on it.
    $result2 = mysql_query("SELECT timestamp, title FROM php_blog WHERE id='$get_group'");
    while($row2 = mysql_fetch_array($result2)) {
        $date = date("l F d Y",$row2['timestamp']);
        $title = stripslashes($row2['title']);
        print "" . $date . " - " . $title . "
";
    }
Now the final query to get the comment info so we can format it to be linked to the edit page.  Don’t close this while loop just yet, there’s more:
    $result3 = mysql_query("SELECT * FROM php_blog_comments WHERE entry='$get_group' ORDER BY timestamp DESC");
    while($row3 = mysql_fetch_array($result3)) {
        $id = $row3['id'];
        $name = stripslashes($row3['name']);
        $comment = stripslashes($row3['comment']);
        $date = date("l F d Y",$row3['timestamp']);
We want to know which comment we are clicking on to edit, but if we displayed each comment in full, the page could get quite lengthy.  So, we can check to see if the comment is longer than 75 characters, and if it is, trim it and put an ellipsis on the end. We’re also stripping line breaks in order to keep the size down as well:
        if (strlen($comment) > 75 || strstr($comment, "
") || strstr($comment, "\n")) {
            $comment = substr($comment,0,75) . "...";
            $comment = str_replace("
", "", $comment);
            $comment = str_replace("\n", " ", $comment);
        }
Now print the comment (or comment snippet), linked to the edit form for that comment:
        print "" . $comment . "
Comment by " . $name . " @ " . $date;
Close the paragraph, the third query’s while loop, the first query’s while loop and then the else part we opened earlier:
        print "";

    }
}
}
Then close the database connection:
mysql_close();
And finally, close PHP:
?>
Here’s the whole code for the editcomments.php page:
" . $result . "
" . mysql_error());
    if ($result != false) {
        print "The comment has successfully been edited!";
    }
}

if(isset($_POST['delete'])) {
$id = (int)$_POST['id'];
     $result = mysql_query("DELETE FROM php_blog_comments WHERE id='$id' LIMIT 1") or print ("Can't delete comment.
" . $result . "
" . mysql_error());
     if ($result != false) {
         print "The comment has successfully been deleted!";
     }
}

if (isset($_GET['id']) && !empty($_GET['id']) && is_numeric($_GET['id'])) {

$result = mysql_query ("SELECT * FROM php_blog_comments WHERE id='$_GET[id]'") or print ("Can't select comment.
" . mysql_error());

while ($row = mysql_fetch_array($result)) {
      $old_name = stripslashes($row['name']);
      $old_email = $row['email'];
      $old_url = stripslashes($row['url']);
      $old_comment = stripslashes($row['comment']);
      $old_comment = str_replace('
', '', $old_comment);
}

?>


    

    Name: 

    E-mail: 

    URL: 

    Comment:

    <?php echo $old_comment; ?>

      


" . $result . "
" . mysql_error());

while($row = mysql_fetch_array($result)) {
     $get_group = $row['get_group'];

     print "";

    $result2 = mysql_query("SELECT timestamp, title FROM php_blog WHERE id='$get_group'");
    while($row2 = mysql_fetch_array($result2)) {
        $date = date("l F d Y",$row2['timestamp']);
        $title = stripslashes($row2['title']);
        print "" . $date . " - " . $title . "
";
    }

    $result3 = mysql_query("SELECT * FROM php_blog_comments WHERE entry='$get_group' ORDER BY timestamp DESC");
    while($row3 = mysql_fetch_array($result3)) {
        $id = $row3['id'];
        $name = stripslashes($row3['name']);
        $comment = stripslashes($row3['comment']);
        $date = date("l F d Y",$row3['timestamp']);

        if (strlen($comment) > 75 || strstr($comment, "
") || strstr($comment, "\n")) {
            $comment = substr($comment,0,75) . "...";
            $comment = str_replace("
", "", $comment);
            $comment = str_replace("\n", " ", $comment);
        }

        print "" . $comment . "
Comment by " . $name . " @ " . $date;
        print "";

    }
}
}
mysql_close();

?>
That’s it!  Remember to insert your database connection info and to change the table names if yours aren’t php_blog and php_blog_comments.  You should now have an admin panel to edit and delete comments.  If you have any problems, please post in the tutorials forum!

Allow duplicate emails

Julie — Mon, 29 Nov 2004 13:13:20 +0000

This brief tutorial will show you how to allow members to join with duplicate emails.

Open join.php and find the following lines of code (if you haven’t edited anything, they should start at line 316):

    if ($num == "0"){
        if ($emailnotify == 'Y'){

    $msg = "Name:\t$_POST[name]\n";
    $msg .= "E-Mail:\t$_POST[email]\n";
    $msg .= "Hide E-Mail:\t$_POST[hideemail]\n";
    $msg .= "URL:\t$_POST[url]\n";
    $msg .= "Country:\t$_POST[country]\n";
       if ($enablefave == 'Y'){
    $msg .= "Fave:\t$_POST[fave]\n"; }
    $msg .= "Comments:\t$_POST[comments]\n";
    $msg .= "Sender IP:\t$REMOTE_ADDR\n";
    $msg .= "\nLogin to your Admin Panel: $siteurl/admin.php\n";

    $recipient = "$adminemail";

    $subject = "Member - $sitename";

    $mailheaders = "From: $_POST[email]\n";
    $mailheaders .= "Reply-To: $_POST[email]\n\n";

    mail($recipient, $subject, $msg, $mailheaders); }

       if ($enablefave == 'Y'){
    $query = "INSERT INTO $table VALUES ('','$name','$email','$url','$country','$comments','$hideemail','$apr','$fave')";
    mysql_query($query);
    } else {
    $query = "INSERT INTO $table VALUES ('','$name','$email','$url','$country','$comments','$hideemail','$apr')";
    mysql_query($query);
    }

    echo "Thank you, $_POST[name]! You will be added to the members list with the next update. :)";

    } else { ?>

    Sorry, but this email address is already listed in the database. This means that you're already listed as a member. If you wish to update your member     information, please use the Update Form. If you want to see your listing as a member, please click here.
    
Delete those lines and replace them with this code:
    if ($emailnotify == 'Y'){

    $msg = "Name:\t$_POST[name]\n";
    $msg .= "E-Mail:\t$_POST[email]\n";
    $msg .= "Hide E-Mail:\t$_POST[hideemail]\n";
    $msg .= "URL:\t$_POST[url]\n";
    $msg .= "Country:\t$_POST[country]\n";
       if ($enablefave == 'Y'){
    $msg .= "Fave:\t$_POST[fave]\n"; }
    $msg .= "Comments:\t$_POST[comments]\n";
    $msg .= "Sender IP:\t$REMOTE_ADDR\n";
    $msg .= "\nLogin to your Admin Panel: $siteurl/admin.php\n";

    $recipient = $adminemail;

    $subject = "Member - $sitename";

    $mailheaders = "From: $_POST[email]\n";
    $mailheaders .= "Reply-To: $_POST[email]\n\n";

    mail($recipient, $subject, $msg, $mailheaders); }

       if ($enablefave == 'Y'){
    $query = "INSERT INTO $table VALUES ('','$name','$email','$url','$country','$comments','$hideemail','$apr','$fave')";
    mysql_query($query);
    } else {
    $query = "INSERT INTO $table VALUES ('','$name','$email','$url','$country','$comments','$hideemail','$apr')";
    mysql_query($query);
    }

    echo "Thank you, $_POST[name]! You will be added to the members list with the next update. :)";
    }
That’s it!  Just save and re-upload the file.  Now members are able to join more than once with the same email, which can come in handy if you are using the script for something other than a fanlisting.

Part 8: Next & previous links

Michelle — Sat, 04 Sep 2004 13:21:39 +0000

In this instalment we will learn how to create next and previous links for easy navigation through our single entry pages. The following code should be placed on your single entry page (probably called journal.php or entry.php), just after your blog entry (and before any commenting functions). In this tutorial, the individual entry page will be referred to as journal.php.

MySQL should already be open on this page. Ensure that you have not closed MySQL previous to this code.

Now, the SQL query to find the id of the entry BEFORE the one you are viewing (ie, the previous id) should look like so:

$sql_prev = "SELECT * FROM php_blog WHERE id < '$id' ORDER BY id DESC LIMIT 1";

Remember that the $id variable comes from your url, and that any time you view journal.php, you should view it as journal.php?id=xx (where xx is an id number). The above code takes your $id variable, and find the first existing smaller id number — the id for the previous entry.

Next we’ll execute that SQL:

$result_prev = mysql_query ($sql_prev) or print ("Can't select previous entry id table php_blog.
" . $sql_prev . "
" . mysql_error());

And while it is true, define $prev as the previous id:

while ($row = mysql_fetch_array($result_prev)) {
    $prev = $row['id'];
}

Now, in order to have a previous link if there is a previous entry, but not have one if no previous entry exists, we will use the following if statement:

if (isset($prev)) {
    // print a previous link
    printf("Previous -- ", $prev);
}
else {
    // just print the word "previous"
    print "Previous -- ";
}

So, the entire code for coming up with a previous link will look something like this:

$sql_prev = "SELECT * FROM php_blog WHERE id < '$id' ORDER BY id DESC LIMIT 1";
$result_prev = mysql_query ($sql_prev) or print ("Can't select previous entry id table php_blog.
" . $sql_prev . "
" . mysql_error());

while ($row = mysql_fetch_array($result_prev)) {
    $prev = $row['id'];
}

if (isset($prev)) {
    // print a previous link
    printf("Previous -- ", $prev);
}
else {
    // just print the word "previous"

    print "Previous -- ";
}

Our next link will be almost identical, except for finding the first existing LARGER id number, ie, the next entry id:

$sql_next = "SELECT * FROM php_blog WHERE id > '$id' ORDER BY id LIMIT 1";
$result_next = mysql_query ($sql_next) or print ("Can't select next entry id table php_blog.
" . $sql_next . "
" . mysql_error());

while ($row = mysql_fetch_array($result_next)) {
    $next = $row['id'];
}

if (isset($next)) {
    // print a next link
    printf("Next", $next);
}
else {
    // just print the word "next"

    print "Next";
}

And that’s all there is to it. If you have any trouble, post your entire journal.php code in the Tutorial Help forum.

Collective: show all

Sasha — Sun, 22 Aug 2004 13:24:07 +0000

Do you want to have a page that shows every fanlist in your collective, rather than having to click on each category? This tutorial will show you how.
Note: This tutorial is for Flinx Collective, not the normal version!

First, open your editor (even something as simple as Notepad would work for this) - save the new file as showall.php.

Paste all of the following code into it:

Below you can view all listings in this Collective.

" alt="">

Title:
Subject:
Opened:

Edit any of the table attributes to your own liking, to fit in with your layout.

Save the file in your collective website (make sure it’s in the same folder as your FlinxCollective config.php!), upload it, and voila! A page that shows every list in your collective, alphabetically.

Reviews section (with MTAmazon)

Sasha — Tue, 17 Aug 2004 13:26:54 +0000

I have been asked loads of times how I created my own Book Reviews section on my personal site, so here’s a tutorial explaining how.

For this tutorial you’ll need Movable Type 2.x. It might work in MT3 as well, but I haven’t tested it so I’m not sure. You’ll also need to have MTAmazon installed and working properly. This tutorial will not tell you how to install MTAmazon, however.

Please note that you can use this tutorial for more than just book reviews. Using Amazon, you could also review CDs, DVDs, games, etc. The categories in this tutorial are used as the Book Categories (Fiction, Non-Fiction, Childrens, etc), but obviously they can be used for other things as well. For example, if you’re reviewing games, you might want to create a category for each game platform (PC, PS2, XBox) that you’re reviewing.
This tutorial is just to give you an idea of how to set something like this up properly.

And as always, this tutorial assumes you’re using PHP headers and footers for your site. If you’re not, just replace the PHP includes with whatever HTML coding you’d like there.

Create a new blog in MT. My Core Setup settings look like this, where "books" is the folder I’ll be putting the reviews in (so replace books with something else if you don’t want it all in a "books" folder):

Weblog Name: Books
Local Site Path: /your/absolute/path/to/books
Site URL: http://domain.com/books/
Local Archive Path: same as Local Site Path

Archive URL: same as Site URL

Under Preferences, make sure that you have selected Individual as Preferred Archive Type, and php as the file extension for archive files.

Under Archiving, make sure you have the boxes ticked next to Individual and Category. Fill in the following under Archive File Template:

Individual:
```
//.php
```
Category:
```
.php
```

Now go into the Templates section. The only templates you’ll really need for this tutorial are Main Index, Category Archive, and Individual Entry Archive, so feel free to delete the rest if you’re not using them.

Click on Main Index, and copy and paste the following coding into it:



Recent Reads



" border="0" class="floatleft" alt="" />

<$MTEntryDate format="%x"$> ::"> <$MTEntryTitle$>



By 

Released 



<$MTEntryExcerpt$>
   [more...]

 


Genres

<$MTCategoryLabel$> [  ]



Older Reads


In  <$MTArchiveTitle$> I read the following book(s):


  -    "><$MTEntryTitle$>     -

Hit save, and go to the Category Template. Copy the following code into the Category template:


Book List

<$MTArchiveCategory$>


 ()

Hit save again, and now go to the Individual Entry Archive. Copy the following code into there:


<$MTEntryDate format="%x"$> - <$MTEntryTitle$>



« <$MTEntryTitle$> |

Main


| <$MTEntryTitle$> »



<$MTEntryTrackbackData$>



" border="0" alt="" />


Title: 
Author:  
Genre:  <$MTCategoryLabel$>

Published By:  
Published On: 
Type: 

Price: 
Avg. Customer Rating:  stars

[ Buy Now ]



<$MTEntryBody convert_breaks="1"$> 

Agree? Disagree? Speak up! (<$MTEntryCommentCount$>)

Obviously, if you’re not reviewing books, you’ll want to edit the fields mentioned above. A CD won’t have an Author, so you’d need to take that out. Here is a list of tags that you can use in MTAmazon.
When you’re done, hit Save again.

Now you’re ready to publish your first review. Click on New Entry in the navigation bar, and put the following into the entry fields:

Entry Title: Book Title

Category: Book’s category
Entry Body: Your review of the book
Extended Entry: The book’s ISBN or ASIN number (look it up on Amazon)

And that’s all. Now when you hit Save Entry (and make sure that Post Status is set to Publish), your first book review will show up!

If you get any errors, keep in mind that they’re usually caused by MTAmazon. Double check that you have the right ASIN number, and that there are no spaces around the number in the Extended Entry field. If you’re reviewing something else than books, make sure that the tags you used in the templates are actually available for whatever it is that you’re reviewing.

And lastly, keep in mind that this is just the way I do it. There are many other ways to achieve a similar result, please don’t feel like you have to copy me exactly. This tutorial is more meant to give you an idea of how to use MT’s versatality than a step-by-step-this-is-the-only-way-to-do-it guide. Have fun with it!

PLEASE NOTE: If you’re getting MTAmazon errors with this tutorial, please take a look at the following forum thread!