How to develop custom writing modules for Magento 1.x version?

本文共计2723个文字，预计阅读时间需要11分钟。

Writing Magento Modules

Creating Magento modules is a crucial skill for developers working with the Magento e-commerce platform. This guide will walk you through the basics of writing Magento modules, from setting up your development environment to writing module code and deploying it to a Magento store.

1. Setting Up Development Environment

Before you start writing modules, ensure you have a proper development environment. Here's a step-by-step guide:

1. Install Magento: Download and install the latest version of Magento from the official website.

2.Install a Code Editor: Choose a code editor like Visual Studio Code, Sublime Text, or Atom.

3.Install Composer: Magento requires Composer for dependency management. Install it globally or via your project's root directory.

4.Create a Local Development Copy: Clone your Magento store to a local development machine.

2. Understanding Module Structure

A Magento module consists of several components, including:

- Module Name: The name of your module (e.g., `Vendor_Module`).

- Module Directory: The directory where your module code is stored.- Module Configuration: Configuration files that define how your module interacts with the system.- Block Files: PHP classes that extend Magento's block classes to create custom views.- Controller Files: PHP classes that extend Magento's controller classes to handle requests.- Model Files: PHP classes that extend Magento's model classes to handle data access and business logic.

3. Creating a Basic Module

To create a basic module, follow these steps:

1. Create a Module Directory: In your Magento root directory, create a new directory with your module name (e.g., `Vendor_Module`).

2.Add Module Information: Inside the module directory, create a file named `module.xml`. This file contains metadata about your module, such as its name, version, and description.

xml

1.0.0

3. Add Module Declaration: In the `app/code/Vendor/Module/etc/module.xml` file, declare your module.

xml

4. Create Module Files: Inside your module directory, create the necessary files and folders (e.g., `Block`, `Controller`, `Model`, etc.).

4. Writing Module Code

Now that you have a basic module structure, you can start writing code for your module.

4.1. Blocks

Blocks are PHP classes that extend Magento's block classes to create custom views. For example, to create a custom product view block, you can do the following:

1. Create a new file named `view.p` inside the `Block` directory.

2.Add your custom HTML and PHP code to the `view.p` file.

php

escapeHtml($block->getProductName()); ?>

3. Extend the `Magento\Catalog\Block\Product\View` class in your module's `Block\Catalog\Product\View` class.

php

class View extends \Magento\Catalog\Block\Product\View{ // Add custom code here}

4.2. Controllers

Controllers are PHP classes that extend Magento's controller classes to handle requests. For example, to create a custom controller that displays a product page, you can do the following:

1. Create a new file named `IndexController.php` inside the `Controller` directory.

2.Extend the `Magento\Catalog\Controller\Product\View\Action` class in your module's `Controller\Catalog\Product\View\Action` class.

php

class IndexController extends \Magento\Catalog\Controller\Product\View\Action{ // Add custom code here}

3. Define the route for your controller in the `etc/routes.xml` file.

xml

5. Deploying Your Module

Once you've finished writing your module, you can deploy it to your Magento store:

1. Test Your Module: Make sure your module works correctly on your local development environment.

2.Commit Changes: Commit your changes to your version control system (e.g., Git).

3.Deploy to Production: Use Composer to install your module on your live Magento store.

bash

composer require vendor/module:dev-master

By following these steps, you can create and deploy your own Magento modules to extend the functionality of your e-commerce store.

WritingMagentoModules.md

# Writing Magento Modules All custom modules should have a **Namespace** and **Module Name**. These are used below as `{Namespace}` and `{Module}`. > **Caution:** The Magento autoloader is known to have problems with CamelCase namespaces and/or modules between Windows and *nix systems. If your module requires more than one word for either of these, it is best to just concatenate them to avoid any issues (Example: `{Namespace}_{Examplemodule}`). ## Index * [Directory Structure](#directory_structure) * [Setup](#setup) * [Tell Magento how to load your module](#step1) * [Create your module's configuration](#step2) * [Create your module's administration settings](#step3) (optional) * [Write your module classes](#classes) * [Blocks](#blocks) * [Controllers](#controllers) * [Frontend](#frontend) * [Backend (Admin)](#backend) * [Helpers](#helpers) * [Models](#models) * [Data Models](#data) * [Resource Models](#resource) * [Observers](#observers) * [Extending Magento classes](#extending) * [Tips](#tips) ## Standard Directory Structure > **Note:** Not all paths are required (`app/design`, `skin`), only implement the ones you need. ```python +-app | +-code | | +-local | | +-{Namespace} | | +-{Module} | | +-Block | | | +-Adminhtml | | +-controllers | | | +-Adminhtml | | | | +-{ControllerName}Controller.php # Backend controller | | | +-{ControllerName}Controller.php # Frontend controller | | +-etc | | | +-adminhtml.xml # Admin ACL and other settings | | | +-config.xml # Configuration settings for your module | | | +-system.xml # Administration settings and form options | | +-Helper | | | +-Data.php | | +-Model | | | +-Resource | | | | +-{EntityName} | | | | | +-Collection.php # Collection model for {entity} | | | | +-{EntityName}.php # Resource model for {entity} | | | +-Observer.php # Used for subscribing to Magento events | | | +-{EntityName}.php # Data model for {entity} | | +-sql | | | +-{namespace}_{module}_setup | | | +-mysql4-install-{X}.{X}.{X}.php | | | +-mysql4-upgrade-{X}.{X}.{X}-{X}.{X}.{X}.php | | +-Test | +-design | | +-adminhtml | | | +-default | | | +-default | | | +-layout | | | | +-{namespace} | | | | +-{module}.xml | | | +-template | | | +-{namespace} | | | +-{module} | | +-frontend | | +-base | | +-default | | +-layout | | | +-{namespace} | | | +-{module}.xml | | +-template | | +-{namespace} | | +-{module} | +-etc | +-modules | +-{Namespace}_{Module}.xml +-skin +-adminhtml | +-default | +-default | +-css | | +-{namespace} | | +-{module} | +-images | | +-{namespace} | | +-{module} | +-js | +-{namespace} | +-{module} +-frontend +-base +-default +-css | +-{namespace} | +-{module} +-images | +-{namespace} | +-{module} +-js +-{namespace} +-{module} ``` ## Setup ### 1. Tell Magento how to load your module Magento needs to know that it should load your module and where to find it. For this, create an XML file under `app/etc/modules/{Namespace}_{Module}.xml`: ```xml <{Namespace}_{Example}> true local ``` The ` ` block above is for illustrative purposes only. If your module requires others to be loaded before it, list them under ` ` - otherwise you can remove it or replace it with an empty node (` `). ### 2. Create your module's configuration Create your module's `config.xml` under `app/code/local/{Namespace}/{Module}/etc`. Again, not all sections are required and it will greatly depend on your module and what it needs - however, this example covers the most common use cases: ```xml <{Namespace}_{Example}> {X}.{X}.{X} <{namespace}_{module}> {Namespace}_{Example}_Block <{namespace}_{module}> {Namespace}_{Example}_Helper <{namespace}_{module}> {Namespace}_{Example}_Model {namespace}_{module}_resource <{namespace}_{module}_resource> {Namespace}_{Example}_Model_Resource <{entity_name}}> {namespace}_{module}_{table_name} <{namespace}_{module}_setup> {Namespace}_{Example} core_setup <{namespace}_{module}_write> core_write <{namespace}_{module}_read> core_read <{event_name}> <{namespace}_{module}_{event_name}> model {namespace}_{module}/observer {methodName} <{namespace}_{module} before="Mage_Adminhtml">{Namespace}_{Example}_Adminhtml <{namespace}_{module}> {namespace}/{module}.xml <{namespace}_{module}> standard {Namespace}_{Example} {namespace} <{namespace}_{module}> {namespace}/{module}.xml <{namespace}_{module}> <{group_name}> 0 0 <{namespace}_{module}_{job_name}> * * * * * {namespace}_{module}/observer::{methodName} ``` The comments above should explain which sections can be removed if your module does not require/need them. > **Note:** Be sure to replace `{X}.{X}.{X}` with your module's version number (Example: `1.0.0`). This number is stored in the database table `core_resource` and is also used for running module setup scripts under `app/code/local/{Namespace}/{Module}/sql/{namespace}_{module}_setup`. ### 3. Create your module's administration settings (optional) Create the file `system.xml` under `app/code/local/{Namespace}/{Module}/etc`. Within this file you can define custom admin configuration tabs, admin settings, etc. Two example settings are included below (`enabled` and `debug`) which provide simple on/off settings in the Magento administration interface. ```xml <{namespace}_{module} translate="label" module="{namespace}_{module}"> {Namespace} 300 <{namespace}_{module} translate="label" module="{namespace}_{module}"> {Section Label Text} {namespace}_{module} 1 1 1 1 <{group_name} translate="label"> {Group Label Text} 1 1 1 1 Enable Module select adminhtml/system_config_source_yesno 1 1 0 0 1 Debug select adminhtml/system_config_source_enabledisable 2 1 0 0 ``` > **Note:** Each setting relates to the ` ` key in `config.xml` - which specifies that setting's default value. In order for the settings to show up/work - you must also create ACL rules for your new admin config section. For that, we need to create `adminhtml.xml` under `app/code/local/{Namespace}/{Module}/etc`. ```xml <{namespace}_{module] translate="title" module="{namespace}_{module]"> 1 ``` > **Note:** For older Magento versions, it is necessary to also specify the above ` ` area under the ` ` section of `config.xml`. ## Write your module classes ### Blocks Blocks control the HTML output of a specific section/area of various pages within Magento. You can create your own blocks but the most common use is to extend another Magento block. ```php getRequest()->getParam('query_parameter', 'Default Value (if not present)'); // Example of getting a URL from the router $url = Mage::app()->getStore()->getUrl('{module}/{controller}'); // Example of performing a redirect $this->_redirectUrl($url); } } ``` #### Backend (Admin) ```php loadLayout() ->_setActiveMenu('{menu_name}') ->_addBreadcrumb( '{Breadcrumb Text}', '{Breadcrumb Text}', // ... ); return $this; } public function {actionName}Action() { $this->_title('{Title Text}'); $this->_initAction()->renderLayout(); // Example of adding a success notice message Mage::getSingleton('adminhtml/session')->addSuccess('{Success Message Text}'); // Example of adding an error notice message Mage::getSingleton('adminhtml/session')->addError('{Error Message Text}'); } } ``` ### Helpers You must create one Helper class, however - it can remain empty. These classes are used for general functions/methods that are required between different class types (Example: retrieving configuration values). ```php **Note:** This class can then be retrieved with: `Mage::helper('{namespace}_{module}')` ### Models Models can be broken into 2 types: [data models](#data) and [resource models](#resource). Resource models control the interaction with the database (MySQL) whereas data models can range in responsibilities but usually manipulate data between controllers and resource models. #### Data Model ```php _init('{namespace}_{module}/{entity_name}'); } } ``` > **Note:** This class can then be retrieved with: `Mage::getModel('{namespace}_{module}/{entity_name}')` #### Resource Model ```php _init('{namespace}_{module}/{entity_name}', '{primary_key}'); } } ``` > **Note:** This class can then be retrieved with: `Mage::getResourceModel('{namespace}_{module}/{entity_name}')` However, it is common practice to retrieve it from the data model instance: `Mage::getModel('{namespace}_{module}/{entity_name}')->getResource()` You can also (optionally) define the Collection class used. The Collection is used to handle many instances of your resource models (saving many rows, retrieving many rows, iterating, etc.). ```php _init('{namespace}_{module}/{entity_name}'); } } ``` > **Note:** This class can then be retrieved from the data modal instance with: `Mage::getModel('{namespace}_{module}/{entity_name}')->getCollection()` #### Observers The easiest and most flexible way of extending Magento features is by listening and responding to events with an observer class. Which events your module listens for is defined in your module's `config.xml`. ```php ``` Here is an example of rewriting `Mage_Core_Model_Email_Template` with `Acme_Custom_Model_Email_Template`: ```xml Acme_Custom_Model_Email_Message ``` > **Caution:** It is important to remember that core Magento modules (those namespaced with `Mage_`) do not require the use of `mage_`. So the example above uses just `core` rather than `mage_core`. ## Tips #### `var_dump()` and Magento Trying to `var_dump()` a Magento class instance will quickly lead to headaches because of circular references. Most Magento classes extend `Varien_Object` and thus expose a `debug()` method which is much better for dumping: ```php debug()); ``` #### Logging The easiest way to write to the system logger (or your own custom log file) is to use the `log()` method exposed by the `Mage` class: ```php