protected function getBlockContext(BlockServiceInterface $blockService)
{
$this->blockServiceManager->expects($this->once())->method('get')->will($this->returnValue($blockService));
$block = $this->getMock('Sonata\\BlockBundle\\Model\\BlockInterface');
$block->expects($this->once())->method('getSettings')->will($this->returnValue(array()));
$blockContext = $this->blockContextManager->get($block);
$this->assertInstanceOf('Sonata\\BlockBundle\\Block\\BlockContextInterface', $blockContext);
return $blockContext;
}
/**
* Action for ajax route rendering a block by calling his executeAjax() method.
*
* @param Request $request Symfony request object
* @param int $pageId Page identifier
* @param int $blockId Block identifier
*
* @return Response
*/
public function execute(Request $request, $pageId, $blockId)
{
$cmsManager = $this->cmsManagerSelector->retrieve();
$page = $cmsManager->getPageById($pageId);
$block = $cmsManager->getBlock($blockId);
if (!$block instanceof BlockInterface) {
throw new BlockNotFoundException(sprintf('Unable to find block identifier "%s" in page "%s".', $blockId, $pageId));
}
$blockContext = $this->contextManager->get($block);
return $this->blockRenderer->render($blockContext);
}
/**
* @param Request $request
*
* @return mixed
*/
public function cacheAction(Request $request)
{
$parameters = array_merge($request->query->all(), $request->attributes->all());
if ($request->get('_token') != $this->computeHash($parameters)) {
throw new AccessDeniedHttpException('Invalid token');
}
$manager = $this->getManager($request);
$page = $manager->getPageById($request->get('page_id'));
if (!$page) {
throw new NotFoundHttpException(sprintf('Page not found : %s', $request->get('page_id')));
}
$block = $manager->getBlock($request->get('block_id'));
$blockContext = $this->contextManager->get($block);
if ($this->recorder) {
$this->recorder->add($blockContext->getBlock());
$this->recorder->push();
}
$response = $this->blockRenderer->render($blockContext);
if ($this->recorder) {
$keys = $this->recorder->pop();
$keys['page_id'] = $page->getId();
$keys['block_id'] = $block->getId();
foreach ($keys as $key => $value) {
$response->headers->set($this->normalize($key), $value);
}
}
$response->headers->set('x-sonata-page-not-decorable', true);
return $response;
}
/**
* @param Request $request
*
* @throws NotFoundHttpException
* @throws AccessDeniedHttpException
*
* @return mixed
*/
public function cacheAction(Request $request)
{
$parameters = array_merge($request->query->all(), $request->attributes->all());
if ($request->get('_token') != $this->computeHash($parameters)) {
throw new AccessDeniedHttpException('Invalid token');
}
$block = $this->blockLoader->load(array('name' => $request->get('block_id')));
if (!$block) {
throw new NotFoundHttpException(sprintf('Block not found : %s', $request->get('block_id')));
}
$settings = $request->get(BlockContextManagerInterface::CACHE_KEY, array());
if (!is_array($settings)) {
throw new \RuntimeException(sprintf('Query string parameter `%s` is not an array', BlockContextManagerInterface::CACHE_KEY));
}
return $this->blockRenderer->render($this->blockContextManager->get($block, $settings));
}
/**
* @param Request $request
*
* @return Response
*/
public function cacheAction(Request $request)
{
$cms = $this->cmsSelector->retrieve();
try {
$page = $cms->getPageById($request->get('page_id'));
} catch (PageNotFoundException $e) {
$page = false;
}
$block = $cms->getBlock($request->get('block_id'));
if (!$page || !$block) {
return new Response('', 404);
}
$options = array();
$blockContext = $this->contextManager->get($block, $options);
$response = $this->blockRenderer->render($blockContext);
$response->setPrivate();
// always set to private
if ($this->sync) {
return $response;
}
$response->setContent(sprintf('
(function () {
var block = document.getElementById("block-cms-%s");
var div = document.createElement("div");
div.innerHTML = %s;
for (var node in div.childNodes) {
if (div.childNodes[node] && div.childNodes[node].nodeType == 1) {
block.parentNode.replaceChild(div.childNodes[node], block);
}
}
})();
', $block->getId(), json_encode($response->getContent())));
$response->headers->set('Content-Type', 'application/javascript');
return $response;
}
/**
* @param mixed $block
* @param array $options
*
* @return null|Response
*/
public function render($block, array $options = array())
{
$blockContext = $this->blockContextManager->get($block, $options);
if (!$blockContext instanceof BlockContextInterface) {
return '';
}
$stats = array();
if ($this->stopwatch) {
$stats = $this->startTracing($blockContext->getBlock());
}
$service = $this->blockServiceManager->get($blockContext->getBlock());
$this->computeAssets($blockContext, $stats);
$useCache = $blockContext->getSetting('use_cache');
$cacheKeys = $response = false;
$cacheService = $useCache ? $this->getCacheService($blockContext->getBlock(), $stats) : false;
if ($cacheService) {
$cacheKeys = array_merge($service->getCacheKeys($blockContext->getBlock()), $blockContext->getSetting('extra_cache_keys'));
if ($this->stopwatch) {
$stats['cache']['keys'] = $cacheKeys;
}
// Please note, some cache handler will always return true (js for instance)
// This will allows to have a non cacheable block, but the global page can still be cached by
// a reverse proxy, as the generated page will never get the generated Response from the block.
if ($cacheService->has($cacheKeys)) {
$cacheElement = $cacheService->get($cacheKeys);
if ($this->stopwatch) {
$stats['cache']['from_cache'] = false;
}
if (!$cacheElement->isExpired() && $cacheElement->getData() instanceof Response) {
/* @var Response $response */
if ($this->stopwatch) {
$stats['cache']['from_cache'] = true;
}
$response = $cacheElement->getData();
}
}
}
if (!$response) {
$recorder = null;
if ($this->cacheManager) {
$recorder = $this->cacheManager->getRecorder();
if ($recorder) {
$recorder->add($blockContext->getBlock());
$recorder->push();
}
}
$response = $this->blockRenderer->render($blockContext);
$contextualKeys = $recorder ? $recorder->pop() : array();
if ($this->stopwatch) {
$stats['cache']['contextual_keys'] = $contextualKeys;
}
if ($response->isCacheable() && $cacheKeys && $cacheService) {
$cacheService->set($cacheKeys, $response, $response->getTtl(), $contextualKeys);
}
}
if ($this->stopwatch) {
$stats['cache']['created_at'] = $response->getDate();
$stats['cache']['ttl'] = $response->getTtl() ?: 0;
$stats['cache']['age'] = $response->getAge();
}
// update final ttl for the whole Response
if ($this->cacheHandler) {
$this->cacheHandler->updateMetadata($response, $blockContext);
}
if ($this->stopwatch) {
$this->stopTracing($blockContext->getBlock(), $stats);
}
return $response->getContent();
}