Argument.php

Go to the documentation of this file.

<?php
namespace TYPO3\CMS\Extbase\Mvc\Controller;

use TYPO3\CMS\Extbase\Property\Exception\TargetNotFoundException;

class Argument {

    protected $objectManager;

    protected $queryFactory;

    protected $configurationManager;

    protected $deprecatedPropertyMapper;

    protected $propertyMapper;

    protected $propertyMappingConfiguration;

    protected $reflectionService;

    protected $typeHandlingService;

    protected $name = '';

    protected $shortName = NULL;

    protected $dataType = NULL;

    protected $dataTypeClassSchema;

    protected $isRequired = FALSE;

    protected $value = NULL;

    protected $defaultValue = NULL;

    protected $validator = NULL;

    protected $validationResults = NULL;

    protected $uid = NULL;

    const ORIGIN_CLIENT = 0;
    const ORIGIN_PERSISTENCE = 1;
    const ORIGIN_PERSISTENCE_AND_MODIFIED = 2;
    const ORIGIN_NEWLY_CREATED = 3;

    protected $origin = 0;

    protected $persistenceManager;

    public function __construct($name, $dataType) {
        if (!is_string($name)) {
            throw new \InvalidArgumentException('$name must be of type string, ' . gettype($name) . ' given.', 1187951688);
        }
        if (strlen($name) === 0) {
            throw new \InvalidArgumentException('$name must be a non-empty string, ' . strlen($name) . ' characters given.', 1232551853);
        }
        $this->name = $name;
        $this->dataType = $dataType;
    }

    public function injectReflectionService(\TYPO3\CMS\Extbase\Reflection\ReflectionService $reflectionService) {
        $this->reflectionService = $reflectionService;
        // Check for classnames (which have at least one underscore or backslash)
        $this->dataTypeClassSchema = strpbrk($this->dataType, '_\\') !== FALSE ? $this->reflectionService->getClassSchema($this->dataType) : NULL;
    }

    public function injectTypeHandlingService(\TYPO3\CMS\Extbase\Service\TypeHandlingService $typeHandlingService) {
        $this->typeHandlingService = $typeHandlingService;
        $this->dataType = $this->typeHandlingService->normalizeType($this->dataType);
    }

    public function getName() {
        return $this->name;
    }

    public function setShortName($shortName) {
        if ($shortName !== NULL && (!is_string($shortName) || strlen($shortName) !== 1)) {
            throw new \InvalidArgumentException('$shortName must be a single character or NULL', 1195824959);
        }
        $this->shortName = $shortName;
        return $this;
    }

    public function getShortName() {
        return $this->shortName;
    }

    public function setDataType($dataType) {
        $this->dataType = $dataType;
        $this->dataTypeClassSchema = $this->reflectionService->getClassSchema($dataType);
        return $this;
    }

    public function getDataType() {
        return $this->dataType;
    }

    public function setRequired($required) {
        $this->isRequired = (boolean) $required;
        return $this;
    }

    public function isRequired() {
        return $this->isRequired;
    }

    public function setDefaultValue($defaultValue) {
        $this->defaultValue = $defaultValue;
        return $this;
    }

    public function getDefaultValue() {
        return $this->defaultValue;
    }

    public function setValidator(\TYPO3\CMS\Extbase\Validation\Validator\ValidatorInterface $validator) {
        $this->validator = $validator;
        return $this;
    }

    public function setNewValidatorConjunction(array $objectNames) {
        if ($this->validator === NULL) {
            $this->validator = $this->objectManager->get('TYPO3\\CMS\\Extbase\\Validation\\Validator\\ConjunctionValidator');
        }
        foreach ($objectNames as $objectName) {
            if (!class_exists($objectName)) {
                $objectName = 'Tx_Extbase_Validation_Validator_' . $objectName;
            }
            $this->validator->addValidator($this->objectManager->get($objectName));
        }
        return $this;
    }

    public function getValidator() {
        return $this->validator;
    }

    public function getOrigin() {
        return $this->origin;
    }

    public function setValue($rawValue) {
        if ($this->configurationManager->isFeatureEnabled('rewrittenPropertyMapper')) {
            if ($rawValue === NULL) {
                $this->value = NULL;
                return $this;
            }
            if (is_object($rawValue) && $rawValue instanceof $this->dataType) {
                $this->value = $rawValue;
                return $this;
            }
            try {
                $this->value = $this->propertyMapper->convert($rawValue, $this->dataType, $this->propertyMappingConfiguration);
            } catch (TargetNotFoundException $e) {
                // for optional arguments no exeption is thrown.
                if ($this->isRequired()) {
                    throw $e;
                }
            }
            $this->validationResults = $this->propertyMapper->getMessages();
            if ($this->validator !== NULL) {
                // TODO: Validation API has also changed!!!
                $validationMessages = $this->validator->validate($this->value);
                $this->validationResults->merge($validationMessages);
            }
            return $this;
        } else {
            if ($rawValue === NULL || is_object($rawValue) && $rawValue instanceof $this->dataType) {
                $this->value = $rawValue;
            } else {
                $this->value = $this->transformValue($rawValue);
            }
            return $this;
        }
    }

    protected function transformValue($value) {
        if (!class_exists($this->dataType)) {
            return $value;
        }
        $transformedValue = NULL;
        if ($this->dataTypeClassSchema !== NULL) {
            // The target object is an Entity or ValueObject.
            if (is_numeric($value)) {
                $this->origin = self::ORIGIN_PERSISTENCE;
                $transformedValue = $this->findObjectByUid($value);
            } elseif (is_array($value)) {
                $this->origin = self::ORIGIN_PERSISTENCE_AND_MODIFIED;
                $transformedValue = $this->deprecatedPropertyMapper->map(array_keys($value), $value, $this->dataType);
            }
        } else {
            if (!is_array($value)) {
                throw new \TYPO3\CMS\Extbase\Mvc\Exception\InvalidArgumentValueException('The value was a simple type, so we could not map it to an object. Maybe the @entity or @valueobject annotations are missing?', 1251730701);
            }
            $this->origin = self::ORIGIN_NEWLY_CREATED;
            $transformedValue = $this->deprecatedPropertyMapper->map(array_keys($value), $value, $this->dataType);
        }
        if (!$transformedValue instanceof $this->dataType && ($transformedValue !== NULL || $this->isRequired())) {
            throw new \TYPO3\CMS\Extbase\Mvc\Exception\InvalidArgumentValueException('The value must be of type "' . $this->dataType . '", but was of type "' . (is_object($transformedValue) ? get_class($transformedValue) : gettype($transformedValue)) . '".' . ($this->deprecatedPropertyMapper->getMappingResults()->hasErrors() ? '<p>' . implode('<br />', $this->deprecatedPropertyMapper->getMappingResults()->getErrors()) . '</p>' : ''), 1251730702);
        }
        return $transformedValue;
    }

    protected function findObjectByUid($uid) {
        $query = $this->queryFactory->create($this->dataType);
        $query->getQuerySettings()->setRespectSysLanguage(FALSE);
        $query->getQuerySettings()->setRespectStoragePage(FALSE);
        return $query->matching($query->equals('uid', $uid))->execute()->getFirst();
    }

    public function getValue() {
        if ($this->value === NULL) {
            return $this->defaultValue;
        } else {
            return $this->value;
        }
    }

    public function isValue() {
        return $this->value !== NULL;
    }

    public function getPropertyMappingConfiguration() {
        return $this->propertyMappingConfiguration;
    }

    public function isValid() {
        return !$this->validationResults->hasErrors();
    }

    public function getValidationResults() {
        return $this->validationResults;
    }

    public function __toString() {
        return (string) $this->value;
    }
}