symfony

     En este capítulo comenzaremos a preparar nuestra aplicación, para que podamos interactuar con la base de datos através de lo que se conoce en Symfony, como Entidades y Modelo de datos.

     Gracias a que hemos optado por utilizar Lando, ver o modificar los detalles de conexión con nuestra base de datos es bastante sencillo, podemos verlo en el archivo de configuración de lando, .lando.yml, donde encontraremos rápidamente la siguiente configuración:

services:
  phpmyadmin:
    type: phpmyadmin
    hosts:
      - symfony2.symfony2app.internal
  symfony2:
    type: mariadb
    portforward: true
    creds:
      user: symfony2
      password: symfony2
      database: symfony2

     Como puedes ver, además del acceso a la herramienta PhpMyAdmin, con la cual podrás manipular tus tablas y base de datos, mediante interfaz gráfica; tienes también el nombre tipo de motor de base de datos mariadb y los detalles para el usuario, clave y base de datos.

     Pero si lo prefieres, también podrás ver toda la información relacionada con la base de datos, ejecutando el comando siguiente:

lando info

     El resultado será parecido a la siguiente imagen:

     Para que podamos conectar nuestra aplicación de Symfony, con esta base de datos, tendremos que modificar el archivo parameters.yml, que se encuentra en la ubicación app/config/parameters.yml

     En realidad, este archivo se puede configurar automáticamente, cuando comenzamos con la instalación de nuestra aplicación de Symfony, pero hemos preferido dejarlo para este momento, ya que tendría más sentido mecionarlo, ahora que trabajaremos con las entidades y los datos.

     En el caso de que no tuviéramos creada la base de datos para nuestra aplicación, sólo necesitaríamos ejecutar el siguiente comando para que Symfony se encargara de hacerlo por nosotros (Recuerda que trabajamos con Lando, por eso hemos añadido la palabra al principio del comando):

lando php app/console doctrine:database:create

     Pero como nosotros ya teníamos la base de datos creada desde el principio, lo que tendremos que hacer es decirle a Symfony que la borre y luego vuelva a configurarla, y así podremos interactuar con ella.

lando php app/console doctrine:database:drop --force

     Así, podremos volver a crear nuestra base de datos con el siguiente comando:

lando php app/console doctrine:database:create

     Ahora, para trabajar con nuestro modelo de datos (blog de noticias), tendremos que crear algo llamado Entidad. Esta es básicamente una clase de PHP que define toda la información sobre nuestras páginas de noticias. Symfony tiene una ingeniosa herramienta de línea de comandos para esto que usaremos y otra buena para crear las tablas de base de datos reales que coincidan con este modelo de datos.

     Para generar nuestra entidad, a la que llamaremos noticia, vamos a ejecutar el siguiente comando de Symfony 2, con la ayuda de Lando:

lando php app/console doctrine:generate:entity

     Al igual que nos pasó cuando generamos el Bundle, Symfony nos presentará en pantalla una serie de preguntas relacionadas con nuestra entidad, que debermos ir completando hasta terminar el proceso; sin en algún punto de la generación de la entidad nos equivocamos, podremos hacer clic en la combinación de las teclas Ctrl + C y podremos comenzar nuevamente desde cero.

     En nuestro ejemplo, la entidad tendrás los siguientes campos y se guardará dentro de nuestro Bundle, por eso, en la primera pregunda, para el shortcut o atajo, escribiremos el nombre del bundle seguido de dos puntos y luego el nombre para nuestra entidad. Ej.: NewsBundle:News, el resto de la información será la siguiente:

     Una vez terminado el proceso, podremos echarle un vistazo a nuestra entidad, ubicada dentro de nuestro bundle, en la carpeta Entity, con el nombre News.php, su aspecto será como la siguiente imagen:

     En este momento, ya estamos listos para que Symfony se encargue de generar la tabla equivalente, con los datos de nuestra entidad, para ello, ejecutaremos el siguiente código en la consola:

lando php app/console doctrine:schema:update --force

     Como sólo tendremos una entidad, el proceso Symfony tardará muy poco en crear nuestra tabla y mostrarnos en pantalla el mensaje de confirmación, indicándonos el resultado:

     Gracias a Lando, podremos verificar los datos de nuestra tabla, accediendo a PhpMyAdmin, para ello, si no recuerdas la url, sólo tendremos que escribir el comando de información de lando:

lando info

     Y buscar la url que nos permitirá acceder a la interfaz gráfica de PhpMyAdmin:

     Dentro de PhpMyAdmin, podrás comprobar, que han sido generados correctamente, la tabla News y sus respectivos campos, coincidiendo con el modelo que hemos planteado en nuestra Entidad.

     Los datos con los que trabajaremos son páginas de un Blog de noticias. Crearemos una entidad (que sirve como nuestro modelo de datos para las páginas del blog) y aprenderemos a leerla y mostrarla. Durante todo el curso, aprenderemos cómo realizar las otras operaciones, es decir, agregar, actualizar y eliminar las páginas de noticias. Pero primero, necesitaremos crear un Bundle o paquete.

     En symfony un Bandle es el equivalente a los conocidos como Plugins en otras aplicaciones. La diferencia principal con respecto a estos, es que dentro de un Bundle de Symfony podremos encontrar, tanto la funcionalidad del propio Framework central, como el código escrito para nuestra aplicación personalizada. Esto le brinda la flexibilidad de usar funciones preconstruidas empaquetadas en paquetes de terceros o para distribuir sus propios paquetes. Hace que sea fácil seleccionar y elegir qué funciones habilitar en su aplicación y optimizarlas de la manera que desee.

      Un Bundle o paquete en Symfony, es un directorio donde guardas todos los archivos necesarios, para una funcionalidad específica en tu aplicación. En esta pequeña aplicación donde configuraremos para nuestro Modelo de datos, las operaciones básicas que implican un CRUD (Create, Read, Update, Delete ), necesitaremos crear un Bundle, antes de poder generar las entidades que nos ayudarán con los datos.

     Para generar un Bundle, nos colocaremos en la carpeta raiz de nuestra aplicación y ejecutaremos el siguiente código en consola, y dejaremos que Symfony 2 haga el trabajo por nosotros, como estamos trabajando con Lando, añadiremos lando, como parte del comando:

lando php app/console generate:bundle

     Entonces veremos en consola, el mensaje de bienvenida de symfony al sistema para generar nuestro Bundle:

     En este ejemplo, he decidido añadir los siguientes datos, pero puedes cambiarlos por los tuyos, en cuanto aprendas a trabajar con la generación de un Bundle:

Bundle name: NewsBundle

Target Directory [src/]: yes

Configuration format (annotation, yml, xml, php) [annotation]: yes

     Al finalizar, veremos un mensaje de confirmación, y a la vez uno de error, ya que en esta versión de Symfony 2, tendremos que añadir manualemente una línea, dentro de nuestro archivo composer.json y a continuación ejecutar nuevamente el comando de composer update, en este caso utilizando LANDO:

     Una vez añadida la línea con el nombre de nuestro NewsBundle, que es el que usamos para el ejercicio, ejecutaremos en pantalla el comando que permitirá a Composer actualizar en Syfmony nuestro Bundle.

lando composer update

     Al terminar la actualización de Composer, deberíamos ver un mensaje de confirmación, parecido al siguiente:

   Comprobación de que el NewsBundle funciona

     En este caso, el NewsBundle, que acabamos de generar, nos permitierá acceder a una página con el mensaje por defecto que viene en el Twig, generada por Symfony 2. 

     Para comprobarlo, primero abriremos el archivo DefaaultController.php, donde podremos comprobar la URL para nuestra página, en el apartado de las anotaciones, (Los comentarios que se muestran justo encima de la función).

     Podemos coprobar que nuestro nuevo NewsBundle funciona correctamente, accediendo a la url de desarrollo:

http://symfony2-app.lndo.site/app_dev.php

 

   Dónde se encuentra esta plantilla que vemos en pantalla?

     Para encontrar desde dónde se está imprimiendo este mensaje en pantalla, tendremos que abrir el archivo index.html.twig, que es la plantilla twig, llamada desde el controlador.

Si no ves el video, puedes refrescar el navegador, presionando (Ctrl+Shift+R | Ctrl+F5 o Shift+F5), o abrirlo directamente desde el Canal de Youtube... HAZ CLIC AQUI

     A pesar de que en la actualidad, todas las aplicaciones y lenguajes de programación, siguen evolucionado para mejorar sus características y funcionalidades, relacionadas sobretodo, con la seguridad o escalabilidad; facilitándonos cada vez más, las tareas de desarrollo e implementación, en cualquier proyecto o aplicación.

     En la vida real, nos encontramos con una gran cantidad de empresas, que se resisten a dicha evolución y pretenden continuar con versiones obsoletas e inseguras, en lugar de invertir tiempo y dinero en su actualización.

     Muchos de los casos con los que me he encontrado, a lo largo de estos últimos meses, tienen relación con proyectos desarrollados, utilizando el framework PHP, Symfony, que actualmente ha lanzado la versión 6, pero en lugar de utilizar ésta, la mayoría funciona todavía con la versión Symonfy 2.

     Por esta razón, he decidido compartir una guía rápida, para que puedas configurar un entorno local, utilizando Lando, en lugar de hacerlo con Docker puro, que suele ser un poco más complejo, para tus proyectos de Symfony 2.

   Instalación de Symfony 2 utilizando Lando

    Incompatibilidades:

          Lo primero que debes tener en cuenta, son las posibles incompatibilidades con las que te encontrarás, ya que Symfony 2 funciona correctamente, sólo con las versiones PHP 5.3 hasta la 7.2, a partir de entonces experimentarás diversos fallos. 

          Symfony 2, tampoco funciona con las versiones actuales de Composer, por lo que en caso de que estés tratando de instalar un proyecto de Symfony 2, deberás utilizar versiones anteriores a la 2.0

   Paso 1 - Instalar el lando

Si todavía no lo haz instalado, puedes ver el video y leer las instrucciones HAZ CLIC AQUÍ

git clone https://github.com/drupaladicto/symfony2-lando.git

   Paso 2 - Descargar las actualizaciones de Symfony

     Para ello, nos moveremos dentro de la carpeta del proyecto y ejecutaremos el comando para que comience a funcionar Lando:

lando start

     A continuación, ejectuaremos el comando de Composer, para comenzar con la descargas de las dependencias de Symfony 2

lando composer update

   Paso 3 - Acceder a la página de bienvenida de Symfony

     Para acceder a la página de bienenida de Symfony2, añadiremos a la url /app_dev.php:

http://symfony2-app.lndo.site/app_dev.php

 

Detalles de la instalación:

     El proyecto incluye un archivo de configuración para lando que activará, La versión 1.10.1 de Composer y PHP 7.2, para evitar errores de compatibilidad en esta versión Obsoleta de Symfony, además de PhpMyAdmin con una base de datos completamente configurable:

name: symfony2-app
recipe: symfony
config:
  php: 7.2
  webroot: web
  composer_version: '1.10.1'

services:
  phpmyadmin:
    type: phpmyadmin
    hosts:
      - symfony2.symfony2app.internal
  symfony2:
    type: mariadb
    portforward: true
    creds:
      user: symfony2
      password: symfony2
      database: symfony2

Guardaremos los cambios y continuaremos con el siguiente paso.

   Descarga de las dependencias

        Una vez descargados los archivo del repositorio, necesitarás ejecutar el comando de composer para que terminen de descargarse todas las dependencias de Symfony definida en el archivo composer.json. Para ello el comando que deberás utilizar es el siguiente:

lando composer update

 

   Desactivación de las comprobaciones en el navegador

     Cuando realizamso una instalación de Symfony 2, tendremos que realizar un pequeña modificación en dos archivos (app_dev.php y config.php), se trata de un trozo de código que se encarga de comprobar los accesos de las ips en entornos locales, pero que podremos modificar ya que estaremos trabajando en nuestro ordenador.

     Antes de realizar ningún cambio más, vamos a comprobarlo. Arrancaremos el proyecto, ejecutando el comando de lando:

lando rebuild

   Posibles Fallos

        Según la documentaicón oficial de esta versión, podremos comprobar si nos falta algo en la configuración inicial del proyecto, accediendo a la url http://nuestrositio/config.php, pero debido a la comprobación del navegador dentro de este mismo arhivo, es posible que veamos un error en pantalla como el siguiente:

     Ahora que estamos seguros de que no funciona, vamos a ejecutar los cambios necesarios para continuar.

   Config.php

     El primer archivo que deberíamos corregir y ejecutar, tan pronto arranque nuestro proyecto es config.php y nos confirmará si todo ha ido bien en la instalación del proyecto.

     Está ubicado en '/web/config.php' y las líneas que tenemos que comentar, para no tener que borrarlas, están al principio del archivo, son las siguientes:

<?php

if (!isset($_SERVER['HTTP_HOST'])) {
    exit('This script cannot be run from the CLI. Run it from a browser.');
}

if (!in_array(@$_SERVER['REMOTE_ADDR'], array(
    '127.0.0.1',
    '::1',
))) {
    header('HTTP/1.0 403 Forbidden');
    exit('This script is only accessible from localhost.');
}

     Una vez realizado el cambio, si ejecutamos el comando lando rebuild y accedemos a la url http://proyecto.lndo.site/config.php, deberíamos ver que todo funciona correctamente:

   app_dev.php

     El próximo arhivo está ubicado, al igual que el anterior, dentro de la carpeta '/web/app_dev.php', es el que nos muestra la pantalla de bienvenida de Symfony 2, al acceder a la url http://proyecto.lndo.site/app_dev.php. En este caso, las líneas que tendremos que comentar son las siguientes:

// This check prevents access to debug front controllers that are deployed by accident to production servers.
// Feel free to remove this, extend it, or make something more sophisticated.
if (isset($_SERVER['HTTP_CLIENT_IP'])
    || isset($_SERVER['HTTP_X_FORWARDED_FOR'])
    || !in_array(@$_SERVER['REMOTE_ADDR'], array('127.0.0.1','fe80::1', '::1'))
) {
    header('HTTP/1.0 403 Forbidden');
    exit('You are not allowed to access this file. Check '.basename(__FILE__).' for more information.');
}

 

     En este caso, la pantalla que deberíamos ver una vez realizados los cambios y ejecutado el comando lando rebuild, sería la siguiente:

   Trabajando con un proyecto Symfony 2 existente

     En el caso de que necesites trabajar en tu entorno local, con un proyecto desarrollado en Symfony 2, sólo sería necesario que tuvieras instalado lando en tu ordenador y una vez añadido el archivo de configuración .lando.yml, arrancar el servidor y ajustar los detalles de urls.

     Si quieres saber más sobre Symfony 2, visita su Documentación Oficial de Symfony 2

     Solución de problemas: HAZ CLIC AQUÍ

 

   Ahora que ya sabemos Cómo instalar una distribución Linux dentro de Windows 10 usando el WSL, podemos pasar al siguiente nivel y explorar tantas opciones como nos hagan falta, para trabajar con cualquier proyecto, sin tener que cambiarnos de ordenador o trabajar con máquinas virtuales.

     La idea es facilitarnos la vida y que podamos implementar todas las herramientas necesarias sin la necesidad de invertir demasiado tiempo en ello.

     Por esta razón, hoy vamos a explicar cómo podremos configurar un entorno PHP para desarrollar un proyecto utilizando Symfony; uno de los Frameworks más potentes, robustos y seguros  que existen en el mercado.

     Aclaración antes de seguir

     Al momento de crear este artículo, existe un conocido error relacionado con el reloj en tiempo real con Ubuntu 20.04 y WSL2. Para evitar que surja este error, configuramos APT para congelar nuestra versión libc6 instalada a la de la distribución original emitiendo el siguiente comando:

sudo apt-mark hold libc6

     Tan pronto como hayamos ejecutado el anterior comando, podremos actualizar los paquetes de ubuntu ejecutando los siguiente:

sudo apt update

sudo apt upgrade

     Lo próximo que instalemos son las dependencias centrales para ejecutar la plataforma eZ (y muchas otras aplicaciones Symfony):

sudo apt install composer php-xml php-intl php-gd php-curl php-fpm

     En la línea anterior, he omitido el servicio de base de datos para aclarar que la plataforma eZ es compatible con las bases de datos MySQL / MariaDB y PostgreSQL. ASí que podrás elegir lo que mejor se adapte a tus necesidades. En nuestro caso usaremos MariaDB para este tutorial. Instala el servidor MariaDB y la extensión PHP MySQL:

sudo apt install mariadb-server php-mysql

     Ya estamos listos para arrancar la instancia del servidor MariaDB e iniciar sesión como usuario root:

sudo service mysql start

sudo mysql

     Vamos a añadir una base de datos para la plataforma eZ, Por lo que ejecutamos las siguientes declaraciones SQL:

CREATE DATABASE ezp;

GRANT ALL ON ezp.* TO 'ezp'@'localhost' IDENTIFIED BY 'wsl2ezp';

FLUSH PRIVILEGES;

EXIT;

     Y ahora comprobamos que podemos acceder a la base de datos:

mysql -uezp -pwsl2ezp ezp

     Ahora ya tenemos un entorno Linux con PHP, MariaDB y el administrador de paquetes Composer listo para funcionar:

 

     Ya que vamos a utilizar Symfony Encore para gestionar los activos de front-end, instalaremos el administrador de paquetes Yarn desde el repositorio del proyecto. De esta forma también instalará Node.js como dependencia:

curl -sS https://dl.yarnpkg.com/debian/pubkey.gpg | sudo apt-key add -
echo "deb https://dl.yarnpkg.com/debian/ stable main" | sudo tee /etc/apt/sources.list.d/yarn.list
sudo apt update
sudo apt install yarn

     Instalando el CLI de Symfony

     A estas alturas, puede que hayas notado que falta en el procedimiento de instalación anterior es la A en LAMP y la E en LEMP. En lenguaje sencillo: nuestra pila no tiene un servidor web instalado. Tradicionalmente, una pila PHP ha incluido un servidor web separado. Un servidor HTTP completo sigue siendo para instalaciones de producción, pero como estamos en desarrollo utilizaremos una opción más simple: Symfony Local Web Server

     Symfony CLI es una aplicación de línea de comandos independiente que podremos instalar desde nuestra terminal WSL. Recuerda seguir las instrucciones de Linux, NO las de Windows:

wget https://get.symfony.com/cli/installer -O - | bash

     El código anterior lo instalará en nuestra carpeta de usuario, pero  podremos hacerlo disponible de forma global si ejecutamos el siguiente código, cambiando el NOMBRE DEL USUARIO por el tuyo:

sudo mv /home/nombre_usuario/.symfony/bin/symfony /usr/local/bin/symfony

     Ahora podemos verificar que nuestra pila está funcionando creando una nueva aplicación Symfony hello world y ejecutando el servidor web:

symfony new hola-mundo

cd hola-mundo

symfony serve

     Ha llegado el momento de abrir una ventana del navegador en http: // localhost: 8000 / para ver la aplicación en ejecución. La primera vez que lo ejecutes, es posible que Windows te pregunte si este tráfico está permitido. Ahora debería tener una aplicación Symfony básica ejecutándose en Windows usando WSL2 como se muestra en la captura de pantalla a continuación.

 

     Para obtener más detalles sobre cómo configurar TLS, múltiples versiones de PHP, etc., diríjase a los documentos de Symfony.

     Instalación de la Plataforma eZ y acceso a archivos

     El siguiente paso es instalar y ejecutar una aplicación Symfony completa. Esto funciona como en cualquier entorno Linux (¡porque es uno!). Así que vamos a instalar una copia de la plataforma eZ  y para ello utilizaremos. Éste se encargará de clonar los archivos desde el repositorio, verificará por nosotros las actualizaciones disponibles y a continuación instalar los paquetes necesarios usando:

composer create-project ezsystems/ezplatform ezplatform ^3 cd ezplatform

     Lo siguiente será instalar nuestra base de datos y para ello, necesitamos definir la configuración de la base de datos y ejecutar el instalador:

echo "DATABASE_URL=mysql://ezp:wsl2ezp@127.0.0.1:3306/ezp?serverVersion=10.3" > .env.local composer run-script ezplatform-install

Cuando se haya completado el proceso de instalación,  podremos ingresar al directorio del proyecto e iniciar el servidor web Symfony:

symfony serve

     El resultado mostrará que el servidor web Symfony detecta y usa la copia instalada de PHP-FPM:

     Ahora, si abrimos un navegador (en Windows) y nos dirigimos a http: // localhost: 8000 /, podremos ver la aplicación en ejecución. Para acceder a los archivos desde Windows, puede ejecutar el siguiente comando para abrir una ventana del Explorador de Windows en su directorio de trabajo actual:

explorer.exe .

     Desde aquí, podrás recoger las cosas y usar cualquier IDE en Windows (¡o incluso notepad.exe!) Que necesites usar para tu desarrollo.

Si no ves el video, puedes refrescar el navegador, presionando (Ctrl+Shift+R | Ctrl+F5 o Shift+F5), o abrirlo directamente desde el Canal de Youtube... HAZ CLIC AQUI

       En el anterior capítulo, aprendimos a generar un controlador con su respectiva página, utilizando el Bundle Make, que nos generó una serie de archivos conectados, gracias a los cuales, pudimos acceder a nuestra primera página personalizada, llamada /main, al escribir dicha url en nuestro navegador.

     Si nos fijamos un poco más en detalle, podremos apreciar que esta página, nos muestra la ubicación de los dos archivos necesarios para generarla, estos son el controlador MainController.php y la plantilla Twig, llamada index.html.twig. Así que en esta ocasión vamos a conocer un poco más sobre cómo trabajar con las plantillas para mostar nuestros contenidos en Symfony.

   Documentación oficial de Twig

     Para conocer mejor el funcionamiento de las plantillas en Symfony, deberíamos visitar la documentación oficial, donde encontraremos toda clase de información relacionada, con las diferentes funcionalidades, estructuras, filtros y opciones, disponibles para nosotros, al trabajar con plantillas Twig. Te recomiendo visitarla en este enlace: 

https://twig.symfony.com/doc/3.x/

     Twig es el resultado de una evolución en la programación, basada en PHP, que te permitirá trabajar de manera más amigable, flexible y rápida, al momento de ejecutar todo tipo de operaciones o cambios en tus plantillas. 

     Con un mínimo de esfuerzo, podrás realizar todo tipo de operaciones como declaraciones de variables, arrays, loops, ordenación de elementos, entre otras.

   Cómo trabajar con Twig dentro de Symfony 5

     Si abrimos el archivo llamado index.html.twig, que nos aparece en nuestra página /main, veremos la siguiente estructura:

     En la primera línea, tenemos la declaración de una herencia, esto quiere decir, que nuestra plantilla está heredando desde la plantilla llamada base, las principales características, que son las que permitirán utilizar, por ejemplo, las etiquetas html, los css o javascript:

{% extends 'base.html.twig' %}

     Encontraremos esta plantilla base, si buscamos dentro de la carpeta llamada templates, que es justo donde se guardan por defecto, todas las plantillas generadas automáticamente.

   Cómo trabajar con la plantilla base.hmtl.twig

      Cuando exploramos un poco más a fondo, la estructura dentro de la plantilla base.html.twig, nos daremos cuenta de en varias partes de ella, encontraremos combinaciones de etiquetas html, con otras en un formato menos conocido:

<body>
    {% block body %}{% endblock %}
</body>

     En Twig, cuando vemos dos llaves, acompañadas de signos de porcentaje, significará que dentro se ejecuta algun proceso. En este caso, se están declarando bloques de contenido, específcamente, el bloque llamado body, correspondiente al cuerpo o parte principal de la página.

     Al igual que en otros lenguajes de programación, cuando declaramos un bloque, tendremos una "Etiqueta" de apertura y otra de cierre, es por esta razón, que vemos {% endblock %}, como parte de la estructura.

     Si abrimos nuestra plantilla generada automáticamente, entenderemos mejor, porqué parte de sus código está entre estas dos etiquetas:

{% block body %}
<style>
    .example-wrapper { margin: 1em auto; max-width: 800px; width: 95%; font: 18px/1.5 sans-serif; }
    .example-wrapper code { background: #F5F5F5; padding: 2px 6px; }
</style>

<div class="example-wrapper">
    <h1>Hello {{ controller_name }}! ✅</h1>

    This friendly message is coming from:
    <ul>
        <li>Your controller at <code><a href="{{ '/app/src/Controller/MainController.php'|file_link(0) }}">src/Controller/MainController.php</a></code></li>
        <li>Your template at <code><a href="{{ '/app/templates/main/index.html.twig'|file_link(0) }}">templates/main/index.html.twig</a></code></li>
    </ul>
</div>
{% endblock %}

   Ejemplo práctico

     Primero, analicemos la estructura que utilliza Symfony, para pasarle datos desde el controlador a la plantilla:

public function index(): Response
{
    return $this->render('main/index.html.twig', [
        'controller_name' => 'MainController',
    ]);
}

     En la primera parte de la declaración, vemos que se devuelve un objeto del tipo Response utilizando el método render, donde pasamos, como primer parámetro la ubicación de la plantilla, o sea, main/index.html.twig y a continuación, un array, con los valores que se le pasarán a dicha plantilla, en este caso, el array de datos, tiene una clave llamada controller_name y un valor asignado, que es MainController.

     Para pasar el valor y poder imprimirlo dentor de la plantilla, Symfony utiliza dobles llaves, por eso, si abrimos la plantilla, podremos ver la línea donde imprime en pantalla el valor de esta variable, utilizando la siguiente estructura:

<h1>Hello {{ controller_name }}! ✅</h1>

     Hagamos entonces la siguiente comprobación, vamos a reescribir nuestra página, para ello, primero añadiremos un nuevo array, que pasaremos como parámetro desde el controlador y a continuación, utilizaremos un bucle for, para recorrerlo e imprimir todos sus valores dentro de una lista, en la plantilla. El siguiente será el aspecto del controlador con los nuevos cambios.

<?php

namespace App\Controller;

use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Routing\Annotation\Route;

class MainController extends AbstractController
{
    /**
     * @Route("/main", name="app_main")
     */
    public function index(): Response
    {
        $recommendations = [
            'one' =>  'Poner atención en los detalles',
            'two' =>  'Nunca darte por vecido',
            'tree' => 'Siempre marcarte nuevos objetivos'
        ];
        return $this->render('main/index.html.twig', [
            'recommendations' => $recommendations,
        ]);
    }
}

 

     Y a continuación, tendremos la nueva estructura dentro de nuestra plantilla, en la cual hemos removido casi todo lo generado automáticamente, para dejar solamente, la declaración de herencia {% extends 'base' %} y luego los bloques title y body:

{% extends 'base.html.twig' %}

{% block title %}Nuevo controlador {% endblock %}

{% block body %}
    <ul>
        <h2>Nuestra recomendaciones</h2>

        {# Estos son los comentarios #}
        {% for recommendation in recommendations %}
        <li>{{ recommendation }}</li>
        {% endfor %}

    </ul>
{% endblock %}

     Si guardamos los cambios y volvemos a nuestro navegador y refrescamos, el aspecto de la página /main, debería ser el siguiente:

    Ahora que ya sabemos, que para utilizar elementos de la plantilla base.twig.html, dentro de nuestras plantillas personalizadas, lo primero es declarar la herencia, con la sentencia {% extends 'base.html.twig' %}, y a continaución podremos definir uno o varios bloques y llamarlos desde nuestra plantilla.

Si no ves el video, puedes refrescar el navegador, presionando (Ctrl+Shift+R | Ctrl+F5 o Shift+F5), o abrirlo directamente desde el Canal de Youtube... HAZ CLIC AQUI

     Aprovechando que poco a poco, nos estamos acostumbrando a trabajar en proyectos locales de Drupal, ejecutando Lando para nuestros servidores, por ser la forma más sencilla y rápida de comenzar a desarrollar, utilizando los contenedores de Docker sin tener que complicarnos la vida; en esta ocasión, te quiero mostrar la manera de comenzar con un proyecto de Symfony 5, en un entono Linux, con WSL2 y Windows 11, y así podrás comenzar a explorar otras alternativas para tus proyectos, además de conocer la estructura en la que está basado Drupal, a partir de la versión 8.

Prerrequisitos:

- Tener instalado en tu servidor local Lando. Si todavía no lo haz hecho y quieres aprender cómo hacerlo, Haz clic aquí

 

NOTA: Puedes acceder al repositorio listo para utlizar en este enlace  https://github.com/drupaladicto/symfony5-lando

 

Cómo instalar y comenzar un proyecto con Symfony usando Lando

     En realidad es mucho más sencillo de lo que pudieras imaginar, al igual que explicamos en el capítulo para instalar Drupal 10, solo necesitaremos colocarnos en la ubicación deseada para nuestro proyecto y una vez alli, creaemos el archivo al que llamaré configurador.sh, donde lo más importante es la extensión .sh, para que nos permita ejecutarlo dentro de nuestro servidor linux.

     A continaución, copiaremos el siguiente código, le daremos permisos totales, para evitar fallos durante el proceso de descarga e instalación y ya podremos comenzar a desarrollar casi de inmediato.

# Initialize a symfony recipe
mkdir symfony5-app \
  && cd symfony5-app \
  && lando init \
    --source cwd \
    --recipe symfony \
    --webroot public \
    --name symfony5-app

# Install symfony
lando composer create-project symfony/skeleton:"^5.4" tmp && cp -r tmp/. . && rm -rf tmp

# Install other Symfony dependencies you may like
lando composer require annotations asset doctrine encore form logger profiler security security-guard stof/doctrine-extensions-bundle twig validator var-dumper

# Start it up
lando start

# List information about this app.
lando info

# Run bin/console commands with: lando console
# Here is how to clear cache; 
lando console cache:clear

 

     Aclaración 24 de abril 2022: Poco después de haber subido el video y publicado la documentación, pude comprobar que el bundle Make, de Symfony se había actualizado para la versión 5 y daba fallos con la versión 5.4.6, por lo que decidí removerlo del archivo de instalación configurador.sh.

     No obstante, una vez terminada la instalación, podrás descargar la versión estable del bundle Make, ejecutando en tu consola el siguiente comando:

lando composer make

Explicación:

     En las primeras líneas, se creará la carpeta para nuestro proyecto y, a continuación, se moverá para añadir el arhivo de configuración de Lando, e iniciará el proceso de la descarga desde el repositorio oficial de Drupal. 

     Deberías sustituir, si lo prefieres, todas las líneas donde ves symfony5-app, que en este caso se refiere tanto al nombre de la carpeta donde estará alojado el proyecto de Symfony, como al nombre que dará Lando una vez instalado y que podrás comprobar si abres el archivo de cofiguración .lando.yml.

  # Initialize a symfony recipe
mkdir symfony5-app \
  && cd drupal10-app \
  && lando init \
    --source cwd \
    --recipe symfony \
    --webroot public \
    --name symfony5-app

     Las siguientes líneas son las encargadas de descargar el esqueleto para un proyecto Symfony, utilizando el comando de Lando Composer.

# Install symfony
lando composer create-project symfony/website-skeleton tmp && cp -r tmp/. . && rm -rf tmp

     En la siguiente línea, se descargarán las dependencias o paquetes, más comunes para comenzar a desarrollar nuestros proyectos, dentro de los que se incluyen doctrine, twig, entre otros, ahorrándonos tiempo considerablemente. El resto de paquetes podrás consultarlos y descargarlos desde la web: flex.symfony.com 

 # Install other Symfony dependencies you may like
lando composer require annotations asset doctrine encore form logger maker profiler security security-guard stof/doctrine-extensions-bundle twig validator var-dumper

     A continuación, se levantan nuevamente los servicios de Lando, para poner en funcionamiento la aplicación.

# Start it up
lando start

     Por último, se muestra la información del proyecto, gracias al comando Lando info y se limpia la consola, para que podamos acceder a nuestro proyecto y comenzar a trabajar en él.

# List information about this app.
lando info

# Run bin/console commands with: lando console
# Here is how to clear cache; 
lando console cache:clear

 

     Si quieres explorar algo más de información antes del próximo artículo, puedes visitar la documentación oficial de Lando para Symfony