I always forget how to create custom transactional emails, I thought I'd throw a blog post together to remind myself!

## Step 1) Adding your template to `etc/config.xml` to register the email template.

First of all, assuming you already have a basic module setup, add this into `app/code/[codePool]/[Namespace]/[Module]/etc/config.xml`
```xml
<config>
    ...
    <global>
        ...
        <template>
            <email>
                
                <[email_template_name]>
                    <label>[Email Template Label]</label>
                    <file>[email_template_filename].html</file>
                    <type>html</type>
                </[email_template_name]>
            </email>
        </template>
    </global>
</config>
```

## Step 2) Creating your email template!

Awesome, we now have the email template setup, next up we'll need to create the email template itself. This file needs to be saved in `app/locale/[your_locale_or_en_US]/template/email/[email_template_filename].html`. The locale code is important, this allows you to create the email in multiple languages, the default locale in Magento is en_US, so saving there is a good place if you're not sure.

```html

<div style="font:11px/1.35em Verdana, Arial, Helvetica, sans-serif;">
  <table cellspacing="0" cellpadding="0" border="0" width="98%" style="margin-top:10px; font:11px/1.35em Verdana, Arial, Helvetica, sans-serif; margin-bottom:10px;">
    <tr>
      <td align="center" valign="top">
        
          <table cellspacing="0" cellpadding="0" border="0" width="650">
            <tr>
              <td valign="top">
                <p>
                  <a href="{% raw %}{{store url=""}}{% endraw %}" style="color:#1E7EC8;"><img src="{% raw %}{{skin url="images/logo_email.gif" _area='frontend'}}{% endraw %}" alt="Magento" border="0"/></a>
                </p>
              </td>
            </tr>
          </table>
          
          <table cellspacing="0" cellpadding="0" border="0" width="650">
            <tr>
              <td valign="top">
                <p>
                <strong>Dear {% raw %}{{var customer_name}}{% endraw %}</strong>,<br/>
                This is the content of your email!
                </p>
              </td>
            </tr>
          </table>
      </td>
    </tr>
  </table>
</div>
```

Items to note in the above email template:

####Your subject looks like a HTML comment:

    

####Variables!

Since these templates don't support PHP directly, we can use this form accessing variables and objects.

    Get the current stores URL
    {% raw %}{{store url=""}}{% endraw %}

    Get the skin url, accepts a path, in this case it's the logo image.
    {% raw %}{{skin url="images/logo_email.gif"}}{% endraw %}

    Custom variables, as defined by us. We'll cover this shortly!
    {% raw %}{{var customer_name}}{% endraw %}


##Step 3) Sending the email!

We have our email template configured, and recognised by Magento. Now it's time to put it all together and send the email!

```php
<?php

// This is the template name from your etc/config.xml
$template_id = '[email_template_name]';

// Who were sending to...
$email_to = 'demo@example.com';
$customer_name   = 'John Doe';

// Load our template by template_id
$email_template  = Mage::getModel('core/email_template')->loadDefault($template_id);

// Here is where we can define custom variables to go in our email template!
$email_template_variables = array(
    'customer_name' => $customerName
    // Other variables for our email template.
);

// I'm using the Store Name as sender name here.
$sender_name = Mage::getStoreConfig(Mage_Core_Model_Store::XML_PATH_STORE_STORE_NAME);
// I'm using the general store contact here as the sender email.
$sender_email = Mage::getStoreConfig('trans_email/ident_general/email');
$email_template->setSenderName($sender_name);
$email_template->setSenderEmail($sender_email);

//Send the email!
$email_template->send($email_to, $customer_name, $email_template_variables);
?>
```

## Conclusion

And that's it, that is how you send a transactional email in Magento. We can put the code from step 3 in side of a Cron, Observer, or in a custom model to send emails how ever we like. Here are a few use cases:

- Automate getting reviews and feedback from customers
- Abandon cart emails
- Customer assistance (ask if they need any help after browsing the store)
- And many more!

Quick Tip: Sending custom transactional emails in Magento

Ever needed to test a new payment module, or shipping rate? Hate going through the checkout multiple times? Well, I've put together this simple little bookmarklet:

```js
javascript: (function(){
    document.getElementById("login:guest").checked="checked";
    checkout.setMethod();
    document.getElementById("billing:firstname").value="John";
    document.getElementById("billing:lastname").value="Doe";
    document.getElementById("billing:email").value="demo@example.com";
    document.getElementById("billing:company").value="Acme Corp";
    document.getElementById("billing:street1").value="Doe House";
    document.getElementById("billing:street2").value="Doe Road";
    document.getElementById("billing:city").value="Doe Town";
    document.getElementById("billing:region").value="Doe Region";
    document.getElementById("billing:postcode").value="DO33 3OD";
    document.getElementById("billing:telephone").value="12345678901";
    document.getElementById("billing:fax").value="";
    billing.save();
    function waitForBilling() {
        if(checkout.loadWaiting != false){
            return setTimeout(waitForBilling, 50);
        }
        document.getElementsByName("shipping_method")[0].checked="checked";
        shippingMethod.save();
    }
    waitForBilling();
})();
```

To use, simply create a new bookmark, and enter the above code into the URL section of the bookmark and keep the bookmark in your bookmarks toolbar. Now, when you hit the first stage of the onepage checkout, click your bookmarklet. It will populate your fields, and progress you to the payment stage. Easy!

Word of warning: This bookmarklet is not perfect, and feel free to tailor the information contained, this has been put together for UK stores which doesn't require a region (I entered dummy data anyway, but if you are for example a US user, you will need to change this value in relation to the states drop-down menu.)

Other solutions? yes, you could just create an account, and use that. However sometimes we need to test as a guest user.

Don't want to skip shipping methods? Simply remove lines 16 &#8211; 23.


Magento one page checkout bookmarklet

Time and time again I need to create a custom category attribute for a site I'm working on, and each time I search for a good article covering the topic in depth I fall short, and half written and poorly explained versions of how to do exactly this. I've learnt how to do this over time, and now I'll share exactly how to, and also how it works. First of all, I'll show you the code for each file, and explain everything afterwards.

### Lets get going then..

To create a custom attribute we are going to create it as a module, the reason for this is so when we come to install our Magento site on another server, or if our extension we're developing needs to be used on other Magento installs our custom category attribute will be installed if it doesn't yet exist!

First of all let's set up our basic module file structure we need for this:

    app/code/local/Meteorify/Customcatattrb
    app/code/local/Meteorify/Customcatattrb/etc
    app/code/local/Meteorify/Customcatattrb/sql/customcatattrb_setup


Now let's create the files, first up is our config.xml, this is the main file within your module which tells Magento which controllers and models to load, plus plenty more.

Save this file to: `app/code/local/Meteorify/Customcatattrb/etc/config.xml`

```xml
<?xml version="1.0"?>
<config>
  <modules>
    <Meteorify_Customcatattrb>
      <version>0.0.1</version>
    </Meteorify_Customcatattrb>
  </modules>
    <global>
      <resources>
          <customcatattrb_setup>
            <setup>
              <module>Meteorify_Customcatattrb</module>
              <class>Mage_Eav_Model_Entity_Setup</class>
            </setup>
            <connection>
              <use>default_setup</use>
            </connection>
          </customcatattrb_setup>
      </resources>
    </global>
</config>
```

So what we have done here is defined a few requirements for our module. We tell Magento to load in the setup resources, and which database connection to use. If we wanted, we could define our own class for the setup, extending off of the same class specified above so we can do a few more things to install our attributes. However that is out of scope for this article today.

Next up, let's create yet another XML file, this time it's our file which lets magento know we have a module to be loaded in, and where the module is located.

Save this file to: `app/etc/modules/Meteorify_Customcatattrb.xml`

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


As mentioned above, all this file does is let Magento know this module exists, and to load it. We also specify which code pool it belong to (either Community, Core, or Local).

Last but not least, is our install script. This is a tiny script which will install our attribute to the database, and we can start using our newly created attribute straight away after!

Save to: `app/code/local/Meteorify/Customcatattrb/sql/customcatattrb_setup/mysql4-install-0.0.1.php`

```php
<?php
$installer = $this;
$installer->startSetup();
$attribute  = array(
    'type' => 'text',
    'label'=> 'Bottom Description',
    'input' => 'textarea',
    'global' => Mage_Catalog_Model_Resource_Eav_Attribute::SCOPE_GLOBAL,
    'visible' => true,
    'required' => false,
    'user_defined' => true,
    'default' => "",
    'group' => "General Information"
);
$installer->addAttribute('catalog_category', 'bottom_description', $attribute);
$installer->endSetup();
?>
```

Once you have done all of this, clear the cache, and head over to `Catalog > Manage Categories` and you will now see your new custom attribute appearing at the bottom of the General Information tab. Perfecto!

### Explanation of our module

In this dead simple module the main points I want to make is about our install script we created. Whenever we install this module on another Magento install our attribute will be created along with it. Making it super easy to maintain! So let's dig into it a bit, and learn what else we can do with this.

Let's start with our `$attribute` variable which contains an array of values.

`type` = The character type, it can be any of the following: text, varchar, or int

`label` = Label is the visible name of our attribute. This allows us to define a more human friendly title to our attribute.

`input` = Input is how the data will be inputted by the end-user. In this case we used a `textarea`, but we can also use `text`, or other ones such as drop downs, multi-selects and date ranges. We'll cover these other attributes in more depth another time.

`global` = Global simply defines the scope of the attribute. By default I use the global scope available on all store views, and website views.

`visible` = Is a boolean, it simply states whether or not the module is visible to the user or not.

`required` = Self explanatory, we can set this to `true` to make the field mandatory for the user to fill in before saving the category.

`user_defined` = If the user can define the value of this or not.

`group` = The tab where this attribute will live. If you enter a new tab name, it will create the new tab for you.

#### Parameters I didn't include:

`sort_order` = Here we can define which position this attribute appears when editing a category.

`option` = If we have defined our input to be a drop down or mutli-select we can use this to define our different options, see the code below for a complete example:

    'option' => array ('value' => array(
        'optionone'=> array(
            0 =>'My First Option'),
        'optiontwo'=> array(
            0 =>'My Second Option'))),


### Using your new attribute

If you want to use this attribute in your template file, you can do so with the following:

```php
  <?php echo $_category->getBottomDescription() ?>
```
### And that's how you create a custom category attribute

I hope you learnt something from this article. I have personally learnt more researching for this article than I have trying to find an article to simply follow.

I will be doing a follow up post covering attributes in a more complete way, covering custom product attributes, CMS page attributes and more!

If you have any questions, post them in the comments and I'll do my best to answer. Although, stack overflow will be the best place.


Quick Tip: Adding Custom Category Attributes to Magento

Whether you're developing a theme, or a new extension for Magento the whole process can be made a lot easier when you know various in's and out's of Magento. Including some of the in-built development tools ready for you to use.

In this post I'll cover two ways you can speed up your development. These tips have served me well, and I use these on a daily basis, hopefully you will be too.

### Enable Template paths hints

Ever tried debuging why your Magento theme isn't updating? Maybe it's not actually using your template for some reason. Enabling Template Path Hints will help you find which templates & blocks are being used in your themes!

To enabled this simply head over to `System > Configuration > Advanced > Developer` and change the configuration scope (top left) to your desired store view. Under the debug menu is two options `Template path hints` and `Add Block Names to Hints`, once enabled your theme will now display a breakdown of all the template files, and also the block names so you can see which block modules are loading too.

Another useful feature under `Developer Client Restrictions` is allowing certain IPs to view your enabled template paths. This helps if you need to quickly debug something on a live site.

### Enabling logging & use Mage::log()

`Mage::log()` is one of my most used lines of code in Magento whilst I'm developing themes and modules. This is because we can use `Mage::log()` to log anything, and get the contents outputs of objects and arrays without var_dump'ing.

First of all you need to enable logging, head over `System > Configuration > Advanced > Developer` and under `Log Settings` simply enable the log, and leave the other default values.

To use `Mage::log()` in your theme, or module you can simply add this line: `Mage::log('Hello World')` and when you run your script, over in var/log you will see a system.log file which will now contain your debug message!

Taking this a step further, we can output arrays and objects using `Mage::log()`, just simply pass it as a variable.

If you want to customise the output a little, for example save to a different log file, then no problem! Here's all the parameters the log method takes:

```php
Mage::log($message, $level = null, $file = '', $forceLog = false)
```

With this, we can change a few settings, most importantly where the log saves to.

```php
Mage::log($message, null, 'mylogfile.log');
```

In `var/log` you will now see a file named `mylogfile.log`! Brilliant. We can use this to split up our logging. General PHP errors will get logged to `system.log`, so by separating our debug logging we can easily scan our log file for what really matters in the early stages of development.

### Have your own Magento Development Tips & Tricks?

I would love to hear any tips and tricks you have for magento development. If you are using any particular development extensions, or are the creator of one, please share it and I'll likely feature it here on the meteorify blog too.


Magento developments tips: logging &#038; template paths

In this series about creating a faster Magento store, I will walk you through a number of must-do things that can speed up your Magento stores dramatically. A lot of these tips are easy, and free, a few are technical and require server knowledge and are best carried out by someone who knows their way around a server.
This series will go from optimising your server, and getting your initial magento install set up. I highly recommend these changes are made on a separate server, perhaps a VPS/Cloud Server. I personally use Rackspace Cloud Servers to create new servers quickly.

### What are we going to do?

The main thing we are going to do is installed Nginx, Varnish and PHP-FPM, these all improve performance in their own way. So let's get started.

### Why are we using Nginx, Varnish and PHP-FPM?

Nginx is a web-server, like Apache, but boosts much better performance results, and is much more stable when handling lots of requests, which results in high CPU usage and can slow down your entire server. Apache, for example, doesn't scale quiet so well without a large amount of know-how, and in my experience I have found it easier to use an alternative web server, hence Nginx! Now, Nginx isn't without it's flaws, you will need to install PHP-FPM, which is a FastCGI Process Manager for PHP, essentially it allows us to use PHP via FastCGI, I believe their are alternative solutions to this, however this is one I have come across and is simple enough to setup

Varnish Cache is a HTTP proxy or sometimes referred to as a HTTP accelerator. What Varnish does is sit between you and your web-server, when a page is requested Varnish will check if it has a cached version and return it to the user, if not it simply passes the request onto the normal web server (in this case Nginx), it then caches it so in future it can be returned quickly. What's even better about Varnish is it makes use of the physical memory on your server as opposed to the CPU, which results in high speed without slowing your server down. This leads to some seriously good performance results.

### Server Requirements

This article does presume you're using a CentOS based server, and it's a fresh install (CentOS 6 or greater), if you are using an existing server, parts of this article you will be able to skip, and equally you will need to either stop Apache from running or change the port it runs on when it comes to the stage of running Varnish/Nginx.

For the best performance results, use a dedicated server. VPS's are great, but they do share resources and I don't like relying on them heavily. If you expect your sites to take on a lot of traffic, go for a dedicated server, if not a VPS will be great, and very low cost too.

```bash
rpm -Uvh http://download.fedoraproject.org/pub/epel/6/x86_64/epel-release-6-8.noarch.rpm
rpm -Uvh http://rpms.famillecollet.com/enterprise/remi-release-6.rpm
yum install mysql mysql-server
/etc/init.d/mysqld start
/usr/bin/mysql_secure_installation
```

As you run through the installation process for mysql note there is no root password by default. Read each step carefully. I highly recommend you set a root password, and all options should be set to yes for the optimal setup.

```bash
yum install nginx
/etc/init.d/nginx start
yum --enablerepo=remi install php-fpm php-mysql php-pdo php-common php-mcrypt php-gd php-curl php-soap
vi /etc/php.ini
```

When you open up php.ini, find `cgi.fix_pathinfo` and set the value to `0`

Next up we need to create our virtual host in Nginx so our site can be accessed from the web! to do this simply enter:

```bash
vi /etc/nginx/conf.d/magentosite.conf
```

Then modify the details below to match your needs:

```nginx
server {
    listen      8080;
    server_name www.magentosite.co.uk;
    root        /var/www/sites/magentosite/;
    index index.html index.php;

    access_log /var/log/nginx/www.magentosite.co.uk-access_log;
    error_log /var/log/nginx/www.magentosite.co.uk-error_log;

    location / {
        try_files $uri $uri/ @handler;
        expires 30d;
    }
    location /app/                       { deny all; }
    location /includes/                  { deny all; }
    location /lib/                       { deny all; }
    location /media/downloadable/        { deny all; }
    location /pkginfo/                   { deny all; }
    location /report/config.xml          { deny all; }
    location /var/                       { deny all; }

    location /var/export/ {
        auth_basic              "Restricted";
        auth_basic_user_file    htpasswd;
        autoindex               on;
    }
    location  /. {
        return 404;
    }

    location @handler {
        rewrite / /index.php;
    }

    location ~ .php/ {
        rewrite ^(.*.php)/ $1 last;
    }

    location ~ \.php$ {
        try_files $uri =404;
        expires off;
        fastcgi_read_timeout 900s;
        fastcgi_index index.php;
        fastcgi_pass 127.0.0.1:9000;
        fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
        include /etc/nginx/fastcgi_params;
    }
    rewrite ^/minify/([0-9]+)(/.*.(js|css))$ /lib/minify/m.php?f=$2&d=$1 last;
    rewrite ^/skin/m/([0-9]+)(/.*.(js|css))$ /lib/minify/m.php?f=$2&d=$1 last;

    location /lib/minify/ {
        allow all;
    }
    gzip on;
    #gzip_comp_level 9;
    gzip_min_length  1000;
    gzip_proxied any;
    gzip_types       text/plain application/xml text/html text/css text/js application/x-javascript;
}
```

In short what the above does is create a virtual host much like how we do in Apache, assign a server name, and root directory for where the store is set. We then also do various other tweaks to pass PHP requests to PHP-FPM, and to allow friendly URLs without index.php.

Most importantly I have set nginx to run on port 8080 rather than the usual port 80. This is so we can run Varnish on port 80, and pass requests onto 8080. We will be installing varnish shortly

Next we want to configure php-fpm to work nicely with Nginx, to do this simply open up /etc/php-fpm.d/www.conf and find the User & Group settings, and set both the user and group to &#8216;nginx'.

Now start php-fpm:

```bash
service php-fpm start
```

If you want to quickly test your changes before adding your magento installation simply create a file in your root directory you defined in your nginx conf and set it to output phpinfo();

Then finally restart nginx by doing service nginx restart. You can then navigate to your site followed by :8080 (e.g. http://example.com:8080/) you should now see details about your php configuration. Perfect! If you receive a 500 error, try changing the ownership of your files and folders for the root site to the nginx user. Like so:

```bash
chown -R nginx:nginx /var/www/mysite
```

Great, so you have your site working on port 8080! Now let's get varnish installed and configured to run on port 80!

To install varnish simply run:


```bash
sudo yum install varnish
```

Great, now we have that installed let's get Varnish running on port 80. This is so when we first request a page it will go through to Varnish cache first, check if a cached version exists and return that, if no cache exists it'll pass the request to nginx, which in turn will then cache that and return it to the user.


```bash
vi /etc/sysconfig/varnish
```

Now find `VARNISH_LISTEN_PORT=6081` and change it to port 80, save and close.

Next up we want to update the default configuration for our server. We need to check what version of Varnish we have installed, as this will dictate which configuration file we need to load in. You can run the following command to find out your version:


```bash
sudo varnishd -V
```

My version was 2.1.5, so I can use the first set of code below. I have both of these configurations saved using Gist by GitHub, so you can head to one of the following links to jump directly to the configuration you require: <a href="https://gist.github.com/ashsmith/5429365#file-default_2-1-vcl" target="_blank">version 2.1</a> or <a href="https://gist.github.com/ashsmith/5429365#file-default_3-0-vcl" target="_blank">version 3.0+</a>

We'll want to place this configuration in the following file:

```bash
etc/varnish/default.vcl
```

#### Varnish configuration for version 2.1:

{% gist 5429365 default_2.1.vcl %}

#### Varnish configuration for version 3.0+

{% gist 5429365 default_3.0.vcl %}

Now we can fire up Varnish:

```bash
service varnish start
```

Now if you access your site again but without the port :8080 you should see your entire site working perfectly!

From here you can set up your database, and install magento. Once that is done, install the following plugin:
[PageCache powered by Varnish][1] this will allow you to clear the Varnish cache from within the Admin and auto-clear after saving categories/products or CMS pages. Very handy indeed.

Then when logged into the Magento admin head over to System > Configuration > Advanced > System. You'll notice a new section labeled &#8220;PageCache powered by Varnish settings&#8221; Enable the module, set the varnish port to 80, and you may also want to set the purge settings to yes, these will enable auto-purging when categories/products or CMS pages are edited. Very handy for getting your changes live before the cache expires on it's own.

You can also make sure everything is set to run on startup with these simple commands:

```bash
chkconfig --levels 235 mysqld on
chkconfig --levels 235 nginx on
chkconfig --levels 235 php-fpm on
chkconfig --levels 235 varnish on
```

### Known Quirks

*   If you have design exceptions i.e. a mobile site. Varnish cache will not work. I'm working on a fix. But, if the budget is there purchase the full-version of the free extension.
*   Your .htaccess will no longer work, that's because we're not using Apache anymore. So any unique changes in there need to be transfered directly to your PHP settings or to your nginx VHOST setup.

### Finishing up

And we're done with this part of the series. From here on we'll be looking at various other ways we can speed up our stores by optimising our site resources to increase speed further. Plus various other plugins we can use to speed up our stores.

If you have any questions, or even suggestions on how you optimise your servers for the best performance on Magento stores, please use the comments!

 [1]: http://www.magentocommerce.com/magento-connect/pagecache-powered-by-varnish.html


Creating a faster Magento Store with Nginx &#038; Varnish

When developing for Magento, often most peoples first action is to override a particular class or method from the core. They also usually use the same namespaces and copy into the local folder like: `local/Mage/Sales/Model/Orders.php` for example. While this is handy for a lot of things, often people don't know, forget about, or don't know how to make use of an Observer when that is 9 times out of 10 the better approach.

In this little tutorial I'll teach you how to create an observer, and you'll also be able to figure out for yourself when to use them too. Awesome stuff, let's get started.

## What is an Observer anyway?

In a nutshell: An Observer in Magento listens for when specific events fire, and then executes code we have defined to listen to that observer.

What this allows us to do is create more speration of our code. Especially if it's something we don't really want coded directly into other modules or having to override core functionality which could make it very difficult for you to upgrade in the future.

## How do I find what events exist in Magento?

Figuring out how to find these events is relatively simple. We first need to know how Magento fires events and that is done like this:

```php
Mage::dispatchEvent('event_name', array('data' => $data));
```

With that we can simply do a search in all of our files to return all the events. You can run this command on Linux/Mac:

```bash
grep -r "dispatchEvent(" /path/to/magento/install/
```

Alterntively if you're using Sublime Text 2 or a similar IDE where you can search file contents across an entire project search for `dispatchEvent` and you'll start to see the results pouring in.

This is fantastic, however it's tricky to digest all this information. Luckily for you there is a fantastic [little cheat sheet][1] generated by [Nick Jones][2] over on his site. He maintains this and is generally up-to-date and is a fantastic reference. His cheatsheet will show you which file, line and what event is called.

## Okay, now how do I create an observer?

By now you will have found the event you're looking for. Now is the time to create our observer in order to execute our desired code! Let's get started.

To do this we will be creating our own module. If you're not familiar with creating your own module don't worry, I'll cover the basics but I won't be going into too much detail.

Before we get started, my example below uses the `sales_order_place_before` event which is called just before the order is saved. We could do numerous things at this stage such as add additional meta data to the order. In my example, we'll simply output to our log.

### Step 1) Create main module xml file

We need to create a file called `Meteorify_Observerexample.xml` in `app/etc/modules`.

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

This file allows Magento to recongise the modules existence and is where we can deactivate it (by changing `<active>true</active>` to `<active>false</active>`)

### Step 2) Create folder structure for our module

We need to create the folders where our modules code will live. To do this create the following directories:

```bash
mkdir app/code/local/Meteorify/
mkdir app/code/local/Meteorify/Observerexample/
mkdir app/code/local/Meteorify/Observerexample/etc
mkdir app/code/local/Meteorify/Observerexample/Model
```

Quick explaination of the module folder structure. `Meteorify` represents the company or group, then `Observerexample` is our actual module. `etc` will contain various configuration files which instructs Magento how to read/use our module. `Model` contains our various Model classes which our module might use (in this case we will have a `Observer.php` file in the Model folder).

### Step 2) Create our module's configuration file

Each module requires a file called `config.xml` this file lives in `app/code/local/Meteorify/Observerexample/etc`

```xml
<?xml version="1.0"?>
<config>
    <modules>
        <Meteorify_Observerexample>
            <version>0.0.1</version>
        </Meteorify_Observerexample>
    </modules>
    <global>
        <models>
            <meteorifyobserverexample>
                <class>Observerexample_Model</class>
            </meteorifyobserverexample>
        </models>
        <events>
            <sales_order_place_before>
                <observers>
                    <meteorify_observerexample_model_observer>
                        <type>singleton</type>
                        <class>Meteorify_Observerexample_Model_Observer</class>
                        <method>example</method>
                    </meteorify_observerexample_model_observer>
                </observers>
            </sales_order_place_before>
        </events>
    </global>
</config>
```

The above code is our basic config for our model. If you stick to similar naming conventions you'll get on by fine here.

The main code I'd like to highlight here is contained between the `<events>` tags. The first tag in represents our event we decided to use earlier on `sales_order_place_before`, so within here we are defining what to do when that event is fired. Within the `<observers>` tag we have the set up for our Observer. The value within `<class>` represents the class name of our Observer, and then the value in `<method>` is the method (or function) we will run when that event is fired.

### Step 4) Creating our Observer.php

Now we can create our Observer and place our code inside our method we will create. To do this create a file named `Observer.php` in `app/code/local/Meteorify/Observerexample/Model` and place the following code:

```php
<?php
class Meteorify_Observerexample_Model_Observer {

    public function example($observer) {
        //$observer contains data passed from when the event was triggered.
        //You can use this data to manipulate the order data before it's saved.
        //Uncomment the line below to log what is contained here:
        //Mage::log($observer);

        Mage::log('We just made an Observer!');
    }

}

```

### Easy as that.

Now all you need to do is clear the cache, make sure log's are enabled in `System > Configuration > Advanced > Developer > Logging` and then go through the checkout and then check the logs in `var/log`.

I've put the completed module onto my github profile, so go ahead and check it out: [Observer Example Magento][3]

If you have any questions, or any tips and tricks please feel free to post a comment below!

 [1]: https://www.nicksays.co.uk/magento-events-cheat-sheet-1-9/
 [2]: http://www.nicksays.co.uk/
 [3]: https://github.com/ashsmith/Observer-Example-Magento


Making use of Observers in Magento

Sometimes you will be required to change the default increment ID's of orders, invoices, credit memos & shipments. To do this is surprisingly simple, yet cannot be done via the backend Admin area without an extension. Today I'll show you how simple it is to change these numbers with some simple SQL queries to run on your database.

The table in question is eav\_entity\_store. Which has the last used increment id for each of the records we want to change. Knowing which is which is relatively easy to find out when you know where to look. In order to find out which is which you only need to take the entity\_type\_id and look at the records contained within eav\_entity\_type. From there you can spot which record corresponds  to the records within eav\_entity\_store.

To help you out, here are the records from a Magento 1.7.0.2 install I have. I can also verify that the same ID's are in Magento 1.6.0.2 and 1.5.0.1 installs.

*   5 = Order
*   6 = Invoice
*   7 = Credit Memo
*   8 = Shipment

### Creating our SQL queries

With this knowledge we can apply this to creating our simple SQL update query to update our order numbers!

{% gist 4279368 update_order_numbers_1.sql %}

Okay, so that's all great. But have you noticed your order numbers still begin with the number one? That's because there is a prefix added to your order numbers. To change this, simply change the increment_prefix column in the same table. So let's update our SQL

{% gist 4279368 update_order_numbers_2.sql %}

So, what if we don't currently have any records in the eav\_entity\_store table, like in a clean fresh install with no orders then the above commands won't work because we can't update records that don't yet exist. That means we need to insert them. So simply replace the UPDATE directive with INSERT.

There you have it, it's as easy as that! You can now easily update order numbers, invoice numbers etc with these simple SQL queries.

Let me know in the comments if this has helped you, or if you have any other tips like these that help you.


Quick tip: Change Magento default increment ID for orders & invoices

In this quick tip I'll teach you how to override the meta data using Magento's XML layout files. You'll be able to adjust any meta tag in the head with ease. For the changes I'm teaching you to make I recommend you add them to your local.xml file which you may need to create within your theme if it doesn't already exist (app/design/frontend/[package]/[theme]/layout/local.xml)

### Overriding Robots Meta Tag:

```xml
<customer_account_login>
  <reference name="head">
    <action method="setRobots">
      <value>NOINDEX, NOFOLLOW</value>
    </action>
  </reference>
</customer_account_login>
```

### Overriding the Page Title:

```xml
<customer_account_login>
  <reference name="head">
    <action method="setTitle" translate="title">
      <title>New Page Title</title>
    </action>
  </reference>
</customer_account_login>
```

### Overriding the Meta Description:

```xml
<customer_account_login>
  <reference name="head">
    <action method="setDescription" translate="title">
      <title>New Meta Description</title>
    </action>
  </reference>
</customer_account_login>
```

### Overriding the Meta Keywords:

```xml
<customer_account_login>
  <reference name="head">
    <action method="setKeywords" translate="title">
      <title>New Keywords</title>
    </action>
  </reference>
</customer_account_login>
```

### Add Rel Canonical

```xml
<customer_account_login>
  <reference name="head">
    <action method="addLinkRel" translate="title">
      <rel>canonical</rel>
      <href>http://www.example.com/page.html</href>
    </action>
  </reference>
</customer_account_login>
```

To add these to different pages simply change the outer most tag (customer\_account\_login) to the approiate tag. For example if you wanted to override a product page, just change the outer
most tag to <kbd>&lt;catalog_product_index&gt;</kbd>.

That it from me, if you have any other quick references like this, let me know in the comments and I'll add them to the post! Thanks for reading!


Quick Tip: Override Magento Meta data in XML files

If you're like me, you make use of a lot of widget links within Magento, and those Widget links have a pesky habit of adding ?\___store=default to the end of your URLs, which first of all don't look nice and it certainly doesn't help your optimisation efforts when it comes to SEO and ridding yourself of duplicate content.

This is a dead simple fix, and gives you peace of mind.

Simply copy the follow file: app/code/**core**/Mage/Catalog/Block/Widget/Link.php and paste it into app/code/**local**/Magento/Catalog/Block/Widget/Link.php

Then lines 89 &#8211; 92 need to be commented out. These lines look like this: (if it changes in future versions!)

```php
if(strpos($this->_href, "___store") === false){
  $symbol = (strpos($this->_href, "?") === false) ? "?" : "&";
  $this->_href = $this-&gt;_href . $symbol . "___store=" . $store->getCode();
}
```

It's as simple as that!

For extra special bonus points I would recommend packaging this change into it's own module rather than overriding core functionality in this way. Doing so will be covered in a later blog post!

Side note: I have not tested how this works with multiple stores, so I can't comment or recommend this until it's been tested and giving the OK. If anyone runs into problems, I'd love to hear your feedback.


Get rid of ?__store=default from your Magento links

Many users have reported issues when trying to import images using the default Import/Export within Magento. I too have suffered this headache. Luckily, I have figured out a way to bypass any issues by separating out our import files.

Traditionally when we import our CSV, we have one giant document full of attributes. Including all the image references  Well, in my version don't include the image attributes. Instead, we'll put those into a new CSV along side a column with the SKU of the product.

In order to import a second CSV that is customised like this we'll need a separate import profile. I'll teach you how to create one now.

## Step 1) Create the advanced profile

The solution is to create a custom import profile (System > Import/Export > Dataflow &#8211; Profiles). You only need to include the attributes that are required, which is just the SKU. Plus the appropiate image attributes. Plus labels if you want to go all out.

When you are creating your new profile, enter the following settings:

[Magento Import Profile Setup](./Magento-import-profile.png)

Now you can hit save! With our Profile now complete, we just need to create the folder media/import. This is where you will be storing all your images awaiting import.

## Step 2) Create your Magento images import CSV

So now we have our profile created all we need to do is create our CSV. The CSV is pretty standard format. First of we have our SKU, and then followed by our image attributes.

When uploading images, they need to be within a folder called `media/import`. Once saved to that folder you can then reference them relatively. By that I mean if your image is in `media/import/test.jpg` in your csv reference it as `/test.jpg`. It's as easy as that.

Now finally all you need to do is modify your CSV file to include only the following columns:

<pre>sku, image, image_label, small_image, small_image_label, thumbnail, thumbnail_label</pre>

Now you can upload and run the profile, sit back and breath.

Did this help you? Have any questions? Got any other tips like this? Let me know in the comments!


Importing Product Images via CSV in Magento 1.7.0.0

Magento is a fantastic system with a huge range of features, however with that comes a &#8220;slight&#8221; performance issue, whereby all the requests are long and slow and without a completely kick-ass server your site will struggle to load quickly. Luckily, provided you own a VPS or dedicated server there are many things you can do to combat the performance issues you'll experience with Magento, which in the long run could save you money and time whilst speeding up your Magento websites dramatically!

## 1) Install a PHP accelerator

PHP Accelerators can improve PHP's performance by ten-fold, so using an accelerator would be perfect for the likes of Magento, there are a number of PHP Accelerators such as: [eaccelerator][1], [APC][2], [ionCube][3], [XCache][4], [Zend Optimizer+][5]&#8230; the list goes on and on

PHP Accelerators work by caching a complied version of all the PHP scripts, and storing them in shared memory thus meaning the code is not read from the slow hard disk, and is already complied.

I personally installed eaccelerator on this server, and on our two production servers at work, we have seen a fantastic performance difference and even managed to reduce the overall server load. PHP Accelerators are a must if you ask me.

## 2) NGinx, reverse proxy set up

[nginx ][6](or engine x) is a http and reverse proxy server, as well as a mail proxy server. Now, nginx as a http server is far faster than Apache, setting nginx up as a reverse proxy (nginx receives http requests, serves static content and passes everything else onto Apache) is also far faster than using Apache alone, in most cases it can increase speed by 50% and decrease load by 50%. So, with that in mind you could now use a smaller server set up, and dramatically reduce costs.

Sadly I haven't been able to install NGinx on our main production server which receives the most traffic, and therefore can't truly speak for the performance difference. The reason for this is there appear to be too many things that could go wrong, we use Plesk on our main production server and all the guides and forum posts I have read covering this seem to experience issues with mail on Plesk, which is something I can't risk. Perhaps I'll set up a Plesk development server in the future and try that & I'll report back how I managed to do it sometime in the future.

## 3) Disable unused magento modules

By disabling unused modules on Magento you can stop Magento from loading them and reduce the time it takes for each page to be generated, along with a PHP Accelerator you could see  a solid change in performance.

Modules I've disabled: Tags, PayPal (I've kept PayPal UK on), Weee, Find\_Feed, Authorizenet, Downloadable, GiftMessage, GoogleCheckout, Newsletter, Paygate, Poll, Mage\_Usa and Phoenix_Moneybookers. That's 13 Modules I don't use, and will most likely never use. Why bother having them enabled if you're not going to use them? Perhaps you might use some of the above, but it's completely down to what your requirements are.

To disable/enable modules on Magento simply go:

<pre>System &gt; Configuration &gt; Advanced &gt; Advanced</pre>

## 4) Edit your .htaccess settings

By uncommenting settings within your .htaccess you can unlock better magento performance again, enabling settings such as gzip compression and increasing PHP's memory limit will have a positive effect on your performance. Personally, I set our PHP memory limit to 500m to make sure there is no doubt it has enough memory. Furthermore I make sure everything is gzip compressed before sending to the browser.

So there it is, 4 useful tips towards unlocking your magento's store hidden potential. If you have any tips on increasing performance please use the comments below, I'd like to hear what tips you have!

 [1]: http://eaccelerator.net/
 [2]: http://pecl.php.net/package/APC
 [3]: http://www.ioncube.com/
 [4]: http://xcache.lighttpd.net/
 [5]: http://www.zend.com/products/server/
 [6]: http://nginx.org/en/


Tips for Tuning Magentos Performance

Recently I've been working on a new store which will be shipping internationally, and needed to set up all the tax rates within the EU, for this the client is deciding to stick to the UK's 20% VAT rate. With this in mind I pulled together a quick CSV which you can download (here: <http://db.tt/TrrKtQgc>) and simply uploading within Magento by navigating to: **Sales** > **Tax** > **Import / Export Tax Rates**.

Hopefully this will help you speed up setting up multiple EU tax zones!


Quick Tip: Setup EU tax rates in Magento quickly

Being able to track Checkout Abandonment is crucial when you're focused on increasing conversions, with Magento's one page checkout by default you can't step up goals for Google Analytics to pick out each step, so instead we can use the trackPageview method to track fake pageviews for each step, we can then add these into our Goal steps inside GA.

## Step 1) Modify onepage checkout template file

First of all we need to modify the file called onepage.phtml located inside checkout/onepage.phtml within your theme's template directory, if the file doesn't exist here copy it across from the base/default folder:

**Your Theme:**
app/design/frontend/`[package]`/`[yourtemplate]`/template/checkout/onepage.phtml
**Base Default:**
app/design/frontend/base/default/template/checkout/onepage.phtml

Once you've got the file open paste in the following code at the end of the file, save and upload.

```html
<script type="text/javascript">
  Checkout.prototype.gotoSection = Checkout.prototype.gotoSection.wrap(function(parentMethod, section, reloadProgressBlock) {

    // Call parent method.
    parentMethod(section, reloadProgressBlock);

    var _gaq = _gaq || [];

    try {
      // push current checkout section to google analytics if available.
      _gaq.push(['_trackPageview', '<?php echo $this->getUrl('checkout/onepage'); ?>' + section + '/']);
    } catch(err) {
      // silent fail.
    }
  });
</script>
```

## Step 2) Set up Goal & Funnel on Google Analytics

All that is left to do now is to set up the goal and funnel on Google Analytics so we can begin tracking our abandonment's. To do this within the new version of Google Analytics in the top right in the main navigation bar there is a link called &#8220;Admin&#8221; on this page navigate to the Goals section under Profiles > Goals.

Then enter the following information:
[Google Analytics Goal Setup](./Screen-Shot-2012-03-04-at-18.50.12.png)

**Goal Type:** URL Destination<br />
**Match Type:** Head Match<br />
**Goal URL:** /checkout/onepage/success/<br />

[Example of goal funnel setup](./Screen-Shot-2012-03-04-at-18.48.59.png)

**Funnel Steps:**
Step 1: /checkout/cart/<br />
Step 2: /checkout/onepage/<br />
Step 3: /checkout/onepage/billing/<br />
Step 4: /checkout/onepage/shipping/<br />
Step 5: /checkout/onepage/shipping_method/<br />
Step 6: /checkout/onepage/payment/<br />
Step 7: /checkout/onepage/review/<br />

## And that's it!

Save those changes and voila! You're done and now tracking checkout abandonment! On the Standard Reporting section to Google Analytics go to `Conversions > Goals > Funnel Visualization` to see where your users are dropping out from the checkout process.


Tracking Magentos Onepage Checkout Steps in Google Analytics

Today we're going to look at how you can use php to add blocks, both static CMS blocks and blocks that include things like featured products, we can use this line of php in any of our phtml files within the template folder of our themes. Although the same result can be replicated using the XML layout files, this can be used as an alternative way of getting the same result.

## Fetching CMS Blocks using PHP

This first example shows you how to load CMS Blocks into your template files, if you're building a template that will be used by other people, it would be best to not use this, since adding CMS Blocks means the static cms block needs to exist in the installation of the Magento site. Unless you have clear instructions, and you consider it the only way, then by all means use it at free will.

```php
<?php
    echo $this->getLayout()->createBlock('cms/block')->setBlockId('contacts_text')->toHtml();
?>
```

## Fetching Template Blocks using PHP

This second example here shows you how to add any other block type with a specified template, this example below grabs the related products list. This example would be perfectly acceptable to use in a template that will be redistributed. However like I mentioned before you could in actual fact include this in your layout structure (XML files) rather than using it directly in your template files (phtml files)

```php
<?php
    echo $this->getLayout()->createBlock('catalog/product_list_related')->setTemplate('catalog/product/list/related.phtml')->toHtml();
?>
```

## Final Words

By using these php snippets to include Blocks into your templates you can speed up your development. I've often found myself struggling to get blocks to display when using the XML layout files, so by including these snippets you can bypass this. However, use with caution I'm not aware of any performance issues with using this method although I would advise you test both methods and decide which is best for you.

As usual, thanks for reading and I welcome any comments


Quick Tip: Adding blocks to templates in Magento

When setting your store up one of the first things you'll come across is on the catalog pages of your store you'll see down the right hand side in the 2columns-right.phtml file is the paypal logo saying you accept paypal. If you are new to Magento this can prove to be rather difficult. Anyway, there are two options to getting rid of the Paypal logo.

## Option One: Disable Paypal

So, if you have no intention of using paypal as a payment method you can disable paypal from your store completely, this is simple to do go to: system > configuration > advanced > advanced  then from the list of modules disable both paypal and paypaluk. Refresh your cache and the logo has gone from your right hand sidebar.

## Option Two: Remove the logo yourself

To remove the logo from the right hand sidebar all you need to do is go into your file system and navigate to: app/design/frontend/base/default/layout/ and open up paypal.xml. Copy this file to your theme's layout directory (app/design/frontend/[package]/[yourtheme]/layout/) once you've done this open up paypal.xml and remove the following lines from the file: 98-100, 106 112, 118. Once you've completed this simply refresh your cache and you're done!

Thanks for reading this quick tip on removing the paypal logo from catalog page inside of your Magento store. For more quick tips stay tuned and subscribe to our RSS feed.


Ash Smith

Cloud & Serverless Developer

Magento 1 Posts