sammela.com » article

The OpenCart Controller base class

Sam Mela — Sun, 15 Nov 2009 05:00:30 +0000

All controllers in OpenCart share a common ancestor, the Controller class, located in the DIR_APPLICATION/system/engine/controller.php file. Note that DIR_APPLICATION is the path to your application directory, and is defined in the OpenCart config.php file.

In object oriented terms, the Controller class is called a base class. It contains common methods and data definitions that all its descendant classes will find useful and can use.

Data definitions for the Controller class follow:

$id;	$id is used to identify the controller. Typically it is set by the controller. For example, the ControllerCommonColumnLeft controller sets its $id to “column_left”. Controller id’s are the means by which a parent controller relates child controller output to a template. The name used in the template must match the controller name.
$template	$template is the file that defines the output of the controller. It is basically a PHP/HTML file that is populated with variables from the controller $data array.
$children	$children is an array of the controllers that a top level controller is composed of. It is very important to understand that these are not children in the object oriented inheritance sense of the term. They are just pieces of the top level controller, the way tires and the engine are pieces of a car. For example, ControllerCommonHome contains the following childres: ControllerCommonHeader ControllerCommonFooter ControllerCommonLeft ControllerCommonRight
$data	All information that will be used to populate the $template is stored in the $data array. In the controller fetch method, the PHP extract function is used to create local variables from the $data array and make them available to populate the $template.
$output	The HTML output of the $template is ultimately stored in the $output variable, where it is available to be echoed to the client browser.

In addition to the above class data, the baseController class makes a few methods available.

__get	__get is a magic method that gets a class scope variable from the Registry class. See the online PHP documentation on magic methods for more detail. Also see The Open Cart “load” Class Variable and Magic Methods.
__set	__set is a magic method that puts a class scope variable into the Registry class. See the online PHP documentation on magic methods for more detail. Also see The Open Cart “load” Class Variable and Magic Methods.
forward	The forward method creates a new instance of the Router class.
redirect	The redirect method immediately redirects to a new location.
fetch	See How OpenCart Renders Pages.
render	See How OpenCart Renders Pages.

OpenCart Top Level Controller Architecture

Sam Mela — Sat, 14 Nov 2009 22:54:52 +0000

An OpenCart top level controller is responsible for orchestrating the complete construction of an OpenCart page.

As an example, the ControllerCheckoutCart controller class is responsible for coordinating the model data and the template view necessary to create a checkout cart page for the client.

Another example is the ControllerCommonHome controller class, which is responsible for the main store view that customers see when they first visit.

Common Base Class

All controllers in OpenCart share a common ancestor, the Controller class, located in the DIR_APPLICATION/system/engine/controller.php file. This class is described in The OpenCart Controller Base Class

The Index Method

How OpenCart Renders Pages

Sam Mela — Sat, 14 Nov 2009 06:01:07 +0000

The OpenCart Controller class contains a render method that is used to produce HTML pages output by all OpenCart classes that inherit from Controller class.

Here is how it works.

Each time a page is rendered, it is done with one top level controller. The top level controller may contain zero or more child controllers and it contains a template. Rendering proceed in the following order:

Each child controller is rendered
The top level controller is rendered, based on its own data and the output of the child controllers

That’s it. The rest is details which are described in the remainder of this article.

How the Template is Rendered

As stated previously, the top level controller render method produces output using a template. To accomplish this, it passes the template to the fetch method, which does the actual work.

The fetch Method

As stated previously, the top level controller render method produces output using a template. To accomplish this, it passes the template to the fetch method, which does the actual work.

The fetch method is not very long, but it does some clever things and it takes advantage of some very powerful features of PHP. Here is the operative code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

// Create local variables from the controller data array
extract($this->data);

// Initialize PHP output buffering
ob_start();

// Load the template file, which is automatically
// populated with the local variables created above
require($file);

// Get the output of the template file
// Which has been echoed to the PHP output buffer
$content = ob_get_contents();

// Empty the PHP output buffer
ob_end_clean();

Basically, all information necessary to populate the template must be stored in the controller’s $data array. The native PHP extract function pulls the information out the the $data array and populates the local symbol table with it, so it is available to the template file.

Now here is the trick. The template file echoes its output; but since PHP buffering is turned on, the echoed HTML is not output to the client browser, but rather to the PHP output buffer. The fetch method stores the PHP output buffer contents in the $content variable and then returns it to the calling function. Cool beans.

But there’s more. Not only is this method used for the top level controller, but each of the controllers contained by the top level controller (the children) is evaluated the same way; and the children can contain their own children, theoretically without limit, although in practical terms it is unlikely they will go more than two or three levels deep.

Add Backtrace to the WiPeD WordPress Debugger

Sam Mela — Wed, 07 Oct 2009 01:53:07 +0000

In a previous article (WiPeD: A Useful WordPress Debugger Plugin), I discussed the WiPeD WordPress Debugger, written by Sterling Camden, which you can read more about on the Chiptips Blog.

I’ve been educating myself about the structure of WordPress, and recently I found it useful to add some backtrace capability to WiPeD.

What is Backtrace?

Backtrace is the PHP capability to create an array containing a list of the hierarchical function calls that led to a particular point of execution.

Actually the PHP debug_backtrace function produces an array of arrays. For each function in the call hierarchy, it makes available the line number, file name, and function name. But the format isn’t very use friendly for this application, so the bulk of my backtrace addition is devoted to producing a nice format that fits into the output scheme of the WiPeD debugger.

How Backtrace Affects WiPeD

Logging — the WPD_backtrace is used to perform a backtrace at any point in your code. Just add a WPD_backtrace(); function call where you want the backtrace data logged. As a coder/debugger, this is the only modification to your code you will need to make, in order to use this feature.
Output — the WiPeD output now includes the results of the logged backtrace calls.

Example of Use

Here’s an example of the WPD_backtrace() function used in the main method of the WP object in the classes.php file of WordPress.

1
2
3
4
5
6
7
8
9
10

function main($query_args = '') {
WPD_backtrace(); //ssmela
$this->init();
$this->parse_request($query_args);
$this->send_headers();
$this->query_posts();
$this->handle_404();
$this->register_globals();
do_action_ref_array('wp', array(&$this));
}

File and Code Modifications

CSS

I added a css style file — wiped.css. You can change the css in this file to control how the backtrace output looks.

The WPD_backtrace class defines the style of the backtrace output data.

The WPD_tracepoint class is a specialized class to define the style of the output data at the tracepoint.

You can also modify css tags used by the original author (WPD_output, WPD_message, WPD_text, WPD_element, and WPD_array).

Additions to WiPeD.php

Additions to WiPeD.php are marked as “ssmela addition 1″, “ssmela addition 2″, and “ssmela addition 3″; and they are listed below, along with brief explanations. Basically, my additions build on the existing general WiPeD logging and display capability, but they add a more specialized backtrace display capability.

ssmela addition 1 – Sets up to include the wiped.css file

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

// Start ssmela addition 1
// Set up to include the wiped.css file
if (!defined("WP_CONTENT_URL")) define("WP_CONTENT_URL", get_option("siteurl") . "/wp-content");
if (!defined("WP_PLUGIN_URL")) define("WP_PLUGIN_URL", WP_CONTENT_URL . "/plugins");

function wiped_head()
{
$css_url = WP_PLUGIN_URL . "/wiped/wiped.css";
if (file_exists(TEMPLATEPATH . "/wiped.css"))
{
$css_url = get_bloginfo("template_url") . "/wiped.css";
}
echo "\n".'. $css_url . '" type="text/css" media="screen" />'."\n";
}
// End ssmela Addition 1

ssmela addition 2 – Call the function that includes additional css file, wiped.css

1
2
3
4

// Start ssmela addition 2
// Call the function that includes wiped.css
add_action('wp_head', 'wiped_head');
// End ssmela addition 2

ssmela addition 3 – Function to add trace data to the WiPeD log

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

// Start ssmela addition 3
// Function to add trace data to the WiPeD log
function WPD_backtrace()
{
$trace_array    = debug_backtrace(true);
$trace_array_count = count($trace_array);

$callee_line    = "";
$callee_file    = "";
$callee_function = "";
$caller_line    = "";
$caller_file    = "";

for($i=0; $i<$trace_array_count; $i++)
{
$trace_element = $trace_array[$i];

$callee_line    = $caller_line;
$callee_file    = $caller_file;
$callee_function = $trace_element["function"];
$caller_line    = $trace_element["line"];
$caller_file    = $trace_element["file"];

$call_list[] = array(
" ",
"Caller file: $caller_file",
"Caller line: $caller_line",
"Callee file: $callee_file",
"Callee line: $callee_line",
"Callee function: $callee_function",
" "
);
}

$call_list = array_reverse($call_list);
$call_list_count = count($call_list);

WPD_print("

\"WPD_backtrace\">+++++++++++++++++++++++++++

\n");
WPD_print("

\"WPD_backtrace\">|||||||||||||||||||||||||||

\n");

for($i=0; $i<$call_list_count; $i++)
{
$call_list_element = $call_list[$i];

foreach($call_list_element as $call_list_element_string)
{
if ($i!=($call_list_count-2))
{
WPD_print("

\"WPD_backtrace\">".$call_list_element_string."

\n");
}
else
{
WPD_print("

\"WPD_tracepoint\">".$call_list_element_string."

\n");
}
}
}

WPD_print("

\"WPD_backtrace\">|||||||||||||||||||||||||||

\n");
WPD_print("

\"WPD_backtrace\">+++++++++++++++++++++++++++

\n");
}
// End ssmela addition 3

Output

The output looks like the following. Towards the bottom of the output listing, note the red text color, which denotes the point in the code where the trace is actually called. The entries above the red are preceding code points in the call tree. The entries below the red is the actual trace code function, and could be removed in the future.

+++++++++++++++++++++++++++

|||||||||||||||||||||||||||

Caller file: /home/sammela/public_html/index.php

Caller line: 17

Callee file: /home/sammela/public_html/wp-blog-header.php

Callee line: 16

Callee function: require

Caller file: /home/sammela/public_html/wp-blog-header.php

Caller line: 16

Callee file: /home/sammela/public_html/wp-includes/template-loader.php

Callee line: 37

Callee function: require_once

Caller file: /home/sammela/public_html/wp-includes/template-loader.php

Caller line: 37

Callee file: /home/sammela/public_html/wp-content/themes/Sam-Cutline-1-1.4-2ColumnRight/sandbox.php

Callee line: 23

Callee function: include

Caller file: /home/sammela/public_html/wp-content/themes/Sam-Cutline-1-1.4-2ColumnRight/sandbox.php

Caller line: 23

Callee file:

Callee line:

Callee function: ssm_show_trace

|||||||||||||||||||||||||||

+++++++++++++++++++++++++++

Download WiPeD with BackTrace

Download a copy of WiPeD with BackTrace here.

As stated previously, the original author of this excellent plugin is Sterling Camden. His company is Camden Software Consulting.

WiPeD: A Useful WordPress Debugger Plugin

Sam Mela — Tue, 06 Oct 2009 22:37:50 +0000

I like the WiPeD (WordPress Printf Debugging) Plugin for four reasons:

It does what I want
It is easy to install
It is easy to use
It is easy to customize

As a bonus, I should say, I talked to the author (Sterling “Chip” Camden) on the phone today, and he’s very helpful.

Problems with echo

PHP programmers typically use the echo keyword to output debugging information.

But there are some annoyances with this approach.

Echo output that precedes headers can cause PHP errors.
Echo statements are difficult to turn on and off.
It can be difficult to locate diagnostic echo statements when they are sprinkled throughout code.

WiPeD to the Rescue

WiPeD solves the problems listed above by queing diagnostic outputs. The diagnostic data is then dumped all at one, at a location chosen by the programmer.

Once the plugin is installed, it is a simple matter to write debug information to the queue. Here’s an example:

1 2	// Queue a message WPD_print("This is a test of the WiPeD WPD_print function");

Output

Typically you don’t have to worry about output. In the default install configuration, WiPeD outputs the queued diagnostic data on the get_footer and admin_footer actions, which means it winds up at the bottom of your page. Note, however, you can set it to display on any actions you want (see “Options” below).

Options

When WiPeD is installed, it adds a “WiPeD” options menu item to the bottom of the Admin “Settings” menu. In the otpions menu you can set the following:

User capability level required to record debug info
User capability level required to display debug info
Actions that trigger display of debug info
Clear debug log when displayed (check yes/no)
Clear debug log now (check yes/no)

Summary

WiPeD is a handy expanable debug support Plugin that does just what it should.

Want it? Visit the WiPeD links below:

	Author:	Sterling “Chip” Camden
	Visit:	plugin site

Add backtrace to the WiPeD Debugger.

Make a WordPress Template Sandbox

Sam Mela — Wed, 30 Sep 2009 04:31:52 +0000

Are you learning how do make code modifications in WordPress?

Sometimes you just want to experiment.

But it is messy and risky to make changes in the standard template pages such as index.php, page.php, archive.php, etc. So the best thing to do is make yourself a code sandbox.

A sandbox template should pull in all the infrastructure you need but allow you to write custom code and try things out. In WordPress, a custom template fulfills these requirements. This article tells you how to build one.

First, if you are not familiar with the directory structure of themes in WordPress, read my article titled The Theme Directory Structure.

Build Your Sandbox

Armed with knowledge from my Theme directory structure article, go to the directory of your favorite theme and copy the index.php file to a file called sandbox.php.

Add the following line to the top of the sandbox.php file.

1
2
3
4
5

/*
Template Name: SandBox
*/
?>

That’s it. You have created the basic sandbox.

If you are working locally on a PC or MAC, upload sandbox.php to your site.

Using Your Sandbox Template

To use your sandbox template, you can either create a new WordPress page or modify and old one. I suggest creating a new one for starters. Let’s make a page called “sb”.

Now, if you want to view the results of your experimental changes to sandbox.php, you can just view your new page.

Now you can start making changes in your sandbox.php page.

At the bottom of my sandbox.php page is the code that displays the sidebar, shown below:

1	get_sidebar(); ?>

What happens if you add a put some html code just above the get_sidebar function?

Now our code looks like the following?

1
2
3
4
5
6
7
8
9
10
11

This is a table	above the right sidebar
This is row 2	of the table

get_sidebar(); ?>

When you view the “sb” page, you should see a little table up above the sidebar. Basically, you can try out any idea you want on the sandbox page and it won’t affect your main blog pages.

TIP:

When you create a test page based on the sandbox template, make it “private”, so visitors to your blog won’t see it in the menu.

The Wordpress Theme Directory Structure

Sam Mela — Tue, 29 Sep 2009 22:25:09 +0000

Wordpress uses a standard directory structure for storing themes.

Starting from your wordpress installation home directtor, all themes are stored in /wp-content/themes.

Each theme is stored in it’s own directory. The two themes that come with a standard WordPress installation are “WordPress Classic” and “WordPress Default”. Their folders are located relative to the WordPress home directory as follows:

Theme	Location
WordPress Default	wp-content/themes/default
WordPress Classic	wp-content/themes/classic

Contents of the Theme Directory

Within the Theme directory, minimally there will be the following files:

index.php
header.php
sidebar.php
footer.php
functions.php
style.css

Typically, there will be more. Often there is an images sub-directory.

How to Find Your Theme Directory

In the Site Admin Console, click on “Appearance” then “Themes”.
The “Current Theme” will be shown in the top right hand side of the screen.
The relative directory address will be listed below the Theme name.

Keep Your Meta Tags Portable

Sam Mela — Mon, 28 Sep 2009 05:22:45 +0000

It was difficult to think of an interesting title for this article. Maybe I should have called it “Save Time and Money — Keep Your Meta Tags Portable”, because eventually, if your Meta Tags are not portable, you’re going to invest time/money moving them.

Problem

The latest WordPress documentation says:

To add meta tags to your site, simply add them to the header.php template file in your WordPress Theme, specifically in the head section near the link for the style sheet.

That works fine until you switch themes. The meta tags don’t follow you to the next theme. This may not be obvious at first. Your search engine rankings may go down if the Google, Yahoo, or Bing search engines cannot verify your site — an activity they do from time to time. But it could take a long time to trace this back to the missing meta tags, and meanwhile your site is losing $traffic.

Not good.

Solution

Use a Wordpress Meta Tag Plugin.

I’m agnostic about which Meta Tag Plugin to use, but I will tell you that I am using Meta Tag Manager Wordpress Plugin from netweblogic. Just download it, install it, and activate it according to the instructions. It shows up as a menu item under “Settings” in your Admin Dashboard. Click on it and you should see something like the screen below. Just add new tags and save the changes.

Meta Tag Manager

You’re done.

Double Check Your Work

Finally, make sure your tags are really showing up. Navigate to your blog use your browser “view page source” capability to view the source of the page. Make sure your meta tags are included.

Sitemaps and Google Webmaster — Like Milk and Cookies

Sam Mela — Sun, 27 Sep 2009 18:54:46 +0000

This is an article about Sitemaps and Google Webmaster Tools.

This article won’t tell you how to make a Sitemap or how to use Google Webmaster Tools. There are plenty of good articles that explain the mechanics of Sitemaps and Webmaster Tools (see Add a Sitemap to Your Wordpress Site). But sometimes it’s good to get up above the trees and see the big picture.

In a Nutshell

When people search the web using Google, you want them to find your Site.

But if Google doesn’t have the right information, it won’t return links to your Site.

Yes, Google needs information about your Site. Why is this?

Well, let’s look at an example.

Suppose someone is a dog lover. This person wants Google to find links to pages with dogs. More specifically, suppose this person types “Boston Terrier” into the Google search box, and hits return.

So now the Google search engine has two problems to solve. First, it wants to find site with the “Boston Terrier” content. Second, it doesn’t want to return unpopular sites. It wants to return a site people are interested in, otherwise people will stop using Google and start using another search engine.

So the Google search engine really as two problems to solve — content and popularity.

How Google Keeps Track of Content

We’ll discuss popularity (called “ranking”) later in this article, but for now the topic is content.

How does the Google search engine keep track of everything on the Web?

Well, the truth is, the Google search engine doesn’t keep track of EVERYTHING on the Web; but it tries to.

Someplace (probably more than one place) Google corporation has an enormous number of big Server machines with lots of hard drives and backup media, just for keeping lists of what is on the World Wide Web.

But the problem (actually opportunity) for Google is that web content keeps changing. Each day trillions pieces of new information are added to the Web.

So the Google search engine is constantly combing through the web in a process called “crawling”.

Here is the definition of “crawling”, according to a Google Webmaster help page,:

“Crawling is the process by which Googlebot discovers new and updated pages to be added to the Google index.”

Google goes on to say the following:

We use a huge set of computers to fetch (or “crawl”) billions of pages on the web. The program that does the fetching is called Googlebot (also known as a robot, bot, or spider). Googlebot uses an algorithmic process: computer programs determine which sites to crawl, how often, and how many pages to fetch from each site.

Another Way Google Tracks Content

As described in the previous section, the Google search engine is constantly looking at sites on the Web to build indices of Web content. But there is still a lot of content that the Google search engine cannot process.

For instance, if you submit a video to YouTube, the Google search engine can’t (yet!) watch the video and create index data based on the content of the Video.

Also, more sophisticated Web sites build their pages dynamically, meaning that pages and content of pages change, depending upon user input. It is difficult or impossible for the search engine to build an index of such a site.

So there is some content that the Google search engine cannot find or index by crawling. Still, the authors of such sites want people to be able to find their content and the operators of the search engines want to be able to find the content. Therefore, Sitemaps were invented.

A Sitemap is a protocol webmasters use to tell search engines about Web pages that are available for crawling. Below is a very simple example of a Sitemap. Again, we leave it to other documents and articles to give detailed technical descriptions. Suffice it to say, the information in the Sitemap helps the Google search engine to find pages on your site. http://www.sitemaps.org has official specifications and other useful information.

1
2
3
4
5
6
7
8
9
10
11
12

version="1.0" encoding="UTF-8"?>
">
>
>http://ssmela.googlepages.com/>
>
>
>http://ssmela.googlepages.com/AnonymousClassesinJava.pdf>
>
>
>http://ssmela.googlepages.com/NetbeansMacrodef.pdf>
>
>

Submitting the Sitemap

At the beginning of this article, I implied that Sitemaps and Google Webmaster Tools go together like milk and cookies. Here’s why — once your Sitemap is ready, you register your Site with Google Webmaster Tools and then submit your Sitemap.

You join Google Webmaster Tools pretty much the same way you join any other Google Application Service. Just go to the Google Webmaster Tools Site and sign in with an existing Google Account Name/Password or create a new one. Then follow the instructions for registering your Site and submitting your Sitemap.

If you have followed reasonable rules of SEO (Search Engine Optimization) in creating your site and your site has good quality content then you are off and running. Of course, Google makes different types of reports available. Demystifying Google Webmaster Tools Reports is a nice place to start reading about them.

Other Search Engines

As you know, Google isn’t the only search engine. Both Microsoft Bing and Yahoo Search have tools for registering your Site and submitting Sitemaps. Check them out too.

Ranking (popularity)

As promised earlier, we include here a brief section on the topic of ranking. It’s just the way it sounds. The Google search engine ranks pages. Google’s method is not disclosed but it is generally understood to be based on popularity. This includes factors like how many times people search for your site, how many other sites link to your site, and the ranking of the sites that have links to your site, and possibly how long your site has been around.

There is a marketing specialty called Search Engine Optimization (SEO) that deals with optimizing your site to improve its search engine rankings. See the Wikipedia Article on Search Engine Optimization.

Add a Sitemap to Your WordPress Site

Sam Mela — Sat, 26 Sep 2009 02:04:07 +0000

In a previous article (Sitemaps and Google Webmaster — Like Milk and Cookies) I explained why it is important to register your Sitemap with Google. This article tells you how to create a Sitemap for your Wordpress site and register it with Google.

Sitemap Plugin Eases the Job

Google accepts Sitemaps in several formats, but it’s time consuming to create WordPress site by hand. Furthermore, you will neeed to update the map every time you add or delete an article. Here’s the good news — there are a number of excellent WordPress Plugins that do the job of creating Sitemaps for you.

I use a Plugin called “Sitemap Index” Version 1.2.2, by Twardes (http://torrentlist.pl/sitemap-index-plugin). This Plugin generates sitemaps dynamically, meaning that the sitemap is regenerated every time the Sitemap file is accessed.

It couldn’t be easier to install and use. In the Plugins section of the WordPress Admin console, click on “Add New”. Search on “sitemap index” (quotes included), and the “Sitemap Index” should be included in the result list.

Under “actions” on the right side of the screen, click “install”. It’s that easy.

Get the URL of the Sitemap

Click on Plugins on the left side of the WordPress Admin screen, then click on Sitemap Index “settings” on the right side of the screen.

You should see something like the following screen shot. Copy the Sitemap address so you can paste it into Google Webmaster Tools.

Add the Site and Sitemap to Google Webmaster Tools

If you don’t already have a Google Webmaster Account, go to http://www.google.com/webmasters and create one.

It is very important to register your site with Google, because Google is the most popular search engine.

Log into Webmaster Tools, and on the right-hand side of the screen click the “Add a Site” button.
Enter the name of your site and hit “enter”.
Now you should be in the Verification screen, which looks like the screenshot below. You’ll need to copy the verification “meta” tag from the Webmaster tool back to the header.php file on your site.

The header.php file is located in the same folder as your theme.
Using your favorite code editor, open header.php and look for a reasonable place to put the meta tag.

sammela.com » article

The OpenCart Controller base class

OpenCart Top Level Controller Architecture

Common Base Class

The Index Method

How OpenCart Renders Pages

How the Template is Rendered

The fetch Method

Add Backtrace to the WiPeD WordPress Debugger

What is Backtrace?

How Backtrace Affects WiPeD

Example of Use

File and Code Modifications

CSS

Additions to WiPeD.php

Output

Download WiPeD with BackTrace

WiPeD: A Useful WordPress Debugger Plugin

Problems with echo

WiPeD to the Rescue

Output

Options

Summary

Related Article

Make a WordPress Template Sandbox

Build Your Sandbox

Using Your Sandbox Template

The Wordpress Theme Directory Structure

Contents of the Theme Directory

How to Find Your Theme Directory

Keep Your Meta Tags Portable

Problem

Solution

Double Check Your Work

Sitemaps and Google Webmaster — Like Milk and Cookies

In a Nutshell

How Google Keeps Track of Content

Another Way Google Tracks Content

Submitting the Sitemap

Other Search Engines

Ranking (popularity)

Add a Sitemap to Your WordPress Site

Sitemap Plugin Eases the Job

Get the URL of the Sitemap

Add the Site and Sitemap to Google Webmaster Tools