because it will slow up dramatically your site.
Better use the following piece of code:

<?php

$productSku = 'sku1';

$pname = Mage::getSingleton("catalog/product")
	    		->getCollection()
	    		->addFieldToFilter('sku', $newpsku)
	    		->addAttributeToSelect('name')
	    		->load()
	    		->getFirstItem()
	    		->getName();

Let’s say you have configurable products in your Magento site. 
Each configurable product has 1 parent product (configurable product) and some (let’s say 2) children (simple product). Let’s say you wish to display the product list on your category page, but each product should have it’s parent URL.

Lets implement this:
I assume you wish to implement this in base/default/template/catalog/product/list.phtml

<?php $i=0; foreach ($_productCollection as $_product):
	$prodId = $_product->getId();
	$arrayOfParentIds = Mage::getSingleton("catalog/product_type_configurable")->getParentIdsByChild($prodId);
	$parentId = (count($arrayOfParentIds) > 0 ? $arrayOfParentIds[0] : null);
	$url = $_product->getProductUrl();
	if(!is_null($parentId)){
		$url = Mage::getModel("catalog/product")->load($parentId)->getProductUrl();
	}
?>

This implementation will work, but it isn’t recommended when performing on a large collection (more than 5 products / page). why? Because, the action

Mage::getModel("catalog/product")->load($parentId);

is pretty expensive in terms of efficiency (in other words – it takes large amount of time for the server to perform this action). looping on this action more than once or twice will slow your website down dramatically.

So here is the alternative. might be more complicated, but a lot more efficient (implementation):

<?php
        $rewrite = Mage::getModel('core/url_rewrite');

	$params = array();
	$params['_current']     = false;

	?>
	<?php $i=0; foreach ($_productCollection as $_product):

	$prodId = $_product->getId();
	$arrayOfParentIds = Mage::getSingleton("catalog/product_type_configurable")->getParentIdsByChild($prodId);
	$parentId = (count($arrayOfParentIds) > 0 ? $arrayOfParentIds[0] : null);
	$url = $_product->getProductUrl();
	$idPath = 'product/'.$parentId;
	$rewrite->loadByIdPath($idPath);

	$parentUrl = Mage::getUrl($rewrite->getRequestPath(), $params);
	$url = ($parentUrl ? $parentUrl : $url);
	?>

This implemenation is much more cheaper in terms of efficiency, because we use

$rewrite->loadByIdPath($idPath);

instead of the expensive

Mage::getModel("catalog/product")->load($parentId);

which means, less loading time.

That’s all

For this, go to app/code/local/Engineering/Helloworld/controllers/IndexController.php and change its code to following:

<?php class Engineering_Helloworld_IndexController extends Mage_Core_Controller_Front_Action
{
	public function indexAction()
	{
	    $this->loadLayout();
            $this->renderLayout();
	}
}

A short explanation:
When calling to

$this->loadLayout();

Magento will go to “app/design/myinterface/mytheme/layout” (on a fresh Magento installation, it actually “app/design/base/default/layout”) reads all the XML files and searches there for a tag named layout and loads the found data to “core/layout” object.
Now, when calling to

$this->renderLayout();

the layout will be rendered.

Now lets go to www.mysite.com/helloworld – we will see some empty standard Magento design. It’s because only tags get loaded.

Now go to app/code/local/Engineering/Helloworld/etc/config.xml and add some change to it:

<?xml version="1.0"?>
<config>
 <modules>
  <Engineering_Helloworld>
   <version>0.1.0</version>
  </Engineering_Helloworld>
 </modules>
 <frontend>
  <routers>
   <engineering_helloworld>
    <use>standard</use>
    <args>
     <module>Engineering_Helloworld</module>
     <frontName>helloworld</frontName>
    </args>
   </engineering_helloworld>
  </routers>
  <layout>
   <updates>
    <engineering_helloworld>
     <file>helloworld.xml</file>
    </engineering_helloworld>
  </updates>
  </layout>
 </frontend>
</config>

This tells magento to regard the file named helloworld.xml as another layout file. Now create the helloworld.xml at:
app/design/frontend/default/default/layout/helloworld.xml
Type in the following:

<?xml version="1.0"?>
<layout version="0.1.0">
 <engineering_helloworld_index_index>
  <reference name="content">
   <block type="core/template" name="helloworld.text" template="engineering/helloworld/sayhello.phtml"/>
  </reference>
 </engineering_helloworld_index_index>
</layout>

Because the URL is www.mysite.com/helloworld/index/index magento will load the content of <helloworld_index_index> tag to the layout object.  Afterwards, the

$this->renderLayout();

will put the block named “helloworld.text” to the block named “content”,  load the block class “core/template” (Mage_Core_Block_Template) and template “engineering/helloworld/sayhello.phtml” (app/design/frontend/myinterface/mytheme/engineering/helloworld/sayhello.phtml)  for this block.

Now, create “sayhello.phtml” at
app/design/frontend/default/default/template/engineering/helloworld/sayhello.phtml
type there just

Hello World

Now, go to www.mysite.com/admin/helloworld – you should see the text “Hello world” inside magento design.

Go to “app/code/local” and create a new folder. name it “Packagename” – the “Packagename” is likely to be your company name – this folder will serve all the extensions that will be made by your company. I’ll call it “Engineering”.

Inside the “Packagename” folder, create another folder named “Modulename” – the “Modulename” is the name of your module – I’ll name it “Helloworld”. now we should have the following path:

app/code/local/Engineering/Helloworld

Now you have to tell Magento about your extension, so create a file named “Engineering_Helloworld.xml” in the following path:

app/etc/modules/Engineering_Helloworld.xml

type in the following:

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

Magento is a configuration-set MVC system. that means, if you want the URL

www.mysite.com/helloworld/index/index

will display “Hello World”, you need to tell Magento about this. Create a file named “config.xml” in the following path (create the etc folder, also):

app/code/local/Engineering/Helloworld/etc/config.xml

type in the following:

<?xml version="1.0"?>
<config>
 <modules>
  <Engineering_Helloworld>
   <version>0.1.0</version>
  </Engineering_Helloworld>
 </modules>
 <frontend>
  <routers>
   <engineering_helloworld>
    <use>standard</use>
    <args>
     <module>Engineering_Helloworld</module>
     <frontName>helloworld</frontName>
    </args>
   </engineering_helloworld>
  </routers>
 </frontend>
</config>

A short explanation about the config.xml tags:
The <use> tag in the <router> hierarcy, tells Magento whether the <router> tag refers to admin url or the frontend url. we want the URL www.mysite.com/helloworld/index/index, and not  www.mysite.com/admin/helloworld/index/index, so that means we need the frontend. the <use> is “standard” (other options are “admin” and “default”).
The tag <engineering_helloworld> under <routers> seems to be arbitrary, but sure, there are conventions, so you need to write your full module name in lower case.
The tag <frontName> tells Magento about the first string of your extension’s URL, so the URL is:
www.mysite.com/helloworld/index/index
and not, for example
www.mysite.com/byeworld/index/index
[Note: you have to make sure that the term "helloworld" isn't already occupied by other extension or core module, otherwise the Magento's behavior will be unpredicted.]

Now it’s time to write the code for the output “Hello World”:
For us, to make the page

www.mysite.com/helloworld/index/index

display “Hello World”, we need to create a file named “indexController.php” at:

app/code/local/Engineering/Helloworld/controllers/IndexController.php

and type in the following code:

<?php
class Engineering_Helloworld_IndexController extends Mage_Core_Controller_Front_Action
{
    public function indexAction()
    {
    echo "Hello World";
    }
}

Now, go to www.mysite.com/helloworld/index/index, and you should see the desired “Hello World”.
So, actually, when you go to www.mysite.com/helloworld/index/index, Magento is looking for a front name “helloworld” through all the active module configurations. if found, it searches for indexController. if found, it’s looking for
indexAction inside that controller.
Now try to go to www.mysite.com/helloworld – you should see the same result, this is only because when nothing mentioned after the module name, Magento looking for index/index by default.

On the next post, we will add some design to our extension page – so don’t go anywhere

Writing Magento Extension – part2

Let’s say you would like to know what query is used to get a product collection – go to your debugging area (or maybe some phtml file), and paste following code:

$_productCollection = Mage::getResourceModel("catalog/product_collection");
$_productCollection->load(true);

Passing “true” as a parameter to the load function, will print out the query that Magento uses to retrieve the items for the collection.

For some reason you want to show the products whose price is lower than 100$.
If you go to list.phtml at app/design/frontend/base/default/template/catalog/product, you will see the following line:

$_productCollection=$this->getLoadedProductCollection();

$_productCollection is instance of Mage_Catalog_Model_Resource_Eav_Mysql4_Product_Collection, and of course this is already loaded collection (collection that has items). resource collections in Magento – once the collection is loaded, you cannot add anything to the “select” and then call “load” again – this will not change the items of a collection. The solution is:

$_productCollection->clear();
$_productCollection->getSelect()->where('price_index.price < 100'); $_productCollection->load();

In line 1 we called to “clear” function that deleted all items in the collection, but preserved the current select. So in the line 2 we added stuff to the select, and called “load”. This gave us the desired result.

It may sound surprising, but a chunk of code that triggers all the functionality of the layered navigation, is placed in “Mage_Catalog_Block_Layer_View”, inside the function “_prepareLayout()”.

When is the function _prepareLayout being called?

The function “_prepareLayout()” exists in every block, and it’s being called each time the block is being created.
Therefore, each time the block “Mage_Catalog_Block_Layer_View” is created, it’s function “_prepareLayout()” is being called.

Here we loop over all the filterable attributes and filter the current product collection by each of them:
We create an appropriate block for each attribute (for example, for dropdown attribute, we create block from class “Mage_Catalog_Block_Layer_Filter_Attribute”) and call its “init” function.

/* FILE: code/core/Mage/Catalog/Block/Layer/View.php Function:_prepareLayout */
/**
     * Prepare child blocks
     *
     * @return Mage_Catalog_Block_Layer_View
     */
    protected function _prepareLayout()
    {
        $stateBlock = $this->getLayout()->createBlock($this->_stateBlockName)
            ->setLayer($this->getLayer());

        $categoryBlock = $this->getLayout()->createBlock($this->_categoryBlockName)
            ->setLayer($this->getLayer())
            ->init();

        $this->setChild('layer_state', $stateBlock);
        $this->setChild('category_filter', $categoryBlock);

        $filterableAttributes = $this->_getFilterableAttributes();
        foreach ($filterableAttributes as $attribute) {
            if ($attribute->getAttributeCode() == 'price') {
                $filterBlockName = $this->_priceFilterBlockName;
            }
            elseif ($attribute->getBackendType() == 'decimal') {
                $filterBlockName = $this->_decimalFilterBlockName;
            }
            else {
                $filterBlockName = $this->_attributeFilterBlockName;
            }

            $this->setChild($attribute->getAttributeCode() . '_filter',
                $this->getLayout()->createBlock($filterBlockName)
                    ->setLayer($this->getLayer())
                    ->setAttributeModel($attribute)
                    ->init());
        }

        $this->getLayer()->apply();

        return parent::_prepareLayout();
    }

Inside the “init” function we have a call to “_initFilter”:

Here (line 15) we call the apply function on the model that regards the filter block. (e.g:  for the block “Mage_Catalog_Block_Layer_Filter_Attribute”, the model will be “Mage_Catalog_Model_Layer_Filter_Attribute”)

/* FILE: code/core/Mage/Catalog/Block/Layer/Filter/Abstract.php Function:_initFilter */
/**
     * Init filter model object
     *
     * @return Mage_Catalog_Block_Layer_Filter_Abstract
     */
    protected function _initFilter()
    {
        if (!$this->_filterModelName) {
            Mage::throwException(Mage::helper('catalog')->__('Filter model name must be declared.'));
        }
        $this->_filter = Mage::getModel($this->_filterModelName)
            ->setLayer($this->getLayer());
        $this->_prepareFilter();

        $this->_filter->apply($this->getRequest(), $this);
        return $this;
    }

 /* FILE: code/core/Mage/Catalog/Model/Layer/Filter/Attribute.php Function:apply */

So finally, the filter is applied to product collection if it exists and has non-empty value in the request URI.
 The apply is performed by
$this->_getResource()->applyFilterToCollection($this, $filter);
(in the following code chunk).
/**

* Apply attribute option filter to product collection

*

* @param   Zend_Controller_Request_Abstract $request

* @param   Varien_Object $filterBlock

* @return  Mage_Catalog_Model_Layer_Filter_Attribute

*/

public function apply(Zend_Controller_Request_Abstract $request, $filterBlock)

{

$filter = $request->getParam($this->_requestVar);

if (is_array($filter)) {

return $this;

}

$text = $this->_getOptionText($filter);

if ($filter && $text) {

$this->_getResource()->applyFilterToCollection($this, $filter);

$this->getLayer()->getState()->addFilter($this->_createItem($text, $filter));

$this->_items = array();

}

return $this;

}

While “_getResource” returns a resource model of this class (in our example for the class “Mage_Catalog_Model_Layer_Filter_Attribute” “_getResource” will return “Mage_Catalog_Model_Resource_Eav_Mysql4_Layer_Filter_Attribute” object), and there it calls “applyFilterToCollection” that builds appropriate SQL query according to the attribute and its value in URI.

And thats all,when the loop ends running we have a filtered product collection. And if we go now to “Mage_Catalog_Block_Product_List” (the block that shows the product collection),we will see that the collection is retrieved from layer (“Mage_Catalog_Model_Layer”) – this is the object which we have loaded the filtered product collection to it after looping over all filterable attributes.

Summary

As we have seen, the architecture of Magento Layered Navigation is simple – the creation of “Mage_Catalog_Block_Layer_View” block triggers looping on models that regards the filterable attributes, and save the filtered product collection back to the layer.

After understanding the architecture of Magento Layered Navigation we have the power to customize Magento Layered Navigation to our own needs.
Read the next posts of this series, to see the examples of our new capabilities.

What is Magento Layered Navigation?

Magento Layered Navigation is a piece of functionality that allows customers to filter categories in the following way:
If you have to example a category named “Apparel” and the products inside this category have
attributes such as color, manufacturer, etc., you can tell Magento to display a sidebar that will allow the customers to filter the category named “Apparel” by those attributes (and some others – will be explained later in this article). The next image shows an example of such sidebar:

How to make such a sidebar appear on my desired category?

To make such a sidebar appear on a desired category and contain a desired attribute, you must follow next 3 simple steps:

1) Make the desired category “anchor”: Go to the admin panel -> Catalog -> Manage Categories. On the left, click on the category that you want to make filterable. On the right, click on the “Display Settings” tab, and choose “Yes” on “In Anchor” field.

2) Add filterable attributes: Go  to the admin panel ->Catalog -> Attributes -> Manage Attributes.  Add attribute which you wish to filter by (Detailed explanation about adding/managing  attributes -here). Make sure that you choose “Filterable (without results)” or” Filterabe (with results)” in”Use In Layered Navigation” field (To do so, you must choose “Dropdown” or “Multiple Select” or “Price”  in “Catalog Input Type for Store Owner” field).  Also don’t forget to add some options (on Manage Label/Options tab). Finaly, make sure that you added those attributes to some attribute set (Detailed explanation about adding/managing  attribute sets – in next articles), remember the name of this set for next section.

3)Apply attributes on some products: if in the previous section, you set “Filterable (without results)” for the attribute, you will not see this attribute on the sidebar, until you will have some products that has a value for this attribute. So, create new product (choose tha attribute set that you chose in a previous section), or update existing product (that has this attribute on it’s attribute set), so that the field of the attribute(s) you added, will contain some value. Don’t forget to set a desired category as a category of this product.

Now, on your desired category page, you should see a sidebar, that contains the attribute you added.

(Note: those 3 steps are 100% effective for clean Magento installation. If some modifications where done to the code/design files, those steps may not suffice.)

In the next article we will learn about the architecture of a Magento Layered Navigation.