Generando un panel de control en pocos minutos con EasyAdmin en Symfony

2020-03-27 - Categorías: General / PHP / Symfony / WordPress
EasyAdmin generando a partir de la BD

¡Hola! Jugando y jugando, probando software, aquí que vengo de nuevo y os traigo un codekata en Symfony. Es para hacer ingeniería inversa de cualquier proyecto en el que tengas una base de datos. También traigo una joya del software que se llama EasyAdmin, un bundle/componente para Symfony. Este codekata se puede aplicar a cualquier base de datos compatible con Symfony, más en concreto, con cualquiera compatible con Doctrine, que es el componente ORM que te conectará con la BD.

Quizá tienes que hacer un panel de control que sólo acceda a la información X del proyecto, a ciertas tablas. También sirve para bases de datos completas. Podría ser un proyecto legacy, de un Symfony antiguo, un Magento, un ERP como Odoo con el que trabajar con Symfony, o un WordPress, un Prestashop, Drupal, etc.. Sea cual sea el proyecto la idea es la misma.

En este post he usado una BD de WordPress recién instalado. Pero lo dicho, la idea es la misma para cualquier proyecto, salvando los ajustes que haya que hacer por el camino. El primer paso es mapear la base de datos con Doctrine. Entonces podremos crear en unos pocos minutos más, un panel de control que molará un pegote, con EasyAdmin.. ?

Creando el proyecto de pruebas

Vamos al grano después de la introducción de turno.. lo primero a fecha de hoy es que tenemos disponible el comando symfony. Si no lo tienes instalado me remito a las instrucciones: https://symfony.com/download

Acciones disponibles con el nuevo comando de consola de Symfony.

Entonces, creamos el proyecto desde consola, en nuestra carpeta desastre:

symfony new symfony-testing-easyadmin

Configurando el proyecto, cargando los componentes

Lo siguiente es entrar a la nueva carpeta y cargar el componente EasyAdmin, cuyo nombre en clave será admin para Composer:

cd symfony-testing-easyadmin/
composer require admin
Todos los componentes de EasyAdmin instalándose en el proyecto.

Ingeniería inversa de la base de datos con Doctrine

Lo siguiente será conectar este nuevo proyecto con la BD, así que lo hacemos con el fichero .env:

DATABASE_URL=mysql://usuariobd:contraseña@127.0.0.1:3306/nombrebd?serverVersion=mariadb-10.4.12

En mi caso es la configuración anterior. Si tienes Mysql o Postgresql por ejemplo, tendrás que cambiarlo. También se puede ignorar el serverVersion aquí, y configurarlo en config/packages/doctrine.yaml.

Lo siguiente será importar la estructura, lo que se llama mapear las entidades para el ORM. Este es el proceso de ingeniería inversa para el caso de proyectos de este estilo. Lo normal sería crear las entidades en Doctrine con comandos, y después generar la base de datos. Pues en este codekata lo hacemos al revés ? Para importar la base de datos completa hacemos:

php bin/console doctrine:mapping:import "App\Entity" annotation --path=src/Entity
Generando automáticamente los códigos fuentes de las entidades de la BD.

Hasta aquí ya tenemos la primera parte. Ya podemos trabajar los datos sin ninguna interfaz, o comenzar a crear interfaces, comandos, disparar acciones en el tiempo, lo que haga falta..

Arrancando el servidor de desarrollo

Este ha migrado de la consola de cada proyecto al comando symfony a partir de la versión 5 de Symfony. Así que hacemos:

symfony server:start
Servidor de desarrollo local arrancando en local.

Si vamos ahora a http://localhost:8000/ no veremos nada porque es la home del proyecto nuevo. Ya podemos empezar a picar código para el frontend. Si estamos trabajando en un proyecto ya creado sí. Pero vamos ahora al panel de control en la dirección http://localhost:8000/admin/ y veremos que nos faltan algunas cosas.

Configurando las tablas disponibles en el panel de control

Lo siguiente es decirle a EasyAdmin qué entidades queremos tener en el panel de control. Para esto tenemos que configurar el fichero config/packages/easy_admin.yaml, que para el caso este de WordPress le podemos poner lo siguiente:

easy_admin:
    entities:
#        # List the entity class name you want to manage
#        - App\Entity\Product
#        - App\Entity\Category
#        - App\Entity\User
        - App\Entity\WwpCommentmeta
        - App\Entity\WwpComments
        - App\Entity\WwpLinks
        - App\Entity\WwpOptions
        - App\Entity\WwpPostmeta
        - App\Entity\WwpPosts
        - App\Entity\WwpTermRelationships
        - App\Entity\WwpTermTaxonomy
        - App\Entity\WwpTermmeta
        - App\Entity\WwpTerms
        - App\Entity\WwpUsermeta
        - App\Entity\WwpUsers

En la versión actual de WordPress sale un error en la WwpTermRelationships, porque tenemos dos identificadores. Es sencillo arreglarlo, podemos modificar el fichero de la entidad src/Entity/WwpTermRelationships.php y lo modificamos como el siguiente:

<?php

namespace App\Entity;

use Doctrine\ORM\Mapping as ORM;

/**
 * WwpTermRelationships
 *
 * @ORM\Table(name="wwp_term_relationships", indexes={@ORM\Index(name="term_taxonomy_id", columns={"term_taxonomy_id"})})
 * @ORM\Entity
 */
class WwpTermRelationships
{
    /**
     * @var int
     *
     * @ORM\Column(name="object_id", type="bigint", nullable=false, options={"unsigned"=true})
     * @ORM\Id
     * @ORM\GeneratedValue(strategy="NONE")
     */
    private $objectId = '0';

    /**
     * @var int
     *
     * @ORM\Column(name="term_taxonomy_id", type="bigint", nullable=false, options={"unsigned"=true})
     * NONONOORM\Id
     * @ORM\GeneratedValue(strategy="NONE")
     */
    private $termTaxonomyId = '0';

    /**
     * @var int
     *
     * @ORM\Column(name="term_order", type="integer", nullable=false)
     */
    private $termOrder = '0';
}

Con dejar un identificador Doctrine nos lo admitirá. Según cada caso habrá que ver si hacer claves compuestas para algunas entidades. Pero para probar los códigos para este post, simplemente la segunda etiqueta @ORM/Id la he anulado.

Generando códigos fuentes

Una cosa que nos falta que estamos viendo, son todos los getters y setters de las entidades. Todavía no va a funcionar el panel de control por este motivo, pero queda bien poco. Así que con lo siguiente en línea de comandos se regenerarán todas las funciones que faltan en las entidades.

composer require maker
php bin/console make:entity --regenerate
Regenerando códigos fuentes de funciones faltantes de las entidades.

Ahora sí que sí, ya está todo si no me equivoco..

Probando que todo funciona, ya en el panel de control

Ahora sí, ya tenemos el punto de partida de un backend completo. Si accedemos a http://localhost:8000/admin/ veremos el backend. Como hemos partido de una base de datos de WordPress, podemos ir a ver la tabla WwpPosts, por ejemplo, y veremos una pantalla como la siguiente:

Si entramos por ejemplo al post 1 que es de pruebas, que se genera cuando instalamos WordPress veremos lo siguiente:

Ya con esto, en pocos minutos, tenemos comenzado un buen panel de control. Como punto de partida no está nada mal.. ¿verdad? A mi me mola un pegote EasyAdmin, seguiré probándolo para nuevos proyectos ?

Terminando, referencias y más ayuda

Para terminar, no me queda más que remitirte a la documentación oficial. Podrás encontrar información y ejemplos de todo tipo mucho más avanzados, para personalizar el panel de control, para darle seguridad con control de accesos, y un largo etcétera:

https://symfony.com/doc/master/bundles/EasyAdminBundle/index.html

También:

https://symfony.com/
https://www.doctrine-project.org/

Ya me estoy extendiendo demasiado, otro día más.. ? ¡Hasta la próxima!

4 respuestas a “Generando un panel de control en pocos minutos con EasyAdmin en Symfony”

  1. oscar dice:

    realmente fácil pero quisiera saber como se puede explotar esto como parte del frontend, es decir por ejemplo un sistema para un almacén donde el usuario y no necesariamente un administrador tenga acceso a la lista de productos en tal caso se tendría que bloquear el «edit» y el «delete»

    • Jnj dice:

      Hola Oscar!

      Aquí tienes toda la documentación oficial del EasyAdmin:
      https://symfony.com/doc/master/bundles/EasyAdminBundle/index.html

      De hecho hay otros bundles, para crear «automáticamente» mucho de lo necesario para hacer paneles de gestión, como por ejemplo el SonataAdminBundle:
      https://symfony.com/doc/current/bundles/SonataAdminBundle/index.html

      En todos los gestores de paneles tienes que configurarlos. En el caso del EasyAdmin puedes configurar ese bloqueo como pone en la documentación aquí:
      https://symfony.com/doc/master/bundles/EasyAdminBundle/actions.html#disabling-actions

      Si son muchas las personalizaciones que vas a necesitar, como en el caso de un ERP para gestionar inventario, te recomiendo que lo pienses. Lo digo porque yo eligiría el hacer el panel de gestión a base del generador de código de Symfony con CRUDs, y luego editando el código para poder personalizarlo lo máximo posible. Es decir, que si vas a querer hacer un ERP con gestión de inventario, creo que a la larga te conviene más usar Symfony sin bundles de administración:
      https://symfony.com/doc/current/bundles/SensioGeneratorBundle/commands/generate_doctrine_crud.html

      Saludos.

      • oscar dice:

        gracias!! te comentaré como me va, yo pensé poder utilizar en lo posible easyadmin como para reutilizar codigo, en lo que leía tengo entendido que antes el easyadmin generaba archivos independientes en su src para cada entidad mientras se le iba especificando los parametros en su yml de configuracion pero en la version que instalé ayer no encuentro esos archivos para cada entidad me imagino que ya no los genera, si me recomiendas otros admins te agradecería, un saludo

        • Jnj dice:

          Si es para un proyecto pequeño que quieras usar pronto y no te importa mucho precindir de algunas funcionalidades, EasyAdmin está de maravilla. Si quieres luego modificarlo mucho, yo escogería el generar CRUDs con el maker de Symfony, y luego editarlo todo (controladores, plantillas, hacer servicios..). Pero esto es una decisión personal que tienes que hacer..

          EasyAdmin te genera este fichero config/packages/easy_admin.yaml ..ahí es donde tienes que poner las entidades que hayas hecho, y que quieras que EasyAdmin te administre. Te invito a que sigas también la documentación oficial, que es mucho más extensa que el post que he escrito aquí arriba:
          https://symfony.com/doc/current/bundles/EasyAdminBundle/book/your-first-backend.html
          https://symfony.com/doc/current/bundles/EasyAdminBundle/index.html

          EasyAdmin es una maravilla la verdad, pero como te digo, necesita de un poco de tiempo para aprender a modificarlo. Hmmm.. también te invito a seguir viendo otros vendors de Composer, aquí puedes hacer búsquedas también de lo que necesites para tu proyecto. Por ejemplo: https://packagist.org/?query=easyadmin

          Y no hay de qué. Gracias a ti por comentar. Un saludo Oscar!

Responder a Jnj Cancelar la respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *

 

© 2024 JnjSite.com - MIT license

Sitio hecho con WordPress, diseño y programación del tema por Jnj.