/**
*/
public function setUp()
{
ComposerUtility::flushCaches();
vfsStream::setup('Packages');
$this->mockPackageManager = $this->getMockBuilder(\Neos\Flow\Package\PackageManager::class)->disableOriginalConstructor()->getMock();
ObjectAccess::setProperty($this->mockPackageManager, 'composerManifestData', array(), true);
}
/**
* @test
*/
public function ignoredClassesCanBeOverwrittenBySettings()
{
$object = new ApplicationContext('Development');
$this->assertEquals(sprintf('%s prototype object', ApplicationContext::class), Debugger::renderDump($object, 10, true));
Debugger::clearState();
$currentConfiguration = ObjectAccess::getProperty($this->configurationManager, 'configurations', true);
$configurationOverwrite['Settings']['Neos']['Flow']['error']['debugger']['ignoredClasses']['Neos\\\\Flow\\\\Core\\\\.*'] = false;
$newConfiguration = Arrays::arrayMergeRecursiveOverrule($currentConfiguration, $configurationOverwrite);
ObjectAccess::setProperty($this->configurationManager, 'configurations', $newConfiguration, true);
$this->assertContains('rootContextString', Debugger::renderDump($object, 10, true));
}
/**
* Builds a transformation object from the given configuration.
*
* @param array $transformationConfiguration
* @return TransformationInterface
* @throws MigrationException if a given setting is not supported
*/
protected function buildTransformationObject($transformationConfiguration)
{
$transformationClassName = $this->resolveTransformationClassName($transformationConfiguration['type']);
$transformation = new $transformationClassName();
foreach ($transformationConfiguration['settings'] as $settingName => $settingValue) {
if (!ObjectAccess::setProperty($transformation, $settingName, $settingValue)) {
throw new MigrationException('Cannot set setting "' . $settingName . '" on transformation "' . $transformationClassName . '" , check your configuration.', 1343293094);
}
}
return $transformation;
}
/**
* WARNING: If using this step definition, IT MUST RUN AS ABSOLUTELY FIRST STEP IN A SCENARIO!
*
* @Given /^I have the following policies:$/
*/
public function iHaveTheFollowingPolicies($string)
{
if ($this->subProcess !== null) {
// This check ensures that this statement is ran *before* a subprocess is opened; as the Policy.yaml
// which is set here influences the Proxy Building Process.
throw new \Exception('Step "I have the following policies:" must run as FIRST step in a scenario, because otherwise the proxy-classes are already built in the wrong manner!');
}
self::$testingPolicyPathAndFilename = $this->environment->getPathToTemporaryDirectory() . 'Policy.yaml';
file_put_contents(self::$testingPolicyPathAndFilename, $string->getRaw());
$configurationManager = $this->objectManager->get(ConfigurationManager::class);
$configurations = ObjectAccess::getProperty($configurationManager, 'configurations', true);
unset($configurations[ConfigurationManager::CONFIGURATION_PROCESSING_TYPE_POLICY]);
ObjectAccess::setProperty($configurationManager, 'configurations', $configurations, true);
$policyService = $this->objectManager->get(PolicyService::class);
ObjectAccess::setProperty($policyService, 'initialized', false, true);
}
/**
* @test
* @dataProvider attributeExamples
*/
public function evaluateTests($properties, $expectedOutput)
{
$path = 'attributes/test';
$this->mockTsRuntime->expects($this->any())->method('evaluate')->will($this->returnCallback(function ($evaluatePath, $that) use($path, $properties) {
$relativePath = str_replace($path . '/', '', $evaluatePath);
return ObjectAccess::getPropertyPath($properties, str_replace('/', '.', $relativePath));
}));
$typoScriptObjectName = 'Neos.Fusion:Attributes';
$renderer = new AttributesImplementation($this->mockTsRuntime, $path, $typoScriptObjectName);
if ($properties !== null) {
foreach ($properties as $name => $value) {
ObjectAccess::setProperty($renderer, $name, $value);
}
}
$result = $renderer->evaluate();
$this->assertEquals($expectedOutput, $result);
}
/**
* @param string $dataSourceIdentifier
* @param NodeInterface $node
* @return string
* @throws NeosException
*/
public function indexAction($dataSourceIdentifier, NodeInterface $node = null)
{
$dataSources = static::getDataSources($this->objectManager);
if (!isset($dataSources[$dataSourceIdentifier])) {
throw new NeosException(sprintf('Data source with identifier "%s" does not exist.', $dataSourceIdentifier), 1414088186);
}
/** @var $dataSource DataSourceInterface */
$dataSource = new $dataSources[$dataSourceIdentifier]();
if (ObjectAccess::isPropertySettable($dataSource, 'controllerContext')) {
ObjectAccess::setProperty($dataSource, 'controllerContext', $this->controllerContext);
}
$arguments = $this->request->getArguments();
unset($arguments['dataSourceIdentifier']);
unset($arguments['node']);
$values = $dataSource->getData($node, $arguments);
$this->view->assign('value', $values);
}
/**
* Factory method which creates the specified transport with the given options.
*
* @param string $transportType Object name of the transport to create
* @param array $transportOptions Options for the transport
* @param array $transportArguments Constructor arguments for the transport
* @return \Neos\SwiftMailer\TransportInterface The created transport instance
* @throws Exception
*/
public function create($transportType, array $transportOptions = array(), array $transportArguments = null)
{
if (!class_exists($transportType)) {
throw new Exception('The specified transport backend "' . $transportType . '" does not exist.', 1269351207);
}
if (is_array($transportArguments)) {
$class = new \ReflectionClass($transportType);
$transport = $class->newInstanceArgs($transportArguments);
} else {
$transport = new $transportType();
}
foreach ($transportOptions as $optionName => $optionValue) {
if (ObjectAccess::isPropertySettable($transport, $optionName)) {
ObjectAccess::setProperty($transport, $optionName, $optionValue);
}
}
return $transport;
}
/**
* @param PaletteInterface $proxy
* @param $profilePath
* @return \Imagine\Image\Profile
*/
protected function createAndSetProfileOnProxy(PaletteInterface $proxy, $profilePath)
{
if (substr($profilePath, 0, 11) !== 'resource://') {
$profilePath = $this->packageManager->getPackage('imagine.imagine')->getPackagePath() . 'lib/Imagine/resources/' . $profilePath;
}
$profile = Profile::fromPath($profilePath);
ObjectAccess::setProperty($proxy, 'profile', $profile, TRUE);
return $profile;
}
/**
* @test
*/
public function collectionValidatorIsValidEarlyReturnsOnUnitializedDoctrinePersistenceCollections()
{
$entityManager = $this->getMockBuilder(\Doctrine\ORM\EntityManager::class)->disableOriginalConstructor()->getMock();
$persistentCollection = new \Doctrine\ORM\PersistentCollection($entityManager, new \Doctrine\ORM\Mapping\ClassMetadata(''), new \Doctrine\Common\Collections\ArrayCollection());
ObjectAccess::setProperty($persistentCollection, 'initialized', false, true);
$this->mockValidatorResolver->expects($this->never())->method('createValidator');
$this->validator->validate($persistentCollection);
}
/**
* 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);
}
}
/**
* This serves a rather strange use case: renaming columns used in FK constraints.
*
* For a column that is used in a FK constraint to be renamed, the FK constraint has to be
* dropped first, then the column can be renamed and last the FK constraint needs to be
* added back (using the new name, of course).
*
* This method helps with the task of handling the FK constraints during this. Given a list
* of tables that contain columns to be renamed and a search/replace pair for the column name,
* it will return an array with arrays with drop and add SQL statements.
*
* Use them like this before and after renaming the affected fields:
*
* // collect foreign keys pointing to "our" tables
* $tableNames = array(...);
* $foreignKeyHandlingSql = $this->getForeignKeyHandlingSql($schema, $tableNames, 'old_name', 'new_name');
*
* // drop FK constraints
* foreach ($foreignKeyHandlingSql['drop'] as $sql) {
* $this->addSql($sql);
* }
*
* // rename columns now
*
* // add back FK constraints
* foreach ($foreignKeyHandlingSql['add'] as $sql) {
* $this->addSql($sql);
* }
*
* @param Schema $schema
* @param AbstractPlatform $platform
* @param array $tableNames
* @param string $search
* @param string $replace
* @return array
*/
public static function getForeignKeyHandlingSql(Schema $schema, AbstractPlatform $platform, $tableNames, $search, $replace)
{
$foreignKeyHandlingSql = ['drop' => [], 'add' => []];
$tables = $schema->getTables();
foreach ($tables as $table) {
$foreignKeys = $table->getForeignKeys();
foreach ($foreignKeys as $foreignKey) {
if (!in_array($table->getName(), $tableNames) && !in_array($foreignKey->getForeignTableName(), $tableNames)) {
continue;
}
$localColumns = $foreignKey->getLocalColumns();
$foreignColumns = $foreignKey->getForeignColumns();
if (in_array($search, $foreignColumns) || in_array($search, $localColumns)) {
if (in_array($foreignKey->getLocalTableName(), $tableNames)) {
array_walk($localColumns, function (&$value) use($search, $replace) {
if ($value === $search) {
$value = $replace;
}
});
}
if (in_array($foreignKey->getForeignTableName(), $tableNames)) {
array_walk($foreignColumns, function (&$value) use($search, $replace) {
if ($value === $search) {
$value = $replace;
}
});
}
$identifierConstructorCallback = function ($columnName) {
return new Identifier($columnName);
};
$localColumns = array_map($identifierConstructorCallback, $localColumns);
$foreignColumns = array_map($identifierConstructorCallback, $foreignColumns);
$newForeignKey = clone $foreignKey;
ObjectAccess::setProperty($newForeignKey, '_localColumnNames', $localColumns, true);
ObjectAccess::setProperty($newForeignKey, '_foreignColumnNames', $foreignColumns, true);
$foreignKeyHandlingSql['drop'][] = $platform->getDropForeignKeySQL($foreignKey, $table);
$foreignKeyHandlingSql['add'][] = $platform->getCreateForeignKeySQL($newForeignKey, $table);
}
}
}
return $foreignKeyHandlingSql;
}
/**
* Set the given $identity on the created $object.
*
* @param object $object
* @param string|array $identity
* @return void
* @todo set identity properly if it is composite or custom property
*/
protected function setIdentity($object, $identity)
{
ObjectAccess::setProperty($object, 'Persistence_Object_Identifier', $identity, true);
}
/**
* Set options on the given (AbstractArray)TypoScript object
*
* @param AbstractArrayTypoScriptObject $typoScriptObject
* @param array $typoScriptConfiguration
* @return void
*/
protected function setPropertiesOnTypoScriptObject(AbstractArrayTypoScriptObject $typoScriptObject, array $typoScriptConfiguration)
{
foreach ($typoScriptConfiguration as $key => $value) {
// skip keys which start with __, as they are purely internal.
if ($key[0] === '_' && $key[1] === '_' && in_array($key, Parser::$reservedParseTreeKeys, true)) {
continue;
}
ObjectAccess::setProperty($typoScriptObject, $key, $value);
}
}
/**
* Set a specific option of this object
*
* @param string $optionName
* @param mixed $value
* @return void
*/
public function setOption($optionName, $value)
{
$this->options[$optionName] = $value;
if (ObjectAccess::isPropertySettable($this, $optionName)) {
ObjectAccess::setProperty($this, $optionName, $value);
}
}
/**
* @param array $elements
* @return FlowQuery
*/
protected function createFlowQuery(array $elements)
{
$flowQuery = $this->getAccessibleMock(FlowQuery::class, ['dummy'], [$elements]);
// Set up mock persistence manager to return dummy object identifiers
$this->mockPersistenceManager = $this->createMock(PersistenceManagerInterface::class);
$this->mockPersistenceManager->expects($this->any())->method('getIdentifierByObject')->will($this->returnCallback(function ($object) {
if (isset($object->__identity)) {
return $object->__identity;
}
}));
$mockPersistenceManager = $this->mockPersistenceManager;
$objectManager = $this->createMock(ObjectManagerInterface::class);
$objectManager->expects($this->any())->method('get')->will($this->returnCallback(function ($className) use($mockPersistenceManager) {
$instance = new $className();
// Special case to inject the mock persistence manager into the filter operation
if ($className === Operations\Object\FilterOperation::class) {
ObjectAccess::setProperty($instance, 'persistenceManager', $mockPersistenceManager, true);
}
return $instance;
}));
$operationResolver = $this->getAccessibleMock(OperationResolver::class, ['dummy']);
$operationResolver->_set('objectManager', $objectManager);
$operationResolver->_set('finalOperationNames', ['count' => 'count', 'get' => 'get', 'is' => 'is', 'property' => 'property']);
$operationResolver->_set('operations', ['count' => [300 => Operations\CountOperation::class], 'first' => [300 => Operations\FirstOperation::class], 'last' => [300 => Operations\LastOperation::class], 'slice' => [300 => Operations\SliceOperation::class], 'get' => [300 => Operations\GetOperation::class], 'is' => [300 => Operations\IsOperation::class], 'filter' => [300 => Operations\Object\FilterOperation::class], 'children' => [300 => Operations\Object\ChildrenOperation::class], 'property' => [300 => Operations\Object\PropertyOperation::class]]);
$flowQuery->_set('operationResolver', $operationResolver);
return $flowQuery;
}
/**
* @BeforeScenario @fixtures
*/
public function resetContextFactory()
{
/** @var ContextFactoryInterface $contextFactory */
$contextFactory = $this->objectManager->get(ContextFactoryInterface::class);
ObjectAccess::setProperty($contextFactory, 'contextInstances', array(), true);
}
/**
* After returning advice, generates the value hash for the object
*
* @param JoinPointInterface $joinPoint The current join point
* @return void
* @Flow\After("Neos\Flow\Persistence\Aspect\PersistenceMagicAspect->isNonEmbeddedValueObject && method(.*->__construct()) && filter(Neos\Flow\Persistence\Doctrine\Mapping\Driver\FlowAnnotationDriver)")
*/
public function generateValueHash(JoinPointInterface $joinPoint)
{
$proxy = $joinPoint->getProxy();
$proxyClassName = get_class($proxy);
$hashSourceParts = [];
$classSchema = $this->reflectionService->getClassSchema($proxyClassName);
foreach ($classSchema->getProperties() as $property => $propertySchema) {
// Currently, private properties are transient. Should this behaviour change, they need to be included
// in the value hash generation
if ($classSchema->isPropertyTransient($property) || $this->reflectionService->isPropertyPrivate($proxyClassName, $property)) {
continue;
}
$propertyValue = ObjectAccess::getProperty($proxy, $property, true);
if (is_object($propertyValue) === true) {
// The persistence manager will return NULL if the given object is unknown to persistence
$propertyValue = $this->persistenceManager->getIdentifierByObject($propertyValue) ?: $propertyValue;
}
$hashSourceParts[$property] = $propertyValue;
}
ksort($hashSourceParts);
$hashSourceParts['__class_name__'] = $proxyClassName;
$serializedSource = $this->useIgBinary === true ? igbinary_serialize($hashSourceParts) : serialize($hashSourceParts);
$proxy = $joinPoint->getProxy();
ObjectAccess::setProperty($proxy, 'Persistence_Object_Identifier', sha1($serializedSource), true);
}
/**
* @param ApplicationContext $context
* @return void
*/
protected function injectApplicationContextIntoConfigurationManager(ApplicationContext $context)
{
ObjectAccess::setProperty($this->mockConfigurationManager, 'configurations', [ConfigurationManager::CONFIGURATION_TYPE_SETTINGS => []], true);
ObjectAccess::setProperty($this->mockConfigurationManager, 'context', $context, true);
ObjectAccess::setProperty($this->mockConfigurationManager, 'orderedListOfContextNames', [(string) $context], true);
ObjectAccess::setProperty($this->mockConfigurationManager, 'includeCachedConfigurationsPathAndFilename', FLOW_PATH_CONFIGURATION . (string) $context . '/IncludeCachedConfigurations.php', true);
}
/**
* Converts and adds ImageAdjustments to the ImageVariant
*
* @param ImageInterface $asset
* @param mixed $source
* @param array $convertedChildProperties
* @param PropertyMappingConfigurationInterface $configuration
* @return ImageInterface|NULL
*/
protected function applyTypeSpecificHandling($asset, $source, array $convertedChildProperties, PropertyMappingConfigurationInterface $configuration)
{
if ($asset instanceof ImageVariant) {
$adjustments = [];
if (isset($source['adjustments'])) {
foreach ($source['adjustments'] as $adjustmentType => $adjustmentOptions) {
if (isset($adjustmentOptions['__type'])) {
$adjustmentType = $adjustmentOptions['__type'];
unset($adjustmentOptions['__type']);
}
$identity = null;
if (isset($adjustmentOptions['__identity'])) {
$identity = $adjustmentOptions['__identity'];
unset($adjustmentOptions['__identity']);
}
$adjustment = $this->propertyMapper->convert($adjustmentOptions, $adjustmentType, $configuration);
if ($identity !== null) {
ObjectAccess::setProperty($adjustment, 'persistence_object_identifier', $identity, true);
}
$adjustments[] = $adjustment;
}
} elseif (isset($source['processingInstructions'])) {
$adjustments = $this->processingInstructionsConverter->convertFrom($source['processingInstructions'], 'array');
}
if (count($adjustments) > 0) {
$asset->addAdjustments($adjustments);
}
}
return $asset;
}
/**
* This is an edge-case which occurs if somebody makes the formState persistent, which can happen when subclassing the FormRuntime.
*
* The goal is to build a GET request *only* containing the form state, and nothing else. Furthermore, we need to make sure
* that we do NOT send any of the parameters with the form; as we only want the form state to be applied.
*
* So, if the form state contains some values, we want to be sure these values are re-displayed.
*
* @test
*/
public function goingForthAndBackStoresFormValuesOfSecondPageEvenWhenSecondPageIsManuallyCalledAsGetRequest()
{
// 1. TEST SETUP: FORM STATE PREPARATION
// - go to the 2nd page of the form, and fill in text2-1.
$this->browser->request('http://localhost/test/form/simpleform/ThreePageFormWithValidation');
$this->gotoNextFormPage($this->browser->getForm());
$form = $this->browser->getForm();
$form['--three-page-form-with-validation']['text2-1']->setValue('My Text on the second page');
// - then, go back and forth, in order to get an *up-to-date* form state having the right values inside.
$this->gotoPreviousFormPage($form);
$this->gotoNextFormPage($this->browser->getForm());
// 2. TEST SETUP: BUILD GET REQUEST ONLY CONTAINING FORM STATE
$form = $this->browser->getForm();
\Neos\Utility\ObjectAccess::setProperty($form, 'method', 'GET', true);
// we want to stay on the current page, that's why we send __currentPage = 1. (== 2nd page of the form)
$doc = new \DOMDocument();
$doc->loadXML('<input type="hidden" name="--three-page-form-with-validation[__currentPage]" value="1" />');
$node = $doc->getElementsByTagName('input')->item(0);
$form->set(new InputFormField($node));
// We do *not* send any form content with us, as we want to test these are properly reconstituted from the form state.
$form->offsetUnset('--three-page-form-with-validation[text2-1]');
// 3. TEST RUN
// submit the GET request ONLY containing formState.
$this->browser->submit($form);
// now, make sure the text2-1 (which has been persisted in the form state) gets reconstituted and shown properly.
$form = $this->browser->getForm();
$this->assertSame('My Text on the second page', $form['--three-page-form-with-validation']['text2-1']->getValue());
}
/**
* @param array $commandOptions
* @param array $adjustmentOptions
* @param string $commandOptionPath
* @param string $adjustmentOptionName
* @return void
*/
protected function transferOptionFromCommandToAdjustment(array $commandOptions, array &$adjustmentOptions, $commandOptionPath, $adjustmentOptionName)
{
$commandOptionValue = ObjectAccess::getPropertyPath($commandOptions, $commandOptionPath);
if ($commandOptionValue !== null) {
ObjectAccess::setProperty($adjustmentOptions, $adjustmentOptionName, $commandOptionValue);
}
}
/**
* @test
*/
public function setPropertyCanDirectlySetValuesInAnArrayObjectOrArray()
{
$arrayObject = new \ArrayObject();
$array = array();
ObjectAccess::setProperty($arrayObject, 'publicProperty', 4242);
ObjectAccess::setProperty($array, 'key', 'value');
$this->assertEquals(4242, $arrayObject['publicProperty']);
$this->assertEquals('value', $array['key']);
}
/**
* Resets security test requirements
*
* @return void
*/
protected function tearDownSecurity()
{
if ($this->privilegeManager !== null) {
$this->privilegeManager->reset();
}
if ($this->policyService !== null) {
$this->policyService->reset();
}
if ($this->testingProvider !== null) {
$this->testingProvider->reset();
}
if ($this->securityContext !== null) {
$this->securityContext->clearContext();
}
if ($this->authenticationManager !== null) {
\Neos\Utility\ObjectAccess::setProperty($this->authenticationManager, 'isAuthenticated', null, true);
}
}
/**
* Make the node "similar" to the given source node. That means,
* - all properties
* - index
* - node type
* - content object
* will be set to the same values as in the source node.
*
* @param AbstractNodeData $sourceNode
* @param boolean $isCopy
* @return void
*/
public function similarize(AbstractNodeData $sourceNode, $isCopy = false)
{
$this->properties = [];
foreach ($sourceNode->getProperties() as $propertyName => $propertyValue) {
$this->setProperty($propertyName, $propertyValue);
}
$propertyNames = ['nodeType', 'hidden', 'hiddenAfterDateTime', 'hiddenBeforeDateTime', 'hiddenInIndex', 'accessRoles'];
if (!$isCopy) {
$propertyNames[] = 'creationDateTime';
$propertyNames[] = 'lastModificationDateTime';
}
if ($sourceNode instanceof NodeData) {
$propertyNames[] = 'index';
}
foreach ($propertyNames as $propertyName) {
ObjectAccess::setProperty($this, $propertyName, ObjectAccess::getProperty($sourceNode, $propertyName));
}
$contentObject = $sourceNode->getContentObject();
if ($contentObject !== null) {
$this->setContentObject($contentObject);
}
}
/**
* An onFlush event listener used to validate entities upon persistence.
*
* @param \Doctrine\ORM\Event\OnFlushEventArgs $eventArgs
* @return void
*/
public function onFlush(\Doctrine\ORM\Event\OnFlushEventArgs $eventArgs)
{
$unitOfWork = $this->entityManager->getUnitOfWork();
$entityInsertions = $unitOfWork->getScheduledEntityInsertions();
$validatedInstancesContainer = new \SplObjectStorage();
$knownValueObjects = [];
foreach ($entityInsertions as $entity) {
$className = TypeHandling::getTypeForValue($entity);
if ($this->reflectionService->getClassSchema($className)->getModelType() === ClassSchema::MODELTYPE_VALUEOBJECT) {
$identifier = $this->getIdentifierByObject($entity);
if (isset($knownValueObjects[$className][$identifier]) || $unitOfWork->getEntityPersister($className)->exists($entity)) {
unset($entityInsertions[spl_object_hash($entity)]);
continue;
}
$knownValueObjects[$className][$identifier] = true;
}
$this->validateObject($entity, $validatedInstancesContainer);
}
ObjectAccess::setProperty($unitOfWork, 'entityInsertions', $entityInsertions, true);
foreach ($unitOfWork->getScheduledEntityUpdates() as $entity) {
$this->validateObject($entity, $validatedInstancesContainer);
}
}
/**
* Imports the given content passed as a string as a new persistent resource.
*
* The given content typically is binary data or a text format. On a successful import this method
* returns a PersistentResource object representing the imported content and automatically publishes it to the
* configured publication target.
*
* The specified filename will be used when presenting the resource to a user. Its file extension is
* important because the resource management will derive the IANA Media Type from it.
*
* @param string $content The binary content to import
* @param string $filename The filename to use for the newly generated resource
* @param string $collectionName Name of the collection this new resource should be added to. By default the standard collection for persistent resources is used.
* @param string $forcedPersistenceObjectIdentifier INTERNAL: Force the object identifier for this resource to the given UUID
* @return PersistentResource A resource object representing the imported resource
* @throws Exception
* @api
*/
public function importResourceFromContent($content, $filename, $collectionName = ResourceManager::DEFAULT_PERSISTENT_COLLECTION_NAME, $forcedPersistenceObjectIdentifier = null)
{
if (!is_string($content)) {
throw new Exception(sprintf('Tried to import content into the resource collection "%s" but the given content was a %s instead of a string.', $collectionName, gettype($content)), 1380878115);
}
$this->initialize();
if (!isset($this->collections[$collectionName])) {
throw new Exception(sprintf('Tried to import a file into the resource collection "%s" but no such collection exists. Please check your settings and the code which triggered the import.', $collectionName), 1380878131);
}
/* @var CollectionInterface $collection */
$collection = $this->collections[$collectionName];
try {
$resource = $collection->importResourceFromContent($content);
$resource->setFilename($filename);
if ($forcedPersistenceObjectIdentifier !== null) {
ObjectAccess::setProperty($resource, 'Persistence_Object_Identifier', $forcedPersistenceObjectIdentifier, true);
}
} catch (Exception $exception) {
throw new Exception(sprintf('Importing content into the resource collection "%s" failed: %s', $collectionName, $exception->getMessage()), 1381156155, $exception);
}
$this->resourceRepository->add($resource);
$this->systemLogger->log(sprintf('Successfully imported content into the resource collection "%s" (storage: %s, a %s. SHA1: %s)', $collectionName, $collection->getStorage()->getName(), get_class($collection->getStorage()), $resource->getSha1()), LOG_DEBUG);
return $resource;
}
/**
* Sets the given properties on the object.
*
* @param object $object The object to set properties on
* @param string $identifier The identifier of the object
* @param array $objectData
* @return void
* @throws UnknownObjectException
*/
public function thawProperties($object, $identifier, array $objectData)
{
$classSchema = $this->reflectionService->getClassSchema($objectData['classname']);
foreach ($objectData['properties'] as $propertyName => $propertyData) {
if (!$classSchema->hasProperty($propertyName) || $classSchema->isPropertyTransient($propertyName)) {
continue;
}
$propertyValue = null;
if ($propertyData['value'] !== null) {
switch ($propertyData['type']) {
case 'integer':
$propertyValue = (int) $propertyData['value'];
break;
case 'float':
$propertyValue = (double) $propertyData['value'];
break;
case 'boolean':
$propertyValue = (bool) $propertyData['value'];
break;
case 'string':
$propertyValue = (string) $propertyData['value'];
break;
case 'array':
$propertyValue = $this->mapArray($propertyData['value']);
break;
case 'Doctrine\\Common\\Collections\\Collection':
case 'Doctrine\\Common\\Collections\\ArrayCollection':
$propertyValue = new ArrayCollection($this->mapArray($propertyData['value']));
break;
case 'SplObjectStorage':
$propertyValue = $this->mapSplObjectStorage($propertyData['value'], $classSchema->isPropertyLazy($propertyName));
break;
case 'DateTime':
$propertyValue = $this->mapDateTime($propertyData['value']);
break;
default:
if ($propertyData['value'] === false) {
throw new UnknownObjectException('An expected object was not found by the backend. It was expected for ' . $objectData['classname'] . '::' . $propertyName, 1289509867);
}
$propertyValue = $this->mapToObject($propertyData['value']);
break;
}
} else {
switch ($propertyData['type']) {
case 'NULL':
continue;
case 'array':
$propertyValue = $this->mapArray(null);
break;
case Collection::class:
case ArrayCollection::class:
$propertyValue = new ArrayCollection();
break;
case 'SplObjectStorage':
$propertyValue = $this->mapSplObjectStorage(null);
break;
}
}
ObjectAccess::setProperty($object, $propertyName, $propertyValue, true);
}
if (isset($objectData['metadata'])) {
$object->Flow_Persistence_Metadata = $objectData['metadata'];
}
ObjectAccess::setProperty($object, 'Persistence_Object_Identifier', $identifier, true);
}
/**
* Sets legacy "option" properties to the view for backwards compatibility.
*
* @param ViewInterface $view
* @param array $renderingOptions
* @return ViewInterface
*/
protected function applyLegacyViewOptions(ViewInterface $view, array $renderingOptions)
{
if (isset($renderingOptions['templatePathAndFilename'])) {
ObjectAccess::setProperty($view, 'templatePathAndFilename', $renderingOptions['templatePathAndFilename']);
}
if (isset($renderingOptions['layoutRootPath'])) {
ObjectAccess::setProperty($view, 'layoutRootPath', $renderingOptions['layoutRootPath']);
}
if (isset($renderingOptions['partialRootPath'])) {
ObjectAccess::setProperty($view, 'partialRootPath', $renderingOptions['partialRootPath']);
}
if (isset($renderingOptions['format'])) {
ObjectAccess::setProperty($view, 'format', $renderingOptions['format']);
}
return $view;
}
/**
* Convert an object from $source to an object.
*
* @param mixed $source
* @param string $targetType
* @param array $convertedChildProperties
* @param PropertyMappingConfigurationInterface $configuration
* @return object the target type
* @throws InvalidTargetException
* @throws InvalidDataTypeException
* @throws InvalidPropertyMappingConfigurationException
*/
public function convertFrom($source, $targetType, array $convertedChildProperties = [], PropertyMappingConfigurationInterface $configuration = null)
{
$object = $this->buildObject($convertedChildProperties, $targetType);
foreach ($convertedChildProperties as $propertyName => $propertyValue) {
$result = ObjectAccess::setProperty($object, $propertyName, $propertyValue);
if ($result === false) {
$exceptionMessage = sprintf('Property "%s" having a value of type "%s" could not be set in target object of type "%s". Make sure that the property is accessible properly, for example via an appropriate setter method.', $propertyName, is_object($propertyValue) ? get_class($propertyValue) : gettype($propertyValue), $targetType);
throw new InvalidTargetException($exceptionMessage, 1304538165);
}
}
return $object;
}
/**
* Sets the specified property.
* If the node has a content object attached, the property will be set there
* if it is settable.
*
* @param string $propertyName Name of the property
* @param mixed $value Value of the property
* @return void
*/
public function setProperty($propertyName, $value)
{
if (!is_object($this->contentObjectProxy)) {
switch ($this->getNodeType()->getPropertyType($propertyName)) {
case 'references':
$nodeIdentifiers = array();
if (is_array($value)) {
foreach ($value as $nodeIdentifier) {
if ($nodeIdentifier instanceof NodeInterface || $nodeIdentifier instanceof AbstractNodeData) {
$nodeIdentifiers[] = $nodeIdentifier->getIdentifier();
} elseif (preg_match(UuidValidator::PATTERN_MATCH_UUID, $nodeIdentifier) !== 0) {
$nodeIdentifiers[] = $nodeIdentifier;
}
}
}
$value = $nodeIdentifiers;
break;
case 'reference':
$nodeIdentifier = null;
if ($value instanceof NodeInterface || $value instanceof AbstractNodeData) {
$nodeIdentifier = $value->getIdentifier();
} elseif (preg_match(UuidValidator::PATTERN_MATCH_UUID, $value) !== 0) {
$nodeIdentifier = $value;
}
$value = $nodeIdentifier;
break;
}
$this->persistRelatedEntities($value);
if (isset($this->properties[$propertyName]) && $this->properties[$propertyName] === $value) {
return;
}
$this->properties[$propertyName] = $value;
$this->addOrUpdate();
} elseif (ObjectAccess::isPropertySettable($this->contentObjectProxy->getObject(), $propertyName)) {
$contentObject = $this->contentObjectProxy->getObject();
ObjectAccess::setProperty($contentObject, $propertyName, $value);
$this->updateContentObject($contentObject);
}
}
