Come posso visualizzare programmaticamente un blocco?

Sto sviluppando un sito usando Drupal 8 beta-14. Ho creato un blocco di visualizzazione di termini diversi e ora voglio visualizzarlo utilizzando il codice. Come posso visualizzarlo programmaticamente? Lo facevo in Drupal 7 usando questo codice ma sono confuso su Drupal 8.

$block = module_invoke('block', 'block_view', '4');
$text_block = render($block['content']);

Esistono due tipi di blocchi e il metodo di rendering dei due è leggermente diverso:

Blocchi di contenuto

I blocchi di contenuto sono blocchi creati nell'interfaccia. Sono molto simili a strutture di dati configurabili dei nodi, con campi ecc. Se si desidera eseguire il rendering di uno di questi, è possibile fare ciò che si farebbe normalmente con le entità, caricarle e renderle con il generatore di viste:

$bid = ??? // Get the block id through config, SQL or some other means
$block = \Drupal\block_content\Entity\BlockContent::load($bid);
$render = \Drupal::entityTypeManager()->
  getViewBuilder('block_content')->view($block);
return $render;

Blocchi plugin

I blocchi possono anche essere plug-in, definiti in vari moduli. Un esempio potrebbe essere il blocco del pangrattato. Se si desidera renderizzarli, sarà necessario utilizzare il gestore plug-in di blocco.

$block_manager = \Drupal::service('plugin.manager.block');
// You can hard code configuration or you load from settings.
$config = [];
$plugin_block = $block_manager->createInstance('system_breadcrumb_block', $config);
// Some blocks might implement access check.
$access_result = $plugin_block->access(\Drupal::currentUser());
// Return empty render array if user doesn't have access.
// $access_result can be boolean or an AccessResult class
if (is_object($access_result) && $access_result->isForbidden() || is_bool($access_result) && !$access_result) {
  // You might need to add some cache tags/contexts.
  return [];
}
$render = $plugin_block->build();
// In some cases, you need to add the cache tags/context depending on
// the block implemention. As it's possible to add the cache tags and
// contexts in the render method and in ::getCacheTags and 
// ::getCacheContexts methods.
return $render;

Configurare le entità

Condivisi per i due tipi sono blocchi, che una volta inseriti in una regione, si creerà un'entità di configurazione che ha tutte le impostazioni per il blocco. In alcuni casi sarà più utile gestire le entità di configurazione. Poiché lo stesso blocco può essere posizionato in più aree con e con diversa configurazione, può diventare più complicato utilizzando le entità di configurazione del blocco. La cosa bella è che potresti voler rendere un blocco con una configurazione specifica, la cosa brutta è che gli ID di configurazione possono cambiare facendo un casino con l'interfaccia, quindi il codice potrebbe finire per non funzionare dopo aver permesso agli utenti di usare l'interfaccia del blocco.

$block = \Drupal\block\Entity\Block::load('config.id');
$render = \Drupal::entityTypeManager()
  ->getViewBuilder('block')
  ->view($block);
return $render;

Per visualizzare solo il tuo blocco nei tuoi modelli con preelaborazione, il modo migliore è

$block = \Drupal\block\Entity\Block::load('my_block_id');
$variables['My_region'] = \Drupal::entityManager()
          ->getViewBuilder('block')
          ->view($block);

E nel tuo page.html.twigo node.html.twigo xxx.html.twigusa la tua variabile My_region in questo modo:

{% if page.My_region %}
    {{ page.My_region }}
{% endif %}

E in un array renderizzabile (modulo personalizzato), ad esempio, in un controller personalizzato in content ():

public function content() {
    $block = \Drupal\block\Entity\Block::load('my_block_id');
    $block_content = \Drupal::entityManager()
      ->getViewBuilder('block')
      ->view($block);

          return array(
        '#type' => 'container',
        '#attributes' => array(
          'class' => array("Myclass"),
        ),
        "element-content" => $block_content,
        '#weight' => 0,
      );
}

utilizzando drupal_rendernon è utile poiché Drupal assume già il rendering in D8 e questo è obsoleto . Dovresti usare \Drupal::service('renderer')->renderRoot()invece.

È un po 'pesante, è meglio utilizzare il sistema di area massima e non aggiunge il blocco di carico dal preprocesso. Nel caso di utilizzo di un controller nei tuoi moduli questo sembra un uso giustificato.

Oltre alla risposta principale ... Se si desidera eseguire il rendering di un blocco da una vista, potrebbe essere necessario fare le cose in modo leggermente diverso.

$view = views_embed_view('my_view_name', 'my_display_name');

(nome visualizzato ad es. -> blocco_1)

Dal momento che lo passeremo al ramoscello, non è necessario eseguire il rendering (utilizzando il servizio di rendering).

Quindi puoi semplicemente passarlo come variabile al ramoscello (per questo esempio, è il ritorno di un controller):

return [
  ['description' => [
    '#theme' => 'your_theme_hook',
    '#your_variable => $view
  ]
]

nel tuo modulo hai bisogno di un hook_theme () per la tua variabile:

function hook_theme($existing, $type, $theme, $path) {
  return array(
    'your_theme_hook' => array(
      'variables' => [
        'your_variable' => NULL,
      ]
    )
  )
}

E infine nel tuo modello di ramoscello:

{{ your_variable }}

Avevo bisogno di ottenere l'HTML di un blocco personalizzato e ottenerlo usando:

$con = \Drupal\block\BlockViewBuilder::lazyBuilder('bartik_search', 'full');
$d   = \Drupal::service('renderer')->renderPlain($con);

print $d->__toString();

// You need a block_id! to get it just click configure in the desire block and you'll get url like this /admin/structure/block/manage/bartik_search   the last part of the parameter is the block id
$block = \Drupal\block\Entity\Block::load('bartik_search');
$block_content = \Drupal::entityManager()
  ->getViewBuilder('block')
  ->view($block);

return array('#markup' => \Drupal::service('renderer')->renderRoot($block_content));

Fondamentalmente, ci sono due tipi di rendering.

1. Quando esiste un'istanza esistente del blocco nel layout. il blocco può essere reso in ramoscello usando il preprocesso come

   $ block = Block :: load ('BLOCK_ID'); $ variabili ['social_links'] = \ Drupal :: entityTypeManager () -> getViewBuilder ('block') -> view ($ block);

2. Non ci sono istanze o configurazioni per il blocco. Quindi nel preprocessore, dobbiamo creare l'istanza, creare il blocco e quindi renderizzarlo

   $ block_manager = \ Drupal :: service ('plugin.manager.block'); $ config = []; $ plugin_block = $ block_manager-> createInstance ('farmjournal_social_sharing', $ config); $ render = $ plugin_block-> build (); $ variabili ['farmjournal_social_sharing'] = render ($ render);

Sembra che questo funzioni per i blocchi di plugin ..

$block = \Drupal\block\Entity\Block::load('some_block_id_3');
  $pluin = $block->getPlugin();
  $build = $pluin->build();
  $build['#weight'] = 4;
  $form['block'] = $build;

Ottieni l'output del blocco:

$block = \Drupal\block\Entity\Block::load ('my_bock_id');
$block_content = \Drupal::entityManager ()->
  getViewBuilder ('block')->
  view ($block);

E quindi puoi restituire l'output in diversi modi:

return array (
    '#type' => 'container',
    'element-content' => $block_content
);

o:

return ['#markup' => \Drupal::service ('renderer')->render ($block_content)];

Sulla base della mia ricerca, potresti basare il codice su Come rendere un blocco a livello di codice in drupal 8 . Potresti anche cambiare

return array('#markup' => \Drupal::service('renderer')->renderRoot($block_content));

in qualcosa di semplice come:

$output .= \Drupal::service('renderer')->renderRoot($block_content);

per collegarlo, ad esempio, alla variabile di ritorno di una pagina.