‪TYPO3CMS  ‪main
SettingsController.php
Go to the documentation of this file.
1 <?php
2 
3 declare(strict_types=1);
4 
5 /*
6  * This file is part of the TYPO3 CMS project.
7  *
8  * It is free software; you can redistribute it and/or modify it under
9  * the terms of the GNU General Public License, either version 2
10  * of the License, or any later version.
11  *
12  * For the full copyright and license information, please read the
13  * LICENSE.txt file that was distributed with this source code.
14  *
15  * The TYPO3 project - inspiring people to share!
16  */
17 
19 
20 use Psr\Http\Message\ResponseInterface;
21 use Psr\Http\Message\ServerRequestInterface;
22 use TYPO3\CMS\Core\Configuration\ConfigurationManager;
35 use TYPO3\CMS\Core\Package\PackageManager;
47 
53 {
54  public function ‪__construct(
55  private readonly PackageManager $packageManager,
56  private readonly ‪LanguageServiceFactory $languageServiceFactory,
57  private readonly ‪CommentAwareAstBuilder $astBuilder,
58  private readonly ‪LosslessTokenizer $losslessTokenizer,
59  private readonly ‪AstTraverser $astTraverser,
60  private readonly ‪FormProtectionFactory $formProtectionFactory,
61  private readonly ConfigurationManager $configurationManager,
62  ) {
63  }
64 
68  public function ‪cardsAction(ServerRequestInterface $request): ResponseInterface
69  {
70  $view = $this->‪initializeView($request);
71  $view->assign('isWritable', $this->configurationManager->canWriteConfiguration());
72  return new ‪JsonResponse([
73  'success' => true,
74  'html' => $view->render('Settings/Cards'),
75  ]);
76  }
77 
81  public function ‪changeInstallToolPasswordGetDataAction(ServerRequestInterface $request): ResponseInterface
82  {
83  $view = $this->‪initializeView($request);
84  $formProtection = $this->formProtectionFactory->createFromRequest($request);
85  $isWritable = $this->configurationManager->canWriteConfiguration();
86  $view->assignMultiple([
87  'isWritable' => $isWritable,
88  'changeInstallToolPasswordToken' => $formProtection->generateToken('installTool', 'changeInstallToolPassword'),
89  ]);
90  $buttons = [];
91  if ($isWritable) {
92  $buttons[] = [
93  'btnClass' => 'btn-default t3js-changeInstallToolPassword-change',
94  'text' => 'Set new password',
95  ];
96  }
97  return new ‪JsonResponse([
98  'success' => true,
99  'html' => $view->render('Settings/ChangeInstallToolPassword'),
100  'buttons' => $buttons,
101  ]);
102  }
103 
107  public function ‪changeInstallToolPasswordAction(ServerRequestInterface $request): ResponseInterface
108  {
109  $messageQueue = new ‪FlashMessageQueue('install');
110  if (!$this->configurationManager->canWriteConfiguration()) {
111  $messageQueue->enqueue(new ‪FlashMessage(
112  'The configuration file is not writable.',
113  'Configuration not writable',
114  ContextualFeedbackSeverity::ERROR
115  ));
116  } else {
117  $password = $request->getParsedBody()['install']['password'] ?? '';
118  $passwordCheck = $request->getParsedBody()['install']['passwordCheck'];
119 
120  if ($password !== $passwordCheck) {
121  $messageQueue->enqueue(new ‪FlashMessage(
122  'Given passwords do not match.',
123  'Install tool password not changed',
124  ContextualFeedbackSeverity::ERROR
125  ));
126  } elseif (strlen($password) < 8) {
127  $messageQueue->enqueue(new ‪FlashMessage(
128  'Given password must be at least eight characters long.',
129  'Install tool password not changed',
130  ContextualFeedbackSeverity::ERROR
131  ));
132  } else {
133  $hashInstance = GeneralUtility::makeInstance(PasswordHashFactory::class)->getDefaultHashInstance('BE');
134  $this->configurationManager->setLocalConfigurationValueByPath(
135  'BE/installToolPassword',
136  $hashInstance->getHashedPassword($password)
137  );
138  $messageQueue->enqueue(new ‪FlashMessage(
139  'The Install tool password has been changed successfully.',
140  'Install tool password changed'
141  ));
142  }
143  }
144  return new ‪JsonResponse([
145  'success' => true,
146  'status' => $messageQueue,
147  ]);
148  }
149 
153  public function ‪systemMaintainerGetListAction(ServerRequestInterface $request): ResponseInterface
154  {
155  $view = $this->‪initializeView($request);
156  $formProtection = $this->formProtectionFactory->createFromRequest($request);
157  $isWritable = $this->configurationManager->canWriteConfiguration();
158  $view->assignMultiple([
159  'isWritable' => $isWritable,
160  'systemMaintainerWriteToken' => $formProtection->generateToken('installTool', 'systemMaintainerWrite'),
161  'systemMaintainerIsDevelopmentContext' => ‪Environment::getContext()->isDevelopment(),
162  ]);
163 
164  $connectionPool = GeneralUtility::makeInstance(ConnectionPool::class);
165 
166  // We have to respect the enable fields here by our own because no TCA is loaded
167  $queryBuilder = $connectionPool->getQueryBuilderForTable('be_users');
168  $queryBuilder->getRestrictions()->removeAll();
169  $users = $queryBuilder
170  ->select('uid', 'username', 'disable', 'starttime', 'endtime')
171  ->from('be_users')
172  ->where(
173  $queryBuilder->expr()->and(
174  $queryBuilder->expr()->eq('deleted', $queryBuilder->createNamedParameter(0, ‪Connection::PARAM_INT)),
175  $queryBuilder->expr()->eq('admin', $queryBuilder->createNamedParameter(1, ‪Connection::PARAM_INT)),
176  $queryBuilder->expr()->neq('username', $queryBuilder->createNamedParameter('_cli_'))
177  )
178  )
179  ->orderBy('uid')
180  ->executeQuery()
181  ->fetchAllAssociative();
182 
183  $systemMaintainerList = ‪$GLOBALS['TYPO3_CONF_VARS']['SYS']['systemMaintainers'] ?? [];
184  $systemMaintainerList = array_map('intval', $systemMaintainerList);
185  $currentTime = time();
186  foreach ($users as &$user) {
187  $user['disable'] = $user['disable'] ||
188  ((int)$user['starttime'] !== 0 && $user['starttime'] > $currentTime) ||
189  ((int)$user['endtime'] !== 0 && $user['endtime'] < $currentTime);
190  $user['isSystemMaintainer'] = in_array((int)$user['uid'], $systemMaintainerList, true);
191  }
192  $buttons = [];
193  if ($isWritable) {
194  $buttons[] = [
195  'btnClass' => 'btn-default t3js-systemMaintainer-write',
196  'text' => 'Save system maintainer list',
197  ];
198  }
199  return new ‪JsonResponse([
200  'success' => true,
201  'users' => $users,
202  'html' => $view->render('Settings/SystemMaintainer'),
203  'buttons' => $buttons,
204  ]);
205  }
206 
210  public function ‪systemMaintainerWriteAction(ServerRequestInterface $request): ResponseInterface
211  {
212  $messages = [];
213 
214  if (!$this->configurationManager->canWriteConfiguration()) {
215  $messages[] = new ‪FlashMessage(
216  'The configuration file is not writable.',
217  'Configuration not writable',
218  ContextualFeedbackSeverity::ERROR
219  );
220  }
221  // Sanitize given user list and write out
222  $newUserList = [];
223  $users = $request->getParsedBody()['install']['users'] ?? [];
224  if (is_array($users)) {
225  foreach ($users as ‪$uid) {
227  $newUserList[] = (int)‪$uid;
228  }
229  }
230  }
231 
232  $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)->getQueryBuilderForTable('be_users');
233  $queryBuilder->getRestrictions()->removeAll();
234 
235  $validatedUserList = $queryBuilder
236  ->select('uid')
237  ->from('be_users')
238  ->where(
239  $queryBuilder->expr()->and(
240  $queryBuilder->expr()->eq('deleted', $queryBuilder->createNamedParameter(0, ‪Connection::PARAM_INT)),
241  $queryBuilder->expr()->eq('admin', $queryBuilder->createNamedParameter(1, ‪Connection::PARAM_INT)),
242  $queryBuilder->expr()->in('uid', $queryBuilder->createNamedParameter($newUserList, Connection::PARAM_INT_ARRAY))
243  )
244  )->executeQuery()->fetchAllAssociative();
245 
246  $validatedUserList = array_column($validatedUserList, 'uid');
247  $validatedUserList = array_map('intval', $validatedUserList);
248 
249  $this->configurationManager->setLocalConfigurationValuesByPathValuePairs(
250  ['SYS/systemMaintainers' => $validatedUserList]
251  );
252 
253  if (empty($validatedUserList)) {
254  $messages[] = new ‪FlashMessage(
255  'The system has no maintainers enabled anymore. Please use the standalone Admin Tools from now on.',
256  'Cleared system maintainer list',
257  ContextualFeedbackSeverity::INFO
258  );
259  } else {
260  $messages[] = new ‪FlashMessage(
261  'New system maintainer uid list: ' . implode(', ', $validatedUserList),
262  'Updated system maintainers',
263  ContextualFeedbackSeverity::INFO
264  );
265  }
266  return new ‪JsonResponse([
267  'success' => true,
268  'status' => $messages,
269  ]);
270  }
271 
275  public function ‪localConfigurationGetContentAction(ServerRequestInterface $request): ResponseInterface
276  {
277  $localConfigurationValueService = new ‪LocalConfigurationValueService();
278  $formProtection = $this->formProtectionFactory->createFromRequest($request);
279  $isWritable = $this->configurationManager->canWriteConfiguration();
280  $view = $this->‪initializeView($request);
281  $view->assignMultiple([
282  'isWritable' => $isWritable,
283  'localConfigurationWriteToken' => $formProtection->generateToken('installTool', 'localConfigurationWrite'),
284  'localConfigurationData' => $localConfigurationValueService->getCurrentConfigurationData(),
285  ]);
286 
287  $buttons = [
288  [
289  'btnClass' => 'btn-default t3js-localConfiguration-toggleAll',
290  'text' => 'Toggle All',
291  ],
292  ];
293 
294  if ($isWritable) {
295  $buttons[] = [
296  'btnClass' => 'btn-default t3js-localConfiguration-write',
297  'text' => 'Write configuration',
298  ];
299  }
300 
301  return new ‪JsonResponse([
302  'success' => true,
303  'html' => $view->render('Settings/LocalConfigurationGetContent'),
304  'buttons' => $buttons,
305  ]);
306  }
307 
313  public function ‪localConfigurationWriteAction(ServerRequestInterface $request): ResponseInterface
314  {
315  if (!$this->configurationManager->canWriteConfiguration()) {
316  $messageQueue = new ‪FlashMessageQueue('install');
317  $messageQueue->enqueue(new ‪FlashMessage(
318  'The configuration file is not writable.',
319  'Configuration not writable',
320  ContextualFeedbackSeverity::ERROR
321  ));
322  } else {
323  $settings = $request->getParsedBody()['install']['configurationValues'];
324  if (!is_array($settings) || empty($settings)) {
325  throw new \RuntimeException(
326  'Expected value array not found',
327  1502282283
328  );
329  }
330  $localConfigurationValueService = new ‪LocalConfigurationValueService();
331  $messageQueue = $localConfigurationValueService->updateLocalConfigurationValues($settings);
332  if ($messageQueue->count() === 0) {
333  $messageQueue->enqueue(new ‪FlashMessage(
334  'No configuration changes have been detected in the submitted form.',
335  'Configuration not updated',
336  ContextualFeedbackSeverity::WARNING
337  ));
338  }
339  }
340  return new ‪JsonResponse([
341  'success' => true,
342  'status' => $messageQueue,
343  ]);
344  }
345 
349  public function ‪presetsGetContentAction(ServerRequestInterface $request): ResponseInterface
350  {
351  $view = $this->‪initializeView($request);
352  $isWritable = $this->configurationManager->canWriteConfiguration();
353  $presetFeatures = GeneralUtility::makeInstance(FeatureManager::class);
354  $presetFeatures = $presetFeatures->getInitializedFeatures($request->getParsedBody()['install']['values'] ?? []);
355  $formProtection = $this->formProtectionFactory->createFromRequest($request);
356  $view->assignMultiple([
357  'isWritable' => $isWritable,
358  'presetsActivateToken' => $formProtection->generateToken('installTool', 'presetsActivate'),
359  // This action is called again from within the card itself if a custom image path is supplied
360  'presetsGetContentToken' => $formProtection->generateToken('installTool', 'presetsGetContent'),
361  'presetFeatures' => $presetFeatures,
362  ]);
363  $buttons = [];
364  if ($isWritable) {
365  $buttons[] = [
366  'btnClass' => 'btn-default t3js-presets-activate',
367  'text' => 'Activate preset',
368  ];
369  }
370  return new ‪JsonResponse([
371  'success' => true,
372  'html' => $view->render('Settings/PresetsGetContent'),
373  'buttons' => $buttons,
374  ]);
375  }
376 
380  public function ‪presetsActivateAction(ServerRequestInterface $request): ResponseInterface
381  {
382  $messages = new ‪FlashMessageQueue('install');
383  if (!$this->configurationManager->canWriteConfiguration()) {
384  $messages->enqueue(new ‪FlashMessage(
385  'The configuration file is not writable.',
386  'Configuration not writable',
387  ContextualFeedbackSeverity::ERROR
388  ));
389  } else {
390  $featureManager = new ‪FeatureManager();
391  $configurationValues = $featureManager->getConfigurationForSelectedFeaturePresets($request->getParsedBody()['install']['values'] ?? []);
392  if (!empty($configurationValues)) {
393  $this->configurationManager->setLocalConfigurationValuesByPathValuePairs($configurationValues);
394  $messageBody = [];
395  foreach ($configurationValues as $configurationKey => $configurationValue) {
396  if (is_array($configurationValue)) {
397  $configurationValue = json_encode($configurationValue);
398  }
399  $messageBody[] = '\'' . $configurationKey . '\' => \'' . $configurationValue . '\'';
400  }
401  $messages->enqueue(new ‪FlashMessage(
402  implode(', ', $messageBody),
403  'Configuration written'
404  ));
405  } else {
406  $messages->enqueue(new ‪FlashMessage(
407  '',
408  'No configuration change selected',
409  ContextualFeedbackSeverity::INFO
410  ));
411  }
412  }
413  return new ‪JsonResponse([
414  'success' => true,
415  'status' => $messages,
416  ]);
417  }
418 
422  public function ‪extensionConfigurationGetContentAction(ServerRequestInterface $request): ResponseInterface
423  {
424  // Extension configuration needs initialized $GLOBALS['LANG']
425  ‪$GLOBALS['LANG'] = $this->languageServiceFactory->create('default');
426  $extensionsWithConfigurations = [];
427  $activePackages = $this->packageManager->getActivePackages();
428  $extensionConfiguration = new ‪ExtensionConfiguration();
429  foreach ($activePackages as $extensionKey => $activePackage) {
430  if (@file_exists($activePackage->getPackagePath() . 'ext_conf_template.txt')) {
431  $ast = $this->astBuilder->build(
432  $this->losslessTokenizer->tokenize(file_get_contents($activePackage->getPackagePath() . 'ext_conf_template.txt')),
433  new ‪RootNode()
434  );
435  $astConstantCommentVisitor = new (AstConstantCommentVisitor::class);
436  $this->astTraverser->resetVisitors();
437  $this->astTraverser->addVisitor($astConstantCommentVisitor);
438  $this->astTraverser->traverse($ast);
439  $constants = $astConstantCommentVisitor->getConstants();
440  // @todo: It would be better to fetch all LocalConfiguration settings of an extension at once
441  // and feed it as pseudo-TS to the AST builder. This way the full AstConstantCommentVisitor
442  // preparation magic would kick in and the JS-side processing in extension-configuration.ts
443  // could be removed (especially the 'wrap' and 'offset' stuff) by handling it in fluid directly.
444  foreach ($constants as $constantName => &$constantDetails) {
445  try {
446  $valueFromLocalConfiguration = $extensionConfiguration->get($extensionKey, str_replace('.', '/', $constantName));
447  $constantDetails['value'] = $valueFromLocalConfiguration;
449  // Deliberately empty - it can happen at runtime that a written config does not return
450  // back all values (eg. saltedpassword with its userFuncs), which then miss in the written
451  // configuration and are only synced after next install tool run. This edge case is
452  // taken care of here.
453  }
454  }
455  $displayConstants = [];
456  foreach ($constants as $constant) {
457  $displayConstants[$constant['cat']][$constant['subcat_sorting_first']]['label'] = $constant['subcat_label'];
458  $displayConstants[$constant['cat']][$constant['subcat_sorting_first']]['items'][$constant['subcat_sorting_second']] = $constant;
459  }
460  foreach ($displayConstants as &$constantCategory) {
461  ksort($constantCategory);
462  foreach ($constantCategory as &$constantDetailItems) {
463  ksort($constantDetailItems['items']);
464  }
465  }
466  $extensionsWithConfigurations[$extensionKey] = $displayConstants;
467  }
468  }
469  ksort($extensionsWithConfigurations);
470  $formProtection = $this->formProtectionFactory->createFromRequest($request);
471  $isWritable = $this->configurationManager->canWriteConfiguration();
472  $view = $this->‪initializeView($request);
473  $view->assignMultiple([
474  'isWritable' => $isWritable,
475  'extensionsWithConfigurations' => $extensionsWithConfigurations,
476  'extensionConfigurationWriteToken' => $formProtection->generateToken('installTool', 'extensionConfigurationWrite'),
477  ]);
478  return new ‪JsonResponse([
479  'success' => true,
480  'html' => $view->render('Settings/ExtensionConfigurationGetContent'),
481  ]);
482  }
483 
487  public function ‪extensionConfigurationWriteAction(ServerRequestInterface $request): ResponseInterface
488  {
489  $messages = [];
490  if (!$this->configurationManager->canWriteConfiguration()) {
491  $messages[] = new ‪FlashMessage(
492  'The configuration file is not writable.',
493  'Configuration not writable',
494  ContextualFeedbackSeverity::ERROR
495  );
496  } else {
497  $extensionKey = $request->getParsedBody()['install']['extensionKey'];
498  $configuration = $request->getParsedBody()['install']['extensionConfiguration'] ?? [];
499  $nestedConfiguration = [];
500  foreach ($configuration as $configKey => $value) {
501  $nestedConfiguration = ‪ArrayUtility::setValueByPath($nestedConfiguration, $configKey, $value, '.');
502  }
503  (new ‪ExtensionConfiguration())->set($extensionKey, $nestedConfiguration);
504  $messages[] = new ‪FlashMessage(
505  'Successfully saved configuration for extension "' . $extensionKey . '".',
506  'Configuration saved',
507  ContextualFeedbackSeverity::OK
508  );
509  }
510  return new ‪JsonResponse([
511  'success' => true,
512  'status' => $messages,
513  ]);
514  }
515 
519  public function ‪featuresGetContentAction(ServerRequestInterface $request): ResponseInterface
520  {
521  $isWritable = $this->configurationManager->canWriteConfiguration();
522  $configurationDescription = GeneralUtility::makeInstance(YamlFileLoader::class)
523  ->load($this->configurationManager->getDefaultConfigurationDescriptionFileLocation());
524  $allFeatures = ‪$GLOBALS['TYPO3_CONF_VARS']['SYS']['features'] ?? [];
525  $features = [];
526  foreach ($allFeatures as $featureName => $featureValue) {
527  // Only features that have a .yml description will be listed. There is currently no
528  // way for extensions to extend this, so feature toggles of non-core extensions are
529  // not listed here.
530  if (isset($configurationDescription['SYS']['items']['features']['items'][$featureName]['description'])) {
531  $default = $this->configurationManager->getDefaultConfigurationValueByPath('SYS/features/' . $featureName);
532  $features[] = [
533  'label' => ucfirst(str_replace(['_', '.'], ' ', strtolower(‪GeneralUtility::camelCaseToLowerCaseUnderscored(preg_replace('/\./', ': ', $featureName, 1))))),
534  'name' => $featureName,
535  'description' => $configurationDescription['SYS']['items']['features']['items'][$featureName]['description'],
536  'default' => $default,
537  'value' => $featureValue,
538  ];
539  }
540  }
541  $formProtection = $this->formProtectionFactory->createFromRequest($request);
542  $view = $this->‪initializeView($request);
543  $view->assignMultiple([
544  'isWritable' => $isWritable,
545  'features' => $features,
546  'featuresSaveToken' => $formProtection->generateToken('installTool', 'featuresSave'),
547  ]);
548  $buttons = [];
549  if ($isWritable) {
550  $buttons[] = [
551  'btnClass' => 'btn-default t3js-features-save',
552  'text' => 'Save',
553  ];
554  }
555  return new ‪JsonResponse([
556  'success' => true,
557  'html' => $view->render('Settings/FeaturesGetContent'),
558  'buttons' => $buttons,
559  ]);
560  }
561 
565  public function ‪featuresSaveAction(ServerRequestInterface $request): ResponseInterface
566  {
567  if (!$this->configurationManager->canWriteConfiguration()) {
568  $message = new ‪FlashMessage(
569  'The configuration file is not writable.',
570  'Configuration not writable',
571  ContextualFeedbackSeverity::ERROR
572  );
573  } else {
574  $enabledFeaturesFromPost = $request->getParsedBody()['install']['values'] ?? [];
575  $allFeatures = array_keys(‪$GLOBALS['TYPO3_CONF_VARS']['SYS']['features'] ?? []);
576  $configurationDescription = GeneralUtility::makeInstance(YamlFileLoader::class)
577  ->load($this->configurationManager->getDefaultConfigurationDescriptionFileLocation());
578  $updatedFeatures = [];
579  $configurationPathValuePairs = [];
580  foreach ($allFeatures as $featureName) {
581  // Only features that have a .yml description will be listed. There is currently no
582  // way for extensions to extend this, so feature toggles of non-core extensions are
583  // not considered.
584  if (isset($configurationDescription['SYS']['items']['features']['items'][$featureName]['description'])) {
585  $path = 'SYS/features/' . $featureName;
586  $newValue = isset($enabledFeaturesFromPost[$featureName]);
587  if ($newValue !== $this->configurationManager->getConfigurationValueByPath($path)) {
588  $configurationPathValuePairs[$path] = $newValue;
589  $updatedFeatures[] = $featureName . ' [' . ($newValue ? 'On' : 'Off') . ']';
590  }
591  }
592  }
593  if ($configurationPathValuePairs !== []) {
594  $success = $this->configurationManager->setLocalConfigurationValuesByPathValuePairs($configurationPathValuePairs);
595  if ($success) {
596  $this->configurationManager->exportConfiguration();
597  $message = new ‪FlashMessage(
598  "Successfully updated the following feature toggles:\n" . implode(",\n", $updatedFeatures),
599  'Features updated',
600  ContextualFeedbackSeverity::OK
601  );
602  } else {
603  $message = new ‪FlashMessage(
604  'An error occurred while saving. Some settings may not have been updated.',
605  'Features not updated',
606  ContextualFeedbackSeverity::ERROR
607  );
608  }
609  } else {
610  $message = new ‪FlashMessage(
611  'Nothing to update.',
612  'Features not updated',
613  ContextualFeedbackSeverity::INFO
614  );
615  }
616  }
617  return new ‪JsonResponse([
618  'success' => true,
619  'status' => [$message],
620  ]);
621  }
622 }
‪TYPO3\CMS\Core\Localization\LanguageServiceFactory
Definition: LanguageServiceFactory.php:25
‪TYPO3\CMS\Install\Controller\SettingsController\localConfigurationWriteAction
‪localConfigurationWriteAction(ServerRequestInterface $request)
Definition: SettingsController.php:313
‪TYPO3\CMS\Core\Crypto\PasswordHashing\PasswordHashFactory
Definition: PasswordHashFactory.php:27
‪TYPO3\CMS\Core\Database\Connection\PARAM_INT
‪const PARAM_INT
Definition: Connection.php:47
‪TYPO3\CMS\Install\Configuration\FeatureManager
Definition: FeatureManager.php:30
‪TYPO3\CMS\Core\Configuration\Exception\ExtensionConfigurationPathDoesNotExistException
Definition: ExtensionConfigurationPathDoesNotExistException.php:25
‪TYPO3\CMS\Core\TypoScript\Tokenizer\LosslessTokenizer
Definition: LosslessTokenizer.php:61
‪TYPO3\CMS\Core\Configuration\ExtensionConfiguration
Definition: ExtensionConfiguration.php:47
‪TYPO3\CMS\Install\Controller\SettingsController\systemMaintainerGetListAction
‪systemMaintainerGetListAction(ServerRequestInterface $request)
Definition: SettingsController.php:153
‪TYPO3\CMS\Core\Utility\GeneralUtility\camelCaseToLowerCaseUnderscored
‪static string camelCaseToLowerCaseUnderscored($string)
Definition: GeneralUtility.php:767
‪TYPO3\CMS\Install\Controller\SettingsController\presetsGetContentAction
‪presetsGetContentAction(ServerRequestInterface $request)
Definition: SettingsController.php:349
‪TYPO3\CMS\Core\Type\ContextualFeedbackSeverity
‪ContextualFeedbackSeverity
Definition: ContextualFeedbackSeverity.php:25
‪TYPO3\CMS\Core\Utility\MathUtility\canBeInterpretedAsInteger
‪static bool canBeInterpretedAsInteger(mixed $var)
Definition: MathUtility.php:69
‪TYPO3\CMS\Install\Controller\SettingsController\__construct
‪__construct(private readonly PackageManager $packageManager, private readonly LanguageServiceFactory $languageServiceFactory, private readonly CommentAwareAstBuilder $astBuilder, private readonly LosslessTokenizer $losslessTokenizer, private readonly AstTraverser $astTraverser, private readonly FormProtectionFactory $formProtectionFactory, private readonly ConfigurationManager $configurationManager,)
Definition: SettingsController.php:54
‪TYPO3\CMS\Install\Controller\SettingsController\cardsAction
‪cardsAction(ServerRequestInterface $request)
Definition: SettingsController.php:68
‪TYPO3\CMS\Install\Controller
Definition: AbstractController.php:18
‪TYPO3\CMS\Install\Controller\SettingsController\presetsActivateAction
‪presetsActivateAction(ServerRequestInterface $request)
Definition: SettingsController.php:380
‪TYPO3\CMS\Install\Controller\SettingsController\systemMaintainerWriteAction
‪systemMaintainerWriteAction(ServerRequestInterface $request)
Definition: SettingsController.php:210
‪TYPO3\CMS\Install\Controller\SettingsController\localConfigurationGetContentAction
‪localConfigurationGetContentAction(ServerRequestInterface $request)
Definition: SettingsController.php:275
‪TYPO3\CMS\Install\Controller\SettingsController\changeInstallToolPasswordGetDataAction
‪changeInstallToolPasswordGetDataAction(ServerRequestInterface $request)
Definition: SettingsController.php:81
‪TYPO3\CMS\Install\Controller\SettingsController\extensionConfigurationGetContentAction
‪extensionConfigurationGetContentAction(ServerRequestInterface $request)
Definition: SettingsController.php:422
‪TYPO3\CMS\Install\Controller\SettingsController\featuresGetContentAction
‪featuresGetContentAction(ServerRequestInterface $request)
Definition: SettingsController.php:519
‪TYPO3\CMS\Install\Controller\AbstractController\initializeView
‪initializeView(ServerRequestInterface $request)
Definition: AbstractController.php:39
‪TYPO3\CMS\Install\Controller\SettingsController\extensionConfigurationWriteAction
‪extensionConfigurationWriteAction(ServerRequestInterface $request)
Definition: SettingsController.php:487
‪TYPO3\CMS\Install\Controller\SettingsController\featuresSaveAction
‪featuresSaveAction(ServerRequestInterface $request)
Definition: SettingsController.php:565
‪TYPO3\CMS\Core\Database\Connection
Definition: Connection.php:36
‪TYPO3\CMS\Core\Configuration\Loader\YamlFileLoader
Definition: YamlFileLoader.php:47
‪TYPO3\CMS\Core\Messaging\FlashMessage
Definition: FlashMessage.php:27
‪TYPO3\CMS\Core\FormProtection\FormProtectionFactory
Definition: FormProtectionFactory.php:44
‪TYPO3\CMS\Webhooks\Message\$uid
‪identifier readonly int $uid
Definition: PageModificationMessage.php:35
‪TYPO3\CMS\Core\Utility\ArrayUtility
Definition: ArrayUtility.php:26
‪TYPO3\CMS\Core\Http\JsonResponse
Definition: JsonResponse.php:28
‪$GLOBALS
‪$GLOBALS['TYPO3_CONF_VARS']['EXTCONF']['adminpanel']['modules']
Definition: ext_localconf.php:25
‪TYPO3\CMS\Core\TypoScript\AST\Node\RootNode
Definition: RootNode.php:26
‪TYPO3\CMS\Core\Core\Environment
Definition: Environment.php:41
‪TYPO3\CMS\Core\Utility\ArrayUtility\setValueByPath
‪static array setValueByPath(array $array, string|array|\ArrayAccess $path, mixed $value, string $delimiter='/')
Definition: ArrayUtility.php:261
‪TYPO3\CMS\Core\Utility\MathUtility
Definition: MathUtility.php:24
‪TYPO3\CMS\Install\Controller\AbstractController
Definition: AbstractController.php:35
‪TYPO3\CMS\Install\Controller\SettingsController
Definition: SettingsController.php:53
‪TYPO3\CMS\Install\Service\LocalConfigurationValueService
Definition: LocalConfigurationValueService.php:33
‪TYPO3\CMS\Core\Database\ConnectionPool
Definition: ConnectionPool.php:51
‪TYPO3\CMS\Core\TypoScript\AST\CommentAwareAstBuilder
Definition: CommentAwareAstBuilder.php:55
‪TYPO3\CMS\Core\TypoScript\AST\Traverser\AstTraverser
Definition: AstTraverser.php:31
‪TYPO3\CMS\Core\Utility\GeneralUtility
Definition: GeneralUtility.php:51
‪TYPO3\CMS\Core\Messaging\FlashMessageQueue
Definition: FlashMessageQueue.php:30
‪TYPO3\CMS\Core\Core\Environment\getContext
‪static getContext()
Definition: Environment.php:128
‪TYPO3\CMS\Install\Controller\SettingsController\changeInstallToolPasswordAction
‪changeInstallToolPasswordAction(ServerRequestInterface $request)
Definition: SettingsController.php:107
‪TYPO3\CMS\Core\TypoScript\AST\Visitor\AstConstantCommentVisitor
Definition: AstConstantCommentVisitor.php:35