src/Frontend/Core/Engine/Page.php line 107

Open in your IDE?
  1. <?php
  3. namespace Frontend\Core\Engine;
  5. use Common\Exception\RedirectException;
  6. use ForkCMS\App\KernelLoader;
  7. use Frontend\Core\Engine\Base\Widget as FrontendBaseWidget;
  8. use Frontend\Core\Engine\Block\ModuleExtraInterface;
  9. use Frontend\Core\Engine\Model as FrontendModel;
  10. use Frontend\Core\Header\Header;
  11. use Frontend\Core\Language\Language;
  12. use Symfony\Component\HttpFoundation\RedirectResponse;
  13. use Symfony\Component\HttpFoundation\Response;
  14. use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
  15. use Symfony\Component\HttpKernel\KernelInterface;
  16. use Frontend\Core\Engine\Block\ExtraInterface as FrontendBlockExtra;
  17. use Frontend\Core\Engine\Block\Widget as FrontendBlockWidget;
  18. use Backend\Core\Engine\Model as BackendModel;
  19. use Frontend\Modules\Profiles\Engine\Authentication as FrontendAuthenticationModel;
  20. use Symfony\Component\Security\Core\Exception\InsufficientAuthenticationException;
  22. /**
  23.  * Frontend page class, this class will handle everything on a page
  24.  */
  25. class Page extends KernelLoader
  26. {
  27.     /**
  28.      * Breadcrumb instance
  29.      *
  30.      * @var Breadcrumb
  31.      */
  32.     protected $breadcrumb;
  34.     /**
  35.      * Array of extras linked to this page
  36.      *
  37.      * @var array
  38.      */
  39.     protected $extras = [];
  41.     /**
  42.      * Footer instance
  43.      *
  44.      * @var Footer
  45.      */
  46.     protected $footer;
  48.     /**
  49.      * Header instance
  50.      *
  51.      * @var Header
  52.      */
  53.     protected $header;
  55.     /**
  56.      * Header instance
  57.      *
  58.      * @var Modals
  59.      */
  60.     protected $modals;
  62.     /**
  63.      * The current pageId
  64.      *
  65.      * @var int
  66.      */
  67.     protected $pageId;
  69.     /**
  70.      * Content of the page
  71.      *
  72.      * @var array
  73.      */
  74.     protected $record = [];
  76.     /**
  77.      * The path of the template to show
  78.      *
  79.      * @var string
  80.      */
  81.     protected $templatePath;
  83.     /**
  84.      * The statuscode
  85.      *
  86.      * @var int
  87.      */
  88.     protected $statusCode = Response::HTTP_OK;
  90.     /**
  91.      * TwigTemplate instance
  92.      *
  93.      * @var TwigTemplate
  94.      */
  95.     protected $template;
  97.     /**
  98.      * URL instance
  99.      *
  100.      * @var Url
  101.      */
  102.     protected $url;
  104.     public function __construct(KernelInterface $kernel)
  105.     {
  106.         parent::__construct($kernel);
  108.         $this->getContainer()->set('page', $this);
  109.         $this->template = $this->getContainer()->get('templating');
  110.         $this->url = $this->getContainer()->get('url');
  111.     }
  113.     /**
  114.      * Loads the actual components on the page
  115.      */
  116.     public function load(): void
  117.     {
  118.         // set tracking cookie
  119.         Model::getVisitorId();
  121.         // create header instance
  122.         $this->header = new Header($this->getKernel());
  124.         /* @var $pageAliasUrl PageUrlAliasInterface */
  125.         $pageAliasUrl = $this->get('fork.frontend.page_url_alias');
  127.         try {
  128.             $this->handlePage($pageAliasUrl->getPageId(implode('/', $this->url->getPages()), FRONTEND_LANGUAGE));
  129.         } catch (NotFoundHttpException $notFoundHttpException) {
  130.             $this->handlePage(Response::HTTP_NOT_FOUND);
  131.         } catch (InsufficientAuthenticationException $insufficientAuthenticationException) {
  132.             $this->redirectToLogin();
  133.         }
  134.     }
  136.     private function handlePage(int $pageId)
  137.     {
  139.         // get page content from pageId of the requested URL
  140.         $this->record = $this->getPageContent($pageId);
  142.         /* @var $pageAliasUrl PageUrlAliasInterface */
  143.         $pageAliasUrl = $this->get('fork.frontend.page_url_alias');
  146.         //redirect when url not alias and alias url is present
  147.         if(!empty($this->record) && !$pageAliasUrl->isAlias(implode('/', $this->url->getPages()), FRONTEND_LANGUAGE) && $pageAliasUrl->hasPageIdAlias($this->record['id'], FRONTEND_LANGUAGE)) {
  148.             throw new RedirectException(
  149.                 'Redirect',
  150.                 new RedirectResponse(
  151.                     Navigation::getURL($this->record['id']),
  152.                     301
  153.                 )
  154.             );
  155.         }
  157.         if (empty($this->record)) {
  158.             throw new NotFoundHttpException('No page was found for the page id:' . $pageId);
  159.         }
  161.         $this->checkAuthentication();
  163.         // we need to set the correct id
  164.         $this->pageId = (int) $this->record['id'];
  166.         if ($this->pageId === Response::HTTP_NOT_FOUND) {
  167.             $this->statusCode = Response::HTTP_NOT_FOUND;
  169.             if (extension_loaded('newrelic')) {
  170.                 newrelic_name_transaction('404');
  171.             }
  172.         }
  174.         $this->breadcrumb = new Breadcrumb($this->getKernel());
  175.         $this->footer = new Footer($this->getKernel());
  176.         $this->modals = new Modals($this->getKernel(), $this->pageId);
  178.         $this->processPage();
  180.         // execute all extras linked to the page
  181.         array_map([$this, 'processExtra'], $this->extras);
  182.     }
  184.     private function checkAuthentication(): void
  185.     {
  186.         // no authentication needed
  187.         if (!isset($this->record['data']['auth_required'])
  188.             || !$this->record['data']['auth_required']
  189.             || !BackendModel::isModuleInstalled('Profiles')
  190.         ) {
  191.             return;
  192.         }
  194.         if (!FrontendAuthenticationModel::isLoggedIn()) {
  195.             throw new InsufficientAuthenticationException('You must log in to see this page');
  196.         }
  198.         // specific groups for auth?
  199.         if (empty($this->record['data']['auth_groups'])) {
  200.             // no further checks needed
  201.             return;
  202.         }
  204.         foreach ($this->record['data']['auth_groups'] as $group) {
  205.             if (FrontendAuthenticationModel::getProfile()->isInGroup($group)) {
  206.                 // profile is in a group that is allowed to see the page
  207.                 return;
  208.             }
  209.         }
  211.         throw new NotFoundHttpException('The current page is not available to the logged in profile');
  212.     }
  214.     public function display(): Response
  215.     {
  216.         try {
  217.             $this->template->assignGlobal('homePage', $this->pageId == 1);
  218.             // assign the id so we can use it as an option
  219.             $this->template->assignGlobal('isPage' . $this->pageId, true);
  220.             $this->template->assignGlobal('isChildOfPage' . $this->record['parent_id'], true);
  222.             // hide the cookiebar from within the code to prevent flickering
  223.             $this->template->assignGlobal(
  224.                 'cookieBarHide',
  225.                 !$this->get('fork.settings')->get('Core', 'show_cookie_bar', false)
  226.                 || $this->getContainer()->get('fork.cookie')->hasHiddenCookieBar()
  227.             );
  229.             // assign globals for GtmCookieBar module
  230.             if (BackendModel::isModuleInstalled('GtmCookieBar'))
  231.             {
  232.                 $gtmId = $this->get('fork.settings')->get('GtmCookieBar', 'gtmId', null);
  233.                 $gtmId = !empty($gtmId) ? (string) $gtmId : null;
  235.                 $this->template->assignGlobal('gtmId', $gtmId);
  236.                 $this->template->assignGlobal('gtmCookieSettings', \Frontend\Modules\GtmCookieBar\Engine\Model::getGtmCookieSettings());
  237.                 // Kept for backwards compatibility with existing theme includes.
  238.                 $this->template->assignGlobal('cookiebar_template', '/GtmCookieBar/Layout/Templates/CookieBar.html.twig');
  239.                 // Kept for backwards compatibility with existing theme includes.
  240.                 $this->template->assignGlobal('gtm_template', '/GtmCookieBar/Layout/Templates/Gtm.html.twig');
  241.             }
  243.             // assign globals for PageExtend module
  244.             if (BackendModel::isModuleInstalled('PagesExtension'))
  245.             {
  246.                 $this->template->assignGlobal('pageClass', \Frontend\Modules\PagesExtension\Engine\Model::getPageClass($this->pageId, FRONTEND_LANGUAGE) ?: null);
  247.             }
  249.             $this->parsePositions();
  251.             // assign empty positions
  252.             $unusedPositions = array_diff(
  253.                 $this->record['template_data']['names'],
  254.                 array_keys($this->record['positions'])
  255.             );
  256.             foreach ($unusedPositions as $position) {
  257.                 $this->template->assign('position' . \SpoonFilter::ucfirst($position), []);
  258.             }
  260.             $this->header->parse();
  261.             $this->breadcrumb->parse();
  262.             $this->parseLanguages();
  263.             $this->footer->parse();
  264.             $this->modals->parse();
  266.             return new Response(
  267.                 $this->template->getContent($this->templatePath),
  268.                 $this->statusCode
  269.             );
  270.         } catch (NotFoundHttpException $notFoundHttpException) {
  271.             $this->handlePage(Response::HTTP_NOT_FOUND);
  273.             return $this->display();
  274.         } catch (InsufficientAuthenticationException $insufficientAuthenticationException) {
  275.             $this->redirectToLogin();
  276.         }
  277.     }
  279.     /**
  280.      * Redirects to the login page in a way that the login page will redirect back to the current page after logging in
  281.      */
  282.     private function redirectToLogin()
  283.     {
  284.         $this->redirect(
  285.             Navigation::getUrlForBlock('Profiles', 'Login') . '?queryString=' . Model::getRequest()->getRequestUri(),
  286.             Response::HTTP_TEMPORARY_REDIRECT
  287.         );
  288.     }
  290.     public function getExtras(): array
  291.     {
  292.         return $this->extras;
  293.     }
  295.     public function getId(): int
  296.     {
  297.         return $this->pageId;
  298.     }
  300.     private function getPageRecord(int $pageId): array
  301.     {
  302.         if ($this->url->getParameter('page_revision', 'int') === null) {
  303.             return Model::getPage($pageId);
  304.         }
  306.         // add no-index to meta-custom, so the draft won't get accidentally indexed
  307.         $this->header->addMetaData(['name' => 'robots', 'content' => 'noindex, nofollow'], true);
  309.         return Model::getPageRevision($this->url->getParameter('page_revision', 'int'));
  310.     }
  312.     protected function getPageContent(int $pageId): array
  313.     {
  314.         $record = $this->getPageRecord($pageId);
  316.         if (empty($record)) {
  317.             return [];
  318.         }
  320.         // redirect to the first child if the page is empty
  321.         if ($this->allPositionsAreEmpty($record['positions'])) {
  322.             $firstChildId = Navigation::getFirstChildId($record['id']);
  324.             // check if we actually have a first child
  325.             if ($firstChildId !== 0) {
  326.                 $this->redirect(Navigation::getUrl($firstChildId));
  327.             }
  328.         }
  330.         return $record;
  331.     }
  333.     private function allPositionsAreEmpty(array $positions): bool
  334.     {
  335.         // loop positions to check if they are empty
  336.         foreach ($positions as $blocks) {
  337.             // loop blocks in position
  338.             foreach ($blocks as $block) {
  339.                 // It isn't empty if HTML is provided, a decent extra is provided or a widget is provided
  340.                 if ($block['extra_type'] === 'block'
  341.                     || $block['extra_type'] === 'widget'
  342.                     || trim($block['html']) !== ''
  343.                 ) {
  344.                     return false;
  345.                 }
  346.             }
  347.         }
  349.         return true;
  350.     }
  352.     public function getRecord(): array
  353.     {
  354.         return $this->record;
  355.     }
  357.     public function getStatusCode(): int
  358.     {
  359.         return $this->statusCode;
  360.     }
  362.     protected function parseLanguages(): void
  363.     {
  364.         // just execute if the site is multi-language
  365.         if (!$this->getContainer()->getParameter('site.multilanguage') || count(Language::getActiveLanguages()) === 1) {
  366.             return;
  367.         }
  369.         $this->template->assignGlobal(
  370.             'languages',
  371.             array_map(
  372.                 function (string $language) {
  373.                     return [
  374.                         'url' => '/' . $language,
  375.                         'label' => $language,
  376.                         'name' => Language::msg(mb_strtoupper($language)),
  377.                         'current' => $language === LANGUAGE,
  378.                     ];
  379.                 },
  380.                 Language::getActiveLanguages()
  381.             )
  382.         );
  383.     }
  385.     protected function parsePositions(): void
  386.     {
  387.         // init array to store parsed positions data
  388.         $positions = [];
  390.         // fetch variables from main template
  391.         $mainVariables = $this->template->getAssignedVariables();
  393.         // loop all positions
  394.         foreach ($this->record['positions'] as $position => $blocks) {
  395.             // loop all blocks in this position
  396.             foreach ($blocks as $i => $block) {
  397.                 $positions[$position][$i] = $this->parseBlock($block, $mainVariables);
  398.             }
  400.             // assign position to template
  401.             $this->template->assign('position' . \SpoonFilter::ucfirst($position), $positions[$position]);
  402.         }
  404.         $this->template->assign('positions', $positions);
  405.     }
  407.     private function parseBlock(array $block, array $mainVariables): array
  408.     {
  409.         if (!isset($block['extra'])) {
  410.             $parsedBlock = $block;
  411.             if (array_key_exists('blockContent', $block)) {
  412.                 $parsedBlock['html'] = $block['blockContent'];
  413.             }
  415.             return $parsedBlock;
  416.         }
  418.         $block['extra']->execute();
  419.         $extraVariables = $block['extra']->getTemplate()->getAssignedVariables();
  420.         $block['extra']->getTemplate()->assignArray($mainVariables);
  421.         $block['extra']->getTemplate()->assignArray($extraVariables);
  423.         return [
  424.             'variables' => $block['extra']->getTemplate()->getAssignedVariables(),
  425.             'blockIsEditor' => false,
  426.             'html' => $block['extra']->getContent(),
  427.         ];
  428.     }
  430.     protected function processExtra(ModuleExtraInterface $extra): void
  431.     {
  432.         $this->getContainer()->get('logger.public')->info(
  433.             'Executing ' . get_class($extra) . " '{$extra->getAction()}' for module '{$extra->getModule()}'."
  434.         );
  436.         // overwrite the template
  437.         if (is_callable([$extra, 'getOverwrite']) && $extra->getOverwrite()) {
  438.             $this->templatePath = $extra->getTemplatePath();
  439.         }
  440.     }
  442.     private function addAlternateLinks(): void
  443.     {
  444.         // no need for alternate links if there is only one language
  445.         if (!$this->getContainer()->getParameter('site.multilanguage')) {
  446.             return;
  447.         }
  449.         array_map([$this, 'addAlternateLinkForLanguage'], Language::getActiveLanguages());
  450.     }
  452.     private function addAlternateLinkForLanguage(string $language): void
  453.     {
  454.         if ($language === LANGUAGE) {
  455.             return;
  456.         }
  458.         // Get page data
  459.         $pageInfo = Model::getPage($this->pageId);
  461.         // Check if hreflang is set for language
  462.         if (isset($pageInfo['data']['hreflang_' . $language])) {
  463.             $url = Navigation::getUrl($pageInfo['data']['hreflang_' . $language], $language);
  464.         } else {
  465.             $url = Navigation::getUrl($this->pageId, $language);
  466.         }
  468.         // remove last /
  469.         $url = rtrim($url, '/\\');
  471.         // Ignore 404 links
  472.         if ($this->pageId !== Response::HTTP_NOT_FOUND
  473.             && $url === Navigation::getUrl(Response::HTTP_NOT_FOUND, $language)) {
  474.             return;
  475.         }
  477.         // Convert relative to absolute url
  478.         if (strpos($url, '/') === 0) {
  479.             $url = SITE_URL . $url;
  480.         }
  482.         $this->header->addLink(['rel' => 'alternate', 'hreflang' => $language, 'href' => $url]);
  483.     }
  485.     private function assignPageMeta(): void
  486.     {
  487.         // set pageTitle
  488.         $this->header->setPageTitle(
  489.             $this->record['meta_title'],
  490.             $this->record['meta_title_overwrite']
  491.         );
  493.         // set meta-data
  494.         $this->header->addMetaDescription(
  495.             $this->record['meta_description'],
  496.             $this->record['meta_description_overwrite']
  497.         );
  498.         $this->header->addMetaKeywords(
  499.             $this->record['meta_keywords'],
  500.             $this->record['meta_keywords_overwrite']
  501.         );
  502.         $this->header->setMetaCustom($this->record['meta_custom']);
  504.         // advanced SEO-attributes
  505.         if (isset($this->record['meta_seo_index'])) {
  506.             $this->header->addMetaData(
  507.                 ['name' => 'robots', 'content' => $this->record['meta_seo_index']]
  508.             );
  509.         }
  510.         if (isset($this->record['meta_seo_follow'])) {
  511.             $this->header->addMetaData(
  512.                 ['name' => 'robots', 'content' => $this->record['meta_seo_follow']]
  513.             );
  514.         }
  515.     }
  517.     protected function processPage(): void
  518.     {
  519.         $this->assignPageMeta();
  520.         new Navigation($this->getKernel());
  521.         $this->addAlternateLinks();
  523.         // assign content
  524.         $pageInfo = Navigation::getPageInfo($this->record['id']);
  525.         $this->record['has_children'] = $pageInfo['has_children'];
  526.         $this->template->assignGlobal('page', $this->record);
  528.         // set template path
  529.         $this->templatePath = $this->record['template_path'];
  531.         // loop blocks
  532.         foreach ($this->record['positions'] as $position => &$blocks) {
  533.             // position not known in template = skip it
  534.             if (!in_array($position, $this->record['template_data']['names'])) {
  535.                 continue;
  536.             }
  538.             $blocks = array_map(
  539.                 function (array $block) {
  540.                     if ($block['extra_id'] === null) {
  541.                         return [
  542.                             'blockIsEditor' => true,
  543.                             'blockContent' => $block['html'],
  544.                         ];
  545.                     }
  547.                     $block = ['extra' => $this->getExtraForBlock($block)];
  549.                     // add to list of extras to parse
  550.                     $this->extras[] = $block['extra'];
  552.                     return $block;
  553.                 },
  554.                 $blocks
  555.             );
  556.         }
  557.     }
  559.     private function getExtraForBlock(array $block): ModuleExtraInterface
  560.     {
  561.         // block
  562.         if ($block['extra_type'] === 'block') {
  563.             if (extension_loaded('newrelic')) {
  564.                 newrelic_name_transaction($block['extra_module'] . '::' . $block['extra_action']);
  565.             }
  567.             return new FrontendBlockExtra(
  568.                 $this->getKernel(),
  569.                 $block['extra_module'],
  570.                 $block['extra_action'],
  571.                 $block['extra_data']
  572.             );
  573.         }
  575.         return new FrontendBlockWidget(
  576.             $this->getKernel(),
  577.             $block['extra_module'],
  578.             $block['extra_action'],
  579.             $block['extra_data']
  580.         );
  581.     }
  583.     private function redirect(string $url, int $code = RedirectResponse::HTTP_FOUND): void
  584.     {
  585.         throw new RedirectException('Redirect', new RedirectResponse($url, $code));
  586.     }
  588.     public static function getCurrentMainBlock(): ?FrontendBlockExtra
  589.     {
  590.         $extras = FrontendModel::getContainer()->get('page')->getExtras();
  592.         foreach ($extras as $extra) {
  593.             if ($extra instanceof FrontendBlockExtra && !$extra instanceof FrontendBaseWidget) {
  594.                 return $extra;
  595.             }
  596.         }
  598.         return null;
  599.     }
  600. }