PHP ReflectionService::getClassSchema方法代码示例

 /**
  * Builds a data map by adding column maps for all the configured columns in the $TCA.
  * It also resolves the type of values the column is holding and the typo of relation the column
  * represents.
  *
  * @param string $className The class name you want to fetch the Data Map for
  * @throws \TYPO3\CMS\Extbase\Persistence\Generic\Exception\InvalidClassException
  * @return \TYPO3\CMS\Extbase\Persistence\Generic\Mapper\DataMap The data map
  */
 protected function buildDataMapInternal($className)
 {
     if (!class_exists($className)) {
         throw new \TYPO3\CMS\Extbase\Persistence\Generic\Exception\InvalidClassException('Could not find class definition for name "' . $className . '". This could be caused by a mis-spelling of the class name in the class definition.', 1476045117);
     }
     $recordType = null;
     $subclasses = [];
     $tableName = $this->resolveTableName($className);
     $columnMapping = [];
     $frameworkConfiguration = $this->configurationManager->getConfiguration(\TYPO3\CMS\Extbase\Configuration\ConfigurationManagerInterface::CONFIGURATION_TYPE_FRAMEWORK);
     $classSettings = $frameworkConfiguration['persistence']['classes'][$className];
     if ($classSettings !== null) {
         if (isset($classSettings['subclasses']) && is_array($classSettings['subclasses'])) {
             $subclasses = $this->resolveSubclassesRecursive($frameworkConfiguration['persistence']['classes'], $classSettings['subclasses']);
         }
         if (isset($classSettings['mapping']['recordType']) && $classSettings['mapping']['recordType'] !== '') {
             $recordType = $classSettings['mapping']['recordType'];
         }
         if (isset($classSettings['mapping']['tableName']) && $classSettings['mapping']['tableName'] !== '') {
             $tableName = $classSettings['mapping']['tableName'];
         }
         $classHierarchy = array_merge([$className], class_parents($className));
         foreach ($classHierarchy as $currentClassName) {
             if (in_array($currentClassName, [\TYPO3\CMS\Extbase\DomainObject\AbstractEntity::class, \TYPO3\CMS\Extbase\DomainObject\AbstractValueObject::class])) {
                 break;
             }
             $currentClassSettings = $frameworkConfiguration['persistence']['classes'][$currentClassName];
             if ($currentClassSettings !== null) {
                 if (isset($currentClassSettings['mapping']['columns']) && is_array($currentClassSettings['mapping']['columns'])) {
                     \TYPO3\CMS\Core\Utility\ArrayUtility::mergeRecursiveWithOverrule($columnMapping, $currentClassSettings['mapping']['columns'], true, false);
                 }
             }
         }
     }
     /** @var $dataMap \TYPO3\CMS\Extbase\Persistence\Generic\Mapper\DataMap */
     $dataMap = $this->objectManager->get(\TYPO3\CMS\Extbase\Persistence\Generic\Mapper\DataMap::class, $className, $tableName, $recordType, $subclasses);
     $dataMap = $this->addMetaDataColumnNames($dataMap, $tableName);
     // $classPropertyNames = $this->reflectionService->getClassPropertyNames($className);
     $tcaColumnsDefinition = $this->getColumnsDefinition($tableName);
     \TYPO3\CMS\Core\Utility\ArrayUtility::mergeRecursiveWithOverrule($tcaColumnsDefinition, $columnMapping);
     // @todo Is this is too powerful?
     foreach ($tcaColumnsDefinition as $columnName => $columnDefinition) {
         if (isset($columnDefinition['mapOnProperty'])) {
             $propertyName = $columnDefinition['mapOnProperty'];
         } else {
             $propertyName = \TYPO3\CMS\Core\Utility\GeneralUtility::underscoredToLowerCamelCase($columnName);
         }
         // if (in_array($propertyName, $classPropertyNames)) {
         // @todo Enable check for property existence
         $columnMap = $this->createColumnMap($columnName, $propertyName);
         $propertyMetaData = $this->reflectionService->getClassSchema($className)->getProperty($propertyName);
         $columnMap = $this->setType($columnMap, $columnDefinition['config']);
         $columnMap = $this->setRelations($columnMap, $columnDefinition['config'], $propertyMetaData);
         $columnMap = $this->setFieldEvaluations($columnMap, $columnDefinition['config']);
         $dataMap->addColumnMap($columnMap);
     }
     return $dataMap;
 }

 /**
  * Returns the type of a child object.
  *
  * @param string $parentClassName The class name of the object this proxy is part of
  * @param string $propertyName The name of the proxied property in it's parent
  * @throws UnexpectedTypeException
  * @return string The class name of the child object
  */
 public function getType($parentClassName, $propertyName)
 {
     $propertyMetaData = $this->reflectionService->getClassSchema($parentClassName)->getProperty($propertyName);
     if (!empty($propertyMetaData['elementType'])) {
         $type = $propertyMetaData['elementType'];
     } elseif (!empty($propertyMetaData['type'])) {
         $type = $propertyMetaData['type'];
     } else {
         throw new UnexpectedTypeException('Could not determine the child object type.', 1251315967);
     }
     return $type;
 }

 /**
  * Remove related objects
  *
  * @param \TYPO3\CMS\Extbase\DomainObject\DomainObjectInterface $object The object to scanned for related objects
  * @return void
  */
 protected function removeRelatedObjects(\TYPO3\CMS\Extbase\DomainObject\DomainObjectInterface $object)
 {
     $className = get_class($object);
     $dataMap = $this->dataMapper->getDataMap($className);
     $classSchema = $this->reflectionService->getClassSchema($className);
     $properties = $object->_getProperties();
     foreach ($properties as $propertyName => $propertyValue) {
         $columnMap = $dataMap->getColumnMap($propertyName);
         $propertyMetaData = $classSchema->getProperty($propertyName);
         if ($propertyMetaData['cascade'] === 'remove') {
             if ($columnMap->getTypeOfRelation() === \TYPO3\CMS\Extbase\Persistence\Generic\Mapper\ColumnMap::RELATION_HAS_MANY) {
                 foreach ($propertyValue as $containedObject) {
                     $this->removeEntity($containedObject);
                 }
             } elseif ($propertyValue instanceof \TYPO3\CMS\Extbase\DomainObject\DomainObjectInterface) {
                 $this->removeEntity($propertyValue);
             }
         }
     }
 }

 /**
  * Loads the model with the given identifier
  *
  * @param mixed		$identifier The identifier
  * @param string	$path		The path
  * @return mixed|null|object
  */
 protected function getModelWithIdentityForPath($identifier, $path)
 {
     $repository = $this->getRepositoryForPath($path);
     // Tries to fetch the object by UID
     $object = $repository->findByUid($identifier);
     if ($object) {
         return $object;
     }
     // Fetch the first identity property and search the repository for it
     $type = NULL;
     $property = NULL;
     try {
         $classSchema = $this->reflectionService->getClassSchema($this->getModelClassForPath($path));
         $identityProperties = $classSchema->getIdentityProperties();
         $type = reset($identityProperties);
         $property = key($identityProperties);
     } catch (\Exception $exception) {
     }
     switch ($type) {
         case 'string':
             $typeMatching = is_string($identifier);
             break;
         case 'boolean':
             $typeMatching = is_bool($identifier);
             break;
         case 'integer':
             $typeMatching = is_int($identifier);
             break;
         case 'float':
             $typeMatching = is_float($identifier);
             break;
         case 'array':
         default:
             $typeMatching = FALSE;
     }
     if ($typeMatching) {
         $findMethod = 'findOneBy' . ucfirst($property);
         return call_user_func(array($repository, $findMethod), $identifier);
     }
     return NULL;
 }

 /**
  * Sets the data type of this argument's value
  *
  * @param string $dataType The data type. Can be either a built-in type such as "Text" or "Integer" or a fully qualified object name
  * @return \TYPO3\CMS\Extbase\Mvc\Controller\Argument $this
  * @api
  */
 public function setDataType($dataType)
 {
     $this->dataType = $dataType;
     $this->dataTypeClassSchema = $this->reflectionService->getClassSchema($dataType);
     return $this;
 }

 /**
  * Maps the given properties to the target object WITHOUT VALIDATING THE RESULT.
  * If the properties could be set, this method returns TRUE, otherwise FALSE.
  * Returning TRUE does not mean that the target object is valid and secure!
  *
  * Only use this method if you're sure that you don't need validation!
  *
  * @param array $propertyNames Names of the properties to map.
  * @param mixed $source Source containing the properties to map to the target object. Must either be an array, ArrayObject or any other object.
  * @param object|array|string $target The target object
  * @param array $optionalPropertyNames Names of optional properties. If a property is specified here and it doesn't exist in the source, no error is issued.
  * @throws Exception\InvalidSourceException
  * @throws Exception\InvalidTargetException
  * @return boolean TRUE if the properties could be mapped, otherwise FALSE, or the object in case it could be resolved
  * @see mapAndValidate()
  * @api
  */
 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();
 }