Damián Culotta » tips

Mejorando el SEO de nuestros módulos en Magento

Damián — Mon, 07 Nov 2011 13:30:28 +0000

Hoy vamos a ver dos pequeños trucos para lograr una mejor presentación de nuestros módulos.

El primero está relacionado con el SEO y el segundo con la navegación.

Para no perder la costumbre, vamos a partir de un módulo hecho por el Generador de Módulos. Además, para seguir manteniendo la línea, el módulo ha de llamarse Dc_Test.

Si intentamos acceder al controlador de nuestro módulo en el frontend, vamos a encontrarnos con lo siguiente.

Si vemos el código fuente, vamos a notar que hay 3 tags que no se están usando correctamente: title, description y keywords.

La idea del tip de hoy es aprovechar algunas funcionalidades de Magento para darle a nuestro módulo un poco de SEO haciendo uso de los tags html y del breadcrumb.

Si miramos el controlador que se generó automáticamente, vamos a encontrar el siguiente código.

class Dc_Test_IndexController extends Mage_Core_Controller_Front_Action
{
    public function indexAction()
    {
        $this->loadLayout();
        $this->renderLayout();
    }
}

Lo primero que vamos a agregar serán los valores para los tags html.

Para esto, luego del loadLayout, agregamos el siguiente código.

class Dc_Test_IndexController extends Mage_Core_Controller_Front_Action
{
    public function indexAction()
    {
        $this->loadLayout();
        if ($head = $this->getLayout()->getBlock('head')) {
            $head->setTitle('Mi título');
            $head->setDescription('Contenido del tag Description');
            $head->setKeywords('mis,keywords,para,la,pagina');
        }
        $this->renderLayout();
    }
}

Lo que estamos haciendo aquí es validar si el bloque head existe en el layout. En caso afirmativo asignamos valores para las 3 keys que nos interesan (al menos en el ejemplo).

El segundo paso será agregar el breadcrumb para nuestro módulo. Nuevamente, vamos a tener que agregar algunas líneas en el controlador.

class Dc_Test_IndexController extends Mage_Core_Controller_Front_Action
{
    public function indexAction()
    {
        $this->loadLayout();
        if ($head = $this->getLayout()->getBlock('head')) {
            $head->setTitle('Mi título');
            $head->setDescription('Contenido del tag Description');
            $head->setKeywords('mis,keywords,para,la,pagina');
        }
        if ($breadcrumbs = $this->getLayout()->getBlock('breadcrumbs')) {
            $breadcrumbs->addCrumb('home', array(
                'label' => Mage::helper('test')->__('Inicio'),
                'link'  => Mage::getBaseUrl()
            ))->addCrumb('test', array(
                'label' => Mage::helper('test')->__('Título de la página')
            ));
        }
        $this->renderLayout();
    }
}

Una vez guardados los cambios, actualizamos la página y ya van a verse los cambios.

De más está decir que el ejemplo tiene, justamente, ese fin.

Si nuestro módulo utiliza varias acciones, será más correcto tener un método privado en el controlador que se invoque dentro de cada una de ellas para manipular los distintos valores.

A lo mejor te interese leer

Agregar validaciones javascript en Magento de forma no obstrusiva

Damián — Mon, 10 Oct 2011 12:00:39 +0000

Pequeño tip en pro de seguir con las buenas prácticas.

Hace no mucho tiempo me tocó hacer una personalización en la cual el requerimiento pedía agregar una regla adicional de validación para ciertos campos del checkout.

Lo que vamos a a ver es cómo agregar reglas propias de validación haciendo uso de la clase Validation. Por supuesto, la idea es no tocar el código original agregando código en js/prototype/validation.js o dentro de un phtml (como todavía seguimos viendo incluso en extensiones pagas).

Para el ejemplo vamos a necesitar 3 archivos.

El escenario con el cual voy a trabajar será el siguiente: “Agregar una nueva validación Javascript a ciertos campos del formulario del checkout sin por esto crear un nuevo módulo” (más adelante voy a volver sobre este punto).

Lo primero que vamos a hacer es crear nuestra función javascript de validación. Dado que la regla en si misma va más allá del skin, voy a crear el archivo dentro del directorio js. En mi caso, el archivo será /js/dc/validacion.js.

Dentro del archivo, vamos a declarar una nueva regla.

Validation.add('mi-nueva-validacion', 'Mensaje de error a mostrar.', function (v) {
    return /^[ INGRESAMOS NUESTRA VALIDACION ]*$/.test(v);
});

El siguiente paso será lograr que el layout agregue nuestro nuevo archivo junto con todos los demás.

Para que esto suceda vamos a editar el archivo page.xml del layout de nuestro theme y agregamos dentro del nodo , en la definición del bloque head, la llamada a nuestro archivo.

<default translate="label" module="page">
 
    ...
 
    <block type="page/html_head" name="head" as="head">
 
        ...
 
        <action method="addJs"><script>dc/validacion.jsscript>action>
 
        ...
 
    block>
 
default>

Ahora ya tenemos nuestra nueva regla de validación y también el archivo javascript cargado.

Para aplicarlo, necesitamos editar el archivo phtml que contiene el input al cual buscamos agregarle la validación.

Según el ejemplo, vamos a probar con el campo Company de la sección de Billing.

Abrimos el archivo app/design/frontend/[package]/[tema]/template/checkout/onepage/billing.phtml y en la línea 47 deberíamos ver nuestro campo. Al final de la línea se indica que la única clase de este input es “input-text”.

Vamos a modificar eso y agregamos, a continuación, el nombre de nuestra regla de validación.

Ahora el código de nuestro input debería verse de la siguiente forma:

 echo $this->__('Company') ?>" type="text" name="billing[company]" value=" echo $this->htmlEscape($this->getAddress()->getCompany()) ?>" />

Una vez que lleguemos al formulario, si ingresamos un valor no permitido, veríamos nuestro mensaje.

Aplicando estos pasos estamos obteniendo una forma bastante prolija y reutilizable de agregar validaciones para nuestros formularios.

Al comienzo dejé una aclaración con respecto al requerimiento. Esto se debe a que la forma en que estoy agregando la validación no es la única.

Si mi validación fuera sólo para el checkout, quizás lo más correcto hacer la inclusión en la definición de layout del checkout y no en page. Si creamos un módulo que necesita una validación, también podríamos hacer al inclusión en la definición de layout de ese módulo.

Lo importante es evitar ensuciar el phtml y poder reutilizar nuestro código de una forma sencilla.

A lo mejor te interese leer

Configuraciones dependientes en Magento

Damián — Mon, 12 Sep 2011 05:00:15 +0000

Normalmente, cuando creamos un módulo y le agregamos opciones de configuración, obtenemos un formulario, al menos, como el siguiente.

Está claro, el ejemplo es de lo más básico. Contamos con varios tipos de campos que nos permiten manejarnos con cierta flexibilidad al momento de definir nuestras configuraciones.

Dentro de esas posibilidades existe una opción (que no suele verse muy seguido) que nos permite indicar que si un campo cambia de valor, nos muestre (o no) otros campos.

Guiándonos por la primera imagen, la lógica sería la siguiente: si el campo “Condición” equivale a No, mostramos el campo “Valor A”.

Y ahora, si el campo “Condición” cambia a Si, ocultamos el campo “Valor A” y mostramos el campo “Valor B”.

Lograr el comportamiento es bastante sencillo (no, no es necesario enviar otro cohete a luna).

Repasemos el código usado para la primera imagen.

>
     translate="label">
        >Condicion>
        >select>
        >adminhtml/system_config_source_yesno>
        >1>
        >1>
        >1>
        >1>
    >
     translate="label">
        >Valor A>
        >text>
        >2>
        >1>
        >1>
        >1>
    >
     translate="label">
        >Valor B>
        >text>
        >3>
        >1>
        >1>
        >1>
    >
>

Desde Magento 1.4 existe un parámetro adicional que nos permite indicar la relación (y visibilidad) de un campo según el valor de otro.

El parámetro se llama “depends” e indica el campo con el que se relaciona y el valor que debe tener para que nuestro campo se muestre.

>
    >0>
>

El ejemplo completo nos quedaría de la siguiente forma.

>
     translate="label">
        >Condicion>
        >select>
        >adminhtml/system_config_source_yesno>
        >1>
        >1>
        >1>
        >1>
    >
     translate="label">
        >Valor A>
        >text>
        >2>
        >1>
        >1>
        >1>
        >
            >0>
        >
    >
     translate="label">
        >Valor B>
        >text>
        >3>
        >1>
        >1>
        >1>
        >
            >1>
        >
        >Descripción del segundo campo>
    >
>

Este pequeño truco nos permite mejorar la presentación de nuestra configuración con muy poco esfuerzo.

Cabe aclarar que no es la única forma en que podemos mejorar la forma de ingresar parámetros de configuración, ya que podemos implementar nuestros propios source para los campos.

Un ejemplo de esto último puede verse en el post de Robert Popovic sobre cómo implementar modelos personalizados para los parámetros de la configuración.

(Todavía no tengo seguridad sobre si el título describe correctamente el contenido del post)

A lo mejor te interese leer

Cómo agregar atributos a una categoría en Magento

Damián — Thu, 18 Aug 2011 01:44:43 +0000

Entre las tantas personalizaciones que normalmente se hacen en un tienda, es posible que necesitemos agregar atributos a las categorías.

Dado que Magento no ofrece la posibilidad de gestionar los atributos de ésta entidad desde el backend, vamos a ver cómo agregar uno nuevo a través de nuestros módulos.

En éste caso, vamos a usar un módulo (como siempre: Dc_Test) para agregar el atributo.

Dc_Test va a tener sólo tres archivos. El primero, es la configuración del módulo y estará ubicado en /app/code/local/Dc/Test/etc/config.xml.

 version="1.0"?>
>
   >
      >
         >0.1.0>
      >
   >
   >
      >
         >
            >
               >Dc_Test>
               >Mage_Catalog_Model_Resource_Eav_Mysql4_Setup>
            >
            >
               >core_setup>
            >
         >
      >
   >
>

Luego, vamos a especificar las propiedades de nuestro atributo en el instalador, que se encontrará en /app/code/local/Dc/Test/sql/test_setup/mysql4-install-0.1.0.php.

$installer = $this;
 
$installer->startSetup();
 
$installer->addAttribute('catalog_category', 'test', array(
                        'type'              => 'text',
                        'backend'           => '',
                        'frontend'          => '',
                        'label'             => 'My test attribute',
                        'input'             => 'text',
                        'class'             => '',
                        'source'            => '',
                        'global'            => 1,
                        'visible'           => 1,
                        'required'          => 0,
                        'user_defined'      => 0,
                        'default'           => '',
                        'searchable'        => 0,
                        'filterable'        => 0,
                        'comparable'        => 0,
                        'visible_on_front'  => 0,
                        'unique'            => 0,
                        'position'          => 1,
                    ));
 
$installer->endSetup();

Por último, vamos a dejar habilitado el módulo dentro de Magento, agregando el archivo /app/etc/modules/Dc_Test.xml.

 version="1.0"?>
>
    >
        >
            >true>
            >local>
        >
    >
>

Paso siguiente, ingresamos al backend y si estamos utilizando cache, lo refrescamos.

La próxima vez que ingresemos a la edición de categorías debería verse lo siguiente.

El ejemplo sólo agrega un atributo de tipo texto con un input para llenar el valor, pero podemos utilizar cualquiera de los tipos de campos que nos ofrece la plataforma.

Si necesitáramos un atributo para manejar una imagen adicional, el setup podría quedar así:

$installer = $this;
 
$installer->startSetup();
 
$installer->addAttribute('catalog_category', 'test_picture', array(
                        'type'              => 'varchar',
                        'backend'           => 'catalog/category_attribute_backend_image',
                        'frontend'          => '',
                        'label'             => 'Test Picture',
                        'input'             => 'image',
                        'class'             => '',
                        'source'            => '',
                        'global'            => 0,
                        'visible'           => 1,
                        'required'          => 0,
                        'user_defined'      => 0,
                        'default'           => '',
                        'searchable'        => 0,
                        'filterable'        => 0,
                        'comparable'        => 0,
                        'visible_on_front'  => 0,
                        'unique'            => 0,
                        'position'          => 1,
                    ));
 
$installer->endSetup();

Puede ser un campo booleano haciendo uso de los modelos de Magento.

$installer = $this;
 
$installer->startSetup();
 
$installer->addAttribute('catalog_category', 'test_yes_no', array(
                        'type'              => 'int',
                        'backend'           => '',
                        'frontend'          => '',
                        'label'             => 'Test Yes/No',
                        'input'             => 'select',
                        'class'             => '',
                        'source'            => 'eav/entity_attribute_source_boolean',
                        'global'            => 1,
                        'visible'           => 1,
                        'required'          => 0,
                        'user_defined'      => 0,
                        'default'           => '',
                        'searchable'        => 0,
                        'filterable'        => 0,
                        'comparable'        => 0,
                        'visible_on_front'  => 0,
                        'unique'            => 0,
                        'position'          => 1,
                    ));
 
$installer->endSetup();

O incluso podemos crear nuestros propios modelos para llenar los valores de un atributo.

$installer = $this;
 
$installer->startSetup();
 
$installer->addAttribute('catalog_category', 'test_custom', array(
                        'type'              => 'int',
                        'backend'           => '',
                        'frontend'          => '',
                        'label'             => 'Test Custom',
                        'input'             => 'select',
                        'class'             => '',
                        'source'            => 'test/entity_attribute_source_test',
                        'global'            => 1,
                        'visible'           => 1,
                        'required'          => 0,
                        'user_defined'      => 0,
                        'default'           => '',
                        'searchable'        => 0,
                        'filterable'        => 0,
                        'comparable'        => 0,
                        'visible_on_front'  => 0,
                        'unique'            => 0,
                        'position'          => 1,
                    ));
 
$installer->endSetup();

Y agregamos el modelo que nos dará los valores. El archivo estará, para el ejemplo, en /app/code/local/Dc/Test/Model/Entity/Attribute/Source/Test.php.

class Dc_Test_Model_Entity_Attribute_Source_Test extends Mage_Eav_Model_Entity_Attribute_Source_Table
{
    public function getAllOptions()
    {
        return array(
            array(
                'value' => 'none',
                'label' => Mage::helper('adminhtml')->__('No Test')
            ),
            array(
                'value' => 'test1',
                'label' => Mage::helper('adminhtml')->__('Test 1')
            ),
            array(
                'value' => 'test2',
                'label' => Mage::helper('adminhtml')->__('Test 2')
            ),
            array(
                'value' => 'test3',
                'label' => Mage::helper('adminhtml')->__('Test 3')
            )
        );
    }
}

Para que éste modelo sea accesible es necesario modificar el archivo config.xml del módulo. La versión final debería verse así:

 version="1.0"?>
>
   >
      >
         >0.1.0>
      >
   >
   >
      >
         >
            >
               >Dc_Test>
               >Mage_Catalog_Model_Resource_Eav_Mysql4_Setup>
            >
            >
               >core_setup>
            >
         >
      >
      >
        >
            >Dc_Test_Model>
        >
      >
   >
>

El resultado de ésta modificación sería:

A lo mejor te interese leer

Cómo modificar valores de configuración vía código en Magento

Damián — Mon, 15 Aug 2011 09:00:13 +0000

En algunos escenarios es posible que ante ciertas acciones o resultados, debamos modificar algún valor que se encuentra en la configuración general de Magento.

Para modificar un valor de la configuración general de forma programática (si, suena rara la palabra al traducirla) sólo necesitamos 3 líneas de código, la clave que queremos actualizar y el nuevo valor.

Para el ejemplo, vamos a poner la tienda en modo demo.

$_new_value = '1';
$model = new Mage_Core_Model_Config();
$model->saveConfig('design/head/demonotice', $_new_value, 'default');
Mage::getConfig()->cleanCache();

De ésta forma, con éste sencillo tip, podemos modificar comportamientos generales de la tienda.

A lo mejor te interese leer

Cómo hacer un módulo con soporte multistore en Magento

Damián — Tue, 31 May 2011 21:20:07 +0000

Una de las características que no necesita presentación en Magento es su capacidad de ser multistore.

Si estuviéramos armando un módulo para mostrar contenido en el frontend de una tienda, deberíamos tener en cuenta ésta característica. (Por más obvio que suena, aún hoy siguen apareciendo módulos que no acusan recibo de esto)

Agregar ésta posibilidad a nuestro módulo es algo realmente sencillo. Para el ejemplo, vas a seguir jugando con el ya ultra modificado módulo Dc_Test.

Una vez que hayamos activado el módulo (como siempre, el creador de Módulos es de gran ayuda), veríamos una grilla y un formulario como los siguientes.

Ahora lo que vamos a hacer es agregar la posibilidad de administrar nuestros registros por store view (ya sea que lo quieran usar por idioma o por tienda).

Las modificaciones las vamos a hacer en 5 archivos de nuestro módulo:

Dc/Test/Block/Adminhtml/Test/Edit/Tab/Form.php
Dc/Test/Block/Adminhtml/Test/Grid.php
Dc/Test/etc/config.xml
Dc/Test/Model/Mysql4/Test/Collection.php
Dc/Test/Model/Mysql4/Test.php

La primera modificación la hacemos sobre Dc/Test/Block/Adminhtml/Test/Edit/Tab/Form.php y, sólo como ejemplo, luego del campo Status agregamos el siguiente código.

if (!Mage::app()->isSingleStoreMode()) {
    $fieldset->addField('store_id', 'multiselect', array(
        'name'      => 'stores[]',
        'label'     => Mage::helper('test')->__('Store View'),
        'title'     => Mage::helper('test')->__('Store View'),
        'required'  => true,
        'values'    => Mage::getSingleton('adminhtml/system_store')->getStoreValuesForForm(false, true),
    ));
} else {
    $fieldset->addField('store_id', 'hidden', array(
        'name'      => 'stores[]',
        'value'     => Mage::app()->getStore(true)->getId()
    ));
}

Una vez que guardemos, y siempre y cuando tengan más de un Store View creado, ya se verían los cambios en el formulario.

Ahora necesitamos modificar la grilla para que nos muestre ésta información. Editamos el archivo Dc/Test/Block/Adminhtml/Test/Grid.php y, siempre a manera de ejemplo, antes de la columna Status, agregamos:

if (!Mage::app()->isSingleStoreMode()) {
    $this->addColumn('store_id', array(
        'header'        => Mage::helper('test')->__('Store View'),
        'index'         => 'store_id',
        'type'          => 'store',
        'store_all'     => true,
        'store_view'    => true,
        'sortable'      => false,
        'filter_condition_callback' => array($this, '_filterStoreCondition'),
    ));
}

Luego agregaremos también estos dos métodos dentro de la misma clase.

protected function _afterLoadCollection() {
    $this->getCollection()->walk('afterLoad');
    parent::_afterLoadCollection();
}
 
protected function _filterStoreCondition($collection, $column) {
    if (!$value = $column->getFilter()->getValue()) {
        return;
    }
    $this->getCollection()->addStoreFilter($value);
}

Ahora nuestra grilla nos mostrará la información y nos permitirá filtrar por éstos valores.

Hasta acá lo más sencillo. Ahora tenemos que modificar la forma en la que se manejarán esos datos.

Lo primero, será agregar una tabla a la que, para ser ordenados, podemos llamar test_store. En nuestro script de instalación (o actualización) el sql debería verse así:

CREATE TABLE  {$this->getTable('test_store')} (
  test_id int(11) unsigned NOT NULL,
  store_id smallint(5) unsigned NOT NULL,
  PRIMARY KEY  (test_id,store_id),
  KEY `FK_TEST_STORE_STORE` (store_id),
  CONSTRAINT `FK_TEST_STORE_TEST` FOREIGN KEY (`test_id`) REFERENCES `test` (`test_id`) ON DELETE CASCADE ON UPDATE CASCADE,
  CONSTRAINT `FK_TEST_STORE_STORE` FOREIGN KEY (`store_id`) REFERENCES `core_store` (`store_id`) ON DELETE CASCADE ON UPDATE CASCADE
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

El siguiente paso es agregar la entidad dentro de nuestros modelos. Para esto vamos a modificar el archivo Dc/Test/etc/config.xml y dentro de los Models, en las entidades, vamos a agregar:

>
    >test_store>
>

Ahora nuestra definición quedaría así.

>
    >Dc_Test_Model_Mysql4>
    >
        >
            >test>
        >
        >
            >test_store>
        >
    >
>

Tercer paso. Buscamos el archivo Dc/Test/Model/Mysql4/Test/Collection.php y vamos a agregar el método addStoreFilter.

public function addStoreFilter($store, $withAdmin = true) {
    if ($store instanceof Mage_Core_Model_Store) {
        $store = array($store->getId());
    }
    $this->getSelect()->join(
        array('store_table' => $this->getTable('test/test_store')),
        'main_table.test_id = store_table.test_id',
        array()
    )
    ->where('store_table.store_id in (?)', ($withAdmin ? array(0, $store) : $store))
    ->group('main_table.test_id');
 
    return $this;
}

Para finalizar, editamos Dc/Test/Model/Mysql4/Test.php. Aquí se agregaran 3 métodos que serán los que hagan la magia con los datos.

protected function _afterLoad(Mage_Core_Model_Abstract $object) {
    $select = $this->_getReadAdapter()->select()
        ->from($this->getTable('test/test_store'))
        ->where('test_id = ?', $object->getId());
 
    if ($data = $this->_getReadAdapter()->fetchAll($select)) {
        $storesArray = array();
        foreach ($data as $row) {
            $storesArray[] = $row['store_id'];
        }
        $object->setData('store_id', $storesArray);
    }
    return parent::_afterLoad($object);
}
 
protected function _afterSave(Mage_Core_Model_Abstract $object) {
    $condition = $this->_getWriteAdapter()->quoteInto('test_id = ?', $object->getId());
    $this->_getWriteAdapter()->delete($this->getTable('test/test_store'), $condition);
    foreach ((array)$object->getData('stores') as $store) {
        $storeArray = array();
        $storeArray['test_id'] = $object->getId();
        $storeArray['store_id'] = $store;
        $this->_getWriteAdapter()->insert($this->getTable('test/test_store'), $storeArray);
    }
 
    return parent::_afterSave($object);
}
 
protected function _getLoadSelect($field, $value, $object) {
    $select = parent::_getLoadSelect($field, $value, $object);
    if ($object->getStoreId()) {
        $select->join(
            array('ts' => $this->getTable('test/test_store')),
            $this->getMainTable().'.test_id = ts.test_id'
        )
        ->where('is_active=1 AND ts.store_id in (0, ?) ', $object->getStoreId())
        ->order('store_id DESC')
        ->limit(1);
    }
 
    return $select;
}

Ahora si, con todas nuestras modificaciones implementadas, volvemos al backend a probar el módulo. Deberían estar viendo algo similar a:

De ésta forma, nuestro módulo ya soporta múltiples store views.

El paso final para utilizar éstos valores en el frontend es aplicar el filtro al momento de pedir la colección.

Cuando ejecutemos el getModel de éste módulo, deberíamos hacerlo de la siguiente manera.

Mage::getModel('test/test')->getCollection()->addStoreFilter(Mage::app()->getStore()->getId())->getItems();

De acá en más será simplemente hacer la iteración para obtener los datos.

A lo mejor te interese leer

Cómo obtener la versión de un módulo en Magento

Damián — Tue, 17 May 2011 03:15:55 +0000

Podría darse el caso en el cual necesitemos obtener información de un módulo para tomar ejecutar ciertas acciones.

Definitivamente es un escenario pensado para cuando creamos extensiones. Para el caso de un desarrollo completo, nuestro control del código y de la tienda es total.

Supongamos entonces que tenemos al ya ultra trillado módulo Dc_Test. Vamos a considerar que nuestro módulo se encarga de interactuar o incluso modificar algún comportamiento del módulo Mage_Newsletter.

No recuerdo ahora las versiones, pero si que tuve que lidiar alguna vez con modelos de ese módulo, que de una versión a otra habían sido eliminados.

La solución ante ese escenario sería reescribir el código de forma tal que funcione de la misma forma sin importar la versión, pero ¿y si existiera un caso en el cual esto no fuera posible?.

Si llegáramos a éste punto, lo que podemos hacer es validar la versión del módulo con el que estamos trabajando. De ésta forma podríamos invocar una acción u otra según las versiones, puntualmente, conflictivas.

Para obtener ese dato sólo necesitamos ejecutar una función.

echo Mage::getConfig()->getModuleConfig('Mage_Newsletter')->version;

El resultado de la llamada sería: 0.8.3.

Además de ésta información, podemos validar si el módulo se encuentra activo, ver en que pool se encuentra el módulo y, además, preguntar por las dependencias del mismo.

echo Mage::getConfig()->getModuleConfig('Mage_Newsletter')->active;

Nos mostrará: true.

echo Mage::getConfig()->getModuleConfig('Mage_Newsletter')->codePool;

Y en éste caso: core.

Un pequeño tip que puede llegar a ahorrar algunas horas de coding.

A lo mejor te interese leer

Cómo crear una clase para el Shell en Magento

Damián — Mon, 25 Apr 2011 07:00:28 +0000

Cuando pensamos en módulos para Magento nos quedamos, normalmente, con agregar funcionalidad para el frontend o para el backend.

Creo que cuando pensamos en un módulo debemos imaginarnos los cuatro posibles entornos para su aplicación. Por los cuatro entornos me refiero:

Frontend o tienda propiamente dicha.
Backend o administración.
API.
Consola.

Si bien ésta división puede parecer arbitraria, éstas serán las posibles puertas de entrada que normalmente utilicemos (dependiendo sobre si nos toca ser usuario, administrador, desarrollador o el encargado del mantenimiento; o todo).

Claro está que no todos los módulos requieren funcionalidad en los cuatro entornos, pero en muchos casos deberíamos cuidar las formas y proveer de herramientas para cada caso.

En mi caso, desde hace ya un buen tiempo, me ha tocado desarrollar unas cuantas integraciones que importan o exportan información. Normalmente, con procesos manejados a través del Cron de Magento.

Uno de las situaciones con las que nos vamos a encontrar cuando trabajemos con módulos que funcionan con un cronjob, es la de la prueba de ejecución. Está claro que podemos programar la tarea para que se ejecute y esperar a que suceda. Luego de la quinta prueba es muy probable que empecemos a perder un poco la paciencia.

Lo que vamos a ver hoy es cómo crear una clase para el shell respetando el estilo de la plataforma. Si bien podemos hacerlo por fuera de éstos lineamientos, vamos a tratar de ser lo más respetuosos posible. La idea es lograr tener siempre extensiones prolijas para que puedan ser reutilizadas y no nos generen conflictos con otras extensiones (o al menos que esos casos sean los menos posibles).

Para seguir con los ejemplos, y partiendo de un punto que cualquiera podría replicar para partir desde el mismo lugar, voy a seguir con mi módulo Dc_Test, creado con el generador de módulos.

Ahora bien, nuestro modulito nos provee ya de la grilla y el formulario para cargar datos en el backend.

Más allá que en éste caso no tenemos motivo aparente para tener funcionalidad en la consola, vamos a pasar por alto ésta cuestión y pensemos que necesitamos poder tener información sobre los datos manejados por éste módulo.

Lo primero que tenemos que hacer es crear nuestra clase que, para mantener la lógica, vamos a llamar Dc_Shell_Test y la vamos a guardar en el archivo /shell/test.php.

La versión más simple de nuestra clase contará con dos métodos: run() y usageHelp(). Más allá de lo obvio, el método usageHelp es el que usaremos para brindar información sobre el uso de la clase.

Un ejemplo de su contenido podría ser:

public function usageHelp() {
    return <<;
}

Hasta ahora, dado que nuestra clase no tiene acciones posibles, sólo podemos mostrar que la ayuda nos permite invocar a la ayuda (si, muy Inception style).

El otro método posible, en nuestra adolescente clase, es run(). De más está decir que éste es el método que será invocado y que será el responsable de ejecutar la o las acciones que desarrollemos.

Aquí podemos aplicar dos formas para invocar a las acciones.

La primera, para el caso más sencillo, sería la siguiente.

public function run() {
    if ($this->getArg('my_action')) {
        //Tareas a realizar por la acción my_action
    } else {
        echo $this->usageHelp();
        exit(1);
    }
}

En éste momento, nuestra clase se debe ver de la siguiente forma. (Nótese que agregué información en el método usageHelp() para describir nuestra acción).

class Dc_Shell_Test {
    public function run() {
        if ($this->getArg('my_action')) {
            //Tareas a realizar por la acción my_action
        } else {
            echo $this->usageHelp();
            exit(1);
        }
    }
 
    public function usageHelp() {
        return <<;
    }
 
}

La clase ya es funcional, pero a nuestro archivo le faltan aún tres líneas.

Primero, debemos hacer un include para la clase abstracta que Magento utiliza para el Shell.

Luego, al final de nuestro archivo otras dos líneas que nos van a instanciar la clase y luego a ejecutarla.

El ejemplo completo debe verse así.

require_once 'abstract.php';
 
class Dc_Shell_Test extends Mage_Shell_Abstract {
 
    public function run() {
        if ($this->getArg('my_action')) {
            echo "Acción de my_action\n";
        } else {
            echo $this->usageHelp();
            exit(1);
        }
    }
 
    public function usageHelp() {
        return <<;
    }
 
}
 
$shell = new Dc_Shell_Test();
$shell->run();

Ahora si, nos vamos a la consola, y dando por sentado que estamos en el directorio correcto, hacemos nuestra primera prueba.

php test --my_action

Nos devolverá.

Acción de my_action

Si en cambio pasamos un parámetro no soportado.

php test --my_test

Tendríamos que obtener lo siguiente.

Usage:  php -f test.php -- [options]
  --myaction          Test action
  --help              This help

Como ven, es una lógica muy sencilla. Básicamente, si el nombre del argumento coincide con uno de los definidos como acción, se ejecutará. Caso contrario, se muestra la ayuda.

Si tuviéramos varias acciones, podemos, o bien tener varios if else if y toda la lógica dentro del método run(), o bien hacer un poco más ordenada nuestra clase y separar cada acción en métodos independientes y modificar un poquito a run().

A manera de ejemplo, vamos a suponer que tenemos 5 acciones posibles, a las que llamaremos: accion1, accion2, accion3, accion4 y accion5.

Para cada acción vamos a crear un método privado. Sólo para el ejemplo, probemos con:

private function accion1() {
    echo "Acción 1\n";
}
 
private function accion2() {
    echo "Acción 2\n";
}
 
private function accion3() {
    echo "Acción 3\n";
}
 
private function accion4() {
    echo "Acción 4\n";
}
 
private function accion5() {
    echo "Acción 5\n";
}

Ahora vamos a cambiar un poquito a run() para evitarnos una lista interminable de if else if.

No sólo vamos a pasar un argumento, sino que vamos a asignarle un valor.

public function run() {
    $action = $this->getArg('my_action');
    if (!empty($action)) {
        $method = $action;
        if (method_exists($this, $method)) {
            $this->$method();
        } else {
            echo "Action $action not exists\n";
            echo $this->usageHelp();
            exit(1);
        }
    } else {
        echo $this->usageHelp();
        exit(1);
    }
 
}

Lo que cambia ahora es que además de validar que exista el parámetro, vamos a tomar el valor del argumento y lo vamos a utilizar para invocar uno de nuestros métodos.

Si el método no existe, notificamos y mostramos la ayuda. (Siempre que agreguemos nuevas acciones tendríamos que agregar la correspondiente descripción en la ayuda).

La clase completa debería verse así.

class Dc_Shell_Test extends Mage_Shell_Abstract {
 
    public function run() {
        $action = $this->getArg('my_action');
        if (!empty($action)) {
            $method = $action;
            if (method_exists($this, $method)) {
                $this->$method();
            } else {
                echo "Action $action not exists\n";
                echo $this->usageHelp();
                exit(1);
            }
        } else {
            echo $this->usageHelp();
            exit(1);
        }
    }
 
    private function accion1() {
        echo "Acción 1\n";
    }
 
    private function accion2() {
        echo "Acción 2\n";
    }
 
    private function accion3() {
        echo "Acción 3\n";
    }
 
    private function accion4() {
        echo "Acción 4\n";
    }
 
    private function accion5() {
        echo "Acción 5\n";
    }
 
    public function usageHelp() {
        return <<;
    }
 
}

Con ésta modificación, vamos a cambiar la forma de pasar los parámetros. Si quisiéramos llamar a la Acción 3, lo haríamos de ésta forma.

php test.php --my_action accion3

Y obtendríamos éste resultado.

Acción 3

Y si enviáramos un parámetro incorrecto, por ejemplo: php test.php –my_action accion6, deberíamos obtener el mensaje de nuestra ayuda.

Action accion6 not exists
Usage:  php -f test.php -- [options]
 
  --my_action accion1     Acción 1
  --my_action accion2     Acción 2
  --my_action accion3     Acción 3
  --my_action accion4     Acción 4
  --my_action accion5     Acción 5
  --help                  This help

Ahora si, ya tenemos una forma prolija y ordenada de realizar acciones en Magento desde la consola.

A lo mejor te interese leer

Cómo modificar los botones de la grilla en un módulo de Magento

Damián — Sun, 20 Feb 2011 21:30:16 +0000

Cuando utilizamos el generador automático de modulos, nuestra grilla viene un botón para agregar nuevos registros.

En algunas oportunidades, posiblemente necesitemos hacer algunos cambios, ya sea agregando acciones o quitando las que obtenemos por defecto.

Para comenzar, tenemos que identificar la clase que se encarga de definir dicha sección. Suponiendo que el módulo se llama Dc_Test, tenemos que buscar el siguiente archivo: /app/code/local/Dc/Test/Block/Adminhtml/Test.php.

Lo que vamos a ver en el archivo es lo siguiente:

class Dc_Test_Block_Adminhtml_Test extends Mage_Adminhtml_Block_Widget_Grid_Container {
 
    public function __construct()     {
        $this->_controller = 'adminhtml_test';
        $this->_blockGroup = 'test';
        $this->_headerText = Mage::helper('test')->__('Item Manager');
        $this->_addButtonLabel = Mage::helper('test')->__('Add Item');
        parent::__construct();
    }
 
}

Si quisiéramos eliminar el botón “Add item” que se genera automáticamente, vamos a tener que hacer uso del método _removeButton().

Para que funcione, el código deberá quedar de ésta forma.

class Dc_Test_Block_Adminhtml_Test extends Mage_Adminhtml_Block_Widget_Grid_Container {
 
    public function __construct()     {
        $this->_controller = 'adminhtml_test';
        $this->_blockGroup = 'test';
        $this->_headerText = Mage::helper('test')->__('Item Manager');
        $this->_addButtonLabel = Mage::helper('test')->__('Add Item');
        parent::__construct();
        $this->_removeButton('add');
    }
 
}

Ahora, la grilla nos quedará como en la imagen.

El segundo escenario posible es el de modificar y/o agregar acciones. Para esto tenemos dos formas diferentes de lograrlo.

Si queremos modificar valores de un botón ya existente, vamos a hacer uso del método _updateButton(). Suponiendo que no hemos removido el botón original, vamos a cambiar el texto y la acción que realiza.

class Dc_Test_Block_Adminhtml_Test extends Mage_Adminhtml_Block_Widget_Grid_Container {
 
    public function __construct()     {
        $this->_controller = 'adminhtml_test';
        $this->_blockGroup = 'test';
        $this->_headerText = Mage::helper('test')->__('Item Manager');
        $this->_addButtonLabel = Mage::helper('test')->__('Add Item');
        parent::__construct();
        $$this->_updateButton('add', 'label', Mage::helper('adminhtml')->__('Updated label'));
        $this->_updateButton('add', 'onclick', 'alert(\'New action event\')');
    }
 
}

Luego de esto, vemos que el texto fue modificado y también su acción.

El otro caso sería el de agregar nuevas acciones. Para esto tenemos que hacer uso del último método: _addButton().

class Dc_Test_Block_Adminhtml_Test extends Mage_Adminhtml_Block_Widget_Grid_Container {
 
  public function __construct() {
    $this->_controller = 'adminhtml_test';
    $this->_blockGroup = 'test';
    $this->_headerText = Mage::helper('test')->__('Item Manager');
    $this->_addButtonLabel = Mage::helper('test')->__('Add Item');
    parent::__construct();
    $this->_addButton('test', array(
            'label'     => 'My test button',
            'onclick'   => 'alert(\'Test button with custom action.\')',
        ));
  }
 
}

Como resultado, ésto es lo que obtenemos.

De ésta forma ya podemos manejar los botones que se muestran en la grilla, personalizando tanto su leyenda como su acción.

Lo último que nos falta agregar son los estilos. Si prestamos atención a la última imagen, el botón original presenta un icono, mientras que el agregado no lo hace.

Para esto necesitamos pasarle un parámetro adicional al botón: class.

    $this->_addButton('test', array(
            'label'     => 'My test button',
            'onclick'   => 'alert(\'Test button with custom action.\')',
            'class'     => 'add',
        ));

Los valores que podemos usar son add, save, delete y back.

La yapa

Estos métodos (implementándolos de la misma forma) sirven para modificar los botones que se tienen en los formularios.

La clase que maneja éstos botones, siguiendo con mi módulo de ejemplo, es: Dc_Test_Block_Adminhtml_Test_Edit.

Si revisamos el archivo, nos encontraremos con el siguiente código.

class Dc_Test_Block_Adminhtml_Test_Edit extends Mage_Adminhtml_Block_Widget_Form_Container {
 
    public function __construct() {
        parent::__construct();
        $this->_objectId = 'id';
        $this->_blockGroup = 'test';
        $this->_controller = 'adminhtml_test';
        $this->_updateButton('save', 'label', Mage::helper('test')->__('Save Item'));
        $this->_updateButton('delete', 'label', Mage::helper('test')->__('Delete Item'));
        $this->_addButton('saveandcontinue', array(
            'label'     => Mage::helper('adminhtml')->__('Save And Continue Edit'),
            'onclick'   => 'saveAndContinueEdit()',
            'class'     => 'save',
        ), -100);
    }
 
    public function getHeaderText() {
        ...
    }
 
}

Es ahí donde tenemos que empezar a hacer los ajustes para personalizar el formulario.

A lo mejor te interese leer

Agregar columnas a la grilla de Productos en Magento

Damián — Sun, 23 Jan 2011 04:56:35 +0000

Una pequeña pero útil customización que suelen pedirme es la de agregar más información en la grilla de productos y, en otros casos, en la grilla de productos de las categorías. La idea es proveer de mayor cantidad de filtros según la necesidad de cada catalogación.

La grilla de productos, por defecto, tiene éstas columnas.

Si bien hay varios tipos de filtros, los que suelo usar en éstas modificaciones son los campos de texto y los dropdown.

Por ejemplo, para agregar la columna Descripción a la grilla, y que funcione como filtro, debemos realizar el siguiente cambio en el archivo /app/code/core/Mage/Adminhtml/Block/Catalog/Product/Grid.php.

(En realidad, modificamos el archivo del Core sólo para el ejemplo. Lo que hay que hacer es aplicar una reescritura del bloque).

Como decía, vamos a editar el archivo y vamos a agregar al método _prepareCollection() el atributo que queremos utilizar en la definición de la colección.

$collection = Mage::getModel('catalog/product')->getCollection()
                ->addAttributeToSelect('sku')
                ->addAttributeToSelect('name')
                ->addAttributeToSelect('attribute_set_id')
                ->addAttributeToSelect('type_id')
                ->addAttributeToSelect('description') // ESTE ES NUESTRO NUEVO ATRIBUTO
                ->joinField('qty',
                    'cataloginventory/stock_item',
                    'qty',
                    'product_id=entity_id',
                    '{{table}}.stock_id=1',
                    'left');

Luego, en el método _prepareColumns() lo siguiente a la definición de la columna Qty.

$this->addColumn('description',
    array(
        'header' => Mage::helper('catalog')->__('Description'),
         'index' => 'description',
));

De ésta forma, la grilla debería verse como ésta.

Desde ahora, podremos ver el contenido de ese atributo y utilizarlo como filtro de búsqueda.

Si quisiéramos usar un dropdown, como el caso del atributo Fabricante, el código a utilizar nos debería quedar de la siguiente manera.

En el método _prepareCollection() la llamada para la definición del collection debe agregar el atributo. Al igual que en el ejemplo anterior.

$collection = Mage::getModel('catalog/product')->getCollection()
                ->addAttributeToSelect('sku')
                ->addAttributeToSelect('name')
                ->addAttributeToSelect('attribute_set_id')
                ->addAttributeToSelect('type_id')
                ->addAttributeToSelect('manufacturer')
                ->joinField('qty',
                    'cataloginventory/stock_item',
                    'qty',
                    'product_id=entity_id',
                    '{{table}}.stock_id=1',
                    'left');

El siguiente paso es agregar la columna, la cual requiere de algunas líneas más de código.

$_attribute = Mage::getModel('eav/entity_attribute');
$_attribute->loadByCode(4,'manufacturer');
$_attribute_values = Mage::getResourceModel('eav/entity_attribute_option_collection')
                        ->setAttributeFilter($_attribute->getId())
                        ->setStoreFilter( Mage_Core_Model_App::ADMIN_STORE_ID, false)
                        ->getData();
$manufacturer = array();
foreach ($_attribute_values as $_manufacturer) {
    $manufacturer[$_manufacturer['option_id']] = $_manufacturer['value'];
}
 
$this->addColumn('manufacturer', array(
        'header'    => Mage::helper('catalog')->__('Manufacturer'),
        'index'     => 'manufacturer',
        'type'      => 'options',
        'options'   => $manufacturer
));

Ahora si, el resultado de éstas modificaciones nos debería mostrar la grilla con ésta nueva columna.

La segunda grilla que podemos modificar es la mostrada en la cuarta solapa en la edición de la Categoría. Con ésta modificación tendremos mayor comodidad si, por ejemplo, se crean categorías como marcas y el atributo manufacturer fue cargado. De ésta forma, asociar los productos correspondientes será muchísimo más rápido que utilizando otro criterio.

Para poder personalizar dicha grilla, nuestra modificación deberá recaer sobre el archivo /app/code/core/Mage/Adminhtml/Block/Catalog/Category/Tab/Product.php, en el cual aplicaremos exactamente el mismo código que ya probamos para la grilla de Productos.

Una vez hecha la modificación, pasaríamos de la grilla original.

A la grilla modificada.