programacion
Views | Personalizar vistas con plantillas (Parte 2)
Video de Youtube
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
Ahora que ya conocemos todos los requerimientos para poder modificar nuestras vistas, utilizando las plantillas Twig, vamos a explicar, el proceso de modificación de las vistas.
Cómo modifcar una vista de Campos con formato Lista desordenada
Lo primero que debemos tomar en cuenta es que para modificar el aspecto de una vista, podremos utilizar más de una plantilla, ya que dentro de ellas tenemos varios elementos, como el estilo para la vista en sí, que podría ser en cuadrículas (Grid), lista html, tabla o lista (Lista ordenada o Lista desordenada).
Cada uno de estos estilos tiene su propia plantilla y con ella podremos configurar diferentes maneras de presentar los resultados.
Pero además de reescribir el aspecto de la vista en general, podemos modificarla en función del estilo para sus filas, que cambiarán en función de si presentamos los contenidos, los campos de los contenidos o el resultado de la búsqueda.
Al igual que para la vista general, tendremos disponibles una plantilla que nos permitirá modificar, tanto el conjunto de datos mostrados (Filas de la vista), como a nivel individual.
Dónde podemos encontrar las plantillas para las vistas
A partir de Drupal 8, el módulo Views se integró como parte de su núcleo, por lo tanto, nos viene instalado por defecto y todas las plantillas, al igual que el resto de módulos integrados en el núcleo, podremos encontrarlos en la ubicación: web/core/modules
Por lo tanto, todas las plantillas para modificar cualquiera de las vistas, estarán alojadas en la ubicación:
web/core/modules/views/templates
Cómo especificar la vista afectada por la plantilla
Al trabar con plantillas debemos tener en cuenta que podremos modificar, todos los tipos de contenido o vistas similares o podremos modificar sólo algunos tipos de contenido o vistas en concreto.
Para modificar una vista concreta, tendremos que añadir al nombre de la plantilla, el nombre máquina de nuestra vista; para ello, a continuación del nombre de la plantilla, añadiremos dos guiones ( -- ), seguidos del nombre máquina de nuestra vista.
Por ejemplo, en nuestro caso, nuestra vista es de tipo Campos (Fields), así que la plantilla que tendremos que seleccionar será la llamada views-view-fields.html.twig, si sólo queremos que la plantilal afecte a nuestra vista factura, debemos copiarla dentro de la carpeta templates de nuestro subtema, y renombrarla de forma parecida a la siguiente:
views-view-fields--facturas.html.twig
También podremos añadir el nombre de sistema, que encontrarmos al editar la vista, en el apartado de Avanzados, para ello, añadiremos un guión medio más y luego, sustituiremos los guiones bajos por guiones medios:
views-view-fields--facturas--page-1.html.twig
Una vez nombrada correctamente la plantilla para nuestra vista, y estando guardada dentro de la carpeta templates de nuestro tema, borraremos la cache de Drupal, si exploramos la vista, haciendo clic derecho y seleccionando explorar o presionando la tecla F-12, deberíamos ver un resultado como el siguiente:
Entonces, haremos la siguiente prueba para verificar tenemos control sobre el aspecto de la vista, la idea es saber en qué línea añadiremos los cambios deseados.
Para ello, vamos a copiar la siguientes líneas sustituyendo el contenido de la plantilla:
{% for field in fields -%}
{{ field.separator }}
{%- if field.wrapper_element -%}
<{{ field.wrapper_element }}{{ field.wrapper_attributes }}>
{%- endif %}
{%- if field.label -%}
{%- if field.label_element -%}
<{{ field.label_element }}{{ field.label_attributes }}>{{ field.label }}{{ field.label_suffix }}</{{ field.label_element }}>
{%- else -%}
{{ field.label }}{{ field.label_suffix }}
{%- endif %}
{%- endif %}
{%- if field.element_type -%}
<{{ field.element_type }}{{ field.element_attributes }}>{{ field.content }}MODIFICAR-1</{{ field.element_type }}>
{%- else -%}
{{ field.content }}MODIFICAR-2
{%- endif %}
{%- if field.wrapper_element -%}
</{{ field.wrapper_element }}>
{%- endif %}
{%- endfor %}
Si guardamos los cambios y accedemos a la vista, podremos comprobar la línea exacta donde se afectara la información mostrada en la vista:
En nuestro caso, hemos añadido las palabras MODIFICAR-1 y MODIFICAR-2, en las líneas donde se imprime el contenido de los campos, para saber en cuál de ellas tendremos acceso a los datos mostrados.
Cómo imprimir los valores de los campos en la plantilla
Ahora que ya tenemos claro la línea de la plantilla donde podremos imprimir los valores deseados, nos falta tener en cuenta dos cosas:
- Sólo podremos imprimir en la plantilla los campos que se muestran en la vista, por lo tanto, primero los agregaremos en la pantalla de configuración de la vista y así luego podremos imprimirlos en la plantilla.
- Podremos configurar el valor del campo desde la pantalla de configuración de la vista, antes de imprimirlo mediante la plantilla.
Para poder imprimir el valor de los campos de la vista, dentro de la plantilla, añadiremos el nombre del campo, siguiendo esta estructura:
{{ fields.nombre_del_campo.content }}
Esto nos permitirá crear cualquier tipo de estructura, combinando los campos, sin importar el orden en que se muestren dentro de la configuración de la vista.
PRUEBA 1 - Impresión de campos con plantilla
Para comprobar todo lo anterior, ahora lo que haremos será copiar el siguiente código, sustituyendo todo el contenido de nuestra plantilla por los valores correspondientes a tu vista y a continuación, refrescaremos el cache de Drupal para ver los resultados.
{% for field in fields -%}
{{ field.separator }}
{%- if field.wrapper_element -%}
<{{ field.wrapper_element }}{{ field.wrapper_attributes }}>
{%- endif %}
{%- if field.label -%}
{%- if field.label_element -%}
<{{ field.label_element }}{{ field.label_attributes }}>{{ field.label }}{{ field.label_suffix }}</{{ field.label_element }}>
{%- else -%}
{{ field.label }}{{ field.label_suffix }}
{%- endif %}
{%- endif %}
{%- if field.element_type -%}
<{{ field.element_type }}{{ field.element_attributes }}>
<div class="caja" style="border: 2px solid; padding: 10px 5px">
<div class="imagen">
{{ fields.field_imagen_reforma.content }}
</div>
<div class="detalles">
<h1>{{ fields.title.content }}</h1>
<span>{{ fields.field_fecha_de_inicio.content }}</span><br/>
<span>{{ fields.field_fecha_de_entrega.content }}</span>
</div>
</div>
</{{ field.element_type }}>
{%- else -%}
{{ field.content }}
{%- endif %}
{%- if field.wrapper_element -%}
</{{ field.wrapper_element }}>
{%- endif %}
{%- endfor %}
Para ver mejor el resultado de los datos, cambiaremos el estilo de la vista por Cuádricula (Grid) en lugar de Lista sin formato, deberías ver algo parecido a lo siguiente:
Seleccionado el estilo GRID y dejando todo lo demás por defecto, el resultado será el siguiente:
La vista de Facturas, ahora presenta algo de estructura, pero se ven duplicados todos los resultados, ya que sólo deberían mostrarse las cinco facturas que tenemos creadas en el contenido.
Esto se debe a que por defecto, Drupal depura los elementos que necesita de sus plantillas, de esta manera si dejáramos la plantilla por defecto y sólo configuráramos la interfaz de usuario, obtendríamos el mismo resultado en ambos lados, pero como en nuestro caso estamos reescribiendo la plantilla, necesitaremos eliminar todo lo innecesario para nosotros.
Copia el siguiente código, sustituyendo todo lo que tenías antes en tu plantilla:
<div class="caja" style="border: 2px solid; padding: 10px 5px">
<div class="imagen">
{{ fields.field_imagen_reforma.content }}
</div>
<div class="detalles">
<h1>{{ fields.title.content }}</h1>
<span>{{ fields.field_fecha_de_inicio.content }}</span><br/>
<span>{{ fields.field_fecha_de_entrega.content }}</span>
</div>
</div>
Ahora si guardas los cambios y borras nuevamente la cache de Drupal, al visitar la vista, deberías obtener el resultado esperado:
Cómo imprimir las etiquetas de los campos
Ahora que ya sabemos que dejaremos en las plantillas personalizadas para las vista, solamente los valores que necesitemos imprimir, echamos en falta las etiquetas que ya hemos activado en la configureación de la vista, pero que no vemos en nuestro resultado final.
Para imprimir las etiquetas, en caso de que lo necesites, lo único que tendrás que hacer es añadir la estructura siguiente, que consta del nombre del campo, sustituyendo el final por la palabra label en lugar de content.
{{ fields.nombre_del_campo.label }}
Por lo tanto, si quieres imprimir los campos con sus etiquetas, además del valor correspondiente a cada uno de ellos, deberías añadir la siguiente estructura
{{ fields.nombre_del_campo.label }} {{ fields.nombre_del_campo.content }}
PRUEBA final - Impresión de campos con plantilla
Copia y sustituye el código de la plantilla por el siguiente, para comprobar que se imprimen todos los campos, con algunas de las etiquetas añadidas en la configuración de la vista:
<div class="caja" style="border: 2px solid; padding: 10px 5px">
<div class="imagen">
{{ fields.field_imagen_reforma.content }}
</div>
<div class="detalles">
<h1>{{ fields.title.content }}</h1>
<strong>{{ fields.field_fecha_de_inicio.label }}</strong><br/>
<span>{{ fields.field_fecha_de_inicio.content }}</span><p>
<strong>{{ fields.field_fecha_de_entrega.label }}</strong><br/>
<span>{{ fields.field_fecha_de_entrega.content }}</span>
</div>
</div>
El resultado final, debería ser algo parecido a la siguiente imagen:
Views | Personalizar vistas con plantillas (Parte 1)
Video de Youtube
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
Entre los módulos más utilizados y potentes con los que cuenta Drupal, por defecto a partir de Drupal 8, el el módulo Views o Vistas, que nos permite crear consultas de todo tipo, através de su interfaz de usario.
Ya hemos explicado varias de las maneras de configuración de vistas en anteriores capítulos, pero hoy nos concentraremos en la manera de reescribir los resultados que se muestran, para que podamos darle un aspecto específico, manteniendo el control de su aspecto y de la manera en que se presentarán los datos.
Si quieres aprender más sobre el uso de las vistas HAZ CLIC AQUÍ
Cómo personalizar la plantilla para una vista
Paso 1 - Crear un tema personalizado
Para que Drupal reconozca nuestras plantillas, tendremos que crear un tema personalizado. Para ello podremos elegir entre varias opciónes:
Subtema basado en Radix, HAZ CLIC AQUI
Subtema basado en Bootstrap 3, HAZ CLIC AQUI
Subtema basado en Boostrap Barrio, HAZ CLIC AQUÍ
Cómo crear un Subtema basándonos en Bartik o cualquier otro tema del Core de Drupal
Si queremos crear un subtema, de la forma más sencilla, podremos utilizar cualquiera de los que trae Drupal por defecto, por ejemplo el Tema Bartik. Para crear un subtema, basándonos en cualquiera de los del core, sigue estos pasos:
1.- Colócate en la carpeta themes, a continuación, añade una carpeta custom, donde deberás alojar cualquiera de tus temas personalizados. Luego, dentro de ella, crea una nueva carpeta con el nombre de tu Subtema.
2.- Dentro de la carpeta de tu Subtema, crear un archivo, con el mismo nombre de tu carpeta, terminado en .info.yml, es decir, si tu Subtema se llama mitema, entonces, crearás un archivo llamado mitema.info.yml y a continuación, copia y pega el siguiente código dentro de él.
name: Subtema Bartik description: Subtema creado a partir de Bartik type: theme core_version_requirement: ^8 || ^9 base theme: bartik
3.- Finalmente Actívalo desde la interfaz de Drupal, para que sea tu tema por defecto. Para tus plantillas, añadirás, una carperta Templates y si quieres que tenga el mismo logo de Drupal, como en este ejemplo, sólo tendrás que copiarlos desde el Tema Padre.
- También puedes activar el tema y configurarlo como tema por defecto, a través de la consola, ejecutando el siguiente comando de Drush:
drush config-set system.theme default Subtheme_name -y
Paso 2 - Activar el modo Debug o Depurador
Si vamos a trabajar con archivos de Drupal, en este caso, con las plantillas Twig, tendremos que conocer el nombre de la o las plantillas que afectan al contenido que vamos a modificar. Para ello, activaremos el modo depurado de Drupal, que nos permitirá conocer la ubicación de las Plantillas Modelo, así como el nombre que tendremos que ponerle, en caso de querer modificar un tipo de contenido, un bloque, una vista, etc.
Para saber cómo activar el Modo Depurador o Debug, HAZ CLIC AQUÍ
Paso 3 - Crear la vista que vamos a modificar
Cuando trabajas con vistas, podrás decidir varias maneras de mostrar sus contenidos y de acuerdo con la opción que elijas, tendrás que utilizar la plantilla relacionada con el tipo de contenido, o la plantilla que afecta directamente el tipo de vista con el que haz decidido trabajar.
En este artículo trabajaremos con el tipo de contenido Factura, un tipo de contenido con varios campos de texto, fechas y un campo imagen, para que sea más gráfico el ejemplo.
Así que seleccionaremos el tipo de contenido que vamos a mostar y, a continuación, en el selector para elegir nuestra vista, seleccionaremos "Campos", de esta forma, podremos trabajar directamente con la plantilla llamada views-view-fields.html.twig.
Paso 4 - Confirmar las sugerencias de plantillas
Cuando hayas activado el Modo Debug o depurador, tendrás que borrar la cache de Drupal y te recomiendo actualizar la base de datos; para ello, podrás utilizar la interfaz o los comando de Drush:
drush cr drush updb
A continuación, podrás comprobar las sugerencias para los nombres de las plantillas, haciendo clic derecho y seleccionando Explorar, o presionando la tecla F12; el resultado será algo parecido a lo siguiente:
Contenidos programáticamente | Creación en Drupal 9
Video de Youtube
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:
- Tener Drupal funcionando ya sea con un servidor local tipo Xampp o con contenedores de Docker.
- Haber instalado al menos estos dos módulos esenciales Backup and Migrate y Admin Toolbar
- (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.
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.
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.
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.
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.
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.
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.
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"
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:
Rules, Admin Toolbar, Pathauto
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:
- Haga un $ this-> drupalGet ('some / path') para ir a una página
- Use $ this-> clickLink (..) para navegar por enlaces en la página
- Use $ this-> getSession () -> getPage () -> fillField (...); para completar los campos del formulario
- Envíe formularios con $ this-> getSession () -> getPage () -> pressButton (...); o use $ this-> submitForm (...); (o use el método obsoleto drupalPostForm ())
- 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.
- La clase de prueba base debe ser abstracta
- 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
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:
- Instalar Composer y ejecutar composer install (o actualizar tu Drupal 8 ó 9 existente, ejecutando composer update)
- Utilizar una versión de desarrollo (por ejemplo, 9.0.x-dev) en lugar de la que tienes en tu sitio actual.
- 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`
Entity API | Introducción en Drupal 8/9
Video de Youtube
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 (DRY, Don'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
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
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.
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
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.
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.
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í.
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).
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
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Í