13566190336

Committed 27 Feb 2025 12:18PM UTC coverage: 72.127% (-0.6%) from 72.746%

Build # 13566190336

Build Type

push

github

Committed by

NamelessCoder

Commit Message

[TER] 7.1.0

Run Details

5649 of 7832 relevant lines covered (72.13%)

20.01 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

32.81

/Classes/ViewHelpers/Page/Header/AlternateViewHelper.php

<?php
namespace FluidTYPO3\Vhs\ViewHelpers\Page\Header;

/*
 * This file is part of the FluidTYPO3/Vhs project under GPLv2 or later.
 *
 * For the full copyright and license information, please read the
 * LICENSE.md file that was distributed with this source code.
 */

use FluidTYPO3\Vhs\Service\PageService;
use FluidTYPO3\Vhs\Traits\PageRendererTrait;
use FluidTYPO3\Vhs\Utility\ContextUtility;
use FluidTYPO3\Vhs\Utility\RequestResolver;
use TYPO3\CMS\Core\Page\PageRenderer;
use TYPO3\CMS\Core\Utility\GeneralUtility;
use TYPO3\CMS\Extbase\Mvc\Web\Routing\UriBuilder;
use TYPO3Fluid\Fluid\Core\ViewHelper\AbstractViewHelper;
use TYPO3Fluid\Fluid\Core\ViewHelper\TagBuilder;

/**
 * Returns the all alternate urls.
 */
class AlternateViewHelper extends AbstractViewHelper
{
    use PageRendererTrait;

    /**
     * @var PageService
     */
    protected $pageService;

    /**
     * @var TagBuilder
     */
    protected $tagBuilder;

    public function injectPageService(PageService $pageService): void
    {
        $this->pageService = $pageService;
    }

    public function __construct()
    {
        /** @var TagBuilder $tagBuilder */
        $tagBuilder = GeneralUtility::makeInstance(TagBuilder::class);
        $this->tagBuilder = $tagBuilder;
    }

    public function initializeArguments(): void
    {
        $this->registerArgument(
            'languages',
            'mixed',
            'The languages (either CSV, array or implementing Traversable)',
            true
        );
        $this->registerArgument('pageUid', 'integer', 'The page uid to check', false, 0);
        $this->registerArgument(
            'normalWhenNoLanguage',
            'boolean',
            'If TRUE, a missing page overlay should be ignored',
            false,
            false
        );
        $this->registerArgument(
            'addQueryString',
            'boolean',
            'If TRUE, the current query parameters will be kept in the URI',
            false,
            false
        );
    }

    /**
     * @return string
     */
    public function render()
    {
        if (ContextUtility::isBackend()) {
            return '';
        }

        /** @var array<int, string>|string $languages */
        $languages = $this->arguments['languages'];
        if ($languages instanceof \Traversable) {
            $languages = iterator_to_array($languages);
        } elseif (is_string($languages)) {
            $languages = GeneralUtility::trimExplode(',', $languages, true);
        } else {
            $languages = (array) $languages;
        }

        /** @var int $pageUid */
        $pageUid = $this->arguments['pageUid'];
        $pageUid = (integer) $pageUid;
        if (0 === $pageUid) {
            $pageUid = $GLOBALS['TSFE']->id;
        }

        /** @var bool $normalWhenNoLanguage */
        $normalWhenNoLanguage = $this->arguments['normalWhenNoLanguage'];
        $addQueryString = (boolean) $this->arguments['addQueryString'];

        /** @var UriBuilder $uriBuilder */
        $uriBuilder = GeneralUtility::makeInstance(UriBuilder::class);
        $uriBuilder->setRequest(RequestResolver::resolveRequestFromRenderingContext($this->renderingContext));

        $uriBuilder = $uriBuilder->reset()
            ->setTargetPageUid($pageUid)
            ->setCreateAbsoluteUri(true)
            ->setAddQueryString($addQueryString);

        $this->tagBuilder->reset();
        $this->tagBuilder->setTagName('link');
        $this->tagBuilder->addAttribute('rel', 'alternate');

        /** @var PageRenderer $pageRenderer */
        $pageRenderer = GeneralUtility::makeInstance(PageRenderer::class);
        $usePageRenderer = (1 !== (integer) ($GLOBALS['TSFE']->config['config']['disableAllHeaderCode'] ?? 0));
        $output = '';

        foreach ($languages as $languageUid => $languageName) {
            if (!$this->pageService->hidePageForLanguageUid($pageUid, $languageUid, $normalWhenNoLanguage)) {
                $uri = $uriBuilder->setArguments(['L' => $languageUid])->build();
                $this->tagBuilder->addAttribute('href', $uri);
                $this->tagBuilder->addAttribute('hreflang', $languageName);

                $renderedTag = $this->tagBuilder->render();
                if ($usePageRenderer) {
                    if (method_exists($pageRenderer, 'addMetaTag')) {
                        $pageRenderer->addMetaTag($renderedTag);
                    } else {
                        $pageRenderer->addHeaderData($renderedTag);
                    }
                } else {
                    $output .= $renderedTag . LF;
                }
            }
        }

        if (!$usePageRenderer) {
            return trim($output);
        }

        return '';
    }
}

1	<?php
2	namespace FluidTYPO3\Vhs\ViewHelpers\Page\Header;
3
4	/*
5	* This file is part of the FluidTYPO3/Vhs project under GPLv2 or later.
6	*
7	* For the full copyright and license information, please read the
8	* LICENSE.md file that was distributed with this source code.
9	*/
10
11	use FluidTYPO3\Vhs\Service\PageService;
12	use FluidTYPO3\Vhs\Traits\PageRendererTrait;
13	use FluidTYPO3\Vhs\Utility\ContextUtility;
14	use FluidTYPO3\Vhs\Utility\RequestResolver;
15	use TYPO3\CMS\Core\Page\PageRenderer;
16	use TYPO3\CMS\Core\Utility\GeneralUtility;
17	use TYPO3\CMS\Extbase\Mvc\Web\Routing\UriBuilder;
18	use TYPO3Fluid\Fluid\Core\ViewHelper\AbstractViewHelper;
19	use TYPO3Fluid\Fluid\Core\ViewHelper\TagBuilder;
20
21	/**
22	* Returns the all alternate urls.
23	*/
24	class AlternateViewHelper extends AbstractViewHelper
25	{
26	use PageRendererTrait;
27
28	/**
29	* @var PageService
30	*/
31	protected $pageService;
32
33	/**
34	* @var TagBuilder
35	*/
36	protected $tagBuilder;
37
38	public function injectPageService(PageService $pageService): void
39	{
40	$this->pageService = $pageService;	×
41	}
42
43	public function __construct()
44	{
45	/** @var TagBuilder $tagBuilder */
46	$tagBuilder = GeneralUtility::makeInstance(TagBuilder::class);	×
47	$this->tagBuilder = $tagBuilder;	×
48	}
49
50	public function initializeArguments(): void
51	{
52	$this->registerArgument(	7✔
53	'languages',	7✔
54	'mixed',	7✔
55	'The languages (either CSV, array or implementing Traversable)',	7✔
56	true	7✔
57	);	7✔
58	$this->registerArgument('pageUid', 'integer', 'The page uid to check', false, 0);	7✔
59	$this->registerArgument(	7✔
60	'normalWhenNoLanguage',	7✔
61	'boolean',	7✔
62	'If TRUE, a missing page overlay should be ignored',	7✔
63	false,	7✔
64	false	7✔
65	);	7✔
66	$this->registerArgument(	7✔
67	'addQueryString',	7✔
68	'boolean',	7✔
69	'If TRUE, the current query parameters will be kept in the URI',	7✔
70	false,	7✔
71	false	7✔
72	);	7✔
73	}
74
75	/**
76	* @return string
77	*/
78	public function render()
79	{
80	if (ContextUtility::isBackend()) {	×
81	return '';	×
82	}
83
84	/** @var array<int, string>\|string $languages */
85	$languages = $this->arguments['languages'];	×
86	if ($languages instanceof \Traversable) {	×
87	$languages = iterator_to_array($languages);	×
88	} elseif (is_string($languages)) {	×
89	$languages = GeneralUtility::trimExplode(',', $languages, true);	×
90	} else {
91	$languages = (array) $languages;	×
92	}
93
94	/** @var int $pageUid */
95	$pageUid = $this->arguments['pageUid'];	×
96	$pageUid = (integer) $pageUid;	×
97	if (0 === $pageUid) {	×
98	$pageUid = $GLOBALS['TSFE']->id;	×
99	}
100
101	/** @var bool $normalWhenNoLanguage */
102	$normalWhenNoLanguage = $this->arguments['normalWhenNoLanguage'];	×
103	$addQueryString = (boolean) $this->arguments['addQueryString'];	×
104
105	/** @var UriBuilder $uriBuilder */
106	$uriBuilder = GeneralUtility::makeInstance(UriBuilder::class);	×
107	$uriBuilder->setRequest(RequestResolver::resolveRequestFromRenderingContext($this->renderingContext));	×
108
109	$uriBuilder = $uriBuilder->reset()	×
110	->setTargetPageUid($pageUid)	×
111	->setCreateAbsoluteUri(true)	×
112	->setAddQueryString($addQueryString);	×
113
114	$this->tagBuilder->reset();	×
115	$this->tagBuilder->setTagName('link');	×
116	$this->tagBuilder->addAttribute('rel', 'alternate');	×
117
118	/** @var PageRenderer $pageRenderer */
119	$pageRenderer = GeneralUtility::makeInstance(PageRenderer::class);	×
120	$usePageRenderer = (1 !== (integer) ($GLOBALS['TSFE']->config['config']['disableAllHeaderCode'] ?? 0));	×
121	$output = '';	×
122
123	foreach ($languages as $languageUid => $languageName) {	×
124	if (!$this->pageService->hidePageForLanguageUid($pageUid, $languageUid, $normalWhenNoLanguage)) {	×
125	$uri = $uriBuilder->setArguments(['L' => $languageUid])->build();	×
126	$this->tagBuilder->addAttribute('href', $uri);	×
127	$this->tagBuilder->addAttribute('hreflang', $languageName);	×
128
129	$renderedTag = $this->tagBuilder->render();	×
130	if ($usePageRenderer) {	×
131	if (method_exists($pageRenderer, 'addMetaTag')) {	×
132	$pageRenderer->addMetaTag($renderedTag);	×
133	} else {
134	$pageRenderer->addHeaderData($renderedTag);	×
135	}
136	} else {
137	$output .= $renderedTag . LF;	×
138	}
139	}
140	}
141
142	if (!$usePageRenderer) {	×
143	return trim($output);	×
144	}
145
146	return '';	×
147	}
148	}

FluidTYPO3 / vhs / 13566190336

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous