FormDataTraverser.php

Go to the documentation of this file.

<?php
namespace TYPO3\CMS\Backend\Form;

use TYPO3\CMS\Backend\Utility\BackendUtility;
use TYPO3\CMS\Core\Utility\GeneralUtility;

class FormDataTraverser {

    protected $alternativeFieldValue;

    protected $forceAlternativeFieldValueUse = FALSE;

    protected $currentRow;

    protected $currentTable;

    protected $formEngine;

    protected $originalLanguageUid = NULL;

    public function __construct(\TYPO3\CMS\Backend\Form\FormEngine $formEngine) {
        $this->formEngine = $formEngine;
    }

    public function getTraversedFieldValue(array $fieldNameArray, $tableName, array $row) {
        $this->currentTable = $tableName;
        $this->currentRow = $row;
        $fieldValue = '';
        if (count($fieldNameArray) > 0) {
            $this->initializeOriginalLanguageUid();
            $fieldValue = $this->getFieldValueRecursive($fieldNameArray);
        }
        return $fieldValue;
    }

    protected function initializeOriginalLanguageUid() {
        $fieldCtrlConfig = $GLOBALS['TCA'][$this->currentTable]['ctrl'];
        if (!empty($fieldCtrlConfig['languageField']) && isset($this->currentRow[$fieldCtrlConfig['languageField']])) {
            $this->originalLanguageUid = (int)$this->currentRow[$fieldCtrlConfig['languageField']];
        } else {
            $this->originalLanguageUid = FALSE;
        }
    }

    protected function getFieldValueRecursive(array $fieldNameArray) {
        $value = '';

        foreach ($fieldNameArray as $fieldName) {
            // Skip if a defined field was actually not present in the database row
            // Using array_key_exists here, since TYPO3 supports NULL values as well
            if (!array_key_exists($fieldName, $this->currentRow)) {
                $value = '';
                break;
            }

            $value = $this->currentRow[$fieldName];
            if (empty($value)) {
                break;
            }

            $this->currentRow = $this->getRelatedRecordRow($fieldName, $value);
            if ($this->currentRow === FALSE) {
                break;
            }
        }

        if ((empty($value) || $this->forceAlternativeFieldValueUse) && !empty($this->alternativeFieldValue)) {
            $value = $this->alternativeFieldValue;
        }

        return $value;
    }

    protected function getRelatedRecordRow($fieldName, $value) {
        $fieldConfig = $GLOBALS['TCA'][$this->currentTable]['columns'][$fieldName]['config'];
        $possibleUids = array();

        switch ($fieldConfig['type']) {
            case 'group':
                $possibleUids = $this->getRelatedGroupFieldUids($fieldConfig, $value);
                break;
            case 'select':
                $possibleUids = $this->getRelatedSelectFieldUids($fieldConfig, $fieldName, $value);
                break;
            case 'inline':
                $possibleUids = $this->getRelatedInlineFieldUids($fieldConfig, $fieldName, $value);
                break;
        }

        $relatedRow = FALSE;
        if (count($possibleUids) === 1) {
            $relatedRow = $this->getRecordRow($possibleUids[0]);
        } elseif (count($possibleUids) > 1) {
            $relatedRow = $this->getMatchingRecordRowByTranslation($possibleUids, $fieldConfig);
        }

        return $relatedRow;
    }

    protected function getRelatedGroupFieldUids(array $fieldConfig, $value) {
        $relatedUids = array();
        $allowedTable = $this->getAllowedTableForGroupField($fieldConfig);

        if (($fieldConfig['internal_type'] !== 'db') || ($allowedTable === FALSE)) {
            return $relatedUids;
        }

        $values = GeneralUtility::trimExplode(',', $value, TRUE);
        foreach ($values as $groupValue) {
            list($foreignIdentifier, $foreignTitle) = GeneralUtility::trimExplode('|', $groupValue);
            list($recordForeignTable, $foreignUid) = BackendUtility::splitTable_Uid($foreignIdentifier);
            // skip records that do not match the allowed table
            if (!empty($recordForeignTable) && ($recordForeignTable !== $allowedTable)) {
                continue;
            }
            if (!empty($foreignTitle)) {
                $this->alternativeFieldValue = rawurldecode($foreignTitle);
            }
            $relatedUids[] = $foreignUid;
        }

        if (count($relatedUids) > 0) {
            $this->currentTable = $allowedTable;
        }

        return $relatedUids;
    }

    protected function getRelatedSelectFieldUids(array $fieldConfig, $fieldName, $value) {
        $relatedUids = array();

        $isTraversable = FALSE;
        if (isset($fieldConfig['foreign_table'])) {
            $isTraversable = TRUE;
            // if a foreign_table is used we pre-filter the records for performance
            $fieldConfig['foreign_table_where'] .= ' AND ' . $fieldConfig['foreign_table'] . '.uid IN (' . $value . ')';
        }

        $PA = array();
        $PA['fieldConf']['config'] = $fieldConfig;
        $PA['fieldConf']['config']['form_type'] = $PA['fieldConf']['config']['form_type'] ? $PA['fieldConf']['config']['form_type'] : $PA['fieldConf']['config']['type'];
        $PA['fieldTSConfig'] = $this->formEngine->setTSconfig($this->currentTable, $this->currentRow, $fieldName);
        $PA['fieldConf']['config'] = $this->formEngine->overrideFieldConf($PA['fieldConf']['config'], $PA['fieldTSConfig']);
        $selectItemArray = $this->formEngine->getSelectItems($this->currentTable, $fieldName, $this->currentRow, $PA);

        if ($isTraversable && count($selectItemArray)) {
            $this->currentTable = $fieldConfig['foreign_table'];
            $relatedUids = $this->getSelectedValuesFromSelectItemArray($selectItemArray, $value);
        } else {
            $selectedLabels = $this->getSelectedValuesFromSelectItemArray($selectItemArray, $value, 1, TRUE);
            if (count($selectedLabels) === 1) {
                $this->alternativeFieldValue = $selectedLabels[0];
                $this->forceAlternativeFieldValueUse = TRUE;
            }
        }

        return $relatedUids;
    }

    protected function getSelectedValuesFromSelectItemArray(array $selectItemArray, $value, $maxItems = NULL, $returnLabels = FALSE) {
        $values = GeneralUtility::trimExplode(',', $value);
        $selectedValues = array();

        if ($maxItems !== NULL && (count($values) > (int)$maxItems)) {
            return $selectedValues;
        }

        foreach ($selectItemArray as $selectItem) {
            $selectItemValue = $selectItem[1];
            if (in_array($selectItemValue, $values)) {
                if ($returnLabels) {
                    $selectedValues[] = $selectItem[0];
                } else {
                    $selectedValues[] = $selectItemValue;
                }
            }
        }

        return $selectedValues;
    }


    protected function getRelatedInlineFieldUids(array $fieldConfig, $fieldName, $value) {
        $relatedUids = array();

        $PA = array('itemFormElValue' => $value);
        $items = $this->formEngine->inline->getRelatedRecords($this->currentTable, $fieldName, $this->currentRow, $PA, $fieldConfig);
        if ($items['count'] > 0) {
            $this->currentTable = $fieldConfig['foreign_table'];
            foreach ($items['records'] as $inlineRecord) {
                $relatedUids[] = $inlineRecord['uid'];
            }
        }

        return $relatedUids;
    }

    protected function getAllowedTableForGroupField(array $fieldConfig) {
        $allowedTable = FALSE;

        $allowedTables = GeneralUtility::trimExplode(',', $fieldConfig['allowed'], TRUE);
        if (count($allowedTables) === 1) {
            $allowedTable = $allowedTables[0];
        }

        return $allowedTable;
    }

    protected function getRecordRow($uid) {
        $dataPreprocessor = GeneralUtility::makeInstance('TYPO3\CMS\Backend\Form\DataPreprocessor');
        $dataPreprocessor->fetchRecord($this->currentTable, $uid, '');
        return reset($dataPreprocessor->regTableItems_data);
    }

    protected function getMatchingRecordRowByTranslation(array $relatedUids) {
        if ($this->originalLanguageUid === FALSE) {
            return FALSE;
        }

        $fieldCtrlConfig = $GLOBALS['TCA'][$this->currentTable]['ctrl'];
        if (empty($fieldCtrlConfig['languageField'])) {
            return FALSE;
        }

        $languageField = $fieldCtrlConfig['languageField'];
        $foundRows = array();
        foreach ($relatedUids as $relatedUid) {
            $currentRow = $this->getRecordRow($relatedUid);
            if (!isset($currentRow[$languageField])) {
                continue;
            }
            if ((int)$currentRow[$languageField] === $this->originalLanguageUid) {
                $foundRows[] = $currentRow;
            }
        }

        $relatedRow = FALSE;
        if (count($foundRows) === 1) {
            $relatedRow = $foundRows[0];
        }

        return $relatedRow;
    }
}