Joomla renowned as one of the platforms Content Management System (CMS) to publish to the World Wide Web or an intranet but other than well-known as CMS, Joomla was also famous as a framework Modelview-controller (MVC) Web Application Development.

In this tutorial will discuss about how to manufacture components for Joomla by using Joomla-Framework v1.5.

OVERVIEW OF THE MVC
MVC is common for web developers, MVC is a software design pattern that is used to organize code in such a way that the business logic and data presentation are separated.

The reason is because the MVC approach if business logic is grouped into one section, then DISPLAY (interface) and USER INTERACTION which depends on the data may be revised or amended WITHOUT should reprogram its business logic.

MVC was originally developed to map the traditional functions of inputs, outputs and processes in architecture logical GUI.
Here are the three main points of Joomla MVC (which probably will make it different from other MVC framework).

MODEL
- Model is part of the component associated with the data.
- The model usually takes the form of a working class, add, modify and delete information in the database.
- Model is usually associated with the data. So if for example we change the system of file-based storage systems into a database-based storage, we only need to replace the coding model, without the need to change the controller or view.

VIEW
- View is part of the functional components that render data from a model that is suitable for interaction.
- For web-based applications, generally the view would be in the form of HTML pages.
- View that will pull data from the model (actually drawn on the controller and then thrown into the View) and provide data to the template (the template will be displayed to the user)
- View is never alter the data, only display data taken from the model.

CONTROLLER
- Controller is responsible for user activity. Especially in the web application form page request (for example, $ _POST or $ _GET).
- Controller to determine what prompted the user request and responds by triggering the model to change the data and send the model to the view so that view can display the data.

To implement MVC in Joomla we use 3 classes: JModel, JView and JController

In addition there are Joomla Model, View and Controller are also known as the Entry Point and Template.

START MAKING COMPONENTS
We will create a component named datadiri. This component is to display the stored personal data in the database.
The following list of files that must be made:
- Com_datadiri / datadiri.php - This is the entry point to get to the components
- Com_datadiri / Controller.php - this is a basic file controller.
- Com_datadiri / views / biodatas / view.html.php - This file is interesting data that is considered important then tossed it into the template.
- Com_datadiri / views / biodatas / tmpl / default.php - This is the template file that is output.
- Datadiri.xml - XML ​​is that determines how Joomla install our component.

YOU SHOULD KNOW:
Entry point name must match the name component.
Underscore have a special meaning in Joomla, so avoid using an underscore in the name.

MAKE ENTRY POINT
Joomla always access through the entry point: index.php for regular site and the administrator / site.php to page administrator.

Applications will load the necessary components in accordance with the value of 'option' in the URL or in POST data. For the URL will be something like: index.php? Option = com_datadiri.
Example file contents com_datadiri / datadiri.php:
Code:

<? Php
defined ('_JEXEC') or die ('Restricted accessed');
require_once (JPATH_COMPONENT.DS. 'Controller.php');
$ Controller = new DatadiriController (); / / create object of DatadiriController
$ Controller-> execute (JRequest:: getVar ('task'));
?>

Initial line, "defined ('_JEXEC') or ..." is a statement for security checks.

JPATH_COMPONENT an absolute path to the component now, in this case komponens / com_datadiri.

DS is the directory separator is '/' if not '\'. It automatically according to the server OS.

JRequest:: getVar () to retrieve data from $ _POST [] or from the $ _GET []. For example, its URL index.php? Task = insert, then we can write JRequest:: getVar ('task') to get the value of the task.

Base controller is located on com_datadiri / Controller.php. If for example one day need an additional controller, then create additional controllers such as 'DatadiriControllerxxx' in com_datadiri / controllers / xxx.php.
Additional controller naming standard: Component {Name} {Controller} {name} Controller

MAKING MODEL
Usually we start the design of the Model.
Here are examples of coding (com_datadiri / models / biodatas.php)

Code:

<? Php
defined ('_JEXEC') or die ('Restricted accessed');
jimport ('joomla.application.komponen.model');
DatadiriModelBiodatas class extends JModel
{
getBiodata function ()
{
$ Db = & JFactory:: getDBO ();
$ Query = "SELECT name, value FROM jos_datadiri";
$ Db-> setQuery ($ query);
$ Result = $ db-> loadRowList ();
return $ results;
}
}
?>

jimport is a function whose purpose is the same with php include but with several advantages. For example we need to include file joomla / application / component / model.php, then we can write with jimport (joomla.application.komponen.model) where the sign '/' is replaced with a dot (.) And on the back. Php is not necessary written.

Naming System Model: Component {Name} {Model} {name} Model

If we want to access the database then we have to write $ db = & JFactory:: getDBO ();
We use the & so that only her reference. Because if we do not use it then he will move all data into a variable, and it is very time consuming.

To perform the Select query we use $ db-> setQuery ()
To query the Insert, Update or Delete then we must use $ db-> execute ()
To retrieve the query results there are many ways that is, $ db-> loadResult (), $ db-> loadRowList () and others.
$ Db-> loadRowList () to retrieve all the rows the query results.

THE MAKING OF VIEW
Here are examples of coding (com_datadiri / views / biodatas / view.html.php):

Code:

<? Php
defined ('_JEXEC') or die ('Restricted Accessed');
jimport ('joomla.application.komponen.view');
DatadiriViewBiodatas class extends JView
{
function display ($ tpl = null)
{
$ Model = & $ this-> getModel ();
$ Biodatas = $ model-> getBiodata ();
$ This-> assignRef ('biodatas', $ biodatas);
parent:: display ($ tpl);
}
}
?>

Default function of View is a display ()

In the $ model = & $ this-> getModel (); might be a bit confusing why we only write the model getModel without mentioning what we want to take (normally the model can be more than one). That's because later in the Controller class then we shall setModel () to class View, so here we stay getModel (). Note the Controller class for more details.

$ This-> assignRef () is a function to cast the variable to the template. For example we write $ this-> assignRef ('biodatas', $ biodatas) then to access it in the template later on we simply write $ this-> biodatas

CREATING A TEMPLATE
Template / layout of Joomla is a PHP file which are used to display data from a View.

Variables are set JView:: assignRef can be accessed by using $ this-> {namaproperty}.

Here are examples of coding:
Code:

<? Php
defined ('_JEXEC') or die ('Restricted Accessed');
?>
<strong> List of Biodatas </ strong>
<ol>
<? Php
foreach ($ this-> biodatas as $ row)
{
echo "<li>". "<strong> '. $ row [0 ].'</ strong >'.'=>'.$ row [1 ]."</ li>";
}
?>
</ Ol>

MAKE CONTROLLER
Here are examples of coding (com_datadiri / Controller.php):

Code:

<? Php
defined ('_JEXEC') or die ('restricted accessed');
jimport ('joomla.application.component.controller');
DatadiriController class extends JController
{
function display ()
{
$ View = & $ this-> getView ('biodatas', 'html');
$ Model = & $ this-> getModel ('biodatas');
if (! JError:: ISERROR ($ model))
{
$ View-> setModel ($ model, true);
}
$ View-> setLayout ('default');
$ View-> display ();
}
}
?>

JController constructor must always be enrolled function display () as the default unless you specify other functions by using the method registerDefaultTask ().

Controller that perform load class View and Model classes.

To load the View, use $ this-> getView (nama_view {}, 'html'}

To load the model, using $ this-> getModel (nama_module {}}

$ View-> setLayout () is a function determining the layout, ie how the View displays its data.

To display the View that you created, we shall write $ view-> display ()

Presented in this tutorial is only the basic concept of MVC using Joomla and applied to the Site (front-end page, a visitor sees). If for example you want to use the Administrator (back-end page, the admin) is actually the same, with a record of its component folders are placed in a folder administrator.

Do you like this article? Share It!