Upload
others
View
4
Download
0
Embed Size (px)
Citation preview
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
PROYECTO FINAL DE MÁSTER
Máster en Tecnologías de la Información
Ingeniería del software y sistemas de información
Desarrollo de una Herramienta de Validación / Importación para Magento
JAVIER CARRASCAL HERNÁNDEZ
Director JOSE MANUEL PÉREZ
Ponente JOSEP CARMONA VARGAS
Modalidad B: Empresa
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
Agradecimientos
Este proyecto está dedicado a todas aquellas personas que de algún modo han colaborado en el
desarrollo de este proyecto. Especial agradecimiento a Xose Pérez, Josep Carmona, Azucena
Casado y por último, a mis compañeros de trabajo Oriol Auge y Virginie Faure, porque sin su
ayuda este proyecto no habría sido posible.
3
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
Índice de contenido
Agradecimientos............................................................................................................................3
1.- Abstract.....................................................................................................................................7
2.- Introducción..............................................................................................................................8
2.1.- El comercio electrónico...................................................................................................8
2.2.- El mercado del E-Commerce..........................................................................................8
2.3.- The Etailers.....................................................................................................................9
2.4.- Magento..........................................................................................................................9
Visión General.............................................................................................................10
Lo que diferencia a Magento........................................................................................10
Problemas....................................................................................................................11
3.- Motivación...............................................................................................................................12
3.1.- Motivación y beneficios.................................................................................................12
4.- Análisis de antecedentes.......................................................................................................14
4.1.- Estado del Arte..............................................................................................................14
4.2.- Alternativas...................................................................................................................14
Magento Dataflow........................................................................................................14
Magmi y Hermes..........................................................................................................15
4.3.- Evaluación de las Alternativas: Hermes........................................................................15
5.- Objetivos y Alcance................................................................................................................17
5.1.- Alcance y Objetivos del proyecto..................................................................................17
6.- Especificación de Requisitos.................................................................................................18
6.1.- Requisitos Iniciales ......................................................................................................18
Situación Inicial............................................................................................................18
¿Como mejorar Magmi?..............................................................................................18
Planificación del proceso.............................................................................................19
Estado inicial del proceso y metodología de trabajo....................................................22
6.2.- Evolución de los Requisitos..........................................................................................22
7.- Especificación funcional del sistema....................................................................................25
7.1.- Esquema general del sistema.......................................................................................26
Sistema........................................................................................................................26
Actores.........................................................................................................................26
Casos de Uso..............................................................................................................27
8.- Diseño......................................................................................................................................31
8.1. - Arquitectura tres capas................................................................................................31
8.2.- Patrones de diseño utilizados.......................................................................................33
Singleton......................................................................................................................33
4
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
Strategy........................................................................................................................33
9.- Implementación.......................................................................................................................35
9.1.- Estructura......................................................................................................................35
9.2.- Validación léxica...........................................................................................................36
Métodos/Algoritmos de validación................................................................................37
Expresiones regulares.................................................................................................38
Auto-corrección de datos.............................................................................................39
9.3.- Validación semántica....................................................................................................40
Comprobaciones en la base de datos..........................................................................41
Detección de errores/inconsistencias...........................................................................42
Otras comprobaciones.................................................................................................43
9.4.- Interfaces......................................................................................................................45
Web.............................................................................................................................45
CURL...........................................................................................................................47
Command-line..............................................................................................................49
9.5.- Profiling.........................................................................................................................49
9.6.- Subida de Imágenes.....................................................................................................52
Multi-Sitios/Multi-Marca................................................................................................53
9.7.- Cola de procesamiento asíncrona.................................................................................54
Aprendizaje automático ...............................................................................................58
Árbol de decisión CART...............................................................................................59
10.- Metodología de Desarrollo...................................................................................................62
10.1.- Desarrollo ágil de software..........................................................................................62
10.2.- Kanban........................................................................................................................62
Orígenes......................................................................................................................62
Las tres reglas de Kanban...........................................................................................63
1. Mostrar el proceso..........................................................................................63
2. Limitar el trabajo en curso...............................................................................64
3. Optimizar el flujo de trabajo............................................................................65
11.- Infraestructura.......................................................................................................................66
11.1.- LAMP..........................................................................................................................66
LNMP...........................................................................................................................67
11.2.- Entornos......................................................................................................................67
12.- Pruebas de Software.............................................................................................................68
12.1.- PHPUnit......................................................................................................................69
12.2.- Test Unitarios..............................................................................................................69
Reflection.....................................................................................................................70
Mocks..........................................................................................................................70
5
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
12.3.- Test de Integración/Funcionales.................................................................................71
12.4.- Cobertura de Código...................................................................................................72
12.5.- Integración Continua...................................................................................................73
13.- Funcionamiento.....................................................................................................................75
13.1.- Perfiles, manual de utilización, monitorización............................................................75
14.- Planificación..........................................................................................................................76
14.1.- Planificación de tareas................................................................................................76
Desviaciones................................................................................................................80
15.- Conclusiones.........................................................................................................................81
15.1.- Conclusiones finales...................................................................................................81
15.2.- Trabajo futuro..............................................................................................................82
16.- Referencias............................................................................................................................85
16.1.- Bibliografía referente a las tecnologías utilizadas:......................................................85
16.2.- Bibliografía general ....................................................................................................85
17.- Apéndice................................................................................................................................86
17.1.- Jenkins........................................................................................................................86
Integración Continua....................................................................................................86
Jenkins.........................................................................................................................86
ANT..............................................................................................................................90
Ejecución del Job de Jenkins.......................................................................................94
17.2.- Manual de Usuario....................................................................................................100
6
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
1.- Abstract
Este proyecto se define en el área del comercio electrónico, un sector en pleno auge a nivel
mundial. La empresa The Etailers gestiona numerosas tiendas online por toda España, y el
proyecto surge de la necesidad de renovar y/o actualizar periódicamente los productos de las
tiendas, principalmente en las nuevas temporadas, épocas de rebajas, etc.
La ausencia de una herramienta que permita gestionar de manera eficaz el catálogo de productos
de las distintas tiendas de los clientes finalmente da lugar a este proyecto.
Básicamente, el proyecto consiste en la implementación una herramienta que permita importar y/o
actualizar productos de forma masiva en las tiendas online. Esta herramienta deberá ser capaz de
analizar y validar los datos de manera que no se permita llevar a cabo importaciones y/o
actualizaciones de productos si se detecta algún error. Así mismo, la herramienta deberá
proporcionar un feedback al usuario de la aplicación que permita fácilmente detectar y corregir
dichos errores.
7
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
2.- Introducción
2.1.- El comercio electrónico
El E-Commerce o comercio electrónico es cualquier forma de transacción comercial de compra o
venta de bienes o servicios a través de redes de comunicaciones, específicamente Internet.
En líneas generales, el comercio electrónico trae beneficios tanto para clientes como para
empresas. Por una parte, los clientes disponen de una mayor cantidad de ofertas (algunas de las
cuales personalizables); mientras que las empresas amplían su mercado local y ahorran costos de
personal, infraestructura e intermediarios.
2.2.- El mercado del E-Commerce
Las empresas tradicionales están acelerando la adopción del comercio electrónico debido a la
demanda creciente por parte de los consumidores. Estos están aumentando significativamente el
porcentaje de compras online, animados por fenómenos recientes como los grupos privados de
venta y la venta de cupones.
En este entorno, el comercio electrónico <<del negocio al consumidor>> (en adelante B2C, del
inglés Business-to-Consumer) en España alcanzó en 2010 la cifra de 9.114 millones de euros,
según el observatorio Red.es, lo que representa un incremento del 17,4% respecto al año anterior.
El gasto medio de los compradores online se situó en el año 2010 en 831 euros, creciendo desde
los 749 euros del 2009. La mitad del gasto online se realiza en comercios nacionales.
En 2011, el mercado B2C en España ha crecido respecto a 2010 un 19,8% hasta los 10.917
Millones de euros, 2,4 puntos más que entre 2009 y 2010, período en el que las condiciones
económicas eran más favorables. Con lo cual, se constata que el comercio electrónico es una
modalidad joven en pleno crecimiento y una alternativa tanto de expansión como de supervivencia
para los negocios en tiempos de crisis. El incremento del mercado viene justificado, sobre todo,
por el aumento de más de un 20% de los compradores online, que han gastado de media 828
euros y han bajado ligeramente la frecuencia de compra.
8
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
2.3.- The Etailers
The Etailers es una empresa del grupo Inspirit que ofrece una plataforma gestionada de comercio
electrónico y generación de tráfico online para cualquier compañía que quiera promocionar su
tienda en Internet.
La empresa fue fundada en Barcelona en 2010, y se dirige tanto al comercio tradicional que quiere
dar el salto al medio online, como al comercio exclusivamente online, que quiere mejorar sus
resultados de captación y conversión de tráfico. Del total de sus clientes, un 65% responde a
comercio tradicional y el 35% restante proviene de actores online.
The Etailers está liderada por Santiago Sánchez y cuenta con más de 30 clientes en la actualidad,
entre los que destacan empresas como Aita, Antonio Miró, Cottet, Fundació Dalí, Miguel Torres,
VilaViniteca, Vileda o Schweppes, entre otras.
Actualmente, todas las tiendas están funcionando en una aplicación web e-commerce de código
abierto llamada Magento.
2.4.- Magento
Se trata de una plataforma innovadora
de comercio electrónico para la
completa implementación de sitios
web con una o varias tiendas
virtuales.
Magento es una herramienta
desarrollada en Zend Framework 1,
basada en el modelo de datos
Entidad-Atributo-Valor, también
conocido como Objeto-Atributo-Valor
o Esquema Abierto. Este modelo se usa en casos donde el número de atributos usados para
describir una entidad u objeto es potencialmente grande.
9
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
Visión General
Magento es una plataforma de comercio electrónico construida con tecnologías Open Source que
proporciona a los comerciantes flexibilidad y control sobre la apariencia, contenido y funcionalidad
de sus tiendas de comercio electrónico.
La intuitiva interfaz de administración proporciona funciones de marketing, optimización frente a
buscadores y un catálogo de herramientas de administración para dar la posibilidad a los
comerciantes de crear sitios que se adapten a sus necesidades empresariales.
Lo que diferencia a Magento
Magento incluye posibilidades y opciones avanzadas que lo convierten en una solución flexible
para futuro crecimiento y expansión de sitios de comercio electrónico, desde una tienda virtual
moderna hasta una solución altamente específica e innovadora. Algunas de ellas son:
• Administración del sitio: Magento permite el control de múltiples sitios web y tiendas
online desde un solo panel de administración. Estos sitios web y tiendas online pueden
compartir información entre sí.
• Promociones y herramientas de marketing: Se pueden crear cupones flexibles (en base
a reglas de precios) con la posibilidad de restringirlos a tiendas, grupos de clientes,
periodos de tiempo, productos y categorías.
• Navegabilidad: Los usuarios disponen inicialmente de una vista de los productos
recientemente vistos y recientemente comparados; mientras que los administradores
tienen herramientas para promocionar nuevos productos.
• Soporte internacional: Soporta localización geográfica de acuerdo al visitante, interfaz en
distintos idiomas (incluyendo el español), productos en múltiples monedas y configuración
de tasas de impuestos.
• Pedidos: La generación de pedidos se realiza en una sola página, y se pueden realizar
envíos a múltiples direcciones desde una sola orden. También existe la opción de que los
clientes registrados puedan volver a ordenar pedidos anteriores.
• Administración de órdenes: Las órdenes de pedidos pueden ser vistas, editadas y
creadas desde el panel de administración. Adicionalmente, los administradores cuentan
con un tablero que muestra el resumen de reportes.
• Administración de catálogos: Soporta la venta de productos digitales, descargables vía
Internet; así como el establecimiento de reglas complejas de precios y precios especiales.
10
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
También es posible asignar múltiples imágenes por productos y hacer zoom a las
imágenes.
• Navegación por catálogos y productos: Se pueden efectuar comparaciones entre
productos y opiniones de productos, generar listas de productos que se desearían comprar
(Whish lists), y recomendar productos a amigos vía correo electrónico.
Problemas
Uno de los principales inconvenientes de Magento, es la ausencia de un potente sistema de
importación de productos. La realización de estas tareas es un proceso largo y complejo, no sólo a
la hora de poner en marcha una nueva tienda, sino también para realizar tareas rutinarias de
actualización de stocks, precios, o alta/baja de productos cada nueva temporada.
Este proyecto surge de la necesidad de disponer de una herramienta que optimice el proceso de
actualización e importación de productos, minimizando al máximo el tiempo empleado.
11
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
3.- Motivación
3.1.- Motivación y beneficios
Casi todas las semanas es necesario realizar alguna tarea de importación/actualización de
productos, y es el equipo técnico (los desarrolladores) el encargado de realizarlas. Para ello se
utiliza una herramienta desarrollada por The Etailers, que mediante la API SOAP de Magento,
lleva a cabo la actualización/importación de los productos.
Cuando un cliente desea realizar una tarea, ya sea de actualización, o de importación, el proceso
que se sigue es el siguiente:
1. Primero, se colocan los datos que se desean actualizar en una hoja de cálculo de Google
Docs, cuya plantilla ha sido predefinida por The Etailers.
2. Una vez se ha cumplimentado la hoja, un desarrollador de The Etailers se encarga de
revisarla y, si procede, realizar las correcciones pertinentes.
3. Cuando el documento está listo, se ejecuta la herramienta, que se encarga de descargar el
documento, y gestionar la importación de los datos a la tienda correspondiente.
Este proceso funciona correctamente, no obstante, tiene una serie de desventajas que se detallan
a continuación:
• Si la hoja de cálculo de Google Docs tiene algún error, el proceso de importación fallará,
siendo necesario corregir el problema, eliminar los productos ya importados, y volver a
ejecutar la herramienta. Además, si se trata de una importación/actualización con un gran
número de filas, el manejo del documento desde el navegador se complica debido al gran
consumo de memoria y a las limitaciones de tamaño de los documentos de Google.
• El proceso de importación es muy costoso en cuanto a rendimiento, ya que la herramienta
tiene que descargar el documento, procesarlo, y enviar los datos a la tienda mediante
SOAP. La plataforma Magento, está desarrollada de tal manera que el punto de acceso a
la API, requiere la inicialización de la aplicación, lo cual incrementa notablemente el
descenso del rendimiento a la hora de realizar importaciones.
• Al menos un desarrollador/técnico debe supervisar todo el proceso, así como verificar que
los datos se han importado correctamente, con la consecuente pérdida de tiempo y
recursos que se podrían estar empleando en otras tareas más productivas, ya que una
tarea de importación debería ser un proceso más dinámico y eficiente.
12
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
• El cliente no puede importar los productos por si mismo, ya que depende de que alguien
del equipo de desarrollo realice el proceso.
El incremento del número de tiendas a gestionar y el consecuente aumento del tiempo empleado
en realizar estas tareas, hace necesaria la búsqueda de una solución alternativa que permita
optimizar el proceso, minimizando los recursos empleados. La nueva herramienta deberá tener un
interfaz sencilla e intuitiva, de manera que pueda ser utilizada directamente por los clientes, sin la
necesidad de la intervención del personal técnico de The Etailers. Los beneficios del tiempo
invertido en el desarrollo de la herramienta se amortizarán a corto plazo.
13
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
4.- Análisis de antecedentes
4.1.- Estado del Arte
Una vez tomada la decisión de optar por el desarrollo/integración de una nueva herramienta, se
analiza la situación actual para determinar el alcance y los objetivos del proyecto.
Tras investigar las opciones existentes en el mercado, surgen varias posibilidades, que se
estudiarán en profundidad en el siguiente apartado:
• Magento Dataflow: Magento DataFlow es un Framework para la creación de
componentes que se utilizan en los procesos de intercambio de datos. El sistema consta
de 4 tipos de componentes; Adaptadores, Analizadores, Mapeadores, y Validadores.
Todos los componentes pueden ser secuenciados a la transferencia y transformación de
datos bidireccional-mente de un medio a otro (por ejemplo, a partir de la base de datos de
archivos local, del servidor FTP a la base de datos, a partir de SOAP / REST / XML-RPC a
la base de datos, hoja de cálculo de Google con la base de datos).
• MAGMI (Magento Mass Importer), una herramienta Open Source que permite realizar
importaciones/actualizaciones de productos en tiendas Magento mediante la carga de
ficheros CSV. Dicha herramienta tiene un rendimiento muy bueno, ya que es capaz de
realizar las importaciones conectando directamente a la base de datos de Magento, es
decir, sin tener que conectar a la API y cargar la aplicación.
4.2.- Alternativas
Magento Dataflow
Magento cuenta con un producto de importación / exportación que facilita la adición de la interfaz y
/ o dosificada de edición de datos de productos a través de un archivo (MS - EXCEL, CSV y
valores separados por tabuladores), y un cliente de interfaz de lotes de exportación. Otros usos
para Magento DataFlow pueden incluir:
• Batch de exportación de cualquier tipo de datos en cualquier formato y aplicando la
capacidad de importar de nuevo después de los cambios.
• Exportación de Datos de precios para agregadores (por ejemplo, Shopping.com,
PriceGrabber, Bizrate, etc), incluyendo la capacidad de los archivos FTP de forma
automática.
14
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
• Importación de Datos e integración con terceros ERP / gestión de inventarios / aplicaciones
de contabilidad (por ejemplo, SAP, Great Plains, MAS 90/2000, Oracle, Netsuite,
Quickbooks, Peachtree, etc)
• Integración con terceros de soluciones CRM (por ejemplo, SugarCRM, SalesLogix,
Salesforce.com, ACT, etc)
• Integración con aplicaciones para la gestión de interfaces y EDI
• Obtención de publicación o feeds RSS / Atom (por ejemplo, nuevos productos, precios
especiales, disponibilidad del producto, estado de la orden, etc).
Magmi y Hermes
Magmi es un importador masivo para Magento desarrollado como un cliente de base, (es decir, no
es una extensión de Magento), que opera directamente en SQL. Es el resultado de un análisis en
profundidad del modelo de base de datos de Magento. El principal objetivo de Magmi es la
importación y actualización del catálogo de productos.
Es una herramienta de código abierto desarrollada en PHP, que permite realizar importaciones de
productos a partir de ficheros CSV. Es un complemento ideal para Magento, al proporcionar una
alternativa a la interfaz de importación proporcionada por defecto. Magmi permite crear productos
o actualizar un catálogo existente y hacer frente a gran cantidad de datos, de manera rápida y
eficaz.
4.3.- Evaluación de las Alternativas: Hermes
Tras comparar las alternativas en profundidad, finalmente se descarta la utilización de Magento
Dataflow, principalmente por motivos de rendimiento. Por lo tanto se decide optar por la utilización
de Magmi, debido principalmente a sus características mas destacadas
• El rendimiento es mucho mayor, al importar directamente en la base de datos SQL de
Magento.
• Fácilmente automatizable a través de PHP-CLI o CURL/WGET, además de disponer de
interfaz web para configuración y realización de importaciones.
• Admite diferentes perfiles de configuraciones (de múltiples tiendas)
• Permite importar productos configurables y simples.
• Permite la importación de imágenes (de forma remota y local).
15
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
• Permite la creación categorías sobre la marcha, es decir, es posible importar productos a
una nueva categoría sin tener que crearla previamente, y el programa se encargará de
crearla automáticamente.
• Permite la creación de valores de los campos multi-seleccionables sobre la marcha, es
decir, es posible, por ejemplo, crear una nueva talla a la vez que se importa el producto.
• Se puede integrar fácilmente en scripts de PHP a través de la API datapump.
• Dispone de una serie de plugins que permiten extender su funcionalidad fácilmente.
Sin embargo, el principal problema de Magmi, es la ausencia de un sistema de validación de los
datos, ya que no hay ningún tipo de verificación de la información.
En nuestro caso, la mayoría de las veces esta información es introducida manualmente por los
dueños de cada tienda, con lo cual se producen multitud de errores humanos, que si no se
detectan y corrigen a tiempo, podrían provocar que en el catálogo de Magento aparecieran
productos con datos incorrectos, tales como ausencia de precios, imágenes, etc.
Por lo tanto, para poder utilizar Magmi de manera segura, es imprescindible realizar un análisis
previo de los datos, para detectar los posibles errores y efectuar las correcciones pertinentes
siempre que sea posible, o realizar un informe detallado de los problemas para que se corrijan
manualmente por el usuario.
Este proyecto surge para solventar la necesidad de disponer de una herramienta (en adelante
Hermes) capaz de validar todos los datos proporcionados de forma rápida y eficaz, de manera que
sólo sea posible realizar una importación/actualización si los datos proporcionados son correctos.
16
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
5.- Objetivos y Alcance
5.1.- Alcance y Objetivos del proyecto
Los objetivos del proyecto, a grandes rasgos son:
• Obtener una herramienta capaz de detectar, y corregir siempre que sea posible, todos los
errores encontrados en el archivo de importación.
• Proporcionar un feedback detallado de los errores que permita al usuario detectarlos y
resolverlos con facilidad. Ejemplo: No ha especificado el precio para el producto X.
• Integración con MAGMI, de forma que se pueda unificar el proceso de importación.
• Validación léxica de todos los campos conocidos: Se aplicarán restricciones de formato,
tipo de dato, longitud, caracteres permitidos, etc.
• Validación semántica de todos los campos conocidos: Se verificarán los valores
introducidos, cotejándolos con la base de datos (Ejemplo: Comprobar que el producto que
se va a actualizar ya existe en la base de datos. Asegurar que la tienda o la categoría a la
que se va asociar ya existe.)
• Creación de una batería de test unitarios y de integración que nos proporcionen una
cobertura del código superior al 85%, para mitigar los posibles errores que pudieran surgir
al hacer modificaciones debidas a cambios en los requerimientos.
• El objetivo final es que las tareas de gestión de productos puedan llevarse a cabo de forma
segura por cualquier persona con conocimientos básicos de la plataforma Magento. No
será necesaria la supervisión o presencia de un desarrollador, salvo para el soporte
técnico en caso de que el usuario tenga algún problema que no consiga resolver con la
ayuda del feedback que le proporcionará la aplicación.
El alcance del proyecto abarca básicamente el desarrollo de las fases de validación de los datos,
léxica y semántica, así como su integración con MAGMI. También es posible que se realicen
algunas adaptaciones y mejoras de funcionalidades en MAGMI, si bien no formará parte del
ámbito del proyecto, ya que el principal objetivo es la validación y corrección de los datos.
17
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
6 .- Especificación de Requisitos
6.1.- Requisitos Iniciales
Inicialmente, se reúne el equipo técnico de The Etailers para hacer una primera valoración y
planificar las tareas necesarias para la creación de un nuevo sistema de importación orientado a
su uso por parte de los clientes/dueños de las tiendas. El objetivo es conseguir una aplicación que
garantice que una importación siempre cumple con una serie de requisitos o validaciones de los
datos.
Situación Inicial
The Etailers dispone de dos sistemas de importación de productos. El primero consiste en un
sistema de importación de productos vía SOAP que utiliza una hoja de calculo de Google Docs
como plantilla. El segundo es Magmi, basado en la importación de productos directamente en la
base de datos mediante consultas SQL.
Los problemas actuales que tiene Magmi son una interfaz complicada para usuarios no expertos,
la falta de validación de los datos, y la difícil importación de los productos simples ↔
configurables.
¿Como mejorar Magmi?
Las mejoras obligatorias que se deben implementar en Magmi son las siguientes:
• Mejorar la interfaz para que el usuario no experto pueda importar los productos sin la
necesidad de la supervisión/ayuda de un técnico.
• Mejorar la validación de los atributos/datos.
• Mejorar la importación de los productos simples ↔ configurables.
Además de estas mejoras, se han detectado muchos errores en las importaciones que la
aplicación no puede detectar. Por ejemplo, si para un producto, se especifica el conjunto de
atributos “Ropa con talla y color”, pero el producto es sólo de un solo color, el conjunto de
atributos correcto sería “Ropa con talla”.
18
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
Este tipo de situaciones hace necesario disponer de un entorno donde el usuario pueda hacer
importaciones de prueba, para verificar que la importación es correcta, evitando de esta manera
llenar la base de datos de producción con “productos zombies”.
Inicialmente se decide implementar el siguiente sistema:
De esta manera, si el usuario intenta hacer una importación en producción sin antes haberlo
hecho en pre-producción, el programa notificará al cliente, interrumpiendo el proceso de
importación. Con este paso se trata de evitar los problemas que una máquina no puede detectar
mediante validaciones automáticas.
Este sistema requiere una infraestructura con las E-Shops duplicadas en el entorno de
pre-producción, ya que es necesario un entorno para las importaciones de los clientes, y otro
donde los técnicos puedan hacer sus desarrollos/pruebas.
Planificación del proceso
Para implementar las mejoras de Magmi, se han acordado 4 fases de desarrollo:
1. Crear importador de productos simples.
2. Crear importador de productos configurables
19
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
3. Comprobación entre Producción ↔ Pre-producción
4. Creación de Manuales y tutoriales para los clientes.
A continuación, se detallan las fases del proceso:
Crear importador de productos simples
Las tareas de esta fase serían las siguientes:
1. Mejorar interfaz → Creación de un datadump para que el usuario tenga una interfaz
simple y eficaz para importar y actualizar los productos de la tienda.
2. Validación de atributos → En el datadump, se integrará el código php necesario para
realizar la validación de todos los atributos que son obligatorios en el CSV, asi como
también se verificará que valores de los atributos seleccionables, desplegables,
multi-seleccionables, etc sean correctos.
Las validaciones acordadas han sido:
• Validación de las columnas del CSV: Contemplamos el caso en que cada tienda
tendrá un CSV ligeramente distinto debido a los diferentes atributos que tienen los
productos. Una de las primeras validaciones que se tendrán que hacer es que todas
las columnas del CSV correspondan a un atributo existente en la base de datos. En
caso de error se detendrá la importación
• Error en los campos de los atributos: En caso que el programa detecte un campo
incorrecto en el CSV (Ejemplo: IVA 12% en lugar de IVA 21%), el programa terminará
la ejecución sin importar ningún producto, e informará al cliente. Si el cliente vuelve a
hacer la importación sin corregir este error, el programa terminará en el mismo punto
sin continuar hasta que el error haya sido corregido.
• Casos atributo Talla/Color: Para evitar que los clientes introduzcan las mismas tallas
pero con nombres distintos (ej: XL ↔ xl, Rojo ↔ ROJO, etc). Se implementará un script
para importar un conjunto de valores a estos atributos, haciendo que el cliente tenga un
rango de valores para estos atributos ya predefinidos en la base de datos. Con esto se
pretende unificar las etiquetas (“labels”) de los productos. En caso de tener una tienda
con otros atributos, se prepararán los valores durante la creación de la tienda (Ejemplo:
medidas de un mueble).
• Attribute_set: Se ha acordado que la nomenclatura del conjunto de atributos será
“Producto con talla”, “Producto con talla y color”, etc. para hacer más fácil la distinción
de los conjuntos de atributos. Además, se implementará un validador que compruebe
que todos los atributos del conjunto de atributos son correctos y que no hay otros
20
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
valores. Por ejemplo un producto “Producto con talla” que también tenga el atributo
color en el CSV.
• Skus duplicadas: Se validará que las SKUs no estén duplicadas, además se ha
hablado de crear restricciones en las SKUs (Ejemplo: valores alfanuméricos, no más
de 15 caracteres, etc).
• Categorías: Si el cliente introduce una categoría que no existe, el producto no se
asignará a ninguna categoría y Magmi no creará dicha categoría. Además, el programa
terminará y mostrará un mensaje de error.
• Cada importación debe eliminar los productos que se quieren importar (sólo en el
entorno de pre-producción), ya que se contempla la posibilidad de que el cliente
cometa errores en las importaciones y desee modificar el contenido.
Crear importador de productos configurable s
Esta fase consiste en mejorar el importador de productos simples para soportar productos
configurables. Las tareas son:
1. Validación de atributos configurables:
• Comprobar simple_skus: Se comprobara que todas las SKUs que tienen asignadas
los productos configurables existen en el CSV o en la base de datos.
• Modulo de precios: El comportamiento de Magento para incrementar el precio entre
los productos simples y configurables tiene algunas complicaciones y el funcionamiento
es bastante complejo. Se ha detectado un modulo que hace que el configurable calcule
su precio basándose en los productos simples. Como no todas las tiendas tendrán
implementado este módulo, se debe crear una configuración (solo accesible para los
administradores) para verificar si el módulo existe o no (ya que la importación varía en
función de ello).
Comprobación entre Producción ↔ Preproducción
Es necesario que cuando un cliente ejecuta una importación en producción, previamente se haga
una consulta en pre-producción para verificar que los productos ya hayan sido importados.
21
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
Creación de Manuales y tutoriales para los clientes.
Para que los clientes puedan utilizar la herramienta, sera necesario elaborar un detallado manual
donde se explique claramente como utilizarla, y como generar los ficheros de importación.
Estado inicial del proceso y metodología de trabajo
Existe un script para duplicar sitios web en pre-producción, de manera que se pueden generar
copias de las tiendas de manera automática.
Se ha acordado que cada validación se realizará de manera totalmente independiente, para que
sea posible que diferentes programadores puedan trabajar en pequeñas partes del proyecto sin
bloquearse entre sí. El orden de prioridades sera el orden en el que se han expuesto previamente
las tareas a realizar.
6.2.- Evolución de los Requisitos
Una vez finalizada la primera fase del desarrollo, se comenzó a utilizar la herramienta
internamente, tanto por el equipo técnico como por el equipo de marketing. Con el uso de la
herramienta, se identifican nuevos requerimientos, y se lleva a cabo una modificación/evolución de
algunos de los ya definidos.
La ausencia de una infraestructura tecnológica que permita la sincronización diaria de las bases
de datos de pre-producción con los datos del entorno de producción, obliga a modificar el
funcionamiento del sistema. No siempre es posible realizar importaciones en pre-producción antes
de producción ya que en algunos casos tanto las categorías como los productos no coinciden, de
manera que un mismo fichero de importación podría ser válido para a tienda un el entorno de
producción pero fallaría la validación en pre-producción.
Inicialmente se propuso la estandarización o normalización de una serie de atributos/valores para
facilitar las tareas de validación, tales como:
• Los conjuntos de atributos deberán seguir el siguiente formato:
Default|Producto con (talla|color|peso|etc)((,)(talla|color|peso|etc))*
• Existe un listado de colores predefinidos y no se admiten valores nuevos por defecto.
• Existe un listado de tallas predefinidas y no se admiten valores nuevos por defecto.
22
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
Sin embargo, a la hora de ponerlos en marcha, se detecto que existían demasiados valores que
no cumplían con dichos estándares, y por falta de recursos (tiempo) se descarta su implantación
en el sistema, si bien se recomienda su utilización para usos futuros en nuevas tiendas.
Por otro lado, se definen una serie de nuevas funcionalidades a desarrollar:
• Unificación del proceso de importación/actualización: Se debe proporcionar una
interfaz que permita realizar cualquier tipo de tarea, ya sea actualización, importación, o
una combinación de ambas, para facilitar el uso de la aplicación por parte del usuario.
• Detección de codificación de los caracteres: Debido a los numerosos problemas
detectados por la codificación errónea de los ficheros de importación, muchos productos
cuyo nombre/descripción u otros atributos contenían caracteres especiales, se importaron
incorrectamente. Por ello se debe realizar una comprobación de la codificación del fichero
e intentar su conversión a UTF-8 siempre que sea necesario, mostrando un mensaje de
error en caso de que no sea posible.
• Soporte para perfiles de configuración: Las peculiaridades de cada proyecto hacen
necesario disponer de perfiles de configuración que puedan variar en función de la tienda.
• Mejora de la validación para los multi-sitios: Hay una serie de proyectos cuyos
productos se agrupan y gestionan independientemente por las marcas. Se propone
mejorar Hermes añadiendo validaciones especiales para este tipo de proyectos.
• Solucionar el problema de las sincronizaciones con ERPs/otras tiendas: Debido a
que MAGMI accede directamente a la base de datos, cualquier importación puede
provocar des-sincronizaciones de stocks, si existe algún tipo de integración, bien con ERPs
externos o con otras tiendas. Para solucionar este problema, es necesario cargar los
productos importados/actualizados desde Magento y volver a guardarlos, para que se
ejecuten los procedimientos de sincronización (si los hay).
• Cola de procesamiento asíncrona: Cada vez que se realiza una
importación/actualización, es necesario hacer una re-indexación, o bien guardar uno a uno
todos los productos nuevos/modificados. Ambos procesos son bastante costosos en
cuanto a tiempo y recursos, lo cual hace necesaria la implementación de un sistema de
procesado de tareas de manera asíncrona.
• Feedback del estado de la cola: Dado que hay muchas tiendas y los recursos del
sistema son limitados, es necesario mostrar algún tipo de feedback del estado de la cola
para cada proyecto, de manera que el cliente pueda consultarlo en cualquier momento,
para saber cuando su importación/actualización ha finalizado.
23
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
• Árbol de decisión para el Reindex/ProductSave: Algunas tiendas requieren hacer un
ProductSave, por los motivos previamente mencionados (sincronizaciones con ERPs/otras
tiendas). Sin embargo, en el resto de tiendas, el hecho de realizar un ProductSave de
todos los productos importados, o hacer un Reindex de la tienda, es algo equivalente, e
idealmente se podría realizar el que menos tiempo/recursos vaya a necesitar.
• Inicialmente se opta por guardar un registro de los tiempos de Reindex/ProdutSave
de cada tienda, de manera que en las futuras operaciones, se pueda tomar la mejor
decisión en función de los resultados anteriores.
• Más adelante se propone mejorar este sistema mediante la utilización de un
algoritmo generador de árboles de decisión.
• Mejora de la robustez de la aplicación: Con la utilización de la herramienta se detectan
numerosos casos no contemplados inicialmente, principalmente en cuanto al formato del
fichero. Se propone realizar validaciones adicionales para detectar problemas tales como
columnas repetidas, columnas sobrantes, filas sobrantes, delimitadores incorrectos, etc.
• Solución de problemas detectados: Se deben priorizar y resolver algunos problemas
detectados en algunos validadores con el uso de la aplicación.
24
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
7 .- Especificación funcional del sistema
A continuación se muestra un diagrama general de los casos de uso del sistema. Posteriormente
se dividirá en sub-secciones donde se especificará detalladamente cada caso individual, así como
los actores del sistema.
25
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
7.1.- Esquema general del sistema
Sistema
Actores
Los actores del sistema son tres, principalmente:
• E-Shop Owner: Los dueños de las tiendas son las personas encargadas de actualizar el
catálogo de las mismas, y por tanto son ellos los que más frecuentemente interactuarán
con el sistema, tanto para añadir nuevos productos, como para actualizar los existentes.
• Empleado de Marketing: El equipo de marketing se encarga de realizar actualizaciones
periódicas en las tiendas gestionadas internamente por The Etailers, ya sea para dar de
alta nuevos productos, o para actualizar los existentes por motivos de optimizaciones de
SEO, ofertas, o actualizaciones de stocks.
• Administrador: El equipo técnico de The Etailers, dispone de acceso total al sistema. Su
uso se limitará, sin embargo, a la configuración de de la aplicación para adaptarla a las
necesidades particulares de cada tienda, así como la realización de actualizaciones desde
26
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
un perfil especial que permite realizar algunas operaciones restringidas para el resto de
usuarios, como puede ser la eliminación del contenido de algunos campos, o la creación
de categorías.
Casos de Uso
Login:
Código: CS-001
Nombre: Login
Actores: Dueño de la e-Shop/Administrador/Empleado
de Marketing
Descripción: El usuario introduce sus credenciales de
acceso en el formulario para poder acceder a
la aplicación.
Pre-condición: El entorno es PRODUCCIÓN (en
pre-producción no es necesario hacer login).
Post-condición: El usuario accede a la aplicación, siempre y
cuando los credenciales sean correctos.
Importación de productos:
Código: CS-002
Nombre: Importación de productos
Actores: Dueño de la e-Shop/Administrador/Empleado
de Marketing
Descripción: El usuario selecciona el fichero de importación
y envía el formulario.
Pre-condición: El usuario ha iniciado sesión en el sistema.
Post-condición: El programa muestra un mensaje con el
resultado de la importación. Si la importación
se ha realizado correctamente, los nuevos
27
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
productos se habrán insertado en la base de
datos.
Actualización de productos:
Código: CS-003
Nombre: Actualización de productos
Actores: Dueño de la e-Shop/Administrador/Empleado
de Marketing
Descripción: El usuario selecciona el fichero de
actualización y envía el formulario.
Pre-condición: El usuario ha iniciado sesión en el sistema.
Post-condición: El programa muestra un mensaje con el
resultado de la actualización. Si la operación
se ha realizado correctamente, los productos
se actualizarán con los nuevos datos.
Importación de categorías:
Código: CS-004
Nombre: Importación de categorías
Actores: Dueño de la e-Shop/Administrador/Empleado
de Marketing
Descripción: El usuario selecciona el fichero de importación
y envía el formulario.
Pre-condición: El usuario ha iniciado sesión en el sistema.
Post-condición: El programa muestra un mensaje con el
resultado de la importación. Si la importación
se ha realizado correctamente, las nuevas
categorías se habrán insertado en la base de
datos.
28
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
Actualización de categorías:
Código: CS-005
Nombre: Actualización de categorías
Actores: Dueño de la e-Shop/Administrador/Empleado
de Marketing
Descripción: El usuario selecciona el fichero de
actualización y envía el formulario.
Pre-condición: El usuario ha iniciado sesión en el sistema.
Post-condición: El programa muestra un mensaje con el
resultado de la actualización. Si la operación
se ha realizado correctamente, las categorías
se actualizarán con los nuevos datos.
Gestión de configuración:
Código: CS-006
Nombre: Gestión de configuración
Actores: Administrador
Descripción: 1. El administrador selecciona el perfil
(importación/actualización) en el menú
desplegable.
2. El administrador realiza los cambios
necesarios en al configuración, y envía el
formulario.
Pre-condición: El administrador ha iniciado sesión en el
sistema.
Post-condición: La nueva configuración se aplicará para las
nuevas operaciones del perfil actualizado.
29
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
Importación Especial:
Código: CS-007
Nombre: Importación especial
Actores: Administrador
Descripción: 1. El administrador indica la operación especial
a realizar:
- Creación de categorías no existentes.
- Borrado de información.
2. El administrador selecciona el archivo de
importación y envía el formulario.
Pre-condición: El administrador ha iniciado sesión en el
sistema.
Post-condición: El programa muestra un mensaje con el
resultado de la operación. Si la operación se
ha realizado correctamente, los cambios se
aplicarán en la base de datos.
30
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
8 .- Diseño
Para llevar a cabo este apartado se han aplicado los conocimientos adquiridos en las asignaturas
de Ingeniería del Software I y II del Máster. Se ha llevado a cabo una arquitectura en capas, y se
han seguido los principios del diseño orientado a objetos. Asimismo, se han puesto en practica los
conocimientos teóricos sobre los patrones de diseño, principalmente con el patrón de diseño
Estrategia. Por último, se ha intentado implementar una arquitectura orientada a servicios para
permitir la utilización de la aplicación a modo de API.
La fase mas importante del desarrollo software es el diseño. Si se realiza un mal diseño, se irán
arrastrando los problemas que esto genera a todas las fases del desarrollo, con el resultado de
obtener software de mala calidad.
A continuación se muestra un diagrama del diseño de la aplicación:
8.1. - Arquitectura tres capas
La arquitectura de una aplicación es la vista conceptual de la estructura de esta. Toda aplicación
contiene código de presentación, código de procesamiento de datos y código de almacenamiento
de datos. La arquitectura de las aplicaciones difieren según como esta distribuido este código.
31
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
La programación por capas es una forma de programar bajo un objetivo principal: que las distintas
lógicas presentes en la aplicación se separen y posean estructuras bien planteadas.
En general, suele plantearse esta visión sobre tres niveles o capas:
• La capa de presentación: Esta capa se encarga de proveer una interfaz entre el sistema
y el usuario. Básicamente, se responsabiliza de que se le comunique información al
usuario por parte del sistema y viceversa, manteniendo una comunicación exclusiva con la
capa de negocio que veremos a continuación. Además dentro de esta capa entraría
aquello que el usuario “ve” cuando se conecta a la aplicación.
• La capa de negocio: Es la capa que contiene los procesos a realizar con la información
recibida desde la capa de presentación, las peticiones que el usuario ha realizado, y
responsabilizándose de que se le envíen las respuestas adecuadas a la capa de
presentación. Podríamos verla como una capa intermedia, a medio camino entre la capa
de presentación y la capa de datos, puesto que se relaciona con ambas y por supuesto,
procesa también la información devuelta por la capa de datos.
• La capa de datos: Por último, la capa donde se almacenan los datos. Mediante la capa de
negocio, se puede encargar de ofrecer, modificar, almacenar, borrar y recuperar datos,
mediante el gestor (o los gestores) de bases de datos que la aplicación requiera.
La técnica de programación en tres capas es óptima de cara a conseguir la mejor calidad
acoplamiento-cohesión.
• La cohesión es el parámetro que valora la facilidad con la que en una aplicación es posible
reunir componentes o subsistemas en un sistema software mayor.
• El acoplamiento es el parámetro responsable de evaluar las relaciones que se establecen
entre partes, componentes o subsistemas de un sistema software mayor, de tal forma que
un nivel bajo de acoplamiento permitiría la reutilización de código existente en otro
contexto, o reaprovechar funcionalidades ya definidas o modificadas, siendo negativo en
caso contrario.
Lo ideal es plantear un sistema donde se produzca un bajo acoplamiento y una alta cohesión
entre sus partes.
La aplicación se ha desarrollado siguiendo esta arquitectura, si bien la mayor parte de la
aplicación se centra en la lógica de negocio.
32
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
Existe una interfaz gráfica o capa de presentación donde el usuario puede subir sus ficheros de
datos y recibir un feedback del resultado de la operación, además de una web de configuración
para uso interno.
En cuanto a la capa de datos, Hermes sólo guarda información de las operaciones con carácter
estadístico, y es MAGMI quien se encarga de realizar las actualizaciones/inserciones en la base
de datos de Magento.
Al ser dos aplicaciones separadas, se ha seguido el principio de bajo acoplamiento para tener
claramente diferenciadas las diferentes capas.
En cuanto a la alta cohesión, se ha seguido el patrón de diseño Strategy, para conseguir una
cohesión funcional que permita fácilmente reutilizar y ampliar el software.
8.2.- Patrones de diseño utilizados
Singleton
El patrón de diseño Singleton (instancia única) está diseñado para restringir la creación de
objetos pertenecientes a una clase o el valor de un tipo a un único objeto.
Su intención consiste en garantizar que una clase sólo tenga una instancia y proporcionar un
punto de acceso global a ella.
El patrón Singleton se implementa creando en nuestra clase un método que crea una instancia del
objeto sólo si todavía no existe alguna. Para asegurar que la clase no puede ser instanciada
nuevamente se regula el alcance del constructor (con atributos como protegido o privado).
En la aplicación, se ha seguido este patrón para la conexión con la base de datos.
Strategy
El patrón Estrategia (Strategy) es un patrón de diseño para el desarrollo de software. Se clasifica
como patrón de comportamiento porque determina como se debe realizar el intercambio de
mensajes entre diferentes objetos para resolver una tarea. El patrón estrategia permite mantener
un conjunto de algoritmos de entre los cuales el objeto cliente puede elegir aquel que le conviene
e intercambiarlo dinámicamente según sus necesidades.
Cualquier programa que ofrezca un servicio o función determinada, que pueda ser realizada de
varias maneras, es candidato a utilizar el patrón estrategia. Puede haber cualquier número de
33
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
estrategias y cualquiera de ellas podrá ser intercambiada por otra en cualquier momento, incluso
en tiempo de ejecución. Si muchas clases relacionadas se diferencian únicamente por su
comportamiento, se crea una superclase que almacene el comportamiento común y que hará de
interfaz hacia las clases concretas.
Si un algoritmo utiliza información que no deberían conocer los clientes, la utilización del patrón
estrategia evita la exposición de dichas estructuras. Aplicando el patrón a una clase que defina
múltiples comportamientos mediante instrucciones condicionales, se evita emplear estas
instrucciones, moviendo el código a clases independientes donde se almacenará cada estrategia.
Se ha implementado el patrón Strategy para la validación de los datos, de manera que a cada
columna corresponde una estrategia de validación diferente, la cual varía dinámicamente según la
fase del análisis. Es decir, una misma columna puede tener dos (o N, potencialmente) estrategias
de validación, una para la fase léxica, donde se verifica el formato de los datos, y otra para la fase
semántica, donde se comprueba la concordancia de los mismo entre sí, y con la base de datos de
Magento.
34
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
9 .- Implementación
Para la implementación de las diferentes fases, se han aplicado conocimientos teóricos y prácticos
de las asignaturas Inteligencia Artificial y Compiladores.
El hecho de haber cursado la asignatura de compiladores previamente, ha resultado de gran
utilidad, dado que la herramienta de validación tiene varias similitudes a las fases iniciales de un
compilador.
La implementación se ha dividido en dos fases: Análisis léxico y análisis semántico. Por
simplicidad se ha agrupado el análisis sintáctico con el semántico.
En el análisis léxico se llevan a cabo validaciones a través de patrones o expresiones regulares,
así como varios algoritmos y tratamiento de errores.
En el análisis semántico, se llevan a cabo varias validaciones sintácticas sobre el árbol generado
previamente. También se realizan comprobaciones de tipos, concordancia de los datos y algunas
correcciones de los mismos.
Por último, gracias a la asignatura de Inteligencia Artificial, se han podido aplicar en un entorno
real los conocimientos teóricos sobre sistemas basados en el conocimiento. Se han empleado
técnicas de aprendizaje automático y han resultado funcionar de forma satisfactoria para la
generación de un árbol de decisión.
9.1.- Estructura
La estructura interna de la aplicación es la siguiente:
• Analyzer: Es donde se encuentra la lógica de negocio, donde ser analizan los datos y se
ejecutan los validadores.
• Datapump: Contiene la distintas interfaces/perfiles disponibles:
◦ Actualización
◦ Importación
◦ Actualización/Importación
• Web: Contiene el interfaz de configuración de los diferentes perfiles.
• Cli: Ofrece un interfaz para la linea de comandos, en nuestro proyecto no se utiliza
actualmente.
• Conf: Contiene los ficheros de configuración de cada proyecto/perfil.
• Engines: Contiene los manejadores o handlers de las operaciones de Magmi.
35
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
• Inc: Contiene los diferentes archivos con información compartida por la aplicación, tales
como los datos de acceso a la base de datos, clases auxiliares o helpers con funciones
útiles que permiten obtener información como el entorno o el proyecto desde cualquier
parte de la aplicación.
• Integration: Contiene ejemplos de integración de MAGMI en otras aplicaciones.
• Plugins: Contiene los diferentes plugins de MAGMI.
• Queue: Contiene la implementación de la cola de procesamiento asíncrona.
• State: Contiene las trazas con la información de las importaciones que se estén
procesando.
• Tests: Contiene toda la suite de test unitarios y de integración que han de ejecutarse y
pasar todas las validaciones antes de poder realizar una actualización del código.
• Upload: Contiene los ficheros CSV importados recientemente, así como una serie de
enlaces simbólicos cuya utilidad se explicará más adelante.
9.2.- Validación léxica
Tal y como se ha explicado previamente, se realizan validaciones de formato en la primera fase
del análisis, o fase léxica. Para la validación léxica se utilizan utiliza como base la clase
Abstract_Lexical de la cual extienden todas las validaciones.
Existen a su vez dos validadores base típicamente utilizados:
1. String: Permite validar que el todos los valores corresponden a una cadena de una
longitud determinada (máximo y mínimo).
2. Number: Permite validar que todos los valores introducidos corresponden a un número
delimitado entre un máximo y un mínimo.
Todo validador léxico debe realizar las siguientes funciones:
• Implementación del método “validate”, con una cabecera compatible a la de cualquier clase
de la que herede. En algunos casos no es necesaria la implementación de este método,
siempre que esté implementado en la clase padre.
• Generación de un array con el token o los tokens correspondientes, dependiendo de si se
trata de un campo que admite varios valores separados por comas o si admite un único
valor.
36
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
• Generación de un mensaje detallado del error, sólo en caso de que se haya encontrado
alguno.
Métodos/Algoritmos de validación
Para la validación de algunos campos, es necesario aplicar algún sencillo algoritmo que permite
garantizar la veracidad de los valores introducidos.
Por ejemplo, está el caso del campo EAN (European Article Number), que admite identificadores
numéricos de trece dígitos de longitud, cuyo último dígito debe haber sido calculado mediante la
aplicación de un sencillo algoritmo.
Por ejemplo, para el código 123456789041, el dígito de control sería:
1. Numeramos de derecha a izquierda: 140987654321
2. Suma de los números en los lugares impares: 1+0+8+6+4+2 = 21
3. Multiplicado (por 3): 21 × 3 = 63
4. Suma de los números en los lugares pares: 4+9+7+5+3+1 = 29
5. Suma total: 63 + 29 = 92
6. Decena inmediatamente superior = 100
7. Dígito de control: 100 - 92 = 8
El código EAN completo debería ser: 1234567890418.
Aplicando ese algoritmo como validación, se puede evitar la introducción de productos con un
EAN inválido, y dado que este campo a menudo se puede utilizar como identificador único, es
importante preservar la integridad de la base de datos.
Existen otros métodos de validación más sencillos, empleados para la validación de los campos
donde se dispone de un listado finito de los valores posibles.
Por ejemplo, el campo “visibility” (Visibilidad) admite los siguientes valores:
• No Visible Individualmente / 1
• Catálogo / Catalogo / 2
37
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
• Búsqueda / Búsqueda / 3
• Catálogo, Búsqueda / Catalogo, Búsqueda / 4
Para validar este campo, si el campo introducido no es un número, se hace un mapeo del texto al
valor numérico, es decir:
• 'No Visible Individualmente' => 1,
• 'Catalogo' => 2, 'Catálogo' => 2,
• 'Búsqueda' => 3, 'Búsqueda' => 3,
• 'Catalogo, Búsqueda' => 4, 'Catálogo, Búsqueda' => 4
Finalmente, se utiliza el validador numérico para comprobar que el valor está comprendido entre 1
y 4.
Expresiones regulares
Una expresión regular, a menudo llamada también patrón, es una expresión que describe un
conjunto de cadenas sin enumerar sus elementos. En informática, las expresiones regulares
proveen una manera muy flexible de buscar o reconocer cadenas de texto.
Para la validación léxica de los datos en la fase léxica, siempre que sea posible se realiza una
validación del formato mediante dichas expresiones regulares.
Por ejemplo, para la validación del campo SKU, todo valor ha de cumplir con la siguiente
expresión regular: /^[a-zA-Z0-9][a-zA-Z0-9\.\-\_]*$/
Es decir, sólo se admiten identificadores alfanuméricos, que comiencen por una letra, y se
permiten los siguientes caracteres especiales: “.”, “-”, y “_”. De esta manera se asegura que no se
insertarán identificadores que no cumplan con estos requisitos ya que el validador mostrará un
mensaje de error explicando los valores admitidos en ese campo.
También es posible utilizar la potencia de las expresiones regulares para tratar de corregir los
datos de entrada, tal y como se explica en el siguiente apartado.
38
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
Auto-corrección de datos
• Campos multivalor
En la mayoría de los campos de múltiples valores (separados por comas), a menudo se dan
problemas debido a que los valores introducidos contienen más comas y/o espacios de los
necesarios.
Por ejemplo, para la validación del campo de lo atributos configurables, normalmente suele haber
entre uno y tres valores separados por comas. Un caso típico podría ser una camiseta con los
campos valores “color” y “talla”. La forma correcta de especificar estos valores sería separándolos
mediante una coma, opcionalmente añadiendo un espacio detrás de la coma. El problema es que
a menudo se introducen valores como los siguientes:
• “color , talla”
• “color,talla,”
• “color talla”
• “ color,, talla”
Si no se analizan y se corrigen estos valores, los productos no se insertarán correctamente en la
tienda de Magento.
Para solucionar este problema, hay varias opciones posibles, en este caso se ha optado por la
utilización de la siguiente expresión regular: /[a-zA-Z0-9_-]+/.
De esta manera se reconocen todos los atributos alfanuméricos que opcionalmente contengan un
“_” o un “-”, e incluso si no se ha utilizado una coma como separador, cualquier otro carácter será
reconocido como tal, y se ignorará cualquier espacio, o carácter especial, tanto si se encuentra al
principio, como en el medio o al final de la cadena.
• Campos individuales
En los campos que admiten un único valor también es posible encontrar problemas fácilmente
corregibles.
Por ejemplo en los campos numéricos, a menudo se introducen valores decimales utilizando el
carácter “,” en lugar del “.”, que es el utilizado en PHP. En este caso basta con reemplazar las
comas por puntos para evitar posibles problemas.
39
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
Siempre que es posible, se realiza una normalización de los datos mediante la conversión de los
mismos a mayúsculas/minúsculas, en función del campo.
Por ejemplo, en el campo “Color”, por convención se convierten todos los valores a formato
oración o “ucwords”, es decir, el primer carácter en mayúsculas, y el resto en minúscula. De esta
manera se evita la inserción de valores duplicados en Magento, tales como “Rojo”, “ROJO” y
“rojo”.
En otros casos, como en el campo “type” (tipo), se convierten todos los caracteres a minúscula,
para que se inserten correctamente en la base de datos, dado que sólo son válidos los valores
“simple” y “configurable”, pero no ningún otro que contenga letras en mayúsculas.
9.3.- Validación semántica
Una vez se ha comprobado la validez de los datos en cuanto a formato, se obtiene un árbol con
todos los tokens generados, cuyos valores han sido corregidos y normalizados.
Para realizar la validación léxica, se tomará como entrada este árbol de tokens, y se irán
verificando una a una todas las columnas.
Todo validador léxico debe realizar las siguientes funciones:
• Implementación del método “validate”, con una cabecera compatible a la de cualquier clase
de la que herede. En algunos casos no es necesaria la implementación de este método,
siempre que esté implementado en la clase padre.
• Generación de un mensaje detallado del error, sólo en caso de que se haya encontrado
alguno.
En este caso no es necesaria la generación de tokens, puesto que ya se han obtenido en la fase
anterior, si bien es posible realizar modificaciones/correcciones sobre los mismos.
Existen varios tipos de comprobaciones que se realizan en esta etapa:
• Comprobaciones en la base de datos
• Detección de errores/inconsistencias
• Otras comprobaciones
40
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
La validación que se lleva a cabo es distinta para cada campo, siendo en alguna columna
necesaria únicamente la comprobación en la base de datos, o la verificación de inconsistencias en
el fichero, mientras que en otras columnas es necesario realizar ambas y/u otras comprobaciones.
Comprobaciones en la base de datos
El caso típico de una validación semántica, es la comprobación de la existencia (o no) de los
valores introducidos, mediante la comparación con la base de datos.
Existe un validador semántico genérico que permite fácilmente crear validaciones de cualquier
campo mediante herencia.
Básicamente hay que definir la consulta o “query”, el nombre del campo que se ha de validar y
opcionalmente, si los valores deberían de existir o no (por defecto siempre deberían existir).
Para evitar sobrecargar el servidor con numerosas consultas a la base de datos, lo que se hace es
generar un listado de valores únicos para ese campo, y hacer una sola consulta a la base de
datos, siempre que sea posible.
Por ejemplo, para la validación del campo tipo de impuesto o “tax_class_id”, si el fichero de datos
tuviera 100 productos, de los cuales 90 tienen tax_class_id = “IVA 21%” y 10 tienen tax_class_id =
“IVA 10%”, se haría lo siguiente:
• Dado que en este caso sólo interesa saber que los distintos tipos de IVA introducidos
existen en la base de datos, una vez realizado el filtrado correspondiente, sólo hay que
verificar la existencia de los valores: “IVA 21%” y “IVA 10%”.
• Existe una clase: “TaxClassId” que hereda del validador semántico genérico, en la cual
sólo están definidos la consulta y el nombre del campo:
class Semantic_TaxClassId extends Abstract_Semantic {
public static $QUERY = 'SELECT distinct(class_name) class_name from tax_class WHERE
class_type = "PRODUCT" AND class_name in("%s")';
protected static $FIELD = 'class_name';
}
• El método “validate” de la clase “Abstrac_Semantic”, automáticamente ejecutará la
consulta definida en “tax_class_id”, para los valores “IVA 21%” e “IVA 10%”, y comprobará
41
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
que el número de filas devueltas coincide con el número de valores proporcionado (en este
caso dos). De lo contrario generará un mensaje de error con los valores no encontrados en
el campo “class_name” del resultado de la consulta.
Este proceso es el mismo para la validación de la existencia de cualquier conjunto de valores de
cualquier campo.
En el caso de una importación de productos, la validación del campo SKU es ligeramente
diferente, ya que en este caso, lo que se pretende es que no existan los SKUs que se van a
importar en la base de datos. Sin embargo, el resto del proceso es exactamente el mismo, por lo
tanto sólo hay que indicar una variable adicional en la clase que hereda del validador genérico,
para que en lugar de validar la existencia de los SKUs, se valide que no estén presentes.
Detección de errores/inconsistencias
Para la validación de algunos campos, es necesaria la comprobación de la concordancia de los
datos de cada linea o fila. Es decir, para verificar que el valor introducido en una columna es
correcto, en algunos casos es necesario saber que valor hay en otras columnas de esa misma fila.
Por ejemplo, para comprobar el campo QTY, hay que tener en cuenta que el campo podrá estar
vacío únicamente si se trata de un producto simple (columna type = “simple”), o si la gestión de
stock está desactivada en Magento (columna manage_stock = 0).
Un ejemplo más complejo es la validación del campo de los atributos configurables, donde hay
que realizar las siguientes comprobaciones:
• Para cada producto, comprobar que los atributos configurables especificados, pertenecen
al conjunto de atributos de ese producto.
• Para cada atributo configurable, comprobar que existe una columna con el mismo nombre,
y que no está vacía para los productos con ese conjunto de atributos, a excepción del
configurable.
42
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
Otras comprobaciones
En función del campo, puede ser necesario realizar algún tipo de comprobación especial, no
contemplada en ninguno de los casos anteriores.
Por ejemplo, para la validación del campo “image”, hay que verificar varias cosas:
1. El campo sólo puede estar vacío en los siguientes casos:
• Si el módulo Simples-Configurables está instalado en Magento, y es un producto
configurable.
• Si el módulo Simples-Configurables NO está instalado en Magento,y es un producto
simple.
2. Para cada imagen hay que verificar:
• Que tenga una extensión permitida (jpg, jpeg, png)
• Si se trata de una URL, que la imagen exista (Que sea una URL válida y realmente
corresponda a una imagen alojada en un servidor, y se encuentre online en el
momento de la comprobación/importación)
Otro campo con una validación peculiar, es el “super_attribute_pricing”. Si se desea especificar
precios diferentes para los productos simples de un mismo producto configurable en función de los
valores de un atributo (por ejemplo en función de la talla), hay que especificar el precio con un
valor delta en relación al precio del producto configurable (normalmente el más barato). Para ello,
será necesario especificar este campo en MAGMI con un formato específico, para que la
importación se realice correctamente. Este campo no será necesario siempre que esté instalado el
módulo Simples-Configurables en Magento, el cual permite especificar precios diferentes sin tener
que usar el precio del configurable como base.
Sin embargo, este módulo no viene instalado en Magento por defecto, y no está instalado en la
mayoría de las tiendas, con lo cual es necesario contemplar las dos opciones.
De cara a facilitar al usuario la operación en caso de ser necesaria esta columna, Hermes la
generará automáticamente, siempre y cuando los productos tengan un sólo atributo configurable,
dado que en caso contrario, no seria posible saber cual es el atributo/s en función del cual varía el
precio.
43
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
Por ejemplo, si existiera el producto CAMISETA, con precios variables en función de la talla, el
fichero de importación debería quedar así:
name type configurable_attributes price talla
CAMISETA configurable talla 20
CAMISETA simple talla 25 L
CAMISETA simple talla 30 XL
CAMISETA simple talla 35 XXL
El precio del configurable siempre debe ser el precio inferior, y el resto de precios se calcularán
automáticamente para cada valor de talla, como incrementos respecto del producto configurable.
En este caso, el validador generará automáticamente la columna super_attribute pricing, cuyo
valor sería: talla::L:5;XL:10;XXL:15
En el caso de que el producto camiseta tuviera dos atributos configurables, el fichero de
importación sería así:
name type configurable
_attributes
price talla talla_price color color_price
CAMISETA configurable talla, color 20
CAMISETA simple talla, color 30 L 5 rojo 5
CAMISETA simple talla, color 33 L 5 azul 8
CAMISETA simple talla, color 35 XL 10 rojo 5
CAMISETA talla, color talla, color 38 XL 10 azul 8
En este caso se hace necesario especificar el precio para cada atributo con la columna “nombre
del atributo” + “_price”, para poder determinar cual es el incremento a aplicar en función del
atributo.
44
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
En este caso, el campo generado por el validador sería el siguiente:
talla::L:5;XL:10,color::rojo:5;azul;8
9.4.- Interfaces
Hay varias interfaces disponibles para utilizar Hermes, si bien el acceso a la web es la más
utilizada.
Web
Inicialmente existían dos URLs, en función de la operación a realizar: una para importar y otra
para actualizar. A petición de los usuarios se añadió una URL que permite realizar cualquier
operación, ya sea importaciones, actualizaciones, o una combinación de ambas. De esta forma,
actualmente se puede usar cualquiera de las tres:
1. datapump/index.php: Para realizar cualquier operación.
2. datapump/import_product.php: Para realizar exclusivamente importaciones.
3. datapump/update_product.php: Para realizar exclusivamente actualizaciones.
45
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
Pantalla inicial del Hermes
Para acceder a Hermes en el entorno de producción, será necesario pasar previamente por un
Login e introducir los credenciales de acceso:
Una vez introducidos los credenciales, el usuario es redirigido automáticamente a la ventana
inicial de Hermes. Esta es una pantalla típica de una importación exitosa:
46
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
En caso de detectar algún error, este es un ejemplo típico de la pantalla que se muestra al
usuario:
CURL
Existe la posibilidad de interactuar con Hermes a través de las mismas URL, pero realizando las
peticiones desde CURL, en lugar de acceder desde el navegador. Si se utiliza CURL, el formato
de salida de Hermes se adaptará en función de la variable $_SERVER['HTTP_USER_AGENT'], la
cual permite conocer el navegador utilizado por el usuario para realizar la petición.
47
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
A continuación se muestra un ejemplo de utilización de Hermes mediante peticiones CURL:
Dado que la utilización de CURL a menudo va asociada a tareas ejecutadas periódicamente, y de
manera automática, por defecto Hermes no muestra ningún mensaje si la operación se ha
realizado correctamente. En el ejemplo se ha activado el flag “debug” o modo depuración, para
que muestre información de la operación.
curl -X POST "http://dev.demo.com/hermes/datapump/index.php?debug=true" -F
stock_csv=@/home/javier/Escritorio/update.csv -F upload=1
La utilización es muy sencilla, básicamente hay que poner la URL (opcionalmente con los flags a
continuación), especificar el método POST, y enviar los campos upload = 1, y stock_csv con la
ruta del fichero a importar.
Ejemplo de mensaje de error desde CURL
48
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
Command-line
Por último existe la posibilidad de ejecutar Hermes desde el command-line, mediante php-cli. Esta
opción sólo está disponible para el equipo técnico de The Etailers y la única diferencia respecto al
interfaz de CURL es que al estar ejecutándose de manera local, no existen restricciones en cuanto
a tamaño máximo del fichero, ni problemas de tiempos de espera que podría ocasionar el servidor
web. A continuación se muestra un ejemplo de utilización del Hermes desde command-line.
Ejemplo de importación mediante php-cli
La utilización es muy sencilla:
php hermesImporter.php -- [options]
<file> Import file
<flags> Comma separated list of flags (debug, test, new_categories, etc.)
Ejemplo: php hermesImporter.php /home/javier/Escritorio/update.csv debug,test
9.5.- Profiling
Este apartado no se contemplaba en el ámbito del proyecto, pero los requisitos de rendimiento
hicieron necesario realizar investigaciones adicionales en este área, y por ello finalmente se ha
decidido añadir una mención en la memoria. A continuación se explica brevemente en que
consiste el profiling (perfilar o analizar) y cómo ha influido su utilización en la implementación de
Hermes.
En ingeniería de software el análisis de rendimiento, comúnmente llamado profiling, es la
investigación del comportamiento de un programa de computadora usando información reunida
desde el análisis dinámico del mismo. El objetivo es averiguar el tiempo dedicado a la ejecución
de diferentes partes del programa para detectar los puntos problemáticos y las áreas dónde sea
posible llevar a cabo una optimización del rendimiento (ya sea en velocidad o en consumo de
49
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
recursos). Un profiler puede proporcionar distintas salidas, como una traza de ejecución o un
resumen estadístico de los eventos observados.
Usualmente, el profiling es utilizado durante el desarrollo de software como método para la
depuración y optimización de los algoritmos. El profiling se puede llevar a cabo en el código
fuente, o sobre un archivo binario ejecutable mediante una herramienta llamada profiler.
Uno de los principales requisitos de Hermes es la eficiencia, sin embargo, durante las primeras
fases de desarrollo se detectaron problemas de rendimiento a la hora de procesar grandes
volúmenes de datos (ficheros de hasta 20 Mb). Para solucionar estos problemas se hace uso de
un profiler para PHP llamado Xdebug.
Xdebug es una extensión de PHP que proporciona capacidades de depuración y perfilado. Se
utiliza el protocolo de depuración DBGp, un sencillo protocolo creado con el propósito de ser
usado para la depuración de aplicaciones.
La información de depuración que puede proporcionar Xdebug incluye lo siguiente:
• Pila y traza de las funciones en los mensajes de error con:
◦ Visualización de parámetros completa para las funciones definidas por el usuario
◦ Nombre de la función, el nombre de archivo e indicaciones del numero de línea
• Asignación de memoria
• Protección contra bucles infinitos
Xdebug también proporciona:
• Información de perfiles de scripts PHP
• Análisis de la cobertura de código
• Capacidad para depurar sus scripts de forma interactiva con un depurador front-end.
Gracias a Xdebug se detectan y corrigen varios cuellos de botella en la aplicación, y se mejora
notablemente el rendimiento.
El problema más importante se detectó en el método array_merge_multi, el cual se encarga de
convertir un array multidimensional en uno unidimensional, iterando recursivamente para generar
un array simple que contenga todos los valores. Este método es necesario para la validación
50
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
semántica de varios campos, como “image” o “categories”, donde se pueden introducir varios
valores separados por comas.
El método hacía uso de la función nativa de PHP array_merge. Esta función, dados N arrays como
parámetros, devuelve como resultado un único array con la unión de todos ellos. Hermes hacía
uso de esta función para generar un array unidimensional a partir del array multidimensional dado.
El código funcionaba correctamente, pero con grandes volúmenes de datos ralentizaba
notablemente la ejecución debido a las comprobaciones internar realizadas por la función
array_merge antes de unir los arrays.
Finalmente se realiza el siguiente cambio en el código (se reemplaza array_merge por un bucle
que itera sobre las dimensiones del array, añadiendo todos los elementos a un array
unidimensional):
- $vals = array_merge($vals, $value);
+ $nelem = sizeOf($array[$i]);
+ for($j = 0; $j < $nelem; $j++) {
+ $vals[] = $array[$i][$j];
+ }
Este cambio no altera la semantica del programa, ya que el resultado es el mismo, sin embargo,
se consigue una mejora de un 85% en el rendimiento.
Asimismo se llevan a cabo otras micro-optimizaciones mediante la combinación de XDEBUG y las
directrices de http :// www . phpbench . com / , consiguiendo mejorar aún más el rendimiento de la
aplicación.
51
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
9.6.- Subida de Imágenes
Este apartado no formaba parte de los requisitos iniciales del proyecto, dado que inicialmente se
propuso la utilización de URLs para la subida de las imágenes. Sin embargo, a petición de los
clientes, fue necesaria la implementación de una alternativa, que es interesante mencionar a
continuación, debido a las peculiaridades de la solución, ya que los requerimientos eran una
funcionalidad global, que funcionara correctamente en todas las tiendas, incluidos los multi-sitios.
A la hora de importar o actualizar nuevos productos, es posible insertar una o varias imágenes
para cada producto. Hermes dispone de dos métodos para subir las imágenes:
1. Mediante la introducción de las URLs de las mismas, separadas por comas.
2. Mediante la introducción del nombre de los archivos, separados por comas.
Para este último, es necesario que los archivos se hayan subido previamente a un FTP
proporcionado por The Etailers.
Históricamente, la mayoría de las tiendas existentes disponen de un acceso FTP, sin embargo, no
se siguió una convención o una estructura homogénea a la hora de la creación de las cuentas y la
asignación de los directorios, de manera que cada tienda dispone de un directorio cuya ubicación
no sigue ningún patrón aplicable de forma genérica. Dado que la instalación de Hermes es
compartida para todas las tiendas, no era viable ni mantenible “hardcodear” las rutas de cada
proyecto. Finalmente se opta por la siguiente solución:
• En primer lugar, Hermes buscará un enlace simbólico/carpeta en el directorio:
hermes/upload/ con el nombre del proyecto actual. Ejemplo: Si se está importando en
www.aita.es, se busca la carpeta hermes/upload/www . aita . es .
• Si dicha carpeta no existe, se hace un fall-back, es decir, una ejecución alternativa en caso
de error, a la ruta: “raíz del proyecto”/ftp/media/, dado que las futuras tiendas utilizarán ese
directorio por defecto.
• Si dicha carpeta no existe, se intentará hacer un fall-back a la ruta que se haya introducido
en el perfil de configuración del sitio, y en caso de que esta tampoco exista, se mostrará un
mensaje de error y se realizará la importación/actualización sin las imágenes.
De esta manera, si el directorio ftp de una tienda no cumple con el estándar (“directorio raíz del
proyecto”/ftp/media), se soluciona fácilmente creando un enlace simbólico en la carpeta
52
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
hermes/upload, con el nombre del dominio de la tienda, y apuntando al directorio del FTP al que
tiene acceso el cliente.
Para evitar tener que crear números enlaces simbólicos en las tiendas multi-dominio/website, se
añadió la posibilidad de especificar esta ruta en el perfil de configuración. En algunos casos los
dueños de cada website/dominio son diferentes, de manera que es necesario un mecanismo para
poder soportar todas las posibilidades.
Multi-Sitios/Multi-Marca
Existe una peculiaridad para las tiendas multi-marca, ya que son tiendas en las cuales los
productos son gestionados por cada marca de manera independiente, y todos comparten el
mismo dominio/website.
Por motivos de seguridad, se asignan datos de acceso diferentes para cada marca, y sin embargo
Hermes no permitía especificar diferentes carpetas para un mismo dominio. Afortunadamente,
estas tiendas habían sido creadas recientemente, y las cuentas FTP seguían el siguiente patrón:
nombre_de_la_marca/
photos/: Aquí es donde cada marca debe subir las fotos.
data/: Aquí es donde cada marca puede subir cualquier otra información y/o otros documentos.
De esta manera, fue posible modificar Hermes para añadir el identificador de la marca
(básicamente es el nombre de la marca, una vez eliminados espacios, acentos, y otros caracteres
especiales) a la ruta de las imágenes, siempre que el proyecto actual fuera un multi-sitio.
53
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
9.7.- Cola de procesamiento asíncrona
Este apartado no formaba parte de los requisitos del proyecto, pero con el fin de mejorar la
experiencia del usuario y evitar la sobrecarga de los servidores, fue necesaria la implementación
de un sistema de procesamiento asíncrono para ciertas tareas demasiado costosas para ser
ejecutadas en tiempo real.
Además, ha sido una buena oportunidad para poner en práctica conocimientos y técnicas de
aprendizaje automático de Inteligencia Artificial, por ello se ha decidido incluir una mención
especial en la memoria.
Una cola (también llamada fila) es una estructura de datos, caracterizada por ser una secuencia
de elementos en la que la operación de inserción (push) se realiza por un extremo y la operación
de extracción pop por el otro. También se le llama estructura FIFO (del inglés First In First Out),
debido a que el primer elemento en entrar será también el primero en salir.
Las colas se utilizan en sistemas informáticos, transportes y operaciones de investigación (entre
otros), dónde los objetos, personas o eventos son tomados como datos que se almacenan y se
guardan mediante colas para su posterior procesamiento. Este tipo de estructura de datos
abstracta se implementa en lenguajes orientados a objetos mediante clases, en forma de listas
enlazadas.
En este proyecto, se ha utilizado una implementación open source de una cola de procesamiento
asíncrona (DJJOb), cuyo código fuente está disponible en GitHub.
DJJob permite procesar tareas de larga duración de manera asíncrona en PHP. Es una migración
del proyecto “delayed_job”, desarrollado en Shopify, y ha sido utilizada exitosamente en
producción (en SeatGeek) desde abril de 2010. DJJob utiliza una base de datos con una tabla
para las tareas, donde se guardan las tareas fallidas, pendientes y en progreso.
Se han realizado una serie de modificaciones sobre la cola, para adaptarla a las necesidades de
The Etailers:
• Se ha añadido una columna en la tabla para indicar el proyecto al que pertenece el
job/tarea.
• Se ha añadido una comprobación antes de encolar las tareas, para evitar que se
introduzcan duplicados en la cola.
• Se ha añadido una recuperación en caso de error en la conexión a la base de datos.
54
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
• Se han añadido varias notificaciones por email en caso de error en el procesamiento de
alguna tarea.
• Se ha añadido una columna a la tabla para indicar el progreso/porcentaje completado de
los trabajos.
Asimismo, se ha modificado el interfaz de Hermes para mostrar y actualizar de manera dinámica y
periódica una barra de progreso con el estado de la cola después de una operación de
importación/actualización.
Post Procesamiento
Cada vez que se realiza una importación/actualización de productos en Magento, es necesario
actualizar las tablas que contienen los índices de productos, precios, categorías, etc. De esta
manera se incrementa notablemente el rendimiento y la velocidad de carga de las páginas, ya que
estas tablas contienen la información en una estructura más rápida y accesible. El único
inconveniente es que es necesario actualizar estos índices frecuentemente. Para ello, existen dos
posibilidades:
• Re-indexar: Se trata de actualizar los índices de todas las tablas, para todos los productos
de la tienda y categorías. Este proceso se puede ejecutar de manera totalmente
"independiente" de Magento desde un script, o desde el panel de control. Básicamente
consiste en recorrer las principales tablas de Magento (catalogo de productos y
categorías), y actualizar las tablas de los índices añadiendo los datos de los nuevos
productos y actualizando los cambios de los existentes.
En un principio, el hecho de guardar únicamente los productos nuevos/modificados debería ser
mucho más rápido que hacer un reindex completo, pero al hacer un “save”, no sólo se actualizan
los índices, sino que también se llevan a cabo gran cantidad de acciones que ralentizan
considerablemente el proceso, lo cual varía en función de las características de cada tienda.
Después de llevar a cabo varias investigaciones pruebas, no fue posible llegar a una conclusión
que permitiera decantarse por ninguna de las dos opciones, ya que en función de las
características de la importación (principalmente el número de productos), y del proyecto/tienda
(número de websites, stores, categorías, productos, etc.), en algunas ocasiones es más rápido
hacer un reindex completo, y en otras es más efectivo hacer un “product save” de los productos
importados/actualizados.
55
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
Por este motivo surgió la idea de implementar un algoritmo de IA, capaz de aprender y decidir la
opción adecuada en función de cada situación.
Inicialmente se opta por una sencilla solución basada en prueba y error.
En primer lugar, de cada proyecto, se guardan estadísticas de las importaciones/actualizaciones,
concretamente la siguiente información:
• Save_Time: El tiempo medio que se tarda en hacer un product_save tras una importación.
El Save_Time es igual al tiempo total empleado desde que se comienza a guardar el
primer producto hasta que termina el último, dividido por el número de productos que se
han guardado. La unidad empleada son los segundos. Ejemplo: Si se hace una
importación de 50 productos y se tardan 100 segundos en hacer el product_save de todos
ellos, 1000 / 50 = 2 segundos / producto.
• Guardar el producto de forma independiente (Product Save): Otra posibilidad es cargar
los productos importados y hacer un save() desde el Framework Magento. Dado que al
utilizar Hermes, los cambios se han realizado directamente en la base de datos, es
necesario cargar todos los productos que han sido modificados o creados, y guardarlos
desde Magento. De esta manera, se emula la creación de productos desde el
Back-office/Admin, y al “guardar” (save) el producto, Magento detecta los cambios y
actualiza los índices necesarios sólo para ese producto en concreto. Por lo tanto, si se
hace un “save” de todos los productos importados o actualizados, no es necesario
re-indexar, ya que el “save” se encarga de actualizar los índices.
• Reindex_Time: El tiempo medio que se tarda en hacer un reindex completo de la tienda.
La unidad empleada son los segundos.
A continuación se muestra el pseudo-código del algoritmo implementado:
Evento: IMPORTACION/ACTUALIZACION COMPLETADA:
estadísticas = Obtener_estadísticas(proyecto)
if ! estadísticas then
//La primera vez que se ejecute, no habrá información
accion = random(produtSave, reindex)
else
/**
* Si el tiempo empleado de media en guardar un producto,
56
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
* multiplicado por el numero de productos importados es superior
* al tiempo medio que se tarda en hacer un reindex completo,
* entonces se hace un reindex, de lo contrario se hace un product save.
*/
if estadisticas.save_time * num_products > estadisticas.reindex_time then
accion = Reindex
else
accion = ProductSave
end if
end if
tiempo = procesar(accion)
//Una vez finalizado el proceso, se actualizan las estadísticas
//Haciendo una media con el nuevo tiempo obtenido
actualizar_estadísticas(estadísticas, accion, tiempo)
De esta manera, cada vez que se hace una importación/actualización, el programa puede decidir
la mejor opción a realizar en cada caso, actualizando a continuación las estadísticas existentes,
de manera que cuantas más operaciones se realicen, más preciso será el cálculo y más acertada
será la decisión tomada.
Esta solución fue puesta en marcha en el entorno de producción, obteniendo unos resultados
positivos, sin embargo, cada vez que se crea un nuevo proyecto, es necesario realizar varias
operaciones para que haya estadísticas que permitan realizar el cálculo. Por otro lado, sólo se
está teniendo en cuenta la variable del tiempo, lo cual limita mucho la posibilidad de escoger una
acción u otra en función de otros parámetros tales como la carga del sistema, la hora, u otras
características típicas de cada tienda. Por este motivo se decide investigar una solución más
completa empleando alguna técnica de aprendizaje automático de la rama de Inteligencia Artificial.
57
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
Aprendizaje automático
El aprendizaje automático es la rama de la Inteligencia Artificial que se dedica al estudio de los
agentes/programas que aprenden o evolucionan basados en su experiencia, para realizar una
tarea determinada cada vez mejor. El objetivo principal de todo proceso de aprendizaje es utilizar
la evidencia conocida para poder crear una hipótesis y poder dar una respuesta a nuevas
situaciones no conocidas.
En el caso de este proyecto, se busca una solución capaz de tomar la decisión acertada en
función de unos parámetros dados. El problema es que no es posible anticipar todas las posibles
situaciones que pueden producirse, y tampoco es posible anticipar futuros cambios en el entorno
del sistema, lo cual hace muy complicado tomar esa decisión sin recurrir a la IA.
El objetivo inicial es diseñar un sistema capaz de aprender y mejorar en función de las decisiones
tomadas. Sin embargo, no existe una forma cien por cien fiable de determinar si la decisión
tomada (re-indexar o guardar todos los productos) ha sido la correcta, dado que esto puede variar
en función de muchos parámetros, tales como la carga del servidor, la hora del día, el número de
productos de la tienda, etc.
Por este motivo, se opta por recopilar un elevado número de decisiones tomadas, para así
generar un árbol capaz de tomar decisiones en base a los resultados obtenidos previamente.
En un principio se intenta optar por utilizar una implementación existente del algoritmo ID3, o
C4.5/CART para PHP, dado que es el lenguaje de programación utilizado en todo el proyecto.
Se intenta integrar una implementación de ID3, pero finalmente se descarta la utilización del
algoritmo, tras comprobar que no generaliza para valores continuos, es decir, es necesario que los
valores de las consultas coincidan exactamente con los valores del árbol (Ejemplo: Si en el Árbol
generado hay valores 3, 5 y 6 para el campo nº categorías, si se hace una consulta con el valor 4
para ese campo, no funcionaría correctamente, ya que no existe ese valor en el árbol).
Finalmente se decide utilizar una implementación en Python, debido a la dificultad de encontrar
implementaciones funcionales en PHP.
58
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
Árbol de decisión CART
Para la generación del árbol, se utiliza una implementación existente del algoritmo CART en una
librería escrita en Python de código abierto llamada Scikit-learn.
El nombre Scikit-learn (originalmente Scikits.Learn) proviene de SciPy Toolkit, dado que
inicialmente comenzó como una extensión de SciPy (Scientific Library for Python), una biblioteca
de código abierto con herramientas y algoritmos matemáticos para Python. Finalmente, el código
base fue reescrito por completo y actualmente funciona de manera independiente, tras cambiar
su nombre de “Scikits.Learn” a “Scikit-learn”.
Scikit-learn es una librería de código abierto de la máquina de aprendizaje del lenguaje de
programación Python. Cuenta con varios algoritmos de clasificación, regresión y las agrupaciones
incluidas las máquinas de vectores soporte, regresión logística, naive Bayes, k-means y DBSCAN.
La integración de esta librería en la aplicación ha sido muy sencilla. Tan sólo es necesario generar
el fichero de datos en formato LIBSVM, para poder importarlos directamente y generar el árbol de
decisión.
Para generar el árbol, se han recopilado durante varias semanas una serie de datos necesarios
para generar un árbol con suficiente información para poder escoger la mejor opción en cada
situación. Se ha decidid obtener en cuenta los siguientes criterios/parámetros que se han
considerado relevantes para la toma de decisión:
• Nº de productos de la tienda: Número total de productos existentes en la tienda en la que
se realiza la importación/actualización.
• Nº de categorías: Número total de categorías existentes en la tienda en la que se realiza
la importación/actualización.
• Nº de Rewrite Urls: Número total de entradas en la tabla de “rewrites” existentes en la
tienda en la que se realiza la importación/actualización.
• Nº de atributos: Número total de atributos existentes en la tienda en la que se realiza la
importación/actualización.
• Nº de websites: Número total de websites (dominios) existentes en la tienda en la que se
realiza la importación/actualización.
59
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
• Nº de resultados de búsqueda: Número total de resultados de búsqueda en el catálogo
existentes en la tienda en la que se realiza la importación/actualización.
• Estado de carga del servidor: Estado de carga del servidor donde se realiza la
importación en el momento en el que se realiza la operación.
• Horario: Variable booleana que indica si la operación se ha realizado en horario de oficina.
• Nº de productos: Número total de productos que se han importado/actualizado en esta
operación.
• Acción realizada: Acción realizada (Product Save / Reindex)
Para generar estas estadísticas, se ha guardado también el proyecto donde se han importado, y el
tiempo que ha tardado en completarse la acción realizada, para poder posteriormente comprobar
la exactitud de la información, corrigiendo si fuera necesario la acción recomendada por el
algoritmo de decisión previamente explicado.
Tras varias semanas recopilando datos, finalmente se obtiene el siguiente árbol de decisión:
60
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
Finalmente se realiza la integración con la aplicación, sustituyendo el anterior algoritmo,
empleando el siguiente script en python:
import sys
import os
from sklearn.datasets import load_svmlight_file
from sklearn import tree
#Load Stored Dataset with all the stats
X_train, y_train = load_svmlight_file(os.path.dirname(os.path.abspath(__file__)) + "/datos.txt")
#Generate tree
clf = tree.DecisionTreeClassifier()
clf = clf.fit(X_train.toarray(), y_train)
#Predict the proper action with the given argument
#Return 1 for product save, 2 for reindex, and -1 in case of missing input data
if len(sys.argv) == 12:
print int(clf.predict([[sys.argv[1], sys.argv[2], sys.argv[3], sys.argv[4], sys.argv[5], sys.argv[6], sys.argv[7], sys.argv[8],
sys.argv[9], sys.argv[10],sys.argv[11]]])[0])
else: print -1
Tras la realización de varias pruebas, los resultados han sido positivos, no sólo al realizar
operaciones en proyectos existentes, sino también en nuevos proyectos para los cuales no se
disponía de estadísticas.
Una vez recopilados los datos necesarios, finalmente el nuevo algoritmo ha demostrado ser capaz
de predecir la acción correcta de manera eficaz, consiguiendo un importante ahorro de tiempo y
recursos en la carga del sistema.
Idealmente en un futuro se plantea la mejora de la implementación existente, de manera que se
añadan las nuevas decisiones al árbol, para permitir enriquecer y mejorar el árbol
progresivamente. Actualmente esta en proceso de prueba y se planea su utilización a nivel de
desarrollo para garantizar su correcto funcionamiento antes de ser utilizado en el entorno de
producción.
61
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
10 .- Metodología de Desarrollo
En The Etailers, se trabaja siguiendo una metodología de desarrollo ágil de software conocida
como Kanban. A continuación se explica de forma breve en que consiste el desarrollo ágil, y
concretamente Kanban, ya que ha sido la metodología empleada en el desarrollo de este
proyecto.
10.1.- Desarrollo ágil de software
El desarrollo ágil de software consiste en varios métodos de ingeniería del software basados en el
desarrollo iterativo e incremental, donde los requerimientos y soluciones evolucionan mediante la
colaboración de grupos auto organizados y multidisciplinarios. Existen muchos métodos de
desarrollo ágil, pero la mayoría se basan en intentar minimizar los riesgos desarrollando software
en periodos reducidos. Estos intervalos de tiempo, conocidos como iteración, suelen durar de una
a cuatro semanas. Cada iteración debe incluir una planificación, un análisis de requerimientos, un
diseño, una codificación, una revisión y una documentación. Al final de cada iteración el equipo
vuelve a evaluar las prioridades del proyecto.
Las metodologías ágiles enfatizan las comunicaciones cara a cara en lugar de la documentación,
y también enfatizan que el software funcional es la primera medida del progreso. Por estos
motivos, a menudo estas metodologías son criticadas y tratadas como "indisciplinadas",
principalmente por la ausencia de documentación técnica.
10.2.- Kanban
La palabra Kanban, de origen japonés, se compone de dos términos: Kan que puede traducirse
como "visual" y ban, como "insignia", siendo una traducción aproximada, "insignia visual".
Orígenes
Kanban se basa en un sistema de producción que consiste en que se inician nuevas tareas o
trabajos sólo cuando existe capacidad para procesarlos. Estas tareas se representan por tarjetas
Kanban, de las cuales se dispone de una cantidad limitada.
62
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
En The Etailers, se estableció un límite máximo de tres tareas por desarrollador, lo que significa
que en un momento dado no se pueden iniciar más tareas hasta que algún desarrollador haya
completado alguna de las que tiene asignadas.
Este proceso de producción, donde un trabajo se introduce al sistema solo cuando existe
disponibilidad para procesarlo, se denomina pull (tirar) en contrapartida al mecanismo push
(empujar), donde el trabajo se introduce en función de la demanda.
En el desarrollo de Software, Kanban fue introducido por David Anderson de la Unidad de
Negocios XIT de Microsoft, en 2004, reemplazando el sistemas de tarjetas por un tablero visual
similar al de Scrum, pero con varias características extendidas: Las tres reglas de Kanban.
Las tres reglas de Kanban
Kanban ha demostrado ser una de las metodologías adaptativas que menos resistencia al cambio
presenta para desarrolladores acostumbrados al ciclo de vida clásico para el desarrollo de
software. Dichas reglas son:
1. Mostrar el proceso
2. Limitar el trabajo en curso
3. Optimizar el flujo de trabajo
1. Mostrar el proceso
Consiste en la visualización de todo el proceso de desarrollo mediante un tablero físico,
generalmente, públicamente asequible. El objetivo de mostrar el proceso, consiste en:
• Entender mejor el proceso de trabajo actual.
• Conocer los problemas que puedan surgir y tomar decisiones.
• Mejorar la comunicación entre todos los interesados/participantes del proyecto.
• Hacer los futuros procesos más predecibles.
Un tablero Kanban, se divide en columnas las cuales representan un proceso de trabajo. Un
ejemplo clásico de columnas para dividir un tablero Kanban, sería el siguiente:
Cola de entrada | Análisis | Desarrollo | Test | Deploy | Producción
La cantidad y nombre de las columnas, varía de acuerdo a las necesidades de cada equipo y en la
mayoría de los casos, éstas, son subdivididas en dos columnas: cola de espera y en curso.
63
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
En The Etailers se utiliza una pizarra con las siguientes columnas:
Tareas Pendientes | Tareas en Progreso | Test | Deploy | Producción
El análisis de la tarea se lleva a cabo al comenzar, de manera que una tarea no pasa a estar En
Progreso hasta que el análisis ha finalizado completamente.
Del mismo modo, también se dispone de una columna “Bloqueado”, en la cual se colocan las
tareas que requieren la intervención de personal ajeno al equipo para poder continuar con la tarea,
tales como la respuesta de correo por parte de un cliente, o la aclaración de los requisitos por
parte del personal del equipo de marketing.
2. Limitar el trabajo en curs o
Los límites del trabajo en curso o WIP (Work In Progress) consisten en acordar anticipadamente,
la cantidad de tareas que pueden abordarse por cada proceso (es decir, por columnas del la
pizarra).
El principal objetivo de establecer estos límites es el de detectar cuellos de botella.
Los cuellos de botella representan el estancamiento de un proceso determinado. A continuación
se muestra un ejemplo de una pizarra de Kanban:
En el tablero se ve claramente que en la columna "pruebas" se produce un cuello de botella, ya
que el límite WIP está cubierto, mientras que el proceso siguiente (deploy), está totalmente libre.
De esta forma se determina que hay un problema a resolver en el proceso correspondiente a las
pruebas.
64
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
La resolución de cuellos de botella motiva la colaboración del equipo entre los diferentes
procesos, ya que mientras existen procesos colapsados, también hay procesos libres para aceptar
nuevas tareas.
3. Optimizar el flujo de trabajo
El objetivo ideal es conseguir la producción estable, continua y previsible. Midiendo el tiempo que
el ciclo completo de ejecución del proyecto demanda (por ejemplo, cantidad de días desde el inicio
del análisis hasta el fin del deploy), se obtiene el CycleTime.
Al dividir, el CycleTime por el WIP, se obtiene el "rendimiento de trabajo", denominado
Throughput, es decir, la cantidad de tareas que un equipo puede terminar en un determinado
período de tiempo.
Throughput = CycleTime / WIP
Con estos valores, la optimización del flujo de trabajo consistirá en la búsqueda de:
• Minimizar el CycleTime
• Maximizar el Throughput
• Lograr una variabilidad mínima entre CycleTime y Throughput
65
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
11 .- Infraestructura
En The Etailers, la infraestructura utilizada para la gestión y administración de las tiendas en los
servidores es LAMP para el entorno de producción, y LNMP para el entorno de pre-producción. La
aplicación deberá funcionar correctamente en ambos entornos, y potencialmente en cualquier
plataforma que soporte PHP y MySQL.
11.1.- LAMP
LAMP es el acrónimo usado para describir un sistema de infraestructura de Internet que usa las
siguientes herramientas:
• Linux, el sistema operativo, Cent OS en el caso de The Etailers.
• Apache, el servidor web utilizado para servir el contenido tanto estático como dinámico.
• MySQL/MariaDB, el gestor de bases de datos, MySQL en el caso de The Etailers.
• Perl, PHP, o Python, los lenguajes de programación, PHP en el caso de The Etailers.
La combinación de estas tecnologías es usada para definir la infraestructura de un servidor web,
utilizando un paradigma de programación para el desarrollo.
A pesar de que el origen de estos programas de código abierto no han sido específicamente
diseñado para trabajar entre sí, la combinación se popularizó debido a su bajo coste de
adquisición y ubicuidad de sus componentes (ya que vienen pre-instalados en la mayoría de las
distribuciones Linux). Cuando son combinados, representan un conjunto de soluciones que
soportan servidores de aplicaciones.
En The Etailers se utilizan tres servidores frontales (etailers1, etailers2 y etailers3) con LAMP, y
una base de datos MySQL central a la que todos se conectan. Se utiliza un balanceador de carga
por hardware para distribuir las distintas peticiones en función de la carga de los diferentes
servidores.
Etailers1 es el servidor utilizado preferentemente para el back-office o panel de administración de
Magento, así como para la ejecución de procesos en segundo plano, y tareas programadas
(cronjobs).
66
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
LNMP
LNMP es el acrónimo usado para describir un sistema muy similar al anterior, cuya principal
diferencia es la utilización de Nginx en lugar de Apache como servidor web.
La ventaja más importante de utilizar Nginx es la reducción del consumo de memoria y el
consecuente aumento del rendimiento. La desventaja es que no es posible utilizar el .htaccess, y
hay que adaptar cualquier regla existente al formato utilizado por Nginx.
En The Etailers se utiliza LNMP para el entorno de pre-producción, y cualquier cambio o nuevo
desarrollo se sube a pre-producción y se verifica su correcto funcionamiento antes de subirlo a
live/producción.
11.2.- Entornos
Actualmente existen tres entornos:
• Local/Desarrollo: El que tiene instalado cada desarrollador en su ordenador. No existe un
entorno homogéneo, ya que cada ordenador tiene unas características diferentes, pero
principalmente se utiliza Apache, PHP y MySQL. En algunos casos el sistema operativo es
Windows y en otros Linux.
• Pre-producción: Es la máquina donde se realizan la mayoría de las pruebas, previamente
a subir el código a producción. Se trata de una máquina con recursos muy limitados, que a
menudo está sometida a sobrecarga, dado que todas las tiendas están instaladas en el
mismo servidor, y éste es utilizado tanto por los desarrolladores como por los dueños de
las tiendas para realizar importaciones y otras pruebas.
• Producción: Es el entorno real, formado por tres servidores y un balanceador de carga
por hardware. Se utiliza LAMP por razones históricas pero está previsto migrar a LNMP en
el futuro, para mejorar el rendimiento. Actualmente también se utiliza Nginx en producción,
pero sólo para servir el contenido estático.
67
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
1 2 .- Pruebas de Software
El Software testing, o como se conoce en español, las pruebas de software, se aplican como una
etapa más del proceso de desarrollo de software. Su objetivo es asegurar que el software cumpla
con las especificaciones requeridas y eliminar los posibles defectos que este pudiera tener. En un
principio, la mayoría de empresas de desarrollo contaban con una etapa de pruebas demasiado
informal. Sin embargo, en la actualidad el software testing se ha convertido en una de las etapas
más críticas del ciclo de vida del desarrollo de software y esto ha causado el origen de diversas
metodologías.
La creación de pruebas automatizadas para aplicaciones PHP son consideradas una buena
práctica y conducen a aplicaciones sólidamente construidas. Las pruebas automatizadas son una
gran herramienta que asegura que la aplicación no va a ser afectada negativamente al hacer
cambios o al añadir nuevas características al software.
Existen diferentes tipos de herramientas para pruebas disponibles en PHP, las cuales tienen
enfoques diferentes, pero todas intentan eliminar las pruebas manuales y la necesidad de
disponer grandes equipos de Control de Calidad que se encarguen de asegurar que la aplicación
sigue funcionando correctamente cuando se introducen nuevos cambios en el código.
Una de las tareas más importantes involucradas en la gestión de una aplicación software, son las
pruebas sobre el código generado. Según el modelo de desarrollo de software empleado, estas
pruebas pueden jugar un papel más o menos central, pero siempre importante. Los dos tipos de
pruebas más empleados son los test funcionales y las pruebas unitarias. En los test funcionales se
evalúa la aplicación como un todo y se comprueba que se alcanzan unos determinados resultados
tras realizar una serie de acciones sobre la aplicación. En las pruebas unitarias, se analizan
porciones de código de manera aislada, como por ejemplo funciones y métodos, a los que
después de pasarle unos parámetros de entrada, debemos obtener otros parámetros de salida
claramente definidos.
Ambos tipos de pruebas pueden servir a muchos niveles en el ciclo evolutivo de la aplicación:
documentación, pruebas de regresión, análisis de errores o bugs, etc.
68
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
En este proyecto se han realizado test unitarios para garantizar el correcto funcionamiento de
todos los validadores. Así mismo, hay una suite de test funcionales o de integración, que
automatizan todo el proceso de validación de un fichero, asegurando la correcta integración de
todos los componentes del sistema.
Para la realización de todas las pruebas de este proyecto, se ha utilizado PHPUnit con la
extensión test-helpers, que permite realizar pruebas adicionales sobre la aplicación.
12.1.- PHPUnit
PHPUnit es un Framework PHP para realizar pruebas automáticas creado por Sebastian
Bergmann. PHPUnit nos permite realizar las pruebas pertinentes a nuestro código, verificando que
el funcionamiento de las aplicaciones PHP es el deseado y en su caso encontrando bugs y
errores, que una vez solucionados, mejoran la calidad del software desarrollado.
PHPUnit es open source, y se puede encontrar el código alojado en GitHub.
No es el único Framework de unit-testing o pruebas unitarias que existe, también se puede
mencionar "SimpleTest" o "lime" de Symfony. Sin embargo, PHPUnit es el más popular y utilizado.
12.2.- Test Unitarios
Al desarrollar un nuevo software o sistema de información, la primera etapa de pruebas a
considerar es la etapa de pruebas unitarias o también llamada pruebas de caja blanca (White
Box), estás pruebas también son llamadas pruebas modulares ya que nos permiten determinar si
un modulo del programa esta listo y correctamente terminado.
El principal factor que se debe considerar al inicio de las pruebas es el tamaño del módulo a
probar, se debe considerar si el tamaño del módulo permitirá probar adecuadamente toda su
funcionalidad de manera sencilla y rápida. También es importante separar los módulos de acuerdo
a su funcionalidad, si los módulos son muy grandes y contienen muchas funcionalidades, estos se
volverán más complejos de probar y al encontrar algún error será más difícil ubicar la
funcionalidad defectuosa y corregirla. Al realizar estas pruebas, es más fácil detectar los módulos
más complejos de la aplicación, y dividirlos en varios módulos más sencillos.
En el proyecto, se han realizado pruebas unitarias de los validadores léxicos y semánticos. El
hecho de haber utilizado el patrón de diseño Strategy a la hora de desarrollar la aplicación, ha
69
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
facilitado mucho el desarrollo de las pruebas. Cada validador está completamente aislado de
manera que es muy sencillo probar su funcionamiento individualmente, tan solo hay que llamar a
cada validador proporcionando unos datos de entrada y comprobando que los resultados son los
esperados, incluyendo la validación y la corrección de los datos.
La realización de los test de los validadores semánticos ha sido más compleja, debido a que estos
validadores realizan consultas a la base de datos. Sin embargo, mediante la utilización de Mocks,
ha sido posible emular la conexión al a base de datos, y realizar las pruebas unitarias sobre cada
validador en particular. El objetivo de estos test es garantizar el correcto funcionamiento de un
método o función en particular, de manera que otros factores externos, como la conexión con la
base de datos, salen fuera dicho ámbito.
Reflection
En informática, la reflexión (Reflection) es la capacidad de un programa de software para
examinar y modificar la estructura y el comportamiento (en concreto los valores, meta-datos,
propiedades y funciones) de un objeto en tiempo de ejecución.
La reflexión se utiliza a menudo como parte de las pruebas de software, tales como la
creación/instanciación de objetos simulados (Mocks).
PHP 5 viene con un API completa de reflexión que agrega la habilidad de hacer ingeniería inversa
de clases, interfaces, funciones y métodos así como extensiones. Adicionalmente, el API de
reflexión también ofrece formas de obtener los comentarios de los documentos para funciones,
clases y métodos.
En este proyecto se ha utilizado Reflection para poder realizar test unitarios sobre los métodos
privados y/o protegidos de los validadores complejos, los cuales están modularizados en distintos
métodos.
Mocks
En la programación orientada a objetos, se llaman objetos simulados (pseudo-objetos, Mock
object, objetos de pega) a los objetos que imitan el comportamiento de objetos reales de una
forma controlada. Se usan para probar a otros objetos en pruebas unitarias que esperan mensajes
70
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
de una clase en particular para sus métodos, al igual que los diseñadores de autos usan un crash
dummy cuando simulan un accidente.
En los test de unidad, los objetos simulados se usan para simular el comportamiento de objetos
complejos cuando es muy complicado usar al objeto real en la prueba. Los objetos simulados son
muy simples de construir y devuelven un resultado determinado y de implementación directa,
independientemente de los complejos procesos o interacciones que el objeto real pueda tener.
Los objetos simulados se usan en lugar de objetos reales que tengan algunas de estas
características:
• Devuelven resultados no determinativos (por ejemplo la hora o la temperatura)
• Su estado es difícil de crear o reproducir (por ejemplo errores de conexión)
• Es lento (por ejemplo el resultado de un cálculo intensivo o una búsqueda en una BBDD)
• El objeto todavía no existe o su comportamiento puede cambiar.
• Debería incluir atributos o métodos exclusivamente para el testeo.
12.3.- Test de Integración/Funcionales
Pruebas integrales o pruebas de integración son aquellas que se realizan en el ámbito del
desarrollo de software una vez que se han aprobado las pruebas unitarias. Únicamente se refieren
a la prueba o pruebas de todos los elementos unitarios que componen un proceso, hecha en
conjunto, de una sola vez. Consiste en realizar pruebas para verificar que un gran conjunto de
partes de software funcionan juntos.
Las pruebas de integración es la fase del prueba de software en la cual módulos individuales de
software son combinados y probados como un grupo. Son las pruebas posteriores a las pruebas
unitarias y preceden a las pruebas del sistema.
Las pruebas funcionales consisten en el uso de herramientas que automatizan el uso real de una
aplicación en vez de solo la verificación del funcionamiento de unidades individuales de código.
Estas herramientas suelen trabajar con datos reales y simulan usuarios reales en la aplicación.
71
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
En el proyecto, se han desarrollado varias numerosas pruebas de integración, que garantizan que
el proceso completo funciona correctamente, y que en caso de que se produzca algún error en la
validación, el usuario recibe el feedback adecuado en cada caso.
12.4.- Cobertura de Código
La cobertura de código es una medida (porcentual) en las pruebas de software que mide el grado
en que el código fuente de un programa ha sido testeado. Sirve para determinar la calidad del test
que se lleve a cabo y para determinar las partes críticas del código que no han sido testeadas y
las partes que ya fueron testeadas, además se puede utilizar como técnica de optimización dentro
de un compilador optimizador para llevar a cabo una eliminación de código muerto, más
específicamente sirve para detectar código inalcanzable.
La cobertura de código fue uno de los primeros métodos inventados para las pruebas de software
sistemáticas. La primera referencia fue publicada por Miller y Maloney en Communications of the
ACM en 1963.5.
Las siguientes gráficas muestran el estado actual de la cobertura de código de Hermes:
72
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
12.5.- Integración Continua
La integración continua (continuous integration en inglés) es un modelo informático propuesto
inicialmente por Martin Fowler que consiste en hacer integraciones automáticas de un proyecto lo
más a menudo posible para así poder detectar fallos cuanto antes. Entendemos por integración la
compilación y ejecución de test de todo un proyecto.
El proceso de integración continua tiene como objetivo principal comprobar que cada actualización
del código fuente no genere problemas en una aplicación que se está desarrollando. La
integración continua fue utilizada por IBM para el desarrollo del OS/360 en los años 60.
La integración continua no es una herramienta sino mas bien una práctica salida del eXtreme
Programming (XP).
Los miembros de un equipo de desarrollo integran el programa sobre el que trabajan con
frecuencia. La integración continua consiste en activar en cada integración un proceso basado en
una plataforma que verifica automáticamente el funcionamiento de la aplicación para que las
anomalías sean detectadas lo más pronto posible.
Lo más difícil para el desarrollador es conocer el impacto real de una actualización fundamental
sobre todas las funcionalidades de la aplicación. La integración continua permite al desarrollador
tener esta visión más global de la aplicación ya que las pruebas de la aplicación se hacen sobre
un entorno similar de producción.
Típicamente se trata de un proceso que, cada cierto tiempo (horas) o en función de algún evento,
descarga las fuentes desde el gestor de versiones (por ejemplo CVS, Git, Subversion, Mercurial o
Microsoft Visual SourceSafe o Team Foundation Source Control) lo compila (si es necesario),
ejecuta una serie de test y genera informes con los resultados.
Para esto se utilizan aplicaciones como Bamboo, Continuum, Hudson, Jenkins, CruiseControl o
Anthill (para proyectos Java) o CruiseControl.Net, Team Foundation Build para .Net, que se
encargan de controlar las ejecuciones, apoyadas en otras herramientas como Ant o Maven
(también para proyectos Java), o Nant o MSBUILD (para .Net) que se encargan de realizar las
compilaciones, ejecutar los test y realizar los informes.
73
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
En este proyecto se ha optado por la utilización de Jenkins/Hudson para el
mantenimiento/monitorización del código la aplicación.
En el anexo se explica detalladamente los pasos que se ha seguido para la implantación del
sistema de integración continua.
74
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
1 3 .- Funcionamiento
13.1.- Perfiles, manual de utilización, monitorización
Ver en apéndice el apartado: Manual Hermes.
75
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
14 .- Planificación
Inicialmente, se estima que la duración del proyecto sera de aproximadamente seis meses, si bien
se proponen una serie de posibles mejoras en el futuro que podrían incrementar notablemente el
tiempo de realización del proyecto.
14.1.- Planificación de tareas
En un principio se estimó que la duración del proyecto sería aproximadamente de unos 6-7
meses, variable en función de la evolución de los requisitos.
Inicialmente se realizaron las siguientes estimaciones:
• Análisis de requisitos. (2 semanas).
• Validación léxica de todos los campos conocidos: Se aplicarán restricciones de formato,
tipo de dato, longitud, caracteres permitidos, etc. (3 semanas)
• Validación semántica de todos los campos conocidos: Se verificarán los valores
introducidos, cotejándolos con la base de datos (Ejemplo: Comprobar que el producto que
se va a actualizar ya existe en la base de datos. Asegurar que la tienda o la categoría a la
que se va asociar ya existe.). (1 mes y 1 semana)
• Integración con MAGMI, de forma que se pueda unificar el proceso de importación. (1 mes)
• Proporcionar un feedback detallado de los errores que permita al usuario detectarlos y
resolverlos con facilidad. Ejemplo: No ha especificado el precio para el producto X. (1 mes)
• Creación de una batería de test unitarios y de integración que nos proporcionen una
cobertura del código superior al 85%, para mitigar los posibles errores que pudieran surgir
al hacer modificaciones debidas a cambios en los requerimientos. (1 mes)
• Implementación de nuevas funcionalidades (evolución de requisitos) y resolución de
problemas. (1 mes 2 semanas).
Tiempo total aproximado: 7 meses
76
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
En la siguiente tabla se muestra detalladamente la planificación de las tareas principales que se
han llevado a cabo a lo largo del desarrollo del proyecto.
Tarea Fecha Inicio Fecha Fin
Planificar tareas para Magmi 2.0 (Hermes) 14/11/2012 14/11/2012
Crear importador de productos simples- Mejorar
interfaz 28/11/2012 23/01/2013
Validación de atributos - Análisis léxico 28/11/2012 30/11/2012
Crear importador de productos simples 28/11/2012 12/12/2012
Crear importador de productos configurables-
Validación de atributos configurables 28/11/2012 25/01/2013
Crear importador de productos configurables 28/11/2012 23/01/2013
Creación de Manuales y tutoriales para los
clientes 28/11/2012 07/02/2013
Comprobación entre Producción ↔
Pre-producción 28/11/2012 02/07/2013
Validación de atributos - Análisis Semántico 29/11/2012 12/03/2012
Integrar Validación en Datapump Magmi 29/11/2012 29/11/2012
Migrar Magmi (Hermes) a un repositorio aparte 04/12/2012 12/04/2012
Preparar y hacer el primer deploy de Hermes 05/12/2012 12/05/2012
Deployar Hermes en producc 12/12/2012 12/12/2012
Configurar Hermes en el script de auto-deploy 12/12/2012 12/12/2012
Corregir errores encontrados al ejecutar Magmi
en pre-produccion 12/12/2012 12/01/2013
Quitar comprobación de imagen de Magmi (ya lo
hace el validador) 18/12/2012 18/12/2012
Poner htpassword en raíz de /data/www, añadir 18/12/2012 18/12/2012
77
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
varios usuarios (1 por sitio), y cambiar la ruta
del .htaccess
Definir los pasos para instalar Hermes por
primera vez en una nueva tienda 19/12/2012 23/01/2013
Adaptaciones de Hermes para Garcia de Pou 19/12/2012 20/12/2012
Añadir plugin para redimensión/validación de
tamaño en las imágenes 23/01/2013 25/01/2013
Mejoras de rendimiento en el analizador 23/01/2013 23/02/2013
Crear nuevo site DEMO en PRE para hacer
pruebas de importación con HERMES. 29/01/2013 02/05/2013
Instalar Hermes en Pre y en Pro para todas las
tiendas gestionadas por The Etailers 05/02/2013 16/05/2013
Adaptar Hermes para permitir importar/actualizar
productos desde una sola URL 13/02/2013 28/02/2013
Especificar formato, tamaño, fotos jpg en Manual
Hermes. 14/02/2013 03/06/2013
Multiperfiles por sitio en Hermes/Magmi 21/02/2013 04/03/2013
Dar todas las URL y claves de acceso de
Hermes a Marketing 21/02/2013 22/02/2013
Mejoras/Ajustes en la validación de QTY 22/02/2013 22/03/2013
Mejoras validación de categorías 22/02/2013 25/02/2013
Preparar Hermes para permitir importar etiquetas
de imágenes. 25/02/2013 02/04/2013
Corregir getMagentoPath en Magmi 28/02/2013 25/03/2013
Crear documentación para el campo
super_attribute_pricing 28/02/2013 25/03/2013
Añadir la posibilidad de añadir imágenes durante
la importación. 13/03/2013 18/04/2013
78
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
Hermes: validar formato de los campos de
fechas 18/03/2013 19/03/2013
Detectar codificación del fichero e intentar la
conversión automática a UTF-8 21/03/2013 16/04/2013
Dar acceso FTP de Pre-producción a todas las
marcas. 22/03/2013 22/03/2013
Bloquear el acceso a Magmi según la hora/día
en producción 27/03/2013 04/08/2013
Cambiar cola de Reindex por cola de SAVE 28/03/2013 04/02/2013
Implementar Plug-in para poder hacer un reset
del stock cada vez que se realiza una nueva
importación de una marca. 22/04/2013 23/04/2013
Limpieza de archivos de importación y de logs 24/04/2013 25/04/2013
Investigar como hacer las sincronizaciones entre
las tiendas al importar con Hermes. 05/03/2013 19/04/2013
Interfaz de exportación de categorías / productos 03/05/2013 10/05/2013
Arreglar problemas con el ProductSave para
versiones antiguas de Magento 22/05/2013 22/05/2013
Crear Pagina de Login para Hermes 02/06/2013 02/07/2013
Actualizar Manual Hermes 02/06/2013 02/11/2013
Añadir documentación para subir imágenes en el
Manual Hermes 02/06/2013 05/06/2013
Hermes Category Management 02/06/2013 12/06/2012
Adaptar Magmi para cargar imágenes desde
FTP 02/06/2013 16/06/2013
Revisar documentación del Manual de Hermes 16/06/2013 16/06/2013
Permitir borrar Special Price a los clientes desde
Hermes. 09/04/2013 12/04/2013
79
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
Crear perfiles MAGMI por marcas 10/01/2013 21/05/2013
Migrar documentación de Hermes a Google
Docs y crear PDF 11/03/2013 11/03/2013
Poner el script hermesImporter.php en la carpeta
de Hermes 11/03/2013 19/04/2013
A continuación se muestra el diagrama GANT con la planificación realizada para la segunda fase
del proyecto.
Desviaciones
En cuanto al desarrollo del proyecto, apenas ha habido desviaciones en la estimación, dado que la
metodología ágil Kanban ha permitido fácilmente desglosar las tareas y seguir la planificación sin
variaciones significantes.
Por otro lado, la previsión de la realización de la memoria si se ha visto modificada notablemente,
principalmente debido a la falta de tiempo para realizarla, dado que en el último mes ha habido
una sobrecarga de trabajo que no ha permitido cumplir con los plazos previstos.
Así mismo, la integración del árbol de decisión con la librería de Python era una tarea no prevista,
que se ha desarrollado fuera de los plazos previstos para el desarrollo, si bien no era un requisito
del proyecto, sino una funcionalidad extra que opcionalmente se ha decidido implementar para
aumentar la diversidad del proyecto y mejorar la calidad del software.
80
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
1 5 .- Conclusiones
El propósito de este apartado es reunir los resultados obtenidos en el marco de este proyecto de
tesis, así como proponer posibles mejoras en un futuro.
15.1.- Conclusiones finales
El objetivo inicial del proyecto era obtener una herramienta de gestión de productos de forma
masiva para Magento. Los requisitos más importantes, mas allá de los funcionales, eran la
verificación de la información, y en caso de error, evitar que añadieran productos a la web.
Durante la primera fase se consiguió una versión inicial de la aplicación con una validación básica
de los datos, y se comenzó a utilizar internamente en The Etailers. Esta versión inicial funcionaba
correctamente, si bien no contemplaba todos los casos de error, los cuales se detectaron con la
utilización de la misma en el entorno de pre-producción. Probablemente, se habrían podido
detectar una buena parte de estos errores con análisis de requisitos más extenso y en
profundidad, el cual no se realizó por falta de recursos/tiempo.
Siguiendo un proceso de desarrollo incremental, se realizó la segunda fase de implementación de
la aplicación. En esta fase ya se disponía de un conjunto de test unitarios, lo cual facilitó el
desarrollo y la resolución de los errores/bugs encontrados.
Con el uso de la aplicación en un entorno de producción real, se detectaron varios requisitos
extras por parte de los clientes y de las limitaciones de la infraestructura, que en un principio no se
habían detectado, tal y como se ha explicado en el apartado de implementación.
Como conclusiones finales, idealmente se habría realizado un análisis previo más extenso, para
mitigar los problemas que más adelante se detectaron. Por otro lado el diseño de la aplicación de
forma modularizada y aplicando patrones de diseño, ha permitido realizar desarrollos
incrementales de la misma, de manera que ha sido posible su utilización desde el principio.
Por un lado, al haber iniciado la explotación de la aplicación en la primera fase, ha sido posible
detectar requisitos muy problemas muy pronto, así como integrar la aplicación con proveedores de
stocks/productos externos, lo cual era una necesidad muy urgente para algunas de las tiendas.
81
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
Al iniciar la explotación de la aplicación antes de haber finalizado el desarrollo, surgió la necesidad
de elaborar manuales de usuario y documentación con antelación. Dado que la aplicación aún no
estaba terminada, y algunos requisitos evolucionaron, también hubo que realizar modificaciones
en la documentación y en los manuales de usuario.
Finalmente, la implantación del entorno de integración continua con Jenkins, ha ayudado mucho
en el mantenimiento de la aplicación, no sólo a la hora de detectar y resolver errores, sino también
en el desarrollo de nuevas funcionalidades, ya que con la suite de test existente, es muy fácil
detectar posibles errores o efectos secundarios derivados de dicho mantenimiento.
A nivel personal, me ha parecido un proyecto muy interesante, en el que he podido hacer uso de
muy diversas tecnologías, en las que destaco la utilización de Jenkins para el entorno de
integración continua, y el uso de técnicas de aprendizaje automático (Machine Learning) para la
predicción y generación del árbol de decisión. Considero que si bien no he podido profundizar
mucho en ambas porque quedaba fuera del ámbito del proyecto, me alegro de haber tenido la
oportunidad de aprender cómo funcionan y de utilizarlas en un entorno real, ya que creo que me
podrá ser de gran utilidad en el futuro.
A grandes rasgos, los objetivos se han cumplido satisfactoriamente y la aplicación se encuentra
actualmente en fase de explotación, siendo utilizada por más de treinta tiendas online.
15.2.- Trabajo futuro
Hermes es una herramienta en evolución constante, y nunca se debería de dar por finalizado su
desarrollo, debido a que continuamente se producen cambios en Magento, o en las tiendas que
requieren nuevas funcionalidades. A continuación se muestra una lista de características/tareas
que serían muy útiles para su integración en Hermes:
Case Insensitiveness para las imágenes: Muchos clientes tienen problemas con las imágenes a
la hora de insertar los productos, ya que a menudo introducen el nombre de las imágenes de
manera incorrecta y/o de forma que las mayúsculas/minúsculas no coinciden, y dado que Hermes
funciona en un sistema Linux, el sistema de archivos distingue entre ambas, y a menudo no
encuentra las imágenes especificadas en el CSV. Sería muy útil modificar Magmi para que sea
capaz de encontrar los archivos siempre que existan, sin importar las mayúsculas o minúsculas.
82
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
Borrar thumbnails cacheadas: Se han detectado problemas cuando el cliente importa nuevas
fotografías para productos existentes. Si el nombre de las imágenes coincide con las existentes,
las nuevas fotografías sustituirán a las antiguas (o no, en función de la configuración de Magmi),
pero las imágenes en miniatura/thumbnails se encuentran cacheadas en un directorio temporal, y
es necesario borrarlas para que se generen las miniaturas correctas. Es muy costoso a nivel de
recursos la generación de las imágenes en miniatura, de manera que sería necesario implementar
un sistema capaz de detectar si se han subido imágenes con el mismo nombre, y borrar
únicamente las thumbnails correspondientes. Debido a la aleatoriedad de Magento a la hora de
generar los nombres de los directorios de las imágenes en miniatura, esta tarea puede resultar
bastante compleja.
Problema nombres imágenes: Actualmente, no se permite especificar/subir imágenes que
contengan caracteres especiales, para evitar problemas en la generación de las URLs. Sin
embargo, sería interesante a nivel de SEO que el nombre de los ficheros fuera lo más parecido al
del producto, siempre y cuando éstos hayan sido parseados antes de la importación para generar
URLs válidas. Ejemplo:
Nombre de la imagen (antes de la importación): Traje de Baño Marrón.jpg
Nombre de la imagen (en Magento, una vez importada): traje-de-bano-marron.jpg
Limpieza de archivos de importación y de logs:
Habría que desarrollar un script o cronjob para limpiar periódicamente los directorios:
• hermes/upload/*.csv: En este directorio se almacenan los CSVs de las importaciones.
Habría que borrar los que superen cierta antigüedad, sin borrar los enlaces simbólicos
existentes en la carpeta.
Nota: Se debería modificar la ruta donde se suben estos CSV, o bien mover los enlaces
simbólicos a otra carpeta.
• hermes/state/*.txt: En este directorio se almacenan las trazas/logs de las importaciones.
• hermes/queue/nohup.out: Esta es el log de la cola de procesamiento asíncrono, el cual
convendría borrar periódicamente o cambiar la forma en que se guardan los logs para
generar nuevos ficheros cada día/semana.
• Habría que borrar las fotos de los directorios FTP de las tiendas, una vez que ya se hayan
hecho las importaciones, ya que el espacio del que se dispone es limitado.
83
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
Validación productos relacionados: Habría que crear validadores para las columnas: re_skus,
xre_skus, us_skus y cs_skus. Idealmente habría que comprobar que los SKUS introducidos
existen en el CSV o en la base de datos. También habría que tener en cuenta el orden de
importación, ya que si se especifican SKUs del CSV, estos deben importarse primero para que no
se produzcan problemas.
Añadir "disclaimer" en prod: Hay que añadir un disclaimer en producción para recordar al
cliente que realice las importaciones en pre-producción en primer lugar. Idealmente el disclaimer
pediría al usuario confirmar que ha importado previamente los productos en el entorno de pruebas
y que ha comprobado que se muestran correctamente, tanto en el frontend, como en el panel de
control.
Validar concordancia attribute_set de los productos simples y los configurables: Es
necesario comprobar que los productos simples pertenecientes a un configurable tienen el mismo
attribute_set, para evitar que se produzcan problemas en la importación.
Borrar productos al importar en PRE: Para facilitar las importaciones en pre-producción y
ayudar al cliente a solucionar posibles problemas, sería muy útil borrar los productos existentes
antes de cada importación.
84
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
1 6 .- Referencias
16.1.- Bibliografía referente a las tecnologías utilizadas:
• PHP: http://PHP.net/manual/es/index.php
• Javascript: http://www.w3schools.com/js/default.asp
• MySQL: http://dev.mysql.com/doc/refman/5.0/es/tutorial.html
• Magento: http://www.magentocommerce.com/wiki/
• Magmi: http://sourceforge.net/apps/mediawiki/magmi/index.php?title=Magmi_Wiki
• DJJob: https://github.com/seatgeek/djjob
• Jenkins: http://jenkins-php.org/
16.2.- Bibliografía general
• Apuntes de las asignaturas de Ingeniería del Software I y II, Inteligencia Artificial y
Compiladores.
• Patrones de diseño: http://hillside.net/patterns/
• http://stackoverflow.com/
• http://thedeveloperworldisyours.com/
85
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
1 7 .- Apéndice
17.1.- Jenkins
Integración Continua
Típicamente, este es el esquema de funcionamiento de un entorno de integración continua:
En un entorno ideal, se dispone de uno o varios servidores dedicados exclusivamente a la
integración continua. Cuando un desarrollador sube una nueva versión del código fuente de la
aplicación, automáticamente se inicia el proceso de verificación del mismo. Finalmente se notifica
el resultado y en caso de ser positivo, si es necesario, se despliega automáticamente el nuevo
código en el entorno de producción.
Jenkins
Jenkins es un software de Integración continua Open Source y software libre, está desarrollado en
Java, y basado en el proyecto Hudson.
Jenkins es una popular aplicación que supervisa las ejecuciones de trabajos repetidos, tales
como la construcción de un proyecto de software o trabajos ejecutados por cron. Actualmente, se
centra en las siguientes tareas:
86
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
• Construcción (build) / testing de proyectos de software de forma continua, al igual que
otras aplicaciones como CruiseControl o DamageControl. En pocas palabras, Jenkins
proporciona un sistema de integración continua fácil de usar, de manera que es muy
sencillo para los desarrolladores integrar cambios en el proyecto, y también para los
usuarios obtener una “build” actualizada. El automatizado continuo de las “builds”
aumenta la productividad. Se denomina “build” o construcción del sofware a la
aplicación de una serie de tareas requeridas antes de poder desplegar/subir o
comenzar a utilizar la aplicación. Estas tareas pueden ser las siguientes:
▪ Crear la estructura básica para el proyecto, que se requiere para la
implementación. La estructura puede variar de un proyecto a otro o
dependiendo del tipo de aplicación.
▪ Descargar la última versión de los archivos del proyecto de cualquier sistema
de control de versiones del código fuente.
▪ Copiar el conjunto requerido de archivos en los directorios deseados. Esto
puede incluir el filtrado de los archivos que no son necesarios en el
despliegue/deploy, pero que son necesarios para el desarrollo.
▪ Compilar el código fuente para generar archivos ejecutables de salida.
▪ Copiar otros archivos necesarios en las carpetas de salida (tales como
imágenes u otros ficheros que no formen parte del código fuente de la
aplicación).
▪ Generación de la documentación mediante el uso de diversas herramientas
como Java o PHP Doc.
▪ Ejecución de los casos de prueba en el código fuente compilado.
▪ Generación del paquete de salida en el formato necesario (ejemplo, un .jar).
▪ Copiar los ficheros al directorio de destino, tales como un servidor/es web.
▪ Generar el esquema de base de datos
▪ Ejecutar secuencias de comandos para introducir los datos de la muestra en la
base de datos
▪ Iniciar / reiniciar el servidor
▪ Etcétera
• Monitorizar las ejecuciones de tareas externas, tales como cronjobs, procmail jobs,
incluso algunos que se ejecuten en una máquina remota. Por ejemplo, con un cron, se
recibe un correo electrónico con la salida normal de la ejecución, y es necesario
87
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
revisarlo manualmente para ver si hay algún problema. Jenkins guarda estas salidas y
hace más fácil detectar cuando algo está mal.
En este proyecto, se ha instalado Jenkins junto con los siguientes plugins adicionales:
• Jenkins GIT plugin: Para poder integrar la conexión con el sistema de control de
versiones utilizado (GIT en Bitbucket).
• Jenkins Clover PHP: Para procesar los informes generados por PHPUnit.
• DRY: Para buscar código duplicado en la aplicación (Don’t Repeat Yourself).
• HTML Publisher: Para mostrar informes HTML, tales como los generados por PHPUnit.
• JDepend: Para analizar las dependencias del código y el acoplamiento.
• Plot: Para poder mostrar los resultados de manera gráfica.
• PMD: Para mostrar análisis avanzados del código, tales como la detección de variables
inutilizadas, objetos no usados, etc..
• Violations: Para generar un informe resumiendo todos los problemas detectados por los
plugins previamente mencionados.
• xUnit: Para obtener los resultados de los tests ejecutados por PHPUnit.
Jenkins utiliza una interfaz web, por defecto en el puerto 8080, y para automatizar la generación
de “builds”, se ha creado un script que automáticamente hace una petición al servidor cada vez
que se añade nuevo código al repositorio, de manera que se ejecuta una build automáticamente, y
en caso de detectarse algún error grave (tales como un test fallido), se envía un email de alerta.
Los pasos que se han llevado a cabo para la instalación y configuración de Jenkins a grandes
rasgos son los siguientes:
1. Instalar varias extensiones de PHP requeridas para ejecutar los tests y realizar los análisis
sobre el código de la aplicación:
◦ PHP_Unit
◦ PHP_Dox
◦ PHP_CodeSniffer
◦ PHP_MessDetector
◦ PHP_Depend
88
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
◦ PHP_CPD (Copy/Paste Detector)
2. Instalar Jenkins:
wget -q -O - http://pkg.jenkins-ci.org/debian/jenkins-ci.org.key | sudo apt-key add -
sudo sh -c 'echo deb http://pkg.jenkins-ci.org/debian binary/ > /etc/apt/sources.list.d/jenkins.list'
sudo apt-get update
sudo apt-get install jenkins
3. Instalar los plugins de Jenkins previamente mencionados
4. Configurar Jenkins
◦ Integracion con GIT: Dado que Jenkins crea un usuario virtual, es necesario que
disponga de un set de claves publicas/privadas para poder acceder al repositorio y
descargar el código fuente. Es posible utilizar claves existentes de cualquier
desarrollador con permisos de acceso al repositorio, pero por motivos de seguridad
y mantenibilidad, generaron nuevas claves en el directorio de Jenkins para su uso
exclusivo.
◦ Configuracion del Job: Inicialmente se crea un Job muy sencillo que lo único que
hace es descargar el código del repositorio y ejecutar los tests unitarios, mostrando
el resultado al terminar. Para ello se ejecuta un archivo SH que se encarga de
ejecutar los tests y finalizar la ejecución con un 1 o un 0 en función del resultado de
los tests. El proceso funciona correctamente, pero es poco mantenible así que se
posteriormente se opta por una versión basada en ANT que se explica mas
adelante.
5. Configurar la creación automática de Jobs: GIT dispone de una funcionalidad conocida
como “Hooks”, que básicamente son eventos que puede lanzar automáticamente tanto a
priori como a posteriori de una actualización de código. De esta manera se puede incluso
impedir que se suba código al repositorio si no se cumplen ciertos requisitos especificados
por el usuario. En esta proyecto se opta por la utilización de ambos hooks:
◦ Pre-Commit: Dado que la generación de una build completa lleva bastante tiempo,
no es viable hacer esperar tanto tiempo a los desarrolladores para poder subir
código al repositorio. Sin embargo, los tests unitarios apenas tardan unos segundos
en ejecutarse, de manera que es razonable ejecutarlos y comprobar que todos los
tests pasan antes de actualizar el repositorio.
◦ Post-Commit: Una vez que el código se ha subido al repositorio, si bien se han
ejecutado los tests unitarios, es necesario generar una build completa de jenkins
para asegurar que la aplicación sigue funcionando correctamente. El post-commit
hook se ejecuta en el lado del servidor, por lo tanto para lanzar una build de
Jenkins es necesario realizar una petición remota a Jenkins, y para ello es
89
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
necesario establecer una serie de mecanismos de seguridad que garanticen que el
acceso a Jenkins esta restringido a los usuarios autorizados y al servidor de GIT.
Jenkins dispone de una gestión de usuarios que permite controlar el acceso a la
interfaz web, sin embargo, para lanzar una build, no es necesario hacer login en el
sistema, sino que mediante un token/password, se pueden lanzar jobs
remotamente de manera automática. De esta forma, es muy sencilla la integración
con GIT, y para lanzar una job automáticamente, basta con generar un token para
el job, y hacer una petición HTTP al servidor de Jenkins especificando el token
como parámetro GET en la URL.
6. Notificación del resultado: Existen varios tipos de notificación disponibles, tales como IRC,
RSS, o Email.
En este proyecto se opta por enviar un email con un resumen del resultado y un enlace al informe
detallado en Jenkins a la dirección del equipo técnico de The Etailers, poniendo en copia al
usuario autor del ultimo commit (El que produjo la ejecución de la build).
ANT
Apache Ant es una herramienta usada en programación para la realización de tareas mecánicas y
repetitivas, normalmente durante la fase de compilación y construcción (build). Es, por tanto, un
software para procesos de automatización de compilación, similar a Make, pero desarrollado en
lenguaje Java así que es muy apropiado para la construcción de proyectos Java.
Esta herramienta, hecha en el lenguaje de programación Java, tiene la ventaja de no depender de
las órdenes del shell de cada sistema operativo, sino que se basa en archivos de configuración
XML y clases Java para la realización de las distintas tareas, siendo idónea como solución
multi-plataforma.
La diferencia más nota
ble entre Ant y Make es que Ant utiliza XML para describir el proceso de generación y sus
dependencias, mientras que Make utiliza formato makefile. Por defecto, el archivo XML se
denomina build.xml.
Ant es un proyecto de la Apache Software Foundation. Es software open source, y se lanza bajo la
licencia Apache Software.
90
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
Tras una serie de pruebas, se obtiene la versión final del archivo build.xml:
<?xml versión="1.0" encoding="UTF-8"?>
<project name="Hermes-Build" default="build">
<target name="build"
depends="prepare,lint,phploc,pdepend,phpmd-ci,phpcs-ci,phpcpd,phpdox,phpunit,phpcb"/>
<target name="build-parallel"
depends="prepare,lint,tools-parallel,phpunit,phpcb"/>
<target name="tools-parallel" description="Run tools in parallel">
<parallel threadCount="2">
<sequential>
<antcall target="pdepend"/>
<antcall target="phpmd-ci"/>
</sequential>
<antcall target="phpcpd"/>
<antcall target="phpcs-ci"/>
<antcall target="phploc"/>
<antcall target="phpdox"/>
</parallel>
</target>
<target name="clean" description="Cleanup build artifacts">
<delete dir="${basedir}/build/api"/>
<delete dir="${basedir}/build/code-browser"/>
<delete dir="${basedir}/build/coverage"/>
<delete dir="${basedir}/build/logs"/>
<delete dir="${basedir}/build/pdepend"/>
</target>
<target name="prepare" depends="clean" description="Prepare for build">
<mkdir dir="${basedir}/build/api"/>
<mkdir dir="${basedir}/build/code-browser"/>
<mkdir dir="${basedir}/build/coverage"/>
<mkdir dir="${basedir}/build/logs"/>
<mkdir dir="${basedir}/build/pdepend"/>
<mkdir dir="${basedir}/build/phpdox"/>
</target>
<target name="lint" description="Perform syntax check of sourcecode files">
<apply executable="php" failonerror="true">
<arg value="-l" />
<fileset dir="${basedir}/">
<include name="**/*.php" />
<modified />
</fileset>
<fileset dir="${basedir}/tests">
<include name="**/*.php" />
<modified />
</fileset>
91
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
</apply>
</target>
<target name="phploc" description="Measure project size using PHPLOC">
<exec executable="phploc">
<arg value="--log-csv" />
<arg value="${basedir}/build/logs/phploc.csv" />
<arg path="${basedir}/" />
</exec>
</target>
<target name="pdepend" description="Calculate software metrics using PHP_Depend">
<exec executable="pdepend">
<arg value="--jdepend-xml=${basedir}/build/logs/jdepend.xml" />
<arg value="--jdepend-chart=${basedir}/build/pdepend/dependencies.svg" />
<arg value="--overview-pyramid=${basedir}/build/pdepend/overview-pyramid.svg" />
<arg path="${basedir}/" />
</exec>
</target>
<target name="phpmd"
description="Perform project mess detection using PHPMD and print human readable output. Intended for usage
on the command line before committing.">
<exec executable="phpmd">
<arg path="${basedir}/" />
<arg value="text" />
<arg value="${basedir}/build/phpmd.xml" />
</exec>
</target>
<target name="phpmd-ci" description="Perform project mess detection using PHPMD creating a log file for the
continuous integration server">
<exec executable="phpmd">
<arg path="${basedir}/" />
<arg value="xml" />
<arg value="${basedir}/build/phpmd.xml" />
<arg value="--reportfile" />
<arg value="${basedir}/build/logs/pmd.xml" />
</exec>
</target>
<target name="phpcs"
description="Find coding standard violations using PHP_CodeSniffer and print human readable output. Intended
for usage on the command line before committing.">
<exec executable="phpcs">
<arg value="--standard=${basedir}/build/phpcs.xml" />
<arg path="${basedir}/" />
</exec>
</target>
<target name="phpcs-ci" description="Find coding standard violations using PHP_CodeSniffer creating a log file for the
continuous integration server">
<exec executable="phpcs" output="/dev/null">
92
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
<arg value="--report=checkstyle" />
<arg value="--report-file=${basedir}/build/logs/checkstyle.xml" />
<arg value="--standard=${basedir}/build/phpcs.xml" />
<arg path="${basedir}/" />
</exec>
</target>
<target name="phpcpd" description="Find duplicate code using PHPCPD">
<exec executable="phpcpd">
<arg value="--log-pmd" />
<arg value="${basedir}/build/logs/pmd-cpd.xml" />
<arg path="${basedir}/" />
</exec>
</target>
<target name="phpdox" description="Generate API documentation using phpDox">
<exec executable="phpdox"/>
</target>
<target name="phpunit" description="Run unit tests with PHPUnit">
<exec executable="phpunit" failonerror="true">
<arg value="--log-junit" />
<arg path="${basedir}/tests/reports/unitreport.xml" />
<arg value="--coverage-html" />
<arg path="${basedir}/tests/reports/coverage" />
<arg value="--coverage-clover" />
<arg path="${basedir}/tests/reports/coverage/coverage.xml" />
<arg value="--configuration" />
<arg path="${basedir}/tests/phpunit.xml" />
<arg value="${basedir}" />
</exec>
</target>
<target name="phpcb" description="Aggregate tool output with PHP_CodeBrowser">
<exec executable="phpcb">
<arg value="--log" />
<arg path="${basedir}/build/logs" />
<arg value="--source" />
<arg path="${basedir}/" />
<arg value="--output" />
<arg path="${basedir}/build/code-browser" />
<arg value="${basedir}" />
</exec>
</target>
</project>
En el build.xml básicamente se especifican los targets o tareas a realizar, las cuales incluso se
podrían ejecutar de forma paralela, si se dispone de los suficientes recursos. Generalmente los
targets se componen del nombre del archivo a ejecutar, y de los argumentos que se le han de
93
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
pasar, los cuales normalmente son las rutas de los archivos a analizar y la ruta donde guardar los
logs.
Una vez generada la ant-build, hay que crear el job en Jenkins configurando los plugins para que
lea correctamente los logs de los resultados generados.
Ejecución del Job de Jenkins
Se puede iniciar manualmente el Job, desde la interfaz web, o bien se puede iniciar
automáticamente en función de un evento. En cualquier caso, siempre se puede ver en tiempo
real, el estado de una ejecución en proceso, en el apartado Console.
94
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
A continuación se muestra un ejemplo de la parte final del output de una build exitosa:
A continuación se muestra la salida de una build fallida:
95
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
Una vez finalizada una build, tanto si se ha ejecutado correctamente, como si se han detectado
errores, se pueden revisar los resultados desde el interfaz web:
Pantalla principal del proyecto
96
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
Vista detallada de la cobertura del código fuente (tests):
97
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
Resultados del análisis de código duplicado:
Documentación generada a partir de los comentarios en el código fuente:
98
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
Resumen del proceso:
De manera simplificada, el proceso o flujo es el siguiente:
1. Un usuario hace un “commit” al repositorio, y se ejecutan los tests unitarios:
◦ Si todos los tests pasan, se continua con el commit.
◦ Si algún test falla, se detiene el proceso y no se produce el commit.
2. El usuario hace un PUSH del commit al repositorio.
3. Automáticamente se lanza una build en Jenkins, que se ejecutara inmediatamente,
siempre que haya recursos disponibles, o se añadirá a la cola si se ha alcanzado el
numero máximo de builds en ejecución.
4. Se envía un email con los resultados de la build
◦ Si todo es correcto, el código esta listo para deploy a producción (de manera
manual).
◦ Si existe algún error, el programador que realizo el ultimo commit es responsable
de solucionarlo cuanto antes.
99
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
17.2.- Manual de Usuario
HermesManual del usuario
versión 2013-03-14
100
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
Índice de contenidos
¿ Qué es Hermes ? ¿ Cómo funciona ? Para comenzar Funcionalidades de Hermes
ImportaciónActualizaciónAllInOne
Generación del fichero de datos Productos simples
Campos obligatorios Campos opcionales Categorías
Por el nombre ( categories ) Por identificador ( category _ ids )
Imagenes ( image ) Super Attribute Pricing ( super _ attribute _ pricing ) Precio por cantidad ( tier _ price )
Productos Configurables Diferencias entre un producto simple y un producto configurable Campos especiales de los productos configurables
Operación finalizada correctamente Resolución de problemas Modo de Prueba
101
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
Histórico de versiones
Fecha Autor Descripción
2013-02-11 Virginie Faure & Javier Carrascal Primera versión
2013-03-04 Javier Carrascal Añadida documentación sobre super_attribute_pricing
2013-03-06 Xose Pérez Uniformización
2013-03-08 Xose Pérez Añadido tier_price
2013-03-14 Javier Carrascal Añadida documentación sobre AllInOne
2013-04-02 Virginie Fauré Actualizar documentación campo imagen
102
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
¿Qué es Hermes?
Hermes es una herramienta que permite realizar de forma rápida y segura la importación yactualización de productos de una tienda.
¿Cómo funciona?
El funcionamiento básico consiste en acceder a una determinada dirección web desde donde sepodrá indicar qué archivo se desea importar. Dicho archivo contiene la información necesaria paracrear o actualizar productos en la tienda y deberá estar en un formato específico que se detalla unpoco más adelante en este documento.
Previamente a su importación se realizarán de manera automática una serie de validaciones. Si elarchivo pasa correctamente las validaciones sus contenidos serán importados. Si por el contrario lavalidación no se pasa correctamente se mostrará un mensaje descriptivo de los errores para ayudar ala corrección de los mismos.
Para comenzar
Si se dispone a utilizar Hermes por primera vez, será necesario disponer de un usuario y contraseñapara poder acceder. Si todavía no dispone de los credenciales de acceso puede solicitarlos al equipotécnico de The Etailers mediante un email a la dirección: tecnico @ theetailers . com .
Una vez disponga de sus credenciales, puede acceder a la aplicación a través de la dirección webcorrespondiente a la operación que desee realizar.
103
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
Funcionalidades de Hermes
En función de la operación que desee realizar (importación o actualización), deberá escoger unadirección web. Existen dos perfiles disponibles:
Importación
MUY IMPORTANTE : Para una importación de productos, se tiene que especificar admin en la columna store. Se podrá especificar campos al nivel de vista de tienda con una actualización más adelante.
Utilizado típicamente cuando se desean importar nuevos productos a la tienda. Dirección de acceso:
http://www.SU-TIENDA.com/hermes/datapump/import_product.php
Este perfil tiene asociadas una serie de restricciones específicas de una importación, además de lasrestricciones de formato que se detallarán más adelante):
1. El fichero de importación debe tener, como mínimo, los siguientes campos (obligatorios):name, sku, status, visibility, description, short_description, price, tax_class_id, qty, type,attribute_set, weight y categories o category_ids.
2. Los valores del campo SKU han de ser únicos, no puede haber SKU repetidas1, y no puedenexistir ya en la base de datos.
3. El valor del campo QTY no puede estar vacío2.4. Si la columna store no esta especificada, se pondrá a admin por defecto.
1 Tan sólo se permiten SKUs repetidos si se ha especificado el campo STORE, y siempre que lacombinación de ambos campos sea única. Es decir, no puede haber más de un SKU repetido sila STORE coincide. El campo STORE solo debe definirse en caso que haya más de un idioma enla web y si es necesario.2 Tan solo se permite que el campo QTY esté vacío para los productos configurables.
104
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
Actualización
Permite realizar operaciones de actualización sobre los productos existentes, tales comomodificación de stocks, precios, etc. Dirección de acceso:
http://www.SU-TIENDA.com/hermes/datapump/update_product.php
Este perfil tiene asociadas una serie de restricciones específicas de una actualización, además de lasrestricciones de formato que se detallarán más adelante):
1. El fichero de actualización debe tener, como mínimo, el campo SKU.2. Los valores del campo SKU han de ser únicos, no puede haber SKU repetidas3, y deben
corresponder a productos existentes en la base de datos.3. Si existe el campo QTY, el valor no puede estar vacío3
4. Los valores del campo categories/category_ids, si se especifican, deben corresponder acategorías existentes en la base de datos.
5. Se puede especificar la columna store.
AllInOne
Permite realizar operaciones tanto de importación como de actualización. Dirección de acceso:
http://www.SU-TIENDA.com/hermes/datapump/index.php
Este perfil se encargará automáticamente tanto de importar los productos que no existan (con las restricciones específicas de una importación, como de actualizar los existentes (ver restricciones en el perfil actualización).
Generación del fichero de datos
Para generar un fichero de datos válido, basta con seguir los ejemplos que hay disponibles en la web de cada perfil. El archivo de importación de productos ha de ser un archivo en formato CSV utilizando un punto y coma (;) como carácter de separación y ha de disponer de varias columnas correspondientes a los datos del producto. A continuación se detalla cada campo, con ejemplos de su utilización4.
3 Se aplican las mismas restricciones que en el caso de la importación.4 En las diferentes funcionalidades disponemos de un CSV de ejemplo donde podrá ver la estructura básica de los ficheros. En cualquier caso, si se detecta algún otro problema en el fichero, Hermes mostrará un mensaje de error que le ayudará a solucionarlo. Si necesita ayuda adicional, puede enviar un e-mail a tecnico @ theetailers . com y le atenderemos con la mayor brevedad posible.
105
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
Productos simples
Campos obligatorios
Nombre Título Descripción
attribute_set Conjunto de atributos Especifica el conjunto de atributos de ese producto. Los valores típicosson: “Default”, “Producto con talla”, “Producto con color”, “Productocon talla y color”, etc.
Ha de ser un valor existente en la base de datos, de lo contrario Hermesmostrará un error. Si no dispone de un listado de los posibles conjuntosde atributos disponibles, envíe un email atecnico @ theetailers . com para obtener ayuda con este campo.
type Tipo Indica el tipo del producto, puede tomar los siguientes valores:“simple” o “configurable”. Cualquier otro tipo no está permitido.
visibility Visibilidad Indica la visibilidad del producto. Acepta los siguientes valores (tantonuméricos como texto): “Not Visible Individually” (1), “Catálogo” (2),“Búsqueda” (3)” o “Catálogo, Búsqueda” (4). Cualquier otro valor seráconsiderado como inválido.
name Nombre Nombre del producto, limitado a un máximo de 400 caracteres.
sku SKU Identificador único del producto. Sólo están permitidos caracteresalfanuméricos además de los caracteres especiales: “.”, “_” y “-”.
status Estado Indica el estado del producto. Sólo admite los siguientes valores:“Habilitado” (1) o “Deshabilitado” (2).
weight Peso Indica el peso del producto en kilogramos. Sólo admite valoresnuméricos (decimales y positivos).
price Precio Indica el precio del producto con IVA. Sólo admite valores numéricos(decimales y positivos).
tax_class_id Impuestos Indica la tasa aplicable al producto. Los valores más comunes son:“IVA 21%”, “IVA 8%”... Ha de ser un valor existente en la base de datos, de lo contrario Hermesmostrará un error. Al igual que en los conjuntos de atributos, si nodispone de un listado con los posibles impuestos, envíe un email atecnico @ theetailers . com para recibir soporte de nuestro equipotécnico.
qty Cantidad Número de unidades disponibles del producto. Sólo admite valoresnuméricos (enteros mayores o iguales a cero).
categoriescategory_ids
Categorías Ver explicación al final de este apartado
106
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
Campos opcionales
Nombre Título Descripción
ean EAN Permite indicar el código EAN del producto. El valor introducidoha de ser un código EAN válido , de lo contrario Hermesmostrará un error.
image Imágenes Ver explicación al final de este apartado
store Tienda Por defecto, se importan los productos en la tienda de admin(vista de tienda por defecto). Más adelante, se puede espeficaresta columna para actualizar campos al nivel de vista de tienda.Basta con introducir el nombre de la tienda donde desea importarel producto. El nombre introducido debe corresponder con unatienda existente en la base de datos, de lo contrario Hermesmostrará un mensaje de error.
description Descripción Puede especificar las descripciones del producto en estoscampos.
short_description Descripción corta Puede especificar las descripciones del producto en estoscampos.
marca / brand Marca Permite especificar la marca del producto.
color Color Permite especificar el color del producto.
talla Talla Permite especificar la talla del producto.
re_skus Productosrelacionados
Indica que el producto actual está relacionado con los skusintroducidos en dicho campo, pero no al revés. Es decir, en laficha de este producto pueden aparecer como relacionados losproductos introducidos en este campo, pero en la ficha de esosproductos, no aparecerá ninguna relación con el producto actual.Esta relación aparece en la parte lateral de la ficha de productos.
xre_skus Productosrelacionadosmutuamente
Indica que el producto actual está relacionado con los skusintroducidos en dicho campo, y también al revés. Es decir, en laficha de este producto pueden aparecer como relacionados losproductos introducidos en este campo, y en la ficha de esosproductos, puede aparecer como relacionado el producto actual.Esta relación aparece en la parte lateral de la ficha de productos.
us_skus Ventas sugeridas Esta relación aparece en la parte inferior de la ficha de productos.
cs_skus Ventas cruzadas Esta relación aparece en la parte inferior del checkout.
tier_price Precio por cantidad Permite definir descuentos por volumen de pedido de un artículo.Ver explicación al final de este apartado.
super_attribute_pricing Precio por variante Permite especificar precios diferentes para diferentes variacionesdel mismo producto (precios por producto simple). Verexplicación al final de este apartado.
107
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
Los SKUs introducidos deben corresponder a productos existentes, ya sea en la base de datos, o en el propio MS Excel, sino Hermes mostrará un error.
Un ejemplo de como quedan los productos relacionados en la tienda:
Otro ejemplo de ventas sugeridas:
108
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
Y por último un ejemplo de ventas cruzadas:
Categorías
Las categorías se pueden especificar de dos maneras distintas:
Por el nombre (categories)
Para especificar a qué categoría pertenece un producto, basta con poner el nombre de la misma, tal y como aparece en la el backoffice. Si no tiene acceso al backoffice, el equipo de The Etailers le enviará un listado delas posibles categorías.Los nombres de las categorías introducidos deben existir en la base de datos, de lo contrario Hermes mostrará un mensaje de error.Si desea asignar el producto a una subcategoría, puede utilizar el separador “/”. Por ejemplo, para asignar el producto a la subcategoría “Camisas” de la categoría “Hombres”:
Hombres/Camisas
Si desea asignar el producto a varias categorías/subcategorías, utilice el separador “;;”. Por ejemplo:
Hombres;;Hombres/Camisas;;Marcas/Mimarca
En este último ejemplo el producto se asignaría a:1. La categoría Hombres2. La sub-categoría Camisas dentro de la categoría Hombres.3. La sub-categoría Mimarca dentro de la categoría Marcas.
109
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
Por identificador (category_ids)
Para especificar a que categoría/s pertenece el producto, basta con indicar el ID de la/s categoría/s separados por comas.El ID de las categorías introducidas debe existir en la base de datos, de lo contrario Hermes mostrará un mensaje de error. Por ejemplo, para asignar el producto a las categorías 4, 2 y 5 basta indicar:
4,2,5
Imagenes (image)
El campo “image” permite especificar la imagen o imágenes del producto. Para especificar una imagen basta con introducir el nombre del fichero (subido al FTP), o una URL pública.
Importante : 1- No se permite accentos, ñ, caracteres raros o espacios en los nombres de las imagenes. Solo caracteres alfanumericos (a->z, 0->9), guillon bajo (_) y guillon medio (-). 2- Por favor, compruebe que los nombres de las imagenes en el FTP corresponden EXACTAMENTE al nombre del las imagenes en el CSV, y sobre todo que coinciden los mayusculas/minusculas.3- Las imagenes deben tener la extension especifica. Una imagen sín extension valída será rechazada.
Por ejemplo:
imagen.jpghttps://www.google.es/logo1.png, https://www.google.es/images/logo2.png
Si desea especificar varias imágenes, basta con poner las URLs o los nombres de las imágenesseparadas por comas.
imagen1.jpg, imagen2.jpg, imagen3.pnghttps :// www . google . es / logo 1. png , https :// www . google . es / images / logo 2. png
Las imagenes o URL's introducidas deben ser públicas (accesibles) y tener una extensión válida(GIF / JPG / PNG), de lo contrario Hermes mostrará un mensaje de error. Además, asegúrese de quelos nombres especificados coinciden exactamente con los de los ficheros subidos al FTP, ya quenuestro servidor distingue mayúsculas / minúsculas.
La primera imagen especificada se asignará automáticamente como la principal del producto.
Para excluir o añadir imágenes a une galería existente, se tiene que especificar la columnamedia_gallery.
Esta columna permite valores “relativos”, poniendo - o + delante de los nombres de ficheros.
Por ejemplo:
110
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
-img1.png,+img2.png,-img3.png
En este caso, se excluirán las img1.png y img3.png de la galería, mientras se añadirá la imagen img2.png.No se permite especificar valores relativos en el campo “image”.
Para importar etiquetas de imágenes, se puede especificar la columna "image_label", si no existe se pondrá el nombre del producto por defecto.
Super Attribute Pricing (super_attribute_pricing)
Si dispone de un grupo de productos simples pertenecientes al mismo configurable, cuyos precios varían en función de uno o varios atributos, es necesario especificar la relación atributo-precio. Por ejemplo, si tuviéramos el producto CAMISETA, con precios variables en función de la talla, nuestro fichero de importación debería quedar así:
name type configurable_attributes
price talla talla_price
CAMISETA configurable talla 20
CAMISETA simple talla 25 L 5
CAMISETA simple talla 30 XL 10
CAMISETA simple talla 35 XXL 15
El precio del configurable siempre debe ser el precio inferior, y el resto de precios se calculan sumando el precio del configurable con el incremento en función del valor del atributo.Si el producto introducido sólo tiene un atributo configurable (como en el ejemplo anterior: talla), lacolumna talla_price no es necesaria, ya que Hermes calculará automáticamente el incremento del precio en función de ese atributo.Sin embargo, si tuviéramos un producto con precios variables en función de dos (o más) atributos, nuestro fichero de importación debería ser así:
name type configurable_attributes
price talla talla_price color color_price
CAMISETA configurable talla, color 20
CAMISETA simple talla, color 30 L 5 rojo 5
CAMISETA simple talla, color 33 L 5 azul 8
CAMISETA simple talla, color 35 XL 10 rojo 5
CAMISETA talla, color talla, color 38 XL 10 azul 8
El proceso consiste en añadir una columna con el nombre (“atributo” + “_price”) por cada atributo cuyo precio varíe en función del valor.Para comprobar la validez de los datos, la suma de los precios de los atributos, más el precio del configurable, debe ser igual al precio del simple.
111
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
Nota: Para realizar una actualización de precios sobre alguno de estos productos, no es suficientecon especificar el SKU y el nuevo precio. También será necesario especificar las columnas: type, configurable_attributes y el atributo o atributos en función de los cuales varía el precio, ya que son necesarios para calcular correctamente el incremento del precio de los simples respecto del preciodel producto configurable.
Precio por cantidad (tier_price)
El “tier price” permite especificar el precio de un producto en función del volumen de compra. Además se puede hacer especificando el grupo de usuarios que tendrán acceso a estos descuentos. En realidad no es un único campo sino que se pueden definir tantos como grupos de usuarios haya en la web además de uno para todos los grupos. Así “tier_price:_all_” será el campo que contendrá las definiciones de precios por cantidad aplicables a todos los usuarios de latienda mientras que “tier_price:vip” será aplicable únicamente a los usuarios pertenecientes al grupo “vip”.Los valores de los campos es una concatenación de cantidades mínimas y precios como sigue:
sku price tier_price:_all_ tier_price:vip
SKU001 11.95 50:10.95,100:10.45 50:10.95, 100:9.95
SKU002 22.95 50:21.95,100:19.95
Para borrar la configuración del precio por cantidad basta con dejar la columna vacía (como en el segundo producto del ejemplo anterior).
Productos Configurables
Diferencias entre un producto simple y un producto configurable
Los productos simples son los productos sin ninguna característica especial, es decir, el usuario final no puede seleccionar ningún atributo y debe comprar el producto tal y como se muestra en la web. Estos productos gestionan stock a nivel de tienda, tienen fotografías propias y son la base delos productos en Magento. Un ejemplo de un producto simple puede ser una silla.Los productos configurables son productos donde se puede seleccionar un atributo a la hora de comprarlo. Un ejemplo muy intuitivo podría ser una camiseta. En la web solo mostramos una camiseta pero el usuario debe elegir la talla de dicha camiseta.En Magento, un producto configurable está creado a partir de diferentes productos simples. El producto configurable es el que se muestra en la web y, la información de las tallas y la gestión de stock, está guardadaen los productos simples. A continuación mostraremos un ejemplo gráfico de como está creado un producto configurable:
112
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
En la imagen, podemos ver como son los productos simples los que contienen la información de las tallas y la gestión de stock pero es el producto configurable el que se muestra en la tienda. En la web, el resultado sería el siguiente:
En esta imagen podemos ver un producto configurable (una zapatilla) y un desplegable donde podemos elegir la talla. Este seleccionable coje la información de los productos simples asociados al configurable.
113
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
Campos especiales de los productos configurables
Nombre Título Descripción
simples_skus Simple skus Si existen productos configurables en la importación, debeespecificar su relación con los productos simples a través deeste campo. Para indicar que un producto simple pertenece alproducto configurable, basta con introducir el SKU delproducto simple en el este campo. Para indicar que variosproductos simples pertenecen a un mismo configurable, sólohay que especificar los SKUs de los productos simplesseparados por comas en el campo simple_skus del productoconfigurable.
configurable_attributes AtributosConfigurables
Permite indicar los atributos configurables del producto. Losvalores más comunes son: color, talla, etc. Puede especificarvarios atributos separándolos por comas. Ejemplo: talla, color.Han de ser atributos existentes en la base de datos, ypertenecientes al Conjunto de Atributos (attribute_set)especificado, de lo contrario, Hermes mostrará un error.
Nota: Todos los atributos especificados en este campo, seconvertirán automáticamente en atributos obligatorios para losproductos simples pertenecientes al configurable.
Un ejemplo de configuración de productos simples:
Y otros de atributos configurables:
En el ejemplo, el color es obligatorio, y si alguno de los productos simples no tuviera un color asignado, Hermes mostraría un error.
Operación finalizada correctamente
Una vez finalizada una importación o actualización, Hermes mostrará un mensaje de confirmaciónsimilar al que se muestra a continuación:
114
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
Esto significa que la operación se ha realizado correctamente.
Nota: Es posible que los cambios no surtan efecto de manera inmediata, ya que se debe realizar unareindexación después de cada importación. Esta reindexación se realizará de manera automáticapero puede llevar cierto tiempo.
115
Proyecto Final de Máster - Desarrollo de una Herramienta de Validación/Importación para Magento
Resolución de problemas
Cuando se detecta un error al realizar la importación, Hermes mostrará un mensaje de error,indicando el número de línea o la columna:
En el ejemplo se muestra un error debido a que el precio del producto de la línea nº 6 no puede estaren blanco. Para solucionarlo, basta con corregir el fichero (introduciendo un precio para elproducto) y reintentar la importación.
Modo de Prueba
Es posible la utilización de un modo TEST, que le permitirá comprobar la validez de su fichero CSV antes de hacer la importación. Para activar el modo de prueba, basta con añadir el flag “test=true” en la dirección web:
http :// www . SU - TIENDA . com / hermes / datapump / update _ product . php ? test = true http :// www . SU - TIENDA . com / hermes / datapump / import _ product . php ? test = true
http :// www . SU - TIENDA . com / hermes / datapump / index . php ? test = true
De esta manera, cuando envíe su fichero de datos, Hermes lo analizará como si se tratase de unaimportación real, pero en ningún momento realizará cambios en la base de datos. Esto le permitirárealizar tantas pruebas y correcciones sobre el fichero como considere necesarias antes de realizar laimportación/actualización final.
116