Luckily, I have a solution for you to try out.  Seems to work pretty good for one of Tridian’s Magento clients. Are you curious? Good. Then let’s dive right in.

The goal for this module is to accommodate the following requirement: If you have a tier price discount at 10 and add 5 of one color and 5 of another, the cart will adjust the price for the 2 cart items to the 10 qty price.

I installed it as a module that extends Mage_Catalog_Model_Product_Type_Configurable_Price. 

1. Create your module.  I created mine in app/code/local/Tridian/Catalog.  Use your own namespace instead of Tridian, if you prefer.  Create Model and etc sub folders in Catalog.
2. Add xml to Tridian_All.xml in app/etc/modules/Tridian_All.xml
3. Set up rewrite in app/code/local/Tridian/Catalog/etc/config.xml
4. Extend the class and save to app/code/local/Tridian/Catalog/Model/Product/Type/Configurable/Price.php

Here’s my app/etc/modules/Tridian_All.xml

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

Here’s my app/code/local/Tridian/Catalog/etc/config.xml

<?xml version="1.0"?>

<config>
    <modules>
        <Tridian_Catalog>
            <version>0.1.0</version>
        </Tridian_Catalog>
    </modules>
    <global>
        <models>
            <catalog>
                <rewrite>
                    <product_type_configurable_price>Tridian_Catalog_Model_Product_Type_Configurable_Price</product_type_configurable_price>
                </rewrite>
            </catalog>
        </models>
    </global>
</config>

And lastly here’s the extended class

class Tridian_Catalog_Model_Product_Type_Configurable_Price extends Mage_Catalog_Model_Product_Type_Configurable_Price
{
    /**
     * Get product final price
     *
     * @param   double $qty
     * @param   Mage_Catalog_Model_Product $product
     * @return  double
     */
    public function getFinalPrice($qty=null, $product)
    {
        if (is_null($qty) && !is_null($product->getCalculatedFinalPrice())) {
            return $product->getCalculatedFinalPrice();
        }

        $finalPrice = parent::getFinalPrice($qty, $product);

        // Call config product tier pricing function - Chris Lohman 1/6/2009
        /* This allows for tier price to affect configurable items of different sizes, colors, etc.
         * so that when you have some qty of each, the total will be counted towards the tier pricing matrix.
         */
        $tierPrice = $this->calcConfigProductTierPricing($product);
        if($tierPrice > 0)
            $finalPrice = $tierPrice;
          $finalPrice = $this->_applySpecialPrice($product, $finalPrice); 
        
        $product->getTypeInstance()->setStoreFilter($product->getStore());
        $attributes = $product->getTypeInstance()->getConfigurableAttributes();

        $selectedAttributes = array();
        if ($product->getCustomOption('attributes')) {
            $selectedAttributes = unserialize($product->getCustomOption('attributes')->getValue());
        }
        
        $basePrice = $finalPrice;
        foreach ($attributes as $attribute) {
            $attributeId = $attribute->getProductAttribute()->getId();
            $value = $this->_getValueByIndex(
                $attribute->getPrices() ? $attribute->getPrices() : array(),
                isset($selectedAttributes[$attributeId]) ? $selectedAttributes[$attributeId] : null
            );
            if($value) {
                if($value['pricing_value'] != 0) {
                    $finalPrice += $this->_calcSelectionPrice($value, $basePrice);
                }
            }
        }
        $product->setFinalPrice($finalPrice);
        return max(0, $product->getData('final_price'));
    }

    /**
     * Get product final price via configurable product's tier pricing structure.  Uses qty of parent item to determine price.
     *
     * @param   float $price
     * @param   Mage_Catalog_Model_Product $product
     * @return  float
     */
    public function calcConfigProductTierPricing($product)
    {
        $tierPrice = 0;
        if($items = Mage::getSingleton('checkout/session')->getQuote()->getItemsCollection())
        {
            //The items collection has instances of the parent and simple product.  The correct quantity value is related to the parent
            //so if we loop through and create an array of skus w/quantities, the quantities will fall into array items under the parent sku (array key).
            $cfg_quantities = array();
            foreach ($items as $item)
            {
                $sku = $item->getSku();
                $qty = $item->getQty();
                $cfg_quantities[$sku][] = $qty;
            }

            if(array_key_exists($product->getSku(), $cfg_quantities))
            {
                $cfg_qty = array_sum($cfg_quantities[$product->getSku()]);
                $tierPrice = $this->getTierPrice($cfg_qty, $product);
            }
        }
        return $tierPrice;
    }
}

I know - that’s a lot of code, right? Well, let me explain how it works and you’ll see that it’s not all that bad, ok? The theory is to use the relationship that already exists between the configurable product and its child simple products. The function getTierPrice takes a quantity and a product as parameters, so all we need to do is figure out the total number of items in the cart that share the same parent configurable item and then pass that new total to the getTierPrice function. This is exactly what our calcConfigProductTierPricing function does. Counting up the products is accomplished by taking advantage of the structure of the products collection that’s returned from the cart. The product collection has entries for the parent and simple version of each product in the cart. The quantity of that item in the cart is assigned to the parent member of the collection. So when we have 2 items in the cart that share the same parent, as a red shirt and black shirt of the same product, we can loop through the collection and take the sku value from the parent and then create a secondary array of the quantity of each item. That way, quantities for different child products will all become secondary arrays under the same key (which happens to be the sku of the parent). Once we’ve looped through the entire cart collection, we check if the current product’s sku is in the configurable products array using the array_key_exists function, and if so, we sum the quantities of the array and then use that new total to submit to our getTierPrice function. Now, if you offer a price break at ten items and someone buys 5 red and 5 black, they’ll get the pricing discount!

Keep in mind, that if you are using a different version of Magento, like 1.1.7 or 1.1.8, etc. you should extend *YOUR* version of Mage_Catalog_Model_Product_Type_Configurable_Price, instead of copying my code from this post.  Most of the code of the function getFinalPrice in my extended class is copied directly from my 1.1.6 version of Mage_Catalog_Model_Product_Type_Configurable_Price.  The only lines I added to getFinalPrice() are the 4 lines that call my calcConfigProductTierPricing() function, then check to see if the price is greater than 0, and then apply the special price if it’s lower than the tier price. Everything else in the function is existing code from the core class.

// Call config product tier pricing function - Chris Lohman 1/6/2009
        /* This allows for tier price to affect configurable items of different sizes, colors, etc.
         * so that when you have some qty of each, the total will be counted towards the tier pricing matrix.
         */
        $tierPrice = $this->calcConfigProductTierPricing($product);
        if($tierPrice > 0)
            $finalPrice = $tierPrice;
        $finalPrice = $this->_applySpecialPrice($product, $finalPrice);

So, use the getFinalPrice function from *YOUR* Magento version’s Mage_Catalog_Model_Product_Type_Configurable_Price class as your starting point, and then insert those 4 additional lines to call calcConfigProductTierPricing, and then your version of Tridian_Catalog_Model_Product_Type_Configurable_Price will be good to go.

Cheers!

So, Tridian has been doing quite a bit of Magento development work lately, and in keeping with the spirit of “open source” software, we thought we’d share a module that we recently developed that addresses a very common need when creating an e-store with Magento. The requirements are to get the X most recently products added to the store (108 in this case) and display them in their own “New Arrivals” category, but make it so that the cart will automatically display the newest products based on the product’s creation date, without the site admin having to manually assigned them into and out of a “New Arrivals” category.

In order to create “New Arrivals” functionality on my client’s Magento store (which is 1.1.6, but this code also works for all versions of Magento through the current 1.2.0.1), I created the following module. My approach was to override the normal category behavior for my “New Arrivals” category and display a custom product collection instead.

Here’s how it went down…

Step 1: In the admin, create a category called “New Arrivals” and leave it empty.

Step 2: Find the code that generates the product listings on the Category pages. Turns out the code that does this is in the class Mage_Catalog_Block_Product_List. Great. But now, in order to get the cart to do what we want, we have to override this class and add my own custom code to handle the creation of the product collection for the empty category “New Arrivals”. To do this, I created a new block file called Tridian_Newarrivals_Block_Newarrivals, which extends the original, and saved it here: app/code/local/Tridian/Newarrivals/Block/Newarrivals.php.

class Tridian_Newarrivals_Block_Newarrivals extends Mage_Catalog_Block_Product_List
{
    
     protected function _getProductCollection()  
     {  
        if (is_null($this->_productCollection)) {
            $curr_category = Mage::registry('current_category')->getName();
            $curr_categoryid = Mage::registry('current_category')->getId();
            $curr_category = strtolower($curr_category);
            if($curr_category == 'new arrivals')
            {
                $storeId    = Mage::app()->getStore()->getId();  
                $product    = Mage::getModel('catalog/product');  
                
                $this->_productCollection = Mage::getModel('catalog/resource_eav_mysql4_product_collection')
                    ->setStoreId($storeId)
                    ->addAttributeToSelect(array('name', 'price', 'small_image'), 'inner')
                    ->addAttributeToSelect(array('special_price'), 'left')
                    ->addAttributeToSelect('status')
                    ->setOrder('created_at', 'desc')
                    ->setPageSize(12)
                    ->addUrlRewrite($curr_categoryid)
                    ;//->load(true);  // passing true to load will echo the sql to the browser.

                    Mage::getSingleton('catalog/product_status')->addVisibleFilterToCollection($this->_productCollection);
                    // add InStock filter to prevent out of stock stuff from showing up.  Chris Lohman 1/29/2009
                    Mage::getSingleton('cataloginventory/stock')->addInStockFilterToCollection($this->_productCollection);
                    Mage::getSingleton('catalog/product_visibility')->addVisibleInSearchFilterToCollection($this->_productCollection);
            }
            else
            {
                $this->_productCollection = parent::_getProductCollection();
            }
        }
        return $this->_productCollection;  
    
     }  
}

As you can see in the code above, when the category name equals “new arrivals”, we implement the custom product collection. If not, then the class calls the parent function, which is just the _getProductCollection() function in the Mage_Catalog_Block_Product_List class. The key things to notice here are the page size (12), which should be chosen to match your default page size for your store (our client’s store defaults to 12 items per page), and the setOrder(’created_at’, ‘desc’) call, which sorts the results in descending order by when the product was created/added to the Magento admin. You can also see that we’ve added some filters to the collection to keep unwanted products from showing up in the results (out of stock items, etc).

Great! Sounds like we’re done, right? Not so fast. Turns out that the toolbar that handles the category pagination uses the size of the product collection (which in this case is the entire catalog, sorted from most recently added to least recently added). Doh. We only want to show the most recent 108. In order for our result set to actually be limited to 108 products, it turns out that we also need to change the behavior of the Mage_Catalog_Model_Resource_Eav_Mysql4_Product_Collection class to use our new limit instead of using the size of the returned product collection. That leads us to…

Step 3: Create the following model class: app/code/local/Tridian/Newarrivals/Model/Newarrivals.php

class Tridian_Newarrivals_Model_Newarrivals extends Mage_Catalog_Model_Resource_Eav_Mysql4_Product_Collection
{
    /**
     * Render SQL for retrieve product count
     */
    public function getSelectCountSql()
    {
        $curr_category = Mage::registry('current_category')->getName();
        $curr_category = strtolower($curr_category);
        if($curr_category == 'new arrivals')
        {
            $sql = "select 108";
        }
        else
        {
            $sql = parent::getSelectCountSql();
        }
        return $sql;
    }

}

You’re probably wondering why I picked 108, right? Well to make a long story short - my catalog pages display either 12, 24, or 36 items. If I didn’t use a multiple of all of those values, then the toolbar would display the pagination links incorrectly. If you don’t believe me, try it out for yourself. As before, you see that if the category isn’t “new arrivals”, then the class falls back to its original behavior by calling the parent function.

Well done! The hard part is over. Now all we need to do is activate our module in Magento and then set up our rewrite xml in our config.xml file to get Magento to use our new classes instead of the originals.

Here’s the code to tell the cart to override the original block and model classes. Save it as config.xml and put it here app/code/local/Tridian/Newarrivals/etc/config.xml:

<?xml version="1.0"?>

<config>
    <modules>
        <Tridian_Newarrivals>
            <version>0.1.0</version>
        </Tridian_Newarrivals>
    </modules>
    <global>
        <blocks>
            <catalog>
                <rewrite>
                    <product_list>Tridian_Newarrivals_Block_Newarrivals</product_list>
                </rewrite>
            </catalog>
        </blocks>
        <models>
            <catalog>
                <rewrite>
                    <resource_eav_mysql4_product_collection>Tridian_Newarrivals_Model_Newarrivals</resource_eav_mysql4_product_collection>
                </rewrite>
            </catalog>
        </models>
    </global>
</config>

You need to activate your module in app/etc/modules. We created a file named Tridian_All.xml for this.

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

Just to be crystal clear, since this is where a lot of slip ups occur with Magento – make sure you follow the naming conventions and file locations to a “T”. They are very specific and case sensitive.

As a recap, here’s where your files should go:

Tridian_All.xml (turns on module) goes -> app/etc/modules/Tridian_All.xml
Module code (3 components) goes -> app/code/local/Tridian/Newarrivals
Block class Tridian_Newarrivals_Block_Newarrivals goes -> app/code/local/Tridian/Newarrivals/Block/Newarrivals.php
Model class Tridian_Newarrivals_Model_Newarrivals goes -> app/code/local/Tridian/Newarrivals/Model/Newarrivals.php
config.xml (xml config file for module) goes -> app/code/local/Tridian/Newarrivals/etc/config.xml

And there you have it. The front end will now display your most recent products in their own “New Arrivals” category and it will always be the most recently added.

Feel free to post any questions or comments.

Cheers!