Magento Custom Module Development

Throughout the Post, We’ll refer Magento Community Edition 1.9, though custom module structures are the same in all versions of Magento. Let’s quickly understand the basic structure of Magento.

Whenever you install a fresh Magento, you will notice the following Magento directory structure:

 mage_frsh_install_directory_struct

 

 

 

 

 

Magento MVC architecture

There is main entry point – index.php – from where the whole app will be initialized. Base on the requested URL appropriate controller will be called. Controller defines the pages and load the layout files for those pages. Layout files tells the controllers which block files to use. Block files collect the data from models and helpers files and pass it to templates files. Templates files receive data and render html.

Initially, this may be difficult to understand since it contains a few extra layers. To get more familiar with the flow of control, let’s develop a custom “Hello World” module.
Before Starting With Modules

I am assuming that you already have a working copy of Magento with version 1.9, Disable the cache. To Disable the cache Go to Magento Admin Panel > System > Cache Management > Select all cache type from left side checkboxes > Select Action: disable from right top drop down > click Submit.

The Structure of a Magento Module
Code Pools

Magento contains three type of code pools where the all custom and core modules of Magento are resides.

Core pools contain all the core modules which are by default comes with a Magento installation. These modules are written by Magento developers. It’s recommended not to modify these modules because whenever you will upgrade your Magento installation, all the core modules will be overwritten and your modifications will be lost.
Community pools contain all the modules – that is, custom modules – that are developed by third-party programmers to be installed through Magento Connect. These modules generally extend core modules and offer their own functionality that can often be used anywhere in Magento.
Local pools contain all the custom module that are going to be used for a particular project but are not readled in Magento Connect

Thus, we have two choice of pools: Community or Local. Since we are working on our own project, we are going to use a local pool, though there’s no restriction on using the community pool, either.

Structure

Magento modules consist of the following components:

Blocks contain functions that are used to display data in templates.
Models contain the business logic of modules.
Resource Models contains functions that are used for database interaction.
Controllers defines page layout and blocks files and are loaded when a URL is requested.
etc contains configuration files in XML formats which tells Magento how many files modules have and how the module interacts.
Helpers contain functions that are used for defining common business logic (such as image resize, validation). These functions can used anywhere across the Magento application
sql contains SQL scripts to create, modify, or delete SQL tables.

Module Naming

We need to give a name to our module. Generally, Magento module names are made of two parts: <Namespace>_<Module>. The best practice to give a Magento module a name is choose as an author or a company name and <Module> as a actual module name.

Based on these naming convention, I am giving our module the A2bizz_Mymodule name. We will reference this name throughout this series.

Code Set Up and Configuration

Lets create the directories base on above structure. Go to your Magento installation direction then navigate to app/code/local and create the directories as shown below.

Next, we will configure and activate our module by creating config file A2bizz_Mymodule.xml in the app/etc/modules directory. This directory contains config files for all modules.

<?xml version="1.0"?>
<config>
    <modules>
        <A2bizz_Mymodule>
        <active>true</active>
        <codePool>local</codePool>
        </A2bizz_Mymodule>
    </modules>
</config>

This file will tell Magento about the location of our module. In the active tag, we have specified true to enable our module. If everything is correct thus far, then you will find your module in the Magento Admin Panel > System > Configuration > Advanced > Advanced > Disable Modules Output list. From here you can enable and disable your module.
Getting Started: Development

Next we will create our module configuration file. This file will tell Magento all about our module. This includes how many files our module contains, what type of files (models, helpers, database classes), and so on.

Go to app/code/local/A2bizz/Mymodule/etc and create a config.xml file that will contain following content

<?xml version="1.0"?>
<config
    <modules>
        <A2bizz_Mymodule>
            <version>0.1.0    <!-- Version number of your module -->
        </A2bizz_Mymodule>
    </modules>
    <frontend>
        <routers>
            <mymodule>
                <use>standard</use>
                <args>
                    <module>A2bizz_Mymodule</module>
                    <frontName>mymodule</frontName>
                </args>
            </mymodule>
        </routers>
    </frontend>
</config>

Let’s go through line by line to understand each tag. Here, the first tag is that contains the name and version of our module. The version number is very important when it comes to updating your module update your module.

The tag will tell Magento about the controller dispatched. Inside the tag, we have defined that tells Magento how to access our controllers via the routing mechanism.

In the tag, we have defined module name in tag and frontend name in . By using a frontend name, we can access our module in frontend like yoursitename.com/index.php/mymodule/index.

By calling yoursitename.com/index.php/mymodule or yoursitename.com/index.php/mymodule/index Magento will look for index action of your module’s controller file. As such, we need to create our controller file.

Go to app/code/local/A2bizz/Mymodule/controllers and create file IndexController.php with following content.

Note that each file’s name and class names are case sensitive in Magento It’s very important that you are taking care in naming your work when creating files and classes.

<?php
class A2bizz_Mymodule_IndexController extends Mage_Core_Controller_Front_Action
{
    public function indexAction()
    {
        echo "Hello A2bizz";
    }
}

Now open URL yoursite.com/index.php/mymodule/index it will print “Hello A2bizz”. Awesome – we’re finally done with our first hello world module.
Controller Dispatch

Here we have extend the class Mage_Core_Controller_Front_Action that contains all the methods which are using in routing of url. The Magento class name reflects the location of class file. So the class Mage_Core_Controller_Front_Action resides in location Mage > Core > Controller > Front > Action.php

See the class name of our controller that is A2bizz_Mymodule_IndexController. Magento controller to be named in such a way that it reflects (tag)_(Action Controllername)(keyword Controller).

<module>tag = A2bizz_Mymodule (we have defined this tag in config.xml)
    Action Controllername = Index
    Action controller followed by the Controller keyword

Based on this pattern, the name of our controller is A2bizz_Mymodule_IndexController

Now see the URL pattern which is follow the below route pattern
yoursite.com/index.php/frontendname/actionControllername/actionmethod

 frontendname = mymodule
 actionControllername = Index
 actionmethodname = Index

Based on this URL pattern, our module’s URL is yoursite.com/index.php/mymodule/index/index. You can also access it using yoursite.com/index.php/mymodule because whenever you have not specified an actionController or actionmethod name, Magento loads the index controller and index action by default.

Now let’s create one more action: testAction .

<?php
class A2bizz_Mymodule_IndexController extends Mage_Core_Controller_Front_Action
{
    public function indexAction()
    {
        echo "Hello A2bizz";
    }
    public function testAction()
    {
        echo "test action";
    }
}

We can access the testAction using URL yoursite.com/index.php/mymodule/index/test. As explained earlier here

 frontendname = mymodule
 actionControllername = Index
 actionmethodname = test

This is how the controller works in Magento.

At first, it can be difficult to understand everything at once so We’ve included all of the source code to this module so that you can review it and implement your own work while using it as a guide.