vendor/pimcore/pimcore/bundles/AdminBundle/Controller/Admin/SettingsController.php line 62

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\Bundle\AdminBundle\Controller\Admin;
  18. use Pimcore\Bundle\AdminBundle\Controller\AdminAbstractController;
  19. use Pimcore\Cache;
  20. use Pimcore\Cache\Core\CoreCacheHandler;
  21. use Pimcore\Cache\Symfony\CacheClearer;
  22. use Pimcore\Config;
  23. use Pimcore\Db;
  24. use Pimcore\Event\SystemEvents;
  25. use Pimcore\File;
  26. use Pimcore\Helper\StopMessengerWorkersTrait;
  27. use Pimcore\Localization\LocaleServiceInterface;
  28. use Pimcore\Logger;
  29. use Pimcore\Model;
  30. use Pimcore\Model\Asset;
  31. use Pimcore\Model\Document;
  32. use Pimcore\Model\Element;
  33. use Pimcore\Model\Exception\ConfigWriteException;
  34. use Pimcore\Model\Glossary;
  35. use Pimcore\Model\Metadata;
  36. use Pimcore\Model\Property;
  37. use Pimcore\Model\Staticroute;
  38. use Pimcore\Model\Tool\SettingsStore;
  39. use Pimcore\Model\WebsiteSetting;
  40. use Pimcore\Tool;
  41. use Symfony\Component\EventDispatcher\EventDispatcherInterface;
  42. use Symfony\Component\EventDispatcher\GenericEvent;
  43. use Symfony\Component\Filesystem\Filesystem;
  44. use Symfony\Component\HttpFoundation\File\UploadedFile;
  45. use Symfony\Component\HttpFoundation\JsonResponse;
  46. use Symfony\Component\HttpFoundation\Request;
  47. use Symfony\Component\HttpFoundation\Response;
  48. use Symfony\Component\HttpFoundation\StreamedResponse;
  49. use Symfony\Component\HttpKernel\Event\TerminateEvent;
  50. use Symfony\Component\HttpKernel\Exception\AccessDeniedHttpException;
  51. use Symfony\Component\HttpKernel\KernelEvents;
  52. use Symfony\Component\HttpKernel\KernelInterface;
  53. use Symfony\Component\Routing\Annotation\Route;
  54. use Symfony\Component\Yaml\Yaml;
  55. use Symfony\Contracts\Translation\TranslatorInterface;
  57. /**
  58.  * @Route("/settings")
  59.  *
  60.  * @internal
  61.  */
  62. class SettingsController extends AdminAbstractController
  63. {
  64.     use StopMessengerWorkersTrait;
  66.     private const CUSTOM_LOGO_PATH = 'custom-logo.image';
  68.     public function __construct(protected TranslatorInterface $translator)
  69.     {
  70.     }
  72.     /**
  73.      * @Route("/display-custom-logo", name="pimcore_settings_display_custom_logo", methods={"GET"})
  74.      *
  75.      * @param Request $request
  76.      *
  77.      * @return StreamedResponse
  78.      */
  79.     public function displayCustomLogoAction(Request $request)
  80.     {
  81.         $mime = 'image/svg+xml';
  82.         if ($request->get('white')) {
  83.             $logo = PIMCORE_WEB_ROOT . '/bundles/pimcoreadmin/img/logo-claim-white.svg';
  84.         } else {
  85.             $logo = PIMCORE_WEB_ROOT . '/bundles/pimcoreadmin/img/logo-claim-gray.svg';
  86.         }
  88.         $stream = fopen($logo, 'rb');
  90.         $storage = Tool\Storage::get('admin');
  91.         if ($storage->fileExists(self::CUSTOM_LOGO_PATH)) {
  92.             try {
  93.                 $mime = $storage->mimeType(self::CUSTOM_LOGO_PATH);
  94.                 $stream = $storage->readStream(self::CUSTOM_LOGO_PATH);
  95.             } catch (\Exception $e) {
  96.                 // do nothing
  97.             }
  98.         }
  100.         return new StreamedResponse(function () use ($stream) {
  101.             fpassthru($stream);
  102.         }, 200, [
  103.             'Content-Type' => $mime,
  104.             'Content-Security-Policy' => "script-src 'none'",
  105.         ]);
  106.     }
  108.     /**
  109.      * @Route("/upload-custom-logo", name="pimcore_admin_settings_uploadcustomlogo", methods={"POST"})
  110.      *
  111.      * @param Request $request
  112.      *
  113.      * @return JsonResponse
  114.      *
  115.      * @throws \Exception
  116.      */
  117.     public function uploadCustomLogoAction(Request $request)
  118.     {
  119.         $logoFile = $request->files->get('Filedata');
  121.         if (!$logoFile instanceof UploadedFile
  122.             || !in_array($logoFile->guessExtension(), ['svg', 'png', 'jpg'])
  123.         ) {
  124.             throw new \Exception('Unsupported file format.');
  125.         }
  127.         $storage = Tool\Storage::get('admin');
  128.         $storage->writeStream(self::CUSTOM_LOGO_PATH, fopen($logoFile->getPathname(), 'rb'));
  130.         // set content-type to text/html, otherwise (when application/json is sent) chrome will complain in
  131.         // Ext.form.Action.Submit and mark the submission as failed
  133.         $response = $this->adminJson(['success' => true]);
  134.         $response->headers->set('Content-Type', 'text/html');
  136.         return $response;
  137.     }
  139.     /**
  140.      * @Route("/delete-custom-logo", name="pimcore_admin_settings_deletecustomlogo", methods={"DELETE"})
  141.      *
  142.      * @param Request $request
  143.      *
  144.      * @return JsonResponse
  145.      */
  146.     public function deleteCustomLogoAction(Request $request)
  147.     {
  148.         if (Tool\Storage::get('admin')->fileExists(self::CUSTOM_LOGO_PATH)) {
  149.             Tool\Storage::get('admin')->delete(self::CUSTOM_LOGO_PATH);
  150.         }
  152.         return $this->adminJson(['success' => true]);
  153.     }
  155.     /**
  156.      * Used by the predefined metadata grid
  157.      *
  158.      * @Route("/predefined-metadata", name="pimcore_admin_settings_metadata", methods={"POST"})
  159.      *
  160.      * @param Request $request
  161.      *
  162.      * @return JsonResponse
  163.      */
  164.     public function metadataAction(Request $request)
  165.     {
  166.         $this->checkPermission('asset_metadata');
  168.         if ($request->get('data')) {
  169.             if ($request->get('xaction') == 'destroy') {
  170.                 $data = $this->decodeJson($request->get('data'));
  171.                 $id = $data['id'];
  172.                 $metadata = Metadata\Predefined::getById($id);
  173.                 if (!$metadata->isWriteable()) {
  174.                     throw new ConfigWriteException();
  175.                 }
  176.                 $metadata->delete();
  178.                 return $this->adminJson(['success' => true, 'data' => []]);
  179.             } elseif ($request->get('xaction') == 'update') {
  180.                 $data = $this->decodeJson($request->get('data'));
  182.                 // save type
  183.                 $metadata = Metadata\Predefined::getById($data['id']);
  184.                 if (!$metadata->isWriteable()) {
  185.                     throw new ConfigWriteException();
  186.                 }
  187.                 $metadata->setValues($data);
  189.                 $existingItem = Metadata\Predefined\Listing::getByKeyAndLanguage($metadata->getName(), $metadata->getLanguage(), $metadata->getTargetSubtype());
  190.                 if ($existingItem && $existingItem->getId() != $metadata->getId()) {
  191.                     return $this->adminJson(['message' => 'rule_violation', 'success' => false]);
  192.                 }
  194.                 $metadata->minimize();
  195.                 $metadata->save();
  196.                 $metadata->expand();
  198.                 $responseData = $metadata->getObjectVars();
  199.                 $responseData['writeable'] = $metadata->isWriteable();
  201.                 return $this->adminJson(['data' => $responseData, 'success' => true]);
  202.             } elseif ($request->get('xaction') == 'create') {
  203.                 if (!(new Metadata\Predefined())->isWriteable()) {
  204.                     throw new ConfigWriteException();
  205.                 }
  206.                 $data = $this->decodeJson($request->get('data'));
  207.                 unset($data['id']);
  209.                 // save type
  210.                 $metadata = Metadata\Predefined::create();
  212.                 $metadata->setValues($data);
  214.                 $existingItem = Metadata\Predefined\Listing::getByKeyAndLanguage($metadata->getName(), $metadata->getLanguage(), $metadata->getTargetSubtype());
  215.                 if ($existingItem) {
  216.                     return $this->adminJson(['message' => 'rule_violation', 'success' => false]);
  217.                 }
  219.                 $metadata->save();
  221.                 $responseData = $metadata->getObjectVars();
  222.                 $responseData['writeable'] = $metadata->isWriteable();
  224.                 return $this->adminJson(['data' => $responseData, 'success' => true]);
  225.             }
  226.         } else {
  227.             // get list of types
  228.             $list = new Metadata\Predefined\Listing();
  230.             if ($filter = $request->get('filter')) {
  231.                 $list->setFilter(function (Metadata\Predefined $predefined) use ($filter) {
  232.                     foreach ($predefined->getObjectVars() as $value) {
  233.                         if (stripos((string)$value, $filter) !== false) {
  234.                             return true;
  235.                         }
  236.                     }
  238.                     return false;
  239.                 });
  240.             }
  242.             $properties = [];
  243.             foreach ($list->getDefinitions() as $metadata) {
  244.                 $metadata->expand();
  245.                 $data = $metadata->getObjectVars();
  246.                 $data['writeable'] = $metadata->isWriteable();
  247.                 $properties[] = $data;
  248.             }
  250.             return $this->adminJson(['data' => $properties, 'success' => true, 'total' => $list->getTotalCount()]);
  251.         }
  253.         return $this->adminJson(['success' => false]);
  254.     }
  256.     /**
  257.      * @Route("/get-predefined-metadata", name="pimcore_admin_settings_getpredefinedmetadata", methods={"GET"})
  258.      *
  259.      * @param Request $request
  260.      *
  261.      * @return JsonResponse
  262.      */
  263.     public function getPredefinedMetadataAction(Request $request)
  264.     {
  265.         $type = $request->get('type');
  266.         $subType = $request->get('subType');
  267.         $group = $request->get('group');
  268.         $list = Metadata\Predefined\Listing::getByTargetType($type, [$subType]);
  269.         $result = [];
  270.         foreach ($list as $item) {
  271.             $itemGroup = $item->getGroup() ?? '';
  272.             if ($group === 'default' || $group === $itemGroup) {
  273.                 $item->expand();
  274.                 $data = $item->getObjectVars();
  275.                 $data['writeable'] = $item->isWriteable();
  276.                 $result[] = $data;
  277.             }
  278.         }
  280.         return $this->adminJson(['data' => $result, 'success' => true]);
  281.     }
  283.     /**
  284.      * @Route("/properties", name="pimcore_admin_settings_properties", methods={"POST"})
  285.      *
  286.      * @param Request $request
  287.      *
  288.      * @return JsonResponse
  289.      */
  290.     public function propertiesAction(Request $request)
  291.     {
  292.         if ($request->get('data')) {
  293.             $this->checkPermission('predefined_properties');
  295.             if ($request->get('xaction') == 'destroy') {
  296.                 $data = $this->decodeJson($request->get('data'));
  297.                 $id = $data['id'];
  298.                 $property = Property\Predefined::getById($id);
  299.                 if (!$property->isWriteable()) {
  300.                     throw new ConfigWriteException();
  301.                 }
  302.                 $property->delete();
  304.                 return $this->adminJson(['success' => true, 'data' => []]);
  305.             } elseif ($request->get('xaction') == 'update') {
  306.                 $data = $this->decodeJson($request->get('data'));
  308.                 // save type
  309.                 $property = Property\Predefined::getById($data['id']);
  310.                 if (!$property->isWriteable()) {
  311.                     throw new ConfigWriteException();
  312.                 }
  313.                 if (is_array($data['ctype'])) {
  314.                     $data['ctype'] = implode(',', $data['ctype']);
  315.                 }
  316.                 $property->setValues($data);
  318.                 $property->save();
  320.                 $responseData = $property->getObjectVars();
  321.                 $responseData['writeable'] = $property->isWriteable();
  323.                 return $this->adminJson(['data' => $responseData, 'success' => true]);
  324.             } elseif ($request->get('xaction') == 'create') {
  325.                 if (!(new Property\Predefined())->isWriteable()) {
  326.                     throw new ConfigWriteException();
  327.                 }
  328.                 $data = $this->decodeJson($request->get('data'));
  329.                 unset($data['id']);
  331.                 // save type
  332.                 $property = Property\Predefined::create();
  333.                 $property->setValues($data);
  335.                 $property->save();
  337.                 $responseData = $property->getObjectVars();
  338.                 $responseData['writeable'] = $property->isWriteable();
  340.                 return $this->adminJson(['data' => $responseData, 'success' => true]);
  341.             }
  342.         } else {
  343.             // get list of types
  344.             $list = new Property\Predefined\Listing();
  346.             if ($filter = $request->get('filter')) {
  347.                 $list->setFilter(function (Property\Predefined $predefined) use ($filter) {
  348.                     foreach ($predefined->getObjectVars() as $value) {
  349.                         if ($value) {
  350.                             $cellValues = is_array($value) ? $value : [$value];
  352.                             foreach ($cellValues as $cellValue) {
  353.                                 if (stripos((string)$cellValue, $filter) !== false) {
  354.                                     return true;
  355.                                 }
  356.                             }
  357.                         }
  358.                     }
  360.                     return false;
  361.                 });
  362.             }
  364.             $properties = [];
  365.             foreach ($list->getProperties() as $property) {
  366.                 $data = $property->getObjectVars();
  367.                 $data['writeable'] = $property->isWriteable();
  368.                 $properties[] = $data;
  369.             }
  371.             return $this->adminJson(['data' => $properties, 'success' => true, 'total' => $list->getTotalCount()]);
  372.         }
  374.         return $this->adminJson(['success' => false]);
  375.     }
  377.     /**
  378.      * @Route("/get-system", name="pimcore_admin_settings_getsystem", methods={"GET"})
  379.      *
  380.      * @param Request $request
  381.      * @param Config $config
  382.      *
  383.      * @return JsonResponse
  384.      */
  385.     public function getSystemAction(Request $request, Config $config)
  386.     {
  387.         $this->checkPermission('system_settings');
  389.         $valueArray = [
  390.             'general' => $config['general'],
  391.             'documents' => $config['documents'],
  392.             'assets' => $config['assets'],
  393.             'objects' => $config['objects'],
  394.             'branding' => $config['branding'],
  395.             'email' => $config['email'],
  396.         ];
  398.         $locales = Tool::getSupportedLocales();
  399.         $languageOptions = [];
  400.         $validLanguages = [];
  401.         foreach ($locales as $short => $translation) {
  402.             if (!empty($short)) {
  403.                 $languageOptions[] = [
  404.                     'language' => $short,
  405.                     'display' => $translation . " ($short)",
  406.                 ];
  407.                 $validLanguages[] = $short;
  408.             }
  409.         }
  411.         $valueArray['general']['valid_language'] = explode(',', $valueArray['general']['valid_languages']);
  413.         //for "wrong" legacy values
  414.         foreach ($valueArray['general']['valid_language'] as $existingValue) {
  415.             if (!in_array($existingValue, $validLanguages)) {
  416.                 $languageOptions[] = [
  417.                     'language' => $existingValue,
  418.                     'display' => $existingValue,
  419.                 ];
  420.             }
  421.         }
  423.         $response = [
  424.             'values' => $valueArray,
  425.             'config' => [
  426.                 'languages' => $languageOptions,
  427.             ],
  428.         ];
  430.         return $this->adminJson($response);
  431.     }
  433.     /**
  434.      * @Route("/set-system", name="pimcore_admin_settings_setsystem", methods={"PUT"})
  435.      *
  436.      * @param Request $request
  437.      * @param LocaleServiceInterface $localeService
  438.      *
  439.      * @return JsonResponse
  440.      */
  441.     public function setSystemAction(
  442.         LocaleServiceInterface $localeService,
  443.         Request $request,
  444.         KernelInterface $kernel,
  445.         EventDispatcherInterface $eventDispatcher,
  446.         CoreCacheHandler $cache,
  447.         Filesystem $filesystem,
  448.         CacheClearer $symfonyCacheClearer
  449.     ) {
  450.         $this->checkPermission('system_settings');
  452.         $values = $this->decodeJson($request->get('data'));
  454.         $existingValues = [];
  456.         try {
  457.             $file = Config::locateConfigFile('system.yml');
  458.             $existingValues = Config::getConfigInstance($file, true);
  459.         } catch (\Exception $e) {
  460.             // nothing to do
  461.         }
  463.         // localized error pages
  464.         $localizedErrorPages = [];
  466.         // fallback languages
  467.         $fallbackLanguages = [];
  468.         $existingValues['pimcore']['general']['fallback_languages'] = [];
  469.         $languages = explode(',', $values['general.validLanguages']);
  470.         $filteredLanguages = [];
  472.         foreach ($languages as $language) {
  473.             if (isset($values['general.fallbackLanguages.' . $language])) {
  474.                 $fallbackLanguages[$language] = str_replace(' ', '', $values['general.fallbackLanguages.' . $language]);
  475.             }
  477.             // localized error pages
  478.             if (isset($values['documents.error_pages.localized.' . $language])) {
  479.                 $localizedErrorPages[$language] = $values['documents.error_pages.localized.' . $language];
  480.             }
  482.             if ($localeService->isLocale($language)) {
  483.                 $filteredLanguages[] = $language;
  484.             }
  485.         }
  487.         // check if there's a fallback language endless loop
  488.         foreach ($fallbackLanguages as $sourceLang => $targetLang) {
  489.             $this->checkFallbackLanguageLoop($sourceLang, $fallbackLanguages);
  490.         }
  492.         $settings['pimcore'] = [
  493.             'general' => [
  494.                 'domain' => $values['general.domain'],
  495.                 'redirect_to_maindomain' => $values['general.redirect_to_maindomain'],
  496.                 'language' => $values['general.language'],
  497.                 'valid_languages' => implode(',', $filteredLanguages),
  498.                 'fallback_languages' => $fallbackLanguages,
  499.                 'default_language' => $values['general.defaultLanguage'],
  500.                 'debug_admin_translations' => $values['general.debug_admin_translations'],
  501.             ],
  502.             'documents' => [
  503.                 'versions' => [
  504.                     'days' => $values['documents.versions.days'] ?? null,
  505.                     'steps' => $values['documents.versions.steps'] ?? null,
  506.                 ],
  507.                 'error_pages' => [
  508.                     'default' => $values['documents.error_pages.default'],
  509.                     'localized' => $localizedErrorPages,
  510.                 ],
  511.             ],
  512.             'objects' => [
  513.                 'versions' => [
  514.                     'days' => $values['objects.versions.days'] ?? null,
  515.                     'steps' => $values['objects.versions.steps'] ?? null,
  516.                 ],
  517.             ],
  518.             'assets' => [
  519.                 'versions' => [
  520.                     'days' => $values['assets.versions.days'] ?? null,
  521.                     'steps' => $values['assets.versions.steps'] ?? null,
  522.                 ],
  523.                 'hide_edit_image' => $values['assets.hide_edit_image'],
  524.                 'disable_tree_preview' => $values['assets.disable_tree_preview'],
  525.             ],
  526.         ];
  528.         //branding
  529.         $settings['pimcore_admin'] = [
  530.             'branding' =>
  531.                 [
  532.                     'login_screen_invert_colors' => $values['branding.login_screen_invert_colors'],
  533.                     'color_login_screen' => $values['branding.color_login_screen'],
  534.                     'color_admin_interface' => $values['branding.color_admin_interface'],
  535.                     'color_admin_interface_background' => $values['branding.color_admin_interface_background'],
  536.                     'login_screen_custom_image' => str_replace('%', '%%', $values['branding.login_screen_custom_image']),
  537.                 ],
  538.         ];
  540.         if (array_key_exists('email.debug.emailAddresses', $values) && $values['email.debug.emailAddresses']) {
  541.             $settings['pimcore']['email']['debug']['email_addresses'] = $values['email.debug.emailAddresses'];
  542.         }
  544.         $settingsYml = Yaml::dump($settings, 5);
  545.         $configFile = Config::locateConfigFile('system.yml');
  546.         File::put($configFile, $settingsYml);
  548.         // clear all caches
  549.         $this->clearSymfonyCache($request, $kernel, $eventDispatcher, $symfonyCacheClearer);
  550.         $this->stopMessengerWorkers();
  552.         $eventDispatcher->addListener(KernelEvents::TERMINATE, function (TerminateEvent $event) use (
  553.             $cache, $eventDispatcher, $filesystem
  554.         ) {
  555.             // we need to clear the cache with a delay, because the cache is used by messenger:stop-workers
  556.             // to send the stop signal to all worker processes
  557.             sleep(2);
  558.             $this->clearPimcoreCache($cache, $eventDispatcher, $filesystem);
  559.         });
  561.         return $this->adminJson(['success' => true]);
  562.     }
  564.     /**
  565.      * @param string $source
  566.      * @param array $definitions
  567.      * @param array $fallbacks
  568.      *
  569.      * @throws \Exception
  570.      */
  571.     protected function checkFallbackLanguageLoop($source, $definitions, $fallbacks = [])
  572.     {
  573.         if (isset($definitions[$source])) {
  574.             $targets = explode(',', $definitions[$source]);
  575.             foreach ($targets as $l) {
  576.                 $target = trim($l);
  577.                 if ($target) {
  578.                     if (in_array($target, $fallbacks)) {
  579.                         throw new \Exception("Language `$source` | `$target` causes an infinte loop.");
  580.                     }
  581.                     $fallbacks[] = $target;
  583.                     $this->checkFallbackLanguageLoop($target, $definitions, $fallbacks);
  584.                 }
  585.             }
  586.         } else {
  587.             throw new \Exception("Language `$source` doesn't exist");
  588.         }
  589.     }
  591.     /**
  592.      * @Route("/get-web2print", name="pimcore_admin_settings_getweb2print", methods={"GET"})
  593.      *
  594.      * @param Request $request
  595.      *
  596.      * @return JsonResponse
  597.      */
  598.     public function getWeb2printAction(Request $request)
  599.     {
  600.         $this->checkPermission('web2print_settings');
  602.         $values = Config::getWeb2PrintConfig();
  603.         $valueArray = $values->toArray();
  605.         $optionsString = [];
  606.         if ($valueArray['wkhtml2pdfOptions'] ?? false) {
  607.             foreach ($valueArray['wkhtml2pdfOptions'] as $key => $value) {
  608.                 $tmpStr = '--'.$key;
  609.                 if ($value !== null && $value !== '') {
  610.                     $tmpStr .= ' '.$value;
  611.                 }
  612.                 $optionsString[] = $tmpStr;
  613.             }
  614.         }
  615.         $valueArray['wkhtml2pdfOptions'] = implode("\n", $optionsString);
  617.         $response = [
  618.             'values' => $valueArray,
  619.         ];
  621.         return $this->adminJson($response);
  622.     }
  624.     /**
  625.      * @Route("/set-web2print", name="pimcore_admin_settings_setweb2print", methods={"PUT"})
  626.      *
  627.      * @param Request $request
  628.      *
  629.      * @return JsonResponse
  630.      */
  631.     public function setWeb2printAction(Request $request)
  632.     {
  633.         $this->checkPermission('web2print_settings');
  635.         $values = $this->decodeJson($request->get('data'));
  637.         unset($values['documentation']);
  638.         unset($values['additions']);
  639.         unset($values['json_converter']);
  641.         if ($values['wkhtml2pdfOptions']) {
  642.             $optionArray = [];
  643.             $lines = explode("\n", $values['wkhtml2pdfOptions']);
  644.             foreach ($lines as $line) {
  645.                 $parts = explode(' ', substr($line, 2));
  646.                 $key = trim($parts[0]);
  647.                 if ($key) {
  648.                     $value = trim($parts[1] ?? '');
  649.                     $optionArray[$key] = $value;
  650.                 }
  651.             }
  652.             $values['wkhtml2pdfOptions'] = $optionArray;
  653.         }
  655.         \Pimcore\Web2Print\Config::save($values);
  657.         return $this->adminJson(['success' => true]);
  658.     }
  660.     /**
  661.      * @Route("/clear-cache", name="pimcore_admin_settings_clearcache", methods={"DELETE"})
  662.      *
  663.      * @param Request $request
  664.      * @param KernelInterface $kernel
  665.      * @param EventDispatcherInterface $eventDispatcher
  666.      * @param CoreCacheHandler $cache
  667.      * @param Filesystem $filesystem
  668.      * @param CacheClearer $symfonyCacheClearer
  669.      *
  670.      * @return JsonResponse
  671.      */
  672.     public function clearCacheAction(
  673.         Request $request,
  674.         KernelInterface $kernel,
  675.         EventDispatcherInterface $eventDispatcher,
  676.         CoreCacheHandler $cache,
  677.         Filesystem $filesystem,
  678.         CacheClearer $symfonyCacheClearer
  679.     ) {
  680.         $this->checkPermissionsHasOneOf(['clear_cache', 'system_settings']);
  682.         $result = [
  683.             'success' => true,
  684.         ];
  686.         $clearPimcoreCache = !(bool)$request->get('only_symfony_cache');
  687.         $clearSymfonyCache = !(bool)$request->get('only_pimcore_cache');
  689.         if ($clearPimcoreCache) {
  690.             $this->clearPimcoreCache($cache, $eventDispatcher, $filesystem);
  691.         }
  693.         if ($clearSymfonyCache) {
  694.             $this->clearSymfonyCache($request, $kernel, $eventDispatcher, $symfonyCacheClearer);
  695.         }
  697.         $response = new JsonResponse($result);
  699.         if ($clearSymfonyCache) {
  700.             // we send the response directly here and exit to make sure no code depending on the stale container
  701.             // is running after this
  702.             $response->sendHeaders();
  703.             $response->sendContent();
  704.             exit;
  705.         }
  707.         return $response;
  708.     }
  710.     private function clearPimcoreCache(
  711.         CoreCacheHandler $cache,
  712.         EventDispatcherInterface $eventDispatcher,
  713.         Filesystem $filesystem,
  714.     ): void {
  715.         // empty document cache
  716.         $cache->clearAll();
  718.         if ($filesystem->exists(PIMCORE_CACHE_DIRECTORY)) {
  719.             $filesystem->remove(PIMCORE_CACHE_DIRECTORY);
  720.         }
  722.         // PIMCORE-1854 - recreate .dummy file => should remain
  723.         File::put(PIMCORE_CACHE_DIRECTORY . '/.gitkeep', '');
  725.         $eventDispatcher->dispatch(new GenericEvent(), SystemEvents::CACHE_CLEAR);
  726.     }
  728.     private function clearSymfonyCache(
  729.         Request $request,
  730.         KernelInterface $kernel,
  731.         EventDispatcherInterface $eventDispatcher,
  732.         CacheClearer $symfonyCacheClearer,
  733.     ): void {
  734.         // pass one or move env parameters to clear multiple envs
  735.         // if no env is passed it will use the current one
  736.         $environments = $request->get('env', $kernel->getEnvironment());
  738.         if (!is_array($environments)) {
  739.             $environments = trim((string)$environments);
  741.             if (empty($environments)) {
  742.                 $environments = [];
  743.             } else {
  744.                 $environments = [$environments];
  745.             }
  746.         }
  748.         if (empty($environments)) {
  749.             $environments = [$kernel->getEnvironment()];
  750.         }
  752.         $result['environments'] = $environments;
  754.         if (in_array($kernel->getEnvironment(), $environments)) {
  755.             // remove terminate and exception event listeners for the current env as they break with a
  756.             // cleared container - see #2434
  757.             foreach ($eventDispatcher->getListeners(KernelEvents::TERMINATE) as $listener) {
  758.                 $eventDispatcher->removeListener(KernelEvents::TERMINATE, $listener);
  759.             }
  761.             foreach ($eventDispatcher->getListeners(KernelEvents::EXCEPTION) as $listener) {
  762.                 $eventDispatcher->removeListener(KernelEvents::EXCEPTION, $listener);
  763.             }
  764.         }
  766.         foreach ($environments as $environment) {
  767.             try {
  768.                 $symfonyCacheClearer->clear($environment);
  769.             } catch (\Throwable $e) {
  770.                 $errors = $result['errors'] ?? [];
  771.                 $errors[] = $e->getMessage();
  773.                 $result = array_merge($result, [
  774.                     'success' => false,
  775.                     'errors' => $errors,
  776.                 ]);
  777.             }
  778.         }
  779.     }
  781.     /**
  782.      * @Route("/clear-output-cache", name="pimcore_admin_settings_clearoutputcache", methods={"DELETE"})
  783.      *
  784.      * @param EventDispatcherInterface $eventDispatcher
  785.      *
  786.      * @return JsonResponse
  787.      */
  788.     public function clearOutputCacheAction(EventDispatcherInterface $eventDispatcher)
  789.     {
  790.         $this->checkPermission('clear_fullpage_cache');
  792.         // remove "output" out of the ignored tags, if a cache lifetime is specified
  793.         Cache::removeIgnoredTagOnClear('output');
  795.         // empty document cache
  796.         Cache::clearTags(['output', 'output_lifetime']);
  798.         $eventDispatcher->dispatch(new GenericEvent(), SystemEvents::CACHE_CLEAR_FULLPAGE_CACHE);
  800.         return $this->adminJson(['success' => true]);
  801.     }
  803.     /**
  804.      * @Route("/clear-temporary-files", name="pimcore_admin_settings_cleartemporaryfiles", methods={"DELETE"})
  805.      *
  806.      * @param EventDispatcherInterface $eventDispatcher
  807.      *
  808.      * @return JsonResponse
  809.      */
  810.     public function clearTemporaryFilesAction(EventDispatcherInterface $eventDispatcher)
  811.     {
  812.         $this->checkPermission('clear_temp_files');
  814.         // public files
  815.         Tool\Storage::get('thumbnail')->deleteDirectory('/');
  816.         Db::get()->executeQuery('TRUNCATE TABLE assets_image_thumbnail_cache');
  818.         Tool\Storage::get('asset_cache')->deleteDirectory('/');
  820.         // system files
  821.         recursiveDelete(PIMCORE_SYSTEM_TEMP_DIRECTORY, false);
  823.         $eventDispatcher->dispatch(new GenericEvent(), SystemEvents::CACHE_CLEAR_TEMPORARY_FILES);
  825.         return $this->adminJson(['success' => true]);
  826.     }
  828.     /**
  829.      * @Route("/staticroutes", name="pimcore_admin_settings_staticroutes", methods={"POST"})
  830.      *
  831.      * @param Request $request
  832.      *
  833.      * @return JsonResponse
  834.      */
  835.     public function staticroutesAction(Request $request)
  836.     {
  837.         if ($request->get('data')) {
  838.             $this->checkPermission('routes');
  840.             $data = $this->decodeJson($request->get('data'));
  842.             if (is_array($data)) {
  843.                 foreach ($data as &$value) {
  844.                     if (is_string($value)) {
  845.                         $value = trim($value);
  846.                     }
  847.                 }
  848.             }
  850.             if ($request->get('xaction') == 'destroy') {
  851.                 $data = $this->decodeJson($request->get('data'));
  852.                 $id = $data['id'];
  853.                 $route = Staticroute::getById($id);
  854.                 if (!$route->isWriteable()) {
  855.                     throw new ConfigWriteException();
  856.                 }
  857.                 $route->delete();
  859.                 return $this->adminJson(['success' => true, 'data' => []]);
  860.             } elseif ($request->get('xaction') == 'update') {
  861.                 // save routes
  862.                 $route = Staticroute::getById($data['id']);
  863.                 if (!$route->isWriteable()) {
  864.                     throw new ConfigWriteException();
  865.                 }
  867.                 $route->setValues($data);
  869.                 $route->save();
  871.                 return $this->adminJson(['data' => $route->getObjectVars(), 'success' => true]);
  872.             } elseif ($request->get('xaction') == 'create') {
  873.                 if (!(new Staticroute())->isWriteable()) {
  874.                     throw new ConfigWriteException();
  875.                 }
  876.                 unset($data['id']);
  878.                 // save route
  879.                 $route = new Staticroute();
  880.                 $route->setValues($data);
  882.                 $route->save();
  884.                 $responseData = $route->getObjectVars();
  885.                 $responseData['writeable'] = $route->isWriteable();
  887.                 return $this->adminJson(['data' => $responseData, 'success' => true]);
  888.             }
  889.         } else {
  890.             // get list of routes
  892.             $list = new Staticroute\Listing();
  894.             if ($filter = $request->get('filter')) {
  895.                 $list->setFilter(function (Staticroute $staticRoute) use ($filter) {
  896.                     foreach ($staticRoute->getObjectVars() as $value) {
  897.                         if (!is_scalar($value)) {
  898.                             continue;
  899.                         }
  900.                         if (stripos((string)$value, $filter) !== false) {
  901.                             return true;
  902.                         }
  903.                     }
  905.                     return false;
  906.                 });
  907.             }
  909.             $routes = [];
  910.             foreach ($list->getRoutes() as $routeFromList) {
  911.                 $route = $routeFromList->getObjectVars();
  912.                 $route['writeable'] = $routeFromList->isWriteable();
  913.                 if (is_array($routeFromList->getSiteId())) {
  914.                     $route['siteId'] = implode(',', $routeFromList->getSiteId());
  915.                 }
  916.                 $routes[] = $route;
  917.             }
  919.             return $this->adminJson(['data' => $routes, 'success' => true, 'total' => $list->getTotalCount()]);
  920.         }
  922.         return $this->adminJson(['success' => false]);
  923.     }
  925.     /**
  926.      * @Route("/get-available-admin-languages", name="pimcore_admin_settings_getavailableadminlanguages", methods={"GET"})
  927.      *
  928.      * @param Request $request
  929.      *
  930.      * @return JsonResponse
  931.      */
  932.     public function getAvailableAdminLanguagesAction(Request $request)
  933.     {
  934.         $langs = [];
  935.         $availableLanguages = Tool\Admin::getLanguages();
  936.         $locales = Tool::getSupportedLocales();
  938.         foreach ($availableLanguages as $lang) {
  939.             if (array_key_exists($lang, $locales)) {
  940.                 $langs[] = [
  941.                     'language' => $lang,
  942.                     'display' => $locales[$lang],
  943.                 ];
  944.             }
  945.         }
  947.         usort($langs, function ($a, $b) {
  948.             return strcmp($a['display'], $b['display']);
  949.         });
  951.         return $this->adminJson($langs);
  952.     }
  954.     /**
  955.      * @Route("/glossary", name="pimcore_admin_settings_glossary", methods={"POST"})
  956.      *
  957.      * @param Request $request
  958.      *
  959.      * @return JsonResponse
  960.      */
  961.     public function glossaryAction(Request $request)
  962.     {
  963.         if ($request->get('data')) {
  964.             $this->checkPermission('glossary');
  966.             Cache::clearTag('glossary');
  968.             if ($request->get('xaction') == 'destroy') {
  969.                 $data = $this->decodeJson($request->get('data'));
  970.                 $id = $data['id'];
  971.                 $glossary = Glossary::getById($id);
  972.                 $glossary->delete();
  974.                 return $this->adminJson(['success' => true, 'data' => []]);
  975.             } elseif ($request->get('xaction') == 'update') {
  976.                 $data = $this->decodeJson($request->get('data'));
  978.                 // save glossary
  979.                 $glossary = Glossary::getById($data['id']);
  981.                 if (!empty($data['link'])) {
  982.                     if ($doc = Document::getByPath($data['link'])) {
  983.                         $data['link'] = $doc->getId();
  984.                     }
  985.                 }
  987.                 $glossary->setValues($data);
  989.                 $glossary->save();
  991.                 if ($link = $glossary->getLink()) {
  992.                     if ((int)$link > 0) {
  993.                         if ($doc = Document::getById((int)$link)) {
  994.                             $glossary->setLink($doc->getRealFullPath());
  995.                         }
  996.                     }
  997.                 }
  999.                 return $this->adminJson(['data' => $glossary, 'success' => true]);
  1000.             } elseif ($request->get('xaction') == 'create') {
  1001.                 $data = $this->decodeJson($request->get('data'));
  1002.                 unset($data['id']);
  1004.                 // save glossary
  1005.                 $glossary = new Glossary();
  1007.                 if (!empty($data['link'])) {
  1008.                     if ($doc = Document::getByPath($data['link'])) {
  1009.                         $data['link'] = $doc->getId();
  1010.                     }
  1011.                 }
  1013.                 $glossary->setValues($data);
  1015.                 $glossary->save();
  1017.                 if ($link = $glossary->getLink()) {
  1018.                     if ((int)$link > 0) {
  1019.                         if ($doc = Document::getById((int)$link)) {
  1020.                             $glossary->setLink($doc->getRealFullPath());
  1021.                         }
  1022.                     }
  1023.                 }
  1025.                 return $this->adminJson(['data' => $glossary->getObjectVars(), 'success' => true]);
  1026.             }
  1027.         } else {
  1028.             // get list of glossaries
  1030.             $list = new Glossary\Listing();
  1031.             $list->setLimit($request->get('limit'));
  1032.             $list->setOffset($request->get('start'));
  1034.             $sortingSettings = \Pimcore\Bundle\AdminBundle\Helper\QueryParams::extractSortingSettings(array_merge($request->request->all(), $request->query->all()));
  1035.             if ($sortingSettings['orderKey']) {
  1036.                 $list->setOrderKey($sortingSettings['orderKey']);
  1037.                 $list->setOrder($sortingSettings['order']);
  1038.             }
  1040.             if ($request->get('filter')) {
  1041.                 $list->setCondition('`text` LIKE ' . $list->quote('%'.$request->get('filter').'%'));
  1042.             }
  1044.             $list->load();
  1046.             $glossaries = [];
  1047.             foreach ($list->getGlossary() as $glossary) {
  1048.                 if ($link = $glossary->getLink()) {
  1049.                     if ((int)$link > 0) {
  1050.                         if ($doc = Document::getById((int)$link)) {
  1051.                             $glossary->setLink($doc->getRealFullPath());
  1052.                         }
  1053.                     }
  1054.                 }
  1056.                 $glossaries[] = $glossary->getObjectVars();
  1057.             }
  1059.             return $this->adminJson(['data' => $glossaries, 'success' => true, 'total' => $list->getTotalCount()]);
  1060.         }
  1062.         return $this->adminJson(['success' => false]);
  1063.     }
  1065.     /**
  1066.      * @Route("/get-available-sites", name="pimcore_admin_settings_getavailablesites", methods={"GET"})
  1067.      *
  1068.      * @param Request $request
  1069.      *
  1070.      * @return JsonResponse
  1071.      */
  1072.     public function getAvailableSitesAction(Request $request)
  1073.     {
  1074.         try {
  1075.             // we need to check documents permission for listing purposes in sites ext model & url-slugs
  1076.             $this->checkPermission('documents');
  1077.         } catch (AccessDeniedHttpException $e) {
  1078.             Logger::log('[Startup] Sites are not loaded as "documents" permission is missing');
  1079.             //return empty string to avoid error on startup
  1080.             return $this->adminJson([]);
  1081.         }
  1083.         $excludeMainSite = $request->get('excludeMainSite');
  1085.         $sitesList = new Model\Site\Listing();
  1086.         $sitesObjects = $sitesList->load();
  1087.         $sites = [];
  1088.         if (!$excludeMainSite) {
  1089.             $sites[] = [
  1090.                 'id' => 'default',
  1091.                 'rootId' => 1,
  1092.                 'domains' => '',
  1093.                 'rootPath' => '/',
  1094.                 'domain' => $this->translator->trans('main_site'),
  1095.             ];
  1096.         }
  1098.         foreach ($sitesObjects as $site) {
  1099.             if ($site->getRootDocument()) {
  1100.                 if ($site->getMainDomain()) {
  1101.                     $sites[] = [
  1102.                         'id' => $site->getId(),
  1103.                         'rootId' => $site->getRootId(),
  1104.                         'domains' => implode(',', $site->getDomains()),
  1105.                         'rootPath' => $site->getRootPath(),
  1106.                         'domain' => $site->getMainDomain(),
  1107.                     ];
  1108.                 }
  1109.             } else {
  1110.                 // site is useless, parent doesn't exist anymore
  1111.                 $site->delete();
  1112.             }
  1113.         }
  1115.         return $this->adminJson($sites);
  1116.     }
  1118.     /**
  1119.      * @Route("/get-available-countries", name="pimcore_admin_settings_getavailablecountries", methods={"GET"})
  1120.      *
  1121.      * @param LocaleServiceInterface $localeService
  1122.      *
  1123.      * @return JsonResponse
  1124.      */
  1125.     public function getAvailableCountriesAction(LocaleServiceInterface $localeService)
  1126.     {
  1127.         $countries = $localeService->getDisplayRegions();
  1128.         asort($countries);
  1130.         $options = [];
  1132.         foreach ($countries as $short => $translation) {
  1133.             if (strlen($short) == 2) {
  1134.                 $options[] = [
  1135.                     'key' => $translation . ' (' . $short . ')',
  1136.                     'value' => $short,
  1137.                 ];
  1138.             }
  1139.         }
  1141.         $result = ['data' => $options, 'success' => true, 'total' => count($options)];
  1143.         return $this->adminJson($result);
  1144.     }
  1146.     /**
  1147.      * @Route("/thumbnail-adapter-check", name="pimcore_admin_settings_thumbnailadaptercheck", methods={"GET"})
  1148.      *
  1149.      * @param Request $request
  1150.      * @param TranslatorInterface $translator
  1151.      *
  1152.      * @return Response
  1153.      */
  1154.     public function thumbnailAdapterCheckAction(Request $request, TranslatorInterface $translator)
  1155.     {
  1156.         $content = '';
  1158.         $instance = \Pimcore\Image::getInstance();
  1159.         if ($instance instanceof \Pimcore\Image\Adapter\GD) {
  1160.             $content = '<span style="color: red; font-weight: bold;padding: 10px;margin:0 0 20px 0;border:1px solid red;display:block;">' .
  1161.                 $translator->trans('important_use_imagick_pecl_extensions_for_best_results_gd_is_just_a_fallback_with_less_quality', [], 'admin') .
  1162.                 '</span>';
  1163.         }
  1165.         return new Response($content);
  1166.     }
  1168.     /**
  1169.      * @Route("/thumbnail-tree", name="pimcore_admin_settings_thumbnailtree", methods={"GET", "POST"})
  1170.      *
  1171.      * @return JsonResponse
  1172.      */
  1173.     public function thumbnailTreeAction()
  1174.     {
  1175.         $this->checkPermission('thumbnails');
  1177.         $thumbnails = [];
  1179.         $list = new Asset\Image\Thumbnail\Config\Listing();
  1181.         $groups = [];
  1182.         foreach ($list->getThumbnails() as $item) {
  1183.             if ($item->getGroup()) {
  1184.                 if (empty($groups[$item->getGroup()])) {
  1185.                     $groups[$item->getGroup()] = [
  1186.                         'id' => 'group_' . $item->getName(),
  1187.                         'text' => htmlspecialchars($item->getGroup()),
  1188.                         'expandable' => true,
  1189.                         'leaf' => false,
  1190.                         'allowChildren' => true,
  1191.                         'iconCls' => 'pimcore_icon_folder',
  1192.                         'group' => $item->getGroup(),
  1193.                         'children' => [],
  1194.                     ];
  1195.                 }
  1196.                 $groups[$item->getGroup()]['children'][] =
  1197.                     [
  1198.                         'id' => $item->getName(),
  1199.                         'text' => $item->getName(),
  1200.                         'leaf' => true,
  1201.                         'iconCls' => 'pimcore_icon_thumbnails',
  1202.                         'cls' => 'pimcore_treenode_disabled',
  1203.                         'writeable' => $item->isWriteable(),
  1204.                     ];
  1205.             } else {
  1206.                 $thumbnails[] = [
  1207.                     'id' => $item->getName(),
  1208.                     'text' => $item->getName(),
  1209.                     'leaf' => true,
  1210.                     'iconCls' => 'pimcore_icon_thumbnails',
  1211.                     'cls' => 'pimcore_treenode_disabled',
  1212.                     'writeable' => $item->isWriteable(),
  1213.                 ];
  1214.             }
  1215.         }
  1217.         foreach ($groups as $group) {
  1218.             $thumbnails[] = $group;
  1219.         }
  1221.         return $this->adminJson($thumbnails);
  1222.     }
  1224.     /**
  1225.      * @Route("/thumbnail-downloadable", name="pimcore_admin_settings_thumbnaildownloadable", methods={"GET"})
  1226.      *
  1227.      * @return JsonResponse
  1228.      */
  1229.     public function thumbnailDownloadableAction()
  1230.     {
  1231.         $thumbnails = [];
  1233.         $list = new Asset\Image\Thumbnail\Config\Listing();
  1234.         $list->setFilter(function (Asset\Image\Thumbnail\Config $config) {
  1235.             return $config->isDownloadable();
  1236.         });
  1238.         foreach ($list->getThumbnails() as $item) {
  1239.             $thumbnails[] = [
  1240.                 'id' => $item->getName(),
  1241.                 'text' => $item->getName(),
  1242.             ];
  1243.         }
  1245.         return $this->adminJson($thumbnails);
  1246.     }
  1248.     /**
  1249.      * @Route("/thumbnail-add", name="pimcore_admin_settings_thumbnailadd", methods={"POST"})
  1250.      *
  1251.      * @param Request $request
  1252.      *
  1253.      * @return JsonResponse
  1254.      */
  1255.     public function thumbnailAddAction(Request $request)
  1256.     {
  1257.         $this->checkPermission('thumbnails');
  1259.         $success = false;
  1261.         $pipe = Asset\Image\Thumbnail\Config::getByName($request->get('name'));
  1263.         if (!$pipe) {
  1264.             $pipe = new Asset\Image\Thumbnail\Config();
  1265.             if (!$pipe->isWriteable()) {
  1266.                 throw new ConfigWriteException();
  1267.             }
  1269.             $pipe->setName($request->get('name'));
  1270.             $pipe->save();
  1272.             $success = true;
  1273.         } else {
  1274.             if (!$pipe->isWriteable()) {
  1275.                 throw new ConfigWriteException();
  1276.             }
  1277.         }
  1279.         return $this->adminJson(['success' => $success, 'id' => $pipe->getName()]);
  1280.     }
  1282.     /**
  1283.      * @Route("/thumbnail-delete", name="pimcore_admin_settings_thumbnaildelete", methods={"DELETE"})
  1284.      *
  1285.      * @param Request $request
  1286.      *
  1287.      * @return JsonResponse
  1288.      */
  1289.     public function thumbnailDeleteAction(Request $request)
  1290.     {
  1291.         $this->checkPermission('thumbnails');
  1293.         $pipe = Asset\Image\Thumbnail\Config::getByName($request->get('name'));
  1295.         if (!$pipe->isWriteable()) {
  1296.             throw new ConfigWriteException();
  1297.         }
  1299.         $pipe->delete();
  1301.         return $this->adminJson(['success' => true]);
  1302.     }
  1304.     /**
  1305.      * @Route("/thumbnail-get", name="pimcore_admin_settings_thumbnailget", methods={"GET"})
  1306.      *
  1307.      * @param Request $request
  1308.      *
  1309.      * @return JsonResponse
  1310.      */
  1311.     public function thumbnailGetAction(Request $request)
  1312.     {
  1313.         $this->checkPermission('thumbnails');
  1315.         $pipe = Asset\Image\Thumbnail\Config::getByName($request->get('name'));
  1316.         $data = $pipe->getObjectVars();
  1317.         $data['writeable'] = $pipe->isWriteable();
  1319.         return $this->adminJson($data);
  1320.     }
  1322.     /**
  1323.      * @Route("/thumbnail-update", name="pimcore_admin_settings_thumbnailupdate", methods={"PUT"})
  1324.      *
  1325.      * @param Request $request
  1326.      *
  1327.      * @return JsonResponse
  1328.      */
  1329.     public function thumbnailUpdateAction(Request $request)
  1330.     {
  1331.         $this->checkPermission('thumbnails');
  1333.         $pipe = Asset\Image\Thumbnail\Config::getByName($request->get('name'));
  1335.         if (!$pipe->isWriteable()) {
  1336.             throw new ConfigWriteException();
  1337.         }
  1339.         $settingsData = $this->decodeJson($request->get('settings'));
  1340.         $mediaData = $this->decodeJson($request->get('medias'));
  1341.         $mediaOrder = $this->decodeJson($request->get('mediaOrder'));
  1343.         foreach ($settingsData as $key => $value) {
  1344.             $setter = 'set' . ucfirst($key);
  1345.             if (method_exists($pipe, $setter)) {
  1346.                 $pipe->$setter($value);
  1347.             }
  1348.         }
  1350.         $pipe->resetItems();
  1352.         uksort($mediaData, function ($a, $b) use ($mediaOrder) {
  1353.             if ($a === 'default') {
  1354.                 return -1;
  1355.             }
  1357.             return ($mediaOrder[$a] < $mediaOrder[$b]) ? -1 : 1;
  1358.         });
  1360.         foreach ($mediaData as $mediaName => $items) {
  1361.             if (preg_match('/["<>]/', $mediaName)) {
  1362.                 throw new \Exception('Invalid media query name');
  1363.             }
  1365.             foreach ($items as $item) {
  1366.                 $type = $item['type'];
  1367.                 unset($item['type']);
  1369.                 $pipe->addItem($type, $item, $mediaName);
  1370.             }
  1371.         }
  1373.         $pipe->save();
  1375.         return $this->adminJson(['success' => true]);
  1376.     }
  1378.     /**
  1379.      * @Route("/video-thumbnail-adapter-check", name="pimcore_admin_settings_videothumbnailadaptercheck", methods={"GET"})
  1380.      *
  1381.      * @param Request $request
  1382.      * @param TranslatorInterface $translator
  1383.      *
  1384.      * @return Response
  1385.      */
  1386.     public function videoThumbnailAdapterCheckAction(Request $request, TranslatorInterface $translator)
  1387.     {
  1388.         $content = '';
  1390.         if (!\Pimcore\Video::isAvailable()) {
  1391.             $content = '<span style="color: red; font-weight: bold;padding: 10px;margin:0 0 20px 0;border:1px solid red;display:block;">' .
  1392.                 $translator->trans('php_cli_binary_and_or_ffmpeg_binary_setting_is_missing', [], 'admin') .
  1393.                 '</span>';
  1394.         }
  1396.         return new Response($content);
  1397.     }
  1399.     /**
  1400.      * @Route("/video-thumbnail-tree", name="pimcore_admin_settings_videothumbnailtree", methods={"GET", "POST"})
  1401.      *
  1402.      * @return JsonResponse
  1403.      */
  1404.     public function videoThumbnailTreeAction()
  1405.     {
  1406.         $this->checkPermission('thumbnails');
  1408.         $thumbnails = [];
  1410.         $list = new Asset\Video\Thumbnail\Config\Listing();
  1412.         $groups = [];
  1413.         foreach ($list->getThumbnails() as $item) {
  1414.             if ($item->getGroup()) {
  1415.                 if (empty($groups[$item->getGroup()])) {
  1416.                     $groups[$item->getGroup()] = [
  1417.                         'id' => 'group_' . $item->getName(),
  1418.                         'text' => htmlspecialchars($item->getGroup()),
  1419.                         'expandable' => true,
  1420.                         'leaf' => false,
  1421.                         'allowChildren' => true,
  1422.                         'iconCls' => 'pimcore_icon_folder',
  1423.                         'group' => $item->getGroup(),
  1424.                         'children' => [],
  1425.                     ];
  1426.                 }
  1427.                 $groups[$item->getGroup()]['children'][] =
  1428.                     [
  1429.                         'id' => $item->getName(),
  1430.                         'text' => $item->getName(),
  1431.                         'leaf' => true,
  1432.                         'iconCls' => 'pimcore_icon_videothumbnails',
  1433.                         'cls' => 'pimcore_treenode_disabled',
  1434.                         'writeable' => $item->isWriteable(),
  1435.                     ];
  1436.             } else {
  1437.                 $thumbnails[] = [
  1438.                     'id' => $item->getName(),
  1439.                     'text' => $item->getName(),
  1440.                     'leaf' => true,
  1441.                     'iconCls' => 'pimcore_icon_videothumbnails',
  1442.                     'cls' => 'pimcore_treenode_disabled',
  1443.                     'writeable' => $item->isWriteable(),
  1444.                 ];
  1445.             }
  1446.         }
  1448.         foreach ($groups as $group) {
  1449.             $thumbnails[] = $group;
  1450.         }
  1452.         return $this->adminJson($thumbnails);
  1453.     }
  1455.     /**
  1456.      * @Route("/video-thumbnail-add", name="pimcore_admin_settings_videothumbnailadd", methods={"POST"})
  1457.      *
  1458.      * @param Request $request
  1459.      *
  1460.      * @return JsonResponse
  1461.      */
  1462.     public function videoThumbnailAddAction(Request $request)
  1463.     {
  1464.         $this->checkPermission('thumbnails');
  1466.         $success = false;
  1468.         $pipe = Asset\Video\Thumbnail\Config::getByName($request->get('name'));
  1470.         if (!$pipe) {
  1471.             $pipe = new Asset\Video\Thumbnail\Config();
  1472.             if (!$pipe->isWriteable()) {
  1473.                 throw new ConfigWriteException();
  1474.             }
  1476.             $pipe->setName($request->get('name'));
  1477.             $pipe->save();
  1479.             $success = true;
  1480.         } else {
  1481.             if (!$pipe->isWriteable()) {
  1482.                 throw new ConfigWriteException();
  1483.             }
  1484.         }
  1486.         return $this->adminJson(['success' => $success, 'id' => $pipe->getName()]);
  1487.     }
  1489.     /**
  1490.      * @Route("/video-thumbnail-delete", name="pimcore_admin_settings_videothumbnaildelete", methods={"DELETE"})
  1491.      *
  1492.      * @param Request $request
  1493.      *
  1494.      * @return JsonResponse
  1495.      */
  1496.     public function videoThumbnailDeleteAction(Request $request)
  1497.     {
  1498.         $this->checkPermission('thumbnails');
  1500.         $pipe = Asset\Video\Thumbnail\Config::getByName($request->get('name'));
  1502.         if (!$pipe->isWriteable()) {
  1503.             throw new ConfigWriteException();
  1504.         }
  1506.         $pipe->delete();
  1508.         return $this->adminJson(['success' => true]);
  1509.     }
  1511.     /**
  1512.      * @Route("/video-thumbnail-get", name="pimcore_admin_settings_videothumbnailget", methods={"GET"})
  1513.      *
  1514.      * @param Request $request
  1515.      *
  1516.      * @return JsonResponse
  1517.      */
  1518.     public function videoThumbnailGetAction(Request $request)
  1519.     {
  1520.         $this->checkPermission('thumbnails');
  1522.         $pipe = Asset\Video\Thumbnail\Config::getByName($request->get('name'));
  1524.         $data = $pipe->getObjectVars();
  1525.         $data['writeable'] = $pipe->isWriteable();
  1527.         return $this->adminJson($data);
  1528.     }
  1530.     /**
  1531.      * @Route("/video-thumbnail-update", name="pimcore_admin_settings_videothumbnailupdate", methods={"PUT"})
  1532.      *
  1533.      * @param Request $request
  1534.      *
  1535.      * @return JsonResponse
  1536.      */
  1537.     public function videoThumbnailUpdateAction(Request $request)
  1538.     {
  1539.         $this->checkPermission('thumbnails');
  1541.         $pipe = Asset\Video\Thumbnail\Config::getByName($request->get('name'));
  1543.         if (!$pipe->isWriteable()) {
  1544.             throw new ConfigWriteException();
  1545.         }
  1547.         $settingsData = $this->decodeJson($request->get('settings'));
  1548.         $mediaData = $this->decodeJson($request->get('medias'));
  1549.         $mediaOrder = $this->decodeJson($request->get('mediaOrder'));
  1551.         foreach ($settingsData as $key => $value) {
  1552.             $setter = 'set' . ucfirst($key);
  1553.             if (method_exists($pipe, $setter)) {
  1554.                 $pipe->$setter($value);
  1555.             }
  1556.         }
  1558.         $pipe->resetItems();
  1560.         uksort($mediaData, function ($a, $b) use ($mediaOrder) {
  1561.             if ($a === 'default') {
  1562.                 return -1;
  1563.             }
  1565.             return ($mediaOrder[$a] < $mediaOrder[$b]) ? -1 : 1;
  1566.         });
  1568.         foreach ($mediaData as $mediaName => $items) {
  1569.             foreach ($items as $item) {
  1570.                 $type = $item['type'];
  1571.                 unset($item['type']);
  1573.                 $pipe->addItem($type, $item, htmlspecialchars($mediaName));
  1574.             }
  1575.         }
  1577.         $pipe->save();
  1579.         return $this->adminJson(['success' => true]);
  1580.     }
  1582.     /**
  1583.      * @Route("/robots-txt", name="pimcore_admin_settings_robotstxtget", methods={"GET"})
  1584.      *
  1585.      * @return JsonResponse
  1586.      */
  1587.     public function robotsTxtGetAction()
  1588.     {
  1589.         $this->checkPermission('robots.txt');
  1591.         $config = Config::getRobotsConfig();
  1592.         $config = $config->toArray();
  1594.         return $this->adminJson([
  1595.             'success' => true,
  1596.             'data' => $config,
  1597.             'onFileSystem' => file_exists(PIMCORE_WEB_ROOT . '/robots.txt'),
  1598.         ]);
  1599.     }
  1601.     /**
  1602.      * @Route("/robots-txt", name="pimcore_admin_settings_robotstxtput", methods={"PUT"})
  1603.      *
  1604.      * @param Request $request
  1605.      *
  1606.      * @return JsonResponse
  1607.      */
  1608.     public function robotsTxtPutAction(Request $request)
  1609.     {
  1610.         $this->checkPermission('robots.txt');
  1612.         $values = $request->get('data');
  1613.         if (!is_array($values)) {
  1614.             $values = [];
  1615.         }
  1617.         foreach ($values as $siteId => $robotsContent) {
  1618.             SettingsStore::set('robots.txt-' . $siteId, $robotsContent, 'string', 'robots.txt');
  1619.         }
  1621.         return $this->adminJson([
  1622.             'success' => true,
  1623.         ]);
  1624.     }
  1626.     /**
  1627.      * @Route("/website-settings", name="pimcore_admin_settings_websitesettings", methods={"POST"})
  1628.      *
  1629.      * @param Request $request
  1630.      *
  1631.      * @return JsonResponse
  1632.      *
  1633.      * @throws \Exception
  1634.      */
  1635.     public function websiteSettingsAction(Request $request)
  1636.     {
  1637.         $this->checkPermission('website_settings');
  1639.         if ($request->get('data')) {
  1640.             $data = $this->decodeJson($request->get('data'));
  1642.             if (is_array($data)) {
  1643.                 foreach ($data as &$value) {
  1644.                     $value = trim($value);
  1645.                 }
  1646.             }
  1648.             if ($request->get('xaction') == 'destroy') {
  1649.                 $id = $data['id'];
  1650.                 $setting = WebsiteSetting::getById($id);
  1651.                 if ($setting instanceof WebsiteSetting) {
  1652.                     $setting->delete();
  1654.                     return $this->adminJson(['success' => true, 'data' => []]);
  1655.                 }
  1656.             } elseif ($request->get('xaction') == 'update') {
  1657.                 // save routes
  1658.                 $setting = WebsiteSetting::getById($data['id']);
  1659.                 if ($setting instanceof WebsiteSetting) {
  1660.                     switch ($setting->getType()) {
  1661.                         case 'document':
  1662.                         case 'asset':
  1663.                         case 'object':
  1664.                             if (isset($data['data'])) {
  1665.                                 $element = Element\Service::getElementByPath($setting->getType(), $data['data']);
  1666.                                 $data['data'] = $element;
  1667.                             }
  1669.                             break;
  1670.                     }
  1672.                     $setting->setValues($data);
  1673.                     $setting->save();
  1675.                     $data = $this->getWebsiteSettingForEditMode($setting);
  1677.                     return $this->adminJson(['data' => $data, 'success' => true]);
  1678.                 }
  1679.             } elseif ($request->get('xaction') == 'create') {
  1680.                 unset($data['id']);
  1682.                 // save route
  1683.                 $setting = new WebsiteSetting();
  1684.                 $setting->setValues($data);
  1686.                 $setting->save();
  1688.                 return $this->adminJson(['data' => $setting->getObjectVars(), 'success' => true]);
  1689.             }
  1690.         } else {
  1691.             $list = new WebsiteSetting\Listing();
  1693.             $list->setLimit($request->get('limit'));
  1694.             $list->setOffset($request->get('start'));
  1696.             $sortingSettings = \Pimcore\Bundle\AdminBundle\Helper\QueryParams::extractSortingSettings(array_merge($request->request->all(), $request->query->all()));
  1697.             if ($sortingSettings['orderKey']) {
  1698.                 $list->setOrderKey($sortingSettings['orderKey']);
  1699.                 $list->setOrder($sortingSettings['order']);
  1700.             } else {
  1701.                 $list->setOrderKey('name');
  1702.                 $list->setOrder('asc');
  1703.             }
  1705.             if ($request->get('filter')) {
  1706.                 $list->setCondition('`name` LIKE ' . $list->quote('%'.$request->get('filter').'%'));
  1707.             }
  1709.             $totalCount = $list->getTotalCount();
  1710.             $list = $list->load();
  1712.             $settings = [];
  1713.             foreach ($list as $item) {
  1714.                 $resultItem = $this->getWebsiteSettingForEditMode($item);
  1715.                 $settings[] = $resultItem;
  1716.             }
  1718.             return $this->adminJson(['data' => $settings, 'success' => true, 'total' => $totalCount]);
  1719.         }
  1721.         return $this->adminJson(['success' => false]);
  1722.     }
  1724.     /**
  1725.      * @param WebsiteSetting $item
  1726.      *
  1727.      * @return array
  1728.      */
  1729.     private function getWebsiteSettingForEditMode($item)
  1730.     {
  1731.         $resultItem = [
  1732.             'id' => $item->getId(),
  1733.             'name' => $item->getName(),
  1734.             'language' => $item->getLanguage(),
  1735.             'type' => $item->getType(),
  1736.             'data' => null,
  1737.             'siteId' => $item->getSiteId(),
  1738.             'creationDate' => $item->getCreationDate(),
  1739.             'modificationDate' => $item->getModificationDate(),
  1740.         ];
  1742.         switch ($item->getType()) {
  1743.             case 'document':
  1744.             case 'asset':
  1745.             case 'object':
  1746.                 $element = $item->getData();
  1747.                 if ($element) {
  1748.                     $resultItem['data'] = $element->getRealFullPath();
  1749.                 }
  1751.                 break;
  1752.             default:
  1753.                 $resultItem['data'] = $item->getData();
  1755.                 break;
  1756.         }
  1758.         return $resultItem;
  1759.     }
  1761.     /**
  1762.      * @Route("/get-available-algorithms", name="pimcore_admin_settings_getavailablealgorithms", methods={"GET"})
  1763.      *
  1764.      * @param Request $request
  1765.      *
  1766.      * @return JsonResponse
  1767.      */
  1768.     public function getAvailableAlgorithmsAction(Request $request)
  1769.     {
  1770.         $options = [
  1771.             [
  1772.                 'key' => 'password_hash',
  1773.                 'value' => 'password_hash',
  1774.             ],
  1775.         ];
  1777.         $algorithms = hash_algos();
  1778.         foreach ($algorithms as $algorithm) {
  1779.             $options[] = [
  1780.                 'key' => $algorithm,
  1781.                 'value' => $algorithm,
  1782.             ];
  1783.         }
  1785.         $result = ['data' => $options, 'success' => true, 'total' => count($options)];
  1787.         return $this->adminJson($result);
  1788.     }
  1790.     /**
  1791.      * deleteViews
  1792.      * delete views for localized fields when languages are removed to
  1793.      * prevent mysql errors
  1794.      *
  1795.      * @param string $language
  1796.      * @param string $dbName
  1797.      */
  1798.     protected function deleteViews($language, $dbName)
  1799.     {
  1800.         $db = \Pimcore\Db::get();
  1801.         $views = $db->fetchAllAssociative('SHOW FULL TABLES IN ' . $db->quoteIdentifier($dbName) . " WHERE TABLE_TYPE LIKE 'VIEW'");
  1803.         foreach ($views as $view) {
  1804.             if (preg_match('/^object_localized_[0-9]+_' . $language . '$/', $view['Tables_in_' . $dbName])) {
  1805.                 $sql = 'DROP VIEW ' . $db->quoteIdentifier($view['Tables_in_' . $dbName]);
  1806.                 $db->executeQuery($sql);
  1807.             }
  1808.         }
  1809.     }
  1811.     /**
  1812.      * @Route("/test-web2print", name="pimcore_admin_settings_testweb2print", methods={"GET"})
  1813.      *
  1814.      * @param Request $request
  1815.      *
  1816.      * @return Response
  1817.      */
  1818.     public function testWeb2printAction(Request $request)
  1819.     {
  1820.         $this->checkPermission('web2print_settings');
  1822.         $response = $this->render('@PimcoreAdmin/Admin/Settings/testWeb2print.html.twig');
  1823.         $html = $response->getContent();
  1825.         $adapter = \Pimcore\Web2Print\Processor::getInstance();
  1826.         $params = [];
  1828.         if ($adapter instanceof \Pimcore\Web2Print\Processor\WkHtmlToPdf) {
  1829.             $params['adapterConfig'] = '-O landscape';
  1830.         } elseif ($adapter instanceof \Pimcore\Web2Print\Processor\PdfReactor) {
  1831.             $params['adapterConfig'] = [
  1832.                 'javaScriptMode' => 0,
  1833.                 'addLinks' => true,
  1834.                 'appendLog' => true,
  1835.                 'enableDebugMode' => true,
  1836.             ];
  1837.         } elseif ($adapter instanceof \Pimcore\Web2Print\Processor\HeadlessChrome) {
  1838.             $params = Config::getWeb2PrintConfig();
  1839.             $params = $params->get('headlessChromeSettings');
  1840.             $params = json_decode($params, true);
  1841.         }
  1843.         $responseOptions = [
  1844.             'Content-Type' => 'application/pdf',
  1845.         ];
  1847.         $pdfData = $adapter->getPdfFromString($html, $params);
  1849.         return new \Symfony\Component\HttpFoundation\Response(
  1850.             $pdfData,
  1851.             200,
  1852.             $responseOptions
  1854.         );
  1855.     }
  1856. }