magento
Produkttypen verstehen

Bemerkungen

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

Beschreiben von Standardprodukttypen (einfach, konfigurierbar, gebündelt)

Einfach

Der Typ Einfache Produkte sollte dafür verwendet werden, da er in der Regel eine einzige Konfiguration hat (Einheitsgröße). Dies kann beispielsweise Folgendes beinhalten:

• Eine Schachtel Buntstifte, klein (24 Farben)
• Eine Schachtel Buntstifte, groß (64 Farben)
• SuperHighTech 26 "HD-Computerbildschirm
• Baracke Obama Action Figure (6 ")

Gruppiert

Mit gruppierten Produkten können Sie ein neues Produkt mit einem oder mehreren in Ihrem Geschäft vorhandenen Produkten erstellen. Nehmen wir zum Beispiel an, Sie haben bereits eine „Barrack Obama Action Figure“ und eine „George W Bush Action Figure“ in Ihrem Geschäft und möchten diese als Bundle verkaufen. Sie würden einfach ein neues gruppiertes Produkt erstellen (nennen wir es "Obama + Bush (Holen Sie sich beides und geben Sie doppelt so viel aus!")), Und fügen Sie beide Aktionsfiguren über die Registerkarte "Zugehörige Produkte" zur Gruppe hinzu.

Hinweis: Leider können Sie keinen speziellen Gruppenpreis direkt auf der Produktseite festlegen. Um einen Rabatt für den Kauf von Artikeln anzubieten, müssen Sie eine neue Warenkorbpreisregel erstellen.

Konfigurierbar

Konfigurierbares Produkt: Mit diesem Produkt können Ihre Kunden die gewünschte Variante durch Auswahl von Optionen auswählen. Zum Beispiel können Sie T-Shirts in zwei Farben und drei Größen verkaufen. Sie erstellen sechs einfache Produkte als einzelne Produkte (jeweils mit eigenen SKUs) und fügen diese sechs dann zu einem konfigurierbaren Produkt hinzu, in dem die Kunden die Größe und Farbe auswählen und sie dann in den Warenkorb legen können. Eine sehr ähnliche Funktionalität ist möglich, wenn Sie Benutzerdefinierte Optionen für einfache Produkte verwenden. Der Unterschied zwischen einem konfigurierbaren Produkt und einem Produkt einschließlich benutzerdefinierter Optionen besteht darin, dass das Inventar beim Kauf der benutzerdefinierten Optionen nicht für einzelne Optionen geprüft oder aktualisiert wird.

Virtuell

Virtuelle Produkte sind Produkte, die weder physisch noch digital sind. Sie versenden nicht und haben auch keinen Download-Link. Dieser Produkttyp kann für folgende Dienste verwendet werden:

• Hausputz
• 1-Jahres-Newsletter-Abonnement

Hinweis: Wenn Sie virtuelle Produkte für "Abonnements" verwenden, ist es wichtig zu beachten, dass es keine integrierte Methode zum Verwalten von Abonnements mit automatischer Verlängerung gibt. Alle Einkäufe, die unabhängig von der Produktart in Magento getätigt werden, sind einmalig.

Bündeln

Dieser Produkttyp wird in anderen E-Commerce-Software auch als "Kit" bezeichnet. Dieser Produkttyp ist ideal für Situationen, in denen der Benutzer eine Anzahl konfigurierbarer Optionen auswählen muss, mindestens jedoch eine Option. Dies kann Produkte wie:

• Anpassbare Computersysteme
• Anpassbare Smoking / Anzüge
• Klicken Sie hier für ein Video-Tutorial zur Verwendung von Bundles

Herunterladbar

Herunterladbare Produkte ähneln virtuellen Produkten, haben jedoch die Möglichkeit, eine oder mehrere digitale Dateien zum Download hinzuzufügen. Dateien können entweder über die Admin-Oberfläche hochgeladen werden oder direkt per FTP auf den Server hochgeladen und dann über die URL hinzugefügt werden. Wenn ein Kunde ein herunterladbares Produkt erwirbt, generiert Magento einen sicheren, verschlüsselten Link (damit der Kunde den tatsächlichen Speicherort der Datei nicht sehen kann), damit der Kunde seine Datei herunterladen kann.

Diese Kategorie kann folgende Produkte umfassen:

• Musik / MP3s
• Computer Software

Hinweis : Wenn Sie SSL für Ihre Site aktiviert haben, schlagen die Downloads möglicherweise bei allen IE-Versionen fehl, da IE einen Fehler enthält, der das Herunterladen über sichere Verbindungen verhindert, wenn der Header ohne Cache festgelegt ist. Dies kann leicht in einer htaccess-Datei behoben werden, indem die Header No-Cache und No-Store entfernt werden oder Download-Links als nicht sicher erzwungen werden.