magento
Comprensione dei tipi di prodotto

Osservazioni

getChildren()

getAllChildren()

getChildrenCategories()

<global>
    <index>
        <indexer>
            <{name}>{model}</{name}>
        </indexer>
    </index>
</global>

Mage_Catalog_Model_Product_Type

/**
 * Magento
 *
 * NOTICE OF LICENSE
 *
 * This source file is subject to the Open Software License (OSL 3.0)
 * that is bundled with this package in the file LICENSE.txt.
 * It is also available through the world-wide-web at this URL:
 * http://opensource.org/licenses/osl-3.0.php
 * If you did not receive a copy of the license and are unable to
 * obtain it through the world-wide-web, please send an email
 * to [email protected] so we can send you a copy immediately.
 *
 * DISCLAIMER
 *
 * Do not edit or add to this file if you wish to upgrade Magento to newer
 * versions in the future. If you wish to customize Magento for your
 * needs please refer to http://www.magentocommerce.com for more information.
 *
 * @category    Mage
 * @package     Mage_Catalog
 * @copyright   Copyright (c) 2012 Magento Inc. (http://www.magentocommerce.com)
 * @license     http://opensource.org/licenses/osl-3.0.php  Open Software License (OSL 3.0)
 */

/**
 * Product type model
 *
 * @category    Mage
 * @package     Mage_Catalog
 * @author      Magento Core Team 
 */
class Mage_Catalog_Model_Product_Type
{
    /**
     * Available product types
     */
    const TYPE_SIMPLE       = 'simple';
    const TYPE_BUNDLE       = 'bundle';
    const TYPE_CONFIGURABLE = 'configurable';
    const TYPE_GROUPED      = 'grouped';
    const TYPE_VIRTUAL      = 'virtual';

    const DEFAULT_TYPE      = 'simple';
    const DEFAULT_TYPE_MODEL    = 'catalog/product_type_simple';
    const DEFAULT_PRICE_MODEL   = 'catalog/product_type_price';

    static protected $_types;
    static protected $_compositeTypes;
    static protected $_priceModels;
    static protected $_typesPriority;

    /**
     * Product type instance factory
     *
     * @param   Mage_Catalog_Model_Product $product
     * @param   bool $singleton
     * @return  Mage_Catalog_Model_Product_Type_Abstract
     */
    public static function factory($product, $singleton = false)
    {
        $types = self::getTypes();
        $typeId = $product->getTypeId();

        if (!empty($types[$typeId]['model'])) {
            $typeModelName = $types[$typeId]['model'];
        } else {
            $typeModelName = self::DEFAULT_TYPE_MODEL;
            $typeId = self::DEFAULT_TYPE;
        }

        if ($singleton === true) {
            $typeModel = Mage::getSingleton($typeModelName);
        }
        else {
            $typeModel = Mage::getModel($typeModelName);
            $typeModel->setProduct($product);
        }
        $typeModel->setConfig($types[$typeId]);
        return $typeModel;
    }

    /**
     * Product type price model factory
     *
     * @param   string $productType
     * @return  Mage_Catalog_Model_Product_Type_Price
     */
    public static function priceFactory($productType)
    {
        if (isset(self::$_priceModels[$productType])) {
            return self::$_priceModels[$productType];
        }

        $types = self::getTypes();

        if (!empty($types[$productType]['price_model'])) {
            $priceModelName = $types[$productType]['price_model'];
        } else {
            $priceModelName = self::DEFAULT_PRICE_MODEL;
        }

        self::$_priceModels[$productType] = Mage::getModel($priceModelName);
        return self::$_priceModels[$productType];
    }

    static public function getOptionArray()
    {
        $options = array();
        foreach(self::getTypes() as $typeId=>$type) {
            $options[$typeId] = Mage::helper('catalog')->__($type['label']);
        }

        return $options;
    }

    static public function getAllOption()
    {
        $options = self::getOptionArray();
        array_unshift($options, array('value'=>'', 'label'=>''));
        return $options;
    }

    static public function getAllOptions()
    {
        $res = array();
        $res[] = array('value'=>'', 'label'=>'');
        foreach (self::getOptionArray() as $index => $value) {
            $res[] = array(
               'value' => $index,
               'label' => $value
            );
        }
        return $res;
    }

    static public function getOptions()
    {
        $res = array();
        foreach (self::getOptionArray() as $index => $value) {
            $res[] = array(
               'value' => $index,
               'label' => $value
            );
        }
        return $res;
    }

    static public function getOptionText($optionId)
    {
        $options = self::getOptionArray();
        return isset($options[$optionId]) ? $options[$optionId] : null;
    }

    static public function getTypes()
    {
        if (is_null(self::$_types)) {
            $productTypes = Mage::getConfig()->getNode('global/catalog/product/type')->asArray();
            foreach ($productTypes as $productKey => $productConfig) {
                $moduleName = 'catalog';
                if (isset($productConfig['@']['module'])) {
                    $moduleName = $productConfig['@']['module'];
                }
                $translatedLabel = Mage::helper($moduleName)->__($productConfig['label']);
                $productTypes[$productKey]['label'] = $translatedLabel;
            }
            self::$_types = $productTypes;
        }

        return self::$_types;
    }

    /**
     * Return composite product type Ids
     *
     * @return array
     */
    static public function getCompositeTypes()
    {
        if (is_null(self::$_compositeTypes)) {
            self::$_compositeTypes = array();
            $types = self::getTypes();
            foreach ($types as $typeId=>$typeInfo) {
                if (array_key_exists('composite', $typeInfo) && $typeInfo['composite']) {
                    self::$_compositeTypes[] = $typeId;
                }
            }
        }
        return self::$_compositeTypes;
    }

    /**
     * Return product types by type indexing priority
     *
     * @return array
     */
    public static function getTypesByPriority()
    {
        if (is_null(self::$_typesPriority)) {
            self::$_typesPriority = array();
            $a = array();
            $b = array();

            $types = self::getTypes();
            foreach ($types as $typeId => $typeInfo) {
                $priority = isset($typeInfo['index_priority']) ? abs(intval($typeInfo['index_priority'])) : 0;
                if (!empty($typeInfo['composite'])) {
                    $b[$typeId] = $priority;
                } else {
                    $a[$typeId] = $priority;
                }
            }

            asort($a, SORT_NUMERIC);
            asort($b, SORT_NUMERIC);

            foreach (array_keys($a) as $typeId) {
                self::$_typesPriority[$typeId] = $types[$typeId];
            }
            foreach (array_keys($b) as $typeId) {
                self::$_typesPriority[$typeId] = $types[$typeId];
            }
        }
        return self::$_typesPriority;
    }
}

Descrivere tipi di prodotti standard (semplici, configurabili, in bundle)

Semplice

Il tipo di prodotti semplici dovrebbe essere usato in quanto generalmente hanno una configurazione singola (taglia unica). Questo potrebbe includere elementi come:

• Una scatola di pastelli, piccola (24 colori)
• Una scatola di pastelli, grande (64 colori)
• Monitor per computer HD da 26 "SuperHighTech
• Barrack Obama Action Figure (6 ")

raggruppate

I prodotti raggruppati ti consentono di creare un nuovo prodotto utilizzando uno o più prodotti esistenti nel tuo negozio. Ad esempio, supponiamo di avere già una "figura d'azione di Barrack Obama" e una "figura d'azione di George W. Bush" nel tuo negozio e volevi venderle come un pacchetto. Dovresti semplicemente creare un nuovo prodotto raggruppato (chiamiamolo "Obama + Bush (prendi entrambi e spendi due volte tanto!)", Quindi aggiungi entrambe le figure di azione al gruppo tramite la scheda "Prodotti associati".

Nota: Purtroppo, non è possibile impostare un prezzo speciale per "gruppo" direttamente dalla pagina del prodotto. Per offrire uno sconto per l'acquisto di articoli, dovrai creare una nuova regola del prezzo del carrello.

configurabile

Prodotto configurabile: questo prodotto consente ai clienti di selezionare la variante che desiderano scegliendo le opzioni. Ad esempio, puoi vendere magliette in due colori e tre taglie. Dovresti creare sei prodotti semplici come singoli prodotti (ciascuno con i propri SKU) e quindi aggiungere questi sei a un prodotto configurabile in cui i clienti possono scegliere la dimensione e il colore, quindi aggiungerlo al carrello. Funzionalità molto simile è possibile utilizzando le opzioni personalizzate per i prodotti semplici. La differenza tra un prodotto configurabile e un prodotto che include opzioni personalizzate è che l'inventario non viene controllato o aggiornato per le singole opzioni durante l'acquisto delle opzioni personalizzate.

Virtuale

I prodotti virtuali sono quelli che non hanno una controparte fisica o digitale. Non spediscono, né hanno un link per il download. Questo tipo di prodotto potrebbe essere utilizzato per servizi come:

• Pulizie di casa
• Iscrizione alla newsletter di 1 anno

Nota: se si utilizzano prodotti virtuali per "abbonamenti", è importante notare che non esiste un modo integrato per gestire gli abbonamenti con rinnovo automatico. Tutti gli acquisti effettuati in Magento, indipendentemente dal tipo di prodotto, sono acquisti una tantum.

impacchettare

Questo tipo di prodotto è anche noto come "kit" in altri software eCommerce. Questo tipo di prodotto è ideale per le circostanze in cui l'utente deve selezionare un numero di opzioni configurabili, ma almeno un'opzione. Questo potrebbe includere prodotti come:

• Sistemi informatici personalizzabili
• Smoking / tute personalizzabili
• Fai clic qui per un'esercitazione video sull'utilizzo dei pacchetti

Scaricabile

I prodotti scaricabili sono simili ai prodotti virtuali, tranne che includono la possibilità di aggiungere uno o più file digitali per il download. I file possono essere caricati tramite l'interfaccia di amministrazione o caricati direttamente sul server tramite FTP e quindi aggiunti tramite URL. Quando un cliente acquista un prodotto scaricabile, Magento genererà un collegamento crittografato sicuro (in modo che i clienti non possano vedere la posizione reale del file) affinché quel cliente possa scaricare il proprio file.

Questa categoria potrebbe includere prodotti come:

• Musica / Mp3
• Software per il computer

Nota : se hai SSL abilitato per il tuo sito, i download potrebbero non riuscire in tutte le versioni di IE poiché IE contiene un bug che impedisce il download su connessioni sicure se è impostata l'intestazione no-cache. Questo può essere facilmente risolto in un file htaccess rimuovendo le intestazioni no-cache e no-store o forzando i link di download a non essere sicuri.