magento
Producttypen begrijpen

Opmerkingen

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

Beschrijf standaardproducttypen (eenvoudig, configureerbaar, gebundeld)

Gemakkelijk

Het type Simple Products moet hiervoor worden gebruikt en heeft doorgaans een enkele configuratie (one-size-fits-all). Dit kunnen items zijn zoals:

• Een doos kleurpotloden, klein (24 kleuren)
• Een doos kleurpotloden, groot (64 kleuren)
• SuperHighTech 26-inch HD-computermonitor
• Barrack Obama Action Figure (6 ")

gegroepeerd

Met gegroepeerde producten kunt u een nieuw product maken met een of meer bestaande producten in uw winkel. Laten we bijvoorbeeld aannemen dat u een "Barrack Obama Action Figure" en een "George W Bush Action Figure" al in uw winkel heeft en u ze als een bundel wilde verkopen. U zou eenvoudig een nieuw gegroepeerd product maken (laten we het "Obama + Bush (krijg beide en twee keer zoveel uitgeven!)" Noemen, en vervolgens beide actiefiguren aan de groep toevoegen via het tabblad "Bijbehorende producten".

Opmerking: helaas kunt u geen speciale "groepsprijs" rechtstreeks vanaf de productpagina instellen. Als u korting wilt geven voor het samen kopen van artikelen, moet u een nieuwe prijsregel voor het winkelwagentje maken.

configureerbaar

Configureerbaar product: met dit product kunnen uw klanten de gewenste variant selecteren door opties te kiezen. U kunt bijvoorbeeld T-shirts in twee kleuren en drie maten verkopen. U maakt zes eenvoudige producten als afzonderlijke producten (elk met zijn eigen SKU's) en voegt deze zes vervolgens toe aan een configureerbaar product waar klanten de grootte en kleur kunnen kiezen en vervolgens aan hun winkelwagentje toevoegen. Zeer vergelijkbare functionaliteit is mogelijk door aangepaste opties voor Simple-producten te gebruiken. Het verschil tussen een configureerbaar product en een product met aangepaste opties is dat de inventaris niet wordt gecontroleerd of bijgewerkt voor individuele opties tijdens de aankoop van de aangepaste opties.

virtueel

Virtuele producten zijn producten die geen fysieke of digitale tegenhanger hebben. Ze verzenden niet en hebben ook geen downloadlink. Dit producttype kan worden gebruikt voor services zoals:

• Huis schoonmaken
• Abonnement op nieuwsbrief van 1 jaar

Opmerking: als u virtuele producten gebruikt voor "abonnementen", is het belangrijk op te merken dat er geen ingebouwde manier is om automatisch vernieuwende abonnementen te beheren. Alle aankopen in Magento, ongeacht het producttype, zijn eenmalige aankopen.

Bundel

Dit producttype wordt ook wel een 'kit' genoemd in andere e-commerce-software. Dit producttype is ideaal voor omstandigheden waarin de gebruiker een aantal configureerbare opties moet selecteren, maar ten minste één optie. Dit kunnen producten zijn zoals:

• Aanpasbare computersystemen
• Aanpasbare smoking / pakken
• Klik hier voor een videozelfstudie over het gebruik van bundels

downloadbare

Downloadbare producten zijn vergelijkbaar met virtuele producten, behalve dat ze de mogelijkheid bieden om een of meer digitale bestanden toe te voegen om te downloaden. Bestanden kunnen worden geüpload via de beheerdersinterface of door ze rechtstreeks via FTP naar de server te uploaden en vervolgens per URL toe te voegen. Wanneer een klant een downloadbaar product koopt, genereert Magento een veilige, gecodeerde link (zodat de klanten de echte locatie van het bestand niet kunnen zien) voor die klant om hun bestand te downloaden.

Deze categorie kan producten omvatten zoals:

• Muziek / MP3's
• Computer software

Opmerking : als SSL is ingeschakeld voor uw site, kunnen downloads mislukken onder alle versies van IE omdat IE een bug bevat die downloaden via beveiligde verbindingen voorkomt als de no-cache-header is ingesteld. Dit kan eenvoudig worden opgelost in een htaccess-bestand door de no-cache en no-store headers te verwijderen, of door downloadlinks te dwingen om niet-veilig te zijn.