SaveToDatabaseFinisher.php

Go to the documentation of this file.

<?php
 
declare(strict_types=1);
 
/*
 * This file is part of the TYPO3 CMS project.
 *
 * It is free software; you can redistribute it and/or modify it under
 * the terms of the GNU General Public License, either version 2
 * of the License, or any later version.
 *
 * For the full copyright and license information, please read the
 * LICENSE.txt file that was distributed with this source code.
 *
 * The TYPO3 project - inspiring people to share!
 */
 
namespace ‪TYPO3\CMS\Form\Domain\Finishers;
 
use ‪TYPO3\CMS\Core\Database\ConnectionPool;
use ‪TYPO3\CMS\Core\Utility\GeneralUtility;
use ‪TYPO3\CMS\Extbase\Domain\Model\FileReference;
use ‪TYPO3\CMS\Form\Domain\Finishers\Exception\FinisherException;
use ‪TYPO3\CMS\Form\Domain\Model\FormElements\FormElementInterface;
 
class ‪SaveToDatabaseFinisher extends ‪AbstractFinisher
{
    protected ‪$defaultOptions = [
        'table' => null,
        'mode' => 'insert',
        'whereClause' => [],
        'elements' => [],
        'databaseColumnMappings' => [],
    ];
 
    protected ‪$databaseConnection;
 
    protected function ‪executeInternal()
    {
        ‪$options = [];
        if (isset($this->options['table'])) {
            ‪$options[] = ‪$this->options;
        } else {
            ‪$options = ‪$this->options;
        }
 
        foreach (‪$options as $optionKey => $option) {
            $this->options = $option;
            $this->‪process($optionKey);
        }
    }
 
    protected function ‪prepareData(array $elementsConfiguration, array $databaseData)
    {
        foreach ($this->‪getFormValues() as $elementIdentifier => $elementValue) {
            if (
                ($elementValue === null || $elementValue === '')
                && isset($elementsConfiguration[$elementIdentifier])
                && isset($elementsConfiguration[$elementIdentifier]['skipIfValueIsEmpty'])
                && $elementsConfiguration[$elementIdentifier]['skipIfValueIsEmpty'] === true
            ) {
                continue;
            }
 
            $element = $this->‪getElementByIdentifier($elementIdentifier);
            if (
                !$element instanceof ‪FormElementInterface
                || !isset($elementsConfiguration[$elementIdentifier])
                || !isset($elementsConfiguration[$elementIdentifier]['mapOnDatabaseColumn'])
            ) {
                continue;
            }
 
            if ($elementValue instanceof ‪FileReference) {
                if (isset($elementsConfiguration[$elementIdentifier]['saveFileIdentifierInsteadOfUid'])) {
                    $saveFileIdentifierInsteadOfUid = (bool)$elementsConfiguration[$elementIdentifier]['saveFileIdentifierInsteadOfUid'];
                } else {
                    $saveFileIdentifierInsteadOfUid = false;
                }
 
                if ($saveFileIdentifierInsteadOfUid) {
                    $elementValue = $elementValue->getOriginalResource()->getCombinedIdentifier();
                } else {
                    $elementValue = $elementValue->getOriginalResource()->getProperty('uid_local');
                }
            } elseif (is_array($elementValue)) {
                $elementValue = implode(',', $elementValue);
            } elseif ($elementValue instanceof \DateTimeInterface) {
                $format = $elementsConfiguration[$elementIdentifier]['dateFormat'] ?? 'U';
                $elementValue = $elementValue->format($format);
            }
 
            $databaseData[$elementsConfiguration[$elementIdentifier]['mapOnDatabaseColumn']] = $elementValue;
        }
        return $databaseData;
    }
 
    protected function ‪process(int $iterationCount)
    {
        $this->‪throwExceptionOnInconsistentConfiguration();
 
        $table = $this->‪parseOption('table');
        $table = is_string($table) ? $table : '';
        $elementsConfiguration = $this->‪parseOption('elements');
        $elementsConfiguration = is_array($elementsConfiguration) ? $elementsConfiguration : [];
        $databaseColumnMappingsConfiguration = $this->‪parseOption('databaseColumnMappings');
 
        $this->databaseConnection = GeneralUtility::makeInstance(ConnectionPool::class)->getConnectionForTable($table);
 
        $databaseData = [];
        foreach ($databaseColumnMappingsConfiguration as $databaseColumnName => $databaseColumnConfiguration) {
            $value = $this->‪parseOption('databaseColumnMappings.' . $databaseColumnName . '.value');
            if (
                empty($value)
                && ($databaseColumnConfiguration['skipIfValueIsEmpty'] ?? false) === true
            ) {
                continue;
            }
 
            $databaseData[$databaseColumnName] = $value;
        }
 
        $databaseData = $this->‪prepareData($elementsConfiguration, $databaseData);
 
        $this->‪saveToDatabase($databaseData, $table, $iterationCount);
    }
 
    protected function ‪saveToDatabase(array $databaseData, string $table, int $iterationCount)
    {
        if (!empty($databaseData)) {
            if ($this->‪parseOption('mode') === 'update') {
                $whereClause = $this->‪parseOption('whereClause');
                foreach ($whereClause as $columnName => $columnValue) {
                    $whereClause[$columnName] = $this->‪parseOption('whereClause.' . $columnName);
                }
                $this->databaseConnection->update(
                    $table,
                    $databaseData,
                    $whereClause
                );
            } else {
                $this->databaseConnection->insert($table, $databaseData);
                $insertedUid = (int)$this->databaseConnection->lastInsertId($table);
                $this->finisherContext->getFinisherVariableProvider()->add(
                    $this->shortFinisherIdentifier,
                    'insertedUids.' . $iterationCount,
                    $insertedUid
                );
            }
        }
    }
 
    protected function ‪throwExceptionOnInconsistentConfiguration()
    {
        if (
            $this->‪parseOption('mode') === 'update'
            && empty($this->‪parseOption('whereClause'))
        ) {
            throw new ‪FinisherException(
                'An empty option "whereClause" is not allowed in update mode.',
                1480469086
            );
        }
    }
 
    protected function ‪getFormValues(): array
    {
        return $this->finisherContext->getFormValues();
    }
 
    protected function ‪getElementByIdentifier(string $elementIdentifier)
    {
        return $this
            ->finisherContext
            ->getFormRuntime()
            ->getFormDefinition()
            ->getElementByIdentifier($elementIdentifier);
    }
}