Mapper.php

Go to the documentation of this file.

<?php
namespace TYPO3\CMS\Extbase\Property;

class Mapper implements \TYPO3\CMS\Core\SingletonInterface {

    protected $mappingResults;

    protected $validatorResolver;

    protected $reflectionService;

    protected $persistenceManager;

    protected $objectManager;

    protected $queryFactory;

    public function mapAndValidate(array $propertyNames, $source, $target, $optionalPropertyNames = array(), \TYPO3\CMS\Extbase\Validation\Validator\ObjectValidatorInterface $targetObjectValidator) {
        $backupProperties = array();
        $this->map($propertyNames, $source, $backupProperties, $optionalPropertyNames);
        if ($this->mappingResults->hasErrors()) {
            return FALSE;
        }
        $this->map($propertyNames, $source, $target, $optionalPropertyNames);
        if ($this->mappingResults->hasErrors()) {
            return FALSE;
        }
        if ($targetObjectValidator->isValid($target) !== TRUE) {
            $this->addErrorsFromObjectValidator($targetObjectValidator->getErrors());
            $backupMappingResult = $this->mappingResults;
            $this->map($propertyNames, $backupProperties, $source, $optionalPropertyNames);
            $this->mappingResults = $backupMappingResult;
        }
        return !$this->mappingResults->hasErrors();
    }

    protected function addErrorsFromObjectValidator($errors) {
        foreach ($errors as $error) {
            if ($error instanceof \TYPO3\CMS\Extbase\Validation\PropertyError) {
                $propertyName = $error->getPropertyName();
                $this->mappingResults->addError($error, $propertyName);
            }
        }
    }

    public function map(array $propertyNames, $source, $target, $optionalPropertyNames = array()) {
        if (!is_object($source) && !is_array($source)) {
            throw new \TYPO3\CMS\Extbase\Property\Exception\InvalidSourceException('The source object must be a valid object or array, ' . gettype($target) . ' given.', 1187807099);
        }
        if (is_string($target) && strpbrk($target, '_\\') !== FALSE) {
            return $this->transformToObject($source, $target, '--none--');
        }
        if (!is_object($target) && !is_array($target)) {
            throw new \TYPO3\CMS\Extbase\Property\Exception\InvalidTargetException('The target object must be a valid object or array, ' . gettype($target) . ' given.', 1187807100);
        }
        $this->mappingResults = new \TYPO3\CMS\Extbase\Property\MappingResults();
        if (is_object($target)) {
            $targetClassSchema = $this->reflectionService->getClassSchema(get_class($target));
        } else {
            $targetClassSchema = NULL;
        }
        foreach ($propertyNames as $propertyName) {
            $propertyValue = NULL;
            if (is_array($source) || $source instanceof \ArrayAccess) {
                if (isset($source[$propertyName])) {
                    $propertyValue = $source[$propertyName];
                }
            } else {
                $propertyValue = \TYPO3\CMS\Extbase\Reflection\ObjectAccess::getProperty($source, $propertyName);
            }
            if ($propertyValue === NULL && !in_array($propertyName, $optionalPropertyNames)) {
                $this->mappingResults->addError(new \TYPO3\CMS\Extbase\Error\Error("Required property '{$propertyName}' does not exist.", 1236785359), $propertyName);
            } else {
                if ($targetClassSchema !== NULL && $targetClassSchema->hasProperty($propertyName)) {
                    $propertyMetaData = $targetClassSchema->getProperty($propertyName);
                    if (in_array($propertyMetaData['type'], array('array', 'ArrayObject', 'TYPO3\\CMS\\Extbase\\Persistence\\ObjectStorage', 'Tx_Extbase_Persistence_ObjectStorage'), TRUE) && (strpbrk($propertyMetaData['elementType'], '_\\') !== FALSE || $propertyValue === '')) {
                        $objects = array();
                        if (is_array($propertyValue)) {
                            foreach ($propertyValue as $value) {
                                $transformedObject = $this->transformToObject($value, $propertyMetaData['elementType'], $propertyName);
                                if ($transformedObject !== NULL) {
                                    $objects[] = $transformedObject;
                                }
                            }
                        }
                        // make sure we hand out what is expected
                        if ($propertyMetaData['type'] === 'ArrayObject') {
                            $propertyValue = new \ArrayObject($objects);
                        } elseif (in_array($propertyMetaData['type'], array('TYPO3\\CMS\\Extbase\\Persistence\\ObjectStorage', 'Tx_Extbase_Persistence_ObjectStorage'), TRUE)) {
                            $propertyValue = new \TYPO3\CMS\Extbase\Persistence\ObjectStorage();
                            foreach ($objects as $object) {
                                $propertyValue->attach($object);
                            }
                        } else {
                            $propertyValue = $objects;
                        }
                    } elseif ($propertyMetaData['type'] === 'DateTime' || strpbrk($propertyMetaData['type'], '_\\') !== FALSE) {
                        $propertyValue = $this->transformToObject($propertyValue, $propertyMetaData['type'], $propertyName);
                        if ($propertyValue === NULL) {
                            continue;
                        }
                    }
                } elseif (
                    $targetClassSchema !== NULL
                    && is_subclass_of($target, 'TYPO3\\CMS\\Extbase\\DomainObject\\AbstractEntity')
                    && is_subclass_of($target, 'TYPO3\\CMS\\Extbase\\DomainObject\\AbstractValueObject')
                ) {
                    $this->mappingResults->addError(new \TYPO3\CMS\Extbase\Error\Error("Property '{$propertyName}' does not exist in target class schema.", 1251813614), $propertyName);
                }
                if (is_array($target)) {
                    $target[$propertyName] = $propertyValue;
                } elseif (\TYPO3\CMS\Extbase\Reflection\ObjectAccess::setProperty($target, $propertyName, $propertyValue) === FALSE) {
                    $this->mappingResults->addError(new \TYPO3\CMS\Extbase\Error\Error("Property '{$propertyName}' could not be set.", 1236783102), $propertyName);
                }
            }
        }
        return !$this->mappingResults->hasErrors();
    }

    protected function transformToObject($propertyValue, $targetType, $propertyName) {
        if ($targetType === 'DateTime' || is_subclass_of($targetType, 'DateTime')) {
            if ($propertyValue === '') {
                $propertyValue = NULL;
            } else {
                try {
                    $propertyValue = $this->objectManager->get($targetType, $propertyValue);
                } catch (\Exception $e) {
                    $propertyValue = NULL;
                }
            }
        } else {
            if (ctype_digit((string)$propertyValue)) {
                $propertyValue = $this->findObjectByUid($targetType, $propertyValue);
                if ($propertyValue === FALSE) {
                    $this->mappingResults->addError(new \TYPO3\CMS\Extbase\Error\Error('Querying the repository for the specified object with UUID ' . $propertyValue . ' was not successful.', 1249379517), $propertyName);
                }
            } elseif (is_array($propertyValue)) {
                if (isset($propertyValue['__identity'])) {
                    $existingObject = $this->findObjectByUid($targetType, $propertyValue['__identity']);
                    if ($existingObject === FALSE) {
                        throw new \TYPO3\CMS\Extbase\Property\Exception\InvalidTargetException('Querying the repository for the specified object was not successful.', 1237305720);
                    }
                    unset($propertyValue['__identity']);
                    if (count($propertyValue) === 0) {
                        $propertyValue = $existingObject;
                    } elseif ($existingObject !== NULL) {
                        $newObject = clone $existingObject;
                        if ($this->map(array_keys($propertyValue), $propertyValue, $newObject)) {
                            $propertyValue = $newObject;
                        } else {
                            $propertyValue = NULL;
                        }
                    }
                } else {
                    $newObject = $this->objectManager->get($targetType);
                    if ($this->map(array_keys($propertyValue), $propertyValue, $newObject)) {
                        $propertyValue = $newObject;
                    } else {
                        $propertyValue = NULL;
                    }
                }
            } else {
                throw new \InvalidArgumentException('transformToObject() accepts only numeric values and arrays.', 1251814355);
            }
        }
        return $propertyValue;
    }

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

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