magento
Entender los tipos de productos
Buscar..
Observaciones
Hay seis tipos diferentes de productos integrados en Magento.
- Sencillo
Una sola unidad de stock.
- Configurable
Primero de los productos compuestos. Permita que los clientes configuren su producto y agregue un solo producto simple a la cesta.
- Agrupados
El segundo producto compuesto, un producto agrupado, relaciona productos simples y brinda a los clientes la capacidad de elegir cantidades de cada artículo.
- Haz
El tercer tipo de producto compuesto, un paquete, relaciona productos simples para comprarlos como un solo artículo.
- Virtual
No se requiere ningún artículo físico para la entrega, por ejemplo, servicios
- Descargable
Un producto digital en lugar de físico. La mayoría de los tipos de productos se implementan como parte del módulo Mage_Catalog, además de Mage_Bundle y Mage_Downloadable.
Los productos agrupados, agrupados y configurables implementan una relación padre-hijo donde una serie de otros productos (de forma predeterminada, simple, virtual o descargable) se asignan a un producto principal. Esto luego maneja los datos del producto para toda la colección (por ejemplo, grupo, paquete o nombre de producto configurable, precio y estado).
Los productos descargables y de paquete tienen tablas adicionales en la base de datos, mientras que el resto se comparte con todos los demás tipos de productos. Los productos configurables tienen una tabla adicional para vincular a productos secundarios, catalog_product_super_link.
Tipo de producto personalizado
Para crear un tipo de producto que amplíe uno de los tipos de producto integrados, se debe ampliar el modelo de tipo de producto correspondiente. De lo contrario, el nuevo tipo de producto debería extender la clase Mage_Catalog_Model_Product_Type_Abstract.
También se requiere una entrada en el config.xml del módulo:
Los productos más complicados pueden requerir otras áreas personalizadas, como el modelo de precios y el recuperador de datos de índice.Cálculo del precio
Cuando se trata de un solo producto, el precio siempre se calcula sobre la marcha. El atributo EAV de precio se carga con el producto y el precio final se calcula con el modelo de precio, Mage_Catalog_Model_Product_Type_Price.
Algunos tipos de productos lo tratan de manera diferente. En cuyo caso extienden esta clase e implementan su propia lógica. Por ejemplo, el producto configurable sobrescribe getFinalPrice () y agrega lógica adicional. Este modelo personalizado se puede especificar en config.xml con una etiqueta <price_model>.
Las colecciones de productos, sin embargo, utilizan el índice de precios para recuperar precios precalculados, eliminando la necesidad de calcularlo para cada producto.
El precio final puede ser ajustado por los observadores del evento catalog_product_get_final_price. Por defecto, solo el módulo Mage_CatalogRule observa este evento.
Otro método para anular el precio de producción es simplemente establecerlo en el producto. Si se establece el precio, el producto no lo recalculará.
El precio del nivel del producto es independiente del precio normal (aunque se tiene en cuenta al calcular el precio). Se implementa como una lista con un grupo de clientes y calificadores de cantidad mínima para cada nivel. Los precios de los niveles se muestran en una tabla, utilizando la plantilla catalog / product / view / tierprices.phtml.
Las opciones de productos personalizados se procesan al calcular el precio final. Cada opción tiene su propio precio definido, que se agrega al precio final.
Los precios de grupo, nivel y especiales se tienen en cuenta al mismo tiempo ($priceModel->getBasePrice()) y se elige el precio más bajo de los tres (o cuatro si incluye el precio regular) como precio base del producto.
Impuesto
El módulo Mage_Tax utiliza la clase de impuestos de un producto y si el precio del producto es inclusivo o no del impuesto para identificar la tasa correcta a aplicar.
Los siguientes factores se utilizan para calcular el impuesto sobre los productos:
- Clase de impuesto al producto
- El importe del impuesto ya incluido.
- Direcciones de facturación y envío
- Clase de impuesto al cliente
- Configuración de la tienda
Navegación en capas
Las clases responsables de renderizar la navegación en capas son:
Mage_Catalog_Block_Layer_View
-Manejar los filtros y opciones.
Mage_Catalog_Block_Layer_State
-Control lo que actualmente se está filtrando.
Para implementar la navegación por capas en los atributos con modelos de origen personalizados, el método Mage_Catalog_Model_Layer_Filter_Abstract :: apply () se debería sobrescribir para determinar cómo se debe filtrar la colección de productos.
La navegación en capas es representada por los bloques Mage_Catalog_Block_Layer_View y Mage_Catalog_Block_Layer_State, que usan bloques de filtros para filtros individuales.
La navegación en capas utiliza la tabla de índice para la mayoría de los filtros, por ejemplo, precio, índice de atributo de producto, índice de producto decimal.
Categorías
Categorías en la base de datos
La jerarquía de categorías se administra almacenando el ID principal de una categoría. La jerarquía completa se muestra en la columna de ruta (ID separadas por barras). Hay una categoría especial con parent_id de 0. Esta es la verdadera categoría de raíz y cada una de las otras categorías de raíz, tal como se define en Magento, lo utiliza como padre compartido.
Para leer y administrar un árbol de categorías de la base de datos, se utilizan dos clases diferentes dependiendo de si el catálogo plano está habilitado, Mage_Catalog_Model_Resource_Category_Tree y Mage_Catalog_Model_Resource_Category_Flat.
La ventaja de las categorías planas es que es más rápido de consultar. Sin embargo, debe reconstruirse a partir de las tablas EAV cada vez que se produzca un cambio.
getChildren()
devuelve una cadena separada por comas de ID de hijos inmediatos
getAllChildren()
devuelve una cadena o matriz de todos los ID de hijos
getChildrenCategories()
devuelve una colección de categorías secundarias inmediatas Nota: si el catálogo plano está habilitado, las únicas categorías secundarias devueltas serán aquellas con include_in_menu = 1. En ambos casos, solo se devuelven las categorías activas.
Reglas de precios del catálogo
Las reglas de precios de catálogo aplican descuentos a los productos según la fecha, el producto, el sitio web y el grupo de clientes.
Cuando se llama a getFinalPrice() en un producto, se desencadena el evento catalog_product_get_final_price. Esto es observado por Mage_CatalogRule_Model_Observer que luego buscará cualquier regla de precio de catálogo que se aplique al producto. Si corresponde, luego mira la tabla de precios de la base de datos y vuelve a escribir el precio en el modelo del producto como un campo de datos Varien final_price.
Dentro de la base de datos, la tabla catalogrule describe las reglas, sus condiciones y sus acciones. catalogrule_product contiene los productos coincidentes y alguna información de la regla. Mientras tanto catalogrule_product_price contiene el precio después de que se haya aplicado la regla.
Tablas de indexación y planas
Las tablas de catálogo planas son gestionadas por indexadores de catálogo. Si la reconstrucción automática de los índices está habilitada, los indizadores de catálogo se reconstruyen cada vez que se actualiza un producto, una categoría o cualquier entidad relacionada. El método _afterSave () llama al proceso del indexador. De lo contrario, tienen que ser re-indexados manualmente a través de admin.
El tipo de producto afecta el índice de precios y el índice de acciones donde los productos pueden definir sus propios indexadores personalizados (en config.xml) para manejar sus datos para estos índices.
El módulo Mage_Index proporciona el marco con el que se pueden crear índices personalizados para ayudar a optimizar el rendimiento del sitio. La clase Mage_Index_Model_Indexer_Abstract debe ampliarse para crear un nuevo índice, implementando los métodos _registerEvent () y _processEvent (). Sin olvidar registrarlo en 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;
}
}
Describir los tipos de productos estándar (simples, configurables, agrupados)
Sencillo
El tipo de productos simples debe usarse para que, por lo general, tengan una configuración única (talla única para todos). Esto podría incluir elementos tales como:
- Una caja de crayones, pequeña (24 colores)
- Una Caja de Crayones, Grande (64 Colores)
- Monitor SuperHighTech 26 "HD para computadora
- Figura de Acción de Barrack Obama (6 ")
Agrupados
Los productos agrupados le permiten crear un nuevo producto utilizando uno o más productos existentes en su tienda. Por ejemplo, supongamos que ya tiene una "Figura de Acción de Barrack Obama" y una "Figura de Acción de George W. Bush" en su tienda y desea venderlas como un paquete. Simplemente creará un nuevo producto agrupado (llamémoslo "Obama + Bush (¡obtenga ambos y gastemos el doble!)", Luego agregue ambas figuras de acción al grupo a través de la pestaña "Productos asociados".
Nota: Desafortunadamente, no puede establecer un precio especial de "grupo" directamente desde la página del producto. Para ofrecer un descuento por la compra de artículos en conjunto, deberá crear una nueva Regla de precios del carrito de compras.
Configurable
Producto configurable: este producto permite a sus clientes seleccionar la variante que desean al elegir las opciones. Por ejemplo, puedes vender camisetas en dos colores y tres tamaños. Debería crear seis productos simples como productos individuales (cada uno con sus propias SKU) y luego agregar estos seis a un producto configurable donde los clientes pueden elegir el tamaño y el color, y luego agregarlos a su carrito. Es posible una funcionalidad muy similar mediante el uso de Opciones personalizadas para productos simples. La diferencia entre un producto configurable y un producto que incluye opciones personalizadas es que el inventario no se verifica ni se actualiza para las opciones individuales durante la compra de las opciones personalizadas.
Virtual
Los productos virtuales son aquellos que no tienen una contraparte física o digital. No se envían, ni tienen un enlace de descarga. Este tipo de producto podría ser utilizado para servicios como:
- Limpieza de la casa
- Suscripción al boletín de 1 año
Nota: Si utiliza productos virtuales para "suscripciones", es importante tener en cuenta que no hay una forma integrada de administrar las suscripciones de renovación automática. Todas las compras realizadas en Magento, independientemente del tipo de producto, son compras únicas.
Haz
Este tipo de producto también se conoce como un "kit" en otro software de comercio electrónico. Este tipo de producto es ideal para circunstancias en las que el usuario debe seleccionar una cantidad de opciones configurables, pero al menos una opción. Esto podría incluir productos como:
- Sistemas informáticos personalizables
- Tuxedos / trajes personalizables
- Haga clic aquí para ver un video tutorial sobre el uso de paquetes
Descargable
Los productos descargables son similares a los productos virtuales, excepto que incluyen la capacidad de agregar uno o más archivos digitales para descargar. Los archivos pueden cargarse a través de la interfaz de administración, o bien cargarlos directamente en el servidor a través de FTP y luego agregarlos por URL. Cuando un cliente compra un producto descargable, Magento generará un enlace seguro y encriptado (para que los clientes no puedan ver la ubicación real del archivo) para que ese cliente descargue su archivo.
Esta categoría podría incluir productos tales como:
- Música / MP3s
- Software de ordenador
Nota : si tiene SSL habilitado para su sitio, las descargas pueden fallar en todas las versiones de IE, ya que IE contiene un error que impide la descarga a través de conexiones seguras si se establece el encabezado de no caché. Esto puede solucionarse fácilmente en un archivo htaccess eliminando los encabezados sin almacenamiento en caché y sin almacenamiento, o forzando que los enlaces de descarga no sean seguros.