Joomla! Documentation - User contributions [en]

J2.5:File Structure and Naming Conventions

2014-05-15T05:40:47Z

Samwilsonau: /* The /site folder */ Update view and model parent class names.

{{version/tutor|2.5,3.1}}
{{page|needs version review}}
{{RightTOC}}
Components in Jooomla! 2.5+ can now benefit from the flexibility and power of using Object Oriented Programming (OOP) practices.
Components will follow the Model-View-Controller (MVC) design pattern. This pattern separates the data gathering (Model), presentation (View) and user interaction (Controller) activities of a component. Such separation allows for expanding or revising properties and methods of one section without requiring additional changes to the other sections. Please see [[Developing_a_Model-View-Controller_Component|the MVC tutorial]], then select a Joomla! version for an explanations of the MVC structure.

Joomla!'s file loading system enables developers to work with separate files for controllers, views and models without worrying about importing the right file in the right place. However, for this to work, certain naming conventions need to be observed.

The Joomla! framework is extremely flexible, and it is possible to diverge from these conventions in many ways. It is nonetheless recommended to apply standard naming wherever possible to increase readability and maintainability. Additionally, the framework will take care of the many tedious class management tasks when the files and classes of a component are named correctly.

Throughout this article, {ComponentName} is used to represent the name of the component (for example, Content). Notice also that case is important. {componentname} will refer to the lowercase version of {ComponentName}, eg. <code>CamelCasedController</code> -> <code>camelcasedcontroller</code>.
Similarly, {ViewName} and {viewname}, {ModelName} and {modelname}, {ControllerName} and {controllername}.

== Reserved words ==

There are reserved words which can't be used in names of classes and components.

An example is the word "view" (in any case) for view classes (except "view" that must be second part of that class name)<ref>Reason is in line 420 of file libraries/joomla/application/component/view.php:
<source lang="php">if (!preg_match('/View((view)*(.*(view)?.*))$/i', get_class($this), $r)) {</source></ref>.
Because the first part of the name of view classes is the same as the controller class name, controller class names can't contain the word "view" either. And because of the conventions (although violating of it won't produce an error), controller class names must contain the component name, so component names can't contain the word "view" either. So components can't be named "com_reviews", or if they are, they must violate the naming conventions and have a different base controller class name (or have some other hacks).

== Installation package vs. actual file placement ==

All Joomla! extensions must be packaged as a .zip installation file. According to the most common file arrangement, the package should contain at least the following two folders as a basic structure:
* <code>site</code>
* <code>admin</code>
If you set up your XML manifest file according to standard practice, the contents of <code>site</code> will be installed to <code>/components/com_{componentname}</code>, whereas the contents of <code>admin</code> will be installed to <code>/administrator/components/com_{componentname}</code>.

== The /site folder==
This folder keeps the files for the frontend part of the component.

:'''<code>/site/{componentname}.php</code>'''
:This is the component's main file and entry point ''for the frontend part''.

:'''<code>/site/controller.php</code>'''
:This file holds the default frontend controller, which is a class called <code>{ComponentName}Controller</code>. This class must extend the base class <code>JController</code>.

:'''<code>/site/views</code>'''
:This folder holds the different views for the component.

::'''<code>/site/views/{viewname}</code>'''
::This folder holds the files for the view {ViewName}.

:::'''<code>/site/views/{viewname}/view.html.php</code>'''
:::This file is the entry point for the view {ViewName}. It should declare the class <code>{ComponentName}View{ViewName}</code>. This class must extend the base class <code>JViewLegacy</code>. The <code>.html</code> section of the filename is related to the format the view will be loaded in. For example, if the <code>format</code> URL parameter is set to <code>format=feed</code>, the file <code>view.feed.php</code> will be loaded.

:::'''<code>/site/views/{viewname}/tmpl</code>'''
:::This folder holds the template files for the view {ViewName}.

::::'''<code>/site/views/{viewname}/tmpl/default.php</code>'''
::::This is the default template for the view {ViewName}. In this PHP file, the <code>$this</code> keyword refers to the view class that the template belongs to.

:'''<code>/site/models</code>'''
:This folder holds additional models, if needed by the application.

::'''<code>/site/models/{modelname}.php</code>'''
::This file holds the model class <code>{ComponentName}Model{ModelName}</code>. This class must extend the base class <code>JModelLegacy</code>. Note that the view named {ViewName} will by default load a model called {ViewName} if it exists. Most models are named after the view they are intended to be used with, but this is '''not''' a requirement. See [[Using multiple models in an MVC component]] for more information.

:'''<code>/site/controllers</code>'''
:This folder holds additional controllers, if needed by the application.

::'''<code>/site/controllers/{controllername}.php</code>'''
::This file holds the controller class <code>{ComponentName}Controller{ControllerName}</code>. This class must extend the base class <code>JController</code>.

== The /admin folder ==
The file structure is exactly the same as in the /site folder. Note that the view, models, controllers etc. of the site and admin parts are by default completely separated, and have nothing to do with each other - the site part and the admin part can be thought of as two different components! A view in the /admin folder may have a counterpart with the same name in the /site folder, yet the two views have nothing in common but their name.

However, it might sometimes make sense to share classes between the site and admin parts of the component. Especially models can be shared to avoid duplicating model code. The Joomla! framework supports this strategy. When sharing any code between site and admin applications, the classes should be designed with great care to avoid the possibility of a site user executing admin actions.
<noinclude>
----
<references/>
[[Category:References]][[Category:Component Development]]</noinclude>

J3.x:Developing an MVC Component/Using the database

2014-05-15T04:48:53Z

Samwilsonau: /* Adding a new field type */ Updated link to point to 3.3 tutorial rather than 2.5.

{{:J3.3:Developing a MVC Component}}

== Introduction ==
This tutorial is part of the [[J3.3:Developing a MVC Component | Developing a MVC Component for Joomla! 3.3]] tutorial. You are encouraged to read the previous parts of the tutorial before reading this.

== Using the database ==
Components usually manage their contents using the database. During the install/uninstall/update phase of a component, you can execute SQL queries through the use of SQL text files.

With your favorite file manager and editor create two files called ''admin/sql/install.mysql.utf8.sql'' and ''admin/sql/updates/mysql/0.0.6.sql''. They should both have the same content, as follows:

<span id="admin/sql/install.mysql.utf8.sql">
''admin/sql/install.mysql.utf8.sql'' and ''admin/sql/updates/mysql/0.0.6.sql''
<source lang="sql">
DROP TABLE IF EXISTS `#__helloworld`;

CREATE TABLE `#__helloworld` (
`id` int(11) NOT NULL auto_increment,
`greeting` varchar(25) NOT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=0 DEFAULT CHARSET=utf8;

INSERT INTO `#__helloworld` (`greeting`) VALUES
('Hello World!'),
('Good bye World!');
</source>
</span>

The file ''install.mysql.utf8.sql'' will be executed when you install this component. The file ''0.0.6.sql'' is executed when you do an update.

'''Important Note:''' When the component is installed, the files in the SQL updates folder (for example, ''admin/sql/updates/mysql'') are read and the name of the last file alphabetically is used to populate the component's version number in the <code>#__schemas</code> table. This value must be in this table in order for the automatic update to execute the update SQL files for future versions. For this reason, it is good practice to create a SQL update file for each version (even if it is empty or just has a comment). This way the <code>#__schemas</code> version will always match the component version.

'''Important Note:''' When saving the SQL files in utf8, be sure to save them as utf8 NO BOM or the query will fail with MySQL error #1064.

This is the install file. It will be executed if you put an appropriate order in the ''helloworld.xml'' file

<span id="helloworld.xml">
''helloworld.xml''
<source lang="xml">
<?xml version="1.0" encoding="utf-8"?>
<extension type="component" version="3.2.0" method="upgrade">

<name>Hello World!</name>

<creationDate>January 2014</creationDate>
<author>John Doe</author>
<authorEmail>john.doe@example.org</authorEmail>
<authorUrl>http://www.example.org</authorUrl>
<copyright>Copyright Info</copyright>
<license>License Info</license>

<version>0.0.6</version>

<description>Description of the Hello World component ...</description>

<install> 
<sql>
<file driver="mysql" charset="utf8">sql/install.mysql.utf8.sql</file>
</sql>
</install>
<uninstall> 
<sql>
<file driver="mysql" charset="utf8">sql/uninstall.mysql.utf8.sql</file>
</sql>
</uninstall>
<update> 
<schemas>
<schemapath type="mysql">sql/updates/mysql</schemapath>
</schemas>
</update>



<files folder="site">
<filename>index.html</filename>
<filename>helloworld.php</filename>
<filename>controller.php</filename>
<folder>views</folder>
<folder>models</folder>
</files>

<administration>

<menu>Hello World!</menu>


<files folder="admin">

<filename>index.html</filename>
<filename>helloworld.php</filename>

<folder>sql</folder>

<folder>tables</folder>

<folder>models</folder>
</files>
</administration>

</extension>
</source>
</span>

Do the same for the uninstall file:

With your favorite file manager and editor put a file ''admin/sql/uninstall.mysql.utf8.sql'' containing:

<span id="admin/sql/uninstall.mysql.utf8.sql">
''admin/sql/uninstall.mysql.utf8.sql''
<source lang="sql">
DROP TABLE IF EXISTS `#__helloworld`;
</source>
</span>

== Adding a new field type ==
For the moment, we have used a [[J3.3:Developing a MVC Component/Adding a menu type to the site part|hard coded field type for messages]]. We need to use our database for choosing the message.

Modify the ''site/views/helloworld/tmpl/default.xml'' file and put these lines

<span id="site/views/helloworld/tmpl/default.xml">
''site/views/helloworld/tmpl/default.xml''
<source lang="xml">
<?xml version="1.0" encoding="utf-8"?>
<metadata>
<layout title="COM_HELLOWORLD_HELLOWORLD_VIEW_DEFAULT_TITLE">
<message>COM_HELLOWORLD_HELLOWORLD_VIEW_DEFAULT_DESC</message>
</layout>
<fields
name="request"
addfieldpath="/administrator/components/com_helloworld/models/fields"
>
<fieldset name="request">
<field
name="id"
type="helloworld"
label="COM_HELLOWORLD_HELLOWORLD_FIELD_GREETING_LABEL"
description="COM_HELLOWORLD_HELLOWORLD_FIELD_GREETING_DESC"
/>
</fieldset>
</fields>
</metadata>
</source>
</span>

It introduces a new field type and tells Joomla to look for the field definition in the ''/administrator/components/com_helloworld/models/fields'' folder.

With your favorite file manager and editor put a file ''admin/models/fields/helloworld.php'' file containing:

<span id="admin/models/fields/helloworld.php">
''admin/models/fields/helloworld.php''
<source lang="php">
<?php
// No direct access to this file
defined('_JEXEC') or die;

// import the list field type
jimport('joomla.form.helper');
JFormHelper::loadFieldClass('list');

/**
* HelloWorld Form Field class for the HelloWorld component
*/
class JFormFieldHelloWorld extends JFormFieldList
{
/**
* The field type.
*
* @var string
*/
protected $type = 'HelloWorld';

/**
* Method to get a list of options for a list input.
*
* @return array An array of JHtml options.
*/
protected function getOptions()
{
$db = JFactory::getDBO();
$query = $db->getQuery(true);
$query->select('id,greeting');
$query->from('#__helloworld');
$db->setQuery((string)$query);
$messages = $db->loadObjectList();
$options = array();
if ($messages)
{
foreach($messages as $message)
{
$options[] = JHtml::_('select.option', $message->id, $message->greeting);
}
}
$options = array_merge(parent::getOptions(), $options);
return $options;
}
}
</source>
</span>

The new field type displays a drop-down list of messages to choose from. You can see the result of this change in the menu manager section for the helloworld item.

== Display the chosen message ==
When a menu item of this component is created/updated, Joomla stores the identifier of the message. The ''HelloWorldModelHelloWorld'' model has now to compute the message according to this identifier and the data stored in the database.

Modify the ''site/models/helloworld.php'' file:

<span id="site/models/helloworld.php">
''site/models/helloworld.php''
<source lang="php">
<?php
// No direct access to this file
defined('_JEXEC') or die('Restricted access');

// import Joomla modelitem library
jimport('joomla.application.component.modelitem');

/**
* HelloWorld Model
*/
class HelloWorldModelHelloWorld extends JModelItem
{
/**
* @var array messages
*/
protected $messages;

/**
* Returns a reference to the a Table object, always creating it.
*
* @param type The table type to instantiate
* @param string A prefix for the table class name. Optional.
* @param array Configuration array for model. Optional.
* @return JTable A database object
* @since 2.5
*/
public function getTable($type = 'HelloWorld', $prefix = 'HelloWorldTable', $config = array())
{
return JTable::getInstance($type, $prefix, $config);
}
/**
* Get the message
* @param int The corresponding id of the message to be retrieved
* @return string The message to be displayed to the user
*/
public function getMsg($id = 1)
{
if (!is_array($this->messages))
{
$this->messages = array();
}

if (!isset($this->messages[$id]))
{
//request the selected id
$jinput = JFactory::getApplication()->input;
$id = $jinput->get('id', 1, 'INT' );

// Get a TableHelloWorld instance
$table = $this->getTable();

// Load the message
$table->load($id);

// Assign the message
$this->messages[$id] = $table->greeting;
}

return $this->messages[$id];
}
}
</source>
</span>

The model now asks the ''TableHelloWorld'' to get the message. This table class has to be defined in ''admin/tables/helloworld.php'' file

<span id="admin/tables/helloworld.php">
''admin/tables/helloworld.php''
<source lang="php">
<?php
// No direct access
defined('_JEXEC') or die('Restricted access');

// import Joomla table library
jimport('joomla.database.table');

/**
* Hello Table class
*/
class HelloWorldTableHelloWorld extends JTable
{
/**
* Constructor
*
* @param object Database connector object
*/
function __construct(&$db)
{
parent::__construct('#__helloworld', 'id', $db);
}
}
</source>
</span>

You shouldn't see any differences, but if you access the database you should see a table named ''jos_helloworld'' with two columns: id and greeting. And two entries: ''Hello World!'' and ''Good bye World''

== Packaging the component ==

Content of your code directory
* ''[[#helloworld.xml|helloworld.xml]]''
* ''[[J3.2:Developing_a_MVC_Component/Adding_a_view_to_the_site_part#site/helloworld.php|site/helloworld.php]]''
* ''[[J3.2:Developing_a_MVC_Component/Developing_a_Basic_Component#index.html|site/index.html]]''
* ''[[J3.2:Developing_a_MVC_Component/Adding_a_view_to_the_site_part#site/controller.php|site/controller.php]]''
* ''[[J3.2:Developing_a_MVC_Component/Developing_a_Basic_Component#index.html|site/views/index.html]]''
* ''[[J3.2:Developing_a_MVC_Component/Developing_a_Basic_Component#index.html|site/views/helloworld/index.html]]''
* ''[[J3.2:Developing_a_MVC_Component/Adding_a_view_to_the_site_part#site/views/helloworld/view.html.php|site/views/helloworld/view.html.php]]''
* ''[[J3.2:Developing_a_MVC_Component/Developing_a_Basic_Component#index.html|site/views/helloworld/tmpl/index.html]]''
* ''[[#site/views/helloworld/tmpl/default.xml|site/views/helloworld/tmpl/default.xml]]''
* ''[[J3.2:Developing_a_MVC_Component/Adding_a_view_to_the_site_part#site/views/helloworld/tmpl/default.php|site/views/helloworld/tmpl/default.php]]''
* ''[[J3.2:Developing_a_MVC_Component/Developing_a_Basic_Component#index.html|site/models/index.html]]''
* ''[[#site/models/helloworld.php|site/models/helloworld.php]]''
* ''[[J3.2:Developing_a_MVC_Component/Developing_a_Basic_Component#index.html|admin/index.html]]''
* ''[[J3.2:Developing_a_MVC_Component/Developing_a_Basic_Component#admin/helloworld.php|admin/helloworld.php]]''
* ''[[J3.2:Developing_a_MVC_Component/Developing_a_Basic_Component#index.html|admin/sql/index.html]]''
* ''[[#admin/sql/install.mysql.utf8.sql|admin/sql/install.mysql.utf8.sql]]''
* ''[[#admin/sql/uninstall.mysql.utf8.sql|admin/sql/uninstall.mysql.utf8.sql]]''
* ''[[J3.2:Developing_a_MVC_Component/Developing_a_Basic_Component#index.html|admin/sql/updates/index.html]]''
* ''[[J3.2:Developing_a_MVC_Component/Developing_a_Basic_Component#index.html|admin/sql/updates/mysql/index.html]]''
* ''[[J3.2:Developing_a_MVC_Component/Developing_a_Basic_Component#admin/sql/updates/mysql/0.0.1.sql|admin/sql/updates/mysql/0.0.1.sql]]''
* ''[[#admin/sql/install.mysql.utf8.sql|admin/sql/updates/mysql/0.0.6.sql]]''
* ''[[J3.2:Developing_a_MVC_Component/Developing_a_Basic_Component#index.html|admin/models/index.html]]''
* ''[[J3.2:Developing_a_MVC_Component/Developing_a_Basic_Component#index.html|admin/models/fields/index.html]]''
* ''[[#admin/models/fields/helloworld.php|admin/models/fields/helloworld.php]]''
* ''[[J3.2:Developing_a_MVC_Component/Developing_a_Basic_Component#index.html|admin/tables/index.html]]''
* ''[[#admin/tables/helloworld.php|admin/tables/helloworld.php]]''

Create a compressed file of this directory or directly download the [https://github.com/joomla/Joomla-3.2-Hello-World-Component/archive/step-6-using-the-database.zip archive] and install it using the extension manager of Joomla. You can add a menu item of this component using the menu manager in the backend.

{{notice|Please create a pull request or issue at https://github.com/joomla/Joomla-3.2-Hello-World-Component for any code descprepancies or if editing any of the source code on this page.}}

{{:J3.2:Developing a MVC Component/Navigate
|prev=Adding a variable request in the menu type 
|next=Basic backend }}

== Contributors ==
*[[User:cdemko|Christophe Demko]]
*[[User:oaksu|Ozgur Aksu]]

[[Category:Joomla! 3.0]]
[[Category:Joomla! 3.1]]
[[Category:Joomla! 3.2]]
[[Category:Beginner Development]]
[[Category:Component Development]]

J3.x:Developing an MVC Component/Using the database

2014-05-15T04:45:36Z

Samwilsonau: Updated version numbers to be consistent with the rest of the tutorial.

{{:J3.3:Developing a MVC Component}}

== Introduction ==
This tutorial is part of the [[J3.3:Developing a MVC Component | Developing a MVC Component for Joomla! 3.3]] tutorial. You are encouraged to read the previous parts of the tutorial before reading this.

== Using the database ==
Components usually manage their contents using the database. During the install/uninstall/update phase of a component, you can execute SQL queries through the use of SQL text files.

With your favorite file manager and editor create two files called ''admin/sql/install.mysql.utf8.sql'' and ''admin/sql/updates/mysql/0.0.6.sql''. They should both have the same content, as follows:

<span id="admin/sql/install.mysql.utf8.sql">
''admin/sql/install.mysql.utf8.sql'' and ''admin/sql/updates/mysql/0.0.6.sql''
<source lang="sql">
DROP TABLE IF EXISTS `#__helloworld`;

CREATE TABLE `#__helloworld` (
`id` int(11) NOT NULL auto_increment,
`greeting` varchar(25) NOT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=0 DEFAULT CHARSET=utf8;

INSERT INTO `#__helloworld` (`greeting`) VALUES
('Hello World!'),
('Good bye World!');
</source>
</span>

The file ''install.mysql.utf8.sql'' will be executed when you install this component. The file ''0.0.6.sql'' is executed when you do an update.

'''Important Note:''' When the component is installed, the files in the SQL updates folder (for example, ''admin/sql/updates/mysql'') are read and the name of the last file alphabetically is used to populate the component's version number in the <code>#__schemas</code> table. This value must be in this table in order for the automatic update to execute the update SQL files for future versions. For this reason, it is good practice to create a SQL update file for each version (even if it is empty or just has a comment). This way the <code>#__schemas</code> version will always match the component version.

'''Important Note:''' When saving the SQL files in utf8, be sure to save them as utf8 NO BOM or the query will fail with MySQL error #1064.

This is the install file. It will be executed if you put an appropriate order in the ''helloworld.xml'' file

<span id="helloworld.xml">
''helloworld.xml''
<source lang="xml">
<?xml version="1.0" encoding="utf-8"?>
<extension type="component" version="3.2.0" method="upgrade">

<name>Hello World!</name>

<creationDate>January 2014</creationDate>
<author>John Doe</author>
<authorEmail>john.doe@example.org</authorEmail>
<authorUrl>http://www.example.org</authorUrl>
<copyright>Copyright Info</copyright>
<license>License Info</license>

<version>0.0.6</version>

<description>Description of the Hello World component ...</description>

<install> 
<sql>
<file driver="mysql" charset="utf8">sql/install.mysql.utf8.sql</file>
</sql>
</install>
<uninstall> 
<sql>
<file driver="mysql" charset="utf8">sql/uninstall.mysql.utf8.sql</file>
</sql>
</uninstall>
<update> 
<schemas>
<schemapath type="mysql">sql/updates/mysql</schemapath>
</schemas>
</update>



<files folder="site">
<filename>index.html</filename>
<filename>helloworld.php</filename>
<filename>controller.php</filename>
<folder>views</folder>
<folder>models</folder>
</files>

<administration>

<menu>Hello World!</menu>


<files folder="admin">

<filename>index.html</filename>
<filename>helloworld.php</filename>

<folder>sql</folder>

<folder>tables</folder>

<folder>models</folder>
</files>
</administration>

</extension>
</source>
</span>

Do the same for the uninstall file:

With your favorite file manager and editor put a file ''admin/sql/uninstall.mysql.utf8.sql'' containing:

<span id="admin/sql/uninstall.mysql.utf8.sql">
''admin/sql/uninstall.mysql.utf8.sql''
<source lang="sql">
DROP TABLE IF EXISTS `#__helloworld`;
</source>
</span>

== Adding a new field type ==
For the moment, we have used a [[Developing_a_Model-View-Controller_%28MVC%29_Component_for_Joomla!2.5_-_Part_03|hard coded field type for messages]]. We need to use our database for choosing the message.

Modify the ''site/views/helloworld/tmpl/default.xml'' file and put these lines

<span id="site/views/helloworld/tmpl/default.xml">
''site/views/helloworld/tmpl/default.xml''
<source lang="xml">
<?xml version="1.0" encoding="utf-8"?>
<metadata>
<layout title="COM_HELLOWORLD_HELLOWORLD_VIEW_DEFAULT_TITLE">
<message>COM_HELLOWORLD_HELLOWORLD_VIEW_DEFAULT_DESC</message>
</layout>
<fields
name="request"
addfieldpath="/administrator/components/com_helloworld/models/fields"
>
<fieldset name="request">
<field
name="id"
type="helloworld"
label="COM_HELLOWORLD_HELLOWORLD_FIELD_GREETING_LABEL"
description="COM_HELLOWORLD_HELLOWORLD_FIELD_GREETING_DESC"
/>
</fieldset>
</fields>
</metadata>
</source>
</span>

It introduces a new field type and tells Joomla to look for the field definition in the ''/administrator/components/com_helloworld/models/fields'' folder.

With your favorite file manager and editor put a file ''admin/models/fields/helloworld.php'' file containing:

<span id="admin/models/fields/helloworld.php">
''admin/models/fields/helloworld.php''
<source lang="php">
<?php
// No direct access to this file
defined('_JEXEC') or die;

// import the list field type
jimport('joomla.form.helper');
JFormHelper::loadFieldClass('list');

/**
* HelloWorld Form Field class for the HelloWorld component
*/
class JFormFieldHelloWorld extends JFormFieldList
{
/**
* The field type.
*
* @var string
*/
protected $type = 'HelloWorld';

/**
* Method to get a list of options for a list input.
*
* @return array An array of JHtml options.
*/
protected function getOptions()
{
$db = JFactory::getDBO();
$query = $db->getQuery(true);
$query->select('id,greeting');
$query->from('#__helloworld');
$db->setQuery((string)$query);
$messages = $db->loadObjectList();
$options = array();
if ($messages)
{
foreach($messages as $message)
{
$options[] = JHtml::_('select.option', $message->id, $message->greeting);
}
}
$options = array_merge(parent::getOptions(), $options);
return $options;
}
}
</source>
</span>

The new field type displays a drop-down list of messages to choose from. You can see the result of this change in the menu manager section for the helloworld item.

== Display the chosen message ==
When a menu item of this component is created/updated, Joomla stores the identifier of the message. The ''HelloWorldModelHelloWorld'' model has now to compute the message according to this identifier and the data stored in the database.

Modify the ''site/models/helloworld.php'' file:

<span id="site/models/helloworld.php">
''site/models/helloworld.php''
<source lang="php">
<?php
// No direct access to this file
defined('_JEXEC') or die('Restricted access');

// import Joomla modelitem library
jimport('joomla.application.component.modelitem');

/**
* HelloWorld Model
*/
class HelloWorldModelHelloWorld extends JModelItem
{
/**
* @var array messages
*/
protected $messages;

/**
* Returns a reference to the a Table object, always creating it.
*
* @param type The table type to instantiate
* @param string A prefix for the table class name. Optional.
* @param array Configuration array for model. Optional.
* @return JTable A database object
* @since 2.5
*/
public function getTable($type = 'HelloWorld', $prefix = 'HelloWorldTable', $config = array())
{
return JTable::getInstance($type, $prefix, $config);
}
/**
* Get the message
* @param int The corresponding id of the message to be retrieved
* @return string The message to be displayed to the user
*/
public function getMsg($id = 1)
{
if (!is_array($this->messages))
{
$this->messages = array();
}

if (!isset($this->messages[$id]))
{
//request the selected id
$jinput = JFactory::getApplication()->input;
$id = $jinput->get('id', 1, 'INT' );

// Get a TableHelloWorld instance
$table = $this->getTable();

// Load the message
$table->load($id);

// Assign the message
$this->messages[$id] = $table->greeting;
}

return $this->messages[$id];
}
}
</source>
</span>

The model now asks the ''TableHelloWorld'' to get the message. This table class has to be defined in ''admin/tables/helloworld.php'' file

<span id="admin/tables/helloworld.php">
''admin/tables/helloworld.php''
<source lang="php">
<?php
// No direct access
defined('_JEXEC') or die('Restricted access');

// import Joomla table library
jimport('joomla.database.table');

/**
* Hello Table class
*/
class HelloWorldTableHelloWorld extends JTable
{
/**
* Constructor
*
* @param object Database connector object
*/
function __construct(&$db)
{
parent::__construct('#__helloworld', 'id', $db);
}
}
</source>
</span>

You shouldn't see any differences, but if you access the database you should see a table named ''jos_helloworld'' with two columns: id and greeting. And two entries: ''Hello World!'' and ''Good bye World''

== Packaging the component ==

Content of your code directory
* ''[[#helloworld.xml|helloworld.xml]]''
* ''[[J3.2:Developing_a_MVC_Component/Adding_a_view_to_the_site_part#site/helloworld.php|site/helloworld.php]]''
* ''[[J3.2:Developing_a_MVC_Component/Developing_a_Basic_Component#index.html|site/index.html]]''
* ''[[J3.2:Developing_a_MVC_Component/Adding_a_view_to_the_site_part#site/controller.php|site/controller.php]]''
* ''[[J3.2:Developing_a_MVC_Component/Developing_a_Basic_Component#index.html|site/views/index.html]]''
* ''[[J3.2:Developing_a_MVC_Component/Developing_a_Basic_Component#index.html|site/views/helloworld/index.html]]''
* ''[[J3.2:Developing_a_MVC_Component/Adding_a_view_to_the_site_part#site/views/helloworld/view.html.php|site/views/helloworld/view.html.php]]''
* ''[[J3.2:Developing_a_MVC_Component/Developing_a_Basic_Component#index.html|site/views/helloworld/tmpl/index.html]]''
* ''[[#site/views/helloworld/tmpl/default.xml|site/views/helloworld/tmpl/default.xml]]''
* ''[[J3.2:Developing_a_MVC_Component/Adding_a_view_to_the_site_part#site/views/helloworld/tmpl/default.php|site/views/helloworld/tmpl/default.php]]''
* ''[[J3.2:Developing_a_MVC_Component/Developing_a_Basic_Component#index.html|site/models/index.html]]''
* ''[[#site/models/helloworld.php|site/models/helloworld.php]]''
* ''[[J3.2:Developing_a_MVC_Component/Developing_a_Basic_Component#index.html|admin/index.html]]''
* ''[[J3.2:Developing_a_MVC_Component/Developing_a_Basic_Component#admin/helloworld.php|admin/helloworld.php]]''
* ''[[J3.2:Developing_a_MVC_Component/Developing_a_Basic_Component#index.html|admin/sql/index.html]]''
* ''[[#admin/sql/install.mysql.utf8.sql|admin/sql/install.mysql.utf8.sql]]''
* ''[[#admin/sql/uninstall.mysql.utf8.sql|admin/sql/uninstall.mysql.utf8.sql]]''
* ''[[J3.2:Developing_a_MVC_Component/Developing_a_Basic_Component#index.html|admin/sql/updates/index.html]]''
* ''[[J3.2:Developing_a_MVC_Component/Developing_a_Basic_Component#index.html|admin/sql/updates/mysql/index.html]]''
* ''[[J3.2:Developing_a_MVC_Component/Developing_a_Basic_Component#admin/sql/updates/mysql/0.0.1.sql|admin/sql/updates/mysql/0.0.1.sql]]''
* ''[[#admin/sql/install.mysql.utf8.sql|admin/sql/updates/mysql/0.0.6.sql]]''
* ''[[J3.2:Developing_a_MVC_Component/Developing_a_Basic_Component#index.html|admin/models/index.html]]''
* ''[[J3.2:Developing_a_MVC_Component/Developing_a_Basic_Component#index.html|admin/models/fields/index.html]]''
* ''[[#admin/models/fields/helloworld.php|admin/models/fields/helloworld.php]]''
* ''[[J3.2:Developing_a_MVC_Component/Developing_a_Basic_Component#index.html|admin/tables/index.html]]''
* ''[[#admin/tables/helloworld.php|admin/tables/helloworld.php]]''

Create a compressed file of this directory or directly download the [https://github.com/joomla/Joomla-3.2-Hello-World-Component/archive/step-6-using-the-database.zip archive] and install it using the extension manager of Joomla. You can add a menu item of this component using the menu manager in the backend.

{{notice|Please create a pull request or issue at https://github.com/joomla/Joomla-3.2-Hello-World-Component for any code descprepancies or if editing any of the source code on this page.}}

{{:J3.2:Developing a MVC Component/Navigate
|prev=Adding a variable request in the menu type 
|next=Basic backend }}

== Contributors ==
*[[User:cdemko|Christophe Demko]]
*[[User:oaksu|Ozgur Aksu]]

[[Category:Joomla! 3.0]]
[[Category:Joomla! 3.1]]
[[Category:Joomla! 3.2]]
[[Category:Beginner Development]]
[[Category:Component Development]]

J3.x:Developing an MVC Component/Adding a view to the site part

2014-05-15T04:16:09Z

Samwilsonau: Making the paths agree with the previous tutorial page.

{{version/tutor|3.2}}
{{Chunk:Developing a Model-View-Controller (MVC) Component for Joomla!3.1 - Contents}}

== Introduction ==
This tutorial is part of the [[J3.2:Developing_a_MVC_Component|Developing a Model-View-Controller (MVC) Component for Joomla! 3.x]] tutorial. You are encouraged to read the previous parts of the tutorial before reading this.

In the Joomla!3.x framework, third party component authors divide their code into three main parts:
* ''models'' They manage the data
* ''controllers'' They perform tasks, set and get the states of the models and ask the views to display
* ''views'' They display the content according to the type (''error'', ''feed'', ''html'', ''json'', ''raw'', ''xml'') and the layout chosen by the controllers

== Setting the controller ==
In the core code of Joomla, there is a class able to manage controllers: ''[http://api.joomla.org/cms-3/classes/JControllerLegacy.html JControllerLegacy]''. This class has to be extended to be used in our component. In the file ''yoursite/components/com_helloworld/helloworld.php'' (entry point of our ''Hello World'' component), put these lines:

{{vanchor|site/helloworld.php}}
<source lang="php">
<?php
// No direct access to this file
defined('_JEXEC') or die('Restricted access');

// import joomla controller library
jimport('joomla.application.component.controller');

// Get an instance of the controller prefixed by HelloWorld
$controller = JControllerLegacy::getInstance('HelloWorld');

// Perform the Request task
$input = JFactory::getApplication()->input;
$controller->execute($input->getCmd('task'));

// Redirect if set by the controller
$controller->redirect();
</source>

The ''[http://api.joomla.org/cms-3/classes/JControllerLegacy.html#method_getInstance getInstance]'' static method of the ''JControllerLegacy'' class will create a controller. In the code above, it will instantiate a controller object of a class named ''HelloWorldController''. Joomla will look for the declaration of that class in an aptly named file called ''yoursite/components/com_helloworld/controller.php'' (it's a default behavior).

Now, ''controller.php'' needs to be created and ''HelloWorldController'' needs to be declared and defined. So with your favorite file manager and editor, create a ''yoursite/components/com_helloworld/controller.php'' file containing

{{vanchor|site/controller.php}}
<source lang="php">
<?php
// No direct access to this file
defined('_JEXEC') or die('Restricted access');

// import Joomla controller library
jimport('joomla.application.component.controller');

/**
* Hello World Component Controller
*/
class HelloWorldController extends JControllerLegacy
{
}
</source>

When no task is given in the request variables, the default task will be executed. It's the ''display'' task by default. The ''JControllerLegacy'' class has such a task. In our example, it will display a view named ''HelloWorld''.

So with ''task'' simply a public function display() of ''JControllerLegacy'' is refered to.

{{tip|Just a side note for completion, you could call another function aside from ''display()'' by using an URL like this one:

<pre>http://localhost/index.php?option=com_helloworld&task=insert</pre>

This would try to call a function ''insert()'' of our controller (which we would actually have to implement in ''HelloWorldController'' ).}}

== Setting the view ==

When JControllerLegacy wants to display a view, it will look for certain files in the ''yoursite/components/com_[component_name]/views/[name of view]/'' folder.

The name of the folder of the default view is the name of the component itself. In our case the path is ''yoursite/components/com_helloworld/views/helloworld/''.

The file that will contain the code of the view is called ''view.[view_mode].php''. The default view mode, and probably the only view a component might need is the ''html'' mode. So this give us our file name which is ''view.html.php''.

With your favorite file manager and editor, create a file ''yoursite/components/com_helloworld/views/helloworld/view.html.php'' able to display the default view and containing:

<source lang="php">
<?php
// No direct access to this file
defined('_JEXEC') or die('Restricted access');

// import Joomla view library
jimport('joomla.application.component.view');

/**
* HTML View class for the HelloWorld Component
*/
class HelloWorldViewHelloWorld extends JViewLegacy
{
// Overwriting JView display method
function display($tpl = null)
{
// Assign data to the view
$this->msg = 'Hello World';

// Display the view
parent::display($tpl);
}
}
</source>

The ''display'' method of the ''[http://api.joomla.org/cms-3/classes/JViewLegacy.html JViewLegacy]'' class is called with the ''display'' task of the JControllerLegacy class. In our case, this method will display data using the ''tmpl/default.php'' file. With your favorite file manager and editor, create a file ''yoursite/components/com_helloworld/views/helloworld/tmpl/default.php'' able to display the default view and containing:

<source lang="php">
<?php
// No direct access to this file
defined('_JEXEC') or die('Restricted access');
?>
<h1><?php echo $this->msg; ?></h1>
</source>

This template file will be included by the JViewLegacy class. Therefore, here, $this refers to the HelloWorldViewHelloWorld class.

So to give an example, one could call the view inside the ''yoursite/components/com_[component_name]/views/[name of view]/'' folder by calling <code>index.php?option=com_helloworld</code> (this would default to the ''yoursite/components/com_helloworld/views/helloworld/'' folder) or we could explicitly call the folder by calling: <code>index.php?option=com_helloworld&view=helloworld</code>

if we change <code>&view=helloworld</code> to something else, e.g. <code>&view=fluffy</code> we would have to create a folder <code>components/com_helloworld/views/fluffy/</code>.

Copy the contents of <code>views/helloworld</code> to <code>views/fluffy</code>

The classname of the file <code>view.html.php</code> of the fluffy folder would be ''HelloWorldViewFluffy''. Afterwards you can customize the contents of ''default.php'' of the ''fluffy'' subfolder for custom output and see the output by calling <code>index.php?option=com_helloworld&view=fluffy</code>

== Packaging the component ==

Content of your code directory
* ''[[#helloworld.xml|helloworld.xml]]''
* ''[[#site/helloworld.php|site/helloworld.php]]''
* ''[[J3.2:Developing_a_MVC_Component/Developing_a_Basic_Component#index.html|site/index.html]]''
* ''[[#site/controller.php|site/controller.php]]''
* ''[[J3.2:Developing_a_MVC_Component/Developing_a_Basic_Component#index.html|site/views/index.html]]''
* ''[[J3.2:Developing_a_MVC_Component/Developing_a_Basic_Component#index.html|site/views/helloworld/index.html]]''
* ''[[#site/views/helloworld/view.html.php|site/views/helloworld/view.html.php]]''
* ''[[J3.2:Developing_a_MVC_Component/Developing_a_Basic_Component#index.html|site/views/helloworld/tmpl/index.html]]''
* ''[[#site/views/helloworld/tmpl/default.php|site/views/helloworld/tmpl/default.php]]''
* ''[[J3.2:Developing_a_MVC_Component/Developing_a_Basic_Component#index.html|admin/index.html]]''
* ''[[J3.2:Developing_a_MVC_Component/Developing_a_Basic_Component#admin/helloworld.php|admin/helloworld.php]]''
* ''[[J3.2:Developing_a_MVC_Component/Developing_a_Basic_Component#index.html|admin/sql/index.html]]''
* ''[[J3.2:Developing_a_MVC_Component/Developing_a_Basic_Component#index.html|admin/sql/updates/index.html]]''
* ''[[J3.2:Developing_a_MVC_Component/Developing_a_Basic_Component#index.html|admin/sql/updates/mysql/index.html]]''
* ''[[J3.2:Developing_a_MVC_Component/Developing_a_Basic_Component#admin/sql/updates/mysql/0.0.1.sql|admin/sql/updates/mysql/0.0.1.sql]]''

Create a compressed file of this directory or directly download the [http://joomlacode.org/gf/download/frsrelease/11394/58226/com_helloworld-1.6-part02.zip archive] and install it using the extension manager of Joomla. You can test this basic component by putting ''index.php?option=com_helloworld'' in your browser address.

<span id="helloworld.xml">
''helloworld.xml''
<source lang="xml">
<?xml version="1.0" encoding="utf-8"?>
<extension type="component" version="2.5.0" method="upgrade">

<name>Hello World!</name>

<creationDate>November 2009</creationDate>
<author>John Doe</author>
<authorEmail>john.doe@example.org</authorEmail>
<authorUrl>http://www.example.org</authorUrl>
<copyright>Copyright Info</copyright>
<license>License Info</license>

<version>0.0.2</version>

<description>Description of the Hello World component ...</description>

<update> 
<schemas>
<schemapath type="mysql">sql/updates/mysql</schemapath>
</schemas>
</update>



<files folder="site">
<filename>index.html</filename>
<filename>helloworld.php</filename>
<filename>controller.php</filename>
<folder>views</folder>
</files>

<administration>

<menu>Hello World!</menu>


<files folder="admin">

<filename>index.html</filename>
<filename>helloworld.php</filename>

<folder>sql</folder>
</files>
</administration>

</extension>
</source>
</span>

'''Result:'''
You will see by default the message contained in the variable ''$this->msg'' in the ''view.html.php'' file.

{{notice|Please create a pull request or issue at https://github.com/joomla/Joomla-3.2-Hello-World-Component for any code descprepancies or if editing any of the source code on this page.}}

{{:J3.2:Developing a MVC Component/Navigate|prev=Developing a Basic Component|next=Adding a menu type to the site part}}

<noinclude>[[Category:Component Development]] [[Category:Joomla! 3.0]] [[Category:Joomla! 3.1]][[Category:Joomla! 3.2]]</noinclude>

== Contributors ==
*[[User:cdemko|Christophe Demko]]
*[[User:oaksu|Ozgur Aksu]]

[[Category:Development]]
[[Category:Joomla! 3.0]]
[[Category:Joomla! 3.1]]
[[Category:Joomla! 3.2]]

Category:Wiki Templates

2014-05-15T03:22:27Z

Samwilsonau: Added link to JDOC:Wiki Templates Project.

{{cat header|
:{{about|page=category|MediaWiki Templates|Joomla! Templates|Templates}}
These templates are used for the content formatting of articles, navigating the Wiki and its namespaces, cross-linking pages, and to create the documentation of ''Wiki Templates'' themself. For more information, see [[JDOC:Wiki Templates Project]].

This category contains pages in the {{ns:template}} namespace. It '''must not''' be used to categorize articles or pages in other namespaces.}}
[[Category:{{SITENAME}} Wiki|Wiki Templates]]

J3.x talk:Developing a MVC Component/Developing a Basic Component

2014-05-14T03:29:32Z

Samwilsonau: Discover?

== Install or discover required? ==
I am trying to follow the instructions on this page, but am felled at the first hurdle: navigating to <code> index.php?option=com_helloworld</code> results in '''404 Component not found'''. Any ideas? [[User:Samwilsonau|Sam Wilson]] ([[User talk:Samwilsonau|talk]]) 22:29, 13 May 2014 (CDT)

Chunk:LDAP

2013-03-15T02:17:08Z

Samwilsonau: Updated a bit, but not sure where to put 'how-to' info. Probably in LDAP rather than here.

'''[[wp:LDAP|LDAP]]''' (or ''Lightweight Directory Access Protocol'') is a protocol designed to access directory systems over TCP/IP. Because of this various databases provide an LDAP interface such as [[wp:Active Directory|Microsoft's Active Directory]], [[wp:Novell eDirectory|Novell's eDirectory]], as well as more dedicated LDAP solutions such as [[wp:OpenLDAP|OpenLDAP]].

Since the release of {{jVer|1.5}} Joomla! has had a native LDAP library (<code>[http://api.joomla.org/Joomla-Platform/Client/JLDAP.html joomla.client.ldap]</code>) and a native LDAP authentication plugin. This allows Joomla! to authenticate against LDAP systems out of the box: to configure, go to the Plugin Manager and enable and edit the ''Authentication - LDAP'' plugin.

You can also read a tutorial on [http://community.joomla.org/component/zine/article/507-developer-ldap-from-scratch-sam-moffatt.html getting started from scratch with LDAP].

'''Before 1.5:''' In Joomla! {{jVer|1.0}}, there was no native LDAP library or authentication plugin. The [http://sammoffatt.com.au/jauthtools JAuthTools project] provides a Joomla! 1.0 solution for authentication without hacks as well as configuration resources for both Joomla! 1.0 and 1.5 LDAP authentication solutions.

<noinclude>[[Category:Glossary definitions|{{PAGENAME}}]]</noinclude>

Entering search engine meta-data

2013-03-15T00:18:53Z

Samwilsonau: /* Controlled Crawling */ Simplify.

Meta-data is information about the website in the header portion of the webpage. This information is used by search engines to determine the relevance of the give page to the search request it is processing at any given time. This data is constantly collected by various means by all search engines such as Google, Yahoo, Ask and others. The following list is a partial list of things to consider when building and publishing a web site.

GoDaddy hosting has a web site analysis tool to examine your site and report how each of these rules is violated. The report is shaky at best but it helps in identifying your website's weaknesses.

== Title Tags ==
Well-constructed title tags contain the main keyword for the page, followed by a brief description of the page content. It will be less than 65 characters and avoid using stop words such as: a, if, the, then, and, an, to, etc. Your title tag should also be limited to the use of alphanumeric characters, hyphens, and commas.

== Description Tags ==
Good description tags contain information about the page's content and persuade search engine users to visit your web site. They should be between 25 and 35 words in length.

== Keywords Tags ==
Your keywords meta tag should contain between 5-10 keywords or keyword phrases that are also found in page content.

== Heading Tags ==
Each page of your site should use at least the H1 heading tag for the search engines that examine it when crawling your site.

== Page Content ==
Pages should have between 300 and 700 words of descriptive content that contains the keywords specified in the keywords meta tag for the page. A page's meta tag keywords should also be those that occur most frequently on the page.

== Proper Navigation ==
Each page of your site should contain links to every other page so search engine spiders can find every page. This is a critical step for the proper indexing and page rank distribution of your site.

== Proper Sitemap ==
It's important to use two site maps for your website--an XML version and a static version. The XML table protocol is explained in detail on http://www.sitemaps.org. The static version should sit on a static HTML page and contain links to every other page.

== Controlled Crawling ==
It's important that search engine spiders find your [[Robots.txt file]] that guides spiders to pages and directories you want crawled and denies them entry to protected areas of your site.

== Duplicate Content/Tags ==
Because search engines treat web sites as a grouping of pages and not a single entity, each page on your site should be unique so that the tags and content differ between each page. Doing so increases the number of pages that will rank.

== Word Density ==
Pages should contain 300 to 700 words of unique and descriptive content.

[[Category:Tips and tricks]]
[[Category:Article Management]]
[[Category:Search Engine Optimization]]

Making your site Search Engine Friendly

2013-03-15T00:17:40Z

Samwilsonau: /* Title tag */ Link.

{{RightTOC}}
==Why Create a Search Engine Friendly Site?==
In order to add your pages to its database, a search engine (such as Google) will send out so-called crawlers, spiders or bots to harvest the text on your site. These bots cannot harvest things that are created by Javascript, or 'see' images (though they do check alt tags) and the don't play well with Flash files if at all.

While all these things may make the site look better, they do little to nothing in terms of search engine optimisation (SEO).

It is important that your website can be found by people who are looking for its content, therefore you must serve content to search engine 'bots' in a way that they can interpret, analyse and identify how relevant it is to the search query.

For this to happen, you need to bring to the attention of the 'bots' important information about the page using various techniques detailed below - almost like a 'signpost' telling the 'bot' what the page contains. It will then compare what you tell it the page is about, with what it finds by itself, and run various algorithms to check if the page is in fact relevant. It also runs other checks to make sure that you are not trying to cheat the system using 'black hat' or 'grey hat' tactics to make your page rank higher.

==Update Frequency==
{{review|section}}
While you can manually specify in your Sitemap how frequently search engine spiders should visit your website, they have in-built systems which automatically adjust the frequency of return visits based on how often the page in question has changed.

So, for example, if you tell search engine bots to visit your page on a daily basis, but when it visits the page nothing has changed for a week, it may adjust the frequency of revisits accordingly and not return as often as you told it to. You can request, via the various webmasters portals, for the revisit rate to be amended if required.

This would suggest, therefore, that if you have regularly changing content, your website will be 'spidered' more frequently - leading to content being indexed quickly.

[http://productforums.google.com/forum/#!category-topic/webmasters/sitemaps/-w7T6qg8o7s Google Webmaster Tools thread on Googlebot requests & sitemap frequencies]

==Title tag==
{{review|section}}
The TITLE tag is found in the HEAD portion of your pages. This TITLE tag becomes the clickable title in search engine result pages (SERPs). A title should be under 70 characters in length. It should also include your keywords for the specific page, as close to the start of the TITLE tag as possible.

Google recommends that you create ''unique, descriptive page titles to describe to searchers what the page is about''.

If a title page is not specified, or importantly '''if Google determines that the title is not appropriate for the content being returned for the search term''', algorithms may be used to generate alternative titles which are more relevant.

Google recommends that you follow these key principles when creating a title:

* Specify a title for every page
* Make your title descriptive, and concise
* Avoid keyword stuffing (repeatedly using similar words like "Foobar, foo bar, foobars, foo bars")
* Avoid using generic titles - each page should have an unique title, ideally dynamically updated in relation to the content being displayed
* Brand your titles, but do it concisely and in relation to the content being served
* Use [[robots.txt file|robots.txt]] carefully, don't disallow search engines from visiting your website

There are various webmaster tools which can be used to identify if there are problems with your listings in a particular search engine - it is always worth paying attention and correcting any problems.

[http://support.google.com/webmasters/bin/answer.py?hl=en&answer=35624 Google support article on using titles for your web pages]

==Meta Description==
{{review|section}}
The META DESCRIPTION tag keeps a summary of the content on the page. The tag is used by search engines to display a description of the page when displaying it in search engine result pages (SERPs). This, however, only applies if the word searched for is included in the description. Otherwise, the search engine might display another portion of the page, which includes the keyword. When writing META DESCRIPTION tags for your pages, keep them below 155 characters. Also make sure to include the most important keywords for the page in question. Consider the description to be your sales copy to get people to click the link. Thus, the description should be written for humans, not search engines.

Even though Joomla has a global field for Meta Description (Global Configuration > Site > Global Site Meta Description), you should in most cases leave this blank. Google (and possibly other search engines as well) does not like duplicate title or meta description tags. If you add something to the global field, it will be duplicated on all pages that do not have a specific meta description.

Google recommends the following to ensure that you gain the most from your search engine indexing:

* Ensure every page has unique, relevant meta descriptions
* Ensure you apply metadata for listing pages (e.g. blog & list layouts) in addition to individual articles - this is commonly overlooked on Joomla! websites
* Include factual information if relevant (e.g. blog articles may include the author, products might include the price or manufacturer)
* Consider using automatically generated metadata - but make sure it's relevant, readable and accurate
* Make your descriptions descriptive!

[http://support.google.com/webmasters/bin/answer.py?hl=en&answer=35624 Google support article on using metadata]

==Keywords==
{{review|section}}

There are two major parts to understanding keywords: one is the meta tag and the other is density. If you are starting a brand new site you will need to do a little planning for both SEO and simple Joomla structure. Keywords are the focus of your content. You should come up with a list of no more than 25 keywords that describe your site's message. Once you have your list of keywords, keep them in focus as you write content and create Joomla sections, categories, and articles. Use these keywords through your site to improve SEO.

The meta keyword tag found in the head of most Web documents has little effect for Google, Bing and many of the other larger search engines. Yahoo still uses the meta tag as part of the algorithm, as well as some of the meta crawlers. Search engines all read the text in the tag; they just do not apply the information to their ranking algorithms. If your page has a keyword tag, you must make sure that word is on the same page in the content.

Density is the number of times a word is placed in the readable content of a page. If you have ten readable words and one word is a keyword the density of 10%. If you have 100 words and one of them is a keyword you now have a density of 1%. Keep your density between 3.5 and 7 percent. Look for an online density analyzer to get an estimated density of a keyword.

Make sure to use keywords in your titles or aliases, links, and content. DO NOT STUFF keywords. Content that does not make sense and is full of keywords for the sole purpose of raising the keyword density to a high level will cause your site to be penalized in the search engines. It is very difficult to write an article that someone will enjoy reading or find usable and increase the density over 7 percent.

This section has a keyword density on the term “keyword” of 1.79% and on the term “keywords” of 2.05%. The combined density is approximately 3.8%. You can see how deliberate you would have to be to stuff a site greater than 7%.

'''To Add Meta Keywords to Your Site:'''

* Add the 25 keywords to your Global Configuration > Site > Global Site Meta Keywords.
* Add specific meta keywords to articles using the metadata information. Make sure the keywords listed here are in the content of the article also.
* Adding the data does not harm your rankings in search engines, and will help you in Yahoo, and meta crawlers. Never add more than 25 words in the meta data. Separate words and phrases with a comma. Do not repeat keywords.

==Use Semantic HTML==

What is Semantic HTML?

Semantic HTML is a way of using HTML coding to create or enhance the structure of a page. In other words, it's a way of using HTML - classes, divs, tags and so forth - to compliment the actual words or resources on a page. Again, this helps 'bots' to understand the importance, relevance, and links between the content on your page.

It's important, therefore, that you have an understanding of semantic HTML and how to use it. For example, we often see people using a H2 tag in the middle of content because it has the style that they want to use - but it's not actually a heading. How the content looks has nothing to do with the structure of the page - it's important to remember that the two are quite different.

For example, lets say we have an article:

<source class="html">
<h1>Using headings</h1>
This is an article about the importance of headings

<h2>Why use headings?</h2>
It is important to use headings so that search engine bots can tell what is an <strong>important</strong> part of your article

<h3>Types of headings</h3>
You can use set types of headings, but they should be ordered, and structured, within your page. H1 should be your page title, with H2 being used for sub-headings of the page. Any headings within your sub-headings should cascade using H3, H4, and H5 as appropriate.

<h2>Is it hard to implement headings?</h2>
It is really easy to implement headings, you just use the appropriate HTML code

<h3>Using headings on dynamic pages</h3>
On dynamic pages, simply wrap your main heading within a H1 (for example, the title of a category listing page would be H1) then wrap all subsequent headings in H2.
</source>

Here, a search engine bot could clearly see the structure - h1, h2, h3 - but if we were to simply make these titles bold, underlined and larger font, it would be much more difficult to identify the structure. It is also possible to identify that the word 'important' is an emphasised word, something that is important within the page.

Semantic HTML is also
* Easier to read (in the code)
* Easier for accessibility purposes - screen readers function in a similar way to search engine bots to identify important headings
* Potentially better for search engine optimisation

[http://en.wikipedia.org/wiki/Semantic_HTML Wikipedia article on Semantic HTML]

==Use Links in Your Content==
{{review | section }}
It is important that you ensure any links within your content inform the user what they are linking to, but without being 'spammy' - i.e. stuffed full of keywords.

Ideally you should include words which feature in the URL to which you are linking, and the hyperlinked text should be descriptive of the content you're about to view. An example where this is often done poorly on Joomla! websites is where 'Read more' links display ''Read More'' rather than the title of the article, in the hyperlinked text. Another common habit is for sites to only include a link on the word ''here''.

This also gives the person visiting your site confidence in the link they are clicking - they know what to expect when visiting the link, so it may be more likely that they do so.

This is true for both internal links (if you're linking to another page or area on your website) and also on external links to other sites.

Be aware, however, that with recent updates to Google's algorithms (named Panda, and more recently Penguin), sites with unnatural linking profiles may be down-ranked in search engine positions. One of the main factors in the Penguin update targeted websites which had a large amount of its traffic coming from keyword-stuffed anchor text on hyperlinks from low-value websites. Keep your links relevant, appropriate and relating to what you are linking to.

Where possible, it's also wise to regularly check that your links are still valid. The user experience is tainted somewhat if 50% of the links on your site result in a ''404 - Page Not Found'' error. There are components and plugins available which will automate these checks for you.

In short, use links appropriately, but don't make the mistake of not using them where relevant. The user experience is improved greatly when you link to any article you may be referencing (whether internal or external), and the Search Engines generally recognise this.

==Have a Structured or Planned Navigation==
{{stub|section}}
Having a good navigation system is hugely beneficial for allowing bots to effectively crawl your site. Joomla goes a long way in doing this for you when used correctly.
Using keywords in the actual link title (anchor text) will help improve rankings.

Your site structure starts with your content management - this should be structured according to your website function. A news website might categorise based on the topic (e.g. technology, business, world, etc) but a sports news website might categorise based on sport (e.g. Football, Rugby, Hockey, Cycling).

This is a critical factor in creating your website, and if used properly can have huge implications with regards to your search engine optimisation - as you can use your category name in your Search Engine Friendly URL's.

Once you have defined your content structure, the next step is to create a sitemap - even if it's on the back of a napkin - to identify what your 'top level' menu items will be, and any sub-items under them. This helps you to form an idea of how the visitor will browse your website.

If you are using sub-menus as drop-downs, it is sensible to use text separators at your top level, and the top level for any child menu items - this ensures that users who have touch-screen devices, or those using speech control, can easily click or hover over the top item, and have the sub-menu items display without being directed to a new page before having a chance to select a sub-menu item.

Website navigation is all about improving how users find content in your website. The easier users can find information on your site, the easier search engines will too.

== Have an HTML Sitemap ==
{{review}}
An HTML sitemap is essentially a table of contents for your site. This serves two purposes:

# It provides a place where visitors can go to easily get to any content on your site, even if it isn't necessarily easy to access by other navigation aids on the site.
# It provides a centralized store of links to the content on your site that can be easily indexed by search engines.
# It allows users with disabilities to be able to quickly navigate your website with a simple list of links, rather than through complex menus

At the very least, a sitemap should link to the main sections and pages within your site, but the more detailed you can make it, the better.

There are available extensions that create sitemaps automatically based on Joomla content.

== Have an XML Sitemap ==
Sitemaps are an easy way for webmasters to inform search engines about pages on their sites that are available for crawling. In its simplest form, a Sitemap is an XML file that lists URLs for a site along with additional metadata about each URL (when it was last updated, how often it usually changes, and how important it is, relative to other URLs in the site) so that search engines can more intelligently crawl the site.

Web crawlers usually discover pages from links within the site and from other sites. Sitemaps supplement this data to allow crawlers that support Sitemaps to pick up all URLs in the Sitemap and learn about those URLs using the associated metadata. Using the Sitemap protocol does not guarantee that web pages are included in search engines, but provides hints for web crawlers to do a better job of crawling your site.

# An XML sitemap provides a list of links to the content on your site that can be easily indexed by search engines.
# It is possible to create specific sitemaps for News, Images, Multimedia.

There are available extensions that create XML sitemaps automatically based on Joomla content.
[http://sitemaps.org/protocol.php More about the Sitemap protocol]

== Things to Remember ==
{{review|section}}

There are perhaps a few basic points that readers should away;

* Anything that requires a login will not be 'seen' by a search engine (though some search engines will allow you to tell them how to bypass these).
* This article only just starts to scrape the surface.
* Frequent maintenance and updates are a big part of Search Engine Optimization (SEO).
* SEO is only the start - it might help people find your site through search engines but you've got to work out how to get them to stay or come back or use your site.

Search Engine Optimization is an ongoing task, the 'rules' used change frequently and simply undertaking SEO work once wont guarantee you a high ranking. Unique content is important, but so is site navigation. If a search engine finds it difficult to navigate your site (e.g. needs 7 'clicks' to reach an article) it will assume that real users will encounter similar difficulties. Sitemaps can help with this issue tremendously.

Although Search Engine Optimization is important, focusing on the basic elements of the user experience (easy navigation paths, unique and compelling content etc.) is often one of the best ways to ensure a higher ranking. Simple steps like ensuring appropriate Meta Keywords and Internal links will help to improve that experience further.

[[Category:Search Engine Optimization]]

Archived:Creating a Custom 404 Error

2013-03-15T00:17:27Z

Samwilsonau: /* Additional Steps Toward a Better Custom 404 Error Page */ Link.

This tutorial will show you how to create a custom 404 error page for use in your Joomla Webssite.

== Four Steps to Creating a Custom 404 Error Page ==
# '''Create an Uncategorized '404' Article'''
#: Create an 'uncategorized' article in Joomla! to serve as your 404 Page. Include some text such as ''Sorry, we could not find the page you were looking for...'' and if necessary, also any useful navigational links. For example, you may wish to add a link back to your site's home page.
# '''Create and copy a link to that new 404 Article.'''
#: Create a menu item which links to the new 404 Article and 'apply' your changes. Then copy the URL information (index.php?optio...), set the menu item as 'unpublished' and close out of the menu editing page. You may want to paste the copied URL into Notepad or somewhere accessible for the time-being.
# '''Copy error.php to your Template's Directory'''
#: In your Joomla! installation copy the file error.php from the templates/system directory, to your Template directory. For example, if I was using a template named 'Cleancloud' I would copy the error.php file to the templates/cleancloud directory.
# '''Modify error.php to Redirect 404 Errors to your 404 Article '''
#: Edit the error.php file as follows, adding the code below immediately under the 'restricted access' line:
<source lang="php">
if (($this->error->code) == '404') {
header('Location: /index.php?option=com_content&view=article&id=75');
exit;
}
</source>
If you are using Joomla 1.6, 1.7 and 2.5, use this detection code instead:
<source lang="php">
if (($this->error->getCode()) == '404') {
</source>
Replace the location information (index.php?option..) with the URL from the menu item you created.

== Additional Steps Toward a Better Custom 404 Error Page ==
* Add the following line to the [[robots.txt file|robots.txt]] file located in the root directory of your Joomla! installation.
*: <code>Disallow: /index.php?option=com_content&view=article&id=75</code>
* Replacing the (index.php?option..) location with your 404 Article URL.
* Follow the Best-Practices described here: http://www.alistapart.com/articles/perfect404/
* Be creative, add a [http://www.geekhaiku.com/tag/404/ 404 Haiku] or maybe an [http://www.smashingmagazine.com/2007/08/17/404-error-pages-reloaded Interesting Photo]

== More Custom Error Page Information ==
* [[Custom_error_pages|Custom Error Pages]]
* [[System_error_pages|System Error Pages]]
* [http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html HTTP/1.1 Status Code Definitions]
* [http://www.google.com/support/webmasters/bin/answer.py?answer=83040&topic=8474 Google Webmaster - Analyzing Crawl Errors]

[[Category:Tutorials]]

Robots.txt file

2013-03-15T00:11:23Z

Samwilsonau: Some formatting etc.

{{RightTOC}}
{{review}}
Web Robots (Crawlers, Web Wanderers or Spiders) are programs that traverse the Web automatically. Among many uses, search engines use them to index the web content.
Robots.txt implements the REP ([[wp:Robots exclusion standard|Robots Exclusion Protocol]]), which allows the web site administrator to define what parts of the site are off-limits to specific robot user agent names. Web administrators can Allow access to their web content and Disallow access to cgi, private and temporary directories, for example, if they do not want pages in those areas indexed.

==Where to place my robots.txt file?==
A standard robots.txt its included in your joomla root.
The robots.txt file must reside in the root of the domain or subdomain and must be named <code>robots.txt</code>.

===Joomla in a subdirectory===
A robots.txt file located in a subdirectory isn't valid, as bots only check for this file in the root of the domain.
If the Joomla site is installed within a folder such as at e.g. <code>example.com/joomla/</code> the robots.txt file MUST be moved to the site root at e.g. <code>example.com/robots.txt</code>.
Note: The joomla folder name MUST be prefixed to the disallowed path, e.g. the Disallow rule for the <code>/administrator/</code> folder MUST be changed to read <code>Disallow: /joomla/administrator/</code>

==Joomla robots.txt contents==
This is the contents of a [https://github.com/joomla/joomla-cms/blob/master/robots.txt standard Joomla robots.txt]:

<source lang="text">
User-agent: *
Disallow: /administrator/
Disallow: /cache/
Disallow: /cli/
Disallow: /components/
Disallow: /images/
Disallow: /includes/
Disallow: /installation/
Disallow: /language/
Disallow: /libraries/
Disallow: /logs/
Disallow: /media/
Disallow: /modules/
Disallow: /plugins/
Disallow: /templates/
Disallow: /tmp/
</source>

==Robot exclusion==
You can exclude directories or block robots from your site adding Disallow rule to robots.txt. E.g. to prevent any robots from visiting the <code>/tmp</code> directory, add the following rule:

<source lang="text">
Disallow: /tmp/
</source>

See also:
* [http://www.robotstxt.org/wc/robots.html A Standard for Robot Exclusion] — specification of the robots.txt standard
* [http://support.google.com/webmasters/bin/answer.py?hl=en-GB&answer=156449 Block or remove pages using a robots.txt file]

==Syntax checking==
For syntax checking you can use a validator for robots.txt files.
Try one of these:
* [http://tool.motoricerca.info/robots-checker.phtml Robots.txt Checker (by Motoricerca)]
* [http://www.frobee.com/robots-txt-check Robots.txt Checker (by Frobee)]
* [http://www.searchenginepromotionhelp.com/m/robots-text-tester/robots-checker.php robots.txt Checker (by Search Engine Promotion Help)]

== See also ==

For additional information please read:

=== Joomla! Documentation ===
* [[Creating a Custom 404 Error Page]]
* [[Custom error pages]]
* [[System error pages]]
* [[Making your site Search Engine Friendly]]
* [[Entering search engine meta-data]]

=== How to: Robots.txt and Joomla ===
* [http://www.kangainternet.com.au/joomla-seo-blog/joomla-google-the-robots.txt-file.html Joomla & Google Robots Text File]
* [http://www.joomlablogger.net/seo/joomla-seo/how-to-set-up-the-robotstxt-file-in-joomla How to set up the robots.txt file in Joomla]

=== General information ===
* http://www.robotstxt.org/ — main website for robots.txt
* [http://www.robotstxt.org/wc/robots.html A Standard for Robot Exclusion] — specification of the robots.txt standard
* [https://developers.google.com/webmasters/control-crawl-index/docs/robots_meta_tag Robots meta tag and X-Robots-Tag HTTP header specifications]
* [http://www.searchtools.com/robots/robots-txt.html Robots.txt and Search Indexing]

=== Tools for Webmasters ===
* [https://www.google.com/webmasters/tools Google Webmaster Tools]

[[Category:Search Engine Optimization]]

User:Samwilsonau

2013-03-15T00:05:38Z

Samwilsonau: Updated with link.

My personal website: http://samwilson.id.au/

Robots.txt file

2013-03-14T23:20:09Z

Samwilsonau: /* Joomla in a subdomain */ Subdirectory, not subdomain.

{{RightTOC}}
{{review}}
Web Robots (Crawlers, Web Wanderers or Spiders) are programs that traverse the Web automatically. Among many uses, search engines use them to index the web content.
Robots.txt implements the REP (Robots Exclusion Protocol), which allows the web site administrator to define what parts of the site are off-limits to specific robot user agent names. Web administrators can Allow access to their web content and Disallow access to cgi, private and temporary directories, for example, if they do not want pages in those areas indexed.

==Where to place my robots.txt file?==
A standard robots.txt its included in your joomla root.
The robots.txt file must reside in the root of the domain and must be named "robots.txt".

===Joomla in a subdirectory===
A robots.txt file located in a subdirectory isn't valid, as bots only check for this file in the root of the domain.
If the Joomla site is installed within a folder such as at e.g. <code>example.com/joomla/</code> the robots.txt file MUST be moved to the site root at e.g. <code>example.com/robots.txt</code>.
Note: The joomla folder name MUST be prefixed to the disallowed path, e.g. the Disallow rule for the <code>/administrator/</code> folder MUST be changed to read <code>Disallow: /joomla/administrator/</code>

==Joomla robots.txt contents==
This is the contents of a standard Joomla robots.txt

<source lang="php">
User-agent: *
Disallow: /administrator/
Disallow: /cache/
Disallow: /cli/
Disallow: /components/
Disallow: /images/
Disallow: /includes/
Disallow: /installation/
Disallow: /language/
Disallow: /libraries/
Disallow: /logs/
Disallow: /media/
Disallow: /modules/
Disallow: /plugins/
Disallow: /templates/
Disallow: /tmp/
</source>

==Robot Exclusion==
You can exclude directories or block robots from your site adding Disallow rule to the robots.txt

Infos:
* [http://www.robotstxt.org/orig.html A Standard for Robot Exclusion]
* [http://support.google.com/webmasters/bin/answer.py?hl=en-GB&answer=156449 Block or remove pages using a robots.txt file]

==Syntax checking==
For syntax checking you can use a validator for robots.txt files.
Try one of these:
* [http://tool.motoricerca.info/robots-checker.phtml Robots.txt Checker (by Motoricerca)]
* [http://www.frobee.com/robots-txt-check Robots.txt Checker (by Frobee)]
* [http://www.searchenginepromotionhelp.com/m/robots-text-tester/robots-checker.php robots.txt Checker (by Search Engine Promotion Help)]

==Infos==
For additional infos please read:
===Joomla! Documentation===
* [[Creating_a_Custom_404_Error_Page|Creating a Custom 404 Error Page]]
* [[Custom_error_pages|Custom Error Pages]]
* [[System_error_pages|System Error Pages]]
* [[Making_your_site_Search_Engine_Friendly|Making your site Search Engine Friendly]]
* [[Entering_search_engine_meta-data|Entering search engine meta-data]]

===How to: Robots.txt and Joomla===
* [http://www.kangainternet.com.au/joomla-seo-blog/joomla-google-the-robots.txt-file.html Joomla & Google Robots Text File]
* [http://www.joomlablogger.net/seo/joomla-seo/how-to-set-up-the-robotstxt-file-in-joomla How to set up the robots.txt file in Joomla]

===General informations===
* [http://www.robotstxt.org/orig.html The Web Robots Pages]
* [https://developers.google.com/webmasters/control-crawl-index/docs/robots_meta_tag Robots meta tag and X-Robots-Tag HTTP header specifications]
* [http://www.searchtools.com/robots/robots-txt.html Robots.txt and Search Indexing]

===Tools for Webmasters===
* [https://www.google.com/webmasters/tools Google Webmaster Tools]

[[Category:Search Engine Optimization]]

J3.x:Developing an MVC Component

2013-03-14T07:14:28Z

Samwilsonau: Copyedit.

{{version/tutor|3.0|alt=1.5,1.6,1.7,2.5|altlink=Developing a Model-View-Controller Component|alttitle=these guides!}}
{{Chunk:Developing a Model-View-Controller (MVC) Component for Joomla!3.0 - Contents}}
This is a multiple-article series of tutorials on how to develop a Model-View-Contoller [[Component]] for Joomla! Version {{JVer|3.0}}.

Begin with the [[Developing a Model-View-Controller Component/3.0/Introduction|Introduction]], and navigate the articles in this series by using the navigation box to the right (the ''Articles in this series'').

Chunk:Developing a Model-View-Controller (MVC) Component for Joomla!3.1 - Contents

2013-03-14T07:12:06Z

Samwilsonau: Added 'Developing a Basic Component'.

{{Navbox
|style = float:right; width:200px; margin-left: 10px;
|name = Developing a MVC 3.0
|state = off
|navbar = off
|title = Developing an MVC Component in {{JVer|3.0}}
|titlestyle = font-weight:bold; font-size:1.10em;
|above = __TOC__
|abovestyle = width:200px; background-color:darkgray;
|list1 = {{Navbox|child
|style = width:99%; max-width:220px;
|name = Joomla! MVC 3.0 Screen child
|state = off
|navbar = off
|title = ''Articles in this series''
|titlestyle = font-weight:bold; font-size:.90em; width:99%;
|list1 =
* [[Developing a Model-View-Controller Component/3.0/Introduction|Introduction]]
* [[Developing a Model-View-Controller Component/3.0/Developing a Basic Component|Developing a Basic Component]]
|list1style = background-color: cornsilk; padding:2px; font-size:.92em; text-align:left; width:100%;
}}
}}
<includeonly>[[Category:Tutorials in a Series]]</includeonly>
<noinclude>[[Category:Tutorial Series Templates]]</noinclude>

J3.x:Developing an MVC Component/Developing a Basic Component

2013-03-14T07:03:33Z

Samwilsonau: First draft.

{{:Developing a Model-View-Controller Component/3.0}}

= Developing a Basic Component =

This page goes through the basic steps required to make the simplest possible component that will output ''Hello, world!'' to the [[Site (Application)|front-end]] of a Joomla!{{JVer|3.0}} website.

== Main Output ==

First set up the basic public output for this component. Create <code>yoursite/components/com_helloworld/helloworld.php</code> with the following contents:

<source lang="php">
<?php

echo 'Hello world';
</source>

== Manifest file ==

Every extension needs a [[manifest files|manifest file]] that specifies installation and configuration information for the extension. The manifest file is named <code>''componentname''.xml</code>. For a simple component we need only include a minimal number of the possible elements in this XML file.

Create <code>helloworld.xml</code> in the same directory as your <code>helloworld.php</code> above, with the following contents:

<source lang="xml">
<?xml version="1.0" encoding="utf-8"?>
<extension type="component" version="3.0" method="upgrade">
<name>Hello World!</name>
</extension>
</source>

Note that the <code>name</code> element is actually optional, but it makes for easier identification in the next step.

== Installation ==

Next, we need to tell Joomla! to 'discover' this new component, so that it can be installed and used. This is done by going to the ''Extension Manager -> Discover'' and clicking 'Discover' in the toolbar. This will scan the <code>components</code> directory (amongst others), looking for components that have not yet been installed.

The new component should be listed in the resulting table, and to install it you just select it (with the checkbox) and click 'Install' in the toolbar.

Note: Don't worry about the message ''"Component Install: The XML file did not contain an administration element"'', as our component does not yet have any [[Administrator (Application)|administration]] features. We'll add these later in the tutorial.

== Hello, world! ==

You can now see the basic component in action, by navigating to <code><nowiki>http://localhost/joomla/index.php?option=com_helloworld</nowiki></code> (replacing <code>localhost/joomla</code> with your own installation location).

[[Category:Component Development]]
[[Category:Joomla! 3.0]]

User:Samwilsonau

2013-03-14T04:53:35Z

Samwilsonau: Link to my site.

My personal website is at <code>samwilson dot id dot au</code> (spam-filter here won't let me post a link).

Setting up a directory structure

2013-03-14T03:54:26Z

Samwilsonau: Code tag typo.

To make the most basic template, '''create a new folder''' in the <tt>''templates''</tt> folder. Name this folder after your template i.e. <tt>''mynewtemplate''</tt>.

Using a [[wikipedia:Text editor|text editor]] '''create the files <tt>index.php</tt> and <tt>templateDetails.xml</tt>'''.

To keep things organized, make '''2 new folders called <tt>''images''</tt> and <tt>''css''</tt>'''. Inside the <tt>''css''</tt> folder create a file called <tt>template.css</tt>.

Although it is fine to place all your [[CSS]] code directly in your <tt>index.php</tt> file to start, many web developers prefer to place their CSS code in a separate file that can be linked from multiple pages using the <code>link</code> tag. This may also shorten the loading time of your pages, since the separate file can be cached.

This is the most basic practical setup.

Outline of folder and file structure:
* <tt>'''''mynewtemplate/'''''</tt>
** <tt>''css/''</tt>
*** <tt>template.css</tt>
** <tt>''images/''</tt>
** <tt>index.php</tt>
** <tt>templateDetails.xml</tt>