magento
Comprendre les types de produits

Remarques

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;
    }
}

Décrire les types de produits standard (simple, configurable, groupé)

Simple

Le type Simple Products doit être utilisé pour ceux qui ont généralement une seule configuration (one-size-fits-all). Cela pourrait inclure des éléments tels que:

• Une boîte de crayons, petite (24 couleurs)
• Une boîte de crayons, grande (64 couleurs)
• Moniteur d'ordinateur HD 26 po SuperHighTech
• Figurine Barrack Obama (6 ”)

Groupé

Les produits groupés vous permettent de créer un nouveau produit en utilisant un ou plusieurs produits existants dans votre magasin. Par exemple, supposons que vous ayez déjà dans votre magasin une «Figurine d'action Barrack Obama» et une «Figurine d'action George W Bush» et que vous vouliez les vendre en groupe. Vous devez simplement créer un nouveau produit groupé (appelons-le «Obama + Bush (Obtenir les deux et dépenser deux fois plus!)», Puis ajoutez les deux chiffres d'action au groupe via l'onglet «Produits associés».

Remarque: Malheureusement, vous ne pouvez pas définir un prix spécial «groupe» directement à partir de la page du produit. Pour offrir un rabais sur les achats groupés, vous devez créer une nouvelle règle sur les prix du panier.

Configurable

Produit configurable: ce produit permet à vos clients de sélectionner la variante de leur choix en choisissant des options. Par exemple, vous pouvez vendre des T-shirts en deux couleurs et trois tailles. Vous créez six produits simples en tant que produits individuels (chacun avec ses propres références), puis vous les ajoutez à un produit configurable où les clients peuvent choisir la taille et la couleur, puis les ajouter à leur panier. Des fonctionnalités très similaires sont possibles en utilisant les options personnalisées pour les produits simples. La différence entre un produit configurable et un produit, y compris les options personnalisées, est que l’inventaire n’est ni vérifié ni mis à jour pour les options individuelles lors de l’achat des options personnalisées.

Virtuel

Les produits virtuels sont ceux qui n'ont pas de contrepartie physique ou numérique. Ils ne sont pas expédiés, et ils n’ont pas de lien de téléchargement. Ce type de produit peut être utilisé pour des services tels que:

• Nettoyage de la maison
• Abonnement de 1 an à la newsletter

Remarque: Si vous utilisez des produits virtuels pour les «abonnements», il est important de noter qu’il n’existe aucun moyen intégré de gérer le renouvellement automatique des abonnements. Tous les achats effectués dans Magento, quel que soit le type de produit, sont des achats ponctuels.

Paquet

Ce type de produit est également appelé «kit» dans d’autres logiciels de commerce électronique. Ce type de produit est idéal dans les cas où l'utilisateur doit sélectionner un certain nombre d'options configurables, mais au moins une option. Cela pourrait inclure des produits comme:

• Systèmes informatiques personnalisables
• Smokings / costumes personnalisables
• Cliquez ici pour un tutoriel vidéo sur l'utilisation de bundles

Téléchargeable

Les produits téléchargeables sont similaires aux produits virtuels, sauf qu'ils permettent d'ajouter un ou plusieurs fichiers numériques au téléchargement. Les fichiers peuvent être téléchargés via l'interface d'administration ou en téléchargeant directement sur le serveur via FTP, puis ajoutés par URL. Lorsqu'un client achète un produit téléchargeable, Magento génère un lien sécurisé et crypté (afin que les clients ne puissent pas voir l'emplacement réel du fichier) pour que ce client télécharge son fichier.

Cette catégorie peut inclure des produits tels que:

• Musique / MP3
• Logiciel

Remarque : Si SSL est activé pour votre site, les téléchargements peuvent échouer sous toutes les versions d'IE, car IE contient un bogue qui empêche le téléchargement via des connexions sécurisées si l'en-tête no-cache est défini. Cela peut être facilement corrigé dans un fichier htaccess en supprimant les en-têtes no-cache et no-store, ou en forçant les liens de téléchargement à ne plus être sécurisés.