Actualmente estoy desarrollando un e-commerce para un proyecto familiar. Me decanté en usar Sylius por la experiencia que otros desarrolladores de mi actual empresa habían tenido en uno de los proyectos que habían realizado. Sylius está construido sobre Symfony  utilizando  su misma filosofía.

Sylius está basado en  una serie de componentes totalmente desacoplados. La colaboración entre estos componentes  permite desarrollar una solución completa para un site e-commerce. ¡Es el momento perfecto para apostar por este framework!

Por ello, me puse manos a la obra y comencé a estudiar los distintos componentes que forman el framework. La primera necesidad me surgió, cuando se necesitaba no cobrar gastos de envío si el pedido superaba los 50 euros. Por lo tanto me centré en SyliusShippingBundle, que es el bundle encargado de la gestión de los envíos. Este bundle es responsable de manejar los métodos envío y proporcionar interfaces para poder implementar calculadoras de costes de gastos de envío. Este apartado es muy flexible en Sylius ya que permite incluir distintos servicios de cálculo para los gastos de envío.

Implementando una calculadora en Sylius

Sylius posee distintos servicios de cálculo por defecto, pero es tan flexible que permite registrar nuestros propios métodos de cálculo, asociados a un método de envío, integrado totalmente en el interfaz de administración.

Todos los métodos de cálculo de gastos de envío deben implementar la interfaz CalculatorInterface. A continuación os dejo un ejemplo de una calculadora que devuelve coste 0 si el valor del pedido es igual o superior a un importe concreto. En caso contrario, devolveremos el precio configurado.

<?php

namespace AppBundle\Shipping\Calculator;

use Sylius\Component\Shipping\Calculator\CalculatorInterface;
use Sylius\Component\Shipping\Model\ShipmentInterface;

final class SmileshopCalculator implements CalculatorInterface
{
    /**
     * {@inheritdoc}
     */
    public function calculate(ShipmentInterface $subject, array $configuration): int
    {

        $order = $subject->getOrder();
        $total = $order->getTotal();

        if ($total >= $configuration['amount']) {
            return 0;
        }

        return $configuration['price'];
    }

    /**
     * {@inheritdoc}
     */
    public function getType(): string
    {
        return 'smileshop';
    }
}

En la clase anterior, vemos cómo se reciben algunos valores de un array $configuration. Estos valores se reciben de un formulario. La implementación del  formulario se puede ver en la siguiente clase, con dos campos, el importe al partir del que no se cobra gastos, y el valor de los gastos en sí.

<?php

namespace AppBundle\Shipping\Calculator;

use Symfony\Component\Form\AbstractType;
use Symfony\Component\Form\Extension\Core\Type\IntegerType;
use Symfony\Component\Form\FormBuilderInterface;
use Symfony\Component\OptionsResolver\OptionsResolver;
use Symfony\Component\Validator\Constraints\NotBlank;
use Symfony\Component\Validator\Constraints\Type;

final class SmileshopCalculatorType extends AbstractType
{
    const AMOUNT = 5000;
    const PRICE = 500;

    /**
     * {@inheritdoc}
     */
    public function buildForm(FormBuilderInterface $builder, array $options): void
    {
        $builder
            ->add('amount', IntegerType::class, [
                'label' => 'Importe a partir del que no se cobran gastos',
                'constraints' => [
                    new NotBlank(),
                    new Type(['type' => 'integer']),
                ]
            ])
            ->add('price', IntegerType::class, [
                'label' => 'Precio de los gastos de envio',
                'constraints' => [
                    new NotBlank(),
                    new Type(['type' => 'integer']),
                ]
            ]);
    }

    /**
     * {@inheritdoc}
     */
    public function configureOptions(OptionsResolver $resolver): void
    {
        $resolver
            ->setDefaults([
                'data_class' => null,
                'amount' => self::AMOUNT,
                'price' => self::PRICE

            ])
            ->setAllowedTypes('amount', 'integer');
    }

    /**
     * {@inheritdoc}
     */
    public function getBlockPrefix(): string
    {
        return 'app_shipping_calculator_smileshop';
    }
}

Una vez tenemos implementado la calculadora y el formulario, registramos los servicios con los siguientes tags  sylius.shipping_calculator y form.type respectivamente.

services:

    app.shipping_calculator.smileshop:
        class: AppBundle\Shipping\Calculator\SmileshopCalculator
        tags:
            - { name: sylius.shipping_calculator, calculator: smileshop, form_type: AppBundle\Shipping\Calculator\SmileshopCalculatorType, label: "Calculadora Smileshop" }

    app.form.type.shipping_calculator.dhl:
        class: AppBundle\Shipping\Calculator\SmileshopCalculatorType
        tags:
            - { name: form.type }

Una vez que ya hemos dado de alta nuestros servicios, en la propia interfaz de administración de los gastos de envío, aparece nuestra nueva “Calculadora”. Al seleccionarla, aparecen los valores del formulario que hemos construido, permitiendo al usuario configurar esta calculadora, siendo muy potente y proporcionando al cliente la capacidad de modificar dinámicamente esta opción cuando desee.

Conclusión

Como hemos podido comprobar, Sylius proporciona una serie de interfaces que nos permite extender el comportamiento del e-commerce de una forma muy sencilla. Esto es lo que realmente hace potente a este tipo de soluciones, ya que partiendo de una aplicación e-commerce básica necesitamos personalizar y desarrollar sobre esta las necesidades de nuestra tienda.