ElementConditionMatcher.php

Go to the documentation of this file.

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

use TYPO3\CMS\Core\Utility\ExtensionManagementUtility;

class ElementConditionMatcher {

    protected $flexformValueKey = '';

    protected $record = array();

    public function match($displayCondition, array $record = array(), $flexformValueKey = '', $recursionLevel = 0) {
        if ($recursionLevel > 99) {
            // This should not happen, treat as misconfiguration
            return TRUE;
        }
        if (!is_array($displayCondition)) {
            // DisplayCondition is not an array - just get its value
            $result = $this->matchSingle($displayCondition, $record, $flexformValueKey);
        } else {
            // Multiple conditions given as array ('AND|OR' => condition array)
            $conditionEvaluations = array(
                'AND' => array(),
                'OR' => array(),
            );
            foreach ($displayCondition as $logicalOperator => $groupedDisplayConditions) {
                $logicalOperator = strtoupper($logicalOperator);
                if (($logicalOperator !== 'AND' && $logicalOperator !== 'OR') || !is_array($groupedDisplayConditions)) {
                    // Invalid line. Skip it.
                    continue;
                } else {
                    foreach ($groupedDisplayConditions as $key => $singleDisplayCondition) {
                        $key = strtoupper($key);
                        if (($key === 'AND' || $key === 'OR') && is_array($singleDisplayCondition)) {
                            // Recursion statement: condition is 'AND' or 'OR' and is pointing to an array (should be conditions again)
                            $conditionEvaluations[$logicalOperator][] = $this->match(
                                array($key => $singleDisplayCondition),
                                $record,
                                $flexformValueKey,
                                $recursionLevel + 1
                            );
                        } else {
                            // Condition statement: collect evaluation of this single condition.
                            $conditionEvaluations[$logicalOperator][] = $this->matchSingle(
                                $singleDisplayCondition,
                                $record,
                                $flexformValueKey
                            );
                        }
                    }
                }
            }
            if (count($conditionEvaluations['OR']) > 0 && in_array(TRUE, $conditionEvaluations['OR'], TRUE)) {
                // There are OR conditions and at least one of them is TRUE
                $result = TRUE;
            } elseif (count($conditionEvaluations['AND']) > 0 && !in_array(FALSE, $conditionEvaluations['AND'], TRUE)) {
                // There are AND conditions and none of them is FALSE
                $result = TRUE;
            } elseif (count($conditionEvaluations['OR']) > 0 || count($conditionEvaluations['AND']) > 0) {
                // There are some conditions. But no OR was TRUE and at least one AND was FALSE
                $result = FALSE;
            } else {
                // There are no proper conditions - misconfiguration. Return TRUE.
                $result = TRUE;
            }
        }
        return $result;
    }

    protected function matchSingle($displayCondition, array $record = array(), $flexformValueKey = '') {
        $this->record = $record;
        $this->flexformValueKey = $flexformValueKey;
        $result = FALSE;
        list($matchType, $condition) = explode(':', $displayCondition, 2);
        switch ($matchType) {
            case 'EXT':
                $result = $this->matchExtensionCondition($condition);
                break;
            case 'FIELD':
                $result = $this->matchFieldCondition($condition);
                break;
            case 'HIDE_FOR_NON_ADMINS':
                $result = $this->matchHideForNonAdminsCondition();
                break;
            case 'HIDE_L10N_SIBLINGS':
                $result = $this->matchHideL10nSiblingsCondition($condition);
                break;
            case 'REC':
                $result = $this->matchRecordCondition($condition);
                break;
            case 'VERSION':
                $result = $this->matchVersionCondition($condition);
                break;
        }
        return $result;
    }

    protected function matchExtensionCondition($condition) {
        $result = FALSE;
        list($extensionKey, $operator, $operand) = explode(':', $condition, 3);
        if ($operator === 'LOADED') {
            if (strtoupper($operand) === 'TRUE') {
                $result = ExtensionManagementUtility::isLoaded($extensionKey);
            } elseif (strtoupper($operand) === 'FALSE') {
                $result = !ExtensionManagementUtility::isLoaded($extensionKey);
            }
        }
        return $result;
    }

    protected function matchFieldCondition($condition) {
        list($fieldName, $operator, $operand) = explode(':', $condition, 3);
        if ($this->flexformValueKey) {
            if (strpos($fieldName, 'parentRec.') !== FALSE) {
                $fieldNameParts = explode('.', $fieldName, 2);
                $fieldValue = $this->record['parentRec'][$fieldNameParts[1]];
            } else {
                $fieldValue = $this->record[$fieldName][$this->flexformValueKey];
            }
        } else {
            $fieldValue = $this->record[$fieldName];
        }

        $result = FALSE;
        switch ($operator) {
            case 'REQ':
                if (strtoupper($operand) === 'TRUE') {
                    $result = (bool) $fieldValue;
                } else {
                    $result = !$fieldValue;
                }
                break;
            case '>':
                $result = $fieldValue > $operand;
                break;
            case '<':
                $result = $fieldValue < $operand;
                break;
            case '>=':
                $result = $fieldValue >= $operand;
                break;
            case '<=':
                $result = $fieldValue <= $operand;
                break;
            case '-':
            case '!-':
                list($minimum, $maximum) = explode('-', $operand);
                $result = $fieldValue >= $minimum && $fieldValue <= $maximum;
                if ($operator[0] === '!') {
                    $result = !$result;
                }
                break;
            case 'IN':
            case '!IN':
            case '=':
            case '!=':
                $result = \TYPO3\CMS\Core\Utility\GeneralUtility::inList($operand, $fieldValue);
                if ($operator[0] === '!') {
                    $result = !$result;
                }
                break;
            case 'BIT':
            case '!BIT':
                $result = ((int)$fieldValue & $operand) ? TRUE : FALSE;
                if ($operator[0] === '!') {
                    $result = !$result;
                }
                break;
        }
        return $result;
    }

    protected function matchHideForNonAdminsCondition() {
        return (bool) $this->getBackendUser()->isAdmin();
    }

    protected function matchHideL10nSiblingsCondition($condition) {
        $result = FALSE;
        if ($this->flexformValueKey === 'vDEF') {
            $result = TRUE;
        } elseif ($condition === 'except_admin' && $this->getBackendUser()->isAdmin()) {
            $result = TRUE;
        }
        return $result;
    }

    protected function matchRecordCondition($condition) {
        $result = FALSE;
        list($operator, $operand) = explode(':', $condition, 2);
        if ($operator === 'NEW') {
            if (strtoupper($operand) === 'TRUE') {
                $result = !((int)$this->record['uid'] > 0);
            } elseif (strtoupper($operand) === 'FALSE') {
                $result = ((int)$this->record['uid'] > 0);
            }
        }
        return $result;
    }

    protected function matchVersionCondition($condition) {
        $result = FALSE;
        list($operator, $operand) = explode(':', $condition, 2);
        if ($operator === 'IS') {
            $isNewRecord = !((int)$this->record['uid'] > 0);
            // Detection of version can be done be detecting the workspace of the user
            $isUserInWorkspace = $this->getBackendUser()->workspace > 0;
            if ((int)$this->record['pid'] === -1 || (int)$this->record['_ORIG_pid'] === -1) {
                $isRecordDetectedAsVersion = TRUE;
            } else {
                $isRecordDetectedAsVersion = FALSE;
            }
            // New records in a workspace are not handled as a version record
            // if it's no new version, we detect versions like this:
            // -- if user is in workspace: always TRUE
            // -- if editor is in live ws: only TRUE if pid == -1
            $isVersion = ($isUserInWorkspace || $isRecordDetectedAsVersion) && !$isNewRecord;
            if (strtoupper($operand) === 'TRUE') {
                $result = $isVersion;
            } elseif (strtoupper($operand) === 'FALSE') {
                $result = !$isVersion;
            }
        }
        return $result;
    }

    protected function getBackendUser() {
        return $GLOBALS['BE_USER'];
    }
}