entities

Gutenberg | Módulo Drupal

Video de Youtube
URL de Video remoto
Texto

      Aunque en mi opinión, una de las cosas que me enamoró de Drupal en cuanto lo conocí, es la posibilidad de manipular, personalizar y saber encontrar, prácticamente dónde y cuando ocurren la mayoría de sus funcionalidades, entiendo que el objetivo principal de cualquier herramienta de desarrollo, debería ser facilitarnos la vida, además de ofrecernos grandes posibilidades a nuestro alcance.

     Como cada proyecto requiere de diferentes requisitos para llevarse a cabo, y por lo general, uno de los más importantes, es el tiempo que tendremos que invertir hasta su puesta en producción, muchos desarrolladores web prefieren apostar por otros CMS o construir desde cero proyectos enteros, para sentir que tienen mayor control sobre sus creaciones.

     No obstante, creo que con un pequeño conocimiento sobre cómo instalar Drupal 9 usando Composer y un breve vistazo a cómo gestionar usuarios y permisos, complementado con la ayuda del Módulo Gutenberg, conocido mayormente por usuarios de Wordpress, podrías llegar a tener lo que haz estado buscando hace tiempo, una plataforma simple de manipular, pero potente, con posibilidad de adaptación a la mayoría de webs sencillas.

     Es por esta razón que a continuación, te voy a mostrar cómo puedes utilizar las opciones que integra este módulo a la interfaz de usuario, facilitándote de forma notable, la creación de nuevos contenidos en Drupal 9.

Descarga y Activación:

Para descargar y activar cualquier módulo de Drupal tienes varias opciones:

     Descarga:

          1.- La forma recomendada a partir de Drupal 8, es utilizando el gestor de paquetes Composer, ejecutando en tu consola el comando:

composer require drupal/gutenberg

          2.- Descargándolo manualmente el módulo desde la página oficial del Módulo Gutenberg y una vez descargado y colocado en carpeta "modules/contrib", si haz descargado todos tus módulos manualmente, deberías crear la carpeta "contrib", para que puedas diferenciar entre tus módulos personalizados y los que están disponibles directamente en la Página oficial de Drupal.
 

     Activación:

          1.- Utilizando la herramienta de consola Drush, la opción "-y" activará todos los sub-modulos automáticamente

drush en gutenberg -y

          2.- Desde la interfaz de usuario de Drupal, en la url "/admin/modules", y luego marcando el check junto al nombre de tu módulo y haciendo clic en el botón guardar que aparecer al final de la página.

 

gutenberg - www.drupaladicto.com - formacion especializada en drupal y symfony

 

Cómo utilizar Gutenberg

     Una vez activado el Módulo Gutenberg, veremos que se ha añadido una nueva opción, en la parte inferior izquierda de todos los contenidos, llamada Gutenberg Experience y que al activarla podremos ver dos listados con todos los nuevos bloques, tanto del propio módulo como de el núcleo de Drupal, que podremos activar o no, para que estén disponibles como parte de las opciones del tipo de contenido en que se han activado, modificando inmediatamente la interfaz de creación de dicho contenido.

 

Gutenberg Drupal | www.drupaladicto.com - Consultor especializado en drupal y symfony

     La idea principal de Gutenberg, es que convierte todos los elementos que podamos añadir, en bloques individuales, con sus propias opciones, disponibles en el momento en que seleccionamos dicho bloque o elemento, haciéndolo mucho más gráfico el método para añadir, modificar o reutilizar dicho elemento.

     Para comenzar a añadir contenidos o "Bloques" en nuestro tipo de contenido, veremos un símbolo de más dentro de un círculo y al hacer clic sobre éste, se desplegarán las diferentes opciones disponibles para agregar y una vez seleccionado el elemento que deseamos añadir y se añade, inmediatamente cambiará el panel de la derecha de la pantalla, adaptándose a las opciones disponibles para él.

 

gutenberg - www.drupaladicto.com - formacion especializada en drupal y symfony

     De entre sus opciones más llamativas, está la posibilidad de arrastrar directamente los elementos hasta la posición deseada desde el escritorio de tu ordenador, la integración con módulos como Media o Imagen, insertar directamente elementos embebidos como vídeos, sonidos, etc, o la posibilidad de crear "Bloques" de contenido reutilizables en cualquier otro lugar de la web.

     El objetivo de utilizar Gutenberg, es que todos tus tipos de contenido, sólo tengan el campo "Body" y dentro de este campo se podrán añadir, editar o eliminar el resto de elementos que se mostrará en tus páginas, incluyendo imágenes o incluso bloques del núcleo de Drupal.

Gutenberg Cloud

     Una de las opciones más novedosas de este módulo, es la posibilidad de añadir "bloques" de contenido, directamente desde su repositorio en la web Gutenbergcloud.org, mediante el sistema de CDN, por lo que dichos bloques, con características, estilos y funcionalidades prediseñados, no se guardan como el resto de contenidos en la base de datos de Drupal. Por el contrario, se añaden como etiquetas dentro del campo "BODY", que añade Drupal por defecto cada vez que creamos un nuevo tipo de contenido.

     Para añadir esta funcionalidad, sólo habría que activarla como cualquier otro módulo y una vez hecho esto, se añadirá como una de las opciones disponibles para agregar en el listado de bloques cuando hagamos clic en el selector.

 

gutenberg - www.drupaladicto.com - formacion especializada en drupal y symfony

     Por desgracia, esta funcionalidad no es compatible para todas las versiones de Drupal 9, por lo menos al momento de escribir este artículo. Pero sí podrás utilizarla en cualquier instalación de Drupal 8 o menor que la 9.1.

 

Gutenberg Drupal | www.drupaladicto.com - Consultor especializado en drupal y symfony

Contenidos de Prueba | Generados con el módulo Devel

Video de Youtube
URL de Video remoto
Texto

      Cuando estamos empezando con el desarrollo o implementación de cualquier proyecto, en la mayoría de los casos nos resultará necesario la creación de contenidos con los que podamos realizar pruebas de todo tipo.

     Para realizar esta tarea, en Drupal contamos con el módulo Devel Generate, integrado dentro de las dependencias del módulo Devel. Por lo que, una vez instalado y activado en nuestro Drupal, sólo tendremos que dirigirnos a la url "/admin/config/development/generate/content", y allí veremos el listado de todos los tipos de contenidos que tengamos creados en nuestro proyecto.

CÓMO INSTALAR Y CONFIGURAR EL MÓDULO:

Paso 1 Descargar el módulo:

     Lo primero que tendrás que hacer es descargarlo, para ello, a partir de Drupal 8 se recomienda que utilices el gestor de paquetes Composer, ya que te facilitará tanto la instalación como futuras actualizaciones del tus proyectos. No obstante también podrías descargarlo desde la Página oficial del módulo y una vez descargado, tendrás que colocarlo en la carpeta "modules" o "modules/contrib", dependiendo de tu instalación y asegurarte de descargar todas sus dependencias o el módulo no funcionará, esta es una de las ventajas con las que cuentas al hacer la instalación usando Composer.

Paso 2 Activación del módulo :

     Para activar el módulo Devel, al igual que todos los demás módulos contribuidos de Drupal, tendrás la posibilidad de hacerlo, mediante el uso de la herramienta Drush, con el comando "drush en devel -y", que sirve para activar cualquier módulos y todas sus dependencias, o desde la interfaz de Drupal.    

Devel Drupal | www.drupaladicto.com - Consultor especializado en drupal y symfony

Devel Drupal | www.drupaladicto.com - Consultor especializado en drupal y symfony

     Además de poder generar automáticamente nuestros contenidos, podremos configurar algunas opciones adicionales como, especificar su fecha de publicación, comentarios relacionados, títulos para los contenidos con un límite de caracteres específico, el idioma o incluso los usuarios que los crearon, esta última opción nos facilitará el testeo de los permisos de usuario.

     Para generar nuestro contenidos, sólo tendremos que marcar las opciones con las que deseamos trabajar, es recomendable intentarlo la primera vez como poco contenido para estar seguros de obtener lo que pensábamos o si hará falta modificar algún campo.

     Si no estás conforme con el contenido generado o simplemente quieres volver a generar contenidos otra vez, puedes seleccionar la opción de eliminar todos los contenidos previamente creados antes de ejecutarlo.

Devel Drupal | www.drupaladicto.com - Consultor especializado en drupal y symfony

     Una vez que hayamos revisado todos los campos que nos interesan, haremos clic en el botón que aparece en la parte inferior de la pantalla y comenzará el proceso inmediatamente.

Devel Drupal | www.drupaladicto.com - Consultor especializado en drupal y symfony

     Cuando se haya realizado el proceso de generación de nuestros contenidos, veremos un mensaje de confirmación en la parte superior de la pantalla, con la cantidad y el tipo de contenido que decidimos utilizar.

Devel Drupal | www.drupaladicto.com - Consultor especializado en drupal y symfony

     Para comprobarlo, sólo tendremos que dirigirnos al listado de contenidos en la url "/admin/content" y veremos el listado de contenidos generados por el módulo con las configuraciones adicionales, si es que hemos seleccionado alguna.

Devel Drupal | www.drupaladicto.com - Consultor especializado en drupal y symfony

Contenidos programáticamente | Creación en Drupal 9

Video de Youtube
URL de Video remoto
Texto

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 lo largo de los años, Drupal ha ganado la inmerecida fama de que es un CMS muy complejo y difícil de aprender, pero en realidad, todo dependerá de tu capacidad para experimentar con nuevas herramientas y tu actitud de superar cualquier reto que se te presente; verás que no resulta tan complicado, si dedicas el tiempo necesario y tienes la suficiente paciencia contigo.

     Si todavía no lo conoces, te animo a que empieces desde hoy mismo con este curso gratis de Drupal 9 paso a paso en español y en un par de semanas te llevarás la grata sorpresa de lo mucho que puedes lograr si pones verdadero empeño.

   LO QUE NECESITAS ANTES DE EMPEZAR CON ESTE EJERCICIO:

  1. Tener Drupal funcionando ya sea con un servidor local tipo Xampp o con contenedores de Docker.
     
  2. Haber instalado al menos estos dos módulos esenciales Backup and Migrate y Admin Toolbar
     
  3. (Opcional) Conocimientos básicos sobre Cómo crear un módulo personalizado

     Una vez hayas terminado de configurar todo lo anterior y te sientas con todas las ganas para comenzar, el próximo paso sería hacer tu primera copia de seguridad; de esta forma, te asegurarás de que puedes recuperar la última versión estable de tu desarrollo si hubiera cualquier tipo de fallo durante el proceso.

Así que, para crear esta primera copia de nuestra base de datos estable, nos iremos a la ventana del módulo Backup and migrate usando la siguiente ruta en el navegador o mediante los botones del menú superior "/admin/config/development/backup_migrate" y crearemos la primera copia estable.

Custom Module Drupal  | www.drupaladicto.com - Consultor y formador especializado en Drupal y Symfony

Tan pronto como veamos el mensaje de confirmación de que se ha realizado la copia correctamente, nos toca continuar con el proceso de creación del tipo de contenido y posteriormente su colocación en un módulo personalizado, para que podamos reutilizarlo en cualquier otro proyecto o que nos sirva de base para contenidos más complejos.

PASO 1 CREACIÓN DEL TIPO DE CONTENIDO:

Empezaremos con el proceso de crear nuestro tipo de contenido, añadiéndole los campos correspondientes, funcionalidades y estructura. Es importante que tengas muy claro si tu contenido tendrá dependencias de otros contenidos como vocabularios, referencias a otros contenidos o formularios, etc. La idea es que tu tipo de contenido, tal y como lo definas esté disponible para cualquier otra web de Drupal 8 o 9 o que te sirva como punto de partida para desarrollar otros contenidos más complejos partiendo de una base predefinida.

En este ejercicio, vamos a crear un tipo de contenido llamado "Servicio", al que añadiremos dos campos ( Imagen servicio y Descripción del servicio ), de esta forma podrás apreciar mejor todos los elementos relacionados según el tipo de campo que prefieras emplear.

Custom Module Drupal  | www.drupaladicto.com - Consultor y formador especializado en Drupal y Symfony

PASO 2 CREACIÓN DEL MÓDULO PERSONALIZADO:

     Básicamente, vamos a crear una carpeta con el nombre de nuestro módulo, y la colocaremos dentro de la carpeta "modules/custom", para mantener mejor ordenado el desarrollo de nuestra web. Te recomiendo que utilices el mismo nombre que tendrá tu tipo de contenido y luego añadiremos el archivo "TUMODULO.info.yml", que es necesario para que Drupal lo reconozca como módulo, acompañado de dos carpetas adicionales "config" + "install", donde tendremos que colocar todos los demás archivos relacionados con la definición de nuestro contenido.

Custom Module Drupal  | www.drupaladicto.com - Consultor y formador especializado en Drupal y Symfony

PASO 3 EXPORTACIÓN Y CREACIÓN DE ARCHIVOS:

     Aquí es donde viene la novedad y verdadera ventaja, de utilizar este método para la creación de tus contenidos en un módulo personalizado, en lugar de tener que programar todo desde cero, disminuyendo así considerablemente la generación de errores e investigación de posibles fallos de estructura y ejecución, como en versiones anteriores de Drupal.

     La idea consiste en utilizar la exportación de configuración, incluida en la interfaz de usuario a partir de Drupal 8, para no tener que memorizar un montón de líneas de código, tabulaciones específicas y otras características obligatorias. Haciendo que tus desarrollos puedan ponerse en marcha en el menor tiempo posible.

Custom Module Drupal  | www.drupaladicto.com - Consultor y formador especializado en Drupal y Symfony

     Como en cualquier desarrollo, la clave está en los detalles. Debes prestar mucha atención de no saltarte ningún paso del procedimiento, durante la creación y todo saldrá según lo que esperas.

     LO QUE SIEMPRE DEBES VERIFICAR:

     1.- El tipo de contenido: El primer archivo que debes añadir a tu módulo, siempre dentro de la carpeta "config/install" es el que define tu tipo de contenido, por ejemplo, el desplegable te mostrará todos los elementos disponibles, si tu contenido a exportar es un nodo, debes elegir "Tipo de contenido" o "Content Type", pero también podrías exportar cualquier otro elemento, por lo tanto, podrás usar "Tipo de parrafo" o "Paragraphs Type", "Bloque personalizado" o "Custom Block", etc.

     El proceso siempre debería ser igual, primero creas el archivo con el nombre sugerido en la parte inferior de la ventana de exportación y lo guardas en la dentro de la carpeta "config/install" de tu módulo personalizado.

Custom Module Drupal  | www.drupaladicto.com - Consultor y formador especializado en Drupal y Symfony

A continuación, como sugerencia, en la primera línea de cada archivo, pega el nombre sugerido como comentario, o sea, poniéndole una almohadilla delante, de esta forma ayudarás a Drupal a identificar el archivo y a ti de guía para confirmar si haz cambiado el nombre del archivo por error.

Custom Module Drupal  | www.drupaladicto.com - Consultor y formador especializado en Drupal y Symfony

     Por último, copia todo el código que está justo debajo del UUID en la interfaz y pégalo en cada uno de tus archivos, dejando algo de espacio a partir del comentario que haz pegado al principio.
 

     2.- Todos los contenidos tienen obligatoriamente tres archivos fundamentales:

  • core.entity_form_display.node.servicio.default.yml: Que define el formulario que se utilizará para crear el contenido.
  • - core.entity_view_display.node.servicio.default.yml: Que define la forma de presentación del contenido.
  • node.type.servicio.yml: Define el tipo de contenido.

El resto de archivos que formarán tu módulo, serán los campos que vienen por defecto o que han sido creados por ti, como taxonomías, patrones de url, campos referenciados a otros contenidos, etc.

Custom Module Drupal  | www.drupaladicto.com - Consultor y formador especializado en Drupal y Symfony

     3.- Cada campo tiene dos archivos uno que define sus propiedades específicas, empieza por "field.field", ejemplo "field.field.node.servicio.field_descripcion_del_servicio.yml" y otro que define la manera en que serán guardados los datos, empieza por "field.storage", ejemeplo "field.storage.node.field_descripcion_del_servicio.yml"

Custom Module Drupal  | www.drupaladicto.com - Consultor y formador especializado en Drupal y Symfony

Custom Module Drupal  | www.drupaladicto.com - Consultor y formador especializado en Drupal y Symfony

     Por lo tanto al crear el archivo para cada campo asegúrate de hacerlo con sus correspondencias, antes de pasar a los archivos del siguiente campo, así tendrás más control si quieres modificar los nombres que crea Drupal a los campos por defecto y evitas errores por falta de algún archivo equivalente. 
 

     4.- No olvides añadir dependencias. Siempre que vayas a crear contenidos siguiendo este método, añade al menos una dependencia en el archivo info.yml de tu módulo, eso facilitará que te acostumbres mejor a la estructura de creación de este archivo.

PHPUnit en Drupal 8 | Prueba del navegador

Texto

En este tutorial abarcaremos los conceptos básicos de las pruebas del navegador PHPUnit en Drupal 9. ¡Al final, deberías poder escribir tu primera prueba del navegador!

     Para este ejemplo, usaremos el módulo Rules, ya que podemos incluir algunas pruebas funcionales del navegador. Luego, el tutorial explicará cómo probar la interfaz de usuario de Rules, para asegurarse de que funcione correctamente.

     Prerrequisitos:

     Una instalación de Drupal 8 funcionando:

     - Cómo instalar cualquier versión Drupal 8 usando Composer
 

     - Cómo Instalar LAMP usando WSL2 en Windows 10 (1era Parte)

     Composer instalado:

     - Cómo instalar Composer 2 en Ubuntu 20.04

      Módulos instalados:

       RulesAdmin ToolbarPathauto

    Configuración para el tutorial

        Primero, necesitaremos asegurarnos de que el módulo  Rules esté instalado (descárguelo y agréguelo a su carpeta de módulos). PHPUnit es parte de las dependencias de Composer del núcleo de Drupal, así que asegúrese de haber ejecutado la instalación de composer en tu Drupal 8. Familiarícese con la ejecución de pruebas PHPUnit y asegúrese de habilitar BROWSERTEST_OUTPUT_DIRECTORY e printerClass en su archivo phpunit.xml como se explica en esa página.

   ¿Qué debería probar con BrowserTestBase?

        BrowserTestBase le ofrece una forma de probar comportamientos e interacciones basados en la web. Por ejemplo, si desea verificar que se requiere un determinado permiso antes de que un usuario pueda visitar una determinada página, debe crear un usuario sin ese permiso e intentar visitar la página, y luego comparar el resultado con otro intento con ese permiso. 

        BrowserTestBase satisface la necesidad de realizar pruebas de alto nivel basadas en solicitudes de integraciones entre varios subsistemas en Drupal. Por lo general, las pruebas de BrowserTestBase no deberían requerir temas o configuración específicos del sitio, aunque es posible escribir pruebas con esos requisitos. Otras herramientas como Behat podrían usarse para pruebas de comportamiento específicas del sitio.

        Finalmente, BrowserTestBase reemplaza el WebTestBase heredado basado en Simpletest. Si está migrando desde Simpletest de Drupal, le resultará relativamente fácil convertir las pruebas de WebTestBase a BrowserTestBase.

   Cómo funcionan las pruebas del navegador de Drupal

      La mayor parte de Drupal es una funcionalidad orientada a la web, por lo que es importante tener una forma de ejercitar estas funciones. Las pruebas del navegador crean una instalación completa de Drupal y un navegador web virtual y luego usa el navegador web virtual para guiar la instalación de Drupal a través de una serie de pruebas, tal como lo haría si lo estuviera haciendo a mano.

   Acerca del escenario de prueba del módulo Rules

        El módulo Reglas proporciona una interfaz de usuario para los administradores donde pueden crear reglas. Consiste en múltiples páginas y formularios que queremos probar, los cuales están protegidos con permisos de usuario para que solo los administradores puedan acceder a ellos. El escenario de prueba más simple está en rules/tests/src/Functional/UiPageTest.php.

    Descubriendo lo que necesitamos probar

        Si instala el módulo Reglas, puede seguir manualmente los pasos y ver lo que cree que debe probarse. Si todavia no haz trabajado con Rules, te enseño todo lo que necesitas asaber en este artículo Cómo crear nuestra primera regla con Rules

        Visite Configuración> Flujo de trabajo> Reglas donde debería ver una página que dice "Aún no hay una regla de reacción". en la tabla de reglas. Puede agregar reglas y configurarlas, pero como primer paso, queremos probar que esta página de descripción general del administrador realmente existe y dice que aún no hay reglas.

   Escribir un archivo de prueba

       Ahora es el momento de crear nuestras pruebas, que haremos en la carpeta rules / tests / src / Functional. PHPUnit encontrará automáticamente los archivos de prueba del navegador en la carpeta tests / src / Functional de un módulo.

     Hay cuatro pasos básicos involucrados en la creación de una prueba:

  • Crear la estructura (simplemente crear una clase que herede de \ Drupal \ Tests \ BrowserTestBase o una clase de prueba de navegador similar)
  • Inicializar el caso de prueba con cualquier creación o configuración de usuario que deba realizarse
  • Crear pruebas reales dentro del caso de prueba
  • Y, por supuesto, intentar desesperadamente averiguar por qué nuestra prueba no funciona de la manera que esperamos y depurar la prueba (y quizás el módulo)

     Para empezar con la creación de nuestro archivo de pruebas, necesitaremos extender la clase BrowserTestBase.

namespace Drupal\Tests\rules\Functional;

use Drupal\Tests\BrowserTestBase;

/**
 * Tests that the Rules UI pages are reachable.
 *
 * @group rules_ui
 */
class UiPageTest extends BrowserTestBase {

     Como siguiente paso, debemos especificar la lista de módulos que deben habilitarse para la ejecución de prueba. En nuestro caso, esto es, por supuesto, las Rules.

  /**
   * Modules to enable.
   *
   * @var array
   */
  protected static $modules = ['node', 'rules'];

   Luego viene el setUp() opcional . Aquí es donde debemos hacer todo lo que sea necesario para que esta instancia de Drupal funcione como queremos. Tenemos que pensar: "¿Qué tuve que hacer para pasar de una instalación de Drupal de stock a donde puedo ejecutar esta prueba?". No todos los casos de prueba necesitarán esto, pero aquí hay un ejemplo en el que preparamos un tipo de contenido (tomado de las reglas ConfigureAndExecuteTest):

  /**
   * {@inheritdoc}
   */
  protected function setUp(): void {
    parent::setUp();

    // Create an article content type that we will use for testing.
    $type = $this->container->get('entity_type.manager')->getStorage('node_type')
      ->create([
        'type' => 'article',
        'name' => 'Article',
      ]);
    $type->save();
    $this->container->get('router.builder')->rebuild();
  }

   Tenga en cuenta que si implementa el método setUp(), empiece por ejecutar el método parent::setUp() como en el ejemplo.

   Crear prueba específica: la página de reglas de reacción 

     Ahora necesitamos crear pruebas específicas para ejercitar el módulo. Simplemente creamos métodos de nuestra clase de prueba, cada uno de los cuales realiza una prueba en particular. Todos los métodos deben comenzar con 'prueba' en minúsculas. Cualquier método con visibilidad pública que comience de esta manera será reconocido automáticamente por PHPUnit y se ejecutará cuando se solicite.

     Nuestra primera prueba comprobará la página en admin/config/workflow/rules:

  /**
   * Tests that the reaction rule listing page works.
   */
  public function testReactionRulePage() {
    $account = $this->drupalCreateUser(['administer rules']);
    $this->drupalLogin($account);

    $this->drupalGet('admin/config/workflow/rules');
    $this->assertSession()->statusCodeEquals(200);

    // Test that there is an empty reaction rule listing.
    $this->assertSession()->pageTextContains('There is no Reaction Rule yet.');
  }

   setUp() y pruebas individuales

     Cada función de prueba tendrá una instancia de Drupal completamente nueva para ejecutar pruebas. Esto significa que lo que haya creado en una función de prueba anterior ya no estará disponible en la siguiente.

     Considere este ejemplo, tomado de Rules UIPageTest.php -extraction:

namespace Drupal\Tests\rules\Functional;

class UiPageTest extends RulesBrowserTestBase {

 /**
   * Modules to enable.
   *
   * @var array
   */
  protected static $modules = ['rules'];

  /**
   * {@inheritdoc}
   */
  protected function setUp() {
    parent::setUp();
    // ....
  }
  public function testReactionRulePage() {
    $account = $this->drupalCreateUser(['administer rules']);
    $this->drupalLogin($account);
    // .....
  }

  public function testCreateReactionRule() {
    $account = $this->drupalCreateUser(['administer rules']);
    $this->drupalLogin($account);
    // .....
  }

  public function testCancelExpressionInRule() {
    // Setup a rule with one condition.
    $this->testCreateReactionRule();
    // .....
  }

}

     Aqui ambos testReactionRulePage() y testCreateReactionRule deben crear su propia $account, porque ambas pruebas se ejecutan en sus propias instancias de Drupal y el Drupal de la última función no tiene cuentas a menos que se cree.

     Sin embargo, otras pruebas (posteriores) pueden depender del contenido creado en otras funciones de prueba si ejecutan esas funciones por separado, como lo hace testCancelExpressionInRule ().

     Por otro lado, la función setUp() se ejecuta antes de cada función de prueba, por lo que también puede usarlo para preparar el entorno de prueba.

   drupalGet() y Assertions

       El código anterior hizo una solicitud GET muy simple en la página admin / config / workflow / rules. Carga la página, luego verifica el código de respuesta y afirma que encontramos el texto apropiado en la página.

       La mayoría de las pruebas seguirán este patrón:

  1. Haga un $ this-> drupalGet ('some / path') para ir a una página
  2. Use $ this-> clickLink (..) para navegar por enlaces en la página
  3. Use $ this-> getSession () -> getPage () -> fillField (...); para completar los campos del formulario
  4. Envíe formularios con $ this-> getSession () -> getPage () -> pressButton (...); o use $ this-> submitForm (...); (o use el método obsoleto drupalPostForm ())
  5. Haga una o más afirmaciones para comprobar que lo que vemos en la página es lo que deberíamos ver.

   Rellenar formularios

    $page = $this->getSession()->getPage();

    $page->fillField('form_element', 'value');
    $page->selectFieldOption('form_element', 'value')

   Assertions (Afirmaciones)

       Hay decenas de posibles assertions. A continuación se muestran algunos ejemplos. Cuando vaya más allá de este tutorial, querrá mirar la clase \ Behat \ Mink \ WebAssert y su hijo de Drupal \ Drupal \ Tests \ WebAssert para leer más sobre ellos.

    $this->assertOptionSelected('form_element', 'value');
    $this->assertFieldByName('form_element');

    $web_assert = $this->assertSession();

    $web_assert->addressEquals('node/1');
    $web_assert->pageTextContains("Expected text");
    $web_assert->pageTextNotContains("Unexpected text");

   Ejecutando la prueba

     Usaremos la línea de comando para ejecutar la prueba. Esto se documenta con más detalle en la ejecutando la página de pruebas PHPUnit.

     Ejecutemos solo el método testReactionRulePage () de UiPageTest:

cd core
../vendor/bin/phpunit --filter testReactionRulePage ../modules/rules/tests/src/Functional/UiPageTest.php
PHPUnit 4.8.11 by Sebastian Bergmann and contributors.

.

Time: 25.14 seconds, Memory: 6.00Mb

OK (1 test, 5 assertions)

HTML output was generated
http://drupal-8.localhost/sites/simpletest/browser_output/Drupal_Tests_rules_Functional_UiPageTest-13-411368.html
http://drupal-8.localhost/sites/simpletest/browser_output/Drupal_Tests_rules_Functional_UiPageTest-14-411368.html
http://drupal-8.localhost/sites/simpletest/browser_output/Drupal_Tests_rules_Functional_UiPageTest-15-411368.html

   ¡Sí, nuestra prueba ha pasado! También generó un par de archivos de salida HTML, donde puede ver las páginas que visitó el navegador durante la prueba. Las páginas se escriben en archivos vinculados como, por ejemplo, arriba, por lo que puede inspeccionarlos después de que se haya ejecutado la prueba.

   Una prueba de demostración fallida

      Realmente no nos enseña mucho tener un examen que tenga éxito. Veamos uno que falla.

     Modificaremos la prueba para provocar una falla en la prueba; afirmaremos que la página contiene un texto diferente, que por supuesto no está allí.

  /**
   * Tests that the reaction rule listing page works.
   */
  public function testReactionRulePage() {
    $account = $this->drupalCreateUser(['administer rules']);
    $this->drupalLogin($account);

    $this->drupalGet('admin/config/workflow/rules');
    $this->assertSession()->statusCodeEquals(200);

    $this->assertSession()->pageTextContains('some text not actually on the page');
  }

   Ejecute la prueba y vea el resultado:

../vendor/bin/phpunit --filter testReactionRulePage ../modules/rules/tests/src/Functional/UiPageTest.php 
PHPUnit 4.8.11 by Sebastian Bergmann and contributors.

E

Time: 24.38 seconds, Memory: 6.00Mb

There was 1 error:

1) Drupal\Tests\rules\Functional\UiPageTest::testReactionRulePage
Behat\Mink\Exception\ResponseTextException: The text "some text not actually on the page" was not found anywhere in the text of the current page.

/home/klausi/workspace/drupal-8/vendor/behat/mink/src/WebAssert.php:787
/home/klausi/workspace/drupal-8/vendor/behat/mink/src/WebAssert.php:262
/home/klausi/workspace/drupal-8/modules/rules/tests/src/Functional/UiPageTest.php:37

FAILURES!
Tests: 1, Assertions: 5, Errors: 1.

HTML output was generated
http://drupal-8.localhost/sites/simpletest/browser_output/Drupal_Tests_rules_Functional_UiPageTest-16-425496.html
http://drupal-8.localhost/sites/simpletest/browser_output/Drupal_Tests_rules_Functional_UiPageTest-17-425496.html
http://drupal-8.localhost/sites/simpletest/browser_output/Drupal_Tests_rules_Functional_UiPageTest-18-425496.html

     Vaya, algo salió mal y nuestra prueba lo detectó. ¡Hurra!

   Cuándo usar t () en las pruebas del navegador

       ¡Nunca! No, ni en los mensajes de afirmación, ni para las etiquetas de los botones, ni para el texto que afirma en la página. Siempre desea probar la cadena literal en la página, no desea probar el sistema de traducción de Drupal.

   Depurar las pruebas del navegador

      Como ya se mencionó, es muy importante habilitar la salida de depuración en la prueba del navegador para que pueda ver las páginas visitadas por el navegador. Si una prueba falla, PHPUnit detiene la ejecución de la prueba donde falla, lo que significa que el último de los enlaces de salida HTML es la página donde ocurrió el error.

     También puede utilizar la función dump () (proporcionada por el componente Symfony VarDumper), ya sea en su método de prueba o en el código del sitio que se está ejecutando. Esto tiene la ventaja sobre el uso de print o print_r () que su salida no se detecta como un error de prueba.

     También puede usar el método ddm () del módulo Devel para generar un archivo de registro. Configure la ubicación del archivo de registro en su código de prueba de esta manera:

    $config = $this->config('devel.settings');
    $config->set('debug_logfile', '/path/to/file/drupal_debug.txt')->save();
    $config->set('debug_pre', FALSE)->save();

   Escribir una clase base para ampliarla con otras clases de prueba.

      Puede encontrar que algunos de sus códigos de prueba duplican la funcionalidad compartida. En este caso, es posible que desee crear una clase base que luego se amplíe con sus diversas clases de prueba. Al hacer esto, hay 2 cosas importantes a tener en cuenta.

  1. La clase de prueba base debe ser abstracta
  2. La clase de prueba base debe terminar con la palabra Base

     Ejemplo de Clase de prueba base: my_module/Tests/src/Functional/myModuleTestBase.php

<?php

namespace Drupal\Tests\my_module\Functional;

/**
 * To be extended by other test classes.
 */
abstract class myModuleTestBase extends BrowserTestBase {
  protected function setUp() {
    parent::setUp();
    // etc
  }
}

     Ampliando la clase base: my_module/Tests/src/Functional/myModuleSomethingTest.php

<?php

namespace Drupal\Tests\my_module\Functional;

/**
 * Test something about my module.
 *
 * @group my_module
 */
class myModuleSomethingTest extends myModuleTestBase {

  protected function setUp() {
    parent::setUp();
  }

  public function testSomething() {
    // do the test.
  }
}

   SQLite

     El uso de una base de datos SQLite hace que las pruebas sean más rápidas que con un DBMS como MySQL. Porque la base de datos está contenida en solo 1 archivo. Asegúrese de que Drupal no esté usando su conexión de base de datos predeterminada desde el archivo settings.php.

     Una solución sencilla es comprobar el HTTP_USER_AGENT. Ej.:

if ($_SERVER['HTTP_USER_AGENT'] !== 'Drupal command line') {

  $databases['default']['default'] = [
    'database' => 'MY-DATABASE',
    'username' => 'root',
    'password' => 'root',
    'prefix' => '',
    'host' => '127.0.0.1',
    'port' => '',
    'namespace' => 'Drupal\\Core\\Database\\Driver\\mysql',
    'driver' => 'mysql',
    'unix_socket' => '/Applications/MAMP/tmp/mysql/mysql.sock',
  ];

}

     En su archivo phpunit.xml especifique su conexión de base de datos SQLite (el archivo no debe existir antes):

<env name="SIMPLETEST_DB" value="sqlite://localhost/sites/default/files/db.sqlite"/>

     De lo contrario, obtendrá errores como este:

Exception: PDOException: SQLSTATE[HY000] [2002] Connection refused

   Usar datos de sesión

     Puede inspeccionar los datos de la sesión para la solicitud más reciente de la siguiente manera:

    $session_data = $this->container->get('session_handler.write_safe')->read($this->getSession()->getCookie($this->getSessionName()));
    $session_data = unserialize(explode('_sf2_meta|', $session_data)[1]);

Fuente: https://www.drupal.org/docs/automated-testing/phpunit-in-drupal/phpunit-browser-test-tutorial

PHPUnit | Ejecución de pruebas

Video de Youtube
URL de Video remoto
Texto

     Configuración para ejecutar pruebas PHPUnit

     Antes de entrar en materia sobre el uso de Test Unitarios de Php, en Drupal 8 o 9, tendremos que familiarizarnos con esta actividad, conociendo sus fundamentos y las configuraciones iniciales.

     Prerrequisitos:

       - Asegúrate de que las dependencias de Composer estén instaladas

          Si haz realizado tu instalación de Drupal, utilizando composer desde el repositorio de Drupal.org, y quieres asegurarte de tener además, todas las dependencias necesarias para los test unitarios, puedes hacerlo escogiendo una de las siguientes opciones:

  1. Instalar Composer y ejecutar composer install (o actualizar tu Drupal 8 ó 9 existente, ejecutando composer update)
     
  2. Utilizar una versión de desarrollo (por ejemplo, 9.0.x-dev) en lugar de la que tienes en tu sitio actual.
     
  3. Instale las dependencias de desarrollo que necesita manualmente en el directorio de vendor de Drupal o en otro lugar.

     Yo voy a realizar una instalación de Drupal 8, nueva, utilizando la plantilla drupal/recommended-project, para eso en mi consola, ejecutaré el siguiente comando:

composer create-project drupal/recommended-project:^8 mi_drupal

     Si al instalar tu Drupal, haz utilizado la plantilla de Composer drupal/recommended-project, las dependencias de desarrollo pueden ser instaladas utilizando en tu proyecto una vez instalado, nos colocaremos en la carpeta root de Drupal y ejecutaremos el siguiente comando:

composer require --dev 'drupal/core-dev:^8.9'

 

    Si has instalado Drupal, utilizando git, entonces, instala composer y a continuación ejecuta el siguiente comando para que se descarguen las dependencias:

composer install

   Recuerda que las dependencias de desarrollo, nunca deben instalarse en una producción o en un servidor de acceso público, por razones de seguridad. Ver el announcement about our dev dependency packaging changes para más información.

   Las pruebas de Javascript tienen dependencias adicionales; consulta Running PHPUnit Javascript tests.

   Cómo configurar PHPUnit

   PHPUnit almacena la configuración en el archivo llamado phpunit.xml, ubicado dentro de la carpeta raíz de tu Drupal. Drupal viene con una versión de muestra de esto, puedes encontrarlo dentro de la carpeta core/phpunit.xml.dist, así podrías copiar este archivo para comenzar con tus pruebas.

 

   El lugar de tu archivo de configuración dependerá de tu flujo de trabajo:

  • El ejecutable PHPUnit espera encontrar el archivo de configuración phpunit.xml, dentro de tu carpeta raíz. Esto se puede anular con la opción -c.
     
  • Si estás utilizando Composer para administrar el núcleo de Drupal, la actualización del núcleo sobrescribirá el núcleo / carpeta y eliminará su archivo phpunit.xml

     Una vez hayamos copiado, desde el core/phpunit.xml.dist y renombrado nuestro archivo phpunit.xml, lo abriremos para añadir los siguientes cambios:

  • Añadiremos el valor a la variable SIMPLETEST_BASE_URL con la url de nuestro sitio.
     
  • Configuraremos la variable SIMPLETEST_DB para que apunte a la URL de la base de datos de nuestro Drupal.
     
  • Si estas colocando phpunit.xml en algún lugar que no sea core, tendrás que cambiar el valor del atributo 'bootstrap' de la etiqueta phpunit para reflejar la nueva ubicación.
     
  • Para pruebas funcionales y del kernel, establezca el BROWSERTEST_OUTPUT_DIRECTORY

     El resultado debería verse así:

<phpunit bootstrap="tests/bootstrap.php" colors="true"
         beStrictAboutTestsThatDoNotTestAnything="true"
         beStrictAboutOutputDuringTests="true"
         beStrictAboutChangesToGlobalState="true"
         printerClass="\Drupal\Tests\Listeners\HtmlOutputPrinter">

<php>
  <!-- Set error reporting to E_ALL. -->
  <ini name="error_reporting" value="32767"/>
  <!-- Do not limit the amount of memory tests take to run. -->
  <ini name="memory_limit" value="-1"/>
  <!-- Example SIMPLETEST_BASE_URL value: http://localhost -->
  <env name="SIMPLETEST_BASE_URL" value="http://drupal8.localhost"/>
  <!-- Example SIMPLETEST_DB value: mysql://username:password@localhost/databasename#table_prefix -->
  <env name="SIMPLETEST_DB" value="mysql://drupal8:drupal8@localhost/drupal8"/>
  <!-- Example BROWSERTEST_OUTPUT_DIRECTORY value: /path/to/webroot/sites/simpletest/browser_output -->
  <env name="BROWSERTEST_OUTPUT_DIRECTORY" value="/var/www/sites/simpletest/browser_output"/>
</php> 
</phpunit>

 

   Una vez hecho todo esto, podremos ejecutar cualquier prueba, sin tener que volver a realizar toda esta configuración. 

   Busque y reemplace rápidamente los valores con sed desde la línea de comando. Los valores de ejemplo son para Lando y se supone que estamos ubicados dentro de la carpeta principal de Drupal, al igual que el archivo de configuración phpunit.xml. Ajústalo para igualarlo a tu configuración:

$ cd core
$ cp phpunit.xml.dist phpunit.xml
$ sed -i 's|name="SIMPLETEST_BASE_URL" value=""|name="SIMPLETEST_BASE_URL" value="http://d8dev\.lndo\.site"|g' phpunit.xml
$ sed -i 's|name="SIMPLETEST_DB" value=""|name="SIMPLETEST_DB" value="mysql://drupal8:drupal8@database/drupal8"|g' phpunit.xml
$ sed -i 's|name="BROWSERTEST_OUTPUT_DIRECTORY" value=""|name="BROWSERTEST_OUTPUT_DIRECTORY" value="../sites/simpletest/browser_output"|g' phpunit.xml

     Creando un directorio para la salida HTML

        Las pruebas funcionales pueden generar las páginas HTML que ve el código de ejecución de la prueba. Estos se generan como archivos HTML sin formato. Para proporcionar una ubicación en la que escribirlos, crearemos un directorio llamado sites/simpletest y nos aseguraremos de que el servidor web pueda escribirlo. Está bien hacer que este directorio sea "world-writable", ej.:

mkdir -p sites/simpletest/browser_output
chmod -R 777 sites/simpletest

 

     Locate the PHPUnit binary

       La ubicación relativa del binario PHPUnit depende de cómo instale Drupal.

  • Si hemos instalado Drupal usando un paquete, ejecutaremos composer update, el directorio vendor está dentro de la raíz de Drupal (adyacente a 'core'). Las instrucciones en esta página asumen que esta es su configuración.
  • Si lo hicimos usando composer require drupal/drupal , terminas con un directorio de proveedores fuera de la raíz de Drupal (arriba del 'core'). Es posible que debamos ajustar la ruta a PHPUnit en los comandos que se dan en esta página:
    vendor/bin/phpunit se convertirá en ../vendor/bin/phpunit and ../vendor/bin/phpunit se convertirá en ../../vendor/bin/phpunit.

     Dependiendo de su flujo de trabajo de desarrollo, puede resultarle útil crear un link simbólico a PHPUnit desde / usr / local / bin ( cd /usr/local/bin; ln -s /var/www/html/vendor/bin/phpunit), o parecido, o añadir vendor/bin a tu PATH.

    Comprobando que se verifiquen las aserciones en tiempo de ejecución

        Al ejecutar pruebas de phpunit, es importante asegurarnos de que se verifiquen, las declaraciones de aserción en tiempo de ejecución. Consulte la nota sobre la ejecución de pruebas localmente en el  change notice about runtime assertions , para más información al respecto.

     Ejecutando pruebas

        Todos los comandos de ejemplo en este documento asumen que estamos dentro del directorio raíz  y nuestro archivo ejecutable de configuración phpunit.xml, se encuentra dentro de la carpeta core.

     Al ejecutar \Drupal\Tests\datetime\Unit\Plugin\migrate\field\DateFieldTest, por ejemplo, su comando se vería así:

../vendor/bin/phpunit modules/datetime/tests/src/Unit/Plugin/migrate/field/DateFieldTest.php

     Su ruta al ejecutable phpunit puede ser diferente a la anterior.

     Ejecute todas las pruebas unitarias de PHPUnit

        Para ejecutar las pruebas unitarias en OS X, Linux u otros sistemas * nix:

../vendor/bin/phpunit --testsuite=unit

     Nota: Todas las pruebas, incluidas las ubicadas en [drupalroot]/modules o [drupalroot]/sites/*/modules, se ejecutan desde la carpeta principal con el comando:

../vendor/bin/phpunit

 

     Debemos tomar en cuenta, que no necesita tener una instalación de Drupal en funcionamiento, para ejecutar pruebas unitarias basadas en PHPUnit de esta manera. Las pruebas de PHPUnit están aisladas de Drupal y no las necesitan para ejecutarse.

     En Windows, el enlace simbólico almacenado en vendor/bin/phpunit no funcionará. Debemos usar la ruta completa al ejecutable PHPUnit:

../vendor/phpunit/phpunit/phpunit

     Problemas de permisos

        Las pruebas funcionales deben invocarse con un usuario del mismo grupo que el usuario del servidor web. Puede configurar Apache (o Nginx) para que se ejecute como su propio usuario del sistema o ejecutar pruebas como un usuario privilegiado.

        Para desarrollar localmente, un enfoque sencillo, pero también menos seguro, es para ejecutar pruebas como su propio usuario del sistema. Para lograrlo, cambie el usuario Apache predeterminado para que se ejecute como su usuario del sistema. Normalmente, necesitaría modificar en Linux `/etc/apache2/envvars` o en Mac el `/etc/apache2/httpd.conf`

Fuente: https://www.drupal.org/node/2116263

Entity API | Introducción en Drupal 8/9

Video de Youtube
URL de Video remoto

Breve repaso sobre Programación Orientada a Objetos (OOP)

     La Programación Orientada a Objetos (OOP, Object Oriented Programming) es una manera de organizar el código que permite a los desarrolladores agrupar tareas similares en clases. Con esta implementación nuestro código se hace más fácil de mantener y evita repeteciones innecesarias (DRYDon't Repeat Yourself).

     Una de las ventajas de OOP es que si modificamos parte de la información en el script, normalmente sólo hace falta cambiarla en un sitio para actualizar el código. Por ejemplo si se ha usado un sistema de bases de datos como MySQL utilizando PDO (PHP Database Objects)  y queremos cambiar a otro, los métodos que utilizaremos para las sentencias serán los mismos.

     Una clase se puede ver como el esquema de una casa y un objeto como la casa ya construida. Esto significa que en la clase se define su estructura, sus medidas y características y las relaciones entre ellas y el objeto es la casa construida con todos los datos y organización definidos en ella. Se pueden construir las casas (objetos) que se quieran con esa estructura (clase), y cada una tendrá sus propias familias y decoración.

     Para definir una clase se utiliza la palabra reservada class, seguida del nombre de clase y dos llaves, entre las cuales se guardará toda la información del esquema. Esta información se guarda en propiedades (así es como se les llama a las variables dentro de las clases), métodos (funciones dentro de las clases) y constantes.

     El nombre de la clase puede ser cualquier etiqueta válida siempre que no sea una palabra reservada de PHP. Un nombre válido comienza con una letra o guión bajo, seguido de una cantidad arbitraria de letras, números o guiones bajos.

class NombreClase {
    // Declaración de una propiedad
    public $variable = 'Un valor cualquiera';
    // Declaración de un método
    public function mostrarVariable(){
        echo $this->variable;
    }
}

$this es una pseudo-variable que está disponible cuando una clase se instancia. La clase instanciada es un objeto, y $this hace referencia a ese objeto. Vamos a ver un ejemplo en el que se ve más claro a qué hace referencia $this:

class ClaseA {
    function funcionA()
    {
        if(isset($this)){
            echo '$this está definido, su clase es: ';
            // La función get_class devuelve el nombre de la clase de un objeto:
            echo get_class($this) . "<br>";
        } else {
            echo '$this no está definido <br>';
        }
    }
}
class ClaseB {
    function funcionB() {
        // Se llama estáticamente a la función A, pero ésta no es estática
        // Si E_STRICT está activado generará un aviso
        ClaseA::funcionA();
    }
} 

     Para crear una instancia de una clase, se utiliza la palabra new. Un objeto será creado siempre, a no ser que el objeto tenga un constructor definido y lance una excepción como error. Las clases han de definirse antes de instanciarse.

    Introducción a Entity API en Drupal 8/9

         Entity System es la API para la manipulación de entidades (CRUD: crear, leer, actualizar, eliminar). La validación de entidades tiene su propia API (que podría validar una entidad guardada a través de REST, en lugar de un formulario, por ejemplo).

     El sistema de entidades Drupal 8

          En Drupal las entidades son clases con sus respectivos métodos

 

 

Entidades Drupal | www.drupaladicto.com - Consultor especializado en drupal y symfony

     Ambos tipos están definidos y documentados en interfaces.

     Entidad de configuración y entidad de contenido

     Los tipos de entidad en el núcleo vienen en dos variantes.

     Entidad de configuración (Configuration Entity): Utilizado por el sistema de configuración. Admite traducciones y puede proporcionar valores predeterminados personalizados para las instalaciones. Las entidades de configuración se almacenan dentro de la tabla de la base de datos de configuración común como filas.

     Entidad de contenido (Content Entity): Consiste en campos configurables y base, y puede tener revisiones y traducciones de soporte. Las entidades de contenido se almacenan en una tabla de base de datos personalizada como filas. El nombre de la tabla es el mismo que el de la entidad de contenido "id", y las columnas se definen mediante el método "baseFieldDefinitions" de la entidad.

     Paquetes (Bundles)

        Los paquetes son diferentes variantes de un tipo de entidad. Por ejemplo, con el tipo de entidad de nodo, los paquetes son los diferentes tipos de nodo, como 'artículo' y 'página'.

        Normalmente, un paquete está representado por una entidad de configuración, aunque existen otros modelos en los módulos contrib. Entonces, en el ejemplo de nodo, el tipo de nodo 'artículo' es en sí mismo una entidad de configuración. La configuración almacena las diferencias entre los tipos de entidades de contenido, como la configuración y los campos. Al crear un nuevo tipo de entidad que tiene entidades de paquete, creará tanto una Entidad de contenido que administrará los detalles y operaciones del contenido, como una Entidad de configuración que manejará las diferencias entre los tipos de entidad de contenido.

     Anotaciones (Annotations):

          Al crear un nuevo tipo de entidad, deberá utilizar el sistema de anotaciones integrado en el núcleo. Las anotaciones parecen comentarios de docblock encima de la clase, pero el núcleo de Drupal las analiza y almacena en caché. En muchos sentidos, las anotaciones reemplazan algunos de los ganchos de estilo más antiguos utilizados en Drupal 7.

     Analizador de anotaciones (Annotation parser):

        Las anotaciones se leen y analizan en tiempo de ejecución mediante un motor de anotaciones. Drupal 8 usa el analizador de anotaciones de Doctrine, que lo convierte en un objeto que PHP puede usar.

       Sintaxis: la sintaxis de la anotación está rodeada por @ClassName (), se compone predominantemente de pares clave / valor y puede contener matrices que usan llaves. Las claves de nivel superior no deben estar entre comillas, mientras que las claves de matriz deben hacerlo. Cada par clave / valor debe estar en su propia línea, y esa línea debe terminar con una coma. Ciertas funciones se pueden ejecutar en valores, en particular la función @Translation ().

      Ejemplo de sintaxis de anotación que no funciona:

/**
 * @ContentEntityType(
 *   id = "my_entity_type_id",
 *   label = @Translation("My entity type label"),
 *   example_pair = "this_examples_value",
 *   example_array = {
 *     "array_key" = "array_value",
 *     "some_other_key" = "some_other_value",
 *   },
 * )
 */

Anotaciones comunes de nivel superior

 

 

Entidades Drupal | www.drupaladicto.com - Consultor especializado en drupal y symfony

     Manipuladores o (Handlers)

     Los controladores se definen en la anotación de la entidad como una matriz. Apoyan a la entidad al mapear ciertas partes de su ejecución a otras clases de PHP. Esas clases "manejarán" las partes asignadas de la ejecución de la entidad.

     Almacenamiento (Storage): maneja la carga, el guardado y la eliminación de la entidad. De forma predeterminada, las entidades de contenido usan Drupal \ Core \ Entity \ Sql \ SqlContentEntityStorage mientras que las entidades de configuración usan Drupal \ Core \ Config \ Entity \ ConfigEntityStorage. Puede definir un controlador de almacenamiento para ampliar los métodos de almacenamiento predeterminados de su entidad. Es posible que desee hacer esto para proporcionar métodos adicionales para recopilar los ID de revisión de la entidad o determinar el número de traducciones que tiene una entidad.

     Ejemplo: "storage" = "Drupal\node\NodeStorage",

     Formulario (Form): en la anotación de controladores de cualquier entidad, hay varios controladores de formularios que asignan los formularios de agregar, editar y eliminar de la entidad a otras clases de PHP.

     Ejemplo:

"form" = {
  "add" = "Drupal\block\BlockForm",
  "edit" = "Drupal\block\BlockForm",
  "delete" = "Drupal\block\Form\BlockDeleteForm",
}

     Alternativamente, puede definir un formulario "predeterminado" para manejar tanto el formulario de "agregar" como el de "editar" en lugar de definirlos por separado. Vale la pena señalar que el formulario "eliminar" casi siempre será manejado por una clase separada de los otros formularios. Esto se debe a que el formulario de eliminación es generalmente un "formulario de confirmación" que simplemente pregunta si el usuario está seguro de que desea eliminar la entidad.

     Creador de vistas (View builder): este controlador proporciona una clase que manejará la salida de la entidad cuando la vea el usuario final. Por ejemplo, al visitar un nodo en un sitio de Drupal 8, la salida de la entidad es manejada por la clase NodeViewBuilder.

     Ejemplo: "view_builder" = "Drupal\node\NodeViewBuilder",

     Generador de listas (List builder ): la clase del generador de listas manejará la lista de entidades con fines administrativos. Esta clase definirá el contenido de los encabezados, filas y operaciones cuando visite la página de administración de entidades para la entidad. Por ejemplo, al visitar el URI / admin / content de su sitio Drupal, el contenido de la tabla lo proporciona la clase de constructor de listas de la entidad Node.

   Ejemplo: "list_builder" = "Drupal\node\NodeListBuilder",

   Proveedor de ruta (Route provider): un controlador opcional que, si se implementa, genera rutas para la administración de su entidad. La implementación de este controlador puede reemplazar la necesidad de rutas de entidad definidas en el archivo routing.yml de su módulo. Tenga en cuenta que route_provider funciona junto con los enlaces definidos en su entidad (consulte el ejemplo a continuación en la sección Enlaces). La anotación route_provider es una matriz.
     Ejemplo:

"route_provider" = {
  "html" = "Drupal\Core\Entity\Routing\AdminHtmlRouteProvider",
}

     Acceso (Access): el controlador de acceso se puede usar para verificar dinámicamente los permisos de su entidad. Es una asignación a una clase que implementa EntityAccessControlHandlerInterface. Core proporciona una implementación de esta interfaz como EntityAccessControlHandler, pero para un control confiable sobre su entidad, querrá extender esa clase con la suya propia.

     Datos de vistas (Views data): el controlador views_data permite que una entidad amplíe el módulo Vistas con datos personalizados proporcionados por su entidad. Esto puede ser para agregar baseFieldDefinitions de su entidad como campos de Vistas, unir tablas en relaciones de entidad u otras alteraciones de datos relacionadas con Vistas.

     Ejemplo: "views_data" = "Drupal\node\NodeViewsData",

     Esquema de almacenamiento (Storage schema): el controlador storage_schema se puede implementar para modificar aún más la configuración de almacenamiento de la base de datos de la entidad. Por ejemplo, agregar índices de tabla adicionales.

     Ejemplo: "storage_schema" = "Drupal\node\NodeStorageSchema",

     Traducción (Translation): el controlador de traducción se puede utilizar para modificar la forma en que los formularios de su entidad interactúan con las traducciones.

     Ejemplo: "translation" = "Drupal\node\NodeTranslationHandler",

  Ejemplo completo de Manipuladores (handlers):

     El núcleo de Drupal proporciona controladores que puede usar listos para usar, pero en muchos casos querrá extender estas clases con las suyas propias para un mayor control y personalización de su entidad. Este ejemplo muestra una anotación de controladores más completa, utilizando las clases principales que puede ampliar.

handlers = {
  "view_builder" = "Drupal\Core\Entity\EntityViewBuilder",
  "list_builder" = "Drupal\Core\Entity\EntityListBuilder",
  "access" = "Drupal\Core\Entity\EntityAccessControlHandler",
  "views_data" = "Drupal\views\EntityViewsData",
  "storage" = "Drupal\Core\Entity\Sql\SqlContentEntityStorage",
  "storage_schema" = "Drupal\Core\Entity\Sql\SqlContentEntityStorageSchema",
  "translation" = "Drupal\content_translation\ContentTranslationHandler",
  "form" = {
    "default" = "Drupal\Core\Entity\ContentEntityForm",
    "add" = "Drupal\Core\Entity\ContentEntityForm",
    "edit" = "Drupal\Core\Entity\ContentEntityForm",
    "delete" = "Drupal\Core\Entity\ContentEntityDeleteForm",
  },
  "route_provider" = {
    "html" = "Drupal\Core\Entity\Routing\AdminHtmlRouteProvider",
  },
},

     Enlaces:

         Los enlaces se definen en la anotación de entidad con la sintaxis de matriz. Los enlaces tienen un conjunto específico de claves cuyo valor son URI donde se puede administrar el tipo de entidad o entidades individuales de ese tipo. Tanto las entidades de contenido como las de configuración pueden tener estos enlaces definidos.

     Ejemplo:

id = "node",
handlers = {
  "route_provider" = {
    "html" = "Drupal\Core\Entity\Routing\AdminHtmlRouteProvider"
  }
},
links = {
  "canonical" = "/node/{node}",
  "add-page" = "/node/add",
  "add-form" = "/node/add/{node_type}",
  "edit-form" = "/node/{node}/edit",
  "delete-form" = "/node/{node}/delete",
  "collection" = "/admin/content",
},

     La creación de estos enlaces no crea automáticamente las rutas para esos URI. Para que estos enlaces sean accesibles, nuestro módulo deberá implementar su propio archivo routing.yml o usar un controlador "route_provider" en la anotación de la entidad.

     Enlaces y proveedor de rutas (Links & Route Provider):

     Los enlaces anteriores que trabajan junto con un "route_provider" harán que las siguientes rutas nombradas estén disponibles para Drupal.

 

Entidades Drupal | www.drupaladicto.com - Consultor especializado en drupal y symfony

     Uso de enlaces:

          Se puede acceder a estos enlaces con el método toUrl () de una entidad:

$view_url_object = $entity->toUrl();  // Default is 'canonical'
$edit_url_string = $entity->toUrl('edit-form')->toString();

Fuente: Página oficial de Drupal

Tipos de entidad en Drupal 9

Video de Youtube
URL de Video remoto
Texto

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

     Siguiendo con el aprendizaje sobre la API de Drupal, hoy nos toca hablar sobre los Tipos de entidades.

     En Drupal 7, las entidades eran objetos stdClass genéricos.

     A partir de Drupal 8, las entidades ahora son objetos de tipo específico, y cada tipo de entidad define una clase que se utilizará para las instancias de la entidad dada.

Tipos de entidad Drupal | www.drupaladicto.com - Consultor especializado en drupal y symfony

     Requerimientos:

          Las clases de entidad (Entity classes), deben colocarse en el subespacio de nombres de entidad del módulo que proporciona el tipo de entidad, p. Ej. \ Drupal \ [nombre_módulo] \ Entidad. Esto significa que los archivos PHP de clase de entidad se pueden encontrar en el directorio src / Entity de un módulo.

Tipos de entidad Drupal | www.drupaladicto.com - Consultor especializado en drupal y symfony

          El docblock de la clase debe contener una anotación EntityType que defina los metadatos para las entidades de ese tipo. Estos incluyen cosas como la etiqueta del tipo de entidad, controladores, tablas, etc. Para obtener una lista documentada de todas las propiedades de metadatos disponibles, consulte la clase \Drupal\Core\Entity\Annotation\EntityType Haz clic aquí.

Tipos de entidad Drupal | www.drupaladicto.com - Consultor especializado en drupal y symfony

     Nomenclatura del Tipo de entidad:

          Los nombres de tipo de entidad deben tener el prefijo del nombre del módulo si el tipo de entidad y el nombre del módulo no son los mismos. No es necesario prefijar la clase del tipo de entidad en sí, ya que vive dentro del espacio de nombres del módulo de definición, siempre que sea lo suficientemente significativo por sí mismo. Por ejemplo, el tipo de entidad para los términos de taxonomía se denomina taxonomy_term y el nombre de la clase es Drupal \ taxonomy \ Entity \ Term.

     Interfaces:

          Drupal 8 recomienda que escriba funciones y métodos con interfaces en lugar de clases. Por ejemplo, para las entidades genéricas utilizaremos los métodos y propiedades de EntityInterface como en hook_entity_insert(EntityInterface $entity) y para trabajar con nodos específicos, utilizaremos los métodos y propiedades de NodeInterface como en hook_node_insert(NodeInterface $node).

Tipos de entidad Drupal | www.drupaladicto.com - Consultor especializado en drupal y symfony

Tipos de entidad Drupal | www.drupaladicto.com - Consultor especializado en drupal y symfony

         Los campos / propiedades de las entidades suelen ser muy breves, centrados en el almacenamiento y no muy autodescriptivos. Además, las entidades de contenido no usan propiedades definidas para sus campos (incluidos los campos base como el título del nodo) en absoluto.

          Por lo tanto, el enfoque recomendado es proporcionar una interfaz con nombres de métodos documentados. Algunas reglas a seguir al hacerlo:

  • Los métodos suelen tener un prefijo get / set / is o similar: getSomething (), setSomething ($ value), isSomething ().
     
  • Solo agregue métodos para cosas que se supone que debe cambiar otro código. No se supone que se cambie la fecha de último cambio de los nodos ($node->changed), por lo que hay $node->getChangedTime(), pero no el método $node->setChangedTime().
     
  • Utilice nombres de métodos autodescriptivos, por ejemplo, el método para acceder a $node->status se llama $node->isPublished().

     Capacidad de rastreo o Visibilidad (Discoverability):

          Para averiguar qué tipos de entidad proporciona un módulo, consulte las clases en el subespacio de nombres de Entidad de ese módulo que tienen una anotación @EntityType, que también contiene el nombre en la clave de anotación de id.

          Al intentar encontrar dónde se define un tipo de entidad dado, lo primero que debe buscar es el prefijo del tipo de entidad. Si un módulo no sigue esa convención de nomenclatura, se puede encontrar buscando id = "$type". Si se conoce la clase o interfaz en lugar del tipo de entidad, entonces el namespace indica de dónde proviene.

Fuente: https://www.drupal.org/docs/drupal-apis/entity-api/entity-types

Drupal Behaviors | Javascript y librerías Jquery en Drupal 9

Video de Youtube
URL de Video remoto
Texto

    Recientemente, en un proyecto que estoy desarrollando en Drupal 9, tuve que buscar la manera de integrar parte del código, con llamadas realizadas en JavaScript hacia un servidor de Sharepoint, sin la necesidad de implementar webservice, la idea era reaprovechar un código que ya funcionaba correctamente, sin guardar nada en la base de datos de Drupal y como requisito adicional, debía utilizar una librería de Jquery diferente a la que trae el núcleo de Drupal 9, para ser más específico, se trataba de la versión "jquery-3.5.1.min.js".

     El objetivo de este desarrollo era realizar varias llamadas al servidor externo, aprovechando la modificación de una línea del código, para obtener el resultado que íbamos a mostrar dentro de la página, o sea, que en lugar de cargar la librería en el archivo "MITEMA.libraries.yml", haciendo una llamada al "global-styling", para que estuviera accesible desde cualquier punto de la web, opté por llamar directamente en las plantillas específicas al archivo "codigo_personalizado.js", sin tener que cargarlo innecesariamente.

     Por esta razón he querido compartir los pasos que deberás seguir, primero para añadir en tu proyecto Drupal 9, una librería de jquery diferente a la que tienes en el núcleo de Drupal, y luego, mostrarte cómo realizar las llamadas a tus archivos js, desde la o las plantillas ".twig" que tengas en tu proyecto.

     Si quieres saber más sobre el uso de librerías de javascript y Css, puedes visitar la Página oficial de Drupal, donde también te lo cuenta con varios ejemplos, para que puedas elegir el que más te convenga.

     PASOS PARA INSTALAR UNA LÍBRERÍA JQUERY EXTERNA EN TU TEMA PERSONALIZADO:

     Lo primero que deberías saber es Cómo crear un tema personalizado con Bootstrap 3 o Cómo crear un tema personalizado con Bootstrap Barrio, así podrás familiarizarte con los archivos que componen un tema y entenderás más fácilmente la forma de aplicar cambios, como la creación de librerías.

     PASO 1 AÑADIR LA LIBRERÍA EN EL ARCHIVO LIBRARIES DEL SUBTEMA:

     Partiendo de que ya tienes un subtema instalado en tu proyecto, si quieres añadir una librería externa, bastará con que copies el código que te muestro a continuación, en la parte inferior del archivo donde definimos las librerías del tema, ej.: "MITEMA.libraries.yml", recordando siempre el uso de los espacios, porque de lo contrario los archivos .yml no funcionarán.

jquery-custom:
  remote: https://github.com/jquery/jquery
  version: "3.5.1"
  license:
    name: MIT
    url: https://github.com/jquery/jquery/blob/3.5.1/LICENSE.txt
    gpl-compatible: true
  js:
    js/jquery-3.5.1.min.js: { minified: true, weight: -20 }

 

     Con este código le estamos asignado el nombre "jquery-custom", a nuestra libería y de esta forma podremos llamarla desde cualquier plantilla, mediante el código siguiente:

     PASO 2 LLAMAR A LA LIBRERÍA DESDE LA PLANTILLA:

     Dentro de la plantilla que quieras llamar a la librería o archivos js que quieras, tendrás que colocar el siguiente código, sustituyendo el nombre del tema, por el que haz utilizado para tu proyecto.

{# In a Twig template we attach the library. #}
{{ attach_library('MITEMA/jquery-custom') }}

 

     CÓMO CREAR ARCHIVOS JAVASCRIPT Y FUNCIONES DENTRO DE DRUPAL 9: 

     Lo último que te quiero contar, es cómo puedes añadir tus propias funciones de javascript, sin tener conflictos de código. Ahora que ya sabes la forma de agregar una librería de Jquery, diferente a la versión de tu proyecto, lo que nos falta es cómo intengrar funciones o código dentro de mi tema para que se ejecute correctamente.

     Una vez creado el archivo con el nombre ej:  "codigo_pesonalizado.js", y colocado en la carpeta correspondiente dentro de tu tema, ya sólo nos queda comenzar a escribir el resto de nuestro desarrollo.

(function ($, Drupal) {
  'use strict';

  Drupal.behaviors.micodigo = {
    attach : function(context, settings) {

       //PUEDES PONER AQUÍ TU CÓDIGO

    }
  };

})(jQuery, Drupal); 

     A partir de ahora ya podrás añadir funcionalidades de JavaScript o Jquery, dentro de cualquier tipo de plantilla en Drupal 9, ofreciendo mayores alternativas y soluciones para todos tus proyectos.

 

    Si quieres conocer un poco más visitando la página oficial de Drupal, HAZ CLIC AQUÍ

Entity Api | Trabajando con entidades en Drupal 9

Video de Youtube
URL de Video remoto
Texto

Al trabajar con entidades, en nuestros módulos personalizados, podremos realizar todo tipo de comprobaciones, para asegurarnos de obtener los cambios o respuestas que esperamos según su tipo o relación.

 

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

     Esta vez nos toca abordar el tema de Cómo trabajar con la API de entidades en Drupal 9 o (Entity API). Como mencionamos en el capítulo anterior sobre Tipos de entidad en Drupal 9, a partir de Drupal 8 se recomienda que escribamos funciones y métodos con interfaces en lugar de clases.

     ¿Que son las Interfaces?

     Según la documentación oficial de PHP, en la programación orientada a objetos (OOP), las interfaces de objetos permiten crear código con el cual especificar qué métodos deben ser implementados por una clase, sin tener que definir cómo estos métodos son manipulados.

     Las interfaces se definen de la misma manera que una clase, aunque reemplazando la palabra reservada class por la palabra reservada interface y sin que ninguno de sus métodos tenga su contenido definido.

     Todos los métodos declarados en una interfaz deben ser públicos, ya que ésta es la naturaleza de una interfaz.

     Para implementar una interfaz, se utiliza el operador implements. Todos los métodos en una interfaz deben ser implementados dentro de la clase; el no cumplir con esta regla resultará en un error fatal. Las clases pueden implementar más de una interfaz si se deseara, separándolas cada una por una coma.

Entidades Drupal | www.drupaladicto.com - Consultor especializado en drupal y symfony

     En Drupal, para las entidades genéricas utilizaremos los métodos y propiedades de EntityInterface como en hook_entity_insert(EntityInterface $entity) y para trabajar con nodos específicos, utilizaremos los métodos y propiedades de NodeInterface como en hook_node_insert(NodeInterface $node).

Entidades Drupal | www.drupaladicto.com - Consultor especializado en drupal y symfony

Entidades Drupal | www.drupaladicto.com - Consultor especializado en drupal y symfony

     Los métodos que cubren la mayoría de nuestras necesidades, cuando trabajamos con entidades genéricas son:

  • Entity::create()
     
  • Entity::load()
     
  • Entity::save()
     
  • Entity::id()
     
  • Entity::bundle()
     
  • Entity::isNew()
     
  • Entity::label()

    Comprobación de entidades (Check):

         Al trabajar con entidades, en nuestros módulos personalizados, podremos realizar todo tipo de comprobaciones, para asegurarnos de obtener los cambios o respuestas que esperamos según su tipo o relación.

         A continuación los ejemplos más frecuentes, en las operaciones de comprobación con entidades:

// Asegúrese de que un objeto sea una entidad.
if ($entity instanceof \Drupal\Core\Entity\EntityInterface) {
}

// Asegúrate de que sea una entidad de contenido.
if ($entity instanceof \Drupal\Core\Entity\ContentEntityInterface) {
}
// o también:
if ($entity->getEntityType()->getGroup() == 'content') {
}

// Obtener el tipo de entidad o el ID del tipo de entidad.
$entity->getEntityType();
$entity->getEntityTypeId();

// Asegúrate de que sea un nodo.
if ($entity instanceof \Drupal\node\NodeInterface) {
}

// El uso de entityType () funciona mejor cuando el tipo de entidad necesario es dinámico.
$needed_type = 'node';
if ($entity->getEntityTypeId() == $needed_type) {
}

     Obtener información de una entidad / métodos de entidad:

     Existe varios métodos genéricos disponibles para obtener información de una entidad, como el ID, el paquete, el ID de revisión, etc. Consulte la documentación de EntityInterface para obtener más detalles.

// Obtiene el ID de la entidad.
$entity->id();

// Obtiene el paquete.
$entity->bundle();

// Comprueba si la entidad es nueva.
$entity->isNew();

// Obtén la etiqueta de una entidad. Reemplazo de entity_label().
$entity->label();

// Obtener el objeto URL de una entidad.
$entity->toUrl();

// Obtener ruta interna, alias de ruta si existe, para una entidad.
$entity->toUrl()->toString();

// Cree un duplicado que se pueda guardar como una nueva entidad.
$duplicate = $entity->createDuplicate();

     Creación de entidades:

// Es recomendable que utilicemos el Entity Manager para crear entidades.
$node = \Drupal::entityTypeManager()->getStorage('node')->create(['type' => 'article', 'title' => 'Another node']);


// Podemos usar el método estático create () si conocemos la clase de entidad.
$node = Node::create([
  'type' => 'article',
  'title' => 'The node title',
]);

     Los valores predeterminados de configuración de la anotación de tipo de campo solo se agregan para las claves de nivel superior que faltan; no se realiza una fusión profunda.

     Evita usar el método estático Entity::create() en código orientado a objetos. En su lugar, use la inyección de dependencia para inyectar el administrador de tipos de entidad y crear la entidad con $this->entityTypeManager->getStorage($entity_type)->create(). Esto asegura que el código esté desacoplado correctamente y se pueda probar unitario.

     Si quieres saber más sobre la Inyección de Dependencias, te lo cuento en este artículo: Cómo crear un servicio personalizado en Drupal 9

     Para lograr la visibilidad dentro de un IDE, también puede asignar la interfaz de almacenamiento de la entidad a una propiedad. Por ejemplo, $this->nodeStorage = $this->entityTypeManager->getStorage('node'); Para crear una entidad, puede usar $this->nodeStorage->create().

     Carga de entidades (Load):

// Usando el controlador de almacenamiento (recomendado).
$entity = \Drupal::entityTypeManager()->getStorage($entity_type)->load(1);

// Usa el método estático
$node = Node::load(1);

// Carga varias entidades, también existe como entity_load_multiple().
$entities = \Drupal::entityTypeManager()->getStorage($entity_type)->loadMultiple([1, 2, 3]);

// Cargar entidades por sus valores de propiedad.
$entities = \Drupal::entityTypeManager()->getStorage('node')->loadByProperties(['type' => 'article']);

     Para actualizar una entidad, cárguela y luego guárdela con sus cambios.

         Evite usar el método estático Entity::load() en código orientado a objetos. En su lugar, use la inyección de dependencia para inyectar el administrador de tipos de entidad y cargar la entidad con $this->entityTypeManager->getStorage($entity_type)->load($entity_id). Esto asegura que el código esté desacoplado correctamente y se pueda probar unitario.

          Si quieres saber más sobre la Inyección de Dependencias, te lo cuento en este artículo: Cómo crear un servicio personalizado en Drupal 9

     Guardar los cambios en la entidad (Save):

// Para guardar los cambios en una entidad.
$entity->save();

     Eso funciona tanto para entidades nuevas como existentes, la propia entidad realiza un seguimiento de si es nueva o no. De forma predeterminada, para las entidades de contenido, eso depende de si tiene un ID o no. Para guardar una entidad que tiene un ID como una entidad nueva (por ejemplo, al importar algo), se puede aplicar la marca isNew.

// Lo siguiente intentará insertar un nuevo nodo con el ID 5, esto fallará si ese nodo ya existe.
$node->nid->value = 5;
$node->enforceIsNew(TRUE);
$node->save();

     Eliminar entidades (Delete):

// Eliminar una sola entidad.
$entity = \Drupal::entityTypeManager()->getStorage('node')->load(1);
$entity->delete();

// Elimina varias entidades a la vez.
\Drupal::entityTypeManager()->getStorage($entity_type)->delete([$id1 => $entity1, $id2 => $entity2]);

    Consultando entidades (Query):

$entity = \Drupal::entityTypeManager()->getStorage('node');
$query = $entity->getQuery();
    
$ids = $query->condition('status', 1)
 ->condition('type', 'article')#type = ID de paquete (nombre de la máquina)
 #->sort('created', 'ASC') #ordenada
 #->pager(15) #límite de 15 artículos
 ->execute();

// Cargar carga de artículo único o múltiple($id)
$articles = $entity->loadMultiple($ids);

     Control de acceso a entidades (Access control):

     El método access() se puede utilizar para comprobar quién puede hacer qué con una entidad. El método admite diferentes operaciones, las operaciones estándar son ver, actualizar, eliminar y crear, crear es algo especial, ver más abajo.

     Las comprobaciones de acceso se envían al controlador de acceso.

// Verifique el acceso a la vista de una entidad.
// De forma predeterminada, se verifica el acceso del usuario que ha iniciado sesión actualmente..
if ($entity->access('view')) {

}

// Compruebe si un usuario determinado puede eliminar una entidad.
if ($entity->access('delete', $account)) {

}

     Al marcar el acceso de creación, generalmente no hay una entidad todavía. Crear uno solo para comprobar si alguien podría crearlo es una operación costosa. Por lo tanto, la creación de acceso para aquellos debe verificarse directamente en el controlador de acceso.

\Drupal::entityTypeManager()->getAccessControlHandler('node')->createAccess('article');

     Si ya existe una entidad, $entity->access('create') también funciona, que solo reenvía al método  createAccess(), de la misma manera que otras operaciones reenvían al método access () en el controlador de acceso.

     NOTA: Algunas guías en línea usan \Drupal::entityManager(), pero está obsoleto en 8.x y se eliminará en 9.x. Entonces puede usar \Drupal::entityTypeManager() en lugar de \Drupal::entityManager().

Fuente: https://www.drupal.org/docs/drupal-apis/entity-api/working-with-the-entity-api#s-delete