Obtenha o preço mais baixo e mais alto possível para um produto configurável

Qual seria uma boa maneira de recuperar os preços mais baixos e mais altos possíveis para um determinado produto configurável - com base em suas opções disponíveis?

Por exemplo, uma camiseta vem nos seguintes tamanhos e preços:

Small - $10
Medium - $20
Large - $30

Eu quero obter uma matriz como esta:

array(10, 30)

Até agora, minha melhor ideia é carregar a instância e o tipo de produto configurável e getUsedProductscriar uma matriz de preços, classificação e fatia.

Isso deve funcionar, no entanto, isso precisa ser executado no modelo de lista de produtos para que seja semi-eficiente.

Alguém aí já enfrentou esse problema antes?

EDIT - que não funcionará, pois eu quero o valor configurável do preço, ou seja, o preço aditivo que o magento coloca em cima do preço configurável do produto

Tente esta abordagem. use a matriz de configuração usada pelas listas suspensas de atributos para alterar o preço do produto configurável. Vamos supor que esse $productIdseja o ID do produto configurável.

$product = Mage::getModel('catalog/product')->load($productId);
$block = Mage::app()->getLayout()->createBlock('catalog/product_view_type_configurable');
$block->setProduct($product);
$config = json_decode($block->getJsonConfig(), true);
$basePrice = $config['basePrice'];
$min = null;
$max = null;
foreach ($config['attributes'] as $aId=>$aValues){
    foreach ($aValues['options'] as $key=>$value){
        if (is_null($min) || $min>$value['price']){
            $min = $value['price'];
        }
        if (is_null($max) || $max<$value['price']){
            $max = $value['price'];
        }
    }
}
//until here we have the min and max price differences. Now just add the base price.
$min += $basePrice;
$max += $basePrice;

Um mais simples.

if($_product->isConfigurable()) // check if the product is configurable (u may check this in for loop of products)
                {
                    //get associative (child) products
                    $childProducts = Mage::getModel('catalog/product_type_configurable')->getUsedProducts(null,$_product);
                    $childPriceLowest = "";    
                    $childPriceHighest = "";       
                    foreach($childProducts as $child){
                        $_child = Mage::getModel('catalog/product')->load($child->getId());

                        if($childPriceLowest == '' || $childPriceLowest > $_child->getPrice() )
                        $childPriceLowest =  $_child->getPrice();

                        if($childPriceHighest == '' || $childPriceHighest < $_child->getPrice() )
                        $childPriceHighest =  $_child->getPrice();

                    }
                    $price_array = array($childPriceLowest,$childPriceHighest); // array containing required values
                }

Essa resposta , também de @Marius, a uma pergunta semelhante é uma boa base para se trabalhar. Usando isso, aqui está uma solução para esse problema que leva em consideração o potencial de produtos configuráveis ​​com vários atributos que alteram o preço.

Eu escrevi isso como uma função que usa um ID de produto configurável e retorna uma sequência de min para preço máximo. Deve ficar bem claro como trabalhar no contexto que você precisa.

function getPriceRange($productId) {

 $max = '';
 $min = '';

 $pricesByAttributeValues = array();

 $product = Mage::getModel('catalog/product')->load($productId); 
 $attributes = $product->getTypeInstance(true)->getConfigurableAttributes($product);
 $basePrice = $product->getFinalPrice();

 foreach ($attributes as $attribute){
    $prices = $attribute->getPrices();
    foreach ($prices as $price){
        if ($price['is_percent']){ //if the price is specified in percents
            $pricesByAttributeValues[$price['value_index']] = (float)$price['pricing_value'] * $basePrice / 100;
        }
        else { //if the price is absolute value
            $pricesByAttributeValues[$price['value_index']] = (float)$price['pricing_value'];
        }
    }
 }


 $simple = $product->getTypeInstance()->getUsedProducts();

 foreach ($simple as $sProduct){
    $totalPrice = $basePrice;

    foreach ($attributes as $attribute){

        $value = $sProduct->getData($attribute->getProductAttribute()->getAttributeCode());
        if (isset($pricesByAttributeValues[$value])){
            $totalPrice += $pricesByAttributeValues[$value];
        }
    }
    if(!$max || $totalPrice > $max)
        $max = $totalPrice;
    if(!$min || $totalPrice < $min)
        $min = $totalPrice;
 }

 return "$min - $max";

}

Isso fará o truque, embora não seja o melhor exemplo

<?php $_configurable = $_product->getTypeInstance()->getUsedProductIds(); ?>
<?php $price_array = array(); $i=0; ?>
<?php foreach ($_configurable as $_config): ?>
    <?php $_simpleproduct = Mage::getModel('catalog/product')->load($_config); ?>
    <?php array_push($price_array, $_simpleproduct->getPrice()); ?>
<?php $i++; endforeach; ?>
<?php if(min($price_array) != max($price_array)): ?>
    <div class="price-box">
        <span id="product-price-<?php echo $_product->getId(); ?>" class="regular-price">
            <?php echo Mage::helper('core')->currency(min($price_array)); ?>
            <span class="price" style="padding: 0 5px; color: black;">-</span>
            <span class="final"><?php echo Mage::helper('core')->currency(max($price_array)); ?></span>
        </span>
    </div>
    <?php else: ?>
        <?php echo $this->getPriceHtml($_product, true); ?>
<?php endif; ?>

Usando o EE 1.14, eu estava obtendo números "engraçados" usando os métodos propostos acima, por algum motivo. Os $childPriceLoweste $childPriceHighestnão estavam retornando os valores mínimos e máximos verdadeiros o tempo todo. Às vezes, com várias opções de configuração, etc. Vi valores intermediários.

Acabei usando isso:

//get associated (child) products
$childProducts = Mage::getModel('catalog/product_type_configurable')
    ->getUsedProducts(null,$_product);

//cycle through child products, dump prices in an array.... 
foreach($childProducts as $child){  
   $_child = Mage::getModel('catalog/product')->load($child->getId());
   $childPrices[] = $_child->getPrice();
}

// concentrate the array to unique values and sort ascending....
$childPrices = array_unique($childPrices, SORT_NUMERIC);
sort($childPrices);     // array containing required values

Mais tarde, isso para ecoar o intervalo:

<?php echo Mage::helper('core')->currency( $childPrices[0], true, false); ?>
<span class="config-price-divider"> - </span>
<?php echo Mage::helper('core')->currency( end($childPrices), true, false)?>

(por exemplo, "US $ 10,00 - US $ 30,00")

Você também pode tentar este código simples para obter o preço mais alto / mais baixo conforme sua necessidade

$childPriceHighest = '';
         $product = Mage::getModel('catalog/product')->load($productId);
        $childProducts = Mage::getSingleton('catalog/product_type_configurable')->getUsedProducts( null, $product );

        if ($childProducts) {
            foreach ($childProducts as $child) {
                $_child = Mage::getSingleton('catalog/product')->load($child->getId());
                if ($childPriceHighest == '' || $childPriceHighest < $_child->getPrice()) {
                    $childPriceHighest = $_child->getPrice();
                }
            }
        } else {
            $childPriceHighest = $product->getPrice();
        }

        return $childPriceHighest;