Cómo modificar módulos de PrestaShop sin romper actualizaciones

Por /

La forma más limpia de modificar un módulo de PrestaShop sin que las actualizaciones te borren los cambios es separar tu código del original usando overrides de plantillas, hooks o módulos propios. Los overrides de clases siguen funcionando pero generan más problemas a largo plazo.

Overrides de plantillas en el tema

Esta es la vía más segura y recomendada cuando solo necesitas cambiar el aspecto. PrestaShop permite sobrescribir las plantillas .tpl (o archivos .twig desde la versión 1.7) copiándolos a tu tema.

La estructura es sencilla: copia el archivo del módulo manteniendo la ruta relativa dentro de la carpeta themes/tu_tema/modules/nombre_modulo/. Por ejemplo, para sobrescribir el archivo de pago de un módulo:

themes/tu_tema/modules/ps_wirepayment/views/templates/hook/payment_return.tpl

PrestaShop buscará primero en tu tema y solo usará el del módulo si no lo encuentra. Al actualizar el módulo, tu plantilla se mantiene intacta. Eso sí, revisa los cambios en cada versión del módulo por si han añadido nuevas variables o bloques.

Overrides de clases: cómo funcionan y por qué evitarlos

Los overrides de clases permiten reescribir métodos completos de controladores, modelos o módulos. Se colocan en override/classes/ o override/modules/.

Ejemplo clásico de override de un módulo de pago:

<?php
class Ps_WirePayment extends Ps_WirePaymentCore {
    public function validateOrder($id_cart, $id_order_state, $amount_paid, $payment_method = 'Wire payment', $message = null, $extra_vars = array(), $currency_special = null, $dont_touch_amount = false, $secure_key = false, $order_reference = null)
    {
        // Tu lógica personalizada antes o después de llamar al padre
        parent::validateOrder($id_cart, $id_order_state, $amount_paid, $payment_method, $message, $extra_vars, $currency_special, $dont_touch_amount, $secure_key, $order_reference);
        // Código adicional
    }
}

Funciona, pero tiene varios problemas graves. Primero, si dos módulos sobrescriben la misma clase, solo uno gana. Segundo, cualquier cambio en la clase original (nuevo parámetro, cambio de visibilidad, refactor) puede romper tu override sin aviso. Tercero, dificulta la depuración porque el flujo se vuelve impredecible.

Por todo esto, los overrides de clases deben ser el último recurso. Úsalos solo cuando no exista hook disponible y el cambio sea imposible de otra forma.

Usar hooks: la forma correcta de extender funcionalidad

Los hooks son el mecanismo diseñado por PrestaShop para que los módulos (y temas) extiendan el comportamiento sin tocar el código original. Casi todos los módulos modernos los implementan.

Para engancharte a un hook existente solo tienes que crear un método en tu módulo o en tu archivo functions.php del tema:

public function hookActionValidateOrder($params)
{
    $order = $params['order'];
    // Tu lógica aquí
    if ($order->module == 'ps_wirepayment') {
        // Hacer algo específico tras validar el pedido
    }
}

Si el módulo que quieres modificar no tiene el hook que necesitas, puedes añadirlo tú mismo en un override temporal (solo del método que dispara el hook) o, mejor aún, crear tu propio módulo que escuche los hooks disponibles.

Crear un módulo propio: la solución más profesional

La mejor práctica actual es desarrollar un módulo específico para tu tienda que dependa del módulo original y añada o modifique su comportamiento. De esta forma mantienes todo el código bajo control y en un solo sitio.

Estructura básica de un módulo de extensión:

class MiExtensionPayment extends Module
{
    public function __construct()
    {
        $this->name = 'miextensionpayment';
        $this->version = '1.0.0';
        $this->author = 'TuNombre';
        $this->need_instance = 0;
        $this->bootstrap = true;
        parent::__construct();

        $this->displayName = 'Extensión de pago';
        $this->description = 'Añade funcionalidad al módulo de pago sin overrides';
    }

    public function install()
    {
        return parent::install() 
            && $this->registerHook('actionValidateOrder');
    }
}

Este enfoque te permite actualizar el módulo original con tranquilidad porque tu código vive en un módulo separado y usa únicamente hooks o decoradores cuando es posible.

Cómo documentar los cambios para no volverte loco

Documentar es tan importante como el código. Crea un archivo CUSTOM_CHANGES.md en la raíz de tu proyecto o en la carpeta /docs/ con esta estructura mínima:

# Cambios personalizados - Tienda Nombre

## Overrides de plantillas
- themes/tu_tema/modules/ps_wirepayment/views/templates/hook/payment_return.tpl
  Motivo: Añadir mensaje legal específico de la tienda
  Fecha: 2024-02-15
  Última revisión tras update: 1.2.3 (2024-11-20)

## Módulos propios
- miextensionpayment v1.0.0
  Funcionalidad: Añade campo 'referencia_interna' al pedido cuando se usa transferencia
  Hooks utilizados: actionValidateOrder, displayOrderConfirmation

## Overrides de clases (evitar si es posible)
- override/modules/ps_wirepayment/ps_wirepayment.php
  Motivo: Cambiar estado por defecto en ciertos países
  Riesgo: Alto. Revisar en cada actualización del módulo.

Actualiza este documento cada vez que toques algo. Incluye fecha, motivo técnico y versión del módulo original afectada. Te ahorrará horas cuando tengas que migrar a PrestaShop 8.2 o cuando entre un nuevo desarrollador.

Flujo de trabajo recomendado

  1. Busca si existe un hook adecuado (action, display o filter).
  2. Si no existe, valora crear un módulo de extensión en vez de un override de clase.
  3. Para cambios visuales, usa siempre override de plantilla en el tema.
  4. Documenta absolutamente todo en el fichero de cambios personalizados.
  5. Prueba las actualizaciones del módulo en un entorno de staging antes de subir a producción.

Seguir esta disciplina hace que las actualizaciones de PrestaShop y de sus módulos dejen de ser una lotería y se conviertan en un proceso controlado. El tiempo que inviertes en hacerlo bien se recupera con creces en cada actualización.

Scroll al inicio