/**
* The type of a property is determined by the reflection service.
*
* @param string $targetType
* @param string $propertyName
* @param PropertyMappingConfigurationInterface $configuration
* @return string
* @throws InvalidTargetException
*/
public function getTypeOfChildProperty($targetType, $propertyName, PropertyMappingConfigurationInterface $configuration)
{
$configuredTargetType = $configuration->getConfigurationFor($propertyName)->getConfigurationValue(ObjectConverter::class, self::CONFIGURATION_TARGET_TYPE);
if ($configuredTargetType !== null) {
return $configuredTargetType;
}
$methodParameters = $this->reflectionService->getMethodParameters($targetType, '__construct');
if (isset($methodParameters[$propertyName]) && isset($methodParameters[$propertyName]['type'])) {
return $methodParameters[$propertyName]['type'];
} elseif ($this->reflectionService->hasMethod($targetType, ObjectAccess::buildSetterMethodName($propertyName))) {
$methodParameters = $this->reflectionService->getMethodParameters($targetType, ObjectAccess::buildSetterMethodName($propertyName));
$methodParameter = current($methodParameters);
if (!isset($methodParameter['type'])) {
throw new InvalidTargetException('Setter for property "' . $propertyName . '" had no type hint or documentation in target object of type "' . $targetType . '".', 1303379158);
} else {
return $methodParameter['type'];
}
} else {
$targetPropertyNames = $this->reflectionService->getClassPropertyNames($targetType);
if (in_array($propertyName, $targetPropertyNames)) {
$varTagValues = $this->reflectionService->getPropertyTagValues($targetType, $propertyName, 'var');
if (count($varTagValues) > 0) {
// This ensures that FQCNs are returned without leading backslashes. Otherwise, something like @var \DateTime
// would not find a property mapper. It is needed because the ObjectConverter doesn't use class schemata,
// but reads the annotations directly.
$declaredType = strtok(trim(current($varTagValues), " \n\t"), " \n\t");
try {
$parsedType = TypeHandling::parseType($declaredType);
} catch (InvalidTypeException $exception) {
throw new \InvalidArgumentException(sprintf($exception->getMessage(), 'class "' . $targetType . '" for property "' . $propertyName . '"'), 1467699674);
}
return $parsedType['type'] . ($parsedType['elementType'] !== null ? '<' . $parsedType['elementType'] . '>' : '');
} else {
throw new InvalidTargetException(sprintf('Public property "%s" had no proper type annotation (i.e. "@var") in target object of type "%s".', $propertyName, $targetType), 1406821818);
}
}
}
throw new InvalidTargetException(sprintf('Property "%s" has neither a setter or constructor argument, nor is public, in target object of type "%s".', $propertyName, $targetType), 1303379126);
}
/**
* Return the type of a given sub-property inside the $targetType
*
* @param string $targetType
* @param string $propertyName
* @param PropertyMappingConfigurationInterface $configuration
* @return string
* @api
*/
public function getTypeOfChildProperty($targetType, $propertyName, PropertyMappingConfigurationInterface $configuration)
{
$parsedTargetType = TypeHandling::parseType($targetType);
return $parsedTargetType['elementType'];
}
/**
* Builds a base validator conjunction for the given data type.
*
* The base validation rules are those which were declared directly in a class (typically
* a model) through some validate annotations on properties.
*
* If a property holds a class for which a base validator exists, that property will be
* checked as well, regardless of a validate annotation
*
* Additionally, if a custom validator was defined for the class in question, it will be added
* to the end of the conjunction. A custom validator is found if it follows the naming convention
* "Replace '\Model\' by '\Validator\' and append 'Validator'".
*
* Example: $targetClassName is Neos\Foo\Domain\Model\Quux, then the validator will be found if it has the
* name Neos\Foo\Domain\Validator\QuuxValidator
*
* @param string $indexKey The key to use as index in $this->baseValidatorConjunctions; calculated from target class name and validation groups
* @param string $targetClassName The data type to build the validation conjunction for. Needs to be the fully qualified class name.
* @param array $validationGroups The validation groups to build the validator for
* @return void
* @throws Exception\NoSuchValidatorException
* @throws \InvalidArgumentException
*/
protected function buildBaseValidatorConjunction($indexKey, $targetClassName, array $validationGroups)
{
$conjunctionValidator = new ConjunctionValidator();
$this->baseValidatorConjunctions[$indexKey] = $conjunctionValidator;
if (!TypeHandling::isSimpleType($targetClassName) && class_exists($targetClassName)) {
// Model based validator
$classSchema = $this->reflectionService->getClassSchema($targetClassName);
if ($classSchema !== null && $classSchema->isAggregateRoot()) {
$objectValidator = new AggregateBoundaryValidator(array());
} else {
$objectValidator = new GenericObjectValidator([]);
}
$conjunctionValidator->addValidator($objectValidator);
foreach ($this->reflectionService->getClassPropertyNames($targetClassName) as $classPropertyName) {
$classPropertyTagsValues = $this->reflectionService->getPropertyTagsValues($targetClassName, $classPropertyName);
if (!isset($classPropertyTagsValues['var'])) {
throw new \InvalidArgumentException(sprintf('There is no @var annotation for property "%s" in class "%s".', $classPropertyName, $targetClassName), 1363778104);
}
try {
$parsedType = TypeHandling::parseType(trim(implode('', $classPropertyTagsValues['var']), ' \\'));
} catch (InvalidTypeException $exception) {
throw new \InvalidArgumentException(sprintf(' @var annotation of ' . $exception->getMessage(), 'class "' . $targetClassName . '", property "' . $classPropertyName . '"'), 1315564744, $exception);
}
if ($this->reflectionService->isPropertyAnnotatedWith($targetClassName, $classPropertyName, Flow\IgnoreValidation::class)) {
continue;
}
$propertyTargetClassName = $parsedType['type'];
if (TypeHandling::isCollectionType($propertyTargetClassName) === true) {
$collectionValidator = $this->createValidator(Validator\CollectionValidator::class, ['elementType' => $parsedType['elementType'], 'validationGroups' => $validationGroups]);
$objectValidator->addPropertyValidator($classPropertyName, $collectionValidator);
} elseif (!TypeHandling::isSimpleType($propertyTargetClassName) && $this->objectManager->isRegistered($propertyTargetClassName) && $this->objectManager->getScope($propertyTargetClassName) === Configuration::SCOPE_PROTOTYPE) {
$validatorForProperty = $this->getBaseValidatorConjunction($propertyTargetClassName, $validationGroups);
if (count($validatorForProperty) > 0) {
$objectValidator->addPropertyValidator($classPropertyName, $validatorForProperty);
}
}
$validateAnnotations = $this->reflectionService->getPropertyAnnotations($targetClassName, $classPropertyName, Flow\Validate::class);
foreach ($validateAnnotations as $validateAnnotation) {
if (count(array_intersect($validateAnnotation->validationGroups, $validationGroups)) === 0) {
// In this case, the validation groups for the property do not match current validation context
continue;
}
$newValidator = $this->createValidator($validateAnnotation->type, $validateAnnotation->options);
if ($newValidator === null) {
throw new Exception\NoSuchValidatorException('Invalid validate annotation in ' . $targetClassName . '::' . $classPropertyName . ': Could not resolve class name for validator "' . $validateAnnotation->type . '".', 1241098027);
}
$objectValidator->addPropertyValidator($classPropertyName, $newValidator);
}
}
if (count($objectValidator->getPropertyValidators()) === 0) {
$conjunctionValidator->removeValidator($objectValidator);
}
}
$this->addCustomValidators($targetClassName, $conjunctionValidator);
}
/**
* Adds (defines) a specific property and its type.
*
* @param string $name Name of the property
* @param string $type Type of the property
* @param boolean $lazy Whether the property should be lazy-loaded when reconstituting
* @param boolean $transient Whether the property should not be considered for persistence
* @return void
* @throws \InvalidArgumentException
*/
public function addProperty($name, $type, $lazy = false, $transient = false)
{
try {
$type = TypeHandling::parseType($type);
} catch (InvalidTypeException $exception) {
throw new \InvalidArgumentException(sprintf($exception->getMessage(), 'class "' . $name . '"'), 1315564474);
}
$this->properties[$name] = ['type' => $type['type'], 'elementType' => $type['elementType'], 'lazy' => $lazy, 'transient' => $transient];
}
/**
* @test
* @dataProvider types
*/
public function parseTypeReturnsArrayWithInformation($type, $expectedResult)
{
$this->assertEquals($expectedResult, TypeHandling::parseType($type), 'Failed for ' . $type);
}
/**
* @param ClassSchema $classSchema
* @param string $propertyName
* @return boolean
* @throws InvalidPropertyTypeException
* @throws \InvalidArgumentException
*/
protected function evaluateClassPropertyAnnotationsForSchema(ClassSchema $classSchema, $propertyName)
{
$skipArtificialIdentity = false;
$className = $classSchema->getClassName();
if ($this->isPropertyAnnotatedWith($className, $propertyName, Flow\Transient::class)) {
return false;
}
if ($this->isPropertyAnnotatedWith($className, $propertyName, Flow\Inject::class)) {
return false;
}
if (!$this->isPropertyTaggedWith($className, $propertyName, 'var')) {
return false;
}
$varTagValues = $this->getPropertyTagValues($className, $propertyName, 'var');
if (count($varTagValues) > 1) {
throw new InvalidPropertyTypeException('More than one @var annotation given for "' . $className . '::$' . $propertyName . '"', 1367334366);
}
$declaredType = strtok(trim(current($varTagValues), " \n\t"), " \n\t");
try {
TypeHandling::parseType($declaredType);
} catch (InvalidTypeException $exception) {
throw new \InvalidArgumentException(sprintf($exception->getMessage(), 'class "' . $className . '" for property "' . $propertyName . '"'), 1315564475);
}
if ($this->isPropertyAnnotatedWith($className, $propertyName, ORM\Id::class)) {
$skipArtificialIdentity = true;
}
$classSchema->addProperty($propertyName, $declaredType, $this->isPropertyAnnotatedWith($className, $propertyName, Flow\Lazy::class), $this->isPropertyAnnotatedWith($className, $propertyName, Flow\Transient::class));
if ($this->isPropertyAnnotatedWith($className, $propertyName, Flow\Identity::class)) {
$classSchema->markAsIdentityProperty($propertyName);
}
return $skipArtificialIdentity;
}
/**
* Iterates through the given $properties setting them on the specified $node using the appropriate TypeConverters.
*
* @param object $nodeLike
* @param NodeType $nodeType
* @param array $properties
* @param TYPO3CRContext $context
* @param PropertyMappingConfigurationInterface $configuration
* @return void
* @throws TypeConverterException
*/
protected function setNodeProperties($nodeLike, NodeType $nodeType, array $properties, TYPO3CRContext $context, PropertyMappingConfigurationInterface $configuration = null)
{
$nodeTypeProperties = $nodeType->getProperties();
unset($properties['_lastPublicationDateTime']);
foreach ($properties as $nodePropertyName => $nodePropertyValue) {
if (substr($nodePropertyName, 0, 2) === '__') {
continue;
}
$nodePropertyType = isset($nodeTypeProperties[$nodePropertyName]['type']) ? $nodeTypeProperties[$nodePropertyName]['type'] : null;
switch ($nodePropertyType) {
case 'reference':
$nodePropertyValue = $context->getNodeByIdentifier($nodePropertyValue);
break;
case 'references':
$nodeIdentifiers = json_decode($nodePropertyValue);
$nodePropertyValue = array();
if (is_array($nodeIdentifiers)) {
foreach ($nodeIdentifiers as $nodeIdentifier) {
$referencedNode = $context->getNodeByIdentifier($nodeIdentifier);
if ($referencedNode !== null) {
$nodePropertyValue[] = $referencedNode;
}
}
} elseif ($nodeIdentifiers !== null) {
throw new TypeConverterException(sprintf('node type "%s" expects an array of identifiers for its property "%s"', $nodeType->getName(), $nodePropertyName), 1383587419);
}
break;
case 'DateTime':
if ($nodePropertyValue !== '' && ($nodePropertyValue = \DateTime::createFromFormat(\DateTime::W3C, $nodePropertyValue)) !== false) {
$nodePropertyValue->setTimezone(new \DateTimeZone(date_default_timezone_get()));
} else {
$nodePropertyValue = null;
}
break;
case 'integer':
$nodePropertyValue = intval($nodePropertyValue);
break;
case 'boolean':
if (is_string($nodePropertyValue)) {
$nodePropertyValue = $nodePropertyValue === 'true' ? true : false;
}
break;
case 'array':
$nodePropertyValue = json_decode($nodePropertyValue, true);
break;
}
if (substr($nodePropertyName, 0, 1) === '_') {
$nodePropertyName = substr($nodePropertyName, 1);
ObjectAccess::setProperty($nodeLike, $nodePropertyName, $nodePropertyValue);
continue;
}
if (!isset($nodeTypeProperties[$nodePropertyName])) {
if ($configuration !== null && $configuration->shouldSkipUnknownProperties()) {
continue;
} else {
throw new TypeConverterException(sprintf('Node type "%s" does not have a property "%s" according to the schema', $nodeType->getName(), $nodePropertyName), 1359552744);
}
}
$innerType = $nodePropertyType;
if ($nodePropertyType !== null) {
try {
$parsedType = TypeHandling::parseType($nodePropertyType);
$innerType = $parsedType['elementType'] ?: $parsedType['type'];
} catch (InvalidTypeException $exception) {
}
}
if (is_string($nodePropertyValue) && $this->objectManager->isRegistered($innerType) && $nodePropertyValue !== '') {
$nodePropertyValue = $this->propertyMapper->convert(json_decode($nodePropertyValue, true), $nodePropertyType, $configuration);
}
$nodeLike->setProperty($nodePropertyName, $nodePropertyValue);
}
}
/**
* Create a property mapping configuration for the given dataType to convert a Node property value from the given dataType to a simple type.
*
* @param string $dataType
* @return PropertyMappingConfigurationInterface
*/
protected function createConfiguration($dataType)
{
if (!isset($this->generatedPropertyMappingConfigurations[$dataType])) {
$propertyMappingConfiguration = new PropertyMappingConfiguration();
$propertyMappingConfiguration->allowAllProperties();
$parsedType = ['elementType' => null, 'type' => $dataType];
// Special handling for "reference(s)", should be deprecated and normlized to array<NodeInterface>
if ($dataType !== 'references' && $dataType !== 'reference') {
$parsedType = TypeHandling::parseType($dataType);
}
if ($this->setTypeConverterForType($propertyMappingConfiguration, $dataType) === false) {
$this->setTypeConverterForType($propertyMappingConfiguration, $parsedType['type']);
}
$elementConfiguration = $propertyMappingConfiguration->forProperty('*');
$this->setTypeConverterForType($elementConfiguration, $parsedType['elementType']);
$this->generatedPropertyMappingConfigurations[$dataType] = $propertyMappingConfiguration;
}
return $this->generatedPropertyMappingConfigurations[$dataType];
}
