Szukaj…


Uwagi

Istnieje sześć różnych typów produktów wbudowanych w Magento.

  • Prosty

Jedna jednostka zapasowa

  • Konfigurowalny

Pierwszy z produktów kompozytowych. Pozwól klientom skonfigurować swój produkt i dodać jeden prosty produkt do koszyka.

  • Zgrupowane

Drugi produkt złożony, zgrupowany produkt, dotyczy prostych produktów i zapewnia klientom możliwość wyboru ilości każdego produktu.

  • Pakiet

Trzeci złożony rodzaj produktu, pakiet, łączy proste produkty, które można zakupić jako pojedynczy produkt.

  • Wirtualny

Dostawa nie wymaga żadnych fizycznych przedmiotów, np. Usług

  • Do pobrania

Produkt cyfrowy, a nie fizyczny. Większość typów produktów jest implementowana jako część modułu Mage_Catalog, oprócz Mage_Bundle i Mage_Downloadable.

Zgrupowane, pakietowe i konfigurowalne produkty implementują relację rodzic-dziecko, w której szereg innych (domyślnie prostych, wirtualnych lub do pobrania) produktów jest przypisanych do głównego produktu. Następnie obsługuje dane produktu dla całej kolekcji (np. Grupa, pakiet lub konfigurowalna nazwa produktu, cena i status).

Produkty do pobrania i pakiety mają dodatkowe tabele w bazie danych, podczas gdy pozostałe są udostępniane wszystkim pozostałym typom produktów. Konfigurowalne produkty mają dodatkową tabelę, aby połączyć z produktami potomnymi, katalog_produktu_super_link.

Niestandardowy typ produktu

Aby utworzyć typ produktu, który rozszerza jeden z wbudowanych typów produktu, należy rozszerzyć odpowiedni model typu produktu. W przeciwnym razie nowy typ produktu powinien rozszerzyć klasę Mage_Catalog_Model_Product_Type_Abstract.

Wymagany jest również wpis w pliku config.xml modułu:

Bardziej skomplikowane produkty mogą wymagać innych niestandardowych obszarów, takich jak model cen i narzędzie do pobierania danych indeksowych.

Kalkulacja ceny

W przypadku pojedynczego produktu cena jest zawsze obliczana na bieżąco. Atrybut ceny EAV jest ładowany z produktem, a cena ostateczna jest obliczana na podstawie modelu cenowego Mage_Catalog_Model_Product_Type_Price.

Niektóre typy produktów traktują to inaczej. W takim przypadku rozszerzają tę klasę i implementują własną logikę. Na przykład konfigurowalny produkt zastępuje getFinalPrice () i dodaje dodatkową logikę. Ten model niestandardowy można następnie określić w pliku config.xml za pomocą znacznika <price_model>.

Kolekcje produktów wykorzystują jednak indeks cen do pobierania wstępnie obliczonych cen, co eliminuje konieczność ich obliczania dla każdego produktu.

Ostateczną cenę mogą skorygować obserwatorzy zdarzenia catalog_product_get_final_price. Domyślnie tylko moduł Mage_CatalogRule obserwuje to zdarzenie.

Inną metodą zastąpienia ceny produkcji jest po prostu ustawienie jej na produkcie. Jeśli cena zostanie ustawiona, produkt nie przeliczy jej ponownie.

Cena warstwy produktu jest oddzielona od ceny normalnej (chociaż jest uwzględniana przy obliczaniu ceny). Jest zaimplementowany jako lista z grupą klientów i kwalifikatorami minimalnej ilości dla każdej warstwy. Ceny w warstwie są wyświetlane w tabeli przy użyciu szablonu katalogu / produktu / widoku / tierprices.phtml.

Niestandardowe opcje produktu są przetwarzane przy obliczaniu ceny końcowej. Każda opcja ma własną cenę, która jest dodawana do ceny końcowej.

Ceny grupowe, warstwowe i specjalne są rozpatrywane jednocześnie ($priceModel->getBasePrice()) a jako podstawową cenę produktu wybiera się najmniejszą z trzech (lub czterech, jeśli uwzględnisz cenę regularną).

Podatek

Moduł Mage_Tax wykorzystuje klasę podatkową produktu oraz to, czy cena produktu zawiera podatek, czy nie, w celu ustalenia właściwej stawki, którą należy zastosować.

Do obliczenia podatku od produktów stosuje się następujące czynniki:

  • Klasa podatku od produktów
  • Kwota podatku już uwzględniona
  • Adresy do fakturowania i wysyłki
  • Klasa podatkowa klienta
  • Zapisz ustawienia

Nawigacja warstwowa

Klasy odpowiedzialne za renderowanie nawigacji warstwowej to:

  • Mage_Catalog_Block_Layer_View

    Obsługuje filtry i opcje

  • Mage_Catalog_Block_Layer_State

- Kontroluje to, co jest obecnie filtrowane

Aby zaimplementować nawigację warstwową na atrybutach z niestandardowymi modelami źródłowymi, metoda Mage_Catalog_Model_Layer_Filter_Abstract :: Apply () musiałaby zostać nadpisana, aby określić sposób filtrowania kolekcji produktów.

Nawigacja warstwowa jest renderowana przez bloki Mage_Catalog_Block_Layer_View i Mage_Catalog_Block_Layer_State, które używają bloków filtrów dla poszczególnych filtrów.

Nawigacja warstwowa używa tabeli indeksów dla większości filtrów, np. Ceny, indeksu atrybutu produktu, dziesiętnego indeksu produktu.

Kategorie

Kategorie w bazie danych

Hierarchią kategorii zarządza się poprzez przechowywanie identyfikatora nadrzędnego kategorii. Pełna hierarchia jest pokazana w kolumnie ścieżki (identyfikatory oddzielone ukośnikiem). Istnieje specjalna kategoria z parent_id równym 0. To jest prawdziwa kategoria główna i każda z pozostałych kategorii głównych zdefiniowanych w Magento używa jej jako wspólnego rodzica.

Do odczytu i zarządzania drzewem kategorii z bazy danych używane są dwie różne klasy, w zależności od tego, czy włączony jest katalog płaski, Mage_Catalog_Model_Resource_Category_Tree i Mage_Catalog_Model_Resource_Category_Flat.

Zaletą kategorii płaskich jest to, że zapytanie jest szybsze. Należy go jednak przebudowywać z tabel EAV za każdym razem, gdy następuje zmiana.

getChildren()

zwraca ciąg bezpośrednich identyfikatorów potomnych oddzielonych przecinkami

getAllChildren()

zwraca ciąg lub tablicę wszystkich identyfikatorów potomnych

getChildrenCategories()

zwraca kolekcję bezpośrednich kategorii potomnych Uwaga: Jeśli włączony jest katalog płaski, jedynymi zwracanymi kategoriami będą te, które zawierają include_in_menu = 1. W obu przypadkach zwracane są tylko aktywne kategorie.

Zasady cen katalogowych

Zasady cen katalogowych dotyczą rabatów na produkty na podstawie daty, produktu, strony internetowej i grupy klientów.

Po getFinalPrice() w produkcie uruchamiane jest zdarzenie katalog_produktu_produktu_finalna cena. Obserwuje to Mage_CatalogRule_Model_Observer, który następnie szuka każdej reguły ceny katalogowej, która dotyczy produktu. W stosownych przypadkach przegląda tabelę cen bazy danych i zapisuje cenę z powrotem do modelu produktu jako pole danych Varien cena_końcowa.

W bazie danych tabela katogramu opisuje reguły, ich warunki i działania. Produkt Catalogrule_product zawiera dopasowane produkty i niektóre informacje o regułach. Tymczasem cena_produktu_grupy zawiera cenę po zastosowaniu reguły.

Indeksowanie i tabele płaskie

Płaskie tabele katalogowe są zarządzane przez indeksatorów katalogu. Jeśli włączona jest automatyczna przebudowa indeksów, indeksatory katalogu są przebudowywane za każdym razem, gdy produkt, kategoria lub powiązane jednostki są aktualizowane. Metoda _afterSave () wywołuje proces indeksowania. W przeciwnym razie muszą być ręcznie ponownie zaindeksowane przez administratora.

Typ produktu wpływa na indeks cen i indeks giełdowy, w których produkty mogą definiować własne indeksatory niestandardowe (w config.xml) do obsługi danych dla tych indeksów.

Moduł Mage_Index zapewnia platformę, w której można tworzyć niestandardowe indeksy, aby pomóc zoptymalizować wydajność witryny. Należy rozszerzyć klasę Mage_Index_Model_Indexer_Abstract, aby utworzyć nowy indeks, implementujący metody _registerEvent () i _processEvent (). Nie zapomnij zarejestrować go w config.xml:

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

Opisz standardowe typy produktów (proste, konfigurowalne, w pakiecie)

Prosty

Należy używać typu Produkty proste, które zasadniczo mają jedną konfigurację (jeden rozmiar dla wszystkich). Może to obejmować takie elementy, jak:

  • Pudełko kredek, małe (24 kolory)
  • Pudełko kredek, duże (64 kolory)
  • Monitor komputerowy SuperHighTech 26 ”HD
  • Figurka Barracka Obamy (6 ”)

Zgrupowane

Pogrupowane produkty umożliwiają utworzenie nowego produktu przy użyciu jednego lub więcej produktów istniejących w twoim sklepie. Załóżmy na przykład, że masz „figurkę Baracka Obamy” i „figurkę George'a W. Busha” w swoim sklepie i chciałeś je sprzedać w pakiecie. Po prostu utworzyłbyś nowy zgrupowany produkt (nazwijmy go „Obama + Bush (zdobądź oba i wydaj dwa razy tyle!)”, A następnie dodaj obie figurki do grupy za pomocą karty „Powiązane produkty”.

Uwaga: Niestety nie można ustawić specjalnej ceny „grupowej” bezpośrednio ze strony produktu. Aby zaoferować zniżkę na kupowanie przedmiotów razem, musisz utworzyć nową regułę cenową koszyka.

Konfigurowalny

Produkt konfigurowalny: ten produkt pozwala klientom wybrać żądany wariant, wybierając opcje. Na przykład możesz sprzedawać koszulki w dwóch kolorach i trzech rozmiarach. Utworzysz sześć prostych produktów jako osobne produkty (każdy z własnymi kodami SKU), a następnie dodasz te sześć do konfigurowalnego produktu, w którym klienci mogą wybrać rozmiar i kolor, a następnie dodać je do koszyka. Bardzo podobna funkcjonalność jest możliwa dzięki użyciu opcji niestandardowych dla prostych produktów. Różnica między produktem konfigurowalnym a produktem zawierającym opcje niestandardowe polega na tym, że zapasy nie są sprawdzane ani aktualizowane dla poszczególnych opcji podczas zakupu opcji niestandardowych.

Wirtualny

Produkty wirtualne to te, które nie mają fizycznego ani cyfrowego odpowiednika. Nie wysyłają ani nie mają linku do pobrania. Ten typ produktu może być wykorzystywany do usług takich jak:

  • Sprzątanie domu
  • Roczna subskrypcja biuletynu

Uwaga: jeśli używasz produktów wirtualnych do „subskrypcji”, ważne jest, aby pamiętać, że nie ma wbudowanego sposobu zarządzania subskrypcjami automatycznego odnawiania. Wszystkie zakupy dokonane w Magento, niezależnie od rodzaju produktu, są zakupami jednorazowymi.

Pakiet

Ten typ produktu jest również znany jako „zestaw” w innym oprogramowaniu eCommerce. Ten typ produktu jest idealny w sytuacjach, w których użytkownik musi wybrać wiele konfigurowalnych opcji, ale co najmniej jedną opcję. Może to obejmować produkty takie jak:

  • Konfigurowalne systemy komputerowe
  • Personalizowane smokingi / garnitury
  • Kliknij tutaj, aby obejrzeć samouczek wideo na temat korzystania z pakietów

Do pobrania

Produkty do pobrania są podobne do produktów wirtualnych, z tym wyjątkiem, że zawierają możliwość dodania jednego lub więcej plików cyfrowych do pobrania. Pliki można przesłać za pomocą interfejsu administratora lub bezpośrednio na serwer za pośrednictwem FTP, a następnie dodać za pomocą adresu URL. Gdy klient kupi produkt do pobrania, Magento wygeneruje bezpieczny, zaszyfrowany link (aby klienci nie mogli zobaczyć prawdziwej lokalizacji pliku), aby ten mógł pobrać swój plik.

Ta kategoria może obejmować produkty takie jak:

  • Muzyka / MP3
  • Oprogramowanie komputerowe

Uwaga : jeśli w Twojej witrynie jest włączony protokół SSL, pobieranie może się nie powieść we wszystkich wersjach IE, ponieważ IE zawiera błąd uniemożliwiający pobieranie przez bezpieczne połączenia, jeśli ustawiony jest nagłówek bez pamięci podręcznej. Można to łatwo naprawić w pliku htaccess, usuwając nagłówki no-cache i no-store lub zmuszając linki do pobierania, aby nie były bezpieczne.



Modified text is an extract of the original Stack Overflow Documentation
Licencjonowany na podstawie CC BY-SA 3.0
Nie związany z Stack Overflow