Jak mogę programowo wyświetlić blok?

Tworzę witrynę przy użyciu Drupal 8 beta-14. Utworzyłem blok widoku różnych terminów i teraz chcę go wyświetlić za pomocą kodu. Jak mogę wyświetlić programowo? Robiłem to w Drupal 7 przy użyciu tego kodu, ale nie jestem pewien co do Drupala 8.

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

Istnieją dwa rodzaje bloków, a metoda renderowania tych dwóch jest nieco inna:

Bloki treści

Bloki treści to bloki tworzone w interfejsie. Przypominają one konfigurowalne struktury danych węzłów z polami itp. Jeśli chcesz renderować jedną z nich, możesz zrobić to, co normalnie zrobiłbyś z jednostkami, załadować je i renderować za pomocą kreatora widoków:

$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;

Bloki wtyczek

Bloki mogą być również wtyczkami zdefiniowanymi w różnych modułach. Przykładem może być blok nawigacyjny. Jeśli chcesz je wyrenderować, musisz użyć menedżera wtyczek blokowych.

$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;

Konfiguruj encje

Wspólne dla tych dwóch typów są bloki. Po wstawieniu ich do regionu utworzysz element konfiguracji, który ma wszystkie ustawienia bloku. W niektórych przypadkach bardziej użyteczna będzie obsługa encji konfiguracyjnych. Ponieważ ten sam blok może być umieszczony w wielu regionach z inną konfiguracją i może być trudniejszy przy użyciu jednostek konfiguracji bloku. Fajną rzeczą jest to, że możesz chcieć renderować blok z określoną konfiguracją, złą rzeczą jest to, że identyfikatory konfiguracji mogą się zmieniać przez bałagan w interfejsie, więc kod może nie działać po umożliwieniu użytkownikom korzystania z interfejsu bloku.

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

Najlepszym sposobem do wyświetlania tylko bloków w szablonach z wstępnym przetwarzaniem

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

Iw swoim page.html.twiglub node.html.twigczy xxx.html.twigużyć zmiennej My_region takiego:

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

I w tablicy do renderowania (moduł niestandardowy), na przykład, w kontrolerze niestandardowym w 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,
      );
}

Za pomocą drupal_rendernie jest użyteczny, ponieważ Drupal już zakłada renderowanie w D8 i jest to przestarzałe . Zamiast tego powinieneś użyć \Drupal::service('renderer')->renderRoot().

Jest trochę ciężki, lepiej jest użyć systemu maksymalnego obszaru i nie dodaje bloku obciążenia z procesu wstępnego. W przypadku użycia kontrolera w modułach wydaje się to uzasadnione.

Oprócz najważniejszej odpowiedzi ... Jeśli chcesz renderować blok z widoku, być może będziesz musiał zrobić coś nieco inaczej.

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

(nazwa wyświetlana np. -> blok_1)

Ponieważ zamierzamy przekazać go gałązce, nie musimy renderować (używając usługi renderowania).

Możesz więc po prostu przekazać ją jako zmienną do gałązki (w tym przykładzie jest to zwrot kontrolera):

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

w swoim module potrzebujesz hook_theme () dla swojej zmiennej:

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

I wreszcie w szablonie twig:

{{ your_variable }}

Musiałem pobrać kod HTML niestandardowego bloku i użyć go:

$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));

Zasadniczo istnieją dwa typy renderów.

1. Gdy w układzie istnieje instancja bloku. blok może być renderowany w gałązce przy użyciu wstępnego przetwarzania jako

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

2. Nie ma instancji ani konfiguracji bloku. Następnie w preprocesorze musimy utworzyć instancję, zbudować blok, a następnie go wyrenderować

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

Wygląda na to, że działa to w przypadku bloków wtyczek.

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

Otrzymujesz wyjście bloku:

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

Następnie możesz zwrócić dane wyjściowe na różne sposoby:

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

lub:

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

Na podstawie moich badań możesz oprzeć kod z Jak renderować blok programowo w Drupal 8 . Możesz także zmienić

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

w coś tak prostego jak:

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

aby dołączyć go na przykład do zmiennej zwrotnej strony.