‪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  $connectionPool = GeneralUtility::makeInstance(ConnectionPool::class);
156 
157  // We have to respect the enable fields here by our own because no TCA is loaded
158  $queryBuilder = $connectionPool->getQueryBuilderForTable('be_users');
159  $queryBuilder->getRestrictions()->removeAll();
160  $users = $queryBuilder
161  ->select('uid', 'username', 'disable', 'starttime', 'endtime')
162  ->from('be_users')
163  ->where(
164  $queryBuilder->expr()->and(
165  $queryBuilder->expr()->eq('deleted', $queryBuilder->createNamedParameter(0, ‪Connection::PARAM_INT)),
166  $queryBuilder->expr()->eq('admin', $queryBuilder->createNamedParameter(1, ‪Connection::PARAM_INT)),
167  $queryBuilder->expr()->neq('username', $queryBuilder->createNamedParameter('_cli_'))
168  )
169  )
170  ->orderBy('uid')
171  ->executeQuery()
172  ->fetchAllAssociative();
173 
174  $systemMaintainerList = ‪$GLOBALS['TYPO3_CONF_VARS']['SYS']['systemMaintainers'] ?? [];
175  $systemMaintainerList = array_map('intval', $systemMaintainerList);
176  $currentTime = time();
177  foreach ($users as &$user) {
178  $user['disable'] = $user['disable'] ||
179  ((int)$user['starttime'] !== 0 && $user['starttime'] > $currentTime) ||
180  ((int)$user['endtime'] !== 0 && $user['endtime'] < $currentTime);
181  $user['isSystemMaintainer'] = in_array((int)$user['uid'], $systemMaintainerList, true);
182  }
183  $view = $this->‪initializeView($request);
184  $formProtection = $this->formProtectionFactory->createFromRequest($request);
185  $isWritable = $this->configurationManager->canWriteConfiguration();
186  $view->assignMultiple([
187  'isWritable' => $isWritable,
188  'users' => $users,
189  'systemMaintainerWriteToken' => $formProtection->generateToken('installTool', 'systemMaintainerWrite'),
190  'systemMaintainerIsDevelopmentContext' => ‪Environment::getContext()->isDevelopment(),
191  ]);
192  $buttons = [];
193  if ($isWritable) {
194  $buttons[] = [
195  'btnClass' => 'btn-default t3js-systemMaintainer-write',
196  'text' => 'Save system maintainer list',
197  ];
198  }
199 
200  return new ‪JsonResponse([
201  'success' => true,
202  'users' => $users,
203  'html' => $view->render('Settings/SystemMaintainer'),
204  'buttons' => $buttons,
205  ]);
206  }
207 
211  public function ‪systemMaintainerWriteAction(ServerRequestInterface $request): ResponseInterface
212  {
213  $messages = [];
214 
215  if (!$this->configurationManager->canWriteConfiguration()) {
216  $messages[] = new ‪FlashMessage(
217  'The configuration file is not writable.',
218  'Configuration not writable',
219  ContextualFeedbackSeverity::ERROR
220  );
221  }
222  // Sanitize given user list and write out
223  $newUserList = [];
224  $users = $request->getParsedBody()['install']['users'] ?? [];
225  if (is_array($users)) {
226  foreach ($users as ‪$uid) {
228  $newUserList[] = (int)‪$uid;
229  }
230  }
231  }
232 
233  $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)->getQueryBuilderForTable('be_users');
234  $queryBuilder->getRestrictions()->removeAll();
235 
236  $validatedUserList = $queryBuilder
237  ->select('uid')
238  ->from('be_users')
239  ->where(
240  $queryBuilder->expr()->and(
241  $queryBuilder->expr()->eq('deleted', $queryBuilder->createNamedParameter(0, ‪Connection::PARAM_INT)),
242  $queryBuilder->expr()->eq('admin', $queryBuilder->createNamedParameter(1, ‪Connection::PARAM_INT)),
243  $queryBuilder->expr()->in('uid', $queryBuilder->createNamedParameter($newUserList, Connection::PARAM_INT_ARRAY))
244  )
245  )->executeQuery()->fetchAllAssociative();
246 
247  $validatedUserList = array_column($validatedUserList, 'uid');
248  $validatedUserList = array_map('intval', $validatedUserList);
249 
250  $this->configurationManager->setLocalConfigurationValuesByPathValuePairs(
251  ['SYS/systemMaintainers' => $validatedUserList]
252  );
253 
254  if (empty($validatedUserList)) {
255  $messages[] = new ‪FlashMessage(
256  'The system has no maintainers enabled anymore. Please use the standalone Admin Tools from now on.',
257  'Cleared system maintainer list',
258  ContextualFeedbackSeverity::INFO
259  );
260  } else {
261  $messages[] = new ‪FlashMessage(
262  'New system maintainer uid list: ' . implode(', ', $validatedUserList),
263  'Updated system maintainers',
264  ContextualFeedbackSeverity::INFO
265  );
266  }
267  return new ‪JsonResponse([
268  'success' => true,
269  'status' => $messages,
270  ]);
271  }
272 
276  public function ‪localConfigurationGetContentAction(ServerRequestInterface $request): ResponseInterface
277  {
278  $localConfigurationValueService = new ‪LocalConfigurationValueService();
279  $formProtection = $this->formProtectionFactory->createFromRequest($request);
280  $isWritable = $this->configurationManager->canWriteConfiguration();
281  $view = $this->‪initializeView($request);
282  $view->assignMultiple([
283  'isWritable' => $isWritable,
284  'localConfigurationWriteToken' => $formProtection->generateToken('installTool', 'localConfigurationWrite'),
285  'localConfigurationData' => $localConfigurationValueService->getCurrentConfigurationData(),
286  ]);
287 
288  $buttons = [
289  [
290  'btnClass' => 'btn-default t3js-localConfiguration-toggleAll',
291  'text' => 'Toggle All',
292  ],
293  ];
294 
295  if ($isWritable) {
296  $buttons[] = [
297  'btnClass' => 'btn-default t3js-localConfiguration-write',
298  'text' => 'Write configuration',
299  ];
300  }
301 
302  return new ‪JsonResponse([
303  'success' => true,
304  'html' => $view->render('Settings/LocalConfigurationGetContent'),
305  'buttons' => $buttons,
306  ]);
307  }
308 
314  public function ‪localConfigurationWriteAction(ServerRequestInterface $request): ResponseInterface
315  {
316  if (!$this->configurationManager->canWriteConfiguration()) {
317  $messageQueue = new ‪FlashMessageQueue('install');
318  $messageQueue->enqueue(new ‪FlashMessage(
319  'The configuration file is not writable.',
320  'Configuration not writable',
321  ContextualFeedbackSeverity::ERROR
322  ));
323  } else {
324  $settings = $request->getParsedBody()['install']['configurationValues'];
325  if (!is_array($settings) || empty($settings)) {
326  throw new \RuntimeException(
327  'Expected value array not found',
328  1502282283
329  );
330  }
331  $localConfigurationValueService = new ‪LocalConfigurationValueService();
332  $messageQueue = $localConfigurationValueService->updateLocalConfigurationValues($settings);
333  if ($messageQueue->count() === 0) {
334  $messageQueue->enqueue(new ‪FlashMessage(
335  'No configuration changes have been detected in the submitted form.',
336  'Configuration not updated',
337  ContextualFeedbackSeverity::WARNING
338  ));
339  }
340  }
341  return new ‪JsonResponse([
342  'success' => true,
343  'status' => $messageQueue,
344  ]);
345  }
346 
350  public function ‪presetsGetContentAction(ServerRequestInterface $request): ResponseInterface
351  {
352  $view = $this->‪initializeView($request);
353  $isWritable = $this->configurationManager->canWriteConfiguration();
354  $presetFeatures = GeneralUtility::makeInstance(FeatureManager::class);
355  $presetFeatures = $presetFeatures->getInitializedFeatures($request->getParsedBody()['install']['values'] ?? []);
356  $formProtection = $this->formProtectionFactory->createFromRequest($request);
357  $view->assignMultiple([
358  'isWritable' => $isWritable,
359  'presetsActivateToken' => $formProtection->generateToken('installTool', 'presetsActivate'),
360  // This action is called again from within the card itself if a custom image path is supplied
361  'presetsGetContentToken' => $formProtection->generateToken('installTool', 'presetsGetContent'),
362  'presetFeatures' => $presetFeatures,
363  ]);
364  $buttons = [];
365  if ($isWritable) {
366  $buttons[] = [
367  'btnClass' => 'btn-default t3js-presets-activate',
368  'text' => 'Activate preset',
369  ];
370  }
371  return new ‪JsonResponse([
372  'success' => true,
373  'html' => $view->render('Settings/PresetsGetContent'),
374  'buttons' => $buttons,
375  ]);
376  }
377 
381  public function ‪presetsActivateAction(ServerRequestInterface $request): ResponseInterface
382  {
383  $messages = new ‪FlashMessageQueue('install');
384  if (!$this->configurationManager->canWriteConfiguration()) {
385  $messages->enqueue(new ‪FlashMessage(
386  'The configuration file is not writable.',
387  'Configuration not writable',
388  ContextualFeedbackSeverity::ERROR
389  ));
390  } else {
391  $featureManager = new ‪FeatureManager();
392  $configurationValues = $featureManager->getConfigurationForSelectedFeaturePresets($request->getParsedBody()['install']['values'] ?? []);
393  if (!empty($configurationValues)) {
394  $this->configurationManager->setLocalConfigurationValuesByPathValuePairs($configurationValues);
395  $messageBody = [];
396  foreach ($configurationValues as $configurationKey => $configurationValue) {
397  if (is_array($configurationValue)) {
398  $configurationValue = json_encode($configurationValue);
399  }
400  $messageBody[] = '\'' . $configurationKey . '\' => \'' . $configurationValue . '\'';
401  }
402  $messages->enqueue(new ‪FlashMessage(
403  implode(', ', $messageBody),
404  'Configuration written'
405  ));
406  } else {
407  $messages->enqueue(new ‪FlashMessage(
408  '',
409  'No configuration change selected',
410  ContextualFeedbackSeverity::INFO
411  ));
412  }
413  }
414  return new ‪JsonResponse([
415  'success' => true,
416  'status' => $messages,
417  ]);
418  }
419 
423  public function ‪extensionConfigurationGetContentAction(ServerRequestInterface $request): ResponseInterface
424  {
425  // Extension configuration needs initialized $GLOBALS['LANG']
426  ‪$GLOBALS['LANG'] = $this->languageServiceFactory->create('default');
427  $extensionsWithConfigurations = [];
428  $activePackages = $this->packageManager->getActivePackages();
429  $extensionConfiguration = new ‪ExtensionConfiguration();
430  foreach ($activePackages as $extensionKey => $activePackage) {
431  if (@file_exists($activePackage->getPackagePath() . 'ext_conf_template.txt')) {
432  $ast = $this->astBuilder->build(
433  $this->losslessTokenizer->tokenize(file_get_contents($activePackage->getPackagePath() . 'ext_conf_template.txt')),
434  new ‪RootNode()
435  );
436  $astConstantCommentVisitor = new (AstConstantCommentVisitor::class);
437  $this->astTraverser->traverse($ast, [$astConstantCommentVisitor]);
438  $constants = $astConstantCommentVisitor->getConstants();
439  // @todo: It would be better to fetch all LocalConfiguration settings of an extension at once
440  // and feed it as pseudo-TS to the AST builder. This way the full AstConstantCommentVisitor
441  // preparation magic would kick in and the JS-side processing in extension-configuration.ts
442  // could be removed (especially the 'wrap' and 'offset' stuff) by handling it in fluid directly.
443  foreach ($constants as $constantName => &$constantDetails) {
444  try {
445  $valueFromLocalConfiguration = $extensionConfiguration->get($extensionKey, str_replace('.', '/', $constantName));
446  $constantDetails['value'] = $valueFromLocalConfiguration;
448  // Deliberately empty - it can happen at runtime that a written config does not return
449  // back all values (eg. saltedpassword with its userFuncs), which then miss in the written
450  // configuration and are only synced after next install tool run. This edge case is
451  // taken care of here.
452  }
453  }
454  $displayConstants = [];
455  foreach ($constants as $constant) {
456  $displayConstants[$constant['cat']][$constant['subcat_sorting_first']]['label'] = $constant['subcat_label'];
457  $displayConstants[$constant['cat']][$constant['subcat_sorting_first']]['items'][$constant['subcat_sorting_second']] = $constant;
458  }
459  foreach ($displayConstants as &$constantCategory) {
460  ksort($constantCategory);
461  foreach ($constantCategory as &$constantDetailItems) {
462  ksort($constantDetailItems['items']);
463  }
464  }
465  $extensionsWithConfigurations[$extensionKey] = $displayConstants;
466  }
467  }
468  ksort($extensionsWithConfigurations);
469  $formProtection = $this->formProtectionFactory->createFromRequest($request);
470  $isWritable = $this->configurationManager->canWriteConfiguration();
471  $view = $this->‪initializeView($request);
472  $view->assignMultiple([
473  'isWritable' => $isWritable,
474  'extensionsWithConfigurations' => $extensionsWithConfigurations,
475  'extensionConfigurationWriteToken' => $formProtection->generateToken('installTool', 'extensionConfigurationWrite'),
476  ]);
477  return new ‪JsonResponse([
478  'success' => true,
479  'html' => $view->render('Settings/ExtensionConfigurationGetContent'),
480  ]);
481  }
482 
486  public function ‪extensionConfigurationWriteAction(ServerRequestInterface $request): ResponseInterface
487  {
488  $messages = [];
489  if (!$this->configurationManager->canWriteConfiguration()) {
490  $messages[] = new ‪FlashMessage(
491  'The configuration file is not writable.',
492  'Configuration not writable',
493  ContextualFeedbackSeverity::ERROR
494  );
495  } else {
496  $extensionKey = $request->getParsedBody()['install']['extensionKey'];
497  $configuration = $request->getParsedBody()['install']['extensionConfiguration'] ?? [];
498  $nestedConfiguration = [];
499  foreach ($configuration as $configKey => $value) {
500  $nestedConfiguration = ‪ArrayUtility::setValueByPath($nestedConfiguration, $configKey, $value, '.');
501  }
502  (new ‪ExtensionConfiguration())->set($extensionKey, $nestedConfiguration);
503  $messages[] = new ‪FlashMessage(
504  'Successfully saved configuration for extension "' . $extensionKey . '".',
505  'Configuration saved',
506  ContextualFeedbackSeverity::OK
507  );
508  }
509  return new ‪JsonResponse([
510  'success' => true,
511  'status' => $messages,
512  ]);
513  }
514 
518  public function ‪featuresGetContentAction(ServerRequestInterface $request): ResponseInterface
519  {
520  $isWritable = $this->configurationManager->canWriteConfiguration();
521  $configurationDescription = GeneralUtility::makeInstance(YamlFileLoader::class)
522  ->load($this->configurationManager->getDefaultConfigurationDescriptionFileLocation());
523  $allFeatures = ‪$GLOBALS['TYPO3_CONF_VARS']['SYS']['features'] ?? [];
524  $features = [];
525  foreach ($allFeatures as $featureName => $featureValue) {
526  // Only features that have a .yml description will be listed. There is currently no
527  // way for extensions to extend this, so feature toggles of non-core extensions are
528  // not listed here.
529  if (isset($configurationDescription['SYS']['items']['features']['items'][$featureName]['description'])) {
530  $default = $this->configurationManager->getDefaultConfigurationValueByPath('SYS/features/' . $featureName);
531  $features[] = [
532  'label' => ucfirst(str_replace(['_', '.'], ' ', strtolower(‪GeneralUtility::camelCaseToLowerCaseUnderscored(preg_replace('/\./', ': ', $featureName, 1))))),
533  'name' => $featureName,
534  'description' => $configurationDescription['SYS']['items']['features']['items'][$featureName]['description'],
535  'default' => $default,
536  'value' => $featureValue,
537  ];
538  }
539  }
540  $formProtection = $this->formProtectionFactory->createFromRequest($request);
541  $view = $this->‪initializeView($request);
542  $view->assignMultiple([
543  'isWritable' => $isWritable,
544  'features' => $features,
545  'featuresSaveToken' => $formProtection->generateToken('installTool', 'featuresSave'),
546  ]);
547  $buttons = [];
548  if ($isWritable) {
549  $buttons[] = [
550  'btnClass' => 'btn-default t3js-features-save',
551  'text' => 'Save',
552  ];
553  }
554  return new ‪JsonResponse([
555  'success' => true,
556  'html' => $view->render('Settings/FeaturesGetContent'),
557  'buttons' => $buttons,
558  ]);
559  }
560 
564  public function ‪featuresSaveAction(ServerRequestInterface $request): ResponseInterface
565  {
566  if (!$this->configurationManager->canWriteConfiguration()) {
567  $message = new ‪FlashMessage(
568  'The configuration file is not writable.',
569  'Configuration not writable',
570  ContextualFeedbackSeverity::ERROR
571  );
572  } else {
573  $enabledFeaturesFromPost = $request->getParsedBody()['install']['values'] ?? [];
574  $allFeatures = array_keys(‪$GLOBALS['TYPO3_CONF_VARS']['SYS']['features'] ?? []);
575  $configurationDescription = GeneralUtility::makeInstance(YamlFileLoader::class)
576  ->load($this->configurationManager->getDefaultConfigurationDescriptionFileLocation());
577  $updatedFeatures = [];
578  $configurationPathValuePairs = [];
579  foreach ($allFeatures as $featureName) {
580  // Only features that have a .yml description will be listed. There is currently no
581  // way for extensions to extend this, so feature toggles of non-core extensions are
582  // not considered.
583  if (isset($configurationDescription['SYS']['items']['features']['items'][$featureName]['description'])) {
584  $path = 'SYS/features/' . $featureName;
585  $newValue = isset($enabledFeaturesFromPost[$featureName]);
586  if ($newValue !== $this->configurationManager->getConfigurationValueByPath($path)) {
587  $configurationPathValuePairs[$path] = $newValue;
588  $updatedFeatures[] = $featureName . ' [' . ($newValue ? 'On' : 'Off') . ']';
589  }
590  }
591  }
592  if ($configurationPathValuePairs !== []) {
593  $success = $this->configurationManager->setLocalConfigurationValuesByPathValuePairs($configurationPathValuePairs);
594  if ($success) {
595  $this->configurationManager->exportConfiguration();
596  $message = new ‪FlashMessage(
597  "Successfully updated the following feature toggles:\n" . implode(",\n", $updatedFeatures),
598  'Features updated',
599  ContextualFeedbackSeverity::OK
600  );
601  } else {
602  $message = new ‪FlashMessage(
603  'An error occurred while saving. Some settings may not have been updated.',
604  'Features not updated',
605  ContextualFeedbackSeverity::ERROR
606  );
607  }
608  } else {
609  $message = new ‪FlashMessage(
610  'Nothing to update.',
611  'Features not updated',
612  ContextualFeedbackSeverity::INFO
613  );
614  }
615  }
616  return new ‪JsonResponse([
617  'success' => true,
618  'status' => [$message],
619  ]);
620  }
621 }
‪TYPO3\CMS\Core\Localization\LanguageServiceFactory
Definition: LanguageServiceFactory.php:25
‪TYPO3\CMS\Install\Controller\SettingsController\localConfigurationWriteAction
‪localConfigurationWriteAction(ServerRequestInterface $request)
Definition: SettingsController.php:314
‪TYPO3\CMS\Core\Crypto\PasswordHashing\PasswordHashFactory
Definition: PasswordHashFactory.php:27
‪TYPO3\CMS\Core\Database\Connection\PARAM_INT
‪const PARAM_INT
Definition: Connection.php:46
‪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:661
‪TYPO3\CMS\Install\Controller\SettingsController\presetsGetContentAction
‪presetsGetContentAction(ServerRequestInterface $request)
Definition: SettingsController.php:350
‪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:381
‪TYPO3\CMS\Install\Controller\SettingsController\systemMaintainerWriteAction
‪systemMaintainerWriteAction(ServerRequestInterface $request)
Definition: SettingsController.php:211
‪TYPO3\CMS\Install\Controller\SettingsController\localConfigurationGetContentAction
‪localConfigurationGetContentAction(ServerRequestInterface $request)
Definition: SettingsController.php:276
‪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:423
‪TYPO3\CMS\Install\Controller\SettingsController\featuresGetContentAction
‪featuresGetContentAction(ServerRequestInterface $request)
Definition: SettingsController.php:518
‪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:486
‪TYPO3\CMS\Install\Controller\SettingsController\featuresSaveAction
‪featuresSaveAction(ServerRequestInterface $request)
Definition: SettingsController.php:564
‪TYPO3\CMS\Core\Database\Connection
Definition: Connection.php:35
‪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