Precio de producto configurable de Magento que reemplaza el precio de producto simple

21

Tengo productos configurados de forma idéntica (por lo que puedo decir) y todos fueron importados con una plantilla CSV universal.

  • El precio configurable es 29.99
  • La manga corta del producto simple asociado es 29.99
  • Producto simple asociado de manga larga es 39.99

Una factura facturó recientemente un producto de manga larga ( ZTWS-SBLS-XL ) que tiene un precio de 39.99 con un precio de producto configurable de 29.99. ¿Cómo puedo forzar que el precio simple del producto anule el precio configurable del producto? Ambos productos a continuación se configuran de manera idéntica con su producto configurable principal y como productos simples.

Factura:

Item             Sku             Qty    Subtotal
Item one         ZLOB-SBLS-XL    1      $39.99
Item Two         ZTWS-SBLS-XL    1      $29.99

EDITAR: Todavía estoy trabajando en resolver esto. ¿Qué haría que Magento prefiriera el precio del producto simple sobre el precio del producto configurable o el precio del atributo del producto asociado?

TylersSN
fuente
¿Puedo obtener ayuda magento.stackexchange.com/q/291238/57334 @TylersSN
zus

Respuestas:

18

Cuando crea un producto configurable, no importa cuál sea el precio de los productos simples: estos precios se ignoran por completo. Entonces, si desea vender un producto simple A que tiene un precio de $ 29.99 y un producto simple B ($ 39.99), debe crear un producto configurable, establecer su precio en $ 29.99 y abrir la pestaña Producto asociado . Agregue los productos que desea asociar con este producto configurable. Después de agregarlos, aparece un bloque llamado Configuración de atributos de Super producto que contiene opciones y diferencias de precios. Deje vacío el precio del producto A y ponga 10 (+ $ 10) en el campo de precio del producto B y listo: diferentes productos simples tienen diferentes precios.

En realidad, hay una extensión que le permite usar precios de productos simples en lugar de diferencias de precios, pero es un poco complicado de configurar. Como es una extensión gratuita, espero que nadie se queje de que pegue su enlace aquí:

https://github.com/organicinternet/magento-configurable-simple

Pronto
fuente
Me ayudaste a entender mi problema. He actualizado mi esquema de precios para que los productos tengan un precio de 29,99. Desde productos asociados agregamos $ 10 a los atributos de manga larga y $ 2 por> = 2x atributos. Lo interesante es que esto funciona para algunos productos, mientras que no funciona en otros productos configurables.
TylersSN
Para los productos en los que no funciona, magento prefiere el precio simple del producto sobre el precio configurable, ya sea establecido en el propio producto o en el precio de los atributos de los productos asociados.
TylersSN
55
La extensión es basura y con errores.
Alireza Fallah
¿Puedo obtener ayuda con respecto a los productos configurables magento.stackexchange.com/q/291238/57334 @Pronto
zus
16

Por lo tanto, uso el siguiente código en combinación con una extensión como productos orgánicos configurables simples de Internet.

El siguiente código está destinado al proceso de compra / compra, esencialmente, es una actualización del modelo de precio configurable que pasa el cálculo del precio a un producto simple en caso de que el producto haya sido agregado al carrito --- esta solución NO muestra el precio en la página del producto en sí (sin embargo, hay muchas extensiones que ya lo hacen).

Actualice app / code / core / Mage / Catalog / Model / Product / Type / Configurable / Price.php (lo ideal es que use una extensión o anulación local en app / code / local)

Actualice el método: getFinalPrice, cambie a

public function getFinalPrice($qty=null, $product)
{
    //Start edit
    $selectedAttributes = array();
    if ($product->getCustomOption('attributes')) {
        $selectedAttributes = unserialize($product->getCustomOption('attributes')->getValue());
    }
    //End edit
    if (sizeof($selectedAttributes)) return $this->getSimpleProductPrice($qty, $product);

    if (is_null($qty) && !is_null($product->getCalculatedFinalPrice())) {
        return $product->getCalculatedFinalPrice();
    }

    $basePrice = $this->getBasePrice($product, $qty);
    $finalPrice = $basePrice;
    $product->setFinalPrice($finalPrice);
    Mage::dispatchEvent('catalog_product_get_final_price', array('product' => $product, 'qty' => $qty));
    $finalPrice = $product->getData('final_price');

    $finalPrice += $this->getTotalConfigurableItemsPrice($product, $finalPrice);
    $finalPrice += $this->_applyOptionsPrice($product, $qty, $basePrice) - $basePrice;
    $finalPrice = max(0, $finalPrice);

    $product->setFinalPrice($finalPrice);
    return $finalPrice;
}

Luego agregue esta función justo debajo de getFinalPrice:

public function getSimpleProductPrice($qty=null, $product)
    {
        $cfgId = $product->getId();
        $product->getTypeInstance(true)
            ->setStoreFilter($product->getStore(), $product);
        $attributes = $product->getTypeInstance(true)
            ->getConfigurableAttributes($product);
        $selectedAttributes = array();
        if ($product->getCustomOption('attributes')) {
            $selectedAttributes = unserialize($product->getCustomOption('attributes')->getValue());
        }
        $db = Mage::getSingleton('core/resource')->getConnection('core_read');
        $dbMeta = Mage::getSingleton('core/resource');
        $sql = <<<SQL
SELECT main_table.entity_id FROM {$dbMeta->getTableName('catalog/product')} `main_table` INNER JOIN
{$dbMeta->getTableName('catalog/product_super_link')} `sl` ON sl.parent_id = {$cfgId}
SQL;
        foreach($selectedAttributes as $attributeId => $optionId) {
            $alias = "a{$attributeId}";
            $sql .= ' INNER JOIN ' . $dbMeta->getTableName('catalog/product') . "_int" . " $alias ON $alias.entity_id = main_table.entity_id AND $alias.attribute_id = $attributeId AND $alias.value = $optionId AND $alias.entity_id = sl.product_id";
        }
        $id = $db->fetchOne($sql);
        return Mage::getModel("catalog/product")->load($id)->getFinalPrice($qty);
    }

Puede ver que, en caso de que el usuario haya "personalizado" el producto (IE, opciones configurables seleccionadas), determinamos el producto simple asociado y pasamos el control a su modelo de precios, de lo contrario, si el producto no está "personalizado" (IE, nosotros estás navegando en la página del producto) procedemos normalmente

Alan
fuente
esta respuesta es genial, bravo!
pixiemedia
5

Usando Magento Versión 1.9.2.2

Puede ser una solución ligeramente mejor, utilice el enfoque 'Observador' en lugar de piratear el núcleo o incluso anular la clase de precio del modelo predeterminada, es decir, aplicación / código / núcleo / Mage / Catálogo / Modelo / Producto / Tipo / Configurable / Price.php

Todo lo que tiene que hacer es usar el código de Alan dentro de su Observador recién creado, la única diferencia es en lugar de regresar

Mage::getModel("catalog/product")->load($id)->getFinalPrice($qty);

Reemplácelo con lo siguiente:

$fp = Mage::getModel("catalog/product")->load($id)->getFinalPrice($qty);
return $product->setFinalPrice($fp);

Sigue este Observer.php

class YourFolderinLOCAL_YourModulename_Model_Observer 
{

     public function simpleProductPrice(Varien_Event_Observer $observer) {
        $event   = $observer->getEvent();
        $product = $event->getProduct();
        $qty     = $event->getQty();
        //Mage::log($observer, null, 'confPricing.log');
        // process percentage discounts only for simple products


            $selectedAttributes = array();
            if ($product->getCustomOption('attributes')) {
                Mage::log('yes-----', null, 'confPricing.log');
                $selectedAttributes = unserialize($product->getCustomOption('attributes')->getValue());
            }

            if (sizeof($selectedAttributes)) return $this->getSimpleProductPrice($qty, $product);



    }


    public function getSimpleProductPrice($qty=null, $product)
    {

        $cfgId = $product->getId();
        $product->getTypeInstance(true)
            ->setStoreFilter($product->getStore(), $product);
        $attributes = $product->getTypeInstance(true)
            ->getConfigurableAttributes($product);
        $selectedAttributes = array();
        if ($product->getCustomOption('attributes')) {
            $selectedAttributes = unserialize($product->getCustomOption('attributes')->getValue());
        }
        $db = Mage::getSingleton('core/resource')->getConnection('core_read');
        $dbMeta = Mage::getSingleton('core/resource');
        $sql = <<<SQL
SELECT main_table.entity_id FROM {$dbMeta->getTableName('catalog/product')} `main_table` INNER JOIN
{$dbMeta->getTableName('catalog/product_super_link')} `sl` ON sl.parent_id = {$cfgId}
SQL;
        foreach($selectedAttributes as $attributeId => $optionId) {
            $alias = "a{$attributeId}";
            $sql .= ' INNER JOIN ' . $dbMeta->getTableName('catalog/product') . "_int" . " $alias ON $alias.entity_id = main_table.entity_id AND $alias.attribute_id = $attributeId AND $alias.value = $optionId AND $alias.entity_id = sl.product_id";
        }
        $id = $db->fetchOne($sql);
        //Mage::log(Mage::getModel("catalog/product")->load($id)->getFinalPrice($qty), null, 'confPricing.log');
        //return 
        $fp = Mage::getModel("catalog/product")->load($id)->getFinalPrice($qty);
        return $product->setFinalPrice($fp);
    }


}

Config.xml

<?xml version="1.0"?>
<config> 
 <modules>
        <YourFolderinLOCAL_YourModulename>
            <version>0.0.1</version>
        </YourFolderinLOCAL_YourModulename>
    </modules>
    <global>
        <models>
            <YourFolderinLOCALYourModulename><!-- Al lovwercase in my case -->
                <class>Your_Model</class><!-- not needed in my case -->
            </YourFolderinLOCALYourModulename>
        </models>

    </global>
    <frontend>
    <events>
            <catalog_product_get_final_price>
                <observers>
                    <YourFolderinLOCAL_YourModulename_model_observer>
                        <type>singleton</type>
                        <class> YourFolderinLOCAL_YourModulename_Model_Observer</class>
                        <method>simpleProductPrice</method>
                    </YourFolderinLOCAL_YourModulenameg_model_observer>
                </observers>
            </catalog_product_get_final_price>

        </events>
        </frontend>
</config>

Espero que resuelva el problema .. :)

Zeeshan
fuente
2

Si los productos simples tienen un precio diferente pero se configuran contra el producto configurable sin una fijación de precio, ya sea fija o porcentual, se tomará el precio del producto configurable. No importa qué productos simples se compren, su precio no parece ser tenido en cuenta.

Para actualizar esto, simplemente vaya al producto principal en la sección de administración, luego, en la pestaña Associated Products, puede actualizar el precio de cada producto secundario para agregar un precio adicional al precio de los productos principales.

David modales
fuente
Hola David, he intentado esto. Mi esfuerzo actual consiste en establecer el precio del producto configurable en $ 0.00 y desde la sección de Productos asociados estoy tratando de establecer un precio fijo de $ 29.99 en atributos de manga corta y $ 39.99 en camisas de manga larga. Por alguna razón, todavía hay un único producto configurable (manga larga) que quiere cobrar $ 29.99 a pesar del precio fijo Y el precio establecido dentro del producto simple. Gracias por su respuesta.
TylersSN
@ user1812580 ¿puedes ver este producto en el administrador o simplemente en el front end?
David Manners
Puedo verlo como un producto simple separado asociado con el producto configurable.
TylersSN
Hola David, he actualizado el esquema de precios como se indica en mi respuesta a @Pronto. Espero que eso te ayude a ayudarme.
TylersSN
@DavidManners He intentado actualizar mi precio a través de la sección Super Attributes Config en el producto configurable. Sin embargo, el precio solo se actualiza en el cuadro de información de precio SUPERIOR (donde están el sku, el nombre del producto, etc.) cuando hace clic en la variación. ¿Algún consejo sobre cómo actualizar el cuadro de precios más bajos también?
Elva Sandoval
2

También estoy teniendo el mismo problema y lo solucioné usando el siguiente código. Funcionará también en el lado del administrador si hace un pedido al administrador (para pedidos telefónicos)

Observa este evento,

sales_quote_item_set_product 

y agregue el siguiente código en su Observer.php

public function loadQuote(Varien_Event_Observer $observer)
            {

                $event      = $observer->getEvent();
                $quote_item = $event->getQuoteItem();
                $storeId    = $quote_item->getStoreId();
                $item       = $observer->getQuoteItem();
                $product    = $observer->getProduct();
                $sku        = $product->getSku();
                $productDetails     =  Mage::getModel('catalog/product')
                            ->setStoreId($storeId)
                            ->loadByAttribute('sku',$sku);

                $price      = $productDetails->getPrice();
                $sprice     = $productDetails->getFinalPrice();

                $item->setOriginalCustomPrice($sprice);
                $item->setOriginalPrice($price);

            }

Obtendrá el precio del producto asociado y se guardará en la cotización.

Elavarasan
fuente
+1 para $item->setOriginalCustomPrice($sprice);y $item->setOriginalPrice($price);, que permite múltiples elementos configurables que apuntan al mismo producto, en el carrito, con diferentes precios.
Niloct
2

Siga los pasos a continuación para cambiar el precio del súper atributo

Primero use observadores "catalog_product_get_final_price". Haz observadores como este:

Abra su módulo config.xml y use el siguiente código:

<events>
    <catalog_product_get_final_price>
        <observers>
            <Setblue_Banner_Model_Observer>
                <type>singleton</type>
                <class>Setblue_Banner_Model_Observer</class>
                <method>getFinalPrice</method>
            </Setblue_Banner_Model_Observer>
        </observers>
    </catalog_product_get_final_price>
</events>

Ahora crea el archivo Observer.php en el modelo y luego debajo del código

<?php
class Setblue_Banner_Model_Observer
{

 public function getFinalPrice(Varien_Event_Observer $observer) {

  $event   = $observer->getEvent();
        $product = $event->getProduct();
        $qty     = $event->getQty();

  $selectedAttributes = array();
  if ($product->getCustomOption('attributes')) {
   Mage::log('yes-----', null, 'confPricing.log');
   $selectedAttributes = unserialize($product->getCustomOption('attributes')->getValue());
  }

  if (sizeof($selectedAttributes)) return $this->getSimpleProductPrice($qty, $product);

    }

 public function getSimpleProductPrice($qty=null, $product)
    {

  $cfgId = $product->getId();
        $product->getTypeInstance(true)
            ->setStoreFilter($product->getStore(), $product);
        $attributes = $product->getTypeInstance(true)
            ->getConfigurableAttributes($product);
        $selectedAttributes = array();
        if ($product->getCustomOption('attributes')) {
            $selectedAttributes = unserialize($product->getCustomOption('attributes')->getValue());
        }
        $db = Mage::getSingleton('core/resource')->getConnection('core_read');
        $dbMeta = Mage::getSingleton('core/resource');
        $sql = <<<SQL
SELECT main_table.entity_id FROM {$dbMeta->getTableName('catalog/product')} `main_table` INNER JOIN
{$dbMeta->getTableName('catalog/product_super_link')} `sl` ON sl.parent_id = {$cfgId}
SQL;
        foreach($selectedAttributes as $attributeId => $optionId) {
            $alias = "a{$attributeId}";
            $sql .= ' INNER JOIN ' . $dbMeta->getTableName('catalog/product') . "_int" . " $alias ON $alias.entity_id = main_table.entity_id AND $alias.attribute_id = $attributeId AND $alias.value = $optionId AND $alias.entity_id = sl.product_id";
        }
        $id = $db->fetchOne($sql);
        //Mage::log(Mage::getModel("catalog/product")->load($id)->getFinalPrice($qty), null, 'confPricing.log');
        //return
        $fp = Mage::getModel("catalog/product")->load($id)->getFinalPrice($qty);
        return $product->setFinalPrice($fp);
 }

}

?>

Ahora abra app / design / frontend / default / yourtheme / template / catalog / product / view / type / options / configurable.phtml y pegue el siguiente código en cualquier parte del archivo

<ul class="productIds" style="display:none;">
    <?php
        $configurableProduct = Mage::getModel('catalog/product')->load($_product->getId());
        $childProducts = Mage::getModel('catalog/product_type_configurable')->getUsedProducts(null,$configurableProduct);
        foreach($childProducts as $child) {
            $_productObj = Mage::getModel('catalog/product')->load($child->getId());
            ?>
            <li id='simple_<?php echo $child->getId(); ?>'><?php echo Mage::helper('core')->currency($_productObj->getFinalPrice()); ?></li>
        <?php   
        }
    ?>
</ul>

Ahora abra js / varien / configurable.js y cambie la función reloadPrice como se muestra a continuación o también puede reemplazar toda esta función

reloadPrice: function(){
    if (this.config.disablePriceReload) {
        return;
    }
    var price    = 0;
    var oldPrice = 0;
    for(var i=this.settings.length-1;i>=0;i--){
        var selected = this.settings[i].options[this.settings[i].selectedIndex];
        if(selected.config){
            price    += parseFloat(selected.config.price);
            oldPrice += parseFloat(selected.config.oldPrice);
        }
    }

    /* Edit Code By Chandresh Rana*/

     //optionsPrice.changePrice('config', {'price': price, 'oldPrice': oldPrice});
     optionsPrice.reload();

     var existingProducts = new Object();
     for(var i=this.settings.length-1;i>=0;i--)
     {
         var selected = this.settings[i].options[this.settings[i].selectedIndex];
         if(selected.config)
         {
            for(var iproducts=0;iproducts<selected.config.products.length;iproducts++)
            {
                var usedAsKey = selected.config.products[iproducts]+"";
                if(existingProducts[usedAsKey]==undefined)
                {
                    existingProducts[usedAsKey]=1;
                }
                else
                {
                    existingProducts[usedAsKey]=existingProducts[usedAsKey]+1;
                }
             }
         }
     }

     for (var keyValue in existingProducts)
     {
        for ( var keyValueInner in existingProducts)
         {
            if(Number(existingProducts[keyValueInner])<Number(existingProducts[keyValue]))
            {
                delete existingProducts[keyValueInner];
            }
         }
     }

     var sizeOfExistingProducts=0;
     var currentSimpleProductId = "";
     for ( var keyValue in existingProducts)
     {
        currentSimpleProductId = keyValue;
        sizeOfExistingProducts=sizeOfExistingProducts+1
     }

     if(sizeOfExistingProducts==1)
     {
        if($('product-price-'+this.config.productId)){
            $('product-price-'+this.config.productId).innerHTML = jQuery("#simple_"+currentSimpleProductId).html();
        }

     }
    // End Code By Chandresh Rana

    return price;

    if($('product-price-'+this.config.productId)){
        $('product-price-'+this.config.productId).innerHTML = price;
    }
    this.reloadOldPrice();
},

Código tomado de: http://chandreshrana.blogspot.in/2016/03/set-simple-product-price-instead-of.html

Chandresh Rana
fuente
¿Puedo obtener ayuda con respecto a los productos configurables magento.stackexchange.com/q/291238/57334 @Chandresh Rana
zus