Magento 1.8 Development Cookbook

Magento 1.8 Development Cookbook

By : Bart Delvaux, Nurul Ferdous

Buy this Book

Magento 1.8 Development Cookbook

By: Bart Delvaux, Nurul Ferdous

Buy this Book

Overview of this book

Magento is an open source e-commerce platform which has all the functionality to function from small to large online stores. Its architecture makes it possible to extend the functionalities with plugins where a lot of them are shared by the community. This is the reason why the platform is liked by developers and retailers. A practical developer guide packed with recipes that cover all the parts of Magento development. The recipes will start with the simple development exercises and get the more advanced as the book progresses. A good reference for every Magento developer! This book starts with the basics. The first thing is to create a test environment. Next, the architecture, tools, files and other basics are described to make you ready for the real work. The real work starts with the simple things like theming and catalog configuration. When you are familiar with this, we will move on to more complex features such as module and database development. When you have survived this, we will move on to the last part of making a shop ready for launch: performance optimization and testing. This book will guide you through all the development phases of Magento, covering the most common pitfalls through its recipes.

Magento 1.8 Development Cookbook

Credits

About the Author

About the Reviewers

www.PacktPub.com

Preface

Free Chapter

Getting Started with Magento

Introduction

Preparing the development environment

Installing Magento with sample data

Adding version control to the source code

Configuring the development tools

Theming

Introduction

Configuring Magento themes and packages

Creating your first theme

Adding extra files to your theme

Adding jQuery support

Changing a page title

Working with translations

Understanding the theming block system

Adding widgets to the layout

Working with Products

Introduction

Setting up the catalog defaults

Working with attribute sets

Working with product types

Adding a Facebook like button

Adding a product to the cart through querystring

Embedding a YouTube video

Changing the URL of a product page

Creating a Module

Introduction

Creating files

Registering blocks, helpers, and models

Adding a new page

Adding a layout file

Adding a translation file

Adding a block of new products

Rewriting a core class

Database Concepts

Introduction

Finding your way in the tables

Creating a database connection in Magento

Working with flat tables

Working with EAV tables

Configuring a Master/Slave setup

Repairing the database

Databases and Modules

Introduction

Registering the resource models

Registering connections

Installing and upgrading scripts

Creating a flat table with models

Working with Magento collections

Magento Backend

Introduction

Registering a backend controller

Extending the menu

Adding an ACL

Extending the system configuration

Creating a grid from a database table

Adding customer attributes

Working with source models

Event Handlers and Cronjobs

Introduction

Understanding Magento event types

Creating your own event

Adding an event observer

Introducing cronjobs

Creating a new cronjob

Testing your new cronjob

Creating a Shipping Module

Introduction

Initializing module configurations

Writing an adapter model

Extending the shipping method features

Adding the module in the frontend

Creating a Product Slider Widget

Introduction

Creating an empty module

Registering helpers and blocks

Creating a widget configuration file

Creating a block and the template files

Creating a custom configuration parameter

Finalizing the theming

Performance Optimization

Introduction

Exploring the limits of a website

Optimizing the database and MySQL configuration

Optimizing the Apache web server

Tuning the Magento configurations

Configuring APC and Memcached

Optimizing the PHP configurations

Analyzing the page speed

Debugging and Unit Testing

Introduction

Getting started with Xdebug

Debugging with FirePHP

Installing PHPUnit

Creating a Magento test case

Index

Customer Reviews

5 star

4 star

3 star

2 star

1 star

Adding version control to the source code

With version control, you can manage the changes that are made in the computer files. When you add this to a programming code, you can track all the changes you have made to the code from the time you initialized it. There are some very popular version control systems on the market, such as Subversion (SVN), Mercurial SCM, CVS, and Git SCM.

In this recipe, we will use Git SCM to add version control to our previously created Magento code. We will initialize an empty repository. After that, we will do several commits to add all the Magento code to the repository.

Getting ready

Go to your command line, and install Git on your local server by running the following command in the terminal:

sudo apt-get install git

How to do it...

The following steps show you how you can add the Magento code to the version control system Git:

We have to initialize the Git repository. To do this, navigate to the source folder and enter the following command:
```
git init
```
Run the following command and you will see that all the files are marked as untracked:
```
git status
```
In the next steps, we will add the other folders to the repository.
Add the app/ folder to the repository by running the following command:
```
git add app/ 
```
This will add all the files in the app/ directory. When you run the git status command, you will see a list of all the files.
Run the following command to remove the local.xml file from the repository but not from the drive:
```
git rm --cached app/etc/local.xml
```
Run the following command to create the first commit:
```
git commit –m "add app folder"
```
Run the following command to track the file's status:
```
git status
```
Create a .gitignore file in the root, and add the following content in it:
```
app/etc/local.xml
```
Run the git status command again, and you will see that local.xml is ignored.
Commit the .gitignore file by running the following command:
```
git commit .gitignore –m "add gitignore file"
```
Add the other application files and folders to the repository by running the command git add <folder or filename>. Run this command for the following folders:
- downloader (for installing plugins)
- errors (configuration about error handling)
- js (the JS library folder)
- lib (contains PHP libraries)
- pkginfo (information about upgrades)
- shell/ (contains PHP CLI scripts)
- skin/ (the CSS and images folder)
- api.php
- cron.php
- cron.sh
- favicon.ico
- get.php
- index.php
- index.php.sample
- install.php
- LICENCE_AFL.txt
- LICENCE.html
- LICENCE.txt
- mage
- php.ini.sample
- RELEASE_NOTES.txt
Run a new git commit command:
```
git commit –m "add additional files"
```

Ignore the other nonstatic Magento files and folders. Add the following content in the .gitignore file:

/app/etc/local.xml

/errors/local.xml

/media/css/
/media/dhl
/media/downloadable
/media/import/
/media/js/
/media/catalog/
/media/customer
/media/upload/
/media/wysiwyg/
/media/captcha/
/media/tmp/
/media/xmlconnect

/var/import/
/var/export/
/var/cache/
/var/log/
/var/session/
/var/locks/
/var/package
/var/report/
/var/resource_config.json

sitemap.xml

Add the media/ and var/ folders to the repository with the following command:
```
git add media/.htaccess
git add var/.htaccess
```
We only need the .htaccess files, the other files are ignored because they are dynamic.

How it works...

When working with a version control system, you have to keep in mind that another person who clones the project can set up the environment with a database and the code in the Git. That environment has to be the same as the one you have committed.

It is very important that every Magento core file and your customized files are in the Git repository. You don't have to add configuration files, such as app/etc/local.xml and errors/local.xml, in version control. When running your code on another server, the settings in the configuration files are mostly different from the settings on the server.

Dynamically generated files such as cache files and user images are stored in the media and var folder, so we don't need the content of these folders.

The only important file in these folders is the .htaccess file, which has the configuration to restrict the var folder and the media folder.

Magento 1.8 Development Cookbook

By : Bart Delvaux, Nurul Ferdous

Magento 1.8 Development Cookbook

By: Bart Delvaux, Nurul Ferdous

Overview of this book

Related Content you might be interested in

Current Title:

Magento 1.8 Development Cookbook

Adding version control to the source code

Getting ready

How to do it...

How it works...