Atwix » extensions

Source, frontend and backend models in Magento system settings

Yaroslav Rogoza — Mon, 25 Feb 2013 08:37:40 +0000

In the previous article we have described how the different settings can be applied to a custom extension. There’s nothing difficult for the simple settings such as text field or text area. But, if you look at the drop down, multiselect or editable items list you’ll notice that these items have additional fields, e.g. source_model, backend_model, frontend_model. Let’s focus on these models and find out more info about creating settings that require data models.

Source Model – a model class that serves to get existing values (stored in the db or somewhere else) for further displaying inside the setting’s field.

Frontend Model – as a rule, it’s a block’s class. Methods of this class return html of setting’s field. To be more specific, the block had to have method _getElementHtml() described inside the class which returns the raw html of setting’s field.

Backend Model – a class which allows to operate with configuration data on the different stages (save, load). It contains three major methods respectively for each event: _afterLoad(), _beforeSave() and _afterSave().

If you are interested in, you can always find the working examples of each of them in the Magento core itself. But firstly, let’s try to look on some custom examples of these models. The following part describes how to create a drop down menu with the custom values:

Init setting’s field in your system.xml:


    Color
    select
    Atwix_Shoppingbar_Model_Adminhtml_System_Config_Source_Color
    2
    1
    1
    1

Then, create the source model that was specified above:

class Atwix_Shoppingbar_Model_Adminhtml_System_Config_Source_Color
{
   public function toOptionArray()
   {
       $themes = array(
           array('value' => 'green', 'label' => 'Green'),
           array('value' => 'blue', 'label' => 'Blue'),
           array('value' => 'beige', 'label' => 'Beige'),
       );

       return $themes;
   }
}

As you can see, there’s only one method toOptionArray(). It returns an array with the items (value -> label) for the drop down menu. Nothing difficult is here Let’s look onto another example to find out how to use frontend and source models. The best point is to review editable items list setting since it has both. The setting described below operates with the text items. It allows to add/remove email addresses:


    Blocked Email Addresses
    atwix_emailblocker/adminhtml_addresses
    adminhtml/system_config_backend_serialized
    2
    1
    0
    0
    1

Frontend model is a block:

class Atwix_Emailblocker_Block_Adminhtml_Addresses extends Mage_Adminhtml_Block_System_Config_Form_Field
{
   protected $_addRowButtonHtml = array();
   protected $_removeRowButtonHtml = array();

   /**
    * Returns html part of the setting
    *
    * @param Varien_Data_Form_Element_Abstract $element
    * @return string
    */
   protected function _getElementHtml(Varien_Data_Form_Element_Abstract $element)
   {
       $this->setElement($element);

       $html = '';
       $html .= $this->_getRowTemplateHtml();
       $html .= '';

       $html .= '';
       if ($this->_getValue('addresses')) {
           foreach ($this->_getValue('addresses') as $i => $f) {
               if ($i) {
                   $html .= $this->_getRowTemplateHtml($i);
               }
           }
       }
       $html .= '';
       $html .= $this->_getAddRowButtonHtml('emailblocker_addresses_container',
           'emailblocker_addresses_template', $this->__('Add New Email'));

       return $html;
   }

   /**
    * Retrieve html template for setting
    *
    * @param int $rowIndex
    * @return string
    */
   protected function _getRowTemplateHtml($rowIndex = 0)
   {
       $html = '';

       $html .= '';
       $html .= '_getDisabled() . '/> ';

       $html .= $this->_getRemoveRowButtonHtml();
       $html .= '';
       $html .= '';

       return $html;
   }

   protected function _getDisabled()
   {
       return $this->getElement()->getDisabled() ? ' disabled' : '';
   }

   protected function _getValue($key)
   {
       return $this->getElement()->getData('value/' . $key);
   }

   protected function _getSelected($key, $value)
   {
       return $this->getElement()->getData('value/' . $key) == $value ? 'selected="selected"' : '';
   }

   protected function _getAddRowButtonHtml($container, $template, $title='Add')
   {
       if (!isset($this->_addRowButtonHtml[$container])) {
           $this->_addRowButtonHtml[$container] = $this->getLayout()->createBlock('adminhtml/widget_button')
               ->setType('button')
               ->setClass('add ' . $this->_getDisabled())
               ->setLabel($this->__($title))
               ->setOnClick("Element.insert($('" . $container . "'), {bottom: $('" . $template . "').innerHTML})")
               ->setDisabled($this->_getDisabled())
               ->toHtml();
       }
       return $this->_addRowButtonHtml[$container];
   }

   protected function _getRemoveRowButtonHtml($selector = 'li', $title = 'Delete')
   {
       if (!$this->_removeRowButtonHtml) {
           $this->_removeRowButtonHtml = $this->getLayout()->createBlock('adminhtml/widget_button')
               ->setType('button')
               ->setClass('delete v-middle ' . $this->_getDisabled())
               ->setLabel($this->__($title))
               ->setOnClick("Element.remove($(this).up('" . $selector . "'))")
               ->setDisabled($this->_getDisabled())
               ->toHtml();
       }
       return $this->_removeRowButtonHtml;
   }
}

It’s pretty huge. We have described the full version to show what’s going on there. You can simple extend your block from Mage_GoogleCheckout_Block_Adminhtml_Shipping_Merchant and override the necessary methods.

Backend model, in this case, it’s a standard Magento model:

class Mage_Adminhtml_Model_System_Config_Backend_Serialized extends Mage_Core_Model_Config_Data
{
    protected function _afterLoad()
    {
        if (!is_array($this->getValue())) {
            $value = $this->getValue();
            $this->setValue(empty($value) ? false : unserialize($value));
        }
    }

    protected function _beforeSave()
    {
        if (is_array($this->getValue())) {
            $this->setValue(serialize($this->getValue()));
        }
    }
}

As you can see, it simply unserializes/serializes field’s values before load/save respectively. That’s all. You are always able to improvise with the models described below to get the best result. If you want non-trivial form element – use your own fronted model. To get available values for settings you should use the source model. And if you need to save/load data in your format or make some other actions on these events – feel free to use the backend model.
Good luck and graceful solutions

Magento system settings overview

Yaroslav Rogoza — Fri, 08 Feb 2013 08:26:59 +0000

From time to time Magento developers face with a need to add settings for their extensions. As it’s hard to remember all necessary details for each setting, so we would like to share our snippets which contain xml code of the most recent settings used in Magento admin.

First of all, we would recommend you always place everything, that refers to Magento system settings, in the system.xml file, since it’s the main and the only role of this file.
If you need to create your own tab in the admin system settings, you should simply add the following lines to the file:


    
        
            Atwix Extensions
            150

As a result, you’ll get the new group (tab) in the admin settings. When you need to complete the procedure of adding settings you should add the following items: section, settings groups and the settings (fields) themselves:


    
        
            separator-top
            Shopping Bar
            atwix
            130
            1
            1
            1
            
                
                    Quick search
                    text
                    20
                    1
                    0
                    1
                    
                        
                            Enable Quick Search
                            
                            select
                            adminhtml/system_config_source_yesno
                            1
                            1
                            0
                            1
                        
                        
                            Results count
                            
                            text
                            5
                            1
                            0
                            1

Here is an illustration what means each of these terms:

Next question is how will the different settings in the xml config look like. As you already know, each setting is placed in the node, then follows the unique setting’s id and finally – setting’s attributes. Here is a small review of the most useful settings:

Text field

Simple input field for short text values:

 
    Text Field
    text
    10
    1
    1
    1

Textarea

Wide input field for long text values:

    <label>Textarea</label>
    <frontend_type>textarea</frontend_type>
    <sort_order>20</sort_order>
    <show_in_default>1</show_in_default>
    <show_in_website>1</show_in_website>
    <show_in_store>1</show_in_store>

Drop down with Yes/No values

Drop down menu with the values “Yes” and “No”. Commonly it is used as a flag for enabling/disabling something:


    Enabled
    select
    adminhtml/system_config_source_yesno
    1
    1
    1
    1

Drop down with Enable/Disable values

Almost the same as previous one, but instead of “Yes” and “No” you will get “Enable” and “Disable”:


    Enable/Disable
    select
    40
    adminhtml/system_config_source_enabledisable
    1
    1
    1

Drop down with custom values

Drop down with the custom set of values, generated by source model:


    Select
    select
    
    adminhtml/system_config_source_country
    50
    1
    1
    1

Multiselect with custom values

Field with the ability to select few items at the same time:


    Multiselect
    multiselect
    
    adminhtml/system_config_source_country
    60
    1
    1
    1
    1

File

Allows to choose a file for uploading. In this example the file will be saved in var/uploads directory:


    File
    file
    adminhtml/system_config_backend_file
    var/uploads
    70
    1
    0
    0

Time

Is used to create three drop down menus for setting up the hours, minutes and seconds respectively:

Editable items list

Allows to add/remove text values for the setting:


    Blocked Email Addresses
    atwix_emailblocker/adminhtml_addresses
    adminhtml/system_config_backend_serialized
    90
    1
    1
    1
    1

Heading

Is used to entitle some settings inside the group:


    Heading
    adminhtml/system_config_form_field_heading
    90
    1
    1
    1

Dependent field

It can be any field. The main purpose of this one – it’s to hide/show the field depending on the state of some other field. In the following example the field depends on the field’s enablemethod state. If enablemethod value is 1 – dependent_field will appear and vice versa:


    Dependent Field
    textarea
    100
    1
    1
    1
    
        1

There is also one interesting cheat. You are able to use javascript inside of the node:


    Displayed Error Message
    textarea
    
    
            Event.observe('carriers_flatrate_active', 'change', function() {
                alert('Be careful with this one');
            })
        
    ]]>
    
    2013
    1
    1
    1

It might be useful for changing field’s value depending on different credentials. We would not recommend you to use it very often there, especially for the big javascript code.

Moreover, as you might have noticed, there are some attributes like source_model for the custom drop downs or, all the more so, frontend model for editable list which may disappoint a bit. We are going to describe how to operate with these models in our next article, which will see the light in the nearest future. Thank you for reading us

Creating CSV files in Magento

Yaroslav Rogoza — Tue, 15 Jan 2013 09:00:26 +0000

There are many tools in Magento which allow you to view or generate and download different reports. So, we can conclude that Magento system has integrated tools for CSV and XML files generation. It might help in the situation when you need to generate a report for some feed or just export a list of structured data. We would like to demonstrate the small example that adds an ability to generate and download CSV files.
Let’s assume that you have already created your custom extension and wish to add a CSV export functionality. If it’s not the case and you can’t guess how to create an extension, then you can always find the light in our previous articles, for example this one. We called our extension Atwix_Tweaks so in the code examples below we will use this title.

As we said before, the file is being downloaded within some URL. Well, then we need to create the controller and corresponded method-action. In config.xml file add the section which will tell the system where our controller is located:

   
        
            
                standard
                
                    Atwix_Tweaks
                    mln

On the next step, we should create the controller itself (app/code/local/Atwix/Tweaks/controllers/IndexController.php):

class Atwix_Tweaks_IndexController extends Mage_Core_Controller_Front_Action
{
    /**
     * Returns generated CSV file
     */
    public function mlnProductsListAction()
    {
        $filename = 'mln.csv';
        $content = Mage::helper('atwix_tweaks/mln')->generateMlnList();

        $this->_prepareDownloadResponse($filename, $content);
    }
}

As you can see, the controller calls method generateMlnList() from helper ‘atwix_tweaks/mln’. What are we going to do next? Right, create the helper (app/code/local/Atwix/Tweaks/Helper/Mln.php):

class Atwix_Tweaks_Helper_Mln extends Mage_Core_Helper_Abstract
{
    /**
     * Contains current collection
     * @var string
     */
    protected $_list = null;

    public function __construct()
    {
        $collection = Mage::getModel('catalog/product')->getCollection()
            ->addAttributeToSelect('*')
            ->addAttributeToFilter(array('attribute' => 'wight', 'gt' => 2));

        $this->setList($collection);
    }

    /**
     * Sets current collection
     * @param $query
     */
    public function setList($collection)
    {
        $this->_list = $collection;
    }

    /**
     * Returns indexes of the fetched array as headers for CSV
     * @param array $products
     * @return array
     */
    protected function _getCsvHeaders($products)
    {
        $product = current($products);
        $headers = array_keys($product->getData());

        return $headers;
    }

    /**
     * Generates CSV file with product's list according to the collection in the $this->_list
     * @return array
     */
    public function generateMlnList()
    {
        if (!is_null($this->_list)) {
            $items = $this->_list->getItems();
            if (count($items) > 0) {

                $io = new Varien_Io_File();
                $path = Mage::getBaseDir('var') . DS . 'export' . DS;
                $name = md5(microtime());
                $file = $path . DS . $name . '.csv';
                $io->setAllowCreateFolders(true);
                $io->open(array('path' => $path));
                $io->streamOpen($file, 'w+');
                $io->streamLock(true);

                $io->streamWriteCsv($this->_getCsvHeaders($items));
                foreach ($items as $product) {
                    $io->streamWriteCsv($product->getData());
                }

                return array(
                    'type'  => 'filename',
                    'value' => $file,
                    'rm'    => true // can delete file after use
                );
            }
        }
    }
}

The helper uses Varien_Io_File class, integrated in Magento, to generate a custom CSV file. Generated file will be stored in the media folder and deleted before the controller sends header to the client side. If you don’t want to delete file, you can set parameter rm to false in the return statement. In the constructor (method __construct) you can use any collection you want (customers, orders, custom collections etc.). Also, you are able to pass the collection behind the constructor using method setList().
I hope this small example will help you in your further development. If you have some suggestions or questions you can always place them here ⇩

Filter products by attribute on a Magento CMS page

Yaroslav Rogoza — Fri, 21 Dec 2012 08:30:58 +0000

Ability to create pages with custom content is a great feature provided by Magento. You can easily create a new page for your store and add text, html, images, different widgets there. But sometimes people want to have something non-trivial on their pages. Usually it means that you need to operate some knowledge before you’ll get an appropriate result. In this article we would like to suggest you a simple solution on how to place a products list, prefiltered by some specific attribute, on your CMS page. The example below describes how to create a simple extension for this purpose.

Let’s call the extension Atwix_Cmsattr. First, you need to add the init file for you extension. The path is app/etc/modules/Atwix_Cmsattr.xml . The file’s content is:

The extension contains one block class and one model, therefore the config file, which you should have by the following path: app/code/local/Atwix/Cmsattr/etc/config.xml, is pretty simple and consists of a few records:


    
        
            0.1.0
        
    
    
        
            
                Atwix_Cmsattr_Block
            
        
        
            
                Atwix_Cmsattr_Model

After that, create the block class app/code/local/Atwix/Cmsattr/Block/List.php:

getColor();
        if (!$color)
            return false;
        if (is_null($this->_itemCollection)) {
            $this->_itemCollection = Mage::getModel('atwix_cmsattr/products')->getItemsCollection($color);
        }

        return $this->_itemCollection;
    }
}

and the model class app/code/local/Atwix/Cmsattr/Model/Products.php:

getCollection()
            ->addAttributeToSelect('*')
            ->addAttributeToFilter('color', array('eq' => $valueId));
        Mage::getSingleton('cataloginventory/stock')->addInStockFilterToCollection($collection);
        return $collection;
    }
}

The next file is the most personal thing. You need the template file with your own mockup corresponding to your design. Here is an example for a simple list (app/design/frontend/base/default/template/atwix/cmsattr/list.phtml):

getItems() ?>

    
        __('Red Products') ?>
    
    
        
        
            
                
                    helper('catalog/image')->init($_item, 'thumbnail')->resize(50) ?>" width="50" height="50" alt="htmlEscape($_item->getName()) ?>" />
                    
                        htmlEscape($_item->getName()) ?>
                        getPriceHtml($_item, true) ?>
                        helper('wishlist')->isAllow()) : ?>
                        __('Add to Wishlist') ?>

The last thing you need to do is to create a CMS page and insert the products list where you want to show it on the page. So, go to Admin->CMS->Pages->Add New Page. Fill the page with the necessary content and connect our products block anywhere in the content by putting the following string:

{{block type="atwix_cmsattr/list" name="cmsattr" template="atwix/cmsattr/list.phtml" color="26"}}

Note, that you need to pass the attribute value for color here. The product list on this page is filtered by this value. If you going to filter product by text attribute, such as “name” for example, you can pass the text value directly like name=”Apple”. But current example describes how to filter by attribute with type select. There are many ways to get value id from attribute’s value text. One of the simple (non programmatically) ways to do this is to inspect attributes values form using your browser. The example below describes how to do it within Google Chrome:

Also you can extend your model’s logic with the new method, which would transform attribute value text into it’s id, but this small article doesn’t describe how to do it
In the next articles we are going to tell how to use layered navigation (filters) for products on CMS pages.
Feel free to ask the questions and good luck in your coding experiments.

Advices and Best Practices for Magento developers | Part 2

Yaroslav Rogoza — Mon, 26 Nov 2012 10:37:12 +0000

We continue to share our experience with Magento developers by publishing the next set of Best Practices in Magento coding. If you missed our previous article, here it is.

Local or community code pool.

Pretty often we face with the discussion about choosing a proper code pool. So, let’s talk about the difference. Local pool has the highest load priority and code in this pool can’t be overridden as easy as in community or core pools. But depending on the Magento ideology, local pool was primarily designed for local changes. If you own a website and make modifications for that website, then your modifications are classified as local and your changes should be made in the app/code/local folder. Also, when you do some custom work on the website – local code pool is for you. However, if the extension is used by many other customers, this extension is not local but shared with a (limited) community. Therefore, the extension belongs to the community pool.
Provided that you are an extension developer, you shouldn’t prevent overriding your files by other developers for the purpose of making some small changes. That can always be done by using the local pool.

Where to store the JS files in Magento?

Usually developers choose one of the following paths to store JS files (we are talking about frontend):

js

skin/frontend/package/theme/js

Actually, you should think twice at this point. As we’ve told above, one of the major Magento ideas is modularity. Therefore, as a good developer you should allow third party developers to make small changes/customizations without a need to edit your code wherever it’s possible. If your JS files are located in the skins folder, other developers are always able to change something by copying JS files into their own theme’s folder. But if you use the root JS directory, they won’t be able to do that.

Controllers and common logic.

One of the common Magento problems is tons of logic in the controllers where it shouldn’t be. For exemple, let’s explore the core file app/code/core/Mage/Customer/controllers/AccountController.php. Look at the createPostAction() method and you will see a lot of operations there. Why not to use a helper to store this logic or some abstract class? It allows other developers to extend the logic for their own purposes easily. For example, if you need to add a new customer programmatically and you want to use a standard set of methods for this, you won’t be able to do it, because most of the logic is located in the controller. Hence, we think it would be a good practice to use more extendable structures for common logic instead of hardcoding it in the controllers.

Dispatched events.

There’s yet another way to improve the quality of your extensions using dispatched events. Dispatcher is a Magento integrated system, which allows you to set some “point” with the unique name and some necessary parameters where you can integrate our logic “on the fly”. In other words, you can create your own events in your logic. Then, you or other developers are able to catch these events and connect some handlers to the events. It’s always useful to have dispatched events in the extensions, because it provides you an ability to extend your code more effectively in the future and allows other developers to interact with your logic in intelligent way. Events are usually dispatched in models and controllers. It is good to know, that it is enough to use the following construction in your code to dispatch an event:

Mage::dispatchEvent('the_unique_name', array('var' => $data));

As the second argument, you should pass the data, that you want to send to the observer’s method (some id or some object instance for example).

DB queries profiler:

Magento provides an ability for developers to track database queries. For this purpose you should use a built in DB resource profiler. It can help you to inspect database queries, detect the longest query, detect the slowest query, etc.. Here is a small example on how to use a DB profiler for your own needs :

$profiler = Mage::getSingleton('core/resource')->getConnection('core_write')->getProfiler();
foreach ($profiler->getQueryProfiles() as $query) {
    $queryTime[] = $query->getElapsedSecs(); // Get the query execution time
    $queryRaw[] = $query->getQuery(); // Get the query text
}

We would be glad to read your suggestions in the comments, so feel free to post them

Adding a column to the customers grid in Magento admin. Alternative way

Yaroslav Rogoza — Wed, 07 Nov 2012 09:27:24 +0000

Pretty often we face a task, where we need to add a custom column to the customers/orders grid in Magento admin. The solution is simple and if you google for it, you will get tons of solutions. However, pretty much all of them describe the same way, which isn’t always proper.
Nick described the simple and trivial way of adding columns in his article Adding a custom attribute/column to the orders grid in Magento admin and you are always able to follow it, except the cases, when some other extension already overrides the _prepareColumns() method. At that point, we need some universal solution that won’t conflict with other extensions that may potentially be overwriting the grid block. So, let’s use an observer for our task.
First of all, you need to add your own extension for registering the observer. Create config files and other necessary stuff:

Config to load the extension (app/etc/modules/Atwix_CustomGrid.xml):

The extension config file (app/code/local/Atwix/CustomGrid/etc/config.xml):



    
        
            0.4.0
        
    
    
        
            
                Atwix_CustomGrid_Model
            
        
    
    
        
            
                
                    
                        model
                        Atwix_CustomGrid_Model_Observer
                        appendCustomColumn

The observer itself (app/code/local/Atwix/CustomGrid/Model/Observer.php):

class Atwix_CustomGrid_Model_Observer extends Varien_Event_Observer
{
    /**
     * Adds column to admin customers grid
     *
     * @param Varien_Event_Observer $observer
     * @return Atwix_CustomGrid_Model_Observer
     */
    public function appendCustomColumn(Varien_Event_Observer $observer)
    {
        $block = $observer->getBlock();
        if (!isset($block)) {
            return $this;
        }

        if ($block->getType() == 'adminhtml/customer_grid') {
            /* @var $block Mage_Adminhtml_Block_Customer_Grid */
            $block->addColumnAfter('middlename', array(
                'header'    => 'Middle Name',
                'type'      => 'text',
                'index'     => 'middlename',
            ), 'email');
        }
    }
}

As you can see, the observer retrieves the customer grid block and executes its method addColumnAfter for adding a new column. The column type is “text” and the index is “middlename”. “Middlename” – it’s standard customer’s attribute in Magento, but you are able to add any custom attribute using this way.
The advantage of this method: your code won’t conflict with other third party solutions that also add custom columns. You can use the observer for adding a column to almost any grid in Magento admin. All you need is to change the following condition:

$block->getType() == 'adminhtml/customer_grid')

depending on your grid block. For example, order’s grid block is adminhtml/sales_order_grid.
Good luck and do not hesitate to ask your questions in comments below

Login as a customer from Magento admin

Yaroslav Rogoza — Wed, 26 Sep 2012 06:10:16 +0000

Often there are situations where customer has some issues while placing orders or making operations from the “My Account” section. At that point, an ability for admin to login as a customer and see what is wrong becomes very useful.
Sure, you can make a universal password logic, but that method has heavy security risks. Not so long ago, we’ve noticed that Magento has ability to load and use customer’s sessions different way. We will tell you how to create a simple extension for logging in as a customer from Magento admin.

Step 1

For example, let’s call our module Atwix_Ulogin. As always we must start by creating a module descriptor in app/etc/modules folder. So put the Atwix_Ulogin.xml file into this directory. The file will be with the following content:



    
        
            true
            community

Step 2

On the next step, we need to create a configuration file for our extension:



    
        
            0.4.0
        
    
    
        
            
                
                    Atwix_Ulogin_Block_Adminhtml_Customer_Grid
                
            
        
        
            
                Atwix_Ulogin_Helper
            
        
    
    
        
            
                standard
                
                    Atwix_Ulogin
                    ulogin

Save this file as app/etc/community/Atwix/Ulogin/etc/config.xml.
As you can see, we override customers grid block for admin panel to add new column. Then we tell system to use our custom router ‘ulogin’ as an entry point for the user login.

Step 3

Now we need to create a controller. This controller will check allowed IP’s for autologin, register customer session and redirect to customer account. File should be placed into app/code/community/Atwix/Ulogin/controllers. The filename is LoginController.php.
The content is:

_getSession();
        if (!$this->_isAllowed()) {
            $message = $this->__('You have no pemission to use this option');
            $session->addError($message);
            $this->_redirect('customer/account/login');
        }
        else {
            $id = (int) trim($this->getRequest()->getParam('customerid'));
            try{
                if($id){
                    $customer = Mage::getModel('customer/customer')->load($id);
                    $session->setCustomerAsLoggedIn($customer);
                    $message = $this->__('You are now logged in as %s', $customer->getName());
                    $session->addNotice($message);
                    Mage::log($message);
                }else{
                    throw new Exception ($this->__('The login attempt was unsuccessful. Some parameter is missing'));
                }
            }catch (Exception $e){
                $session->addError($e->getMessage());
            }
            $this->_redirect('customer/account');
        }
    }

    /**
     * Gets customer session
     * @return Mage_Core_Model_Abstract
     */
    protected function _getSession()
    {
        return Mage::getSingleton('customer/session');
    }

    /**
     * Checks if ip is allowed for autologin
     * @return mixed
     */
    protected function _isAllowed()
    {
        $allowedIps = Mage::helper('ulogin')->getAllowedIps();
        return Mage::helper('ulogin')->checkAllowedIp($allowedIps);
    }
}

Also we need to create a helper file with useful methods

 0) {
            $remoteIp = Mage::helper('core/http')->getRemoteAddr();
            if (in_array($remoteIp, $allowedList))
                return true;
        }
        return false;
    }
}

$ipsText variable contains comma separated list of IP addresses with allowed access to universal login ability.

Step 4

The last, but important step is to create an override for customers grid block in admin panel. Create file Grid.php at the location /app/code/community/Atwix/Ulogin/Block/Adminhtml/Customer with the following content:

class Atwix_Ulogin_Block_Adminhtml_Customer_Grid extends Mage_Adminhtml_Block_Customer_Grid
{
    protected function _prepareColumns()
    {
        parent::_prepareColumns();

        $column = $this->getColumn('action');
        $actions = $column->getActions();
        $actions[] = array(
            'caption' => 'Log in',
            'popup' => true,
            'url' => array(
             'base' => 'ulogin/login/autologin'),
            'field' => 'customerid'
        );
        $column->setActions( $actions );

        return $this;
    }
}

This method tells Magento to add one more item to Actions column “Login”.
That’s all. You can try to go to Admin->Customers->Manage Customers. There will be a new action ‘Login’ in Actions column. Choose this action brings a new popup window where you will be logged in as a customer.
Do not forget to clean up Magento cache.

Advices and Best Practices for Magento developers

Yaroslav Rogoza — Mon, 10 Sep 2012 12:48:25 +0000

I think everyone who is interested in ecommerce development get familiar with Magento earlier or later. It’s a very popular platform, where a lot of modern programming technologies are used. Since Magento is one of the most powerful and flexible shopping cart engines, it requires a deep level of expertise to develop extensions or even do some basic changes. So we’ve decided to share our tips for Magento Developers in this article. [Continue to Part 2]
You can get tons of solutions from the Internet on how to make one or another modifications for Magento functionality, but it’s worth noting that not all of them are smart, guarantee results and follow best practices.
Every developer eventually gets to the experience level that allows him to follow good developing practice. I want to share my own findings with you. So lets start.

Never use app/code/local/Mage to override core files.

Instead of this always try to create your own extension to change/add/modify core logic. It saves you from errors upon further store upgrades or third party extension’s collisions. If you ever use
app/code/local/Mage, then only use it for temporary changes that you will remove afterwards.

Try to avoid overriding wherever it’s possible.

Use event-listeners, helpers, or extend (not override) the core classes to form your own. It also saves your extension from conflicts with third party addons. For example, you always can use event core_block_abstract_to_html_after to inject button or some other element into html where there is no ability to inject it properly using xml layouts. There’s no reason to override .phtml files or block’s logic. For example, if you want to add/remove logic for checkout.onepage.billing block you need to create your own extension and specify your block class within xml layout.

Where

class Your_Extension_Block_Checkout_Onepage_Billing extends Mage_Checkout_Block_Onepage_Billing

Do not remove generic blocks from *.phtml files or xml layouts.

For example, you don’t need a generic block with name ‘product_additional_data‘ (product view page) and you think you are able to delete it from code. But you should not do this. Magento third party extensions usually use generic blocks to inject their own blocks there. If you have deleted it, you may spend a lot of time to find out why some extension doesn’t work.

Use Magento generic CSS classes whenever possible.

There are thousands of CSS classes, that are defined in Magento default installation and if you are going to make a new store template, you should use those classnames in your new template. It’s a good practice, because there is a lot of third party extensions that use those classnames for design integration.

Always document your own code.

As a good programmer, you should always use PHPDoc in your projects. If you were faced with problem and trying to find out the solution, it’s always easier to explore documented code. Also you should think about other programmers who may be forced to work with your code

Always explore core abstract classes during your work with Magento.

It helps you to make your code more effectively. For example I met many developers who write their own methods for checking a status of their extensions (enabled/disabled) but only few of them use method isModuleEnabled() from Mage_Core_Helper_Abstract

Use cache for your own blocks.

Magento allows to use cache system separately for custom blocks. Using cache for the blocks may greatly improve your extensions performance. To enable cache for the block you need to use the following part of code in your block constructor:

class Your_Extension_Block_Blah extends Mage_Core_Block_Template
{
protected function _construct()
    {
        parent::_construct();

        $this->addData(array(
            'cache_lifetime'    => 43200,
            'cache_tags'        => array(Mage_Catalog_Model_Product::CACHE_TAG),
        ));
    } 
}

Use Magento built in log system for logging the behaviour of your extension.

It always helps to find issues faster if any. You are able to create/use your own log using the code:

Mage::log('There was a bug', null, 'log_filename.log');

Don’t forget to check if logging is enabled in Admin -> System -> Configuration -> Developer -> Debug .

Use Magento built in profiler to check the performance issues.

Magento allows to display loading time for separate parts at the bottom of every page for development purposes. First, enable the profiler via System -> Configuration -> Developer -> Debug -> Profiler (yes). Second, comment out the following line in index.php

#Varien_Profiler::enable();

Then you should see profiler on the store pages.

Use XML layouts to integrate features or extend functionality wherever it’s possible.

Magento allows to make different actions within layout XML files. As you know, it is possible to integrate your block somewhere in the design, but you can call different methods more efficiently using XML. Usually programmers forget about this feature. For example, you need to extend admin order’s grid with additional column. You can always extend Mage_Adminhtml_Block_Sales_Order_Grid but it’s not the best solution because it may be overwritten within some other extension. Instead of this, you can call method AddColumn, AddColumnAfter or some other directly from xml layout. Take a look at the example below:


        
            
                street
                
                    Street
                    text
                    sales_flat_order_address.street
                
                entity_id

Use IDE (Integrated Development Environment).

There are many useful IDE to make Magento developing process faster, easier and more pleasant. You can try the most popular of them and choose which one is the best for you. There are many advantages of using IDE. You can inspect parent and abstract classes faster since most of IDE’s supports classes inheritance inspection. Popular IDE’s have the debugger in their toolset. It also may help you to save your time. Version control support, syntax checking, deployment management, smart snippets, refactoring, projects management and much more you can find in the modern IDE’s. As you can see, one application replaces many tools you have used before. All you need, is to find a convenient IDE for you and customise every detail.

To be continued… Part 2.

P.S. It would be great to see your own findings of Magento development in the comments.

Adding thumbnail images to the Magento admin product grid

Yaroslav Rogoza — Tue, 28 Feb 2012 10:07:07 +0000

This article describes how to insert images in the Magento admin product grid.
First of all, you will need to create your own extension. Let’s call it: Atwix_Gridthumbs.

Create a file /app/etc/modules/Atwix_Gridthumbs.xml with this content:



    
        
            true
            community

Next step is the module’s config file. It should be located in /app/code/community/Atwix/Gridthumbs/etc/config.xml. The config file content will be like this:



    
        
            1.0
        
    
    
        
            
                
                    Atwix_Gridthumbs_Adminhtml_Block_Catalog_Product_Grid

Now we need to override standard grid file. Create file /app/code/community/Atwix/Gridthumbs/Adminhtml/Block/Catalog/Product/Grid.php with the following content:

addColumn('image', array(
            'header' => Mage::helper('catalog')->__('Image'),
            'align' => 'left',
            'index' => 'image',
            'width'     => '70',
            'renderer' => 'Atwix_Gridthumbs_Block_Adminhtml_Template_Grid_Renderer_Image'
        )); 
        return parent::_prepareColumns();
    }
}

Here you can see line ‘renderer’ => ‘Atwix_Gridthumbs_Block_Adminhtml_Template_Grid_Renderer_Image’ . It says to use the custom renderer for image column. There’s no standard renderer for images, so we need to create it. Create the renderer file /app/code/community/Atwix/Gridthumbs/Block/Adminhtml/Template/Grid/Renderer/Image.php with source:

_getValue($row);
    } 
    protected function _getValue(Varien_Object $row)
    {       
        $val = $row->getData($this->getColumn()->getIndex());
        $val = str_replace("no_selection", "", $val);
        $url = Mage::getBaseUrl('media') . 'catalog/product' . $val; 
        $out = ""; 
        return $out;
    }
}

Renderers return html or just plain text for the cell in the column. You can get the necessary values with the construction $row->getData($this->getColumn()->getIndex());
$this->getColumn()->getIndex(); returns the column index which was entered in addColumn in the previous step. If there is not an image associated with a product, image url will say “no_selection”, so we should remove this string for empty cells with construction $val = str_replace(“no_selection”, “”, $val);
That’s it! To be safe, as will all changes, you should flush cache and log out/log in to be sure you are seeing the new content. Now you can see available images in product grid. Happy coding!

Magento auto invoice and set custom order status upon checkout

Yaroslav Rogoza — Mon, 17 Oct 2011 09:03:21 +0000

Many developers are wondering how to customize Magento behavior once an order has been placed. In particular, sometimes a company would like to change the order status to “Pending” and send an invoice to the customer automatically after checkout. The following article offers a simple solution for this.Let’s assume that we need to have the order status set to “Processing” instead of “Pending” for orders paid with the “Credit Card Save” payment method and have the standard invoice sent automatically at the same time.

A custom Magento module will be required for this task. Let’s name it Atwix_Orderhook.
Step 1

First, create a module initializer in /app/etc/modules/Atwix_Orderhook.xml with the following content:



    
        
            true
            community

Step 2

Create a module configuration file config.xml in /app/code/community/NAMESPACE/MODULENAME/etc/
(replace NAMESPACE and MODULENAME with your own values). In our case the path will be /app/code/community/Atwix/Orderhook/etc/.

config.xml content:



    
        
            1.0
        
    

    

                    
            
                Atwix_Orderhook_Model
            
        

        
            
                
                    
                        singleton
                        orderhook/observer
                        implementOrderStatus

As you can see, we have described observer in the events section. Observers allow you to execute some operations after a desired event took place. We need to observe the sales_order_place_after event in our extension. This event takes place after an order has been placed. Also, do not forget to init your Model path in the models section, like the example above.
… section contains a path to the file with observer class. In our case the file is app/code/community/Atwix/Orderhook/Observer.php, which we will create later.
Section … contains the method’s name, which will be called on in the sales_order_place_after event.

Step 3

Create observer file app/code/community/Atwix/Orderhook/Model/Observer.php with the following content:

getOrder();

        if ($this->_getPaymentMethod($order) == 'ccsave') {
            if ($order->canInvoice())
                $this->_processOrderStatus($order);
        }
        return $this;
    }

    private function _getPaymentMethod($order)
    {
        return $order->getPayment()->getMethodInstance()->getCode();
    }

    private function _processOrderStatus($order)
    {
        $invoice = $order->prepareInvoice();

        $invoice->register();
        Mage::getModel('core/resource_transaction')
           ->addObject($invoice)
           ->addObject($invoice->getOrder())
           ->save();

        $invoice->sendEmail(true, '');
        $this->_changeOrderStatus($order);
        return true;
    }

    private function _changeOrderStatus($order)
    {
        $statusMessage = '';
        $order->setState(Mage_Sales_Model_Order::STATE_PROCESSING, true);        
	$order->save();
    }
}

implementOrderStatus($event) {…} function will be called upon completion of the order’s placement. As you can see, there are some conditions inside that are responsible for the payment method name verification. As we have described above – order status will be changed only if “Credit Card Save” payment method has been used with the order. If you don’t need these conditions – just remove the verification.
_processOrderStatus Method creates an invoice for the order and sends it to the customer.
_changeOrderStatus Method changes the order status to STATE_PROCESSING.

That’s it. You can easily write your own handlers with any functionality from this observer. For example, you can send an additional email or shut down the server after an order has been placed

P.S. Here is a list of the order statuses that you can apply to the order object:

/**
 * change order status to 'Completed'
 */
$order->setState(Mage_Sales_Model_Order::STATE_COMPLETE, true)->save();
Similarly, you can change the order status to pending, processing, canceled, closed, held, etc.

/**
 * change order status to "Pending"
 */
$order->setState(Mage_Sales_Model_Order::STATE_NEW, true)->save();

/**
 * change order status to "Pending Paypal"
 */
$order->setState(Mage_Sales_Model_Order::STATE_PENDING_PAYMENT, true)->save();

/**
 * change order status to "Processing"
 */
$order->setState(Mage_Sales_Model_Order::STATE_PROCESSING, true)->save();

/**
 * change order status to "Completed"
 */
$order->setState(Mage_Sales_Model_Order::STATE_COMPLETE, true)->save();

/**
 * change order status to "Closed"
 */
$order->setState(Mage_Sales_Model_Order::STATE_CLOSED, true)->save();

/**
 * change order status to "Canceled"
 */
$order->setState(Mage_Sales_Model_Order::STATE_CANCELED, true)->save();

/**
 * change order status to "Held"
 */
$order->setState(Mage_Sales_Model_Order::STATE_HOLDED, true)->save();