vendor/pimcore/pimcore/lib/Tool.php line 300

Open in your IDE?
  1. <?php
  3. /**
  4. * Pimcore
  5. *
  6. * This source file is available under two different licenses:
  7. * - GNU General Public License version 3 (GPLv3)
  8. * - Pimcore Commercial License (PCL)
  9. * Full copyright and license information is available in
  10. * LICENSE.md which is distributed with this source code.
  11. *
  12. * @copyright Copyright (c) Pimcore GmbH (http://www.pimcore.org)
  13. * @license http://www.pimcore.org/license GPLv3 and PCL
  14. */
  16. namespace Pimcore;
  18. use GuzzleHttp\RequestOptions;
  19. use Pimcore\Http\RequestHelper;
  20. use Pimcore\Localization\LocaleServiceInterface;
  21. use Pimcore\Model\Element;
  22. use Symfony\Component\HttpFoundation\Request;
  24. final class Tool
  25. {
  26. /**
  27. * Sets the current request to use when resolving request at early
  28. * stages (before container is loaded)
  29. *
  30. * @var Request
  31. */
  32. private static $currentRequest;
  34. /**
  35. * @var array
  36. */
  37. protected static $notFoundClassNames = [];
  39. /**
  40. * @var array
  41. */
  42. protected static $validLanguages = [];
  44. /**
  45. * @var null
  46. */
  47. protected static $isFrontend = null;
  49. /**
  50. * Sets the current request to operate on
  51. *
  52. * @param Request|null $request
  53. *
  54. * @internal
  55. */
  56. public static function setCurrentRequest(Request $request = null)
  57. {
  58. self::$currentRequest = $request;
  59. }
  61. /**
  62. * Checks, if the given language is configured in pimcore's system
  63. * settings at "Localization & Internationalization (i18n/l10n)".
  64. * Returns true, if the language is valid or no language is
  65. * configured at all, false otherwise.
  66. *
  67. * @static
  68. *
  69. * @param string $language
  70. *
  71. * @return bool
  72. */
  73. public static function isValidLanguage($language)
  74. {
  75. $language = (string) $language; // cast to string
  76. $languages = self::getValidLanguages();
  78. // if not configured, every language is valid
  79. if (!$languages) {
  80. return true;
  81. }
  83. if (in_array($language, $languages)) {
  84. return true;
  85. }
  87. return false;
  88. }
  90. /**
  91. * Returns an array of language codes that configured for this system
  92. * in pimcore's system settings at "Localization & Internationalization (i18n/l10n)".
  93. * An empty array is returned if no languages are configured.
  94. *
  95. * @static
  96. *
  97. * @return string[]
  98. */
  99. public static function getValidLanguages()
  100. {
  101. if (empty(self::$validLanguages)) {
  102. $config = Config::getSystemConfiguration('general');
  104. if (empty($config['valid_languages'])) {
  105. return [];
  106. }
  108. $validLanguages = str_replace(' ', '', (string)$config['valid_languages']);
  109. $languages = explode(',', $validLanguages);
  111. if (!is_array($languages)) {
  112. $languages = [];
  113. }
  115. self::$validLanguages = $languages;
  116. }
  118. return self::$validLanguages;
  119. }
  121. /**
  122. * @internal
  123. *
  124. * @param string $language
  125. *
  126. * @return array
  127. */
  128. public static function getFallbackLanguagesFor($language)
  129. {
  130. $languages = [];
  132. $config = Config::getSystemConfiguration('general');
  133. if (!empty($config['fallback_languages'][$language])) {
  134. $fallbackLanguages = explode(',', $config['fallback_languages'][$language]);
  135. foreach ($fallbackLanguages as $l) {
  136. if (self::isValidLanguage($l)) {
  137. $languages[] = trim($l);
  138. }
  139. }
  140. }
  142. return $languages;
  143. }
  145. /**
  146. * Returns the default language for this system. If no default is set,
  147. * returns the first language, or null, if no languages are configured
  148. * at all.
  149. *
  150. * @return null|string
  151. */
  152. public static function getDefaultLanguage()
  153. {
  154. $config = Config::getSystemConfiguration('general');
  155. $defaultLanguage = $config['default_language'] ?? null;
  156. $languages = self::getValidLanguages();
  158. if (!empty($languages) && in_array($defaultLanguage, $languages)) {
  159. return $defaultLanguage;
  160. } elseif (!empty($languages)) {
  161. return $languages[0];
  162. }
  164. return null;
  165. }
  167. /**
  168. * @return array|mixed
  169. *
  170. * @throws \Exception
  171. */
  172. public static function getSupportedLocales()
  173. {
  174. $localeService = \Pimcore::getContainer()->get(LocaleServiceInterface::class);
  175. $locale = $localeService->findLocale();
  177. $cacheKey = 'system_supported_locales_' . strtolower((string) $locale);
  178. if (!$languageOptions = Cache::load($cacheKey)) {
  179. $languages = $localeService->getLocaleList();
  181. $languageOptions = [];
  182. foreach ($languages as $code) {
  183. $translation = \Locale::getDisplayLanguage($code, $locale);
  184. $displayRegion = \Locale::getDisplayRegion($code, $locale);
  186. if ($displayRegion) {
  187. $translation .= ' (' . $displayRegion . ')';
  188. }
  190. if (!$translation) {
  191. $translation = $code;
  192. }
  194. $languageOptions[$code] = $translation;
  195. }
  197. asort($languageOptions);
  199. Cache::save($languageOptions, $cacheKey, ['system']);
  200. }
  202. return $languageOptions;
  203. }
  205. /**
  206. * @internal
  207. *
  208. * @param string $language
  209. * @param bool $absolutePath
  210. *
  211. * @return string
  212. */
  213. public static function getLanguageFlagFile($language, $absolutePath = true)
  214. {
  215. $basePath = '/bundles/pimcoreadmin/img/flags';
  216. $iconFsBasePath = PIMCORE_WEB_ROOT . $basePath;
  218. if ($absolutePath === true) {
  219. $basePath = PIMCORE_WEB_ROOT . $basePath;
  220. }
  222. $code = strtolower($language);
  223. $code = str_replace('_', '-', $code);
  224. $countryCode = null;
  225. $fallbackLanguageCode = null;
  227. $parts = explode('-', $code);
  228. if (count($parts) > 1) {
  229. $countryCode = array_pop($parts);
  230. $fallbackLanguageCode = $parts[0];
  231. }
  233. $languageFsPath = $iconFsBasePath . '/languages/' . $code . '.svg';
  234. $countryFsPath = $iconFsBasePath . '/countries/' . $countryCode . '.svg';
  235. $fallbackFsLanguagePath = $iconFsBasePath . '/languages/' . $fallbackLanguageCode . '.svg';
  237. $iconPath = ($absolutePath === true ? $iconFsBasePath : $basePath) . '/countries/_unknown.svg';
  239. $languageCountryMapping = [
  240. 'aa' => 'er', 'af' => 'za', 'am' => 'et', 'as' => 'in', 'ast' => 'es', 'asa' => 'tz',
  241. 'az' => 'az', 'bas' => 'cm', 'eu' => 'es', 'be' => 'by', 'bem' => 'zm', 'bez' => 'tz', 'bg' => 'bg',
  242. 'bm' => 'ml', 'bn' => 'bd', 'br' => 'fr', 'brx' => 'in', 'bs' => 'ba', 'cs' => 'cz', 'da' => 'dk',
  243. 'de' => 'de', 'dz' => 'bt', 'el' => 'gr', 'en' => 'gb', 'es' => 'es', 'et' => 'ee', 'fi' => 'fi',
  244. 'fo' => 'fo', 'fr' => 'fr', 'ga' => 'ie', 'gv' => 'im', 'he' => 'il', 'hi' => 'in', 'hr' => 'hr',
  245. 'hu' => 'hu', 'hy' => 'am', 'id' => 'id', 'ig' => 'ng', 'is' => 'is', 'it' => 'it', 'ja' => 'jp',
  246. 'ka' => 'ge', 'os' => 'ge', 'kea' => 'cv', 'kk' => 'kz', 'kl' => 'gl', 'km' => 'kh', 'ko' => 'kr',
  247. 'lg' => 'ug', 'lo' => 'la', 'lt' => 'lt', 'mg' => 'mg', 'mk' => 'mk', 'mn' => 'mn', 'ms' => 'my',
  248. 'mt' => 'mt', 'my' => 'mm', 'nb' => 'no', 'ne' => 'np', 'nl' => 'nl', 'nn' => 'no', 'pl' => 'pl',
  249. 'pt' => 'pt', 'ro' => 'ro', 'ru' => 'ru', 'sg' => 'cf', 'sk' => 'sk', 'sl' => 'si', 'sq' => 'al',
  250. 'sr' => 'rs', 'sv' => 'se', 'swc' => 'cd', 'th' => 'th', 'to' => 'to', 'tr' => 'tr', 'tzm' => 'ma',
  251. 'uk' => 'ua', 'uz' => 'uz', 'vi' => 'vn', 'zh' => 'cn', 'gd' => 'gb-sct', 'gd-gb' => 'gb-sct',
  252. 'cy' => 'gb-wls', 'cy-gb' => 'gb-wls', 'fy' => 'nl', 'xh' => 'za', 'yo' => 'bj', 'zu' => 'za',
  253. 'ta' => 'lk', 'te' => 'in', 'ss' => 'za', 'sw' => 'ke', 'so' => 'so', 'si' => 'lk', 'ii' => 'cn',
  254. 'zh-hans' => 'cn', 'zh-hant' => 'cn', 'sn' => 'zw', 'rm' => 'ch', 'pa' => 'in', 'fa' => 'ir', 'lv' => 'lv', 'gl' => 'es',
  255. 'fil' => 'ph',
  256. ];
  258. if (array_key_exists($code, $languageCountryMapping)) {
  259. $iconPath = $basePath . '/countries/' . $languageCountryMapping[$code] . '.svg';
  260. } elseif (file_exists($languageFsPath)) {
  261. $iconPath = $basePath . '/languages/' . $code . '.svg';
  262. } elseif ($countryCode && file_exists($countryFsPath)) {
  263. $iconPath = $basePath . '/countries/' . $countryCode . '.svg';
  264. } elseif ($fallbackLanguageCode && file_exists($fallbackFsLanguagePath)) {
  265. $iconPath = $basePath . '/languages/' . $fallbackLanguageCode . '.svg';
  266. }
  268. return $iconPath;
  269. }
  271. /**
  272. * @param Request|null $request
  273. *
  274. * @return null|Request
  275. */
  276. private static function resolveRequest(Request $request = null)
  277. {
  278. if (null === $request) {
  279. // do an extra check for the container as we might be in a state where no container is set yet
  280. if (\Pimcore::hasContainer()) {
  281. $request = \Pimcore::getContainer()->get('request_stack')->getMasterRequest();
  282. } else {
  283. if (null !== self::$currentRequest) {
  284. return self::$currentRequest;
  285. }
  286. }
  287. }
  289. return $request;
  290. }
  292. /**
  293. * @param Request|null $request
  294. *
  295. * @return bool
  296. */
  297. public static function isFrontend(Request $request = null): bool
  298. {
  299. if (null === $request) {
  300. $request = \Pimcore::getContainer()->get('request_stack')->getMasterRequest();
  301. }
  303. if (null === $request) {
  304. return false;
  305. }
  307. return \Pimcore::getContainer()
  308. ->get(RequestHelper::class)
  309. ->isFrontendRequest($request);
  310. }
  312. /**
  313. * eg. editmode, preview, version preview, always when it is a "frontend-request", but called out of the admin
  314. *
  315. * @param Request|null $request
  316. *
  317. * @return bool
  318. */
  319. public static function isFrontendRequestByAdmin(Request $request = null)
  320. {
  321. $request = self::resolveRequest($request);
  323. if (null === $request) {
  324. return false;
  325. }
  327. return \Pimcore::getContainer()
  328. ->get(RequestHelper::class)
  329. ->isFrontendRequestByAdmin($request);
  330. }
  332. /**
  333. * Verify element request (eg. editmode, preview, version preview) called within admin, with permissions.
  334. *
  335. * @param Request $request
  336. * @param Element\ElementInterface $element
  337. *
  338. * @return bool
  339. */
  340. public static function isElementRequestByAdmin(Request $request, Element\ElementInterface $element)
  341. {
  342. if (!self::isFrontendRequestByAdmin($request)) {
  343. return false;
  344. }
  346. $user = Tool\Authentication::authenticateSession($request);
  348. return $user && $element->isAllowed('view', $user);
  349. }
  351. /**
  352. * @internal
  353. *
  354. * @param Request|null $request
  355. *
  356. * @return bool
  357. */
  358. public static function useFrontendOutputFilters(Request $request = null)
  359. {
  360. $request = self::resolveRequest($request);
  362. if (null === $request) {
  363. return false;
  364. }
  366. if (!self::isFrontend($request)) {
  367. return false;
  368. }
  370. if (self::isFrontendRequestByAdmin($request)) {
  371. return false;
  372. }
  374. $requestKeys = array_merge(
  375. array_keys($request->query->all()),
  376. array_keys($request->request->all())
  377. );
  379. // check for manually disabled ?pimcore_outputfilters_disabled=true
  380. if (in_array('pimcore_outputfilters_disabled', $requestKeys) && \Pimcore::inDebugMode()) {
  381. return false;
  382. }
  384. return true;
  385. }
  387. /**
  388. * @internal
  389. *
  390. * @param Request|null $request
  391. *
  392. * @return null|string
  393. */
  394. public static function getHostname(Request $request = null)
  395. {
  396. $request = self::resolveRequest($request);
  398. if (null === $request) {
  399. return null;
  400. }
  402. return $request->getHost();
  403. }
  405. /**
  406. * @internal
  407. *
  408. * @return string
  409. */
  410. public static function getRequestScheme(Request $request = null)
  411. {
  412. $request = self::resolveRequest($request);
  414. if (null === $request) {
  415. return 'http';
  416. }
  418. return $request->getScheme();
  419. }
  421. /**
  422. * Returns the host URL
  423. *
  424. * @param string|null $useProtocol use a specific protocol
  425. * @param Request|null $request
  426. *
  427. * @return string
  428. */
  429. public static function getHostUrl($useProtocol = null, Request $request = null)
  430. {
  431. $request = self::resolveRequest($request);
  433. $protocol = 'http';
  434. $hostname = '';
  435. $port = '';
  437. if (null !== $request) {
  438. $protocol = $request->getScheme();
  439. $hostname = $request->getHost();
  441. if (!in_array($request->getPort(), [443, 80])) {
  442. $port = ':' . $request->getPort();
  443. }
  444. }
  446. // get it from System settings
  447. if (!$hostname || $hostname == 'localhost') {
  448. $systemConfig = Config::getSystemConfiguration('general');
  449. $hostname = $systemConfig['domain'] ?? null;
  451. if (!$hostname) {
  452. Logger::warn('Couldn\'t determine HTTP Host. No Domain set in "Settings" -> "System" -> "Website" -> "Domain"');
  454. return '';
  455. }
  456. }
  458. if ($useProtocol) {
  459. $protocol = $useProtocol;
  460. }
  462. return $protocol . '://' . $hostname . $port;
  463. }
  465. /**
  466. * @internal
  467. *
  468. * @param Request|null $request
  469. *
  470. * @return string|null
  471. */
  472. public static function getClientIp(Request $request = null)
  473. {
  474. $request = self::resolveRequest($request);
  475. if ($request) {
  476. return $request->getClientIp();
  477. }
  479. // fallback to $_SERVER variables
  480. if (!empty($_SERVER['HTTP_CLIENT_IP'])) {
  481. $ip = $_SERVER['HTTP_CLIENT_IP'];
  482. } elseif (!empty($_SERVER['HTTP_X_FORWARDED_FOR'])) {
  483. $ip = $_SERVER['HTTP_X_FORWARDED_FOR'];
  484. } elseif (!empty($_SERVER['REMOTE_ADDR'])) {
  485. $ip = $_SERVER['REMOTE_ADDR'];
  486. } else {
  487. return null;
  488. }
  490. $ips = explode(',', $ip);
  491. $ip = trim(array_shift($ips));
  493. return $ip;
  494. }
  496. /**
  497. * @internal
  498. *
  499. * @param Request|null $request
  500. *
  501. * @return null|string
  502. */
  503. public static function getAnonymizedClientIp(Request $request = null)
  504. {
  505. $request = self::resolveRequest($request);
  507. if (null === $request) {
  508. return null;
  509. }
  511. return \Pimcore::getContainer()
  512. ->get(RequestHelper::class)
  513. ->getAnonymizedClientIp($request);
  514. }
  516. /**
  517. * @internal
  518. *
  519. * @return array|bool
  520. */
  521. public static function getCustomViewConfig()
  522. {
  523. $configFile = \Pimcore\Config::locateConfigFile('customviews.php');
  525. if (!is_file($configFile)) {
  526. $cvData = false;
  527. } else {
  528. $confArray = include($configFile);
  529. $cvData = [];
  531. foreach ($confArray['views'] as $tmp) {
  532. if (isset($tmp['name'])) {
  533. $tmp['showroot'] = !empty($tmp['showroot']);
  535. if (!is_array($tmp['classes'] ?? [])) {
  536. $flipArray = [];
  537. $tempClasses = explode(',', $tmp['classes']);
  539. foreach ($tempClasses as $tempClass) {
  540. $flipArray[$tempClass] = null;
  541. }
  542. $tmp['classes'] = $flipArray;
  543. }
  545. if (!empty($tmp['hidden'])) {
  546. continue;
  547. }
  549. $cvData[] = $tmp;
  550. }
  551. }
  552. }
  554. return $cvData;
  555. }
  557. /**
  558. * @param array|string|null $recipients
  559. * @param string|null $subject
  560. *
  561. * @return Mail
  562. *
  563. * @throws \Exception
  564. */
  565. public static function getMail($recipients = null, $subject = null)
  566. {
  567. $mail = new Mail();
  569. if ($recipients) {
  570. if (is_string($recipients)) {
  571. $mail->addTo($recipients);
  572. } elseif (is_array($recipients)) {
  573. foreach ($recipients as $recipient) {
  574. $mail->addTo($recipient);
  575. }
  576. }
  577. }
  579. if ($subject) {
  580. $mail->setSubject($subject);
  581. }
  583. return $mail;
  584. }
  586. /**
  587. * @param string $url
  588. * @param array $paramsGet
  589. * @param array $paramsPost
  590. * @param array $options
  591. *
  592. * @return bool|string
  593. */
  594. public static function getHttpData($url, $paramsGet = [], $paramsPost = [], $options = [])
  595. {
  596. $client = \Pimcore::getContainer()->get('pimcore.http_client');
  597. $requestType = 'GET';
  599. if (!isset($options['timeout'])) {
  600. $options['timeout'] = 5;
  601. }
  603. if (is_array($paramsGet) && count($paramsGet) > 0) {
  605. //need to insert get params from url to $paramsGet because otherwise the would be ignored
  606. $urlParts = parse_url($url);
  607. $urlParams = [];
  608. parse_str($urlParts['query'], $urlParams);
  610. if ($urlParams) {
  611. $paramsGet = array_merge($urlParams, $paramsGet);
  612. }
  614. $options[RequestOptions::QUERY] = $paramsGet;
  615. }
  617. if (is_array($paramsPost) && count($paramsPost) > 0) {
  618. $options[RequestOptions::FORM_PARAMS] = $paramsPost;
  619. $requestType = 'POST';
  620. }
  622. try {
  623. $response = $client->request($requestType, $url, $options);
  625. if ($response->getStatusCode() < 300) {
  626. return (string)$response->getBody();
  627. }
  628. } catch (\Exception $e) {
  629. }
  631. return false;
  632. }
  634. /**
  635. * @internal
  636. *
  637. * @param string $class
  638. *
  639. * @return bool
  640. */
  641. public static function classExists($class)
  642. {
  643. return self::classInterfaceExists($class, 'class');
  644. }
  646. /**
  647. * @internal
  648. *
  649. * @param string $class
  650. *
  651. * @return bool
  652. */
  653. public static function interfaceExists($class)
  654. {
  655. return self::classInterfaceExists($class, 'interface');
  656. }
  658. /**
  659. * @internal
  660. *
  661. * @param string $class
  662. *
  663. * @return bool
  664. */
  665. public static function traitExists($class)
  666. {
  667. return self::classInterfaceExists($class, 'trait');
  668. }
  670. /**
  671. * @param string $class
  672. * @param string $type (e.g. 'class', 'interface', 'trait')
  673. *
  674. * @return bool
  675. */
  676. private static function classInterfaceExists($class, $type)
  677. {
  678. $functionName = $type . '_exists';
  680. // if the class is already loaded we can skip right here
  681. if ($functionName($class, false)) {
  682. return true;
  683. }
  685. $class = '\\' . ltrim($class, '\\');
  687. // let's test if we have seens this class already before
  688. if (isset(self::$notFoundClassNames[$class])) {
  689. return false;
  690. }
  692. // we need to set a custom error handler here for the time being
  693. // unfortunately suppressNotFoundWarnings() doesn't work all the time, it has something to do with the calls in
  694. // Pimcore\Tool::ClassMapAutoloader(), but don't know what actual conditions causes this problem.
  695. // but to be save we log the errors into the debug.log, so if anything else happens we can see it there
  696. // the normal warning is e.g. Warning: include_once(Path/To/Class.php): failed to open stream: No such file or directory in ...
  697. set_error_handler(function ($errno, $errstr, $errfile, $errline) {
  698. //Logger::debug(implode(" ", [$errno, $errstr, $errfile, $errline]));
  699. });
  701. $exists = $functionName($class);
  703. restore_error_handler();
  705. if (!$exists) {
  706. self::$notFoundClassNames[$class] = true; // value doesn't matter, key lookups are faster ;-)
  707. }
  709. return $exists;
  710. }
  712. /**
  713. * @internal
  714. *
  715. * @return array
  716. */
  717. public static function getCachedSymfonyEnvironments(): array
  718. {
  719. $dirs = glob(PIMCORE_SYMFONY_CACHE_DIRECTORY . '/*', GLOB_ONLYDIR);
  720. if (($key = array_search(PIMCORE_CACHE_DIRECTORY, $dirs)) !== false) {
  721. unset($dirs[$key]);
  722. }
  723. $dirs = array_map('basename', $dirs);
  725. return array_values($dirs);
  726. }
  728. /**
  729. * @internal
  730. *
  731. * @param string $message
  732. */
  733. public static function exitWithError($message)
  734. {
  735. while (@ob_end_flush());
  737. if (php_sapi_name() != 'cli') {
  738. header('HTTP/1.1 503 Service Temporarily Unavailable');
  739. }
  741. die($message);
  742. }
  743. }