Atwix » magento

Headers already sent. How to find the reason quickly

Yaroslav Rogoza — Thu, 11 Apr 2013 08:31:55 +0000

If you look inside of your Magento system.log from time to time, you will notice an error there like the following one:

2011-01-12T14:16:52+00:00 DEBUG (7): HEADERS ALREADY SENT:

Call stack is here..

As you may already know, it can take a lot of time to find the place where the issues like this one appeared. So, let’s investigate why it happens and what we can do to speed up the bug fixing process.

PHP has such definition as session. Session, it’s a global data which stores only on the server’s side. In other words, it’s a small temporary ‘storage’ with a predefined lifetime which contains data available globally for PHP scripts on the server side. Session provides opportunity to save an information which is required between requests from client to server. For example, if customer is logged in, his information (name, email, group etc..) stores in the session and becomes available between different scripts.

To get/set the session’s data PHP uses global variable $_SESSION by default. Actually, $_SESSION it’s an array, so you can access the data via array indexes i.e $_SESSION[‘customer’], $_SESSION[‘customer’][‘email’] etc.. PHP sessions have one singularity: you need to ‘start’ the session for each request to the server to initialize a current session and make $_SESSION variable available. For this purpose, PHP has built in function session_start(). However, you can’t initialize the session everywhere you want. You have to do it only before the server send some data to the client’s browser. Practically, you need to start the session before echo(), print(), readfile() and other output functions. If you don’t follow that rule your session won’t be initialized and, in addition, you’ll have PHP notice that says about sent headers.

Thereby, we are getting messages in Magento system.log about sent headers because of incorrect session initialization described above. The problem is the place of echo() might be everywhere and finding the place which is causing that error might cost you a whole day. Fortunately, Magento has a controller responsible for sending responses to a client side. As you may guess, we can use this controller to collect additional data that will help us to find the error’s place.

Let’s do a bad thing: make changes directly in the core file. Since it’s just a temporary change, we don’t have to create a copy of that file in the local codepool or create our own extension. Just modify the file directly and don’t forget to remove the changes after the debug process will be finished.

Open the following file with favourite text editor of yours: app/code/local/Mage/Core/Controller/Response/Http.php

and find the line says:

Mage::log('HEADERS ALREADY SENT: '.mageDebugBacktrace(true, true, true));

Then, insert the following line before the previous one:

Mage::Log(print_r(get_included_files(),true));

Save the file and move forward.

As you have already guessed, that change allows you to view the list of included files in the log. So, now you can open each of these files and search for echo(), print(), readfile() and other output functions.

The last thing: do not forget to roll back your changes after you’ll be finished. Otherwise you’ll be wondered how big the logs might be

How to insert your block into any place in Magento

Nick Kravchuk — Tue, 05 Mar 2013 10:22:53 +0000

Hello guys, it’s time to tell you how to insert block into any place you want in Magento. As you know, very often we need to set some block into selected weird place without editing template, so we’ll try to describe the way how to do this using layouts and observers.In our case, for such experiments will be used category page.
Let’s say, you need to place your block inside the other one and this block is instance of the Mage_Core_Block_Text_List class. That means, the block renders his children automatically, what’s easy. Then, you just need to follow the steps which are below:

This block will be displayed after all content of the “left“ block. But, what if we need it to be displayed before all content – just add the “before” directive. See below such example:

In case, you need to place your block between first level children of the “left” one, you should add before=”name” or after=”name”, and check following code:

That was pretty easy, but when we deal with none first level blocks – supposing, it is necessary to insert the block after price on the category page, and for such implementation you should use the observer core_block_abstract_to_html_before. Besides that, don’t forget to declare model in your config.xml:



    
    
         
            
                Atwix_Test_Model
            
        
    
    
        
            
                
                    
                        model
                        atwix_test/observer
                        insertBlock

The next step is creating the observer and your template file.
You can place the template to app/design/frontend///at.phtml for example. For this, look at the observer’s code below:

getBlock();
        /*get Block type*/
        $_type = $_block->getType();
       /*Check block type*/
        if ($_type == 'catalog/product_price') {
            /*Clone block instance*/
            $_child = clone $_block;
            /*set another type for block*/
            $_child->setType('test/block');
            /*set child for block*/
            $_block->setChild('child', $_child);
            /*set our template*/
            $_block->setTemplate('at.phtml');
        }
    }
}

And finally, here is a template at.phtml code:

getChildHtml('child') ?>
Hello

The result is:

That’s all folks! However, if you know another good way how to insert the blocks, please share your knowledges with us.

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

Adding a column to Magento orders grid – alternative way using layout handles

Volodymyr Vygovskyi — Mon, 28 Jan 2013 09:57:02 +0000

In the previous articles (1, 2) you might find the way how to add custom column/attribute to adminhtml (orders, customers, ect) grid. But this is another example. In our article we will use the layout handles for inserting columns to the orders grid.
First of all, you should create a new module (in our case Atwix_ExtendedGrid) and define layout update for adminhtml:



    ...
    
        
            
                atwix/extendedgrid.xml
            
        
    
    ...

Note, this configuration is enough for adding fields from sales_flat_order_grid table (no sql joins are needed). But most likely, you will also need to add some field from the external table. For this purpose we use sales_order_grid_collection_load_before event to join extra tables. Here is how the observer configuration looks like:



    ...
    
        
            
                
                    atwix_extendedgrid/observer
                    salesOrderGridCollectionLoadBefore
                
            
        
    
    ...

Then, add a function that handles our event to the observer:

/*file: app/code/local/Atwix/ExtendedGrid/Model/Observer.php*/
    /**
     * Joins extra tables for adding custom columns to Mage_Adminhtml_Block_Sales_Order_Grid
     * @param $observer
     */
    public function salesOrderGridCollectionLoadBefore($observer)
    {
        $collection = $observer->getOrderGridCollection();
        $select = $collection->getSelect();
        $select->joinLeft(array('payment'=>$collection->getTable('sales/order_payment')), 'payment.parent_id=main_table.entity_id',array('payment_method'=>'method'));
    }

As you can see, we join sales_flat_order_payment table to get a payment method field.

Now, it is time to add this field to the grid. We will use layout handles to call addColumnAfter method of sales_order.grid (Mage_Adminhtml_Block_Sales_Order_Grid) block. There are two handles that we are interested in: adminhtml_sales_order_index and adminhtml_sales_order_grid. The same code goes to both sections, so we will define a new handle sales_order_grid_update_handle and use update directive. And finally, here is how our layout file looks like:



    
        
            
                payment_method
                
                    Payment Method
                    payment_method
                    payment.method
                    text
                
                shipping_name

After all steps you should see your column:

Here is a source code of the completed module. I hope you will find this article useful! Thanks 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 ⇩

Adding custom product attribute to quote and order items in Magento

Volodymyr Vygovskyi — Thu, 03 Jan 2013 09:20:19 +0000

If you are developer, adding custom product attribute to quote and order items in Magento is pretty common task. And if you face with the same issue we will be very glad when you find this article helpful.
Start with creating new module. In config.xml we need to define resources section which allows us to use install and upgrade scripts. This way all necessary changes will be made in the database – so, let’s do it:


    
        
            Atwix_CustomAttribute
            Mage_Catalog_Model_Resource_Setup

Note, that module installation process will be divided in several steps. Using Magento setup classes (in our case Mage_Catalog_Model_Resource_Setup) we add new custom product attribute. This is our first step and here is how install script looks like (install-1.0.1.php):

$installer = $this;

$installer->addAttribute('catalog_product', 'custom_attribute', array(
    'group'             => 'General',
    'type'              => Varien_Db_Ddl_Table::TYPE_VARCHAR,
    'backend'           => '',
    'frontend'          => '',
    'label'             => 'Custom Attribute',
    'input'             => 'text',
    'class'             => '',
    'source'            => '',
    'global'            => Mage_Catalog_Model_Resource_Eav_Attribute::SCOPE_STORE,
    'visible'           => true,
    'required'          => false,
    'user_defined'      => true,
    'default'           => '',
    'searchable'        => true,
    'filterable'        => true,
    'comparable'        => true,
    'visible_on_front'  => true,
    'unique'            => false,
    'apply_to'          => 'simple,configurable,virtual',
    'is_configurable'   => false
));

After launching installer script we can see our custom attribute at the backend:

Next installation step is to add our custom attribute to the entities. In other words: to add neccessary fields to the tables, so we will be able to store our attribute. File upgrade-1.0.1-1.0.2.php:

$installer = new Mage_Sales_Model_Resource_Setup('core_setup');
/**
 * Add 'custom_attribute' attribute for entities
 */
$entities = array(
    'quote',
    'quote_address',
    'quote_item',
    'quote_address_item',
    'order',
    'order_item'
);
$options = array(
    'type'     => Varien_Db_Ddl_Table::TYPE_VARCHAR,
    'visible'  => true,
    'required' => false
);
foreach ($entities as $entity) {
    $installer->addAttribute($entity, 'custom_attribute', $options);
}
$installer->endSetup();

Note. Exclude entities that you don’t need.
So, the database tables are ready. Furthermore, we need to implement the mechanism for converting (copying) our custom product attribute to quote item and order item. Fortunately, it is pretty easy with Magento.
At first, you should add custom attribute to sales->quote->item->product_attributes node:

This makes attribute accessible when we will be copying it from the product to quote item – which is our next step. For this task the observer is used, and the event will be called sales_quote_item_set_product:


    
        
            atwix_customattribute/observer
            salesQuoteItemSetCustomAttribute

Obsever:

public function salesQuoteItemSetCustomAttribute($observer)
{
    $quoteItem = $observer->getQuoteItem();
    $product = $observer->getProduct();
    $quoteItem->setCustomAttribute($product->getCustomAttribute());
}

The last thing we need to carry about – it is converting attribute from quote item to order item. And this can be done with xml:

That’s it. Make a test order and check sales_flat_order_item table. If you see your custom attribute there that means – everything works. And source code can be found here. Good luck!

Passing multiple entities/collections into Magento email template

Nick Kravchuk — Mon, 24 Dec 2012 09:30:23 +0000

Hi friends, my previous article has been written about email sending feature in Magento, and you can read it here. But it seems that we have one more issue – how to display collections/arrays data in the email templates. We’ll try to shed the light on this below.The first thing we should know – is the impossibility to use foreach/for/while in the template. So we should include a block with the template from a current theme inside the email template instead, just like we do for CMS pages. See below:

{{block type='core/template' area='frontend' template='atwix/email/template.phtml'}}

Note, that is a very handy feature, but how do we pass data into the phtml file? – It’s easy:

{{block type='core/template' area='frontend' template='atwix/email/template.phtml' items=$items}}

And if you don’t remember how to pass data into email template, it will be helpful to read our previous articles
So, in this case $items variable may be an array or collection, etc…
Then, you just need to sort out your data in phtml-file, see the following example:

getItems() as $_item): ?>

As a result, you will see a dependence – if you pass items=$items you can get data in a phtml file using $this->getItems() function.

Seems that’s all, but we hope this short Magento article will be useful. Thanks for reading us!

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.

Adding new category attribute in Magento

Sergiy Vasyutynsky — Wed, 19 Dec 2012 10:27:55 +0000

In this article we would like to show you how to add a new custom category attribute. Let’s say, this attribute is needed to display some content on the category page.
First of all, we need to create a new module for adding custom category attribute, we will call it “Custom Category Attribute”.

Step 1. Create new module
We should let Magento know about our new module. Initial configuration file is located in ‘app/etc/modules/Atwix_CustomCategoryAttribute.xml’.
Atwix_CustomCategoryAttribute.xml



    
        
            true
            community

It means that the module is active and it is located in the community code pool.

Step 2. Configure module
Module configuration file is located in ‘app/code////etc’ and its name is config.xml – note, that in our case this looks like ‘ app/code/community/Atwix/CustomCategoryAttribute/etc/config.xml’. config.xml




    
        
            0.0.1
        
    

    
        
            
                
                    Atwix_CustomCategoryAttribute
                    Mage_Catalog_Model_Resource_Eav_Mysql4_Setup
                
                
                    core_setup
                
            
            
                
                    core_write
                
            
            
                
                    core_read
                
            
        
    


As you can see, configuration file is not large, there are two nodes only: module version and resources for install script. Install script helps us to create a new attribute. In the node  we defined the class for our install script which will be used for the extension. Working with methods of this class helps to create, update, remove attribute (etc). And the node  says that script must be located in the folder with the same name (in our case path will be ‘app/code/community/Atwix/CustomCategoryAttribute/sql/add_category_attribute’)
Step 3. Create attribute

Another important thing is to create install script file in the folder ‘add_category_attribute’, and the file name depends on the module version, so it looks like ‘mysql4-install-x.x.x.php’, where x.x.x is the version of the module.

mysql4-install-0.0.1.php
startSetup();
$this->addAttribute('catalog_category', 'custom_attribute', array(
    'group'         => 'General',
    'input'         => 'textarea',
    'type'          => 'text',
    'label'         => 'Custom attribute',
    'backend'       => '',
    'visible'       => true,
    'required'      => false,
    'visible_on_front' => true,
    'global'        => Mage_Catalog_Model_Resource_Eav_Attribute::SCOPE_GLOBAL,
));

$this->endSetup();

As a result, we created a new attribute in the category with label ‘Custom attribute ‘. This attribute is a text area and it must be visible on the frontend. Check this out!
Step 4. Check result

Here, let’s clear cache and after this, go to Manage Categories – in ‘General’ tab you will see a new attribute: ‘Custom attribute’.



Moreover, to see the content from ‘Custom attribute’ on the frontend in the category page – you need to use the helper for reading attribute in the template of this page (‘app/design/frontend/ //template/catalog/category/view.phtml’), check please the following code:
...
getCurrentCategory()->getCustomAttribute()): ?>
    categoryAttribute($_category, $_customAttribute, 'custom_attribute') ?>

...

As this code was put before ‘product list’ output, so after refreshing a page we will see the result:


Following all these steps, it will be great to enable wysiwyg editor for a new attribute, that will give us an opportunity to place different content with an inline styles in simple way.
Step 5. Update attribute

For each version of the module, it is also possible to have upgraded scripts which filenames are of the form mysql4-upgrade-0.0.1-0.0.2.php. It seems to be the best solution to update the attribute.

mysql4-upgrade-0.0.1-0.0.2.php
startSetup();
$this->addAttribute('catalog_category', 'custom_attribute', array(
    'group'         => 'General',
    'input'         => 'textarea',
    'type'          => 'text',
    'label'         => 'Custom attribute',
    'backend'       => '',
    'visible'       => true,
    'required'      => false,
    'wysiwyg_enabled' => true,
    'visible_on_front' => true,
    'is_html_allowed_on_front' => true,
    'global'        => Mage_Catalog_Model_Resource_Eav_Attribute::SCOPE_GLOBAL,
));

$this->endSetup();

As well, method addAttribute can not only create, but also update the attribute – that’s why, you may also use method updateAttribute.
Step 6. Check updated result

At last, we clear cache and see the button ‘ WYSIWYG Editor ‘ near ‘Custom attribute’. Also, it is necessary to use editor to change the content in this attribute, insert some image, format text and at the end – to save the changes. After all, you should refresh category page and see the result:


We hope this article will help you to work with Magento development. Thanks for reading!