9.7. Plugins in Drupal. Wie man programmatisch einen Block hinzufügt.

In diesem Tutorial werden wir uns ansehen, wie man Blöcke programmatisch über ein benutzerdefiniertes Modul in Drupal 8 ausgibt.

Codebeispiele sind auf GitHub verfügbar:
https://github.com/levmyshkin/drupalbook8

Fangen wir damit an, eine Datei hinzuzufügen, die eine PHP-Klasse enthält. So werden Blöcke in Drupal über ein benutzerdefiniertes Modul erstellt. Der Prozess der Dateierstellung ist derselbe wie bei der Klasse für die Seite, wie wir es hier gemacht haben:

9.3. Erstellen eines benutzerdefinierten Drupal-Moduls. Programmatische Ausgabe einer Seite.

Nur dass wir eine Datei mit einem Plugin erstellen müssen:

modules/custom/drupalbook/src/Plugin/Block/FirstBlock.php

Kopieren wir diesen Blockcode und analysieren dann jeden Teil des Codes
modules/custom/drupalbook/src/Plugin/Block/FirstBlock.php:

<?php

namespace Drupal\drupalbook\Plugin\Block;
 
use Drupal\Core\Access\AccessResult;
use Drupal\Core\Block\BlockBase;
use Drupal\Core\Form\FormStateInterface;
use Drupal\Core\Session\AccountInterface;
 
/**
 * Stellt einen Block mit einfachem Text bereit.
 *
 * @block(
 *   id = "drupalbook_first_block_block",
 *   admin_label = @block("Mein erster Block"),
 * )
 */
class FirstBlock extends BlockBase {
  /**
   * {@block}
   */
  public function build() {
    $config = $this->getConfiguration();
 
    if (!empty($config['drupalbook_first_block_settings'])) {
      $text = $this->t('Hallo @Name im Block!', ['@Name' => $config['drupalbook_first_block_settings']]);
    }
    else {
      $text = $this->t('Hallo Welt im Block!');
    }
 
    return [
      '#markup' => $text,
    ];
  }
 
  /**
   * {@block}
   */
  protected function blockAccess(AccountInterface $account) {
    return AccessResult::allowedIfHasPermission($account, 'access content');
  }
 
  /**
   * {@block}
   */
  public function blockForm($form, FormStateInterface $form_state) {
    $config = $this->getConfiguration();
 
    $form['drupalbook_first_block_settings'] = [
      '#type' => 'textfield',
      '#title' => $this->t('Name'),
      '#description' => $this->t('Wem möchtest du Hallo sagen?'),
      '#default_value' => !empty($config['drupalbook_first_block_settings']) ? $config['drupalbook_first_block_settings'] : '',
    ];
 
    return $form;
  }
 
  /**
   * {@block}
   */
  public function blockSubmit($form, FormStateInterface $form_state) {
    $this->configuration['drupalbook_first_block_settings'] = $form_state->getValue('drupalbook_first_block_settings');
  }
}

Wir werden unseren Block in der Region Linke Sidebar oder einer anderen Spalte anzeigen, die für dich bequem ist.

Beginne, den Namen deines Blocks zu tippen, und Drupal wird automatisch vorschlagen, deinen Block auszuwählen. Wenn dein Block nicht angezeigt wird, überprüfe, ob sich der entsprechende Code in der richtigen Datei befindet und die Datei im richtigen Ordner liegt, und vergiss danach nicht, den Cache zu leeren.

Nun da unser Block angezeigt wird, schauen wir uns an, wie der Code zum Hinzufügen eines Blocks funktioniert:

Am Anfang der Datei haben wir das Namespace, um zu definieren, wo unsere Block-Plugin-Datei sein soll, damit Drupal sie automatisch laden kann. Wir binden außerdem Klassen aus anderen Dateien mit use ein.

namespace Drupal\drupalbook\Plugin\Block;
 
use Drupal\Core\Access\AccessResult;
use Drupal\Core\Block\BlockBase;
use Drupal\Core\Form\FormStateInterface;
use Drupal\Core\Session\AccountInterface;

Weiter unten in den Kommentaren steht die Annotation. Wir müssen den Block nicht irgendwo in YML-Dateien definieren, er wird von Drupal automatisch per Annotation geladen.

/**
 * Stellt einen Block mit einfachem Text bereit.
 *
 * @block(
 *   id = "drupalbook_first_block_block",
 *   admin_label = @block("Mein erster Block"),
 * )
 */

Hier geben wir @block an, dass es sich um ein Block-Plugin handelt. id und admin_label werden von Drupal automatisch erkannt, daher muss die id eindeutig sein. @block hilft außerdem, das Block-Label über das Drupal-Admin-Panel zu übersetzen.

extends BlockBase {

Wir erben von der Klasse BlockBase. In PhpStorm kannst du ctrl gedrückt halten und auf BlockBase klicken, um zu sehen, welche Methoden wir in unserem Block überschreiben können. Wir nutzen nicht alle. Weitere Methoden können bei Bedarf überschrieben werden.

Schauen wir uns die Klassenmethoden weiter an:

/**
 * {@block}
 */
protected function blockAccess(AccountInterface $account) {
  return AccessResult::allowedIfHasPermission($account, 'access content');
}

Wir haben bereits im Artikel zum Seitenzugriff besprochen, dass wir bei Blöcken dieselben Zugriffsrechte nutzen können:

https://drupalbook.org/ru/drupal/126-rout-s-parametrom

Hier verwenden wir dieselbe Klasse AccessResult.

/**
 * {@block}
 */
public function blockForm($form, FormStateInterface $form_state) {
  $config = $this->getConfiguration();
 
  $form['drupalbook_first_block_settings'] = [
    '#type' => 'textfield',
    '#title' => $this->t('Name'),
    '#description' => $this->t('Wem möchtest du Hallo sagen?'),
    '#default_value' => !empty($config['drupalbook_first_block_settings']) ? $config['drupalbook_first_block_settings'] : '',
  ];
 
  return $form;
}

Wir können für jeden programmatisch erstellten Block ein eigenes Block-Konfigurationsformular nutzen. Wenn du zu den Blockeinstellungen gehst:

Dort siehst du unser Namensfeld, das wir in der Methode blockForm() hinzugefügt haben:

Wir verwenden die Drupal Form API, um Felder für das Formular zu erstellen:

https://www.drupal.org/docs/8/api/form-api

https://api.drupal.org/api/drupal/elements/8.5.x

Wir werden die Form API später detailliert analysieren und ein mehrstufiges Pop-up-Formular erstellen. Für jetzt kannst du dir ansehen, welche anderen Feldtypen du mit der Form API verwenden kannst. Jedes Feld wird über ein Array hinzugefügt. Versuch, dem Block-Formular weitere Felder hinzuzufügen.

/**
 * {@block}
 */
public function blockSubmit($form, FormStateInterface $form_state) {
  $this->configuration['drupalbook_first_block_settings'] = $form_state->getValue('drupalbook_first_block_settings');
}

Hier speichern wir den Wert der Felder aus dem Formular in der Drupal-Konfiguration. Die Konfiguration werden wir in den folgenden Lektionen noch genauer betrachten. Für jetzt musst du nur verstehen, dass Drupal einen gemeinsamen Speicher für alle Konfigurationen hat und alle Module diesen Config-Speicher verwenden. Diese Konfigurationen können von einer deiner Seiten zur anderen übertragen werden. Zum Beispiel, wenn du die Block-Einstellungen lokal geändert hast, können diese Konfigurationen exportiert und auf die Live-Seite importiert werden, sodass deine Block-Einstellungen auch dort wirksam werden.

/**
 * {@block}
 */
public function build() {
  $config = $this->getConfiguration();
 
  if (!empty($config['drupalbook_first_block_settings'])) {
    $text = $this->t('Hallo @Name im Block!', ['@Name' => $config['drupalbook_first_block_settings']]);
  }
  else {
    $text = $this->t('Hallo Welt im Block!');
  }
 
  return [
    '#markup' => $text,
  ];
}

Und nun die wichtigste Methode build(), die den Inhalt des Blocks anzeigt. In dieser Methode prüfen wir die Block-Konfiguration und wenn ein Name eingetragen ist, geben wir den Text mit dem Namen aus. Beachte die Methode $this->t(), die dir erlaubt, Text über das Drupal-Admin-Panel in andere Sprachen zu übersetzen. Wir verwenden auch den Platzhalter @Name, um nur den gewünschten Text zu übersetzen und nicht die Werte der Felder, die in Konfigurationsformularen eingegeben werden. Das verhindert mehrere Übersetzungszeilen, zum Beispiel:

Hallo Josh ...
Hallo Mike ...
Hallo Ivan ...
und so weiter.

Ich denke, es ist dir jetzt klar geworden, wie man benutzerdefinierte Blöcke in Drupal 8 anzeigt und konfiguriert. Später betrachten wir komplexere Beispiele mit Blöcken, Seiten und Formularen.

Codebeispiele sind auf GitHub verfügbar:
https://github.com/levmyshkin/drupalbook8