public function getOptions()
{
$being = $this->property->being;
if ($being == "array") {
$selected = $this->property->getValue();
$policy = $this->configurationManager->getConfiguration(\TYPO3\FLOW3\Configuration\ConfigurationManager::CONFIGURATION_TYPE_POLICY);
$options = array();
foreach ($policy["roles"] as $key => $value) {
$options[] = new \Admin\Core\Option($key, $key, $this->isSelected($key));
}
return $options;
} else {
$groups = $this->helper->getGroups();
$actions = $this->getActions();
foreach ($groups as $group => $beings) {
foreach ($beings["beings"] as $being => $conf) {
foreach ($actions as $action => $label) {
$label = str_replace("@being", $conf["name"], $label);
$name = $group . " | " . $conf["name"] . " | " . $label;
$this->createOrUpdate($name, $action, $being);
}
}
}
$this->persistenceManager->persistAll();
return parent::getOptions();
}
}
/**
* @test
*/
public function feedActionWithoutParametersRendersFeed()
{
$this->createTestData();
$this->persistenceManager->persistAll();
$this->persistenceManager->clearState();
$result = $this->sendWebRequest('Standard', 'Planetflow3', 'feed');
// TODO Test actual output contains item
}
/**
* Loads the objects this LazySplObjectStorage is supposed to hold.
*
* @return void
*/
protected function initialize()
{
if (is_array($this->objectIdentifiers)) {
foreach ($this->objectIdentifiers as $identifier) {
try {
parent::attach($this->persistenceManager->getObjectByIdentifier($identifier));
} catch (\TYPO3\FLOW3\Persistence\Generic\Exception\InvalidObjectDataException $e) {
// when security query rewriting holds back an object here, we skip it...
}
}
$this->objectIdentifiers = NULL;
}
}
/**
* Sets up this test case
*
*/
public function setUp()
{
$this->mockObjectManager = $this->getMock('TYPO3\\FLOW3\\Object\\ObjectManagerInterface');
$this->mockObjectManager->expects($this->any())->method('create')->will($this->returnCallback(array($this, 'objectManagerCallBack')));
$this->route = $this->getAccessibleMock('TYPO3\\FLOW3\\Mvc\\Routing\\Route', array('dummy'));
$this->route->_set('objectManager', $this->mockObjectManager);
$this->mockRouter = $this->getMock('TYPO3\\FLOW3\\Mvc\\Routing\\RouterInterface');
$this->mockRouter->expects($this->any())->method('getControllerObjectName')->will($this->returnValue('SomeControllerObjectName'));
$this->route->injectRouter($this->mockRouter);
$this->mockPersistenceManager = $this->getMock('TYPO3\\FLOW3\\Persistence\\PersistenceManagerInterface');
$this->mockPersistenceManager->expects($this->any())->method('convertObjectsToIdentityArrays')->will($this->returnCallback(function ($array) {
return $array;
}));
$this->route->injectPersistenceManager($this->mockPersistenceManager);
}
/**
* Finds an object from the repository by searching for its identity properties.
*
* @param array $identityProperties Property names and values to search for
* @param string $type The object type to look for
* @return object Either the object matching the identity or NULL if no object was found
* @throws \TYPO3\FLOW3\Property\Exception\DuplicateObjectException if more than one object was found
*/
protected function findObjectByIdentityProperties(array $identityProperties, $type)
{
$query = $this->persistenceManager->createQueryForType($type);
$classSchema = $this->reflectionService->getClassSchema($type);
$equals = array();
foreach ($classSchema->getIdentityProperties() as $propertyName => $propertyType) {
if (isset($identityProperties[$propertyName])) {
if ($propertyType === 'string') {
$equals[] = $query->equals($propertyName, $identityProperties[$propertyName], FALSE);
} else {
$equals[] = $query->equals($propertyName, $identityProperties[$propertyName]);
}
}
}
if (count($equals) === 1) {
$constraint = current($equals);
} else {
$constraint = $query->logicalAnd(current($equals), next($equals));
while (($equal = next($equals)) !== FALSE) {
$constraint = $query->logicalAnd($constraint, $equal);
}
}
$objects = $query->matching($constraint)->execute();
$numberOfResults = $objects->count();
if ($numberOfResults === 1) {
return $objects->getFirst();
} elseif ($numberOfResults === 0) {
return NULL;
} else {
throw new \TYPO3\FLOW3\Property\Exception\DuplicateObjectException('More than one object was returned for the given identity, this is a constraint violation.', 1259612399);
}
}
/**
* Forwards the request to another action and / or controller.
*
* Request is directly transfered to the other action / controller
*
* @param string $actionName Name of the action to forward to
* @param string $controllerName Unqualified object name of the controller to forward to. If not specified, the current controller is used.
* @param string $packageKey Key of the package containing the controller to forward to. May also contain the sub package, concatenated with backslash (Vendor.Foo\Bar\Baz). If not specified, the current package is assumed.
* @param array $arguments Arguments to pass to the target action
* @return void
* @throws \TYPO3\FLOW3\Mvc\Exception\ForwardException
* @see redirect()
* @api
*/
protected function forward($actionName, $controllerName = NULL, $packageKey = NULL, array $arguments = array())
{
$nextRequest = clone $this->request;
$nextRequest->setControllerActionName($actionName);
if ($controllerName !== NULL) {
$nextRequest->setControllerName($controllerName);
}
if ($packageKey !== NULL && strpos($packageKey, '\\') !== FALSE) {
list($packageKey, $subpackageKey) = explode('\\', $packageKey, 2);
} else {
$subpackageKey = NULL;
}
if ($packageKey !== NULL) {
$nextRequest->setControllerPackageKey($packageKey);
}
if ($subpackageKey !== NULL) {
$nextRequest->setControllerSubpackageKey($subpackageKey);
}
$regularArguments = array();
foreach ($arguments as $argumentName => $argumentValue) {
if (substr($argumentName, 0, 2) === '__') {
$nextRequest->setArgument($argumentName, $argumentValue);
} else {
$regularArguments[$argumentName] = $argumentValue;
}
}
$nextRequest->setArguments($this->persistenceManager->convertObjectsToIdentityArrays($regularArguments));
$this->arguments->removeAll();
$forwardException = new \TYPO3\FLOW3\Mvc\Exception\ForwardException();
$forwardException->setNextRequest($nextRequest);
throw $forwardException;
}
/**
* Schedules a modified object for persistence.
*
* @param object $object The modified object
* @return void
* @throws \TYPO3\FLOW3\Persistence\Exception\IllegalObjectTypeException
* @api
*/
public function update($object)
{
if (!$object instanceof $this->objectType) {
throw new \TYPO3\FLOW3\Persistence\Exception\IllegalObjectTypeException('The modified object given to update() was not of the type (' . $this->objectType . ') this repository manages.', 1249479625);
}
$this->persistenceManager->update($object);
}
/**
* @param \TYPO3\Form\Core\Model\FinisherContext $finisherContext
* @return void
* @throws \TYPO3\Setup\Exception
*/
public function importSite(\TYPO3\Form\Core\Model\FinisherContext $finisherContext)
{
$formValues = $finisherContext->getFormRuntime()->getFormState()->getFormValues();
if (isset($formValues['prune']) && intval($formValues['prune']) === 1) {
$this->nodeRepository->removeAll();
$this->workspaceRepository->removeAll();
$this->domainRepository->removeAll();
$this->siteRepository->removeAll();
$this->persistenceManager->persistAll();
}
if (!empty($formValues['packageKey'])) {
if ($this->packageManager->isPackageAvailable($formValues['packageKey'])) {
throw new \TYPO3\Setup\Exception(sprintf('The package key "%s" already exists.', $formValues['packageKey']), 1346759486);
}
$packageKey = $formValues['packageKey'];
$siteName = $formValues['packageKey'];
$this->packageManager->createPackage($packageKey, NULL, Files::getUnixStylePath(Files::concatenatePaths(array(FLOW3_PATH_PACKAGES, 'Sites'))));
$this->generatorService->generateSitesXml($packageKey, $siteName);
$this->generatorService->generateSitesTypoScript($packageKey, $siteName);
$this->generatorService->generateSitesTemplate($packageKey, $siteName);
$this->packageManager->activatePackage($packageKey);
} else {
$packageKey = $formValues['site'];
}
if ($packageKey !== '') {
try {
$contentContext = new \TYPO3\TYPO3\Domain\Service\ContentContext('live');
$this->nodeRepository->setContext($contentContext);
$this->siteImportService->importFromPackage($packageKey);
} catch (\Exception $exception) {
$finisherContext->cancel();
$this->flashMessageContainer->addMessage(new \TYPO3\FLOW3\Error\Error(sprintf('Error: During the import of the "Sites.xml" from the package "%s" an exception occurred: %s', $packageKey, $exception->getMessage())));
}
}
}
/**
* Schedules a modified object for persistence.
*
* @param object $object The modified object
* @throws \TYPO3\FLOW3\Persistence\Exception\IllegalObjectTypeException
* @api
*/
public function update($object)
{
if (!is_object($object) || !$object instanceof $this->entityClassName) {
$type = is_object($object) ? get_class($object) : gettype($object);
throw new \TYPO3\FLOW3\Persistence\Exception\IllegalObjectTypeException('The value given to update() was ' . $type . ' , however the ' . get_class($this) . ' can only store ' . $this->entityClassName . ' instances.', 1249479625);
}
$this->persistenceManager->update($object);
}
/**
* Returns the number of objects in the result
*
* @return integer The number of matching objects
* @api
*/
public function count()
{
if (is_array($this->queryResult)) {
return count($this->queryResult);
} else {
return $this->persistenceManager->getObjectCountByQuery($this->query);
}
}
/**
* @param object $object
* @param string $parentIdentifier
* @return array
*/
protected function processObject($object, $parentIdentifier)
{
if (isset($this->classSchemata[get_class($object)]) && $this->classSchemata[get_class($object)]->isAggregateRoot() && !$this->persistenceManager->isNewObject($object)) {
return array('identifier' => $this->persistenceSession->getIdentifierByObject($object));
} else {
return array('identifier' => $this->persistObject($object, $parentIdentifier));
}
}
/**
* Helper function which creates or fetches a resource pointer object for a given hash.
*
* If a ResourcePointer with the given hash exists, this one is used. Else, a new one
* is created. This is a workaround for missing ValueObject support in Doctrine.
*
* @param string $hash
* @return \TYPO3\FLOW3\Resource\ResourcePointer
*/
public function getResourcePointerForHash($hash)
{
$resourcePointer = $this->persistenceManager->getObjectByIdentifier($hash, 'TYPO3\\FLOW3\\Resource\\ResourcePointer');
if (!$resourcePointer) {
$resourcePointer = new \TYPO3\FLOW3\Resource\ResourcePointer($hash);
$this->persistenceManager->add($resourcePointer);
}
return $resourcePointer;
}
/**
* Checks, if the given constraint holds for the passed result.
*
* @param array $constraintDefinition The constraint definition array
* @param object $result The result object returned by the persistence manager
* @return boolean TRUE if the query result is valid for the given constraint
* @throws \TYPO3\FLOW3\Security\Exception\InvalidQueryRewritingConstraintException
*/
protected function checkSingleConstraintDefinitionOnResultObject(array $constraintDefinition, $result)
{
$referenceToThisFound = FALSE;
if (!is_array($constraintDefinition['leftValue']) && strpos($constraintDefinition['leftValue'], 'this.') === 0) {
$referenceToThisFound = TRUE;
$propertyPath = substr($constraintDefinition['leftValue'], 5);
$leftOperand = $this->getObjectValueByPath($result, $propertyPath);
} else {
$leftOperand = $this->getValueForOperand($constraintDefinition['leftValue']);
}
if (!is_array($constraintDefinition['rightValue']) && strpos($constraintDefinition['rightValue'], 'this.') === 0) {
$referenceToThisFound = TRUE;
$propertyPath = substr($constraintDefinition['rightValue'], 5);
$rightOperand = $this->getObjectValueByPath($result, $propertyPath);
} else {
$rightOperand = $this->getValueForOperand($constraintDefinition['rightValue']);
}
if ($referenceToThisFound === FALSE) {
throw new \TYPO3\FLOW3\Security\Exception\InvalidQueryRewritingConstraintException('An entity security constraint must have at least one operand that references to "this.". Got: "' . $constraintDefinition['leftValue'] . '" and "' . $constraintDefinition['rightValue'] . '"', 1277218400);
}
if (is_object($leftOperand) && ($this->reflectionService->isClassAnnotatedWith($this->reflectionService->getClassNameByObject($leftOperand), 'TYPO3\\FLOW3\\Annotations\\Entity') || $this->reflectionService->isClassAnnotatedWith($this->reflectionService->getClassNameByObject($leftOperand), 'Doctrine\\ORM\\Mapping\\Entity'))) {
$leftOperand = $this->persistenceManager->getIdentifierByObject($leftOperand);
}
if (is_object($rightOperand) && ($this->reflectionService->isClassAnnotatedWith($this->reflectionService->getClassNameByObject($rightOperand), 'TYPO3\\FLOW3\\Annotations\\Entity') || $this->reflectionService->isClassAnnotatedWith($this->reflectionService->getClassNameByObject($rightOperand), 'Doctrine\\ORM\\Mapping\\Entity'))) {
$rightOperand = $this->persistenceManager->getIdentifierByObject($rightOperand);
}
switch ($constraintDefinition['operator']) {
case '!=':
return $leftOperand !== $rightOperand;
break;
case '==':
return $leftOperand === $rightOperand;
break;
case '<':
return $leftOperand < $rightOperand;
break;
case '>':
return $leftOperand > $rightOperand;
break;
case '<=':
return $leftOperand <= $rightOperand;
break;
case '>=':
return $leftOperand >= $rightOperand;
break;
case 'in':
return in_array($leftOperand, $rightOperand);
break;
case 'contains':
return in_array($rightOperand, $leftOperand);
break;
case 'matches':
return count(array_intersect($leftOperand, $rightOperand)) !== 0;
break;
}
throw new \TYPO3\FLOW3\Security\Exception\InvalidQueryRewritingConstraintException('The configured operator of the entity constraint is not valid. Got: ' . $constraintDefinition['operator'], 1277222521);
}
public function deleteObject($being, $id)
{
$object = $this->persistenceManager->getObjectByIdentifier($id, $being);
if ($object == null) {
return;
}
$repositoryObject = $this->objectManager->get($this->getRepositoryForModel($being));
$repositoryObject->remove($object);
$this->persistenceManager->persistAll();
}
/**
* @test
*/
public function createPathSegmentForObjectReturnsTheCleanedUpObjectIdentifierIfUriPatternIsEmpty()
{
$identityRoutePart = $this->getAccessibleMock('TYPO3\\FLOW3\\Mvc\\Routing\\IdentityRoutePart', array('dummy'));
$identityRoutePart->_set('persistenceManager', $this->mockPersistenceManager);
$identityRoutePart->setUriPattern('');
$object = new \stdClass();
$this->mockPersistenceManager->expects($this->once())->method('getIdentifierByObject')->with($object)->will($this->returnValue('Objäct--Identifüer/---'));
$actualResult = $identityRoutePart->_call('createPathSegmentForObject', $object);
$this->assertSame('Objaect-Identifueer', $actualResult);
}
/**
* Creates a new ObjectPathMapping and stores it in the repository
*
* @param string $pathSegment
* @param mixed $identifier
* @return void
*/
protected function storeObjectPathMapping($pathSegment, $identifier)
{
$objectPathMapping = new \TYPO3\FLOW3\Mvc\Routing\ObjectPathMapping();
$objectPathMapping->setObjectType($this->objectType);
$objectPathMapping->setUriPattern($this->getUriPattern());
$objectPathMapping->setPathSegment($pathSegment);
$objectPathMapping->setIdentifier($identifier);
$this->objectPathMappingRepository->add($objectPathMapping);
// TODO can be removed, when persistence manager has some memory cache
$this->persistenceManager->persistAll();
}
/**
* Iterate through the configured modules, find the matching module and set
* the route path accordingly
*
* @param array $value (contains action, controller and package of the module controller)
* @return boolean
*/
protected function resolveValue($value)
{
if (is_array($value)) {
$this->value = isset($value['@action']) && $value['@action'] !== 'index' ? $value['@action'] : '';
$exceedingArguments = array();
foreach ($value as $argumentKey => $argumentValue) {
if (substr($argumentKey, 0, 1) !== '@' && substr($argumentKey, 0, 2) !== '__') {
$exceedingArguments[$argumentKey] = $argumentValue;
}
}
if ($exceedingArguments !== array()) {
$exceedingArguments = \TYPO3\FLOW3\Utility\Arrays::removeEmptyElementsRecursively($exceedingArguments);
$exceedingArguments = $this->persistenceManager->convertObjectsToIdentityArrays($exceedingArguments);
$queryString = http_build_query(array($this->name => $exceedingArguments), NULL, '&');
if ($queryString !== '') {
$this->value .= '?' . $queryString;
}
}
}
return TRUE;
}
/**
* @test
*/
public function cacheResolveCallSkipsCacheIfRouteValuesContainObjectsThatCantBeConvertedToHashes()
{
$mockObject = new \stdClass();
$routeValues = array('b' => 'route values', 'someObject' => $mockObject);
$this->mockJoinPoint->expects($this->once())->method('getMethodArgument')->with('routeValues')->will($this->returnValue($routeValues));
$this->mockPersistenceManager->expects($this->once())->method('getIdentifierByObject')->with($mockObject)->will($this->returnValue(NULL));
$matchingUri = 'uncached/matching/uri';
$this->mockAdviceChain->expects($this->once())->method('proceed')->with($this->mockJoinPoint)->will($this->returnValue($matchingUri));
$this->mockResolveCache->expects($this->never())->method('has');
$this->mockResolveCache->expects($this->never())->method('set');
$this->routerCachingAspect->cacheResolveCall($this->mockJoinPoint);
}
/**
* Converts the given string or array to a ResourcePointer object.
*
* If the input format is an array, this method assumes the resource to be a
* fresh file upload and imports the temporary upload file through the
* resource manager.
*
* @param array $source The upload info (expected keys: error, name, tmp_name)
* @param string $targetType
* @param array $convertedChildProperties
* @param \TYPO3\FLOW3\Property\PropertyMappingConfigurationInterface $configuration
* @return \TYPO3\FLOW3\Resource\Resource|TYPO3\FLOW3\Error\Error if the input format is not supported or could not be converted for other reasons
*/
public function convertFrom($source, $targetType, array $convertedChildProperties = array(), \TYPO3\FLOW3\Property\PropertyMappingConfigurationInterface $configuration = NULL)
{
if (!isset($source['error']) || $source['error'] === \UPLOAD_ERR_NO_FILE) {
if (isset($source['submittedFile']) && isset($source['submittedFile']['filename']) && isset($source['submittedFile']['resourcePointer'])) {
$resourcePointer = $this->persistenceManager->getObjectByIdentifier($source['submittedFile']['resourcePointer'], 'TYPO3\\FLOW3\\Resource\\ResourcePointer');
if ($resourcePointer) {
$resource = new Resource();
$resource->setFilename($source['submittedFile']['filename']);
$resource->setResourcePointer($resourcePointer);
return $resource;
}
}
return NULL;
}
if ($source['error'] !== \UPLOAD_ERR_OK) {
switch ($source['error']) {
case \UPLOAD_ERR_INI_SIZE:
case \UPLOAD_ERR_FORM_SIZE:
case \UPLOAD_ERR_PARTIAL:
return new \TYPO3\FLOW3\Error\Error(\TYPO3\FLOW3\Utility\Files::getUploadErrorMessage($source['error']), 1264440823);
default:
$this->systemLogger->log(sprintf('A server error occurred while converting an uploaded resource: "%s"', \TYPO3\FLOW3\Utility\Files::getUploadErrorMessage($source['error'])), LOG_ERR);
return new \TYPO3\FLOW3\Error\Error('An error occurred while uploading. Please try again or contact the administrator if the problem remains', 1340193849);
}
}
if (isset($this->convertedResources[$source['tmp_name']])) {
return $this->convertedResources[$source['tmp_name']];
}
$resource = $this->resourceManager->importUploadedResource($source);
if ($resource === FALSE) {
return new \TYPO3\FLOW3\Error\Error('The resource manager could not create a Resource instance.', 1264517906);
} else {
$this->convertedResources[$source['tmp_name']] = $resource;
return $resource;
}
}
/**
* Checks, whether given value can be resolved and if so, sets $this->value to the resolved value.
* If $value is empty, this method checks whether a default value exists.
* This method can be overridden by custom RoutePartHandlers to implement custom resolving mechanisms.
*
* @param string $value value to resolve
* @return boolean TRUE if value could be resolved successfully, otherwise FALSE.
* @api
*/
protected function resolveValue($value)
{
if ($value === NULL) {
return FALSE;
}
if (is_object($value)) {
$value = $this->persistenceManager->getIdentifierByObject($value);
if ($value === NULL || !is_string($value)) {
return FALSE;
}
}
$this->value = (string) $value;
if ($this->lowerCase) {
$this->value = strtolower($this->value);
}
return TRUE;
}
/**
* Fetch the metadata for a given image
*
* @param \TYPO3\Media\Domain\Model\Image $image
* @return string
*/
public function imageWithMetadataAction(\TYPO3\Media\Domain\Model\Image $image)
{
$thumbnail = $image->getThumbnail(500, 500);
return json_encode(array('imageUuid' => $this->persistenceManager->getIdentifierByObject($image), 'previewImageResourceUri' => $this->resourcePublisher->getPersistentResourceWebUri($thumbnail->getResource()), 'originalSize' => array('w' => $image->getWidth(), 'h' => $image->getHeight()), 'previewSize' => array('w' => $thumbnail->getWidth(), 'h' => $thumbnail->getHeight())));
}
/**
* Reconstitutes a persistence object (entity or valueobject) identified by the given UUID.
*
* @param string $className The class name of the object to retrieve
* @param string $uuid The UUID of the object
* @return object The reconstituted persistence object, NULL if none was found
*/
protected function reconstitutePersistenceObject($className, $uuid)
{
return $this->persistenceManager->getObjectByIdentifier($uuid, $className);
}
/**
* Wrap the $content identified by $node with the needed markup for
* the backend.
* $parameters can be used to further pass parameters to the content element.
*
* @param \TYPO3\TYPO3CR\Domain\Model\NodeInterface $node
* @param string $typoscriptPath
* @param string $content
* @param boolean $isPage
* @return string
*/
public function wrapContentObject(\TYPO3\TYPO3CR\Domain\Model\NodeInterface $node, $typoscriptPath, $content, $isPage = FALSE)
{
$contentType = $node->getContentType();
$tagBuilder = new \TYPO3\Fluid\Core\ViewHelper\TagBuilder('div');
$tagBuilder->forceClosingTag(TRUE);
if (!$node->isRemoved()) {
$tagBuilder->setContent($content);
}
if (!$isPage) {
$cssClasses = array('t3-contentelement');
$cssClasses[] = str_replace(array(':', '.'), '-', strtolower($contentType->getName()));
if ($node->isHidden()) {
$cssClasses[] = 't3-contentelement-hidden';
}
if ($node->isRemoved()) {
$cssClasses[] = 't3-contentelement-removed';
}
$tagBuilder->addAttribute('class', implode(' ', $cssClasses));
$tagBuilder->addAttribute('id', 'c' . $node->getIdentifier());
}
try {
$this->accessDecisionManager->decideOnResource('TYPO3_TYPO3_Backend_BackendController');
} catch (\TYPO3\FLOW3\Security\Exception\AccessDeniedException $e) {
return $tagBuilder->render();
}
$tagBuilder->addAttribute('typeof', 'typo3:' . $contentType->getName());
$tagBuilder->addAttribute('about', $node->getContextPath());
$this->addScriptTag($tagBuilder, '__workspacename', $node->getWorkspace()->getName());
$this->addScriptTag($tagBuilder, '_removed', $node->isRemoved() ? 'true' : 'false', 'boolean');
$this->addScriptTag($tagBuilder, '_typoscriptPath', $typoscriptPath);
foreach ($contentType->getProperties() as $propertyName => $propertyConfiguration) {
$dataType = isset($propertyConfiguration['type']) ? $propertyConfiguration['type'] : 'string';
if ($propertyName[0] === '_') {
$propertyValue = \TYPO3\FLOW3\Reflection\ObjectAccess::getProperty($node, substr($propertyName, 1));
} else {
$propertyValue = $node->getProperty($propertyName);
}
// Serialize boolean values to String
if (isset($propertyConfiguration['type']) && $propertyConfiguration['type'] === 'boolean') {
$propertyValue = $propertyValue ? 'true' : 'false';
}
// Serialize date values to String
if ($propertyValue !== NULL && isset($propertyConfiguration['type']) && $propertyConfiguration['type'] === 'date') {
$propertyValue = $propertyValue->format('Y-m-d');
}
// Serialize objects to JSON strings
if (is_object($propertyValue) && $propertyValue !== NULL && isset($propertyConfiguration['type']) && $this->objectManager->isRegistered($propertyConfiguration['type'])) {
$gettableProperties = \TYPO3\FLOW3\Reflection\ObjectAccess::getGettableProperties($propertyValue);
$convertedProperties = array();
foreach ($gettableProperties as $key => $value) {
if (is_object($value)) {
$entityIdentifier = $this->persistenceManager->getIdentifierByObject($value);
if ($entityIdentifier !== NULL) {
$value = $entityIdentifier;
}
}
$convertedProperties[$key] = $value;
}
$propertyValue = json_encode($convertedProperties);
$dataType = 'jsonEncoded';
}
$this->addScriptTag($tagBuilder, $propertyName, $propertyValue, $dataType);
}
if (!$isPage) {
// add CSS classes
$this->addScriptTag($tagBuilder, '__contenttype', $contentType->getName());
} else {
$tagBuilder->addAttribute('id', 't3-page-metainformation');
$tagBuilder->addAttribute('data-__sitename', $this->nodeRepository->getContext()->getCurrentSite()->getName());
$tagBuilder->addAttribute('data-__siteroot', sprintf('/sites/%s@%s', $this->nodeRepository->getContext()->getCurrentSite()->getNodeName(), $this->nodeRepository->getContext()->getWorkspace()->getName()));
}
return $tagBuilder->render();
}
/**
* @test
*/
public function convertFromReturnsNullIfSpecifiedResourcePointerCantBeFound()
{
$source = array('error' => \UPLOAD_ERR_NO_FILE, 'submittedFile' => array('filename' => 'SomeFilename', 'resourcePointer' => 'someNonExistingResourcePointer'));
$this->mockPersistenceManager->expects($this->once())->method('getObjectByIdentifier')->with('someNonExistingResourcePointer', 'TYPO3\\FLOW3\\Resource\\ResourcePointer')->will($this->returnValue(NULL));
$this->assertNull($this->resourceTypeConverter->convertFrom($source, 'TYPO3\\FLOW3\\Resource\\Resource'));
}
/**
* Traverses the given object structure in order to transform it into an
* array structure.
*
* @param object $object Object to traverse
* @param mixed $configuration Configuration for transforming the given object or NULL
* @return array Object structure as an aray
*/
protected function transformObject($object, $configuration)
{
if ($object instanceof \DateTime) {
return $object->format('Y-m-d\\TH:i:s');
} else {
$propertyNames = \TYPO3\FLOW3\Reflection\ObjectAccess::getGettablePropertyNames($object);
$propertiesToRender = array();
foreach ($propertyNames as $propertyName) {
if (isset($configuration['_only']) && is_array($configuration['_only']) && !in_array($propertyName, $configuration['_only'])) {
continue;
}
if (isset($configuration['_exclude']) && is_array($configuration['_exclude']) && in_array($propertyName, $configuration['_exclude'])) {
continue;
}
$propertyValue = \TYPO3\FLOW3\Reflection\ObjectAccess::getProperty($object, $propertyName);
if (!is_array($propertyValue) && !is_object($propertyValue)) {
$propertiesToRender[$propertyName] = $propertyValue;
} elseif (isset($configuration['_descend']) && array_key_exists($propertyName, $configuration['_descend'])) {
$propertiesToRender[$propertyName] = $this->transformValue($propertyValue, $configuration['_descend'][$propertyName]);
}
}
if (isset($configuration['_exposeObjectIdentifier']) && $configuration['_exposeObjectIdentifier'] === TRUE) {
if (isset($configuration['_exposedObjectIdentifierKey']) && strlen($configuration['_exposedObjectIdentifierKey']) > 0) {
$identityKey = $configuration['_exposedObjectIdentifierKey'];
} else {
$identityKey = '__identity';
}
$propertiesToRender[$identityKey] = $this->persistenceManager->getIdentifierByObject($object);
}
return $propertiesToRender;
}
}
/**
* After returning advice, making sure we have an UUID for each and every entity.
*
* @param \TYPO3\FLOW3\Aop\JoinPointInterface $joinPoint The current join point
* @return void
* @FLOW3\Before("TYPO3\FLOW3\Persistence\Aspect\PersistenceMagicAspect->isEntity && method(.*->(__construct|__clone)())")
*/
public function generateUuid(\TYPO3\FLOW3\Aop\JoinPointInterface $joinPoint)
{
$proxy = $joinPoint->getProxy();
\TYPO3\FLOW3\Reflection\ObjectAccess::setProperty($proxy, 'FLOW3_Persistence_Identifier', \TYPO3\FLOW3\Utility\Algorithms::generateUUID(), TRUE);
$this->persistenceManager->registerNewObject($proxy);
}
/**
* @test
*/
public function resolveValueReturnsFalseIfTheValueToBeResolvedIsAnObjectWithAnIdentifierThatIsNoString()
{
$object = new \stdClass();
$this->mockPersistenceManager->expects($this->once())->method('getIdentifierByObject')->with($object)->will($this->returnValue(array('foo', 'bar')));
$this->assertFalse($this->dynamicRoutPart->_call('resolveValue', $object));
}
/**
* Checks whether $routeValues can be resolved to a corresponding uri.
* If all Route Parts can resolve one or more of the $routeValues, TRUE is
* returned and $this->matchingURI contains the generated URI (excluding
* protocol and host).
*
* @param array $routeValues An array containing key/value pairs to be resolved to uri segments
* @return boolean TRUE if this Route corresponds to the given $routeValues, otherwise FALSE
* @throws \TYPO3\FLOW3\Mvc\Exception\InvalidRoutePartValueException
* @see getMatchingUri()
*/
public function resolves(array $routeValues)
{
$this->matchingUri = NULL;
if ($this->uriPattern === NULL) {
return FALSE;
}
if (!$this->isParsed) {
$this->parse();
}
$matchingUri = '';
$mergedRouteValues = \TYPO3\FLOW3\Utility\Arrays::arrayMergeRecursiveOverrule($this->defaults, $routeValues);
$requireOptionalRouteParts = FALSE;
$matchingOptionalUriPortion = '';
foreach ($this->routeParts as $routePart) {
if (!$routePart->resolve($routeValues)) {
if (!$routePart->hasDefaultValue()) {
return FALSE;
}
}
$routePartValue = NULL;
if ($routePart->hasValue()) {
$routePartValue = $routePart->getValue();
if (!is_string($routePartValue)) {
throw new \TYPO3\FLOW3\Mvc\Exception\InvalidRoutePartValueException('RoutePart::getValue() must return a string after calling RoutePart::resolve(), got ' . (is_object($routePartValue) ? get_class($routePartValue) : gettype($routePartValue)) . ' for RoutePart "' . get_class($routePart) . '" in Route "' . $this->getName() . '".');
}
}
$routePartDefaultValue = $routePart->getDefaultValue();
if ($routePartDefaultValue !== NULL && !is_string($routePartDefaultValue)) {
throw new \TYPO3\FLOW3\Mvc\Exception\InvalidRoutePartValueException('RoutePart::getDefaultValue() must return a string, got ' . (is_object($routePartDefaultValue) ? get_class($routePartDefaultValue) : gettype($routePartDefaultValue)) . ' for RoutePart "' . get_class($routePart) . '" in Route "' . $this->getName() . '".');
}
if (!$routePart->isOptional()) {
$matchingUri .= $routePart->hasValue() ? $routePartValue : $routePartDefaultValue;
$requireOptionalRouteParts = FALSE;
continue;
}
if ($routePart->hasValue() && $routePartValue !== $routePartDefaultValue) {
$matchingOptionalUriPortion .= $routePartValue;
$requireOptionalRouteParts = TRUE;
} else {
$matchingOptionalUriPortion .= $routePartDefaultValue;
}
if ($requireOptionalRouteParts) {
$matchingUri .= $matchingOptionalUriPortion;
$matchingOptionalUriPortion = '';
}
}
if ($this->compareAndRemoveMatchingDefaultValues($this->defaults, $routeValues) !== TRUE) {
return FALSE;
}
if (isset($routeValues['@format']) && $routeValues['@format'] === '') {
unset($routeValues['@format']);
}
$this->throwExceptionIfTargetControllerDoesNotExist($mergedRouteValues);
// add query string
if (count($routeValues) > 0) {
$routeValues = \TYPO3\FLOW3\Utility\Arrays::removeEmptyElementsRecursively($routeValues);
$routeValues = $this->persistenceManager->convertObjectsToIdentityArrays($routeValues);
if (!$this->appendExceedingArguments) {
$internalArguments = $this->extractInternalArguments($routeValues);
if ($routeValues !== array()) {
return FALSE;
}
$routeValues = $internalArguments;
}
$queryString = http_build_query($routeValues, NULL, '&');
if ($queryString !== '') {
$matchingUri .= strpos($matchingUri, '?') !== FALSE ? '&' . $queryString : '?' . $queryString;
}
}
$this->matchingUri = $matchingUri;
return TRUE;
}
