Kreiranje formatera polja

Modul za formatiranje polja formatira podatke polja za prikaz krajnjem korisniku. Formatere polja definišu se kao plugini, zato se preporučuje da proučite Plugin API pre nego što počnete sa pisanjem novog formatara polja.

Klasа formatara polja

Fajl: /modules/random/src/Plugin/Field/FieldFormatter/RandomDefaultFormatter.php

<?php

namespace Drupal\random\Plugin\Field\FieldFormatter;

use Drupal\Core\Field\FormatterBase;
use Drupal\Core\Field\FieldItemListInterface;

/**
 * Plugin implementacija 'Random_default' formatara.
 *
 * @FieldFormatter(
 *   id = "Random_default",
 *   label = @Translation("Random text"),
 *   field_types = {
 *     "Random"
 *   }
 * )
 */
class RandomDefaultFormatter extends FormatterBase {

  /**
   * {@inheritdoc}
   */
  public function settingsSummary() {
    $summary = [];
    $summary[] = $this->t('Prikazuje nasumični tekst.');
    return $summary;
  }

  /**
   * {@inheritdoc}
   */
  public function viewElements(FieldItemListInterface $items, $langcode) {
    $element = [];

    foreach ($items as $delta => $item) {
      // Renderuj svaki element kao markup.
      $element[$delta] = ['#markup' => $item->value];
    }

    return $element;
  }

}

Podešavanja formatara

Ako vaš formaterski uređaj zahteva prilagođena podešavanja za prikaz, potrebno je da izvedete tri koraka:

• Prekoračite PluginSettingsBase::defaultSettings() da biste postavili podrazumevane vrednosti
• Kreirajte konfiguracionu šemu za podešavanja koja ste napravili
• Kreirajte formu koja korisnicima omogućava menjanje podešavanja

Korak 1: Prekoračite PluginSettingsBase::defaultSettings() da biste postavili podrazumevane vrednosti

/**
 * {@inheritdoc}
 */
public static function defaultSettings() {
  return [
    // Deklariši podešavanje pod imenom 'text_length' sa
    // podrazumevanom vrednošću 'short'
    'text_length' => 'short',
  ] + parent::defaultSettings();
}

Korak 2: Kreirajte konfiguracionu šemu za vaša podešavanja

Konfiguraciona šema se nalazi u sledećem fajlu:

[ROOT MODULA]/config/schema/[IME MODULA].schema.yml

U ovom fajlu opisujete tipove podataka podešavanja koje ste definisali u defaultSettings():

Korak 1 je napravio podešavanje pod imenom 'text_length' koje sadrži string vrednost. Šema za to bi izgledala ovako:

field.formatter.settings.[ID FORMATARA]:
  type: mapping
  label: 'IME FORMATARA dužina teksta'
  mapping:
    text_length:
      type: string
      label: 'Dužina teksta'

Korak 3: Kreirajte formu koja omogućava korisnicima menjanje podešavanja

Forma za uređivanje vrednosti podešavanja se pravi prekoračenjem FormatterBase::settingsForm().

Ne zaboravite da dodate namespace za FormStateInterface na početak PHP fajla.

use Drupal\Core\Form\FormStateInterface;

/**
 * {@inheritdoc}
 */
public function settingsForm(array $form, FormStateInterface $form_state) {
  $form['text_length'] = [
    '#title' => $this->t('Dužina teksta'),
    '#type' => 'select',
    '#options' => [
      'short' => $this->t('Kratko'),
      'long' => $this->t('Dugo'),
    ],
    '#default_value' => $this->getSetting('text_length'),
  ];

  return $form;
}

Korišćenje #ajax u formama podešavanja

Korišćenje #ajax u formama podešavanja nije jednostavno jer fragment forme kreiran u settingsForm() nije u korenu forme, već je duboko ugnježden. U sledećem primeru, forma ima dve postavke: display_type koji može biti 'label' ili 'entity', i entity_display_mode koji može biti 'full' ili 'teaser'. Mod za prikaz entiteta se prikazuje samo ako je display_type postavljen na 'entity'.

public function settingsForm(array $form, FormStateInterface $form_state) {
  $form['display_type'] = [
    '#title' => $this->t('Tip prikaza'),
    '#type' => 'select',
    '#options' => [
      'label' => $this->t('Oznaka'),
      'entity' => $this->t('Entitet'),
    ],
    '#default_value' => $this->getSetting('display_type'),
    '#ajax' => [
      'wrapper' => 'private_message_thread_member_formatter_settings_wrapper',
      'callback' => [$this, 'ajaxCallback'],
    ],
  ];

  $form['entity_display_mode'] = [
    '#prefix' => '<div id="private_message_thread_member_formatter_settings_wrapper">',
    '#suffix' => '</div>',
  ];

  // Prvo, dohvati ime polja za trenutno polje
  $field_name = $this->fieldDefinition->getItemDefinition()->getFieldDefinition()->getName();
  // Sledeće, postavi ključ podešavanja čiju vrednost treba dohvatiti
  $setting_key = 'display_type';

  // Pokušaj da dohvatiš vrednost iz stanja forme. Ovo neće postojati prilikom prvog učitavanja stranice
  if ($value = $form_state->getValue(['fields', $field_name, 'settings_edit_form', 'settings', $setting_key])) {
    $display_type = $value;
  }
  // Pri prvom učitavanju stranice, koristi podrazumevano podešavanje
  else {
    $display_type = $this->getSetting('display_type');
  }

  if ($display_type == 'entity') {
    $form['entity_display_mode']['#type'] = 'select';
    $form['entity_display_mode']['#title'] = $this->t('Mod prikaza');
    $form['entity_display_mode']['#options'] = [
      'full' => $this->t('Puni'),
      'teaser' => $this->t('Najava'),
    ];
    $form['entity_display_mode']['#default_value'] = $this->getSetting('entity_display_mode');
  }
  else {
    // Prisiljava element da se renderuje (tako da AJAX wrapper bude prikazan) čak i
    // Kada nije izabrana vrednost
    $form['entity_display_mode']['#markup'] = '';
  }

  return $form;
}

Zatim kreirajte ajax callback koji vraća odgovarajući element forme:

public function ajaxCallback(array $form, FormStateInterface $form_state) {
  $field_name = $this->fieldDefinition->getItemDefinition()->getFieldDefinition()->getName();
  $element_to_return = 'entity_display_mode';

  return $form['fields'][$field_name]['plugin']['settings_edit_form']['settings'][$element_to_return];
}

Uvođenje zavisnosti u formatere polja

Korišćenje dependency injection u formatterima polja zahteva tri koraka:

• Implementirati interfejs ContainerFactoryPluginInterface
• Implementirati ContainerFactoryPluginInterface::create()
• Prekoračiti FormatterBase::__construct()

1) Implementacija ContainerFactoryPluginInterface

use Drupal\Core\Plugin\ContainerFactoryPluginInterface;

class MyFormatter extends FormatterBase implements ContainerFactoryPluginInterface {

2) Implementacija ContainerFactoryPluginInterface::create()

Primer ubacuje servis entity.manager u formatter

use Symfony\Component\DependencyInjection\ContainerInterface;

public static function create(ContainerInterface $container, array $configuration, $plugin_id, $plugin_definition) {
  return new static(
    $plugin_id,
    $plugin_definition,
    $configuration['field_definition'],
    $configuration['settings'],
    $configuration['label'],
    $configuration['view_mode'],
    $configuration['third_party_settings'],
    // Ovde ubacite servise koje želite da injektujete
    $container->get('entity.manager')
  );
}

3) Prekoračenje FormatterBase::__construct()

Prekoračite __construct() u FormatterBase, pozovite obavezno parent::__construct(), zatim sačuvajte servis u svojstvu klase

use Drupal\Core\Field\FieldDefinitionInterface;

/**
 * Servis entity manager
 *
 * @var \Drupal\Core\Entity\EntityManagerInterface
 */
protected $entityManager;

/**
 * Konstruktor objekta MyFormatter.
 *
 * @param string $plugin_id
 *   Plugin ID instance.
 * @param mixed $plugin_definition
 *   Definicija implementacije plugina.
 * @param \Drupal\Core\Field\FieldDefinitionInterface $field_definition
 *   Definicija polja entiteta.
 * @param array $settings
 *   Podešavanja formatara.
 * @param string $label
 *   Podešavanje prikaza oznake formatara.
 * @param string $view_mode
 *   Mod prikaza.
 * @param array $third_party_settings
 *   Podešavanja trećih strana.
 * @param \Drupal\Core\Entity\EntityManagerInterface $entityManager
 *   Servis entity manager.
 */
public function __construct($plugin_id, $plugin_definition, FieldDefinitionInterface $field_definition, array $settings, $label, $view_mode, array $third_party_settings, EntityManagerInterface $entityManager) {
  parent::__construct($plugin_id, $plugin_definition, $field_definition, $settings, $label, $view_mode, $third_party_settings);

  $this->entityManager = $entityManager;
}

Sada možete koristiti entity manager bilo gde u vašoj klasi formatara kao $this->entityManager.