BackendServices.php

<?php

namespace TYPO3\Languagevisibility\Service;

use Exception;
use TYPO3\CMS\Core\Site\Entity\SiteLanguage;
use TYPO3\CMS\Core\Site\SiteFinder;
use TYPO3\CMS\Core\Utility\GeneralUtility;
use TYPO3\CMS\Extbase\Utility\LocalizationUtility;
use TYPO3\Languagevisibility\Element\Element;
use TYPO3\Languagevisibility\Element\ElementFactory;
use TYPO3\Languagevisibility\Utility\ExtensionUtility;

/***************************************************************
 * Copyright notice
 *
 * (c) 2007 AOE media (dev@aoemedia.de)
 * All rights reserved
 *
 * This script is part of the TYPO3 project. The TYPO3 project is
 * free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * The GNU General Public License can be found at
 * http://www.gnu.org/copyleft/gpl.html.
 *
 * This script is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * This copyright notice MUST APPEAR in all copies of the script!
 ***************************************************************/

/**
 * Class BackendServices
 *
 * @package TYPO3\Languagevisibility\Service
 */
class BackendServices extends AbstractServices {

	/**
	 * @var array
	 */
	protected static $cache_isVisible = [];

	/**
	 * Helper function to check i an element with a given uid and tablename is visible for a languageid.
	 *
	 * @param array $row
	 * @param string $table
	 * @param int $languageUid
	 * @param boolean $omitLocal DEPRECATED since TYPO3 CMS 9 - is not used anymore because we only use the language visibility settings from the default language record
	 * @return bool
	 * @throws Exception
	 */
	public static function isVisible(array $row, string $table, int $languageUid, bool $omitLocal = FALSE): bool {

		$cacheKey = sprintf('%s:%d:%d', $table, $row['uid'], $languageUid);

		if (!isset(self::$cache_isVisible[$cacheKey])) {

			$siteFinder = GeneralUtility::makeInstance(SiteFinder::class);

			if ($table === 'pages') {
				$pid = $row['uid'];
			} else {
				$pid = $row['pid'];
			}

			try {
				$site = $siteFinder->getSiteByPageId($pid);
			} catch (\Exception $e) {
				return FALSE;
			}

			$language = $site->getLanguageById($languageUid);

			if (!$language instanceof SiteLanguage) {
				return FALSE;
			}

			$elementfactory = GeneralUtility::makeInstance(ElementFactory::class);

			try {
				$element = $elementfactory->getElementForTable($table, $row);
			} catch (Exception $e) {
				return FALSE;
			}

			$visibility = GeneralUtility::makeInstance(VisibilityService::class);

			self::$cache_isVisible[$cacheKey] = $visibility->isVisible($language, $element);
		}

		return self::$cache_isVisible[$cacheKey];
	}

	/**
	 * Helper function to check if a record from a given table in an overlayrecord
	 *
	 * @param array $row
	 * @param string $table
	 * @return bool
	 */
	public static function isOverlayRecord(array $row, string $table): bool {
		$result = FALSE;

		if (in_array($table, VisibilityService::getSupportedTables(), TRUE)) {
			$translationIdField = $GLOBALS['TCA'][$table]['ctrl']['transOrigPointerField'];
			if ($translationIdField !== '') {
				// if the field which points to the original of the translation is
				// not 0 a translation exists and we have an overlay record
				if (is_array($row[$translationIdField])) {
					// somehow the sys_language_uid field could contain 0 => 0
					$result = (int) $row[$translationIdField][0] !== 0;
				} else {
					$result = (int) $row[$translationIdField] !== 0;
				}
			}
		}

		return $result;
	}

	/**
	 * checks if the current BE_USER has access to the page record:
	 * that is the case if:
	 * a) new page created -> always because then the languagevisibility is set to never for all languages where the user has no access
	 * b) edit page record: only if the record is only visible in languages where the user has access to
	 * b.1) also if the languages that are visible and falls back to allowed languages
	 * c) delete: same as for edit (only if user has access to all visible languages)
	 *
	 * @param array $row
	 * @param string $cmd
	 * @return bool
	 * @throws Exception
	 */
	public static function hasUserAccessToPageRecord(array $row, string $cmd = 'edit'): bool {
		if ($cmd === 'new') {
			return TRUE;
		}

		$siteFinder = GeneralUtility::makeInstance(SiteFinder::class);

		try {
			$site = $siteFinder->getSiteByPageId($row['uid']);
		} catch (\Exception $e) {
			return FALSE;
		}

		$availableLanguages = $site->getAllLanguages();

		foreach ($availableLanguages as $language) {
			if (self::isVisible($row, 'pages', $language->getLanguageId())) {
				if (!$GLOBALS['BE_USER']->checkLanguageAccess($language->getLanguageId())) {
					//no access to a visible language: check fallbacks
					$isInFallback = FALSE;
					$fallbacks = $language->getFallbackLanguageIds();

					foreach ($fallbacks as $lId) {
						if ($GLOBALS['BE_USER']->checkLanguageAccess($lId)) {
							$isInFallback = TRUE;
							continue;
						}
					}
					if (!$isInFallback) {
						return FALSE;
					}
				}
			}
		}
		return TRUE;
	}

	/**
	 * checks if the current BE_USER has access to a record:
	 * that is the case if:
	 * a) new page created -> always because then the languagevisibility is set to never for all languages where the user has no access
	 * b) edit page record: only if the record is only visible in languages where the user has access to
	 *
	 * @param string $table
	 * @param array $row
	 * @return bool
	 * @throws Exception
	 */
	public static function hasUserAccessToEditRecord(string $table, array $row): bool {
		if (!self::isSupportedTable($table)) {
			return TRUE;
		}

		if (self::isOverlayRecord($row, $table)) {
			if ($GLOBALS['BE_USER']->checkLanguageAccess($row['sys_language_uid'])) {
				return TRUE;
			}

			return FALSE;
		}

		$siteFinder = GeneralUtility::makeInstance(SiteFinder::class);

		if ($table === 'pages') {
			$pid = $row['uid'];
		} else {
			$pid = $row['pid'];
		}

		try {
			$site = $siteFinder->getSiteByPageId($pid);
		} catch (\Exception $e) {
			return FALSE;
		}

		$availableLanguages = $site->getAllLanguages();

		foreach ($availableLanguages as $language) {
			if (self::isVisible($row, $table, $language->getLanguageId())) {
				if (!$GLOBALS['BE_USER']->checkLanguageAccess($language->getLanguageId())) {
					// no access to a visible language: check fallbacks
					$isInFallback = FALSE;
					$fallbacks = $language->getFallbackLanguageIds();

					foreach ($fallbacks as $lId) {
						if ($GLOBALS['BE_USER']->checkLanguageAccess($lId)) {
							// TODO - write testcase - this can't be right
							$isInFallback = TRUE;
							continue;
						}
					}

					if (!$isInFallback) {
						return FALSE;
					}
				}
			}
		}

		return TRUE;
	}

	/**
	 * Method to check if the translatedAsDefaultEnabled is enabled or not
	 *
	 * @return boolean
	 */
	protected static function isTranslatedAsDefaultEnabled(): bool {
		$confArr = ExtensionUtility::getExtensionConfiguration();
		if (is_array($confArr)) {
			return (bool) $confArr['translatedAsDefaultEnabled'];
		}

		return FALSE;
	}

	/**
	 * returns array with the visibility options that are allowed for the current user.
	 *
	 * @param SiteLanguage $language
	 * @param bool $isOverlay
	 * @param Element $element
	 * @return array
	 */
	public static function getAvailableOptionsForLanguage(
		SiteLanguage $language, bool $isOverlay = FALSE, Element $element = NULL
	): array {

		$uid = $language->getLanguageId();
		$select = [];

		if (!$isOverlay) {
			if ($uid === 0) {
				$select['active'] = 'active';
				$select['enforce'] = 'enforce';
				$select['inactive'] = 'inactive';
			} else {
				$select['active'] = 'active';
				$select['enforce'] = 'enforce';
				$select['translated'] = 'translated';
				$select['fallback'] = 'fallback';
				$select['inactive'] = 'inactive';
			}

			//check permissions, if user has no permission only no for the language is allowed
			// if the user has permissions for languages that act as fallback language: then the languages that falls back can have "-" in the options!
			if (!$GLOBALS['BE_USER']->checkLanguageAccess($uid)) {

				//check if the language falls back to one of the languages the user has permissions:
				$isInFallback = FALSE;
				$fallbacks = $language->getFallbackLanguageIds();

				foreach ($fallbacks as $lId) {
					if ($GLOBALS['BE_USER']->checkLanguageAccess($lId)) {
						$isInFallback = TRUE;
						continue;
					}
				}
				$select = [];
				if ($isInFallback) {
					$select['active'] = 'active';
				}

				if ($uid !== 0 && self::isTranslatedAsDefaultEnabled()) {
					$select['translated'] = 'translated';
				}
				$select['inactive'] = 'inactive';
			}
		} else {
			//overlays elements can only have "force to no"
			$select['active'] = 'active';
			$select['inactive'] = 'inactive';
		}

		/**
		 * Get translations of labels from the locallang file
		 */
		foreach ($select as $k => $v) {
			$select[$k] = LocalizationUtility::translate(
				'LLL:EXT:languagevisibility/Resources/Private/Language/locallang_db.xlf:tx_languagevisibility_visibility.I.' . $v,
				'languagevisibility'
			);
		}

		return $select;
	}
}