Some of the more recent articles I have written have already touched on some of the things I have been adding to the site; see the post on pagination, the post on a plugin to populate the registry and the post on automatically generating a sitemap. I intend to do some further posts on the new parts of the site implementation that are of wider interest.

First, we need to create the controller class used to field the request for the sitemap. This is called SitemapController and is located in controllers/SitemapController.php. The class has the following skeleton:

class SitemapController extends Zend_Controller_Action
{
  // TODO: Implement the class action handlers here
}

The first action is the index action, which is handled by the follow method of the class:

public function indexAction()
{
  $this->_helper->layout->disableLayout();
}

This disable the standard layout, so that only the XML of the sitemap is rendered.

The accompanying view script file is application/views/scripts/sitemap/index.phtml and contains the following code:

<?php
$this->navigation()->sitemap()->setFormatOutput(true); 
echo $this->navigation()->sitemap();

This takes the pages in the navigator and uses them to generate a sitemap.

Now, if you navigate to http://[your-domain]/sitemap, the sitemap will be rendered in the browser.

Now we need to set up the router, so that a request for http://[your-domain]/sitemap.xml also brings up the sitemap.

To do this, we should add the route to the application configuration file:

resources.router.routes.sitemap.type = "Zend_Controller_Router_Route_Static"
resources.router.routes.sitemap.route = "sitemap.xml"
resources.router.routes.sitemap.defaults.controller = "sitemap"
resources.router.routes.sitemap.defaults.action = "redirect"

We now need to add another action handler to the SitemapController class:

public function redirectAction()
{
  $this->_redirect('/sitemap');
}

The reason for doing this indirect redirection is that if we route directly to sitemap/index, the navigator becomes confused and renders all the URLs in the sitemap incorrectly. You can confirm this by changing the ini file setting above from “redirect” to “index”.

The Zend_Navigation module allows us to build up a collection of objects that represent the pages on the site. These pages can then be rendered in different ways, such as a menu or a sitemap.

The helper covered in this post makes use of the Zend_Navigation object that was initialised in the bootstrapping process, as described in the post Bootstrapping the Application: the Standard Navigation Resource Plugin. Each page added to the navigation was given a unique ID. The helper takes this unique ID, along with some text for the link, and it uses the ID to retrieve the URL of the page from the navigation container object. This allows the exact URL of a page to be stored in just one place, so that it can be changed easily if necessary.

The helper is called Default_View_Helper_NavLink; the prefix Default_View_Helper was specified in the bootstrapping process, as described in the post Bootstrapping the Application: a Custom View Resource Plugin.

The helper class is stored in a file called NavLink.php, which is in the views/helpers directory.

Here is the code used to implement the class:

<?php
class Default_View_Helper_NavLink extends Zend_View_Helper_Abstract
{
  public function navLink($pageId, $label)
  {
    // Get navigation container
    $container = $this->view->navigation()->getContainer();
 
    // Get the page
    $page = $container->findOneBy('id', $pageId);
 
    // If the page is found, generate a link 
    // with the specified label text
    if (isset($page))
    {
      $html = sprintf('<a href="%s">%s</a>', $page->getHref(), $label);
    }
    // Otherwise just return the label text 
    else
    {
      $html = $label;
    }
 
    return $html;
  }
}

The class contains a method with a name corresponding to the basic helper name, which is essentially the class name but without the prefix. This corresponds to the name of the method used to invoke the helper from the view script.

Note that when a Zend_Navigation object has been set up via a resource plugin, it is automatically available from the view object via the call:

$this->view->navigation()

This object reference is used to retrieve the page container, which can then be searched for the relevant page. This is then used to generate the link.

The script begins by rendering the DOCTYPE at the head of the page:

<?php echo $this->doctype() . PHP_EOL; ?>

This has previously been set by the custom view resource plugin, as described in the previous post Bootstrapping the Application: a Custom View Resource Plugin.

The rest of the page is enclosed inside an html block:

<html xmlns="http://www.w3.org/1999/xhtml" 
  dir="ltr" lang="en" xml:lang="en">
  <!-- Page content is rendered here -->
</html>

The html tag has the following attributes set:

• xmlns: This specifies the namespace to use; it is required, as the DOCTYPE is set to XHTML, and it is set to the standard value http://www.w3.org/1999/xhtml.
• dir: This specifies the text direction for the content. It is set to ltr (left to right), which is the correct value for English.
• lang: This specifies a language code for the content. It is set to en (English).
• xml:lang: This specifies a language code for the content in XHTML documents. It is set to en (English).

Inside the html block are the head and body blocks:

<head>
  <!-- Head content is rendered here -->
</head>
<body>
  <!-- Body content is rendered here -->
</body>

The head block is generated programmatically using Zend Framework view helpers:

<?php
// Title
echo $this->headTitle('GM-RAM Limited') . PHP_EOL;
 
// Metadata
$this->headMeta()->appendHttpEquiv
  ('Content-Type', 'text/html; charset=UTF-8');
$this->headMeta()->appendHttpEquiv('Content-Language', 'en-GB');
$this->headMeta()->appendName('copyright', 'Copyright ' . 
  $this->placeholder('copyrightDate') . ' GM-RAM Limited');
$this->headMeta()->appendName('verify-v1', '...'); 
  // Google verification code
echo $this->headMeta() . PHP_EOL;
 
// jQuery
$this->jQuery()->setLocalPath('/js/jquery-1.3.2.min.js');
$this->jQuery()->setUiLocalPath('/js/jquery-ui-1.7.2.custom.min.js');
$this->jQuery()->addStylesheet
  ('/css/smoothness/jquery-ui-1.7.2.custom.css');
echo $this->jQuery() . PHP_EOL;
 
// Links
$this->headLink()->appendStylesheet('/css/default.css');
$this->headLink(array('rel' => 'shortcut icon', 
  'href' => '/img/favicon.ico', 'type' => 'image/x-icon'));
echo $this->headLink() . PHP_EOL;
?>

The view helpers used are:

• Zend_View_Helper_HeadTitle (headTitle)
• Zend_View_Helper_HeadMeta (headMeta)
• Zend_View_Helper_HeadLink (headLink)
• ZendX_JQuery_View_Helper_JQuery (jQuery)

These all employ the same pattern of usage: one or more calls are made to the relevant function, which aggregates the content to be rendered; each call returns the content so far, but only the last call is actually echoed to the page.

The above code should be fairly self-explanatory in terms of what is being rendered. The call to headTitle is used to generate the title element; the calls to headMeta are used to generate the various metadata elements; the calls to headLink are used to add the links to the stylesheet and shortcut icon. As the site makes use of the jQuery JavaScript library, there are calls to the jQuery view helper to generate the appropriate elements for including the necessary JavaScript files and also generating the code which sets jQuery to perform certain actions on start up; the latter will be covered in more detail in later posts.

The skeleton structure of the body section is:

<div id="wrapper">
  <div id="header">
    <!-- Header content is rendered here -->
  </div>
  <div id="content">
    <!-- Main page content is rendered here -->
  </div>
  <div id="footer">
    <!-- Footer content is rendered here -->
  </div>
</div>

The header breaks down into:

• The navigation menu at the top
• The company’s logo
• The description of the company’s area of business
• The company’s phone number

The navigation menu is rendered like this:

  <div id="nav">
    <?php echo $this->navigation()->menu()->render() . PHP_EOL; ?>
  </div>

This uses the Zend_Navigation object, which is initialised using the configuration file as described in the post Bootstrapping the Application: the Standard Navigation Resource Plugin. Here, the pages in the navigation are rendered as a menu, which generates an unordered list of links.

The other three elements are rendered as follows:

  <img src="/img/logo.gif" alt="GM-RAM Limited" title="GM-RAM Limited" />
  <div>Software Development and Consultancy</div>
  <div>
    <strong>Phone:</strong> 
    <?php echo $this->placeholder('phoneNumber'); ?>
  </div>

Note the use of the placeholder view helper. This makes use of the placeholders set up using a custom resource plugin, as described in the post Bootstrapping the Application: a Custom View Resource Plugin.

The main page content simply consists of a call to fetch the layout object, so that its content member variable can be rendered:

<?php echo $this->layout()->content . PHP_EOL; ?>

This results in the output generated by the view script for the specific page being injected into the content div.

The footer consists of the following markup:

<div>
  <a href="http://framework.zend.com/">
    <img src="/img/PoweredBy_ZF_4LightBG.png" alt="Zend Framework" />
  </a>
</div>
<div>
  Copyright &copy; <?php echo $this->placeholder('copyrightDate'); ?> 
  GM-RAM Limited
</div>

Note again the use of the placeholder view helper.

In the next post, I shall look at the stylesheet for the website, in particular how it applies to the layout script.

In the sample application, each of the site pages is added via a block of settings in the configuration file, which take the following form:

resources.navigation.pages.home.type = "Zend_Navigation_Page_Mvc"
resources.navigation.pages.home.label = "Home"
resources.navigation.pages.home.id = "home_page"
resources.navigation.pages.home.controller = "index"
resources.navigation.pages.home.action = "index"

The sub-element after pages (here home) is set to a unique name for the page. The purpose of all the settings for this element are as follows:

• type: This inidicates how the page location is represented. It is either Zend_Navigation_Page_Mvc, when the module/controller/action associated with the page is specified, or Zend_Navigation_Page_Uri, when a straightforward URI for the page is given.
• label: This is the string used when rendering the page name.
• id: This is the unique ID used to identify the page.
• controller: This is the controller associated with the page (see type above).
• action: This is the action associated with the page (see type above).

All the pages are of the type Zend_Navigation_Page_Mvc; the other settings are as follows:

• home: Home, home_page, index, index
• about: About Us, about_page, index, about
• contact: Contact Us, contact_page, index, contact
• blogs: Our Blogs, blogs_page, index, blogs

Zend_Application_Resource_Navigation will create a container object. It will then populate it with page objects based on the settings in the configuration file.

We will look at how the Zend_Navigation object is used in rendering the page navigation and sitemap in later posts.